Merge pull request #718 from marle3003/develop

Develop

Author: marle3003

api/handler_events_test.go

@@ -1,16 +1,21 @@
 package api
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
-	"github.com/stretchr/testify/require"
 	"mokapi/config/static"
+	"mokapi/providers/openapi"
 	"mokapi/runtime"
 	"mokapi/runtime/events"
 	"mokapi/runtime/events/eventstest"
 	"mokapi/try"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestHandler_Events(t *testing.T) {
@@ -73,7 +78,109 @@ func TestHandler_Events(t *testing.T) {
 			},
 		},
 		{
-			name: "get specific event but not existing",
+			name: "get http event with header parameter as string",
+			fn: func(t *testing.T, h http.Handler, sm *events.StoreManager) {
+				sm.SetStore(1, events.NewTraits().WithNamespace("http"))
+
+				r := httptest.NewRequest("get", "http://localhost/foo", nil)
+				r.Header.Set("foo", "bar")
+
+				params := &openapi.RequestParameters{Header: map[string]openapi.RequestParameterValue{}}
+				v := "bar"
+				params.Header["Foo"] = openapi.RequestParameterValue{
+					Value: "bar",
+					Raw:   &v,
+				}
+				r = r.WithContext(openapi.NewContext(context.Background(), params))
+
+				_, err := openapi.NewLogEventContext(r, false, sm, events.NewTraits().WithNamespace("http"))
+				require.NoError(t, err)
+				try.Handler(t,
+					http.MethodGet,
+					"http://foo.api/api/events?namespace=http",
+					nil,
+					"",
+					h,
+					try.HasStatusCode(200),
+					try.AssertBody(func(t *testing.T, body string) {
+						var m []map[string]any
+						require.NoError(t, json.Unmarshal([]byte(body), &m))
+						require.Equal(t, map[string]interface{}{
+							"actions":    interface{}(nil),
+							"api":        "",
+							"deprecated": false,
+							"duration":   float64(0),
+							"path":       "",
+							"request": map[string]interface{}{
+								"method": "get",
+								"parameters": []interface{}{
+									map[string]interface{}{
+										"name":  "Foo",
+										"raw":   "bar",
+										"type":  "header",
+										"value": "\"bar\"",
+									},
+								},
+								"url": "http://localhost/foo",
+							},
+							"response": map[string]interface{}{"body": "", "size": float64(0), "statusCode": float64(0)}},
+							m[0]["data"])
+					}))
+			},
+		},
+		{
+			name: "get http event with header parameter as object",
+			fn: func(t *testing.T, h http.Handler, sm *events.StoreManager) {
+				sm.SetStore(1, events.NewTraits().WithNamespace("http"))
+
+				r := httptest.NewRequest("get", "http://localhost/foo", nil)
+				r.Header.Set("foo", "role,admin,firstName,Alex")
+
+				params := &openapi.RequestParameters{Header: map[string]openapi.RequestParameterValue{}}
+				v := "bar"
+				params.Header["Foo"] = openapi.RequestParameterValue{
+					Value: map[string]any{"role": "admin", "firstName": "Alex"},
+					Raw:   &v,
+				}
+				r = r.WithContext(openapi.NewContext(context.Background(), params))
+
+				_, err := openapi.NewLogEventContext(r, false, sm, events.NewTraits().WithNamespace("http"))
+				require.NoError(t, err)
+				try.Handler(t,
+					http.MethodGet,
+					"http://foo.api/api/events?namespace=http",
+					nil,
+					"",
+					h,
+					try.HasStatusCode(200),
+					try.AssertBody(func(t *testing.T, body string) {
+						var m []map[string]any
+						require.NoError(t, json.Unmarshal([]byte(body), &m))
+						require.Equal(t, map[string]interface{}{
+							"actions":    interface{}(nil),
+							"api":        "",
+							"deprecated": false,
+							"duration":   float64(0),
+							"path":       "",
+							"request": map[string]interface{}{
+								"method": "get",
+								"parameters": []interface{}{
+									map[string]interface{}{
+										"name":  "Foo",
+										"raw":   "bar",
+										"type":  "header",
+										"value": "{\"firstName\":\"Alex\",\"role\":\"admin\"}",
+									},
+								},
+								"url": "http://localhost/foo",
+							},
+							"response": map[string]interface{}{"body": "", "size": float64(0), "statusCode": float64(0)}},
+							m[0]["data"])
+					}))
+			},
+		},
+		{
+			name: "http with request parameter",
 			fn: func(t *testing.T, h http.Handler, sm *events.StoreManager) {
 				try.Handler(t,
 					http.MethodGet,

engine/common/host.go

@@ -174,4 +174,10 @@ type FakerNode interface {
 type Store interface {
 	Get(string) any
 	Set(string, any)
+	Has(string) bool
+	Delete(string)
+	Clear()
+	Update(key string, fn func(v any) any) any
+	Keys() []string
+	Namespace(name string) Store
 }

engine/engine.go

@@ -7,6 +7,7 @@ import (
 	"mokapi/runtime"
 	"mokapi/runtime/events"
 	"mokapi/runtime/metrics"
+	"sort"
 	"sync"
 
 	"github.com/pkg/errors"
@@ -163,6 +164,10 @@ func (e *Engine) IsLevelEnabled(level string) bool {
 	return e.logger.IsLevelEnabled(level)
 }
 
+func NewStore() *Store {
+	return &Store{data: make(map[string]any)}
+}
+
 func (s *Store) Get(key string) any {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -174,3 +179,61 @@ func (s *Store) Set(key string, value any) {
 	defer s.mu.Unlock()
 	s.data[key] = value
 }
+
+func (s *Store) Has(key string) bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	_, ok := s.data[key]
+	return ok
+}
+
+func (s *Store) Delete(key string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	delete(s.data, key)
+}
+
+func (s *Store) Clear() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.data = make(map[string]any)
+}
+
+func (s *Store) Keys() []string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	keys := make([]string, 0, len(s.data))
+	for k := range s.data {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func (s *Store) Update(key string, fn func(v any) any) any {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	v := fn(s.data[key])
+	s.data[key] = v
+	return v
+}
+
+func (s *Store) Namespace(name string) common.Store {
+	s.mu.Lock()
+	v, ok := s.data[name]
+	s.mu.Unlock()
+	if ok {
+		ns, ok := v.(*Store)
+
+		if !ok {
+			return nil
+		}
+		return ns
+	}
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	ns := &Store{data: make(map[string]any)}
+	s.data[name] = ns
+	return ns
+}

engine/enginetest/host.go

@@ -3,6 +3,7 @@ package enginetest
 import (
 	"fmt"
 	"mokapi/config/dynamic"
+	"mokapi/engine"
 	"mokapi/engine/common"
 	"mokapi/schema/json/generator"
 	"net/http"
@@ -27,12 +28,7 @@ type Host struct {
 	OnFunc             func(event string, do func(args ...interface{}) (bool, error), tags map[string]string)
 	FindFakerNodeFunc  func(name string) *generator.Node
 	m                  sync.Mutex
-	StoreTest          *Store
-}
-
-type Store struct {
-	data map[string]any
-	m    sync.RWMutex
+	StoreTest          *engine.Store
 }
 
 type HttpClient struct {
@@ -142,7 +138,7 @@ func (h *Host) KafkaClient() common.KafkaClient {
 
 func (h *Host) Store() common.Store {
 	if h.StoreTest == nil {
-		h.StoreTest = &Store{data: make(map[string]any)}
+		h.StoreTest = engine.NewStore()
 	}
 	return h.StoreTest
 }
@@ -173,21 +169,3 @@ func mustParse(s string) *url.URL {
 	}
 	return u
 }
-
-func (s *Store) Get(name string) any {
-	s.m.RLock()
-	defer s.m.RUnlock()
-	if s.data == nil {
-		return nil
-	}
-	return s.data[name]
-}
-
-func (s *Store) Set(name string, value any) {
-	s.m.Lock()
-	defer s.m.Unlock()
-	if s.data == nil {
-		s.data = map[string]any{name: value}
-	}
-	s.data[name] = value
-}

examples/mokapi/services_http.js

@@ -775,5 +775,50 @@ export let events = [
                 }
             ]
         }
+    },
+    {
+        id: "a5409fc1-6a5a-4c0b-be39-a6b80885e41b",
+        traits: {
+            namespace: "http",
+            name: "Swagger Petstore",
+            path: "/requestWithParams",
+            method: 'GET'
+        },
+        time: '2023-02-13T10:05:25.583366+01:00',
+        data: {
+            request: {
+                method: "GET",
+                url: "http://127.0.0.1:18080/requestWithParams",
+                contentType: "application/json",
+                parameters: [
+                    {
+                        name: "foo",
+                        type: "query",
+                        value: `"bar"`,
+                        raw: "bar"
+                    },
+                    {
+                        name: "debug",
+                        type: "header",
+                        value: `{"foo":"bar"}`,
+                        raw: "bar"
+                    },
+                    {
+                        name: "noSpec",
+                        type: "header",
+                        raw: "bar"
+                    }
+                ]
+            },
+            response: {
+                statusCode: 500,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: `{"id": 0,"category": {"id": 0,"name": "string"},"name": "doggie","photoUrls": ["string"],"tags":[{"id": 0,"name": "string"}],"status": "available"}`,
+                size: 512
+            },
+            duration: 133,
+        }
     }
 ]

imap/auth.go

@@ -2,6 +2,7 @@ package imap
 
 import (
 	"encoding/base64"
+	"fmt"
 	"mokapi/sasl"
 	"strings"
 )
@@ -74,9 +75,11 @@ func (c *conn) handleAuth(_, param string) *response {
 
 	c.state = AuthenticatedState
 
+	caps := c.getCapabilities()
 	return &response{
 		status: ok,
-		text:   "Authenticated",
+		code:   responseCode(fmt.Sprintf("%s", caps)),
+		text:   "Logged in",
 	}
 }
 
@@ -95,9 +98,13 @@ func (c *conn) handleLogin(tag, param string) error {
 	if err != nil {
 		return err
 	}
+
+	c.state = AuthenticatedState
+
+	caps := c.getCapabilities()
 	return c.writeResponse(tag, &response{
 		status: ok,
-		code:   readWrite,
-		text:   "SELECT completed",
+		code:   responseCode(fmt.Sprintf("%s", caps)),
+		text:   "Logged in",
 	})
 }