Changes to Response Error struct

pkg/plugin/implementation/schemaValidator/cmd/plugin.go

@@ -5,10 +5,10 @@ import (
 	"errors"
 
 	definition "github.com/beckn/beckn-onix/pkg/plugin/definition"
-	validator "github.com/beckn/beckn-onix/pkg/plugin/implementation/schemaValidator"
+	schemaValidator "github.com/beckn/beckn-onix/pkg/plugin/implementation/schemaValidator"
 )
 
-// ValidatorProvider provides instance of Validator.
+// schemaValidatorProvider provides instances of schemaValidator.
 type schemaValidatorProvider struct{}
 
 // New initializes a new Verifier instance.
@@ -23,11 +23,11 @@ func (vp schemaValidatorProvider) New(ctx context.Context, config map[string]str
 		return nil, nil, errors.New("config must contain 'schema_dir'")
 	}
 
-	// Create a new Validator instance with the provided configuration
-	return validator.New(ctx, &validator.Config{
-		SchemaDir: schemaDir, // Pass the schemaDir to the validator.Config
+	// Create a new schemaValidator instance with the provided configuration
+	return schemaValidator.New(ctx, &schemaValidator.Config{
+		SchemaDir: schemaDir,
 	})
 }
 
 // Provider is the exported symbol that the plugin manager will look for.
-var Provider definition.SchemaValidatorProvider = &schemaValidatorProvider{}
+var Provider definition.SchemaValidatorProvider = schemaValidatorProvider{}

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

@@ -72,7 +72,7 @@ func TestValidatorProviderSuccess(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			vp := schemaValidatorProvider{}
-			validator, close, err := vp.New(tt.ctx, tt.config)
+			schemaValidator, close, err := vp.New(tt.ctx, tt.config)
 
 			// Ensure no error occurred
 			if err != nil {
@@ -80,9 +80,9 @@ func TestValidatorProviderSuccess(t *testing.T) {
 				return
 			}
 
-			// Ensure the validator is not nil
-			if validator == nil {
-				t.Error("expected a non-nil validator, got nil")
+			// Ensure the schemaValidator is not nil
+			if schemaValidator == nil {
+				t.Error("expected a non-nil schemaValidator, got nil")
 			}
 
 			// Ensure the close function is not nil
@@ -110,11 +110,23 @@ func TestValidatorProviderFailure(t *testing.T) {
 		config        map[string]string
 		expectedError string
 	}{
+		{
+			name:          "Config is empty",
+			ctx:           context.Background(),
+			config:        map[string]string{},
+			expectedError: "config must contain 'schema_dir'",
+		},
+		{
+			name:          "schema_dir is empty",
+			ctx:           context.Background(),
+			config:        map[string]string{"schema_dir": ""},
+			expectedError: "config must contain 'schema_dir'",
+		},
 		{
 			name:          "Invalid schema directory",
 			ctx:           context.Background(), // Valid context
 			config:        map[string]string{"schema_dir": "/invalid/dir"},
-			expectedError: "failed to initialise validator: schema directory does not exist: /invalid/dir",
+			expectedError: "failed to initialise schemaValidator: schema directory does not exist: /invalid/dir",
 		},
 		{
 			name:          "Nil context",

pkg/plugin/implementation/schemaValidator/schemaValidator.go

@@ -10,7 +10,7 @@ import (
 	"path/filepath"
 	"strings"
 
-	definition "github.com/beckn/beckn-onix/pkg/plugin/definition"
+	response "github.com/beckn/beckn-onix/pkg/response"
 
 	"github.com/santhosh-tekuri/jsonschema/v6"
 )
@@ -23,12 +23,13 @@ type payload struct {
 	} `json:"context"`
 }
 
-// Validator implements the Validator interface.
+// SchemaValidator implements the Validator interface.
 type SchemaValidator struct {
 	config      *Config
 	schemaCache map[string]*jsonschema.Schema
 }
 
+// Config struct for SchemaValidator.
 type Config struct {
 	SchemaDir string
 }
@@ -45,8 +46,8 @@ func New(ctx context.Context, config *Config) (*SchemaValidator, func() error, e
 	}
 
 	// Call Initialise function to load schemas and get validators
-	if err := v.Initialise(); err != nil {
-		return nil, nil, fmt.Errorf("failed to initialise validator: %v", err)
+	if err := v.initialise(); err != nil {
+		return nil, nil, fmt.Errorf("failed to initialise schemaValidator: %v", err)
 	}
 	return v, v.Close, nil
 }
@@ -88,20 +89,20 @@ func (v *SchemaValidator) Validate(ctx context.Context, url *url.URL, data []byt
 		// Handle schema validation errors
 		if validationErr, ok := err.(*jsonschema.ValidationError); ok {
 			// Convert validation errors into an array of SchemaValError
-			var schemaErrors []definition.SchemaValError
+			var schemaErrors []response.Error
 			for _, cause := range validationErr.Causes {
 				// Extract the path and message from the validation error
 				path := strings.Join(cause.InstanceLocation, ".") // JSON path to the invalid field
 				message := cause.Error()                          // Validation error message
 
 				// Append the error to the schemaErrors array
-				schemaErrors = append(schemaErrors, definition.SchemaValError{
-					Path:    path,
+				schemaErrors = append(schemaErrors, response.Error{
+					Paths:   path,
 					Message: message,
 				})
 			}
 			// Return the array of schema validation errors
-			return &definition.SchemaValidationErr{Errors: schemaErrors}
+			return &response.SchemaValidationErr{Errors: schemaErrors}
 		}
 		// Return a generic error for non-validation errors
 		return fmt.Errorf("validation failed: %v", err)
@@ -116,7 +117,7 @@ type ValidatorProvider struct{}
 
 // Initialise initialises the validator provider by compiling all the JSON schema files
 // from the specified directory and storing them in a cache indexed by their schema filenames.
-func (v *SchemaValidator) Initialise() error {
+func (v *SchemaValidator) initialise() error {
 	schemaDir := v.config.SchemaDir
 	// Check if the directory exists and is accessible.
 	info, err := os.Stat(schemaDir)

pkg/plugin/implementation/schemaValidator/schemaValidator_test.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/beckn/beckn-onix/pkg/plugin/definition"
+	"github.com/santhosh-tekuri/jsonschema/v6"
 )
 
 // setupTestSchema creates a temporary directory and writes a sample schema file.
@@ -54,16 +54,16 @@ func setupTestSchema(t *testing.T) string {
 
 func TestValidator_Validate_Success(t *testing.T) {
 	tests := []struct {
-		name      string
-		url       string
-		payload   string
-		wantValid bool
+		name    string
+		url     string
+		payload string
+		wantErr bool
 	}{
 		{
-			name:      "Valid payload",
-			url:       "http://example.com/endpoint",
-			payload:   `{"context": {"domain": "example", "version": "1.0", "action": "endpoint"}}`,
-			wantValid: true,
+			name:    "Valid payload",
+			url:     "http://example.com/endpoint",
+			payload: `{"context": {"domain": "example", "version": "1.0", "action": "endpoint"}}`,
+			wantErr: false,
 		},
 	}
 
@@ -80,12 +80,11 @@ func TestValidator_Validate_Success(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			u, _ := url.Parse(tt.url)
-			valid, err := v.Validate(context.Background(), u, []byte(tt.payload))
-			if err != (definition.SchemaValError{}) {
+			err := v.Validate(context.Background(), u, []byte(tt.payload))
+			if err != nil {
 				t.Errorf("Unexpected error: %v", err)
-			}
-			if valid != tt.wantValid {
-				t.Errorf("Error: Validate() returned valid = %v, expected valid = %v", valid, tt.wantValid)
+			} else {
+				t.Logf("Test %s passed with no errors", tt.name)
 			}
 		})
 	}
@@ -93,32 +92,28 @@ func TestValidator_Validate_Success(t *testing.T) {
 
 func TestValidator_Validate_Failure(t *testing.T) {
 	tests := []struct {
-		name      string
-		url       string
-		payload   string
-		wantValid bool
-		wantErr   string
+		name    string
+		url     string
+		payload string
+		wantErr string
 	}{
 		{
-			name:      "Invalid JSON payload",
-			url:       "http://example.com/endpoint",
-			payload:   `{"context": {"domain": "example", "version": "1.0"`,
-			wantValid: false,
-			wantErr:   "failed to parse JSON payload",
+			name:    "Invalid JSON payload",
+			url:     "http://example.com/endpoint",
+			payload: `{"context": {"domain": "example", "version": "1.0"`,
+			wantErr: "failed to parse JSON payload",
 		},
 		{
-			name:      "Schema validation failure",
-			url:       "http://example.com/endpoint",
-			payload:   `{"context": {"domain": "example", "version": "1.0"}}`,
-			wantValid: false,
-			wantErr:   "Validation failed",
+			name:    "Schema validation failure",
+			url:     "http://example.com/endpoint",
+			payload: `{"context": {"domain": "example", "version": "1.0"}}`,
+			wantErr: "context: at '/context': missing property 'action'",
 		},
 		{
-			name:      "Schema not found",
-			url:       "http://example.com/unknown_endpoint",
-			payload:   `{"context": {"domain": "example", "version": "1.0"}}`,
-			wantValid: false,
-			wantErr:   "schema not found for domain",
+			name:    "Schema not found",
+			url:     "http://example.com/unknown_endpoint",
+			payload: `{"context": {"domain": "example", "version": "1.0"}}`,
+			wantErr: "schema not found for domain",
 		},
 	}
 
@@ -135,13 +130,21 @@ func TestValidator_Validate_Failure(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			u, _ := url.Parse(tt.url)
-			valid, err := v.Validate(context.Background(), u, []byte(tt.payload))
-			if (err != (definition.SchemaValError{}) && !strings.Contains(err.Message, tt.wantErr)) || (err == (definition.SchemaValError{}) && tt.wantErr != "") {
-				t.Errorf("Error: Validate() returned error = %v, expected error = %v", err, tt.wantErr)
-				return
-			}
-			if valid != tt.wantValid {
-				t.Errorf("Validate() returned valid = %v, expected valid = %v", valid, tt.wantValid)
+			err := v.Validate(context.Background(), u, []byte(tt.payload))
+			if tt.wantErr != "" {
+				if err == nil {
+					t.Errorf("Expected error containing '%s', but got nil", tt.wantErr)
+				} else if !strings.Contains(err.Error(), tt.wantErr) {
+					t.Errorf("Expected error containing '%s', but got '%v'", tt.wantErr, err)
+				} else {
+					t.Logf("Test %s passed with expected error: %v", tt.name, err)
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Unexpected error: %v", err)
+				} else {
+					t.Logf("Test %s passed with no errors", tt.name)
+				}
 			}
 		})
 	}
@@ -269,11 +272,14 @@ func TestValidator_Initialise(t *testing.T) {
 			}
 
 			config := &Config{SchemaDir: schemaDir}
-			v := &Validator{config: config}
+			v := &SchemaValidator{
+				config:      config,
+				schemaCache: make(map[string]*jsonschema.Schema),
+			}
 
-			err := v.Initialise()
+			err := v.initialise()
 			if (err != nil && !strings.Contains(err.Error(), tt.wantErr)) || (err == nil && tt.wantErr != "") {
-				t.Errorf("Error: Initialise() returned error = %v, expected error = %v", err, tt.wantErr)
+				t.Errorf("Error: initialise() returned error = %v, expected error = %v", err, tt.wantErr)
 			} else if err == nil {
 				t.Logf("Test %s passed: validator initialized successfully", tt.name)
 			} else {
@@ -309,22 +315,22 @@ func TestValidator_New_Failure(t *testing.T) {
 			},
 			wantErr: "config cannot be nil",
 		},
-		{
-			name:   "Config is empty",
-			config: &Config{},
-			setupFunc: func(schemaDir string) error {
-				return nil
-			},
-			wantErr: "config must contain 'schema_dir'",
-		},
-		{
-			name:   "schema_dir is empty",
-			config: &Config{SchemaDir: ""},
-			setupFunc: func(schemaDir string) error {
-				return nil
-			},
-			wantErr: "config must contain 'schema_dir'",
-		},
+		// {
+		// 	name:   "Config is empty",
+		// 	config: &Config{},
+		// 	setupFunc: func(schemaDir string) error {
+		// 		return nil
+		// 	},
+		// 	wantErr: "config must contain 'schema_dir'",
+		// },
+		// {
+		// 	name:   "schema_dir is empty",
+		// 	config: &Config{SchemaDir: ""},
+		// 	setupFunc: func(schemaDir string) error {
+		// 		return nil
+		// 	},
+		// 	wantErr: "config must contain 'schema_dir'",
+		// },
 		{
 			name: "Failed to initialise validators",
 			config: &Config{
@@ -334,7 +340,7 @@ func TestValidator_New_Failure(t *testing.T) {
 				// Do not create the schema directory
 				return nil
 			},
-			wantErr: "failed to initialise validator",
+			wantErr: "ailed to initialise schemaValidator: schema directory does not exist: /invalid/path",
 		},
 	}