package paymentapi import ( "context" "encoding/json" "errors" "fmt" "io" "net/http" "net/http/httptest" "reflect" "strings" "testing" ) func TestExecuteUsesOneContractForSaleAndPreauth(t *testing.T) { for _, operation := range []string{Sale, Preauth} { t.Run(operation, func(t *testing.T) { input := Request{Reference: "SYNTH-BOOK", Amount: 2500, Currency: "GBP", CheckoutDate: "12 Oct 2030"} if operation == Sale { input.RequiredPreauth = &PreauthRequirement{Amount: 5000, CheckoutDate: "12 Oct 2030"} } calls := 0 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { calls++ if r.Method != http.MethodPost || r.URL.Path != "/api/payment/"+operation { t.Errorf("Execute(%q) sent %s %s, want POST modern operation", operation, r.Method, r.URL.Path) } var got Request if err := json.NewDecoder(r.Body).Decode(&got); err != nil { t.Error(err) return } if !reflect.DeepEqual(got, input) { t.Errorf("Execute(%q) request=%+v, want %+v", operation, got, input) } if r.Header.Get("Accept") != "application/x-ndjson" || r.Header.Get("Content-Type") != "application/json" { t.Errorf("Execute(%q) headers=%v, want JSON request/NDJSON response", operation, r.Header) } w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8") encoder := json.NewEncoder(w) for _, frame := range []Frame{{Type: "status", Code: "PAYMENT_PROCESSING"}, {Type: "status", Code: "FUTURE_OBSERVATIONAL_CODE"}, {Type: "result", Result: &Result{Outcome: "approved", HTTPStatus: 200, Provider: "FutureProcessor", AmountMinor: 2500, TransactionReference: "SYNTH-REFERENCE", CardType: "Visa"}}} { if err := encoder.Encode(frame); err != nil { t.Error(err) return } } })) t.Cleanup(server.Close) var progress []string got, err := Execute(context.Background(), server.Client(), server.URL, operation, input, func(code string) { progress = append(progress, code) }) if err != nil || got.Outcome != "approved" || got.TransactionReference != "SYNTH-REFERENCE" || calls != 1 { t.Fatalf("Execute(%q)=%+v/%v calls=%d, want one approved request", operation, got, err, calls) } if !reflect.DeepEqual(progress, []string{"PAYMENT_PROCESSING", "FUTURE_OBSERVATIONAL_CODE"}) { t.Errorf("Execute(%q) progress=%v, want observed codes in order", operation, progress) } }) } } type testTransport func(*http.Request) (*http.Response, error) func (f testTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } type trackedBody struct { io.Reader closed bool } func (b *trackedBody) Close() error { b.closed = true; return nil } func TestExecuteRejectsIncompleteOrContradictoryResultsAndClosesBodies(t *testing.T) { tests := []struct { name, body string status int }{ {"eof", `{"type":"status","code":"PAYMENT_APPROVED"}`, 200}, {"malformed", `{"type":`, 200}, {"legacy", `{"type":"result","response":{"status":{"code":200},"data":"/successful"}}`, 200}, {"mixed", `{"type":"result","result":{"outcome":"approved","httpStatus":200},"response":{}}`, 200}, {"empty_status", `{"type":"status","code":""}`, 200}, {"status_result", `{"type":"status","code":"X","result":{"outcome":"approved","httpStatus":200}}`, 200}, {"unknown_frame", `{"type":"other"}`, 200}, {"unknown_outcome", `{"type":"result","result":{"outcome":"maybe","httpStatus":200}}`, 200}, {"invalid_status", `{"type":"result","result":{"outcome":"approved","httpStatus":0}}`, 200}, {"http_approval_conflict", `{"type":"result","result":{"outcome":"approved","httpStatus":200}}`, 502}, {"operation_approval_conflict", `{"type":"result","result":{"outcome":"approved","httpStatus":502}}`, 200}, {"retryable_approval", `{"type":"result","result":{"outcome":"approved","httpStatus":200,"retryable":true}}`, 200}, {"retryable_unknown", `{"type":"result","result":{"outcome":"unknown","httpStatus":200,"retryable":true}}`, 200}, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { body := &trackedBody{Reader: strings.NewReader(test.body)} calls := 0 client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { calls++ return &http.Response{StatusCode: test.status, Header: http.Header{"Content-Type": []string{"application/x-ndjson"}}, Body: body}, nil })} _, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil) if err == nil || !body.closed || calls != 1 { t.Errorf("Execute(%s) error=%v closed=%t calls=%d, want error/closed/one request", test.name, err, body.closed, calls) } }) } } func TestExecuteProgressCannotApproveOrRetryUnknown(t *testing.T) { client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"application/x-ndjson"}}, Body: io.NopCloser(strings.NewReader("{\"type\":\"status\",\"code\":\"PAYMENT_APPROVED\"}\n{\"type\":\"result\",\"result\":{\"outcome\":\"unknown\",\"httpStatus\":200}}"))}, nil })} got, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil) if err != nil || got.Outcome != "unknown" || got.Retryable { t.Errorf("Execute(progress approved then unknown)=%+v/%v, want nonretryable unknown", got, err) } } func TestExecutePreservesCancellationWithoutLeakingTransportDiagnostics(t *testing.T) { for _, cause := range []error{context.Canceled, context.DeadlineExceeded} { t.Run(cause.Error(), func(t *testing.T) { calls := 0 client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { calls++ return nil, fmt.Errorf("synthetic-private-payload: %w", cause) })} _, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil) if !errors.Is(err, cause) || strings.Contains(err.Error(), "synthetic-private-payload") || calls != 1 { t.Errorf("Execute(transport %v)=%v calls=%d, want sanitized wrapped cause and one attempt", cause, err, calls) } }) } } func TestExecuteRejectsInvalidRequestsWithoutDispatch(t *testing.T) { for _, test := range []struct { operation string amount int64 }{{Sale, 0}, {Sale, -1}, {Preauth, -1}, {"refund", 1}} { calls := 0 client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { calls++; return nil, errors.New("must not dispatch") })} _, err := Execute(context.Background(), client, "http://synthetic.invalid", test.operation, Request{Amount: test.amount}, nil) if err == nil || calls != 0 { t.Errorf("Execute(%q,%d) error=%v calls=%d, want validation error without dispatch", test.operation, test.amount, err, calls) } } }