diff --git a/pkg/model/error.go b/pkg/model/error.go new file mode 100644 index 0000000..5c5f450 --- /dev/null +++ b/pkg/model/error.go @@ -0,0 +1,118 @@ +package model + +import ( + "fmt" + "net/http" + "strings" +) + +// Error represents an error response. +type Error struct { + Code string `json:"code"` + Paths string `json:"paths,omitempty"` + Message string `json:"message"` +} + +// Error implements the error interface for the Error struct. +func (e *Error) Error() string { + return fmt.Sprintf("Error: Code=%s, Path=%s, Message=%s", e.Code, e.Paths, e.Message) +} + +// SchemaValidationErr represents a collection of schema validation failures. +type SchemaValidationErr struct { + Errors []Error +} + +// Error implements the error interface for SchemaValidationErr. +func (e *SchemaValidationErr) Error() string { + var errorMessages []string + for _, err := range e.Errors { + errorMessages = append(errorMessages, fmt.Sprintf("%s: %s", err.Paths, err.Message)) + } + return strings.Join(errorMessages, "; ") +} + +func (e *SchemaValidationErr) BecknError() *Error { + if len(e.Errors) == 0 { + return &Error{ + Code: http.StatusText(http.StatusBadRequest), + Message: "Schema validation error.", + } + } + + // Collect all error paths and messages + var paths []string + var messages []string + for _, err := range e.Errors { + if err.Paths != "" { + paths = append(paths, err.Paths) + } + messages = append(messages, err.Message) + } + + return &Error{ + Code: http.StatusText(http.StatusBadRequest), + Paths: strings.Join(paths, ";"), + Message: strings.Join(messages, "; "), + } +} + +// SignalidationErr represents a collection of schema validation failures. +type SignValidationErr struct { + error +} + +func NewSignValidationErrf(format string, a ...any) *SignValidationErr { + return &SignValidationErr{fmt.Errorf(format, a...)} +} + +func NewSignValidationErr(e error) *SignValidationErr { + return &SignValidationErr{e} +} + +func (e *SignValidationErr) BecknError() *Error { + return &Error{ + Code: http.StatusText(http.StatusUnauthorized), + Message: "Signature Validation Error: " + e.Error(), + } +} + +// SignalidationErr represents a collection of schema validation failures. +type BadReqErr struct { + error +} + +func NewBadReqErr(err error) *BadReqErr { + return &BadReqErr{err} +} + +func NewBadReqErrf(format string, a ...any) *BadReqErr { + return &BadReqErr{fmt.Errorf(format, a...)} +} + +func (e *BadReqErr) BecknError() *Error { + return &Error{ + Code: http.StatusText(http.StatusBadRequest), + Message: "BAD Request: " + e.Error(), + } +} + +// SignalidationErr represents a collection of schema validation failures. +type NotFoundErr struct { + error +} + +func NewNotFoundErr(err error) *NotFoundErr { + return &NotFoundErr{err} +} + +func NewNotFoundErrf(format string, a ...any) *NotFoundErr { + return &NotFoundErr{fmt.Errorf(format, a...)} +} + +func (e *NotFoundErr) BecknError() *Error { + return &Error{ + Code: http.StatusText(http.StatusNotFound), + Message: "Endpoint not found: " + e.Error(), + } +} diff --git a/pkg/model/error_test.go b/pkg/model/error_test.go new file mode 100644 index 0000000..4213211 --- /dev/null +++ b/pkg/model/error_test.go @@ -0,0 +1,144 @@ +package model + +import ( + "errors" + "net/http" + "testing" +) + +func TestError_Error(t *testing.T) { + err := &Error{ + Code: "400", + Paths: "/path/to/field", + Message: "Invalid value", + } + + expected := "Error: Code=400, Path=/path/to/field, Message=Invalid value" + if err.Error() != expected { + t.Errorf("Expected %s, got %s", expected, err.Error()) + } +} + +func TestSchemaValidationErr_Error(t *testing.T) { + errs := SchemaValidationErr{ + Errors: []Error{ + {Paths: "/field1", Message: "Field is required"}, + {Paths: "/field2", Message: "Invalid format"}, + }, + } + + expected := "/field1: Field is required; /field2: Invalid format" + if errs.Error() != expected { + t.Errorf("Expected %s, got %s", expected, errs.Error()) + } +} + +func TestSchemaValidationErr_BecknError(t *testing.T) { + errs := SchemaValidationErr{ + Errors: []Error{ + {Paths: "/field1", Message: "Field is required"}, + {Paths: "/field2", Message: "Invalid format"}, + }, + } + + result := errs.BecknError() + if result.Code != http.StatusText(http.StatusBadRequest) { + t.Errorf("Expected %s, got %s", http.StatusText(http.StatusBadRequest), result.Code) + } + + expectedPaths := "/field1;/field2" + expectedMessage := "Field is required; Invalid format" + if result.Paths != expectedPaths { + t.Errorf("Expected paths %s, got %s", expectedPaths, result.Paths) + } + if result.Message != expectedMessage { + t.Errorf("Expected message %s, got %s", expectedMessage, result.Message) + } +} + +func TestNewSignValidationErrf(t *testing.T) { + err := NewSignValidationErrf("signature %s", "invalid") + expected := "signature invalid" + if err.Error() != expected { + t.Errorf("Expected %s, got %s", expected, err.Error()) + } +} + +func TestNewSignValidationErr(t *testing.T) { + baseErr := errors.New("invalid signature") + err := NewSignValidationErr(baseErr) + if err.Error() != "invalid signature" { + t.Errorf("Expected %s, got %s", "invalid signature", err.Error()) + } +} + +func TestSignValidationErr_BecknError(t *testing.T) { + err := NewSignValidationErr(errors.New("invalid signature")) + result := err.BecknError() + + expected := "Signature Validation Error: invalid signature" + if result.Code != http.StatusText(http.StatusUnauthorized) { + t.Errorf("Expected %s, got %s", http.StatusText(http.StatusUnauthorized), result.Code) + } + if result.Message != expected { + t.Errorf("Expected %s, got %s", expected, result.Message) + } +} + +func TestNewBadReqErr(t *testing.T) { + baseErr := errors.New("bad request error") + err := NewBadReqErr(baseErr) + if err.Error() != "bad request error" { + t.Errorf("Expected %s, got %s", "bad request error", err.Error()) + } +} + +func TestNewBadReqErrf(t *testing.T) { + err := NewBadReqErrf("missing %s", "field") + expected := "missing field" + if err.Error() != expected { + t.Errorf("Expected %s, got %s", expected, err.Error()) + } +} + +func TestBadReqErr_BecknError(t *testing.T) { + err := NewBadReqErr(errors.New("invalid payload")) + result := err.BecknError() + + expected := "BAD Request: invalid payload" + if result.Code != http.StatusText(http.StatusBadRequest) { + t.Errorf("Expected %s, got %s", http.StatusText(http.StatusBadRequest), result.Code) + } + if result.Message != expected { + t.Errorf("Expected %s, got %s", expected, result.Message) + } +} + +func TestNewNotFoundErr(t *testing.T) { + baseErr := errors.New("resource not found") + err := NewNotFoundErr(baseErr) + if err.Error() != "resource not found" { + t.Errorf("Expected %s, got %s", "resource not found", err.Error()) + } +} + +func TestNewNotFoundErrf(t *testing.T) { + err := NewNotFoundErrf("route %s not found", "/api/data") + expected := "route /api/data not found" + if err.Error() != expected { + t.Errorf("Expected %s, got %s", expected, err.Error()) + } +} + +func TestNotFoundErr_BecknError(t *testing.T) { + err := NewNotFoundErr(errors.New("endpoint not available")) + result := err.BecknError() + + expected := "Endpoint not found: endpoint not available" + if result.Code != http.StatusText(http.StatusNotFound) { + t.Errorf("Expected %s, got %s", http.StatusText(http.StatusNotFound), result.Code) + } + if result.Message != expected { + t.Errorf("Expected %s, got %s", expected, result.Message) + } +} diff --git a/pkg/model/model.go b/pkg/model/model.go new file mode 100644 index 0000000..f5ffe22 --- /dev/null +++ b/pkg/model/model.go @@ -0,0 +1,119 @@ +package model + +import ( + "context" + "fmt" + "net/http" + "net/url" + "time" +) + +// Subscriber represents a unique operational configuration of a trusted platform on a network. +type Subscriber struct { + SubscriberID string `json:"subscriber_id"` + URL string `json:"url" format:"uri"` + Type string `json:"type" enum:"BAP,BPP,BG"` + Domain string `json:"domain"` +} + +// SubscriptionDetails represents subscription details of a Network Participant. +type Subscription struct { + Subscriber `json:",inline"` + KeyID string `json:"key_id" format:"uuid"` + SigningPublicKey string `json:"signing_public_key"` + EncrPublicKey string `json:"encr_public_key"` + ValidFrom time.Time `json:"valid_from" format:"date-time"` + ValidUntil time.Time `json:"valid_until" format:"date-time"` + Status string `json:"status" enum:"INITIATED,UNDER_SUBSCRIPTION,SUBSCRIBED,EXPIRED,UNSUBSCRIBED,INVALID_SSL"` + Created time.Time `json:"created" format:"date-time"` + Updated time.Time `json:"updated" format:"date-time"` + Nonce string +} + +const ( + AuthHeaderSubscriber string = "Authorization" + AuthHeaderGateway string = "X-Gateway-Authorization" + UnaAuthorizedHeaderSubscriber string = "WWW-Authenticate" + UnaAuthorizedHeaderGateway string = "Proxy-Authenticate" +) + +type contextKey string + +// Correctly define MsgIDKey with a variable, not a const +var MsgIDKey = contextKey("message_id") + +type Role string + +const ( + RoleBAP Role = "bap" + RoleBPP Role = "bpp" + RoleGateway Role = "gateway" + RoleRegistery Role = "registery" +) + +// validRoles ensures only allowed values are accepted +var validRoles = map[Role]bool{ + RoleBAP: true, + RoleBPP: true, + RoleGateway: true, + RoleRegistery: true, +} + +// Custom YAML unmarshalling to validate Role names +func (r *Role) UnmarshalYAML(unmarshal func(interface{}) error) error { + var roleName string + if err := unmarshal(&roleName); err != nil { + return err + } + + role := Role(roleName) + if !validRoles[role] { + return fmt.Errorf("invalid Role: %s", roleName) + } + *r = role + return nil +} + +type Route struct { + Type string + URL *url.URL + Publisher string +} + +type StepContext struct { + context.Context + Request *http.Request + Body []byte + Route *Route + SubID string + Role Role + RespHeader http.Header +} + +func (ctx *StepContext) WithContext(newCtx context.Context) { + ctx.Context = newCtx // Update the existing context, keeping all other fields unchanged. +} + +// Status represents the status of an acknowledgment. +type Status string + +const ( + StatusACK Status = "ACK" + StatusNACK Status = "NACK" +) + +// Ack represents an acknowledgment response. +type Ack struct { + Status Status `json:"status"` // ACK or NACK +} + +// Message represents the message object in the response. +type Message struct { + Ack Ack `json:"ack"` + Error *Error `json:"error,omitempty"` +} + +// Response represents the main response structure. +type Response struct { + Message Message `json:"message"` +} diff --git a/pkg/response/response.go b/pkg/response/response.go index 310d06f..053c1f1 100644 --- a/pkg/response/response.go +++ b/pkg/response/response.go @@ -3,7 +3,11 @@ package response import ( "context" "encoding/json" + "errors" "fmt" + "net/http" + + "github.com/beckn/beckn-onix/pkg/model" ) type ErrorType string @@ -13,131 +17,87 @@ const ( InvalidRequestErrorType ErrorType = "INVALID_REQUEST" ) -type BecknRequest struct { - Context map[string]interface{} `json:"context,omitempty"` -} +// type BecknRequest struct { +// Context map[string]interface{} `json:"context,omitempty"` +// } -type Error struct { - Code string `json:"code,omitempty"` - Message string `json:"message,omitempty"` - Paths string `json:"paths,omitempty"` -} - -type Message struct { - Ack struct { - Status string `json:"status,omitempty"` - } `json:"ack,omitempty"` - Error *Error `json:"error,omitempty"` -} - -type BecknResponse struct { - Context map[string]interface{} `json:"context,omitempty"` - Message Message `json:"message,omitempty"` -} - -type ClientFailureBecknResponse struct { - Context map[string]interface{} `json:"context,omitempty"` - Error *Error `json:"error,omitempty"` -} - -var errorMap = map[ErrorType]Error{ - SchemaValidationErrorType: { - Code: "400", - Message: "Schema validation failed", - }, - InvalidRequestErrorType: { - Code: "401", - Message: "Invalid request format", - }, -} - -var DefaultError = Error{ - Code: "500", - Message: "Internal server error", -} - -func Nack(ctx context.Context, tp ErrorType, paths string, body []byte) ([]byte, error) { - var req BecknRequest - if err := json.Unmarshal(body, &req); err != nil { - return nil, fmt.Errorf("failed to parse request: %w", err) - } - - errorObj, ok := errorMap[tp] - if paths != "" { - errorObj.Paths = paths - } - - var response BecknResponse - - if !ok { - response = BecknResponse{ - Context: req.Context, - Message: Message{ - Ack: struct { - Status string `json:"status,omitempty"` - }{ - Status: "NACK", - }, - Error: &DefaultError, - }, - } - } else { - response = BecknResponse{ - Context: req.Context, - Message: Message{ - Ack: struct { - Status string `json:"status,omitempty"` - }{ - Status: "NACK", - }, - Error: &errorObj, - }, - } - } - - return json.Marshal(response) -} - -func Ack(ctx context.Context, body []byte) ([]byte, error) { - var req BecknRequest - if err := json.Unmarshal(body, &req); err != nil { - return nil, fmt.Errorf("failed to parse request: %w", err) - } - - response := BecknResponse{ - Context: req.Context, - Message: Message{ - Ack: struct { - Status string `json:"status,omitempty"` - }{ - Status: "ACK", +func SendAck(w http.ResponseWriter) { + // Create the response object + resp := &model.Response{ + Message: model.Message{ + Ack: model.Ack{ + Status: model.StatusACK, }, }, } - return json.Marshal(response) -} - -func HandleClientFailure(ctx context.Context, tp ErrorType, body []byte) ([]byte, error) { - var req BecknRequest - if err := json.Unmarshal(body, &req); err != nil { - return nil, fmt.Errorf("failed to parse request: %w", err) + // Marshal to JSON + data, err := json.Marshal(resp) + if err != nil { + http.Error(w, "failed to marshal response", http.StatusInternalServerError) + return } - errorObj, ok := errorMap[tp] - var response ClientFailureBecknResponse + // Set headers and write response + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(data) +} - if !ok { - response = ClientFailureBecknResponse{ - Context: req.Context, - Error: &DefaultError, - } - } else { - response = ClientFailureBecknResponse{ - Context: req.Context, - Error: &errorObj, - } +// nack sends a negative acknowledgment (NACK) response with an error message. +func nack(w http.ResponseWriter, err *model.Error, status int) { + // Create the NACK response object + resp := &model.Response{ + Message: model.Message{ + Ack: model.Ack{ + Status: model.StatusNACK, + }, + Error: err, + }, } - return json.Marshal(response) + // Marshal the response to JSON + data, jsonErr := json.Marshal(resp) + if jsonErr != nil { + http.Error(w, "failed to marshal response", http.StatusInternalServerError) + return + } + + // Set headers and write response + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(status) // Assuming NACK means a bad request + w.Write(data) +} + +func internalServerError(ctx context.Context) *model.Error { + return &model.Error{ + Code: http.StatusText(http.StatusInternalServerError), + Message: fmt.Sprintf("Internal server error, MessageID: %s", ctx.Value(model.MsgIDKey)), + } +} + +// SendNack sends a negative acknowledgment (NACK) response with an error message. +func SendNack(ctx context.Context, w http.ResponseWriter, err error) { + var schemaErr *model.SchemaValidationErr + var signErr *model.SignValidationErr + var badReqErr *model.BadReqErr + var notFoundErr *model.NotFoundErr + + switch { + case errors.As(err, &schemaErr): + nack(w, schemaErr.BecknError(), http.StatusBadRequest) + return + case errors.As(err, &signErr): + nack(w, signErr.BecknError(), http.StatusUnauthorized) + return + case errors.As(err, &badReqErr): + nack(w, badReqErr.BecknError(), http.StatusBadRequest) + return + case errors.As(err, ¬FoundErr): + nack(w, notFoundErr.BecknError(), http.StatusNotFound) + return + default: + nack(w, internalServerError(ctx), http.StatusInternalServerError) + return + } } diff --git a/pkg/response/response_test.go b/pkg/response/response_test.go index 242fa72..e09d3b6 100644 --- a/pkg/response/response_test.go +++ b/pkg/response/response_test.go @@ -1,303 +1,152 @@ package response import ( + "bytes" "context" "encoding/json" - "reflect" + "errors" + "net/http" + "net/http/httptest" "testing" + + "github.com/beckn/beckn-onix/pkg/model" ) +func TestSendAck(t *testing.T) { + http.NewRequest("GET", "/", nil) + rr := httptest.NewRecorder() + + SendAck(rr) + + if rr.Code != http.StatusOK { + t.Errorf("expected status code %d, got %d", http.StatusOK, rr.Code) + } + + expected := `{"message":{"ack":{"status":"ACK"}}}` + if rr.Body.String() != expected { + t.Errorf("expected body %s, got %s", expected, rr.Body.String()) + } +} + func TestNack(t *testing.T) { - ctx := context.Background() - tests := []struct { - name string - errorType ErrorType - requestBody string - wantStatus string - wantErrCode string - wantErrMsg string - wantErr bool - path string + name string + err *model.Error + status int + expected string }{ { - name: "Schema validation error", - errorType: SchemaValidationErrorType, - requestBody: `{"context": {"domain": "test-domain", "location": "test-location"}}`, - wantStatus: "NACK", - wantErrCode: "400", - wantErrMsg: "Schema validation failed", - wantErr: false, - path: "test", + name: "Schema Validation Error", + err: &model.Error{ + Code: "BAD_REQUEST", + Paths: "/test/path", + Message: "Invalid schema", + }, + status: http.StatusBadRequest, + expected: `{"message":{"ack":{"status":"NACK"},"error":{"code":"BAD_REQUEST","paths":"/test/path","message":"Invalid schema"}}}`, }, { - name: "Invalid request error", - errorType: InvalidRequestErrorType, - requestBody: `{"context": {"domain": "test-domain"}}`, - wantStatus: "NACK", - wantErrCode: "401", - wantErrMsg: "Invalid request format", - wantErr: false, - path: "test", - }, - { - name: "Unknown error type", - errorType: "UNKNOWN_ERROR", - requestBody: `{"context": {"domain": "test-domain"}}`, - wantStatus: "NACK", - wantErrCode: "500", - wantErrMsg: "Internal server error", - wantErr: false, - path: "test", - }, - { - name: "Empty request body", - errorType: SchemaValidationErrorType, - requestBody: `{}`, - wantStatus: "NACK", - wantErrCode: "400", - wantErrMsg: "Schema validation failed", - wantErr: false, - path: "test", - }, - { - name: "Invalid JSON", - errorType: SchemaValidationErrorType, - requestBody: `{invalid json}`, - wantErr: true, - path: "test", - }, - { - name: "Complex nested context", - errorType: SchemaValidationErrorType, - requestBody: `{"context": {"domain": "test-domain", "nested": {"key1": "value1", "key2": 123}}}`, - wantStatus: "NACK", - wantErrCode: "400", - wantErrMsg: "Schema validation failed", - wantErr: false, - path: "test", + name: "Internal Server Error", + err: &model.Error{ + Code: "INTERNAL_SERVER_ERROR", + Message: "Something went wrong", + }, + status: http.StatusInternalServerError, + expected: `{"message":{"ack":{"status":"NACK"},"error":{"code":"INTERNAL_SERVER_ERROR","message":"Something went wrong"}}}`, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - resp, err := Nack(ctx, tt.errorType, tt.path, []byte(tt.requestBody)) + http.NewRequest("POST", "/", nil) + rr := httptest.NewRecorder() - if (err != nil) != tt.wantErr { - t.Errorf("Nack() error = %v, wantErr %v", err, tt.wantErr) - return + nack(rr, tt.err, tt.status) + + if rr.Code != tt.status { + t.Errorf("expected status code %d, got %d", tt.status, rr.Code) } - if tt.wantErr && err != nil { - return - } - - var becknResp BecknResponse - if err := json.Unmarshal(resp, &becknResp); err != nil { - t.Errorf("Failed to unmarshal response: %v", err) - return - } - - if becknResp.Message.Ack.Status != tt.wantStatus { - t.Errorf("Nack() status = %v, want %v", becknResp.Message.Ack.Status, tt.wantStatus) - } - - if becknResp.Message.Error.Code != tt.wantErrCode { - t.Errorf("Nack() error code = %v, want %v", becknResp.Message.Error.Code, tt.wantErrCode) - } - - if becknResp.Message.Error.Message != tt.wantErrMsg { - t.Errorf("Nack() error message = %v, want %v", becknResp.Message.Error.Message, tt.wantErrMsg) - } - - var origReq BecknRequest - if err := json.Unmarshal([]byte(tt.requestBody), &origReq); err == nil { - if !compareContexts(becknResp.Context, origReq.Context) { - t.Errorf("Nack() context not preserved, got = %v, want %v", becknResp.Context, origReq.Context) - } + body := rr.Body.String() + if body != tt.expected { + t.Errorf("expected body %s, got %s", tt.expected, body) } }) } } -func TestAck(t *testing.T) { - ctx := context.Background() +func TestSendNack(t *testing.T) { + ctx := context.WithValue(context.Background(), model.MsgIDKey, "123456") tests := []struct { - name string - requestBody string - wantStatus string - wantErr bool + name string + err error + expected string + status int }{ { - name: "Valid request", - requestBody: `{"context": {"domain": "test-domain", "location": "test-location"}}`, - wantStatus: "ACK", - wantErr: false, + name: "SchemaValidationErr", + err: &model.SchemaValidationErr{ + Errors: []model.Error{ + {Paths: "/path1", Message: "Error 1"}, + {Paths: "/path2", Message: "Error 2"}, + }, + }, + status: http.StatusBadRequest, + expected: `{"message":{"ack":{"status":"NACK"},"error":{"code":"Bad Request","paths":"/path1;/path2","message":"Error 1; Error 2"}}}`, }, { - name: "Empty context", - requestBody: `{"context": {}}`, - wantStatus: "ACK", - wantErr: false, + name: "SignValidationErr", + err: model.NewSignValidationErr(errors.New("signature invalid")), + status: http.StatusUnauthorized, + expected: `{"message":{"ack":{"status":"NACK"},"error":{"code":"Unauthorized","message":"Signature Validation Error: signature invalid"}}}`, }, { - name: "Invalid JSON", - requestBody: `{invalid json}`, - wantErr: true, + name: "BadReqErr", + err: model.NewBadReqErr(errors.New("bad request error")), + status: http.StatusBadRequest, + expected: `{"message":{"ack":{"status":"NACK"},"error":{"code":"Bad Request","message":"BAD Request: bad request error"}}}`, }, { - name: "Complex nested context", - requestBody: `{"context": {"domain": "test-domain", "nested": {"key1": "value1", "key2": 123, "array": [1,2,3]}}}`, - wantStatus: "ACK", - wantErr: false, + name: "NotFoundErr", + err: model.NewNotFoundErr(errors.New("endpoint not found")), + status: http.StatusNotFound, + expected: `{"message":{"ack":{"status":"NACK"},"error":{"code":"Not Found","message":"Endpoint not found: endpoint not found"}}}`, + }, + { + name: "InternalServerError", + err: errors.New("unexpected error"), + status: http.StatusInternalServerError, + expected: `{"message":{"ack":{"status":"NACK"},"error":{"code":"Internal Server Error","message":"Internal server error, MessageID: 123456"}}}`, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - resp, err := Ack(ctx, []byte(tt.requestBody)) + http.NewRequest("POST", "/", nil) + rr := httptest.NewRecorder() - if (err != nil) != tt.wantErr { - t.Errorf("Ack() error = %v, wantErr %v", err, tt.wantErr) - return + SendNack(ctx, rr, tt.err) + + if rr.Code != tt.status { + t.Errorf("expected status code %d, got %d", tt.status, rr.Code) } - if tt.wantErr && err != nil { - return - } + var actual map[string]interface{} + json.Unmarshal(rr.Body.Bytes(), &actual) - var becknResp BecknResponse - if err := json.Unmarshal(resp, &becknResp); err != nil { - t.Errorf("Failed to unmarshal response: %v", err) - return - } + var expected map[string]interface{} + json.Unmarshal([]byte(tt.expected), &expected) - if becknResp.Message.Ack.Status != tt.wantStatus { - t.Errorf("Ack() status = %v, want %v", becknResp.Message.Ack.Status, tt.wantStatus) - } - - if becknResp.Message.Error != nil { - t.Errorf("Ack() should not have error, got %v", becknResp.Message.Error) - } - - var origReq BecknRequest - if err := json.Unmarshal([]byte(tt.requestBody), &origReq); err == nil { - if !compareContexts(becknResp.Context, origReq.Context) { - t.Errorf("Ack() context not preserved, got = %v, want %v", becknResp.Context, origReq.Context) - } + if !compareJSON(expected, actual) { + t.Errorf("expected body %s, got %s", tt.expected, rr.Body.String()) } }) } } -func TestHandleClientFailure(t *testing.T) { - ctx := context.Background() - - tests := []struct { - name string - errorType ErrorType - requestBody string - wantErrCode string - wantErrMsg string - wantErr bool - }{ - { - name: "Schema validation error", - errorType: SchemaValidationErrorType, - requestBody: `{"context": {"domain": "test-domain", "location": "test-location"}}`, - wantErrCode: "400", - wantErrMsg: "Schema validation failed", - wantErr: false, - }, - { - name: "Invalid request error", - errorType: InvalidRequestErrorType, - requestBody: `{"context": {"domain": "test-domain"}}`, - wantErrCode: "401", - wantErrMsg: "Invalid request format", - wantErr: false, - }, - { - name: "Unknown error type", - errorType: "UNKNOWN_ERROR", - requestBody: `{"context": {"domain": "test-domain"}}`, - wantErrCode: "500", - wantErrMsg: "Internal server error", - wantErr: false, - }, - { - name: "Invalid JSON", - errorType: SchemaValidationErrorType, - requestBody: `{invalid json}`, - wantErr: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - resp, err := HandleClientFailure(ctx, tt.errorType, []byte(tt.requestBody)) - - if (err != nil) != tt.wantErr { - t.Errorf("HandleClientFailure() error = %v, wantErr %v", err, tt.wantErr) - return - } - - if tt.wantErr && err != nil { - return - } - - var failureResp ClientFailureBecknResponse - if err := json.Unmarshal(resp, &failureResp); err != nil { - t.Errorf("Failed to unmarshal response: %v", err) - return - } - - if failureResp.Error.Code != tt.wantErrCode { - t.Errorf("HandleClientFailure() error code = %v, want %v", failureResp.Error.Code, tt.wantErrCode) - } - - if failureResp.Error.Message != tt.wantErrMsg { - t.Errorf("HandleClientFailure() error message = %v, want %v", failureResp.Error.Message, tt.wantErrMsg) - } - - var origReq BecknRequest - if err := json.Unmarshal([]byte(tt.requestBody), &origReq); err == nil { - if !compareContexts(failureResp.Context, origReq.Context) { - t.Errorf("HandleClientFailure() context not preserved, got = %v, want %v", failureResp.Context, origReq.Context) - } - } - }) - } -} - -func TestErrorMap(t *testing.T) { - - expectedTypes := []ErrorType{ - SchemaValidationErrorType, - InvalidRequestErrorType, - } - - for _, tp := range expectedTypes { - if _, exists := errorMap[tp]; !exists { - t.Errorf("ErrorType %v not found in errorMap", tp) - } - } - - if DefaultError.Code != "500" || DefaultError.Message != "Internal server error" { - t.Errorf("DefaultError not set correctly, got code=%v, message=%v", DefaultError.Code, DefaultError.Message) - } -} - -func compareContexts(c1, c2 map[string]interface{}) bool { - - if c1 == nil && c2 == nil { - return true - } - - if c1 == nil && len(c2) == 0 || c2 == nil && len(c1) == 0 { - return true - } - - return reflect.DeepEqual(c1, c2) +func compareJSON(expected, actual map[string]interface{}) bool { + expectedBytes, _ := json.Marshal(expected) + actualBytes, _ := json.Marshal(actual) + return bytes.Equal(expectedBytes, actualBytes) }