package handlers import ( "bytes" "context" "encoding/json" "encoding/xml" "errors" "io" "net/http" "net/http/httptest" "net/url" "reflect" "strings" "sync" "sync/atomic" "testing" "time" "gitea.futuresens.co.uk/futuresens/cmstypes" "gitea.futuresens.co.uk/futuresens/hardlink/v2/config" "gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/creditcall" "gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/types" "gitea.futuresens.co.uk/futuresens/hardlink/v2/paymentstatus" ) type failedCreditCallBody struct{ closed *bool } func (b failedCreditCallBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF } func (b failedCreditCallBody) Close() error { *b.closed = true; return nil } func TestCreditCallConfirmationReadFailureAndHTTPStatus(t *testing.T) { for _, failFirstRead := range []bool{false, true} { calls, receipts, firstClosed := 0, 0, false app := &App{cfg: &config.ConfigRec{}, creditCallReceipt: func(string) { receipts++ }} app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { calls++ if r.URL.Path != "/confirm-transaction/" { t.Errorf("confirmation path=%s", r.URL.Path) } deadline, ok := r.Context().Deadline() if !ok || time.Until(deadline) < 299*time.Second { t.Errorf("confirmation call has no fresh 300-second deadline: %v", deadline) } var body io.ReadCloser = io.NopCloser(strings.NewReader(chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved"}))) if failFirstRead && calls == 1 { body = failedCreditCallBody{closed: &firstClosed} } // Legacy confirmation ignores HTTP status when the body can be read. return &http.Response{StatusCode: http.StatusServiceUnavailable, Body: body}, nil }) outcome := app.executeCreditCallSale(cmstypes.TransactionRec{AmountMinorUnits: "1234"}, func(*http.Client) (creditcall.TransactionResultXML, error) { return creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{{Key: types.TransactionResult, Value: "Approved"}, {Key: types.Reference, Value: "ref"}}}, nil }) wantCalls := 1 if failFirstRead { wantCalls = 2 } if calls != wantCalls || receipts != 1 || !outcome.Approved || (failFirstRead && !firstClosed) { t.Errorf("readFailure=%v calls/receipts/approved/closed=%d/%d/%v/%v", failFirstRead, calls, receipts, outcome.Approved, firstClosed) } } } func TestCreditCallStreamFailureNeverRestartsOrConfirms(t *testing.T) { calls := 0 app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) { calls++ if r.URL.Path != "/start-transaction-stream/" { t.Errorf("unexpected fallback/confirmation %s", r.URL.Path) } io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n{partial") }) app.creditCallReceipt = func(string) { t.Error("invalid upstream stream printed receipt") } recorder := httptest.NewRecorder() app.salePayment(recorder, saleRequest(true)) frames := decodePaymentStream(t, recorder.Body) if calls != 1 || len(frames) != 2 || frames[1].Result == nil || frames[1].Result.Outcome != "unknown" || frames[1].Result.HTTPStatus != 502 { t.Errorf("malformed stream calls=%d frames=%+v", calls, frames) } } func TestCreditCallStructuredFieldsExcludeRawData(t *testing.T) { result := (creditCallSaleOutcome{Approved: true, Payment: creditcall.PaymentResult{Fields: map[string]string{ types.Reference: "ref", types.PanMasked: "1234567890123456", types.CardHash: "hash", types.CardReference: "card-ref", "PAN": "pan-secret", "CVV": "cvv-secret", "PIN": "pin-secret", "TRACK_DATA": "track-secret", types.ReceiptDataCardholder: "receipt-secret", }}}).streamResult(creditCallInitialResult{kind: creditCallInitialApproved}) body, err := json.Marshal(result) if err != nil { t.Fatal(err) } for _, forbidden := range []string{"1234567890123456", "pan-secret", "cvv-secret", "pin-secret", "track-secret", "receipt-secret", "/successful", "/unsuccessful"} { if bytes.Contains(body, []byte(forbidden)) { t.Errorf("structured result exposed %q", forbidden) } } if result.CardHash != "hash" || result.CardReference != "card-ref" || result.TransactionReference != "ref" { t.Errorf("required identifiers missing: %+v", result) } } type blockedPaymentWriter struct { *httptest.ResponseRecorder started chan struct{} release chan struct{} once sync.Once } func (w *blockedPaymentWriter) Write(data []byte) (int, error) { w.once.Do(func() { close(w.started) }) <-w.release return w.ResponseRecorder.Write(data) } func TestCreditCallBackpressureCannotBlockFinalizationOrLoseFinal(t *testing.T) { nativeRelease, receiptPrinted := make(chan struct{}), make(chan struct{}) var nativeOnce, deliveryOnce sync.Once app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/confirm-transaction/" { io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved"})) return } line := "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n" io.WriteString(w, line) w.(http.Flusher).Flush() <-nativeRelease for i := 0; i < 1000; i++ { io.WriteString(w, line) } io.WriteString(w, "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"ref\"}}\n") }) app.creditCallReceipt = func(string) { close(receiptPrinted) } writer := &blockedPaymentWriter{ResponseRecorder: httptest.NewRecorder(), started: make(chan struct{}), release: make(chan struct{})} t.Cleanup(func() { nativeOnce.Do(func() { close(nativeRelease) }) deliveryOnce.Do(func() { close(writer.release) }) }) done := make(chan struct{}) go func() { app.salePayment(writer, saleRequest(true)); close(done) }() select { case <-writer.started: case <-time.After(5 * time.Second): t.Fatal("progress was not live") } nativeOnce.Do(func() { close(nativeRelease) }) select { case <-receiptPrinted: case <-time.After(5 * time.Second): t.Fatal("blocked writer stopped financial finalization") } deliveryOnce.Do(func() { close(writer.release) }) select { case <-done: case <-time.After(5 * time.Second): t.Fatal("stream did not deliver final") } frames := decodePaymentStream(t, writer.Body) if len(frames) != 130 || frames[len(frames)-1].Result == nil || frames[len(frames)-1].Result.Outcome != "approved" { t.Errorf("backpressure frames=%d, last=%+v, want 129 statuses and final approval", len(frames), frames[len(frames)-1]) } } type creditCallRoundTrip func(*http.Request) (*http.Response, error) func (f creditCallRoundTrip) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) } func chipDNAFixture(t *testing.T, fields map[string]string) string { t.Helper() var result creditcall.TransactionResultXML for key, value := range fields { result.Entries = append(result.Entries, creditcall.EntryXML{Key: key, Value: value}) } data, err := xml.Marshal(result) if err != nil { t.Fatal(err) } return string(data) } func newCreditCallTestApp(t *testing.T, handler http.HandlerFunc) *App { t.Helper() server := httptest.NewServer(handler) t.Cleanup(server.Close) target, err := url.Parse(server.URL) if err != nil { t.Fatal(err) } app := &App{isPayment: true, cfg: &config.ConfigRec{TimeoutSeconds: 1}, creditCallTransport: creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { clone := r.Clone(r.Context()) clone.URL.Scheme, clone.URL.Host = target.Scheme, target.Host return server.Client().Transport.RoundTrip(clone) }), } app.EnableCreditCallStreaming() return app } func saleRequest(stream bool) *http.Request { if stream { r := httptest.NewRequest(http.MethodPost, "/api/payment/sale", strings.NewReader(`{"amount":1234}`)) r.Header.Set("Content-Type", "application/json") return r } r := httptest.NewRequest(http.MethodPost, "/takepayment", strings.NewReader(`1234Sale`)) r.Header.Set("Content-Type", "text/xml") return r } func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) { for _, test := range []struct { name, startResult, confirmation string confirms int approved bool receipt string }{ {"approved", "Approved", "Approved", 1, true, "confirm receipt"}, {"declined", "Declined", "", 0, false, "start receipt"}, {"cancelled", "Cancelled", "", 0, false, "start receipt"}, {"timeout", "TIMEOUT", "", 0, false, "start receipt"}, {"confirmation declined", "Approved", "Declined", 1, false, "confirm receipt"}, {"confirmation omissions", "Approved", "omitted", 1, false, "start receipt"}, {"malformed confirmation", "Approved", "malformed", 1, false, "start receipt"}, } { t.Run(test.name, func(t *testing.T) { fields := map[string]string{types.TransactionResult: test.startResult, types.Reference: "native-ref", types.CardType: "Visa", types.PanMasked: "************1234", types.ExpiryDate: "1228", types.CardHash: "hash", types.CardReference: "card-ref", types.ReceiptDataCardholder: "start receipt"} var legacy cmstypes.ResponseRec for _, streaming := range []bool{false, true} { var starts, confirms atomic.Int32 var receipts []string app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) { switch r.URL.Path { case "/start-transaction/": starts.Add(1) io.WriteString(w, chipDNAFixture(t, fields)) case "/start-transaction-stream/": starts.Add(1) var input struct{ Amount, TransactionType string } if err := json.NewDecoder(r.Body).Decode(&input); err != nil || input.Amount != "1234" || input.TransactionType != "Sale" { t.Errorf("stream start input = %+v, error %v", input, err) } io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n") io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n") io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"Approved\"}\n") json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields}) json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields}) case "/confirm-transaction/": confirms.Add(1) var input creditcall.ConfirmTransactionRequest if err := xml.NewDecoder(r.Body).Decode(&input); err != nil || input.Amount != "1234" || input.Reference != "native-ref" { t.Errorf("confirmation input = %+v, error %v", input, err) } switch test.confirmation { case "omitted": io.WriteString(w, "") case "malformed": io.WriteString(w, "") default: io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: test.confirmation, types.ReceiptDataCardholder: "confirm receipt"})) } default: t.Errorf("unexpected ChipDNA path %q", r.URL.Path) } }) app.creditCallReceipt = func(receipt string) { receipts = append(receipts, receipt) } if got := app.creditCallClient().Timeout; got != 300*time.Second { t.Fatalf("per-call timeout = %v, want 300s", got) } recorder := httptest.NewRecorder() if streaming { app.salePayment(recorder, saleRequest(true)) } else { app.takePayment(recorder, saleRequest(false)) } if starts.Load() != 1 || int(confirms.Load()) != test.confirms { t.Errorf("stream=%v starts/confirms=%d/%d, want 1/%d", streaming, starts.Load(), confirms.Load(), test.confirms) } if !reflect.DeepEqual(receipts, []string{test.receipt}) { t.Errorf("stream=%v receipts=%v, want [%s]", streaming, receipts, test.receipt) } if !streaming { if err := json.Unmarshal(recorder.Body.Bytes(), &legacy); err != nil { t.Fatal(err) } if strings.HasPrefix(legacy.Data, "/successful") != test.approved { t.Errorf("legacy result = %+v, approved want %v", legacy, test.approved) } continue } frames := decodePaymentStream(t, recorder.Body) if len(frames) != 3 || frames[0].Code != paymentstatus.PresentCard || frames[1].Code != paymentstatus.PleaseWait || frames[2].Result == nil { t.Fatalf("frames = %+v, want two ordered hints and one final", frames) } final := frames[2].Result if final.HTTPStatus != http.StatusOK || (final.Outcome == "approved") != test.approved { t.Errorf("structured final = %+v, legacy = %+v", final, legacy) } parsed, err := url.Parse(legacy.Data) if err != nil { t.Fatal(err) } if test.approved { if final.TransactionReference != "native-ref" || final.CardType != "Visa" || final.MaskedCardNumber != "************1234" || final.CardHash != "hash" || final.CardReference != "card-ref" || final.ExpiryDate != "1228" { t.Errorf("retained structured fields = %+v", final) } } else if final.Outcome == "approved" { t.Errorf("structured message = %q, legacy description = %q", final.Message, parsed.Query().Get("Description")) } } }) } } func TestCreditCallFreshConfirmationResults(t *testing.T) { fixtures := map[string]creditCallDiagnosticFixture{} for _, fixture := range creditCallDiagnosticFixtures() { fixtures[fixture.name] = fixture } for _, tc := range []struct { name, outcome string amount int64 }{ {"confirmation_xml/mixed_case", "approved", 1234}, {"confirmation_xml/omitted", "unknown", 1234}, {"confirmation_xml/empty_body", "unknown", 1234}, {"confirmation_xml/whitespace_body", "unknown", 1234}, {"confirmation_xml/malformed_retains_approval", "unknown", 1234}, {"confirmation_xml/malformed_after_approved", "unknown", 1234}, {"confirmation_xml/malformed_after_error", "unknown", 1234}, {"confirmation_xml/malformed_after_declined", "unknown", 1234}, {"confirmation_xml/wrong_root", "unknown", 1234}, {"confirmation_xml/sdk_only_disconnected", "unknown", 1234}, {"confirmation_xml/sdk_only_not_found", "unknown", 1234}, {"confirmation_xml/duplicate_approved_declined", "unknown", 1234}, {"confirmation_xml/duplicate_declined_approved", "approved", 1234}, {"confirmation_xml/duplicate_error_approved", "approved", 1234}, {"confirmation_xml/duplicate_approved_empty", "unknown", 1234}, {"confirmation_xml/duplicate_empty_approved", "approved", 1234}, {"confirmation_xml/duplicate_approved_error", "unknown", 1234}, {"confirmation_result/DECLINED", "unknown", 1234}, {"confirmation_result/ERROR", "unknown", 1234}, {"confirmation_result/CANCELLED", "unknown", 1234}, {"confirmation_result/CANCELED", "unknown", 1234}, {"confirmation_result/TIMEOUT", "unknown", 1234}, {"confirmation_result/UNKNOWN", "unknown", 1234}, {"confirmation_result/", "unknown", 1234}, {"confirmation_metadata/returned_amount", "approved", 3100}, {"confirmation_metadata/overrides", "approved", 2500}, {"confirmation_metadata/empty_overrides", "approved", 3100}, } { for _, legacy := range []bool{false, true} { mode := "modern" if legacy { mode = "legacy" } t.Run(mode+"/"+tc.name, func(t *testing.T) { fixture, ok := fixtures["sale/"+tc.name] if !ok { t.Fatalf("missing confirmation fixture %q", tc.name) } got := captureCreditCallDiagnostic(t, fixture, legacy) if len(got.Requests) != 2 { t.Fatalf("Sale(%s) requests=%+v, want one start and one confirmation", tc.name, got.Requests) } if got.HTTPStatus != http.StatusOK || got.Requests[1].Path != "/confirm-transaction/" { t.Errorf("Sale(%s) HTTP/requests=%d/%+v, want HTTP 200, one start and one confirmation", tc.name, got.HTTPStatus, got.Requests) } for _, request := range got.Requests { if !request.FreshCallDeadline || request.Method != http.MethodPost { t.Errorf("Sale(%s) request=%+v, want POST with an independent 300-second timeout", tc.name, request) } } var confirmation creditcall.ConfirmTransactionRequest if err := xml.Unmarshal([]byte(got.Requests[1].Body), &confirmation); err != nil { t.Fatal(err) } if confirmation.Amount != "1234" || confirmation.Reference != "SYNTH-STAGE2" { t.Errorf("Sale(%s) confirmation=%+v, want the original requested amount and authorization reference", tc.name, confirmation) } if legacy { if strings.HasPrefix(got.Legacy.Data, "/successful?") != (tc.outcome == "approved") { t.Errorf("Sale(%s) legacy=%+v, want success only for fresh approval", tc.name, got.Legacy) } if fixture.correctedConfirmation && (got.Legacy.Status.Code != http.StatusOK || got.Legacy.Status.Message != "unknown" || got.Legacy.Data != "/unsuccessful?Description=Transaction+unknown&MsgType=error") { t.Errorf("Sale(%s) legacy=%+v, want unchanged status code and explicit uncertainty failure response", tc.name, got.Legacy) } } else if got.Final.Outcome != tc.outcome || got.Final.Retryable || got.Final.HTTPStatus != http.StatusOK || got.Final.AmountMinor != tc.amount || got.Final.Reason != fixture.reason || got.Final.Message != fixture.message { t.Errorf("Sale(%s) final=%+v, want %s/nonretryable/HTTP200/amount%d and %q/%q", tc.name, got.Final, tc.outcome, tc.amount, fixture.reason, fixture.message) } wantReceipt := "synthetic initial receipt" if tc.name == "confirmation_metadata/overrides" { wantReceipt = "synthetic confirmation receipt" } if tc.name == "confirmation_metadata/empty_overrides" { wantReceipt = "" } if !reflect.DeepEqual(got.Receipts, []string{wantReceipt}) || got.PersistenceCount != 0 { t.Errorf("Sale(%s) receipts/persistence=%v/%d, want [%q]/0", tc.name, got.Receipts, got.PersistenceCount, wantReceipt) } }) } } } func TestCreditCallSaleConfirmationPreservesMergedFields(t *testing.T) { for _, tc := range []struct { name, rawXML, receipt string confirmation map[string]string approved bool }{ {name: "minimal approval", confirmation: map[string]string{types.TransactionResult: "APPROVED"}, receipt: "synthetic initial receipt", approved: true}, {name: "confirmation overrides", confirmation: map[string]string{types.TransactionResult: "APPROVED", types.Reference: "SYNTH-CONFIRMED", types.TotalAmount: "2500", types.CardHash: "", types.ReceiptDataCardholder: "synthetic confirmation receipt"}, receipt: "synthetic confirmation receipt", approved: true}, {name: "SDK-only uncertainty", confirmation: map[string]string{types.Errors: "ClientNotConnectedToServer"}, receipt: "synthetic initial receipt"}, {name: "partial approved XML", rawXML: "TRANSACTION_RESULTAPPROVED", receipt: "synthetic initial receipt"}, } { t.Run(tc.name, func(t *testing.T) { initial := creditCallDiagnosticFields("APPROVED", "") initial[types.TotalAmount] = "3100" initial["AUTH_DATE_TIME"], initial["CARDEASE_REFERENCE"] = "20300101120000", "synthetic-authorization" expected := map[string]string{} for key, value := range initial { if key != types.ReceiptDataCardholder { expected[key] = value } } for key, value := range tc.confirmation { if key != types.ReceiptDataCardholder { expected[key] = value } } var receipts []string starts, confirms := 0, 0 body := &creditCallDiagnosticBody{} app := &App{cfg: &config.ConfigRec{}, creditCallReceipt: func(receipt string) { receipts = append(receipts, receipt) }} app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { confirms++ if r.URL.Path != "/confirm-transaction/" { t.Errorf("unexpected confirmation path %q", r.URL.Path) } wire := tc.rawXML if wire == "" { wire = chipDNAFixture(t, tc.confirmation) } body.Reader = strings.NewReader(wire) return &http.Response{StatusCode: http.StatusOK, Body: body}, nil }) outcome := app.executeCreditCallSale(cmstypes.TransactionRec{AmountMinorUnits: "1234"}, func(*http.Client) (creditcall.TransactionResultXML, error) { starts++ var result creditcall.TransactionResultXML for key, value := range initial { result.Entries = append(result.Entries, creditcall.EntryXML{Key: key, Value: value}) } return result, nil }) if outcome.Approved != tc.approved || !reflect.DeepEqual(outcome.Payment.Fields, expected) || outcome.Payment.CardholderReceipt != tc.receipt { t.Errorf("Sale(%s) approved/fields/receipt=%t/%v/%q, want %t/%v/%q", tc.name, outcome.Approved, outcome.Payment.Fields, outcome.Payment.CardholderReceipt, tc.approved, expected, tc.receipt) } if !tc.approved && (outcome.Status.Message != "unknown" || outcome.FailureType != "unknown" || outcome.Payment.Status.Message != "APPROVED") { t.Errorf("Sale(%s) status/failure/payment status=%+v/%q/%+v, want uncertainty without mutating merged authorization evidence", tc.name, outcome.Status, outcome.FailureType, outcome.Payment.Status) } if starts != 1 || confirms != 1 || !body.closed || !reflect.DeepEqual(receipts, []string{tc.receipt}) { t.Errorf("Sale(%s) starts/confirms/closed/receipts=%d/%d/%t/%v, want 1/1/true/[%q]", tc.name, starts, confirms, body.closed, receipts, tc.receipt) } }) } } func TestCreditCallConfirmationRetryAndFailureParity(t *testing.T) { for _, streaming := range []bool{false, true} { var attempts int var times []time.Time app := &App{isPayment: true, cfg: &config.ConfigRec{}} app.EnableCreditCallStreaming() app.creditCallReceipt = func(string) { t.Error("transport-failed confirmation must not print a receipt") } app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { if r.Context().Err() != nil { t.Error("transaction context was cancelled") } if r.URL.Path == "/confirm-transaction/" { attempts++ times = append(times, time.Now()) return nil, errors.New("test transport failure") } body := chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved", types.Reference: "native-ref"}) if streaming { body = "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"native-ref\"}}\n" } return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(body)), Header: make(http.Header)}, nil }) recorder := httptest.NewRecorder() if streaming { app.salePayment(recorder, saleRequest(true)) } else { app.takePayment(recorder, saleRequest(false)) } if attempts != 2 { t.Fatalf("stream=%v confirms=%d, want 2", streaming, attempts) } if times[1].Sub(times[0]) < 2*time.Second { t.Errorf("retry delay=%v, want at least 2s", times[1].Sub(times[0])) } if streaming { frames := decodePaymentStream(t, recorder.Body) if len(frames) != 1 || frames[0].Result.HTTPStatus != 502 || frames[0].Result.Outcome != "unknown" || frames[0].Result.Retryable { t.Fatalf("confirmation failure frames=%+v", frames) } } else if recorder.Code != 502 { t.Errorf("legacy confirm failure HTTP=%d, want 502", recorder.Code) } } } func TestCreditCallLegacyMalformedStartAndPreauth(t *testing.T) { for _, test := range []struct{ name, path, result, transactionType string }{ {"malformed sale", "/takepayment", "malformed", ""}, {"approved account verification", "/takepreauth", "Approved", types.AccountVerificationType}, {"declined preauth", "/takepreauth", "Declined", "Sale"}, {"malformed preauth", "/takepreauth", "malformed", ""}, } { t.Run(test.name, func(t *testing.T) { calls, prints := 0, 0 app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) { calls++ if r.URL.Path != "/start-transaction/" { t.Errorf("legacy/preauth path=%s", r.URL.Path) } if test.result == "malformed" { io.WriteString(w, "") return } io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: test.result, types.TransactionType: test.transactionType})) }) app.creditCallReceipt = func(string) { prints++ } recorder := httptest.NewRecorder() request := saleRequest(false) if test.path == "/takepreauth" { app.takePreauthorization(recorder, request) } else { app.takePayment(recorder, request) } var response cmstypes.ResponseRec if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil { t.Fatal(err) } if recorder.Code != 200 || calls != 1 || prints != 1 { t.Errorf("legacy HTTP/calls/receipts=%d/%d/%d", recorder.Code, calls, prints) } if test.result == "malformed" && (response.Status.Code != 0 || response.Data != "/unsuccessful?Description=&MsgType=") { t.Errorf("malformed legacy result=%+v", response) } if test.result == "Approved" && !strings.HasPrefix(response.Data, "/successful?") { t.Errorf("approved preauth=%+v", response) } }) } } func TestChipDNAStreamRejectsIncompleteOrInvalidFrames(t *testing.T) { for _, body := range []string{"", "{", "{}\n", "\n", "{\"type\":\"result\"}\n", "{\"type\":\"result\",\"result\":{}}\n", "{\"type\":\"error\",\"error\":\"sensitive diagnostic\"}\n", "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\"}}", "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"Approved\"}\n"} { client := &http.Client{Transport: creditCallRoundTrip(func(*http.Request) (*http.Response, error) { return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(body))}, nil })} _, err := callChipDNAStream(client, 1234, func(code string) { t.Errorf("invalid stream produced status %q", code) }) if err == nil { t.Errorf("callChipDNAStream(%q) succeeded, want error", body) } if err != nil && strings.Contains(err.Error(), "sensitive diagnostic") { t.Error("raw diagnostic leaked") } } } type disconnectedPaymentWriter struct { header http.Header once sync.Once failed chan struct{} writes atomic.Int32 } func (w *disconnectedPaymentWriter) Header() http.Header { return w.header } func (w *disconnectedPaymentWriter) WriteHeader(int) {} func (w *disconnectedPaymentWriter) Flush() {} func (w *disconnectedPaymentWriter) Write([]byte) (int, error) { w.writes.Add(1) w.once.Do(func() { close(w.failed) }) return 0, io.ErrClosedPipe } func TestCreditCallDisconnectStillConfirmsAndPrints(t *testing.T) { release := make(chan struct{}) var confirms atomic.Int32 var receipts atomic.Int32 app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/confirm-transaction/" { confirms.Add(1) io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved", types.ReceiptDataCardholder: "receipt"})) return } io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n") w.(http.Flusher).Flush() <-release io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n") io.WriteString(w, "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"ref\"}}\n") }) app.creditCallReceipt = func(receipt string) { if receipt != "receipt" { t.Errorf("receipt=%q", receipt) } receipts.Add(1) } writer := &disconnectedPaymentWriter{header: make(http.Header), failed: make(chan struct{})} ctx, cancel := context.WithCancel(context.Background()) defer cancel() done := make(chan struct{}) go func() { app.salePayment(writer, saleRequest(true).WithContext(ctx)); close(done) }() select { case <-writer.failed: case <-time.After(5 * time.Second): close(release) t.Fatal("no live progress before final result") } cancel() close(release) select { case <-done: case <-time.After(5 * time.Second): t.Fatal("finalization stopped after disconnect") } if confirms.Load() != 1 || receipts.Load() != 1 || writer.writes.Load() != 1 { t.Errorf("disconnect confirms/receipts/writes=%d/%d/%d, want 1/1/1", confirms.Load(), receipts.Load(), writer.writes.Load()) } }