Develop

acceptance/mail_test.go

@@ -23,6 +23,8 @@ type MailSuite struct{ BaseSuite }
 
 func (suite *MailSuite) SetupSuite() {
 	cfg := static.NewConfig()
+	port := try.GetFreePort()
+	cfg.Api.Port = fmt.Sprintf("%v", port)
 	wd, err := os.Getwd()
 	require.NoError(suite.T(), err)
 	cfg.ConfigFile = path.Join(wd, "mokapi.yaml")
@@ -47,16 +49,16 @@ func (suite *MailSuite) TestSendMail() {
 	require.NoError(suite.T(), err)
 
 	// test mail API
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/Mokapi%20MailServer/mailboxes", nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/Mokapi%%20MailServer/mailboxes", suite.cfg.Api.Port), nil,
 		try.HasStatusCode(200),
 		try.HasBody(`[{"name":"[email protected]","numMessages":1}]`),
 	)
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/Mokapi%20MailServer/mailboxes/[email protected]", nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/Mokapi%%20MailServer/mailboxes/[email protected]", suite.cfg.Api.Port), nil,
 		try.HasStatusCode(200),
 		try.HasBody(`{"name":"[email protected]","numMessages":1,"folders":["INBOX"]}`),
 	)
 	var messageId string
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/Mokapi%20MailServer/mailboxes/[email protected]/messages", nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/Mokapi%%20MailServer/mailboxes/[email protected]/messages", suite.cfg.Api.Port), nil,
 		try.HasStatusCode(200),
 		try.AssertBody(func(t *testing.T, body string) {
 			var v any
@@ -73,7 +75,7 @@ func (suite *MailSuite) TestSendMail() {
 			messageId = m["messageId"].(string)
 		}),
 	)
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/messages/"+messageId, nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/messages/%v", suite.cfg.Api.Port, messageId), nil,
 		try.HasStatusCode(200),
 		try.AssertBody(func(t *testing.T, body string) {
 			var v any
@@ -209,16 +211,16 @@ It can be any text data.
 	require.NoError(suite.T(), err)
 
 	// test mail API
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/Mokapi%20MailServer%20Old/mailboxes", nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/Mokapi%%20MailServer%%20Old/mailboxes", suite.cfg.Api.Port), nil,
 		try.HasStatusCode(200),
 		try.HasBody(`[{"name":"[email protected]","numMessages":1}]`),
 	)
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/Mokapi%20MailServer%20Old/mailboxes/[email protected]", nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/Mokapi%%20MailServer%%20Old/mailboxes/[email protected]", suite.cfg.Api.Port), nil,
 		try.HasStatusCode(200),
 		try.HasBody(`{"name":"[email protected]","numMessages":1,"folders":["INBOX"]}`),
 	)
 	var messageId string
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/Mokapi%20MailServer%20Old/mailboxes/[email protected]/messages", nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/Mokapi%%20MailServer%%20Old/mailboxes/[email protected]/messages", suite.cfg.Api.Port), nil,
 		try.HasStatusCode(200),
 		try.AssertBody(func(t *testing.T, body string) {
 			var v any
@@ -235,7 +237,7 @@ It can be any text data.
 			messageId = m["messageId"].(string)
 		}),
 	)
