157 lines
6.6 KiB
Go
157 lines
6.6 KiB
Go
package handlers
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/v2/config"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/paymentsvc"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/trustpayments"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type failedDiagnosticWriter struct{ header http.Header }
|
|
|
|
func (w *failedDiagnosticWriter) Header() http.Header { return w.header }
|
|
func (*failedDiagnosticWriter) WriteHeader(int) {}
|
|
func (*failedDiagnosticWriter) Flush() {}
|
|
func (*failedDiagnosticWriter) Write([]byte) (int, error) {
|
|
return 0, errors.New("https://user:WRITE_PRIVATE_MARKER@gateway.invalid/4111111111111111")
|
|
}
|
|
|
|
func TestTrustReconciliationLogsPreserveIdentityAndFinancialOutcome(t *testing.T) {
|
|
for _, preauth := range []bool{false, true} {
|
|
for _, mode := range []string{"unknown", "unknown-transport", "unknown-write-failure", "approved-client-closed", "approved-write-failure"} {
|
|
operation := "sale"
|
|
if preauth {
|
|
operation = "preauth"
|
|
}
|
|
t.Run(operation+"/"+mode, func(t *testing.T) {
|
|
var output bytes.Buffer
|
|
logger := log.StandardLogger()
|
|
oldOutput, oldFormatter := logger.Out, logger.Formatter
|
|
logger.SetOutput(&output)
|
|
logger.SetFormatter(&log.JSONFormatter{})
|
|
t.Cleanup(func() { logger.SetOutput(oldOutput); logger.SetFormatter(oldFormatter) })
|
|
unknown := strings.HasPrefix(mode, "unknown")
|
|
financial, lookups, prints := 0, 0, 0
|
|
var ref string
|
|
var tokens []string
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
t.Cleanup(cancel)
|
|
client, err := trustpayments.New(trustpayments.Config{
|
|
BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "SYNTH-SITE", Password: "PASSWORD_PRIVATE_MARKER", Terminal: "SYNTH-PED", Currency: "GBP", Timezone: "Europe/London",
|
|
Transport: trustFixtureTransport(func(r *http.Request) (*http.Response, error) {
|
|
var input map[string]string
|
|
if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
|
|
return nil, err
|
|
}
|
|
tokens = append(tokens, r.Header.Get("token"))
|
|
if strings.HasSuffix(r.URL.Path, "/status") {
|
|
lookups++
|
|
if input["refid"] != ref {
|
|
t.Errorf("Status RefID=%q, want original %q", input["refid"], ref)
|
|
}
|
|
} else {
|
|
financial++
|
|
ref = input["refid"]
|
|
if !strings.HasSuffix(r.URL.Path, "/"+operation) || input["type"] != operation {
|
|
t.Errorf("Financial request path/type=%s/%s, want %s", r.URL.Path, input["type"], operation)
|
|
}
|
|
if mode == "approved-client-closed" {
|
|
cancel()
|
|
}
|
|
}
|
|
if mode == "unknown-transport" {
|
|
return nil, errors.New("https://user:PASSWORD_PRIVATE_MARKER@gateway.invalid/4111111111111111/JWT_PRIVATE_MARKER")
|
|
}
|
|
body := map[string]any{"refid": ref, "siteid": "SYNTH-SITE", "terminalserialnumber": "SYNTH-PED", "type": operation, "amount": "25.00", "finalamount": "25.00", "resultcode": "Approved", "authcode": "AUTH_PRIVATE_MARKER", "cardtype": "Visa", "last4": "1133", "receipt": "PAN: 4111111111111111\nRAW_PRIVATE_MARKER"}
|
|
if unknown {
|
|
body["errorcode"], body["errormessage"] = 2003, "RAW_PRIVATE_MARKER JWT_PRIVATE_MARKER"
|
|
}
|
|
encoded, err := json.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &http.Response{StatusCode: 200, Body: io.NopCloser(bytes.NewReader(encoded)), Header: make(http.Header)}, nil
|
|
}),
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
app := &App{cfg: &config.ConfigRec{Hotel: "SYNTH-HOTEL", Kiosk: 9}, isPayment: true}
|
|
app.SetPaymentService(paymentsvc.NewService(&trustpayments.Processor{Client: client, PrintReceipt: func(string) { prints++ }}))
|
|
request := httptest.NewRequest(http.MethodPost, "/api/payment/"+operation, strings.NewReader(`{"reference":"SYNTH-BOOK","amount":2500,"currency":"GBP"}`)).WithContext(ctx)
|
|
request.Header.Set("Content-Type", "application/json")
|
|
recorder := httptest.NewRecorder()
|
|
var writer http.ResponseWriter = recorder
|
|
if strings.Contains(mode, "write-failure") {
|
|
writer = &failedDiagnosticWriter{header: make(http.Header)}
|
|
}
|
|
app.streamPayment(writer, request, preauth)
|
|
wantLookups, wantPrints, wantOutcome := 0, 1, "approved"
|
|
if unknown {
|
|
wantLookups, wantPrints, wantOutcome = 1, 0, "unknown"
|
|
}
|
|
if financial != 1 || lookups != wantLookups || prints != wantPrints || len(ref) != 32 {
|
|
t.Fatalf("Trust(%s) financial/status/prints/ref=%d/%d/%d/%q, want 1/%d/%d and original RefID", mode, financial, lookups, prints, ref, wantLookups, wantPrints)
|
|
}
|
|
if unknown && !strings.Contains(mode, "write-failure") {
|
|
frames := decodePaymentStream(t, recorder.Body)
|
|
if len(frames) == 0 {
|
|
t.Fatal("Unknown payment stream is empty, want final result")
|
|
}
|
|
final := frames[len(frames)-1].Result
|
|
if final == nil || final.Outcome != wantOutcome || final.Retryable || final.TransactionReference != ref {
|
|
t.Errorf("Unknown terminal result=%+v, want unchanged nonretryable outcome and RefID %s", final, ref)
|
|
}
|
|
}
|
|
var requestID string
|
|
warnings := 0
|
|
decoder := json.NewDecoder(strings.NewReader(output.String()))
|
|
for {
|
|
var entry map[string]any
|
|
if err := decoder.Decode(&entry); err == io.EOF {
|
|
break
|
|
} else if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if entry["level"] != "warning" {
|
|
continue
|
|
}
|
|
warnings++
|
|
id, _ := entry["request_id"].(string)
|
|
if requestID == "" {
|
|
requestID = id
|
|
}
|
|
if id == "" || id != requestID || entry["request_reference"] != "SYNTH-BOOK" || entry["transaction_reference"] != ref || entry["provider"] != "TrustPayments" || entry["operation"] != operation || entry["outcome"] != wantOutcome {
|
|
t.Errorf("Reconciliation warning=%v, want same request ID, Trust RefID, provider, operation and financial outcome", entry)
|
|
}
|
|
}
|
|
wantWarnings := 0
|
|
if unknown {
|
|
wantWarnings = 2
|
|
}
|
|
if strings.Contains(mode, "write-failure") || mode == "approved-client-closed" {
|
|
wantWarnings++
|
|
}
|
|
if warnings != wantWarnings {
|
|
t.Errorf("Trust(%s) reconciliation warnings=%d, want %d", mode, warnings, wantWarnings)
|
|
}
|
|
for _, secret := range append(tokens, "PASSWORD_PRIVATE_MARKER", "AUTH_PRIVATE_MARKER", "RAW_PRIVATE_MARKER", "JWT_PRIVATE_MARKER", "WRITE_PRIVATE_MARKER", "4111111111111111") {
|
|
if secret != "" && strings.Contains(output.String(), secret) {
|
|
t.Errorf("Trust(%s) diagnostics contain private fixture data", mode)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|