Files
hardlink/paymentapi/client_test.go

147 lines
6.7 KiB
Go

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)
}
}
}