-	try.GetRequest(suite.T(), "http://localhost:8080/api/services/mail/messages/"+messageId, nil,
+	try.GetRequest(suite.T(), fmt.Sprintf("http://localhost:%v/api/services/mail/messages/%v", suite.cfg.Api.Port, messageId), nil,
 		try.HasStatusCode(200),
 		try.AssertBody(func(t *testing.T, body string) {
 			var v any

api/handler_kafka.go

@@ -214,7 +214,7 @@ func (h *handler) handleKafka(w http.ResponseWriter, r *http.Request) {
 			}
 			c := store.NewClient(k.Store, h.app.Monitor.Kafka)
 			ct := media.ParseContentType(r.Header.Get("Content-Type"))
-			result, err := c.Write(topicName, records, &ct)
+			result, err := c.Write(topicName, records, ct)
 			if err != nil {
 				if errors.Is(err, store.TopicNotFound) || errors.Is(err, store.PartitionNotFound) {
 					writeError(w, err, http.StatusNotFound)
@@ -288,7 +288,7 @@ func (h *handler) handleKafka(w http.ResponseWriter, r *http.Request) {
 			}
 			c := store.NewClient(k.Store, h.app.Monitor.Kafka)
 			ct := media.ParseContentType(r.Header.Get("Content-Type"))
-			result, err := c.Write(topicName, records, &ct)
+			result, err := c.Write(topicName, records, ct)
 			if err != nil {
 				if errors.Is(err, store.TopicNotFound) || errors.Is(err, store.PartitionNotFound) {
 					writeError(w, err, http.StatusNotFound)

api/handler_kafka_test.go

@@ -661,7 +661,7 @@ func TestHandler_KafkaAPI(t *testing.T) {
 						Key:   "foo",
 						Value: map[string]interface{}{"value": "bar"},
 					},
-				}, &ct)
+				}, ct)
 
 				return app
 			},
@@ -700,7 +700,7 @@ func TestHandler_KafkaAPI(t *testing.T) {
 						Key:   "foo",
 						Value: map[string]interface{}{"value": "bar"},
 					},
-				}, &ct)
+				}, ct)
 
 				return app
 			},

api/handler_schema.go

