Develop

.github/actions/run-frontend-tests/action.yml

@@ -23,7 +23,7 @@ runs:
       run: docker load --input /tmp/mokapi.tar
       shell: bash
     - name: Run mokapi image
-      run: docker run --name mokapi --rm -d -p 8090:8090 -p 8091:8091 --mount type=bind,source=$(pwd)/examples/mokapi,target=/data --env MOKAPI_Log_Level=Debug --env MOKAPI_Api_Port=8091 --env MOKAPI_Api_Path=/mokapi --env MOKAPI_Providers_File_Directory=/data ${{ inputs.image-name }}
+      run: docker run --name mokapi --rm -d -p 8090:8090 -p 8091:8091 --mount type=bind,source=$(pwd)/webui/e2e/mocks,target=/data --env MOKAPI_Log_Level=Debug --env MOKAPI_Api_Port=8091 --env MOKAPI_Api_Path=/mokapi --env MOKAPI_Providers_File_Directory=/data ${{ inputs.image-name }}
       shell: bash
     - uses: actions/setup-node@v4
       with:
@@ -49,7 +49,7 @@ runs:
       uses: actions/upload-artifact@v4
       with:
         name: ${{ inputs.artifact-test-report }}
-        path: webui/playwright-report
+        path: ./webui/playwright-report
     - name: Save Mokapi logs
       if: always()
       run: docker logs mokapi > /var/tmp/mokapi.log 2>&1

api/handler_http.go

@@ -112,6 +112,10 @@ func getHttpServices(list []*runtime.HttpInfo, m *monitor.Monitor) []interface{}
 			Type:        ServiceHttp,
 		}
 
+		if hs.Info.Summary != "" {
+			s.Description = hs.Info.Summary
+		}
+
 		if m != nil {
 			s.Metrics = m.FindAll(metrics.ByNamespace("http"), metrics.ByLabel("service", hs.Info.Name))
 		}

api/handler_http_test.go

@@ -41,6 +41,19 @@ func TestHandler_Http(t *testing.T) {
 			requestUrl:   "http://foo.api/api/services",
 			responseBody: `[{"name":"foo","description":"bar","version":"1.0","type":"http"}`,
 		},
