Resolving merge conflicts

go.mod

@@ -11,10 +11,14 @@ require (
 )
 
 require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/google/uuid v1.6.0
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/stretchr/testify v1.10.0
 	github.com/zenazn/pkcs7pad v0.0.0-20170308005700-253a5b1f0e03
-	golang.org/x/text v0.23.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1
 )
 
-require gopkg.in/yaml.v3 v3.0.1
+require golang.org/x/text v0.23.0 // indirect
 
 require golang.org/x/sys v0.31.0 // indirect

go.sum

@@ -1,6 +1,10 @@
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
 github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
@@ -9,11 +13,15 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/santhosh-tekuri/jsonschema/v6 v6.0.1 h1:PKK9DyHxif4LZo+uQSgXNqs0jj5+xZwwfKHgph2lxBw=
 github.com/santhosh-tekuri/jsonschema/v6 v6.0.1/go.mod h1:JXeL+ps8p7/KNMjDQk3TCwPpBy0wYklyWTfbkIzdIFU=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/zenazn/pkcs7pad v0.0.0-20170308005700-253a5b1f0e03 h1:m1h+vudopHsI67FPT9MOncyndWhTcdUoBtI1R1uajGY=
 github.com/zenazn/pkcs7pad v0.0.0-20170308005700-253a5b1f0e03/go.mod h1:8sheVFH84v3PCyFY/O02mIgSQY9I6wMYPWsq7mDnEZY=
 golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=

pkg/plugin/implementation/requestPreProcessor/cmd/plugin.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	requestpreprocessor "github.com/beckn/beckn-onix/pkg/plugin/implementation/requestPreProcessor"
+)
+
+type provider struct{}
+
+func (p provider) New(ctx context.Context, c map[string]string) (func(http.Handler) http.Handler, error) {
+	config := &requestpreprocessor.Config{}
+	if contextKeysStr, ok := c["ContextKeys"]; ok {
+		config.ContextKeys = strings.Split(contextKeysStr, ",")
+	}
+	return requestpreprocessor.NewUUIDSetter(config)
+}
+
+var Provider = provider{}