@@ -24,6 +24,7 @@ type schemaInfo struct {
 
 type requestExample struct {
 	Name         string
+	Path         []string
 	Format       string
 	Schema       interface{}
 	ContentTypes []string
@@ -61,10 +62,20 @@ func (h *handler) getExampleData(w http.ResponseWriter, r *http.Request) {
 		re.ContentTypes = []string{"application/json"}
 	}
 
+	req := &generator.Request{}
+	if re.Name != "" {
+		req.Path = []string{re.Name}
+	} else if re.Path != nil {
+		req.Path = re.Path
+	}
+
 	var s *jsonSchema.Schema
 	switch t := re.Schema.(type) {
 	case *openApiSchema.Schema:
 		s = openApiSchema.ConvertToJsonSchema(t)
+		if t.Xml != nil && t.Xml.Name != "" {
+			req.Path = append(req.Path, t.Xml.Name)
+		}
 	case *avro.Schema:
 		s = avro.ConvertToJsonSchema(t)
 	default:
@@ -75,11 +86,9 @@ func (h *handler) getExampleData(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 	}
+	req.Schema = s
 
-	rnd, err := generator.New(&generator.Request{
-		Path:   []string{re.Name},
-		Schema: s,
-	})
+	rnd, err := generator.New(req)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
@@ -254,6 +263,11 @@ func (r *requestExample) UnmarshalJSON(data []byte) error {
 				return err
 			}
 			r.Name = t.(string)
+		case "path":
+			err = d.Decode(&r.Path)
+			if err != nil {
+				return err
+			}
 		case "format":
 			t, err = d.Token()
 			if err != nil {
@@ -270,6 +284,12 @@ func (r *requestExample) UnmarshalJSON(data []byte) error {
 			if err != nil {
 				return err
 			}
+		default:
+			var discard json.RawMessage
+			err = d.Decode(&discard)
+			if err != nil {
+				return err
+			}
 		}
 	}
 

api/handler_schema_test.go

@@ -430,6 +430,29 @@ func TestHandler_Schema_Example(t *testing.T) {
 				)
 			},
 		},
+		{
+			name: "pet with path",
+			app:  &runtime.App{},
+			fn: func(t *testing.T, h http.Handler, app *runtime.App) {
+				try.Handler(t,
+					http.MethodGet,
+					"http://foo.api/api/schema/example",
+					nil,
+					`{"path": ["pet", "category", "name"], "schema": {"type": ["string"]}, "contentTypes": ["application/json"]}`,
+					h,
+					try.HasStatusCode(200),
+					try.HasHeader("Content-Type", "application/json"),
+					try.AssertBody(func(t *testing.T, body string) {
+						var data []map[string]any
+						err := json.Unmarshal([]byte(body), &data)
+						require.NoError(t, err)
+						b, err := base64.StdEncoding.DecodeString(data[0]["value"].(string))
+						require.NoError(t, err)
+						require.Equal(t, `"turtle"`, string(b))
+					}),
+				)
+			},
+		},
 	}
 
 	for _, tc := range testcases {

engine/common/host.go

@@ -27,13 +27,15 @@ type JobOptions struct {
 
 type Host interface {
 	Logger
+	SetEventLogger(func(level, message string))
+
 	Every(every string, do func(), opt JobOptions) (int, error)
 	Cron(expr string, do func(), opt JobOptions) (int, error)
 	Cancel(jobId int) error
 
 	OpenFile(file string, hint string) (*dynamic.Config, error)
 
-	On(event string, do func(args ...interface{}) (bool, error), tags map[string]string)
+	On(event string, do EventHandler, tags map[string]string)
 
 	KafkaClient() KafkaClient
 	HttpClient(HttpClientOptions) HttpClient
@@ -182,3 +184,10 @@ type Store interface {
 	Keys() []string
 	Namespace(name string) Store
 }
+
+type EventHandler func(ctx *EventContext) (bool, error)
+
+type EventContext struct {
+	EventLogger func(level, message string)
+	Args        []any
+}

engine/common/http.go

@@ -1,40 +1,50 @@
 package common
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 )
 
 type EventResponse struct {
-	Headers    map[string]string `json:"headers"`
-	StatusCode int               `json:"statusCode"`
-	Body       string            `json:"body"`
-	Data       interface{}       `json:"data"`
+	Headers    map[string]any `json:"headers"`
+	StatusCode int            `json:"statusCode"`
+	Body       string         `json:"body"`
+	Data       any            `json:"data"`
 }
 
 type EventRequest struct {
-	Method      string                 `json:"method"`
-	Url         Url                    `json:"url"`
-	Body        interface{}            `json:"body"`
-	Path        map[string]interface{} `json:"path"`
-	Query       map[string]interface{} `json:"query"`
-	Header      map[string]interface{} `json:"header"`
-	Cookie      map[string]interface{} `json:"cookie"`
-	QueryString any                    `json:"querystring"`
+	Method      string         `json:"method"`
+	Url         Url            `json:"url"`
+	Body        interface{}    `json:"body"`
+	Path        map[string]any `json:"path"`
+	Query       map[string]any `json:"query"`
+	Header      map[string]any `json:"header"`
+	Cookie      map[string]any `json:"cookie"`
+	QueryString any            `json:"querystring"`
 
+	Api         string `json:"api"`
 	Key         string `json:"key"`
 	OperationId string `json:"operationId"`
 }
 
 type Url struct {
 	Scheme string `json:"scheme"`
 	Host   string `json:"host"`
+	Port   int    `json:"port"`
 	Path   string `json:"path"`
 	Query  string `json:"query"`
 }
 
 func (r *EventRequest) String() string {
-	return r.Method + " " + r.Url.String()
+	s := r.Method + " " + r.Url.String()
+	if r.Api != "" {
+		s += fmt.Sprintf(" [API: %s]", r.Api)
+	}
+	if r.OperationId != "" {
+		s += fmt.Sprintf(" [OperationId: %s]", r.OperationId)
+	}
+	return s
 }
 
 func (u Url) String() string {
@@ -45,15 +55,17 @@ func (u Url) String() string {
 	}
 	sb.WriteString(u.Host)
 	sb.WriteString(u.Path)
-	sb.WriteString("?" + u.Query)
+	if len(u.Query) > 0 {
+		sb.WriteString("?" + u.Query)
+	}
 	return sb.String()
 }
 
 func (r *EventResponse) HasBody() bool {
 	return len(r.Body) > 0 || r.Data != nil
 }
 
-func EventHandler(req *EventRequest, res *EventResponse, resources interface{}) (bool, error) {
+func HttpEventHandler(req *EventRequest, res *EventResponse, resources interface{}) (bool, error) {
 	resource := getResource(req.Url, resources)
 	if resource == nil {
 		return false, nil

engine/common/http_test.go

@@ -1,8 +1,9 @@
 package common
 
 import (
-	"github.com/stretchr/testify/require"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestEventRequest_String(t *testing.T) {
@@ -58,7 +59,7 @@ func TestHttpResource(t *testing.T) {
 				Url: tc.url,
 			}
 			res := &EventResponse{}
-			b, err := EventHandler(req, res, tc.resource)
+			b, err := HttpEventHandler(req, res, tc.resource)
 			tc.test(t, b, res.Data, err)
 		})
 	}