+		{
+			name: "summary takes precedence over description",
+			app: func() *runtime.App {
+				return runtimetest.NewHttpApp(
+					openapitest.NewConfig("3.0.0",
+						openapitest.WithInfo("foo", "1.0", "bar"),
+						openapitest.WithSummary("summary"),
+					),
+				)
+			},
+			requestUrl:   "http://foo.api/api/services",
+			responseBody: `[{"name":"foo","description":"summary","version":"1.0","type":"http"}`,
+		},
 		{
 			name: "get http services with contact",
 			app: func() *runtime.App {
@@ -210,7 +223,7 @@ func TestHandler_Http(t *testing.T) {
 				c := openapitest.NewConfig("3.0.0",
 					openapitest.WithInfo("foo", "", ""),
 					openapitest.WithPathRef("/foo/{bar}", &openapi.PathRef{
-						Reference: dynamic.Reference{
+						Reference: dynamic.Reference[*openapi.PathRef]{
 							Ref:         "#/components/pathItems/foo",
 							Summary:     "Summary",
 							Description: "Description",
@@ -220,7 +233,7 @@ func TestHandler_Http(t *testing.T) {
 							openapitest.WithOperation("get",
 								openapitest.UseResponseRef(http.StatusOK,
 									&openapi.ResponseRef{
-										Reference: dynamic.Reference{
+										Reference: dynamic.Reference[*openapi.ResponseRef]{
 											Ref:         "#/components/pathItems/foo",
 											Description: "Description",
 										},

api/handler_kafka_test.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"mokapi/api"
 	"mokapi/config/dynamic"
-	"mokapi/config/dynamic/asyncApi"
 	"mokapi/config/dynamic/dynamictest"
 	"mokapi/config/static"
 	"mokapi/engine/enginetest"
@@ -1098,7 +1097,7 @@ func TestHandler_Kafka_Metrics(t *testing.T) {
 }
 
 func Test_IsAsyncApiConfig(t *testing.T) {
-	v2 := &asyncApi.Config{Info: asyncApi.Info{Name: "foo"}}
+	v2 := &asyncapi3.Config{Info: asyncapi3.Info{Name: "foo"}}
 	_, ok := runtime.IsAsyncApiConfig(&dynamic.Config{Data: v2})
 	require.True(t, ok)
 

api/handler_schema_test.go

@@ -3,6 +3,7 @@ package api
 import (
 	"encoding/base64"
 	"encoding/json"
+	"mokapi/config/dynamic"
 	"mokapi/config/static"
 	"mokapi/providers/asyncapi3/asyncapi3test"
 	"mokapi/providers/openapi/openapitest"
@@ -540,7 +541,7 @@ func TestSchemaInfo_MarshalJSON(t *testing.T) {
 		},
 		{
 			name: "json schema only ref",
-			s:    &schemaInfo{Schema: &jsonSchema.Schema{Ref: "foo/bar"}},
+			s:    &schemaInfo{Schema: &jsonSchema.Schema{Reference: dynamic.Reference[*jsonSchema.Schema]{Ref: "foo/bar"}}},
 			test: func(t *testing.T, s string, err error) {
 				require.NoError(t, err)
 				require.Equal(t, `{"schema":{"$ref":"foo/bar"}}`, s)
@@ -549,8 +550,8 @@ func TestSchemaInfo_MarshalJSON(t *testing.T) {
 		{
 			name: "json schema ref and value",
 			s: &schemaInfo{Schema: &jsonSchema.Schema{
-				Ref:  "foo/bar",
-				Type: jsonSchema.Types{"string"},
+				Reference: dynamic.Reference[*jsonSchema.Schema]{Ref: "foo/bar"},
+				Type:      jsonSchema.Types{"string"},
 			}},
 			test: func(t *testing.T, s string, err error) {
 				require.NoError(t, err)

api/handler_search_test.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"encoding/json"
 	"mokapi/config/dynamic"
-	"mokapi/config/dynamic/asyncApi/asyncapitest"
 	"mokapi/config/dynamic/dynamictest"
 	"mokapi/config/static"
 	"mokapi/engine/enginetest"
+	"mokapi/providers/asyncapi3/asyncapi3test"
 	"mokapi/providers/openapi/openapitest"
 	"mokapi/runtime"
 	"mokapi/runtime/search"
@@ -143,7 +143,7 @@ func TestHandler_SearchQuery(t *testing.T) {
 
 				h := openapitest.NewConfig("3.0", openapitest.WithInfo("foo", "", ""))
 				app.AddHttp(toConfig(h))
-				k := asyncapitest.NewConfig(asyncapitest.WithInfo("foo", "", ""))
+				k := asyncapi3test.NewConfig(asyncapi3test.WithInfo("foo", "", ""))
 				_, err := app.Kafka.Add(toConfig(k), enginetest.NewEngine())
 				require.NoError(t, err)
 
@@ -173,7 +173,7 @@ func TestHandler_SearchQuery(t *testing.T) {
 
 				h := openapitest.NewConfig("3.0", openapitest.WithInfo("foo", "", ""))
 				app.AddHttp(toConfig(h))
-				k := asyncapitest.NewConfig(asyncapitest.WithInfo("foo", "", ""))
+				k := asyncapi3test.NewConfig(asyncapi3test.WithInfo("foo", "", ""))
 				_, err := app.Kafka.Add(toConfig(k), enginetest.NewEngine())
 				require.NoError(t, err)
 

config/dynamic/asyncApi/config.go

@@ -70,7 +70,7 @@ type ServerTag struct {
 }
 
 type ServerRef struct {
-	Ref   string
+	dynamic.Reference[*ServerRef]
 	Value *Server
 }
 
@@ -79,7 +79,7 @@ type ServerBindings struct {
 }
 
 type ChannelRef struct {
-	Ref   string
+	dynamic.Reference[*ChannelRef]
 	Value *Channel
 }
 
@@ -109,7 +109,7 @@ type OperationBindings struct {
 }
 
 type MessageRef struct {
-	Ref   string
+	dynamic.Reference[*MessageRef]
 	Value *Message
 }
 
@@ -141,7 +141,7 @@ type Components struct {
 }
 
 type ParameterRef struct {
-	dynamic.Reference
+	dynamic.Reference[*ParameterRef]
 	Value *Parameter
 }
 
@@ -152,7 +152,7 @@ type Parameter struct {
 }
 
 type MessageTraitRef struct {
-	dynamic.Reference
+	dynamic.Reference[*MessageTraitRef]
 	Value *MessageTrait
 }
 

config/dynamic/asyncApi/convert.go

@@ -66,24 +66,21 @@ func convertChannels(cfg *asyncapi3.Config, channels map[string]*ChannelRef) err
 		if orig == nil {
 			continue
 		}
-		if len(orig.Ref) > 0 {
-			cfg.Channels[name] = &asyncapi3.ChannelRef{Reference: dynamic.Reference{Ref: orig.Ref}}
+		ch, err := convertChannel(name, orig, cfg)
+		if err != nil {
+			return err
 		}
-		if orig.Value != nil {
-			ch, err := convertChannel(name, orig, cfg)
-			if err != nil {
-				return err
-			}
+		if ch.Value != nil {
 			ch.Value.Config = cfg
-			cfg.Channels[name] = ch
 		}
+		cfg.Channels[name] = ch
 	}
 
 	return nil
 }
 
 func convertChannel(name string, c *ChannelRef, config *asyncapi3.Config) (*asyncapi3.ChannelRef, error) {
-	result := &asyncapi3.ChannelRef{Reference: dynamic.Reference{Ref: c.Ref}}
+	result := &asyncapi3.ChannelRef{Reference: dynamic.Reference[*asyncapi3.ChannelRef]{Ref: c.Ref}}
 
 	if c.Value != nil {
 		target := &asyncapi3.Channel{
@@ -98,7 +95,7 @@ func convertChannel(name string, c *ChannelRef, config *asyncapi3.Config) (*asyn
 		for _, server := range c.Value.Servers {
 			target.Servers = append(
 				target.Servers,
-				&asyncapi3.ServerRef{Reference: dynamic.Reference{
+				&asyncapi3.ServerRef{Reference: dynamic.Reference[*asyncapi3.ServerRef]{
 					Ref: fmt.Sprintf("#/servers/%s", server),
 				}})
 		}
@@ -192,53 +189,50 @@ func convertMessage(msg *MessageRef) *asyncapi3.MessageRef {
 		return nil
 	}
 
-	target := &asyncapi3.MessageRef{Reference: dynamic.Reference{Ref: msg.Ref}}
+	target := &asyncapi3.MessageRef{Reference: dynamic.Reference[*asyncapi3.MessageRef]{Ref: msg.Ref}}
 	if msg.Value != nil {
 		target.Value = &asyncapi3.Message{
 			Title:        msg.Value.Title,
 			Name:         msg.Value.Name,
 			Summary:      msg.Value.Summary,
 			Description:  msg.Value.Description,
 			ContentType:  msg.Value.ContentType,
-			Payload:      nil,
+			Payload:      msg.Value.Payload,
 			Bindings:     convertMessageBinding(msg.Value.Bindings),
+			Headers:      msg.Value.Headers,
 			ExternalDocs: nil,
 		}
 
-		if msg.Value.Payload != nil && msg.Value.Payload.Value != nil {
-			target.Value.Payload = msg.Value.Payload
-		}
-		if msg.Value.Headers != nil && msg.Value.Headers.Value != nil {
-			target.Value.Headers = msg.Value.Headers
-		}
 		for _, orig := range msg.Value.Traits {
-			trait := &asyncapi3.MessageTraitRef{}
-			if len(orig.Ref) > 0 {
-				trait.Reference = dynamic.Reference{Ref: trait.Ref}
-			}
-			if orig.Value != nil {
-				trait.Value = convertMessageTrait(orig.Value).Value
+			trait := convertMessageTrait(orig)
+			if trait != nil {
+				target.Value.Traits = append(target.Value.Traits, trait)
 			}
-			target.Value.Traits = append(target.Value.Traits, trait)
 		}
 	}
 	return target
 }
 
-func convertMessageTrait(trait *MessageTrait) *asyncapi3.MessageTraitRef {
-	target := &asyncapi3.MessageTrait{
-		Name:        trait.Name,
-		Title:       trait.Title,
-		Summary:     trait.Summary,
-		Description: trait.Description,
-		ContentType: trait.ContentType,
-		Bindings:    convertMessageBinding(trait.Bindings),
+func convertMessageTrait(trait *MessageTraitRef) *asyncapi3.MessageTraitRef {
+	target := &asyncapi3.MessageTraitRef{
+		Reference: dynamic.Reference[*asyncapi3.MessageTraitRef]{Ref: trait.Ref},
 	}
 
-	if trait.Headers != nil && trait.Headers.Value != nil {
-		target.Headers = trait.Headers
+	if trait.Value != nil {
+		target.Value = &asyncapi3.MessageTrait{
+			Name:        trait.Value.Name,
+			Title:       trait.Value.Title,
+			Summary:     trait.Value.Summary,
+			Description: trait.Value.Description,
+			ContentType: trait.Value.ContentType,
+			Bindings:    convertMessageBinding(trait.Value.Bindings),
+		}
+		if trait.Value.Headers != nil && trait.Value.Headers.Value != nil {
+			target.Value.Headers = trait.Value.Headers
+		}
 	}
-	return &asyncapi3.MessageTraitRef{Value: target}
+
+	return target
 }
 
 func convertParameters(channel *asyncapi3.Channel, params map[string]*ParameterRef) error {
@@ -251,7 +245,7 @@ func convertParameters(channel *asyncapi3.Channel, params map[string]*ParameterR
 
 	for name, orig := range params {
 		if len(orig.Ref) > 0 {
-			channel.Parameters[name] = &asyncapi3.ParameterRef{Reference: dynamic.Reference{Ref: orig.Ref}}
+			channel.Parameters[name] = &asyncapi3.ParameterRef{Reference: dynamic.Reference[*asyncapi3.ParameterRef]{Ref: orig.Ref}}
 		}
 		if orig.Value != nil {
 			p, err := convertParameter(name, orig.Value)
@@ -308,17 +302,15 @@ func convertServers(cfg *asyncapi3.Config, servers map[string]*ServerRef) {
 	}
 
 	for name, orig := range servers {
-		if len(orig.Ref) > 0 {
-			cfg.Servers.Set(name, &asyncapi3.ServerRef{Reference: dynamic.Reference{Ref: orig.Ref}})
-		}
-		if orig.Value != nil {
-			cfg.Servers.Set(name, convertServer(orig))
+		if orig == nil {
+			continue
 		}
+		cfg.Servers.Set(name, convertServer(orig))
 	}
 }
 
 func convertServer(ref *ServerRef) *asyncapi3.ServerRef {
-	result := &asyncapi3.ServerRef{Reference: dynamic.Reference{Ref: ref.Ref}}
+	result := &asyncapi3.ServerRef{Reference: dynamic.Reference[*asyncapi3.ServerRef]{Ref: ref.Ref}}
 
 	if ref.Value != nil {
 		target := &asyncapi3.Server{
@@ -440,7 +432,7 @@ func convertComponents(c *Components, config *asyncapi3.Config) (*asyncapi3.Comp
 			target.Parameters = map[string]*asyncapi3.ParameterRef{}
 		}
 		if len(orig.Ref) > 0 {
-			target.Parameters[name] = &asyncapi3.ParameterRef{Reference: dynamic.Reference{Ref: orig.Ref}}
+			target.Parameters[name] = &asyncapi3.ParameterRef{Reference: dynamic.Reference[*asyncapi3.ParameterRef]{Ref: orig.Ref}}
 		}
 		if orig.Value != nil {
 			p, err := convertParameter(name, orig.Value)
@@ -455,12 +447,7 @@ func convertComponents(c *Components, config *asyncapi3.Config) (*asyncapi3.Comp
 		if target.MessageTraits == nil {
 			target.MessageTraits = map[string]*asyncapi3.MessageTraitRef{}
 		}
-		if len(orig.Ref) > 0 {
-			target.MessageTraits[name] = &asyncapi3.MessageTraitRef{Reference: dynamic.Reference{Ref: orig.Ref}}
-		}
-		if orig.Value != nil {
-			target.MessageTraits[name] = convertMessageTrait(orig.Value)
-		}
+		target.MessageTraits[name] = convertMessageTrait(orig)
 	}
 
 	return target, nil