pkg/plugin/implementation/requestPreProcessor/cmd/plugin_test.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TODO: Will Split this into success and fail (two test cases)
+func TestProviderNew(t *testing.T) {
+	testCases := []struct {
+		name           string
+		config         map[string]string
+		expectedError  bool
+		expectedStatus int
+		prepareRequest func(req *http.Request)
+	}{
+		{
+			name:           "No Config",
+			config:         map[string]string{},
+			expectedError:  true,
+			expectedStatus: http.StatusOK,
+			prepareRequest: func(req *http.Request) {
+				// Add minimal required headers.
+				req.Header.Set("context", "test-context")
+				req.Header.Set("transaction_id", "test-transaction")
+			},
+		},
+		{
+			name: "With Check Keys",
+			config: map[string]string{
+				"ContextKeys": "message_id,transaction_id",
+			},
+			expectedError:  false,
+			expectedStatus: http.StatusOK,
+			prepareRequest: func(req *http.Request) {
+				// Add headers matching the check keys.
+				req.Header.Set("context", "test-context")
+				req.Header.Set("transaction_id", "test-transaction")
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			requestBody := `{
+				"context": {
+					"transaction_id": "abc"
+				}
+			}`
+
+			p := provider{}
+			middleware, err := p.New(context.Background(), tc.config)
+			if tc.expectedError {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			assert.NotNil(t, middleware)
+
+			testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			req := httptest.NewRequest("POST", "/", strings.NewReader(requestBody))
+			req.Header.Set("Content-Type", "application/json")
+			if tc.prepareRequest != nil {
+				tc.prepareRequest(req)
+			}
+
+			w := httptest.NewRecorder()
+			middlewaredHandler := middleware(testHandler)
+			middlewaredHandler.ServeHTTP(w, req)
+			assert.Equal(t, tc.expectedStatus, w.Code, "Unexpected response status")
+			responseBody := w.Body.String()
+			t.Logf("Response Body: %s", responseBody)
+
+		})
+	}
+}

pkg/plugin/implementation/requestPreProcessor/reqpreprocessor.go

@@ -0,0 +1,105 @@
+package requestpreprocessor
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/google/uuid"
+)
+
+type Config struct {
+	ContextKeys []string
+	Role        string
+}
+
+type becknRequest struct {
+	Context map[string]any `json:"context"`
+}
+
+type contextKeyType string
+
+const contextKey = "context"
+const subscriberIDKey contextKeyType = "subscriber_id"
+
+func NewUUIDSetter(cfg *Config) (func(http.Handler) http.Handler, error) {
+	if err := validateConfig(cfg); err != nil {
+		return nil, err
+	}
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			body, _ := io.ReadAll(r.Body)
+			var req becknRequest
+			if err := json.Unmarshal(body, &req); err != nil {
+				http.Error(w, "Failed to decode request body", http.StatusBadRequest)
+				return
+			}
+			if req.Context == nil {
+				http.Error(w, fmt.Sprintf("%s field not found.", contextKey), http.StatusBadRequest)
+				return
+			}
+			var subID any
+			switch cfg.Role {
+			case "bap":
+				subID = req.Context["bap_id"]
+			case "bpp":
+				subID = req.Context["bpp_id"]
+			}
+			ctx := context.WithValue(r.Context(), subscriberIDKey, subID)
+			for _, key := range cfg.ContextKeys {
+				value := uuid.NewString()
+				updatedValue := update(req.Context, key, value)
+				ctx = context.WithValue(ctx, contextKeyType(key), updatedValue)
+			}
+			reqData := map[string]any{"context": req.Context}
+			updatedBody, _ := json.Marshal(reqData)
+			r.Body = io.NopCloser(bytes.NewBuffer(updatedBody))
+			r.ContentLength = int64(len(updatedBody))
+			r = r.WithContext(ctx)
+			next.ServeHTTP(w, r)
+		})
+	}, nil
+}
+
+func update(wrapper map[string]any, key string, value any) any {
+	field, exists := wrapper[key]
+	if !exists || isEmpty(field) {
+		wrapper[key] = value
+		return value
+	}
+
+	return field
+}
+func isEmpty(v any) bool {
+	switch v := v.(type) {
+	case string:
+		return v == ""
+	case nil:
+		return true
+	default:
+		return false
+	}
+}
+
+func validateConfig(cfg *Config) error {
+	if cfg == nil {
+		return errors.New("config cannot be nil")
+	}
+
+	// Check if ContextKeys is empty.
+	if len(cfg.ContextKeys) == 0 {
+		return errors.New("ContextKeys cannot be empty")
+	}
+
+	// Validate that ContextKeys does not contain empty strings.
+	for _, key := range cfg.ContextKeys {
+		if key == "" {
+			return errors.New("ContextKeys cannot contain empty strings")
+		}
+	}
+	return nil
+}

pkg/plugin/implementation/requestPreProcessor/reqpreprocessor_test.go

