package paybridge import ( "context" "encoding/json" "errors" "io" "net/http" "net/http/httptest" "strings" "sync/atomic" "testing" "time" "gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/paymentsvc" "github.com/gorilla/websocket" log "github.com/sirupsen/logrus" logtest "github.com/sirupsen/logrus/hooks/test" ) func paybridgeDiagnosticLog(t *testing.T) *logtest.Hook { t.Helper() logger := log.StandardLogger() oldOutput := logger.Out oldHooks := logger.ReplaceHooks(make(log.LevelHooks)) hook := logtest.NewGlobal() log.SetOutput(io.Discard) t.Cleanup(func() { log.SetOutput(oldOutput); logger.ReplaceHooks(oldHooks) }) return hook } func TestPayBridgeFailureDiagnosticsKeepIdentityAndDoNotRetry(t *testing.T) { for _, failure := range []string{"connect", "auth", "lost", "malformed", "uncertain", "provider_error", "payment_error", "cancelled"} { t.Run(failure, func(t *testing.T) { hook := paybridgeDiagnosticLog(t) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() var financialPosts atomic.Int32 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Query().Get("api_key") != "SYNTH-CREDENTIAL" { t.Error("PayBridge connection omitted synthetic credential") } if failure == "connect" { http.Error(w, "SYNTH-RAW-SECRET", 503) return } connection, err := (&websocket.Upgrader{}).Upgrade(w, r, nil) if err != nil { t.Error(err) return } defer connection.Close() auth := `{"type":"auth_success","jwt":"SYNTH-JWT-PRIVATE"}` if failure == "auth" { auth = `{"type":"SYNTH-RAW-SECRET","jwt":"SYNTH-JWT-PRIVATE"}` } if err := connection.WriteMessage(websocket.TextMessage, []byte(auth)); err != nil { t.Error(err) return } if failure == "auth" { return } var request struct { Data PaymentRequest `json:"data"` } if err := connection.ReadJSON(&request); err != nil { t.Error(err) return } financialPosts.Add(1) if request.Data.RequestID != "SYNTH-REQUEST" || request.Data.Amount != 2500 { t.Errorf("PayBridge dispatched %+v, want original request identity/amount", request.Data) } body := "" switch failure { case "lost": if err := connection.WriteControl(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.ClosePolicyViolation, "SYNTH-RAW-SECRET"), time.Now().Add(time.Second)); err != nil { t.Error(err) } return case "malformed": body = `{"type":"payment_result","data":"SYNTH-RAW-SECRET"}` case "uncertain": body = `{"type":"payment_result","data":{"requestId":"SYNTH-REQUEST","transactionId":"SYNTH-PROVIDER-TXN","referenceNumber":"SYNTH-PROVIDER-REF","success":false,"status":"TIMEOUT","errorMessage":"SYNTH-RAW-SECRET card 4111111111111111","amount":2500}}` case "provider_error": body = `{"type":"error","error":{"code":"SYNTH-PRIVATE-CODE","message":"SYNTH-RAW-SECRET"}}` case "payment_error": body = `{"type":"payment_error","data":{"transactionId":"SYNTH-PROVIDER-TXN","status":"TIMEOUT","error":"SYNTH-RAW-SECRET"}}` case "cancelled": cancel() return } if err := connection.WriteMessage(websocket.TextMessage, []byte(body)); err != nil { t.Error(err) } })) t.Cleanup(server.Close) client := NewClient("ws"+strings.TrimPrefix(server.URL, "http"), "SYNTH-CREDENTIAL", 5) result, err := client.Sale(ctx, paymentsvc.SaleRequest{RequestID: "SYNTH-REQUEST", Amount: 2500, Currency: "GBP"}, nil) wantPosts := int32(1) if failure == "connect" || failure == "auth" { wantPosts = 0 } if financialPosts.Load() != wantPosts { t.Errorf("Sale(%s) dispatches=%d, want %d without retry", failure, financialPosts.Load(), wantPosts) } if failure == "uncertain" || failure == "payment_error" { if err != nil || result == nil || result.Terminal.Outcome != "unknown" || result.Terminal.Retryable { t.Fatalf("Sale(%s)=%+v/%v, want unchanged nonretryable unknown", failure, result, err) } if !strings.Contains(result.ErrorMessage, "SYNTH-RAW-SECRET") { t.Error("diagnostic changes mutated the existing provider result") } } else if result != nil || err == nil { t.Fatalf("Sale(%s)=%+v/%v, want original nil-result failure", failure, result, err) } if failure == "connect" && !errors.Is(err, ErrConnectionFailed) { t.Errorf("Sale(connect) error=%v, want ErrConnectionFailed", err) } if failure == "cancelled" && !errors.Is(err, context.Canceled) { t.Errorf("Sale(cancelled) error=%v, want context.Canceled", err) } var diagnostic *log.Entry for _, entry := range hook.AllEntries() { data, _ := json.Marshal(entry.Data) for _, secret := range []string{"SYNTH-CREDENTIAL", "SYNTH-JWT-PRIVATE", "SYNTH-RAW-SECRET", "SYNTH-PRIVATE-CODE", "4111111111111111"} { if strings.Contains(string(data)+entry.Message, secret) { t.Errorf("Sale(%s) logged sensitive marker %q", failure, secret) } } if entry.Message == "PayBridge payment requires reconciliation" { diagnostic = entry } } if diagnostic == nil { t.Fatal("Sale failure emitted no reconciliation diagnostic") } for key, want := range map[string]string{"provider": "paybridge", "request_id": "SYNTH-REQUEST", "transaction_reference": "SYNTH-REQUEST"} { if diagnostic.Data[key] != want { t.Errorf("Sale(%s) diagnostic[%s]=%v, want %s", failure, key, diagnostic.Data[key], want) } } stages := map[string]string{"connect": "connect", "auth": "authenticate", "lost": "read_result", "malformed": "decode_result", "uncertain": "decode_result", "provider_error": "provider_error", "payment_error": "decode_payment_error", "cancelled": "read_result"} categories := map[string]string{"connect": "connection_failure", "auth": "authentication_failed", "lost": "response_lost", "malformed": "invalid_response", "uncertain": "unresolved_result", "provider_error": "invalid_response", "payment_error": "unresolved_result", "cancelled": "cancelled"} if diagnostic.Data["stage"] != stages[failure] || diagnostic.Data["error_category"] != categories[failure] { t.Errorf("Sale(%s) diagnostic=%v, want stage=%s category=%s", failure, diagnostic.Data, stages[failure], categories[failure]) } if failure == "lost" && diagnostic.Data["websocket_close_code"] != websocket.ClosePolicyViolation { t.Errorf("Sale(lost) close code=%v, want 1008", diagnostic.Data["websocket_close_code"]) } if failure == "connect" && diagnostic.Data["http_status"] != 503 { t.Errorf("Sale(connect) HTTP status=%v, want 503", diagnostic.Data["http_status"]) } if failure == "uncertain" || failure == "payment_error" { if diagnostic.Data["provider_transaction_id"] != "SYNTH-PROVIDER-TXN" { t.Errorf("Sale(%s) provider transaction=%v, want retained identity", failure, diagnostic.Data["provider_transaction_id"]) } } }) } }