Simplify onlyContainsPrimitiveTypes and fix isObject nil panic (#332)

Author: tomaisthorpe

lib/agent/api_discovery/isPrimitiveType.go

@@ -1,19 +1,12 @@
 package api_discovery
 
-func onlyContainsPrimitiveTypes(types interface{}) bool {
-	switch t := types.(type) {
-	case string:
-		return isPrimitiveType(t)
-	case []string:
-		for _, item := range t {
-			if !isPrimitiveType(item) {
-				return false
-			}
+func onlyContainsPrimitiveTypes(types []string) bool {
+	for _, item := range types {
+		if !isPrimitiveType(item) {
+			return false
 		}
-		return true
-	default:
-		return false
 	}
+	return true
 }
 
 func isPrimitiveType(typeStr string) bool {

lib/agent/api_discovery/isPrimitiveType_test.go

@@ -0,0 +1,50 @@
+package api_discovery
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsPrimitiveType(t *testing.T) {
+	testCases := []struct {
+		str      string
+		expected bool
+	}{
+		{str: "string", expected: true},
+		{str: "number", expected: true},
+		{str: "boolean", expected: true},
+		{str: "null", expected: true},
+		{str: "array", expected: false},
+		{str: "object", expected: false},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.str, func(t *testing.T) {
+			result := isPrimitiveType(tc.str)
+			assert.Equal(t, tc.expected, result)
+		})
+	}
+}
+
+func TestOnlyContainsPrimitiveTypes(t *testing.T) {
+	testCases := []struct {
+		name     string
+		types    []string
+		expected bool
+	}{
+		{name: "all primitive", types: []string{"string", "number", "boolean"}, expected: true},
+		{name: "contains object", types: []string{"number", "object"}, expected: false},
+		{name: "contains array", types: []string{"string", "array"}, expected: false},
+		{name: "both object and array", types: []string{"object", "array"}, expected: false},
+		{name: "empty", types: []string{}, expected: true},
+		{name: "single primitive", types: []string{"string"}, expected: true},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := onlyContainsPrimitiveTypes(tc.types)
+			assert.Equal(t, tc.expected, result)
+		})
+	}
+}

lib/request-processor/api_discovery/getApiAuthType.go

@@ -3,6 +3,7 @@ package api_discovery
 import (
 	"main/context"
 	"main/ipc/protos"
+	"slices"
 	"strings"
 )
 
@@ -98,7 +99,7 @@ func findApiKeys() []*protos.APIAuthType {
 	if len(cookies) > 0 {
 		for cookieName := range cookies {
 			lowerCookieName := strings.ToLower(cookieName)
-			if contains(commonAuthCookieNames, lowerCookieName) {
+			if slices.Contains(commonAuthCookieNames, lowerCookieName) {
 				result = append(result, &protos.APIAuthType{
 					Type: "apiKey",
 					In:   "cookie",
@@ -111,21 +112,11 @@ func findApiKeys() []*protos.APIAuthType {
 	return result
 }
 
-// contains checks if a string exists in a slice.
-func contains(slice []string, item string) bool {
-	for _, a := range slice {
-		if a == item {
-			return true
-		}
-	}
-	return false
-}
-
 // isHTTPAuthScheme checks if the given string is a valid HTTP authentication scheme.
 // You will need to implement this function similar to the TypeScript helper function.
 func isHTTPAuthScheme(scheme string) bool {
 	// You can add proper logic here to check the scheme, e.g., "basic", "bearer", etc.
 	// For example:
 	allowedSchemes := []string{"basic", "bearer"}
-	return contains(allowedSchemes, strings.ToLower(scheme))
+	return slices.Contains(allowedSchemes, strings.ToLower(scheme))
 }

lib/request-processor/api_discovery/getApiInfo.go

@@ -5,6 +5,7 @@ import (
 	"main/context"
 	"main/ipc/protos"
 	"main/log"
+	"reflect"
 )
 
 func GetApiInfo(server *ServerData) *protos.APISpec {
@@ -57,7 +58,10 @@ func GetApiInfo(server *ServerData) *protos.APISpec {
 }
 
 func isObject(data interface{}) bool {
+	if data == nil {
+		return false
+	}
+
 	// Helper function to determine if the data is an object (map in Go)
-	_, ok := data.(map[string]interface{})
-	return ok
+	return reflect.TypeOf(data).Kind() == reflect.Map
 }

lib/request-processor/api_discovery/getApiInfo_test.go

@@ -0,0 +1,21 @@
+package api_discovery
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIsObject(t *testing.T) {
+	t.Run("Test isObject", func(t *testing.T) {
+		assert.Equal(t, false, isObject(""))
+		assert.Equal(t, false, isObject([]string{"1"}))
+		assert.Equal(t, false, isObject(nil))
+
+		assert.Equal(t, true, isObject(map[string]any{"1": "2"}))
+		assert.Equal(t, true, isObject(map[string]string{"1": "2"}))
+		assert.Equal(t, true, isObject(map[string]int{"1": 500}))
+		assert.Equal(t, true, isObject(map[string][]string{"1": {"2"}}))
+		assert.Equal(t, true, isObject(map[string][]any{"1": {"2"}}))
+	})
+}