@@ -0,0 +1,178 @@
+package requestpreprocessor
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestNewUUIDSetterSuccessCases(t *testing.T) {
+	tests := []struct {
+		name         string
+		config       *Config
+		requestBody  map[string]any
+		expectedKeys []string
+		role         string
+	}{
+		{
+			name: "Valid keys, update missing keys with bap role",
+			config: &Config{
+				ContextKeys: []string{"transaction_id", "message_id"},
+				Role:        "bap",
+			},
+			requestBody: map[string]any{
+				"context": map[string]any{
+					"transaction_id": "",
+					"message_id":     nil,
+					"bap_id":         "bap-123",
+				},
+			},
+			expectedKeys: []string{"transaction_id", "message_id", "bap_id"},
+			role:         "bap",
+		},
+		{
+			name: "Valid keys, do not update existing keys with bpp role",
+			config: &Config{
+				ContextKeys: []string{"transaction_id", "message_id"},
+				Role:        "bpp",
+			},
+			requestBody: map[string]any{
+				"context": map[string]any{
+					"transaction_id": "existing-transaction",
+					"message_id":     "existing-message",
+					"bpp_id":         "bpp-456",
+				},
+			},
+			expectedKeys: []string{"transaction_id", "message_id", "bpp_id"},
+			role:         "bpp",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			middleware, err := NewUUIDSetter(tt.config)
+			if err != nil {
+				t.Fatalf("Unexpected error while creating middleware: %v", err)
+			}
+
+			bodyBytes, _ := json.Marshal(tt.requestBody)
+			req := httptest.NewRequest(http.MethodPost, "/test", bytes.NewReader(bodyBytes))
+			req.Header.Set("Content-Type", "application/json")
+
+			rec := httptest.NewRecorder()
+
+			dummyHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				ctx := r.Context()
+				w.WriteHeader(http.StatusOK)
+
+				subID, ok := ctx.Value(subscriberIDKey).(string)
+				if !ok {
+					http.Error(w, "Subscriber ID not found", http.StatusInternalServerError)
+					return
+				}
+
+				response := map[string]any{"subscriber_id": subID}
+				if err := json.NewEncoder(w).Encode(response); err != nil {
+					http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+					return
+				}
+			})
+
+			middleware(dummyHandler).ServeHTTP(rec, req)
+
+			if rec.Code != http.StatusOK {
+				t.Errorf("Expected status code 200, but got %d", rec.Code)
+				return
+			}
+
+			var responseBody map[string]any
+			if err := json.Unmarshal(rec.Body.Bytes(), &responseBody); err != nil {
+				t.Fatal("Failed to unmarshal response body:", err)
+			}
+
+			expectedSubIDKey := "bap_id"
+			if tt.role == "bpp" {
+				expectedSubIDKey = "bpp_id"
+			}
+
+			subID, ok := responseBody["subscriber_id"].(string)
+			if !ok {
+				t.Error("subscriber_id not found in response")
+				return
+			}
+
+			expectedSubID := tt.requestBody["context"].(map[string]any)[expectedSubIDKey]
+			if subID != expectedSubID {
+				t.Errorf("Expected subscriber_id %v, but got %v", expectedSubID, subID)
+			}
+		})
+	}
+}
+
+func TestNewUUIDSetterErrorCases(t *testing.T) {
+	tests := []struct {
+		name         string
+		config       *Config
+		requestBody  map[string]any
+		expectedCode int
+	}{
+		{
+			name: "Missing context key",
+			config: &Config{
+				ContextKeys: []string{"transaction_id"},
+			},
+			requestBody: map[string]any{
+				"otherKey": "value",
+			},
+			expectedCode: http.StatusBadRequest,
+		},
+		{
+			name: "Invalid context type",
+			config: &Config{
+				ContextKeys: []string{"transaction_id"},
+			},
+			requestBody: map[string]any{
+				"context": "not-a-map",
+			},
+			expectedCode: http.StatusBadRequest,
+		},
+		{
+			name:         "Nil config",
+			config:       nil,
+			requestBody:  map[string]any{},
+			expectedCode: http.StatusInternalServerError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			middleware, err := NewUUIDSetter(tt.config)
+			if tt.config == nil {
+				if err == nil {
+					t.Error("Expected an error for nil config, but got none")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("Unexpected error while creating middleware: %v", err)
+			}
+
+			bodyBytes, _ := json.Marshal(tt.requestBody)
+			req := httptest.NewRequest(http.MethodPost, "/test", bytes.NewReader(bodyBytes))
+			req.Header.Set("Content-Type", "application/json")
+
+			rec := httptest.NewRecorder()
+			dummyHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+			})
+
+			middleware(dummyHandler).ServeHTTP(rec, req)
+
+			if rec.Code != tt.expectedCode {
+				t.Errorf("Expected status code %d, but got %d", tt.expectedCode, rec.Code)
+			}
+		})
+	}
+}

pkg/response/response_test.go

@@ -301,3 +301,17 @@ func compareContexts(c1, c2 map[string]interface{}) bool {
 
 	return reflect.DeepEqual(c1, c2)
 }
+
+func TestSchemaValidationErr_Error(t *testing.T) {
+	validationErrors := []Error{
+		{Paths: "name", Message: "Name is required"},
+		{Paths: "email", Message: "Invalid email format"},
+	}
+	err := SchemaValidationErr{Errors: validationErrors}
+	expected := "name: Name is required; email: Invalid email format"
+	if err.Error() != expected {
+		t.Errorf("err.Error() = %s, want %s",
+			err.Error(), expected)
+
+	}
+}