feat(hardlink): unify kiosk payments and finalize legacy cleanup

This commit is contained in:
2026-11-04 17:43:10 +00:00
parent 568adc034b
commit 814d87768d
57 changed files with 3624 additions and 1762 deletions
-34
View File
@@ -2,7 +2,6 @@ package creditcall
import (
"bytes"
"context"
"encoding/xml"
"fmt"
"html"
@@ -243,36 +242,3 @@ func ReadPdqStatus(hotel string, kiosk int) (PaymentDeviceStatus, error) {
return dev, nil
}
func StartPdqHourlyCheck(ctx context.Context, hotel string, kiosk int) {
// waitUntilNextHour(ctx)
// First execution exactly at round hour
_, _ = ReadPdqStatus(hotel, kiosk)
ticker := time.NewTicker(10 * time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
_, _ = ReadPdqStatus(hotel, kiosk)
}
}
}
func waitUntilNextHour(ctx context.Context) {
now := time.Now()
next := now.Truncate(time.Hour).Add(time.Hour)
d := time.Until(next)
timer := time.NewTimer(d)
defer timer.Stop()
select {
case <-ctx.Done():
case <-timer.C:
}
}
-39
View File
@@ -16,12 +16,6 @@ import (
// XML parsing structs
type (
TransactionRec struct {
XMLName xml.Name `xml:"TransactionPayload"`
AmountMinorUnits string `xml:"amount"`
TransactionType string `xml:"transactionType"`
}
TransactionResultXML struct {
XMLName xml.Name `xml:"TransactionResult"`
Entries []EntryXML `xml:"Entry"`
@@ -99,39 +93,6 @@ func (r *PaymentResult) FillFromTransactionResult(trResult TransactionResultXML)
}
}
// BuildPaymentRedirectURL builds the redirect URL to send the guest to after payment.
func BuildPaymentRedirectURL(result map[string]string) string {
res := result[types.TransactionResult]
// Transaction approved?
if strings.EqualFold(res, types.ResultApproved) {
// Transaction confirmed?
if strings.EqualFold(result[types.ConfirmResult], types.ResultApproved) {
log.WithField(types.LogResult, result[types.ConfirmResult]).
Info("Transaction approved and confirmed")
return BuildSuccessURL(result)
}
// Not confirmed
log.WithFields(log.Fields{types.LogFieldError: result[types.ConfirmResult], types.LogFieldDescription: result[types.ConfirmErrors]}).
Error("Transaction approved but not confirmed")
return BuildFailureURL(result[types.ConfirmResult], result[types.ConfirmErrors])
}
// Not approved
return BuildFailureURL(res, result[types.Errors])
}
func BuildPreauthRedirectURL(result map[string]string) (string, bool) {
approved, persist := PreauthDecision(result)
if approved {
return BuildSuccessURL(result), persist
}
return BuildFailureURL(result[types.TransactionResult], result[types.Errors]), false
}
// PreauthDecision preserves the returned-type approval and persistence rules.
func PreauthDecision(result map[string]string) (approved, persist bool) {
res := result[types.TransactionResult]
+4 -5
View File
@@ -1,7 +1,6 @@
package creditcall
import (
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
@@ -23,12 +22,12 @@ func TestPreauthLegacyDecision(t *testing.T) {
} {
t.Run(tc.name, func(t *testing.T) {
fields := map[string]string{types.TransactionResult: tc.result, types.TransactionType: tc.kind, types.Errors: "provider detail"}
redirect, save := BuildPreauthRedirectURL(fields)
if strings.HasPrefix(redirect, "/successful?") != tc.approved || save != tc.save {
t.Errorf("BuildPreauthRedirectURL(%v) = %q,%t, want approved=%t save=%t", fields, redirect, save, tc.approved, tc.save)
approved, save := PreauthDecision(fields)
if approved != tc.approved || save != tc.save {
t.Errorf("PreauthDecision(%v) = %t,%t, want approved=%t save=%t", fields, approved, save, tc.approved, tc.save)
}
if _, ok := fields[types.TotalAmount]; ok {
t.Error("BuildPreauthRedirectURL fabricated TOTAL_AMOUNT")
t.Error("PreauthDecision fabricated TOTAL_AMOUNT")
}
})
}
+1 -2
View File
@@ -84,7 +84,7 @@ func InsertPreauth(ctx context.Context, db *sql.DB, m map[string]string, checkou
txnTime := time.Now().UTC()
// parse departure / checkout date and compute release date (48h after departure)
// Parse departure / checkout date and compute release date (96h after departure).
checkOutDate, err := parseDateOnly(checkoutDate)
if err != nil {
return fmt.Errorf("InsertPreauth: parsing checkoutDate %q: %w", checkoutDate, err)
@@ -198,4 +198,3 @@ WHERE TxnReference = @TxnReference AND Released = 0;
log.Infof("Marked preauth %s released at %s", txnReference, releasedAt.Format(time.RFC3339))
return nil
}
@@ -1,335 +0,0 @@
# K720 dispenser issuance contract
Hardlink treats the K720 as an unreliable mechanical peripheral with a strict transport
protocol and imperfect status telemetry. The implementation must keep transport
validation strict while making mechanical decisions from fresh, bounded observations.
Diagnostic bytes are useful evidence, but they must not override a valid physical
position or turn an uncertain observation into a fatal guest-facing error.
This document records the dispenser invariants agreed for the clean implementation.
It is intended to be a design contract: future changes should preserve these rules
unless production evidence justifies changing them explicitly.
## Ownership and concurrency
- The dispenser worker is the single owner of serial commands and `deliveryPending`.
New code must not access the serial port directly from handlers or background
goroutines.
- Commands that can move a card are serialized through the worker. There must never
be concurrent AP/FC7/FC0/RS traffic from separate flows.
- `deliveryPending` is worker-owned state. It must not be duplicated or mutated by
HTTP handlers.
- A real `/issuedoorcard` operation always has priority over maintenance/prestage
work.
- Cancellation of a real caller must stop caller-owned work. Internal bounded
observation timeouts must remain distinguishable from caller cancellation.
- Do not create overlapping maintenance goroutines or timers per request. Any
background maintenance must have one clear owner and lifecycle.
## Status and observation model
AP transport parsing is strict. A response is usable only when its framing and
contents are valid, including ACK/address/header/length/ETX/BCC/type checks.
Malformed, truncated, timed-out or otherwise invalid AP responses are unusable
observations. They are logged and discarded. They are never converted into a
fabricated physical state such as `0x30` or `0x38`.
Every fresh valid AP observation reclassifies the current mechanical state. No
physical position is latched across later observations.
The fourth AP status byte is the physical position used by the preparation logic:
- Encoder confirmed:
`0x32, 0x33, 0x36, 0x37, 0x3A, 0x3B, 0x3E, 0x3F`.
A card may be handed to `LockSequence` immediately.
- Valid but uncertain:
`0x31, 0x34, 0x35, 0x39, 0x3C, 0x3D`.
Continue bounded fresh observation; if no stronger state appears, one encoding
opportunity may still be granted after the uncertainty window.
- No card on sensors:
exact `0x30`.
This may trigger the bounded mechanical recovery sequence.
- Card well empty:
exact `0x38`.
This is the only physical state that becomes `ErrCardWellEmpty`.
The first three diagnostic bytes are advisory. Values such as `Preparing card fails`,
`Dispense card error`, `Card jammed`, or `Command cannot execute` may coexist with a
usable physical position. They may be logged, but they must not automatically block
encoding when the fourth byte confirms a usable card position.
## Preparing the current card
A `/issuedoorcard` request receives at most one `LockSequence` opportunity.
Preparation uses bounded fresh observation:
- Poll interval: 1 second.
- After a successful FC7, allow 3 seconds of observation before shake recovery is
eligible for a persistent exact `0x30`.
- For uncertain or unusable observations after a successful FC7, use one shared
4-second uncertainty window. Switching between uncertain and unusable observations
does not restart that window.
- A later usable observation always takes precedence:
encoder confirmed -> handoff;
exact `0x38` -> empty;
exact `0x30` -> resume the remaining shake budget and reset uncertainty timing.
- Total preparation budget: 32 seconds.
For persistent exact `0x30`, the request may perform at most three shake recoveries:
`RS -> 2 second settle -> FC7`
There is no additional plain FC7 retry. Including the initial dispatch, the maximum
per request is four FC7 commands and three RS commands.
If all three shakes are exhausted while the latest usable physical state remains
exact `0x30`, preparation fails. If the internal preparation deadline is reached
while the latest state is uncertain or unusable after a successful FC7, the request
may hand off one encoding opportunity. Exact `0x38` remains empty.
FC7 or RS dispatch failures are real transport/command failures. They are not
converted into status uncertainty and are not retried merely because their dispatch
failed.
## Encoding and delivery
`LockSequence` runs exactly once for a prepared card in a single `/issuedoorcard`
request. The dispenser layer does not implement a second encoding attempt on the same
physical card.
After `LockSequence`, FC0 is dispatched exactly once to move the current card toward
the guest:
- `LockSequence` success -> FC0 once -> successful issuance remains successful.
- `LockSequence` failure -> FC0 once -> return the original encoding error.
- FC0 errors are logged only. They do not replace the original encoding result and
they do not become `ErrCardWellEmpty`.
A failed `LockSequence` does not start next-card prestaging.
The design intentionally does not add retained-card state, per-card failure counters,
provider-specific encoder retries, special bad-card recovery, CP/capture recovery, or
multiple encoding attempts per physical card without production evidence requiring
them.
## Delivery clearance
After FC0, the worker marks the previous delivery as pending. A later FC7 must not be
sent until the previous delivery has been considered clear.
Delivery clearance uses fresh AP observations and is owned by the worker.
Current bounds:
- Minimum clearance wait: 2 seconds.
- Clearance timeout: 6 seconds.
- Poll interval: 1 second.
A valid physical position of `0x30` or `0x34` may clear `deliveryPending` after the
minimum wait unless the same fresh observation explicitly indicates active
preparing/dispensing/capturing movement.
Exact `0x38` reports physical empty and does not silently clear the state.
If the internal clearance timeout is reached while the caller context is still
valid, the worker may make the bounded assumption that delivery has cleared unless
the latest fresh usable observation establishes exact physical empty (`0x38`) or
explicit active movement. This fallback may therefore occur while the latest
physical position is `0x33`; `0x33` itself is not positive clearance evidence.
The fallback is an internal timeout policy, not a reclassification of the observed
position.
If the latest fresh usable observation still explicitly indicates movement, that is
not treated as unknown. `deliveryPending` remains set and the clearance attempt
times out.
Caller cancellation or deadline always takes precedence over the internal clearance
fallback. If the caller context expires, return the caller error and do not admit a
subsequent FC7 from that caller-owned operation.
A later unusable observation supersedes older movement evidence; stale movement
information must not be latched indefinitely.
## Next-card prestage and guest UX
Preparing the next card is an optimization for the next guest, not part of the
business success of the current guest's issuance.
After a successful `LockSequence` and FC0, Hardlink may make a short best-effort
attempt to prestage the next card:
- wait for worker-owned delivery clearance;
- if clearance is obtained within the bounded prestage context, send exactly one FC7;
- do not run readiness polling, RS/shake recovery, or the full current-card
preparation flow;
- prestage failure is log-only and must not change the successful `/issuedoorcard`
result.
Do not extend the current guest's screen by 15-20 seconds merely to guarantee that
the next card reaches the encoder. The guest-facing flow must remain bounded even
when the dispenser is slow to become ready for prestage.
If the short prestage window expires, skip that prestage attempt. A later request or
maintenance cycle may prepare the next card.
## HTTP contract
Physical empty and operational failure are deliberately different outcomes.
- HTTP 503 is reserved for `ErrCardWellEmpty`, derived only from an exact valid
physical `0x38`.
- All other dispenser preparation, transport, command and encoding failures return
HTTP 502.
- Normal request/protocol validation keeps its existing 400/405/415 behavior.
- Diagnostic text such as `Preparing card fails` must never by itself produce 503.
Operafyne treats:
- 502 as retryable while attempts remain;
- 503 as terminal `dispenser_failed`;
- a maximum of three total issue attempts: the initial attempt plus up to two user
retries.
The dispenser layer must preserve this distinction.
## Passive status and alerts
Ordinary status queries remain strict and passive. They must not reuse tolerant
issuance semantics to fabricate a status or hide malformed transport.
Passive polling captures the current foreground activity generation when the poll is
queued. The worker skips a passive poll if foreground activity is active when it is
dispatched or if the captured generation has become obsolete. Passive polling does
not reset the idle-maintenance clock.
Status/diagnostic observations may be useful for logs and support alerts, but alerts
must not alter physical state classification or issuance success.
Idle maintenance observations are intentionally quiet: they do not invoke the normal
stock-update callback or generate repeated support email such as `Preparing card
fails`. Maintenance failures are local diagnostic events only.
## Idle prestage maintenance
Idle prestaging recovers from a short post-FC0 prestage timeout without keeping the
current guest waiting.
The implementation uses the existing dispenser worker as the single maintenance
owner:
- one resettable maintenance timer is owned by the serial-worker loop; there is no
maintenance goroutine and no timer created per request;
- `/issuedoorcard` and `/testissuedoorcard` register foreground activity before
using the dispenser/encoder and release it when the handler finishes;
- foreground activity is reference-counted so overlapping requests suppress
maintenance until the last active request finishes;
- each foreground registration increments an activity generation and invalidates the
previous idle deadline;
- when the last foreground request finishes, the next maintenance attempt is
scheduled one minute later;
- enabling maintenance at startup schedules the first check one minute later when
no foreground request is active;
- a stale timer or stale generation cannot perform maintenance;
- after a maintenance attempt, the next check is scheduled one minute from completion
only if the same generation is still authoritative. A later foreground completion
therefore cannot have its newer deadline overwritten by an older maintenance
attempt.
Foreground registration and maintenance transaction admission use the same activity
guard. The guard is used only for admission/state bookkeeping and is never held
across serial I/O, queue waits, sleeps, callbacks, or `LockSequence`.
A maintenance attempt is deliberately weaker than foreground preparation:
1. create a bounded 5-second maintenance context;
2. recheck maintenance admission before AP;
3. obtain one fresh AP using the existing strict transport parser;
4. classify the fresh status using the common physical classifier;
5. do nothing for encoder-present, exact `0x38`, unusable, explicit-movement, or
otherwise ineligible observations;
6. when `deliveryPending` is set, require fresh qualifying clearance evidence and the
existing minimum clearance wait before clearing it;
7. never use the foreground six-second assumed-clearance fallback;
8. recheck foreground count, activity generation, maintenance enabled state, and
maintenance context immediately before FC7 admission;
9. dispatch at most one FC7 and return immediately.
If foreground activity begins while an already-admitted maintenance AP is in
progress, that AP may finish, but the second admission check prevents maintenance
from sending FC7 afterward. An FC7 that was already admitted and dispatched before
foreground registration cannot be recalled.
Maintenance never performs:
- RS or shake recovery;
- `LockSequence`;
- `PrepareCurrentCard`;
- `PrepareNextCard` or `BeginPrepareNextCard`;
- readiness polling after FC7;
- the 32-second foreground preparation flow;
- repeated FC7 attempts;
- the foreground assumed-clearance fallback.
The 5-second maintenance context bounds new admissions and context-aware waits. An
already-admitted serial read may still finish according to the existing serial read
timeout, but no subsequent maintenance transaction is admitted after cancellation or
expiry.
`StartMaintenance` and `StopMaintenance` are idempotent lifecycle operations.
`Client.Close` disables maintenance and stops the timer.
Stopping maintenance cancels the current maintenance context and waits only for an
already-admitted maintenance transaction to finish under the existing bounded serial
behavior.
## Automated verification
Tests should preserve the behavioural contract rather than only exercise individual
functions.
At minimum, cover:
- strict AP framing and malformed/truncated/timeout responses;
- tolerant issuance observations never fabricating `0x30` or `0x38`;
- every physical position class and transitions between classes;
- exact `0x38` as the only `ErrCardWellEmpty` path;
- persistent `0x30` using at most three `RS -> settle -> FC7` recoveries;
- no extra FC7 after the shake budget;
- uncertain/unusable shared timing and later usable-state precedence;
- caller cancellation versus internal preparation timeout;
- exactly one `LockSequence` opportunity per request;
- FC0 exactly once after encoding success or failure;
- FC0 failure remaining log-only;
- failed encoding never starting prestage;
- worker-owned `deliveryPending` and guarded FC7 dispatch;
- bounded delivery-clearance fallback and explicit-movement timeout;
- successful issuance remaining successful when next-card prestage fails;
- HTTP 503 only for exact physical empty and 502 for other issuance failures;
- Operafyne retry semantics remaining three total attempts.
Idle maintenance verification additionally covers:
- first attempt occurs one minute after the latest issuance finishes;
- a new issuance resets that idle interval;
- overlapping foreground requests suppress maintenance until the last request
finishes;
- both `/issuedoorcard` and `/testissuedoorcard` participate in foreground activity
registration;
- stale timer events and stale activity generations cannot perform maintenance;
- foreground registration before maintenance AP prevents AP admission;
- foreground registration during an admitted AP prevents the later FC7;
- passive polls are skipped while foreground activity is active or when their
captured generation is stale;
- maintenance performs one AP and at most one FC7, with no RS/shake/encoding;
- encoder-present, exact-empty, movement and unusable observations are no-ops;
- pending delivery requires fresh normal clearance plus the minimum wait and never
uses the foreground assumed-clearance fallback;
- maintenance errors do not produce guest-facing failures, stock callbacks or
repeated alert email;
- repeated maintenance start/stop calls are safe and do not accumulate work;
- cancellation, `StopMaintenance` and `Client.Close` prevent subsequent maintenance
commands after shutdown admission is revoked.
For Hardlink verification, continue excluding the existing test that sends real
email when running the full suite.
+14 -6
View File
@@ -303,12 +303,17 @@ func TestForegroundEncoderClearanceCallerDeadline(t *testing.T) {
c.deliveryStarted = *now
start := *now
samples := 0
remainingChunks := len(p.chunks)
p.afterRead = func() {
if len(p.chunks)%2 == 0 { // Only complete frame reads advance the observation clock.
if len(p.chunks) == 4 || len(p.chunks) == 2 || len(p.chunks) == 0 {
samples++
*now = now.Add(time.Second)
}
// ACK and frame headers can take several reads without consuming a chunk.
// Advance once per completed AP frame, not during a partial ACK read.
if len(p.chunks) == remainingChunks {
return
}
remainingChunks = len(p.chunks)
if remainingChunks%2 == 0 {
samples++
*now = now.Add(time.Second)
}
}
ctx, cancel := context.WithTimeout(context.Background(), 4*time.Second)
@@ -326,7 +331,10 @@ func TestForegroundEncoderClearanceCallerDeadline(t *testing.T) {
t.Errorf("caller deadline err=%v pending=%t", r.err, c.deliveryPending)
}
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP", "AP", "AP"}) {
t.Errorf("caller deadline commands=%v want AP only", got)
t.Errorf("caller deadline commands=%v, want three AP observations and no movement", got)
}
if samples != 3 {
t.Errorf("caller deadline completed AP frames=%d, want 3", samples)
}
if elapsed := now.Sub(start); elapsed != 5*time.Second {
t.Errorf("last observation elapsed=%v want 5s", elapsed)
+93 -3
View File
@@ -13,13 +13,16 @@ import (
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
log "github.com/sirupsen/logrus"
)
type Config struct {
PrintReceipt func(string)
BaseURL string
APIKey string
SoftwareHouseID string
@@ -28,6 +31,7 @@ type Config struct {
}
type Client struct {
printReceipt func(string)
baseURL string
apiKey string
version string
@@ -91,6 +95,7 @@ func NewClient(cfg Config) (*Client, error) {
}
return &Client{
printReceipt: cfg.PrintReceipt,
baseURL: strings.TrimRight(cfg.BaseURL, "/"),
apiKey: cfg.APIKey,
version: cfg.Version,
@@ -104,7 +109,49 @@ func (c *Client) Sale(
ctx context.Context,
req paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
) (returned *paymentsvc.Result, resultErr error) {
stage := "create_payment_intent"
var intentID, sessionID, transactionID string
observeSession := func(session *terminalSessionResponse) {
if session != nil {
if session.ID != "" {
sessionID = session.ID
}
if session.PaymentDetails != nil && session.PaymentDetails.TransactionID != "" {
transactionID = session.PaymentDetails.TransactionID
}
}
}
defer func() {
if returned != nil {
returned.Terminal = dojoTerminalResult(returned)
if c.printReceipt != nil {
c.printReceipt(returned.CustomerReceipt)
}
}
if resultErr != nil || (returned != nil && returned.Terminal.Outcome == "unknown") {
fields := log.Fields{
"provider": "dojo", "operation": "sale", "stage": stage,
"request_id": req.RequestID, "transaction_reference": req.RequestID,
"error_category": paymentsvc.SafeErrorCategory(resultErr),
}
if intentID != "" {
fields["payment_intent_id"] = intentID
}
if sessionID != "" {
fields["terminal_session_id"] = sessionID
}
if transactionID != "" {
fields["provider_transaction_id"] = transactionID
}
var responseError *httpResponseError
if errors.As(resultErr, &responseError) {
fields["http_status"] = responseError.StatusCode
fields["error_category"] = "http_error"
}
log.WithFields(fields).Warn("Dojo payment requires reconciliation")
}
}()
if req.Currency == "" {
req.Currency = "GBP"
}
@@ -115,7 +162,12 @@ func (c *Client) Sale(
if err != nil {
return nil, err
}
intentID = intent.ID
if intent.PaymentDetails != nil {
transactionID = intent.PaymentDetails.TransactionID
}
stage = "create_terminal_session"
session, err := c.createTerminalSession(ctx, intent.ID)
if err != nil {
var responseErr *httpResponseError
@@ -125,6 +177,8 @@ func (c *Client) Sale(
"operation": "createTerminalSession",
"status": responseErr.StatusCode,
"terminal_unavailable": true,
"request_id": req.RequestID, "transaction_reference": req.RequestID,
"payment_intent_id": intentID,
}).Warn(dojoTerminalUnavailableMessage)
sendPaymentStatus(onStatus, paymentstatus.TerminalUnavailable)
@@ -135,18 +189,24 @@ func (c *Client) Sale(
}
return nil, err
}
observeSession(session)
session, err = c.waitForTerminalSession(ctx, session.ID, onStatus)
stage = "read_terminal_session"
session, err = c.waitForTerminalSession(ctx, session.ID, onStatus, observeSession)
if err != nil {
return nil, err
}
switch strings.ToLower(session.Status) {
case types.ResultCaptured, types.ResultSignatureAccepted:
stage = "read_payment_intent"
intent, err = c.getPaymentIntent(ctx, intent.ID)
if err != nil {
return nil, err
}
if intent.PaymentDetails != nil && intent.PaymentDetails.TransactionID != "" {
transactionID = intent.PaymentDetails.TransactionID
}
if strings.ToLower(intent.Status) != types.ResultCaptured {
return nil, fmt.Errorf("Dojo terminal session is %s but payment intent is %s", session.Status, intent.Status)
}
@@ -215,6 +275,7 @@ func (c *Client) waitForTerminalSession(
ctx context.Context,
terminalSessionID string,
onStatus paymentsvc.StatusHandler,
observeSession func(*terminalSessionResponse),
) (*terminalSessionResponse, error) {
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
@@ -230,7 +291,9 @@ func (c *Client) waitForTerminalSession(
return nil, err
}
log.Println("session status:", session.Status)
observeSession(&session.terminalSessionResponse)
log.WithFields(log.Fields{"provider": "dojo", "terminal_session_id": terminalSessionID,
"status": mapDojoSessionStatus(session.Status)}).Info("Dojo terminal session observed")
emitNewTerminalSessionEvents(
session,
@@ -273,6 +336,7 @@ func (c *Client) waitForTerminalSession(
signatureRejected = true
if rejectedSession != nil {
observeSession(rejectedSession)
rejectedStatus := strings.ToLower(
rejectedSession.Status,
)
@@ -672,3 +736,29 @@ func normalizeReceiptText(value string) string {
return replacer.Replace(value)
}
func (*Client) ValidatePreauth(paymentsvc.SaleRequest) error { return paymentsvc.ErrPreauthUnsupported }
func (*Client) Preauth(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return nil, paymentsvc.ErrPreauthUnsupported
}
func dojoTerminalResult(r *paymentsvc.Result) paymentapi.Result {
final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "dojo", AmountMinor: r.Amount, CurrencyCode: r.Currency, TransactionReference: r.RequestID, CardType: r.CardType, MaskedCardNumber: creditcall.MaskedCardNumber(r.CardNumber), ExpiryDate: r.ExpiryDate, CardHash: r.CardHash, CardReference: r.CardReference, AuthorizationCode: r.AuthCode, LastFour: r.LastFourDigits, Message: "Payment outcome uncertain; contact reception"}
if r.Success && strings.EqualFold(r.Status, "APPROVED") {
final.Outcome, final.Message = "approved", "Payment approved"
return final
}
switch strings.ToUpper(r.Status) {
case "DECLINED":
final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined"
case "CANCELLED", "CANCELED":
final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled"
case "SIGNATUREVERIFICATIONREJECTED", "SIGNATURE_VERIFICATION_REJECTED":
final.Outcome, final.Reason, final.Message = "declined", "signature_verification", "Signature verification declined"
final.Retryable = true
case dojoTerminalUnavailableStatus:
final.Outcome, final.Reason, final.Message = "error", "terminal_unavailable", dojoTerminalUnavailableMessage
final.Retryable = true
}
return final
}
+3
View File
@@ -86,6 +86,9 @@ func TestSaleMapsCreateTerminalSessionConflictToTerminalUnavailable(t *testing.T
if result.Status != dojoTerminalUnavailableStatus || result.ErrorMessage != dojoTerminalUnavailableMessage {
t.Fatalf("terminal-unavailable result = %+v", result)
}
if !result.Terminal.Retryable || result.Terminal.Reason != "terminal_unavailable" || result.Terminal.Outcome != "error" {
t.Errorf("Sale(session conflict) terminal=%+v, want safely retryable pre-dispatch unavailability", result.Terminal)
}
if result.RequestID != request.RequestID ||
result.Operation != "SALE" ||
result.Amount != request.Amount ||
+165
View File
@@ -0,0 +1,165 @@
package dojo
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
log "github.com/sirupsen/logrus"
logtest "github.com/sirupsen/logrus/hooks/test"
)
type diagnosticTransport func(*http.Request) (*http.Response, error)
func (f diagnosticTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func dojoDiagnosticLog(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 TestDojoFailureDiagnosticsKeepIdentityWithoutRawErrors(t *testing.T) {
for _, failure := range []string{"transport", "lost", "malformed", "http", "expired"} {
t.Run(failure, func(t *testing.T) {
hook := dojoDiagnosticLog(t)
financialPosts := 0
client, err := NewClient(Config{BaseURL: "https://synthetic.invalid", APIKey: "SYNTH-CREDENTIAL", SoftwareHouseID: "SYNTH-HOUSE", TerminalID: "SYNTH-PED"})
if err != nil {
t.Fatal(err)
}
client.httpClient = &http.Client{Transport: diagnosticTransport(func(r *http.Request) (*http.Response, error) {
body := ""
switch {
case r.Method == http.MethodPost && r.URL.Path == "/payment-intents":
financialPosts++
if failure == "transport" {
return nil, errors.New("SYNTH-RAW-SECRET https://user:password@private.invalid")
}
body = `{"id":"SYNTH-INTENT"}`
case r.Method == http.MethodPost && r.URL.Path == "/terminal-sessions":
body = `{"id":"SYNTH-SESSION","paymentDetails":{"transactionId":"SYNTH-PROVIDER-TXN"}}`
case r.Method == http.MethodGet && r.URL.Path == "/terminal-sessions/SYNTH-SESSION":
switch failure {
case "lost":
return nil, io.ErrUnexpectedEOF
case "malformed":
body = `{"SYNTH-RAW-SECRET":nope}`
case "http":
return &http.Response{StatusCode: 502, Header: make(http.Header), Body: io.NopCloser(strings.NewReader("SYNTH-RAW-SECRET card 4111111111111111"))}, nil
case "expired":
body = `{"id":"SYNTH-SESSION","status":"Expired","paymentDetails":{"transactionId":"SYNTH-PROVIDER-TXN"}}`
default:
t.Errorf("unexpected poll for %s", failure)
}
default:
t.Errorf("Dojo Sale requested unexpected %s %s", r.Method, r.URL.Path)
}
return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body))}, nil
})}
request := paymentsvc.SaleRequest{RequestID: "SYNTH-REQUEST", Reference: "SYNTH-BOOK", Amount: 2500, Currency: "GBP"}
result, err := client.Sale(context.Background(), request, nil)
if failure == "expired" {
if err != nil || result == nil || result.Terminal.Outcome != "unknown" || result.Terminal.Retryable {
t.Fatalf("Sale(expired)=%+v/%v, want unchanged nonretryable unknown", result, err)
}
} else if err == nil || result != nil {
t.Fatalf("Sale(%s)=%+v/%v, want original nil-result error", failure, result, err)
}
if failure == "http" && !strings.Contains(err.Error(), "SYNTH-RAW-SECRET") {
t.Error("Sale(http) changed the existing returned error")
}
if financialPosts != 1 {
t.Errorf("Sale(%s) financial posts=%d, want one", failure, financialPosts)
}
var diagnostic *log.Entry
for _, entry := range hook.AllEntries() {
data, _ := json.Marshal(entry.Data)
for _, secret := range []string{"SYNTH-CREDENTIAL", "SYNTH-RAW-SECRET", "4111111111111111", "user:password"} {
if strings.Contains(string(data)+entry.Message, secret) {
t.Errorf("Sale(%s) logged sensitive marker %q", failure, secret)
}
}
if entry.Message == "Dojo payment requires reconciliation" {
diagnostic = entry
}
}
if diagnostic == nil {
t.Fatal("Sale failure emitted no reconciliation diagnostic")
}
for key, want := range map[string]any{"provider": "dojo", "request_id": "SYNTH-REQUEST", "transaction_reference": "SYNTH-REQUEST"} {
if diagnostic.Data[key] != want {
t.Errorf("Sale(%s) diagnostic[%s]=%v, want %v", failure, key, diagnostic.Data[key], want)
}
}
wantStage, wantCategory := "read_terminal_session", "unresolved_result"
switch failure {
case "transport":
wantStage, wantCategory = "create_payment_intent", "connection_failure"
case "lost":
wantCategory = "response_lost"
case "malformed":
wantCategory = "invalid_response"
case "http":
wantCategory = "http_error"
}
if diagnostic.Data["stage"] != wantStage || diagnostic.Data["error_category"] != wantCategory {
t.Errorf("Sale(%s) diagnostic=%v, want stage=%s category=%s", failure, diagnostic.Data, wantStage, wantCategory)
}
if failure != "transport" {
for key, want := range map[string]string{"payment_intent_id": "SYNTH-INTENT", "terminal_session_id": "SYNTH-SESSION", "provider_transaction_id": "SYNTH-PROVIDER-TXN"} {
if diagnostic.Data[key] != want {
t.Errorf("Sale(%s) diagnostic[%s]=%v, want %s", failure, key, diagnostic.Data[key], want)
}
}
}
if failure == "http" && diagnostic.Data["http_status"] != 502 {
t.Errorf("Sale(http) status=%v, want 502", diagnostic.Data["http_status"])
}
})
}
}
func TestDojoPollFailureRetainsLastObservedTransactionIdentity(t *testing.T) {
hook := dojoDiagnosticLog(t)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
client, err := NewClient(Config{BaseURL: "https://synthetic.invalid", APIKey: "SYNTH", SoftwareHouseID: "SYNTH", TerminalID: "SYNTH"})
if err != nil {
t.Fatal(err)
}
client.httpClient = &http.Client{Transport: diagnosticTransport(func(r *http.Request) (*http.Response, error) {
body := `{"id":"SYNTH-INTENT"}`
if strings.HasPrefix(r.URL.Path, "/terminal-sessions") {
body = `{"id":"SYNTH-SESSION"}`
}
if r.Method == "GET" {
body = `{"id":"SYNTH-SESSION","status":"Initiated","paymentDetails":{"transactionId":"SYNTH-POLL-TXN"}}`
cancel()
}
return &http.Response{StatusCode: 200, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(body))}, nil
})}
result, err := client.Sale(ctx, paymentsvc.SaleRequest{RequestID: "SYNTH-REQUEST", Amount: 2500}, nil)
if result != nil || !errors.Is(err, context.Canceled) {
t.Fatalf("Sale(cancel after poll)=%+v/%v, want unchanged cancellation", result, err)
}
for _, entry := range hook.AllEntries() {
if entry.Message == "Dojo payment requires reconciliation" {
if entry.Data["provider_transaction_id"] != "SYNTH-POLL-TXN" || entry.Data["error_category"] != "cancelled" {
t.Errorf("Sale(cancel after poll) diagnostic=%v, want last observed transaction and cancellation", entry.Data)
}
return
}
}
t.Fatalf("Sale(cancel after poll) emitted no diagnostic; entries=%d", len(hook.AllEntries()))
}
+31
View File
@@ -0,0 +1,31 @@
package dojo
import (
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"testing"
)
func TestTerminalResultKeepsExistingIdentityAndOnlyRealMetadata(t *testing.T) {
raw := &paymentsvc.Result{Success: true, Status: "APPROVED", RequestID: "SYNTH-REQUEST", TransactionID: "SYNTH-PROVIDER-ID", Amount: 1234, Currency: "EUR", CardNumber: "************1133", CardType: "Visa", ExpiryDate: "1228", AuthCode: "SYNTH-AUTH"}
result := dojoTerminalResult(raw)
if result.Outcome != "approved" || result.TransactionReference != "SYNTH-REQUEST" || result.MaskedCardNumber != raw.CardNumber || result.ExpiryDate != "1228" || result.CardHash != "" || result.CardReference != "" {
t.Errorf("dojoTerminalResult(%+v)=%+v, want current request identity and only supplied card data", raw, result)
}
raw.CardNumber = "4111111111111111"
if got := dojoTerminalResult(raw).MaskedCardNumber; got != "" {
t.Errorf("dojoTerminalResult(unmasked PAN) masked=%q, want omitted", got)
}
}
func TestExpiredTerminalResultIsUncertain(t *testing.T) {
result := dojoTerminalResult(&paymentsvc.Result{Status: "EXPIRED"})
if result.Outcome != "unknown" || result.Retryable {
t.Errorf("dojoTerminalResult(EXPIRED)=%+v, want nonretryable unknown", result)
}
}
func TestConfirmedSignatureRejectionRemainsRetryable(t *testing.T) {
result := dojoTerminalResult(&paymentsvc.Result{Status: "SIGNATUREVERIFICATIONREJECTED"})
if result.Outcome != "declined" || result.Reason != "signature_verification" || !result.Retryable {
t.Errorf("dojoTerminalResult(signature rejected)=%+v, want safely retryable confirmed rejection", result)
}
}
+43
View File
@@ -0,0 +1,43 @@
package handlers
import (
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
)
func TestCardRoutesNeverExecuteStoredCommandAfterBuildFailure(t *testing.T) {
for _, path := range []string{"/issuedoorcard", "/testissuedoorcard"} {
t.Run(path, func(t *testing.T) {
d := &fakeDoorCardDispenser{}
lock := &fakeDoorCardLockServer{buildErr: errors.New("synthetic invalid lock command"), storedCommand: "PREVIOUS-ROOM"}
app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
r := httptest.NewRequest(http.MethodPost, path, strings.NewReader(`{"roomField":"CURRENT-ROOM","checkinTime":"2026-11-04 15:00:00 +0000","checkoutTime":"2026-11-05 11:00:00 +0000","followStr":"0"}`))
r.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
var response cmstypes.StatusRec
if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil {
t.Fatal(err)
}
if w.Code != http.StatusBadGateway || response.Code != http.StatusBadGateway || !strings.Contains(response.Message, "Build key command failed") {
t.Errorf("POST %s = %d %+v, want existing 502 JSON error", path, w.Code, response)
}
if lock.buildCalls != 1 || lock.sequenceCalls != 0 || lock.storedCommand != "PREVIOUS-ROOM" {
t.Errorf("POST %s build=%d sequence=%d stored=%q, want one rejected build and no execution of previous command", path, lock.buildCalls, lock.sequenceCalls, lock.storedCommand)
}
if !reflect.DeepEqual(d.calls, []string{"prepare current"}) || d.activity != 0 || d.outsideActivity {
t.Errorf("POST %s dispenser=%v active=%d outside=%t, want preparation only and released foreground", path, d.calls, d.activity, d.outsideActivity)
}
})
}
}
@@ -0,0 +1,56 @@
package handlers
import (
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
)
func TestCreditCallModernPreauthReportsActualReturnedAmount(t *testing.T) {
for _, total := range []string{"3100", "12000"} {
t.Run(total, func(t *testing.T) {
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": map[string]string{types.TransactionResult: "APPROVED", types.TransactionType: "SALE", types.TotalAmount: total, types.Reference: "SYNTH-HOLD"}})
})
database := preauthTestDatabase(t, app)
app.creditCallReceipt = func(string) {}
recorder := httptest.NewRecorder()
app.preauthPayment(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000"))
frames := decodePaymentStream(t, recorder.Body)
want := int64(12000)
if total == "3100" {
want = 3100
}
if len(frames) != 1 || frames[0].Result == nil || frames[0].Result.Outcome != "approved" || frames[0].Result.AmountMinor != want {
t.Errorf("Preauth(request12000,total%s) frames=%+v, want approved actual%d", total, frames, want)
}
if got := waitPreauthInsert(t, database)["TotalMinorUnits"]; got != total {
t.Errorf("Preauth(total%s) SQLamount=%v, want unchanged provider amount", total, got)
}
})
}
}
func TestCreditCallModernPreauthMalformedAmountRequiresReception(t *testing.T) {
for _, total := range []string{"bad", "-1", "9223372036854775808"} {
t.Run(total, func(t *testing.T) {
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": map[string]string{types.TransactionResult: "APPROVED", types.TransactionType: "ACCOUNT VERIFICATION", types.TotalAmount: total, types.Reference: "SYNTH-HOLD"}})
})
app.creditCallReceipt = func(string) {}
recorder := httptest.NewRecorder()
app.preauthPayment(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000"))
frames := decodePaymentStream(t, recorder.Body)
if len(frames) != 1 || frames[0].Result == nil {
t.Fatalf("Preauth(total%s) frames=%+v, want final uncertainty", total, frames)
}
final := frames[0].Result
if final.Outcome != "unknown" || final.Retryable || final.AmountMinor != 0 || final.Reason != "amount_unverified" {
t.Errorf("Preauth(total%s) final=%+v, want nonretryable unknown without fabricated amount", total, final)
}
})
}
}
+2 -8
View File
@@ -11,14 +11,8 @@ import (
log "github.com/sirupsen/logrus"
)
type creditCallPreauthRequest struct {
Amount string `json:"amount"`
TransactionType string `json:"transactionType"`
CheckoutDate string `json:"checkoutDate"`
}
func (app *App) streamCreditCallPreauth(w http.ResponseWriter, r *http.Request) {
app.streamCreditCall(w, r, true)
func (app *App) preauthPayment(w http.ResponseWriter, r *http.Request) {
app.streamPayment(w, r, true)
}
// executeCreditCallPreauth finalizes the existing unconfirmed transaction.
+21 -12
View File
@@ -7,11 +7,13 @@ import (
"encoding/json"
"encoding/xml"
"errors"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
"io"
"net/http"
"net/http/httptest"
"os"
"reflect"
"strconv"
"strings"
"sync/atomic"
"testing"
@@ -143,8 +145,8 @@ func TestCreditCallPreauthLegacyCharacterization(t *testing.T) {
t.Errorf("persisted=%v, want provider amount/reference", got)
}
departure := time.Date(2026, 9, 11, 0, 0, 0, 0, time.Local).UTC()
if got["DepartureDate"] != departure || got["ReleaseDate"] != departure.Add(48*time.Hour) {
t.Errorf("persisted dates=%v, want existing local midnight plus 48 hours", got)
if got["DepartureDate"] != departure || got["ReleaseDate"] != departure.Add(96*time.Hour) {
t.Errorf("persisted dates=%v, want existing local midnight plus 96 hours", got)
}
} else if c.count.Load() != 0 {
t.Error("non-persisting result inserted SQL")
@@ -154,7 +156,8 @@ func TestCreditCallPreauthLegacyCharacterization(t *testing.T) {
}
func preauthStreamRequest(amount, kind, checkout string) *http.Request {
body, _ := json.Marshal(creditCallPreauthRequest{Amount: amount, TransactionType: kind, CheckoutDate: checkout})
value, _ := strconv.ParseInt(amount, 10, 64)
body, _ := json.Marshal(paymentapi.Request{Amount: value, CheckoutDate: checkout})
r := httptest.NewRequest(http.MethodPost, "/api/payment/preauth", strings.NewReader(string(body)))
r.Header.Set("Content-Type", "application/json")
return r
@@ -214,7 +217,7 @@ func TestCreditCallPreauthStreamingParity(t *testing.T) {
}
recorder := httptest.NewRecorder()
if stream {
app.streamCreditCallPreauth(recorder, preauthStreamRequest(amount, kind, date))
app.preauthPayment(recorder, preauthStreamRequest(amount, kind, date))
frames := decodePaymentStream(t, recorder.Body)
var statuses []string
for _, frame := range frames {
@@ -230,7 +233,7 @@ func TestCreditCallPreauthStreamingParity(t *testing.T) {
if final == nil {
t.Fatal("missing structured final")
}
if (final.Outcome == "approved") != tc.approved || final.Status != legacy.Status || final.HTTPStatus != 200 {
if (final.Outcome == "approved") != tc.approved || final.HTTPStatus != 200 {
t.Errorf("stream final=%+v, legacy=%+v", final, legacy)
}
if tc.approved && (final.TransactionReference != "preauth-ref" || final.CardType != "Visa" || final.MaskedCardNumber != "************1133" || final.ExpiryDate != "1228" || final.CardHash != "hash" || final.CardReference != "cardref") {
@@ -296,9 +299,9 @@ func TestCreditCallInboundCancellationAfterDispatch(t *testing.T) {
go func() {
defer close(done)
if preauth {
app.streamCreditCallPreauth(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000").WithContext(ctx))
app.preauthPayment(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000").WithContext(ctx))
} else {
app.streamCreditCallSale(recorder, saleRequest(true).WithContext(ctx))
app.salePayment(recorder, saleRequest(true).WithContext(ctx))
}
}()
select {
@@ -342,9 +345,9 @@ func TestCreditCallPreauthMissingAmountNeverSynthesized(t *testing.T) {
c := preauthTestDatabase(t, app)
app.creditCallReceipt = func(string) {}
recorder := httptest.NewRecorder()
app.streamCreditCallPreauth(recorder, preauthStreamRequest("9999", "Sale", "2026-09-11 00:00:00 +0000"))
app.preauthPayment(recorder, preauthStreamRequest("9999", "Sale", "2026-09-11 00:00:00 +0000"))
frames := decodePaymentStream(t, recorder.Body)
if frames[0].Result.Outcome != "approved" {
if frames[0].Result.Outcome != "approved" || frames[0].Result.AmountMinor != 9999 {
t.Fatalf("missing amount changed approval: %+v", frames[0].Result)
}
deadline := time.Now().Add(3 * time.Second)
@@ -378,16 +381,22 @@ func TestCreditCallPreauthStreamFailureAndCancelledBeforeDispatch(t *testing.T)
app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) { calls++; return transport.RoundTrip(r) })
app.creditCallReceipt = func(string) { t.Error("malformed stream printed receipt") }
recorder := httptest.NewRecorder()
app.streamCreditCallPreauth(recorder, preauthStreamRequest("", "AccountVerification", ""))
app.preauthPayment(recorder, preauthStreamRequest("", "AccountVerification", ""))
frames := decodePaymentStream(t, recorder.Body)
if calls != 1 || len(frames) != 1 || frames[0].Result.Outcome != "error" || frames[0].Result.HTTPStatus != 502 {
if calls != 1 || len(frames) != 1 || frames[0].Result.Outcome != "unknown" || frames[0].Result.HTTPStatus != 502 {
t.Errorf("invalid stream %q: calls=%d frames=%+v", body, calls, frames)
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
app.streamCreditCallPreauth(httptest.NewRecorder(), preauthStreamRequest("", "AccountVerification", "").WithContext(ctx))
app.preauthPayment(httptest.NewRecorder(), preauthStreamRequest("", "AccountVerification", "").WithContext(ctx))
if calls != 1 {
t.Error("already-cancelled request dispatched a transaction")
}
}
}
type creditCallPreauthRequest struct {
Amount string `json:"amount"`
TransactionType string `json:"transactionType"`
CheckoutDate string `json:"checkoutDate"`
}
+91
View File
@@ -0,0 +1,91 @@
package handlers
import (
"context"
"net/http"
"strconv"
"strings"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
)
// creditCallProcessor delegates to the unchanged legacy execution/finalization core.
type creditCallProcessor struct{ app *App }
func (*creditCallProcessor) ValidatePreauth(req paymentsvc.SaleRequest) error {
if req.Amount < 0 {
return paymentsvc.ErrPreauthUnsupported
}
return nil
}
func (p *creditCallProcessor) Sale(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return p.run(ctx, req, status, false)
}
func (p *creditCallProcessor) Preauth(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return p.run(ctx, req, status, true)
}
func (p *creditCallProcessor) run(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler, preauth bool) (*paymentsvc.Result, error) {
transaction := cmstypes.TransactionRec{AmountMinorUnits: strconv.FormatInt(req.Amount, 10), TransactionType: "Sale", CheckoutDate: req.CheckoutDate}
if preauth && req.Amount == 0 {
transaction.AmountMinorUnits = ""
transaction.TransactionType = "AccountVerification"
}
start := func(client *http.Client) (creditcall.TransactionResultXML, error) {
return callChipDNATransactionStream(context.WithoutCancel(ctx), client, transaction, func(code string) {
if status != nil {
status(paymentsvc.StatusUpdate{Code: code})
}
})
}
var outcome creditCallSaleOutcome
if preauth {
// The existing asynchronous PREAUTH persistence must outlive response delivery.
outcome = p.app.executeCreditCallPreauth(context.WithoutCancel(ctx), transaction, start)
} else {
outcome = p.app.executeCreditCallSale(transaction, start)
}
final := outcome.streamResult()
final.AmountMinor, final.CurrencyCode = req.Amount, req.Currency
if outcome.Approved {
if raw := outcome.Payment.Fields[types.TotalAmount]; raw != "" {
amount, err := strconv.ParseInt(raw, 10, 64)
if err != nil || amount < 0 {
final.Outcome, final.Retryable = "unknown", false
final.AmountMinor = 0
final.Reason = "amount_unverified"
final.Message = "Payment amount uncertain; contact reception"
} else {
final.AmountMinor = amount
}
}
}
return &paymentsvc.Result{Terminal: final}, nil
}
func (outcome creditCallSaleOutcome) streamResult() paymentapi.Result {
final := paymentapi.Result{Outcome: "unknown", HTTPStatus: outcome.HTTPStatus, Provider: "creditcall", Message: "Payment outcome uncertain; contact reception"}
if final.HTTPStatus == 0 {
final.HTTPStatus = http.StatusOK
}
if outcome.Approved {
fields := outcome.Payment.Fields
final.Outcome, final.Message = "approved", "Payment approved"
final.TransactionReference = fields[types.Reference]
final.CardType = fields[types.CardType]
final.MaskedCardNumber = creditcall.MaskedCardNumber(fields[types.PanMasked])
final.ExpiryDate = fields[types.ExpiryDate]
final.CardHash, final.CardReference = fields[types.CardHash], fields[types.CardReference]
} else {
switch strings.ToLower(outcome.FailureType) {
case "declined":
final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined"
case "cancelled", "canceled":
final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled"
}
}
return final
}
+10 -9
View File
@@ -75,7 +75,7 @@ func TestCreditCallStreamFailureNeverRestartsOrConfirms(t *testing.T) {
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 != "error" || frames[1].Result.HTTPStatus != 502 {
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)
}
}
@@ -185,13 +185,15 @@ func newCreditCallTestApp(t *testing.T, handler http.HandlerFunc) *App {
if err != nil {
t.Fatal(err)
}
return &App{isPayment: true, creditCallStreamEnabled: true, cfg: &config.ConfigRec{TimeoutSeconds: 1},
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 {
@@ -292,7 +294,7 @@ func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) {
t.Fatalf("frames = %+v, want two ordered hints and one final", frames)
}
final := frames[2].Result
if final.HTTPStatus != http.StatusOK || final.Status != legacy.Status || (final.Outcome == "approved") != test.approved {
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)
@@ -303,12 +305,10 @@ func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) {
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.Message != parsed.Query().Get("Description") {
} else if final.Outcome == "approved" {
t.Errorf("structured message = %q, legacy description = %q", final.Message, parsed.Query().Get("Description"))
}
if frames[2].Response != nil {
t.Error("CreditCall stream included legacy response")
}
}
})
}
@@ -318,7 +318,8 @@ func TestCreditCallConfirmationRetryAndFailureParity(t *testing.T) {
for _, streaming := range []bool{false, true} {
var attempts int
var times []time.Time
app := &App{isPayment: true, creditCallStreamEnabled: true, cfg: &config.ConfigRec{}}
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 {
@@ -349,7 +350,7 @@ func TestCreditCallConfirmationRetryAndFailureParity(t *testing.T) {
}
if streaming {
frames := decodePaymentStream(t, recorder.Body)
if len(frames) != 1 || frames[0].Result.HTTPStatus != 502 || frames[0].Result.Status.Code != 500 || frames[0].Result.Message != "Transaction error" {
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 {
+4 -172
View File
@@ -10,184 +10,16 @@ import (
"io"
"net/http"
"strconv"
"strings"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
)
type creditCallStreamResult struct {
Outcome string `json:"outcome"`
Message string `json:"message"`
HTTPStatus int `json:"httpStatus"`
Status cmstypes.StatusRec `json:"status"`
TransactionReference string `json:"transactionReference,omitempty"`
CardType string `json:"cardType,omitempty"`
MaskedCardNumber string `json:"maskedCardNumber,omitempty"`
ExpiryDate string `json:"expiryDate,omitempty"`
CardHash string `json:"cardHash,omitempty"`
CardReference string `json:"cardReference,omitempty"`
}
func (outcome creditCallSaleOutcome) streamResult() creditCallStreamResult {
result := creditCallStreamResult{
Outcome: "error", HTTPStatus: outcome.HTTPStatus, Status: outcome.Status,
Message: creditcall.FailureDescription(outcome.FailureType, outcome.FailureDescription),
}
if !outcome.Approved {
switch strings.ToLower(outcome.FailureType) {
case "declined":
result.Outcome = "declined"
case "cancelled", "canceled":
result.Outcome = "cancelled"
case "timeout":
result.Outcome = "timeout"
}
return result
}
fields := outcome.Payment.Fields
result.Outcome = "approved"
result.Message = "Payment approved"
result.TransactionReference = fields[types.Reference]
result.CardType = fields[types.CardType]
result.MaskedCardNumber = creditcall.MaskedCardNumber(fields[types.PanMasked])
result.ExpiryDate = fields[types.ExpiryDate]
result.CardHash = fields[types.CardHash]
result.CardReference = fields[types.CardReference]
return result
}
// EnableCreditCallStreaming selects the CreditCall core without a generic provider.
func (app *App) EnableCreditCallStreaming() { app.creditCallStreamEnabled = true }
func (app *App) streamCreditCallSale(w http.ResponseWriter, r *http.Request) {
app.streamCreditCall(w, r, false)
}
func (app *App) streamCreditCall(w http.ResponseWriter, r *http.Request, preauth bool) {
setPaymentCORS(w)
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("X-Content-Type-Options", "nosniff")
controller := http.NewResponseController(w)
encoder := json.NewEncoder(w)
deliveryFailed := false
// Only this handler writes the response. The transaction worker never waits
// for network delivery, including when the peer stops reading without closing.
send := func(frame paymentStreamMessage) {
if deliveryFailed || r.Context().Err() != nil {
deliveryFailed = true
return
}
if err := encoder.Encode(frame); err != nil {
deliveryFailed = true
return
}
if err := controller.Flush(); err != nil {
deliveryFailed = true
return
}
}
reject := func(status int, message string) {
result := creditCallStreamResult{Outcome: "error", Message: message, HTTPStatus: status,
Status: cmstypes.StatusRec{Code: status, Message: http.StatusText(status)}}
w.WriteHeader(status)
send(paymentStreamMessage{Type: "result", Result: &result})
}
if preauth && !app.creditCallStreamEnabled {
reject(http.StatusServiceUnavailable, "CreditCall preauthorization streaming is not enabled")
return
}
if !app.isPayment && !app.cfg.TestMode {
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment Error", "Attempted payment while payment processing is disabled")
reject(http.StatusServiceUnavailable, "Payment processing is disabled")
return
}
if r.Method != http.MethodPost {
reject(http.StatusMethodNotAllowed, "Method not allowed; use POST")
return
}
if ct := r.Header.Get("Content-Type"); ct != "" && !strings.Contains(ct, "application/json") {
reject(http.StatusUnsupportedMediaType, "Content-Type must be application/json")
return
}
defer r.Body.Close()
var transaction cmstypes.TransactionRec
if preauth {
var request creditCallPreauthRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
reject(http.StatusBadRequest, "Invalid JSON payload")
return
}
transaction = cmstypes.TransactionRec{AmountMinorUnits: request.Amount, TransactionType: request.TransactionType, CheckoutDate: request.CheckoutDate}
} else {
var request SalePaymentRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
reject(http.StatusBadRequest, "Invalid JSON payload")
return
}
if request.Amount <= 0 {
reject(http.StatusBadRequest, "Amount must be greater than zero")
return
}
transaction = cmstypes.TransactionRec{AmountMinorUnits: strconv.FormatInt(request.Amount, 10), TransactionType: "Sale"}
}
if _, ok := w.(http.Flusher); !ok {
reject(http.StatusInternalServerError, "Streaming payment updates are not supported")
return
}
// Validation belongs to the incoming request. This handoff owns financial dispatch.
if r.Context().Err() != nil {
return
}
financialContext := context.WithoutCancel(r.Context())
progress := make(chan string, 128)
finished := make(chan creditCallSaleOutcome, 1)
go func() {
start := func(client *http.Client) (creditcall.TransactionResultXML, error) {
return callChipDNATransactionStream(financialContext, client, transaction, func(code string) {
select {
case progress <- code:
default: // Observational progress may be dropped under backpressure.
}
})
}
var outcome creditCallSaleOutcome
if preauth {
outcome = app.executeCreditCallPreauth(financialContext, transaction, start)
} else {
outcome = app.executeCreditCallSale(transaction, start)
}
close(progress)
finished <- outcome // Independent of the bounded progress queue.
}()
for {
select {
case code, ok := <-progress:
if !ok {
progress = nil
continue
}
send(paymentStreamMessage{Type: "status", Code: code})
case outcome := <-finished:
if progress != nil {
for code := range progress {
send(paymentStreamMessage{Type: "status", Code: code})
}
}
result := outcome.streamResult()
send(paymentStreamMessage{Type: "result", Result: &result})
return
}
}
// EnableCreditCallStreaming selects the existing CreditCall execution core.
func (app *App) EnableCreditCallStreaming() {
app.paymentService = paymentsvc.NewService(&creditCallProcessor{app: app})
}
func callChipDNAStream(client *http.Client, amount int64, onStatus func(string)) (creditcall.TransactionResultXML, error) {
+7 -1
View File
@@ -90,12 +90,18 @@ type fakeDoorCardLockServer struct {
sequence func() error
sequenceErr error
buildErr error
storedCommand string
buildCalls int
sequenceCalls int
}
func (l *fakeDoorCardLockServer) BuildCommand(lockserver.DoorCardRequest, time.Time, time.Time) error {
func (l *fakeDoorCardLockServer) BuildCommand(request lockserver.DoorCardRequest, _ time.Time, _ time.Time) error {
l.buildCalls++
if l.buildErr != nil {
return l.buildErr
}
l.storedCommand = request.RoomField
return nil
}
+41 -32
View File
@@ -37,20 +37,20 @@ type doorCardDispenser interface {
}
type App struct {
disp doorCardDispenser
lockserver lockserver.LockServer
paymentService *paymentsvc.Service
creditCallStreamEnabled bool
creditCallTransport http.RoundTripper
creditCallReceipt func(string)
isPayment bool
db *sql.DB
cfg *config.ConfigRec
dbMu sync.Mutex
cardWellMu sync.RWMutex
cardWellStatus string
availabilityMu sync.Mutex
availabilityTimers map[string]*time.Timer
trustSelected bool
disp doorCardDispenser
lockserver lockserver.LockServer
paymentService *paymentsvc.Service
creditCallTransport http.RoundTripper
creditCallReceipt func(string)
isPayment bool
db *sql.DB
cfg *config.ConfigRec
dbMu sync.Mutex
cardWellMu sync.RWMutex
cardWellStatus string
availabilityMu sync.Mutex
availabilityTimers map[string]*time.Timer
}
func NewApp(disp *dispenser.Client, lockType, encoderAddress, cardWellStatus string, db *sql.DB, cfg *config.ConfigRec) *App {
@@ -66,6 +66,13 @@ func NewApp(disp *dispenser.Client, lockType, encoderAddress, cardWellStatus str
return app
}
// SetPaymentCurrency supplies the CMS currency to the selected modern processor.
func (app *App) SetPaymentCurrency(currency string) {
if app.paymentService != nil {
app.paymentService.SetCurrency(currency)
}
}
func (app *App) SetPaymentService(service *paymentsvc.Service) {
app.paymentService = service
}
@@ -80,10 +87,14 @@ func (app *App) RegisterRoutes(mux *http.ServeMux) {
mux.HandleFunc("/ping-pdq", app.fetchChipDNAStatus)
mux.HandleFunc("/logerror", app.onChipDNAError)
mux.HandleFunc("/api/payment/sale", app.salePayment)
mux.HandleFunc("/api/payment/preauth", app.streamCreditCallPreauth)
mux.HandleFunc("/api/payment/preauth", app.preauthPayment)
}
func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
if app.trustSelected {
http.Error(w, "Trust uses /api/payment/preauth", http.StatusConflict)
return
}
const op = logging.Op("takePreauthorization")
var (
@@ -164,6 +175,10 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
}
func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
if app.trustSelected {
http.Error(w, "Trust uses /api/payment/sale", http.StatusConflict)
return
}
const op = logging.Op("takePayment")
var (
@@ -251,16 +266,8 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
theResponse cmstypes.StatusRec
)
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
w.Header().Set("Content-Type", "application/json")
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
log.Println("issueDoorCard called")
if r.Method != http.MethodPost {
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
@@ -314,7 +321,11 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
// doorReq.RoomField = "104"
// build lock server command
app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
if err := app.lockserver.BuildCommand(doorReq, checkIn, checkOut); err != nil {
logging.Error(types.ServiceName, err.Error(), "Build key command", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusBadGateway, "Build key command failed: "+err.Error())
return
}
// Each request performs at most one encoder operation.
encodingStarted := time.Now()
@@ -374,15 +385,7 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
func (app *App) printRoomTicket(w http.ResponseWriter, r *http.Request) {
const op = logging.Op("printRoomTicket")
var roomDetails printer.RoomDetailsRec
// Allow CORS preflight if needed
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
log.Println("printRoomTicket called")
if r.Method != http.MethodPost {
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use POST")
@@ -424,6 +427,12 @@ func (app *App) printRoomTicket(w http.ResponseWriter, r *http.Request) {
}
func (app *App) reportDispenserStatus(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
w.Header().Set("Allow", http.MethodGet)
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use GET")
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_ = json.NewEncoder(w).Encode(cmstypes.StatusRec{
+231
View File
@@ -0,0 +1,231 @@
package handlers
import (
"context"
"encoding/json"
"encoding/xml"
"fmt"
"io"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"sync/atomic"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
)
func TestModernRoutesRejectNonPOSTWithoutDispatch(t *testing.T) {
var payments atomic.Int32
d := &fakeDoorCardDispenser{}
lock := &fakeDoorCardLockServer{}
provider := paymentProviderFunc(func(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
payments.Add(1)
return nil, nil
})
app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock, isPayment: true, paymentService: paymentsvc.NewService(provider)}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
for _, path := range []string{"/issuedoorcard", "/printroomticket", "/api/payment/sale", "/api/payment/preauth"} {
for _, method := range []string{http.MethodGet, http.MethodOptions, http.MethodPut} {
t.Run(method+path, func(t *testing.T) {
r := httptest.NewRequest(method, path, nil)
r.Header.Set("Origin", "http://retired-browser.invalid")
r.Header.Set("Access-Control-Request-Method", http.MethodPost)
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
if w.Code != http.StatusMethodNotAllowed {
t.Errorf("%s %s status = %d, want 405", method, path, w.Code)
}
for key := range w.Header() {
if strings.HasPrefix(key, "Access-Control-") {
t.Errorf("%s %s header %s = %q, want no browser CORS", method, path, key, w.Header().Get(key))
}
}
if strings.HasPrefix(path, "/api/payment/") {
frames := decodePaymentStream(t, w.Body)
if len(frames) != 1 || frames[0].Result == nil || frames[0].Result.HTTPStatus != 405 || frames[0].Result.Reason != "invalid_request" {
t.Errorf("%s %s frames = %+v, want one structured method rejection", method, path, frames)
}
}
})
}
}
if payments.Load() != 0 || len(d.calls) != 0 || lock.sequenceCalls != 0 {
t.Errorf("Rejected requests dispatched payments=%d dispenser=%v encoder=%d, want none", payments.Load(), d.calls, lock.sequenceCalls)
}
}
func TestOperationalDiagnosticIssuanceRetainsEncodedCard(t *testing.T) {
d := &fakeDoorCardDispenser{}
lock := &fakeDoorCardLockServer{}
app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
r := httptest.NewRequest(http.MethodPost, "/testissuedoorcard", strings.NewReader(`{"roomField":"SYNTH-101"}`))
r.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
if w.Code != http.StatusOK || lock.buildCalls != 1 || lock.sequenceCalls != 1 || !reflect.DeepEqual(d.calls, []string{"prepare current"}) {
t.Errorf("Diagnostic issuance status=%d build=%d encode=%d dispenser=%v, want 200, one build/encode and preparation only", w.Code, lock.buildCalls, lock.sequenceCalls, d.calls)
}
if d.activity != 0 || d.outsideActivity {
t.Errorf("Diagnostic issuance activity=%d outside=%t, want released foreground ownership", d.activity, d.outsideActivity)
}
}
func TestModernPOSTValidationHasNoBrowserCORS(t *testing.T) {
var dispatched bool
provider := paymentProviderFunc(func(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
dispatched = true
return nil, nil
})
app := &App{cfg: &config.ConfigRec{}, isPayment: true, paymentService: paymentsvc.NewService(provider)}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
for _, path := range []string{"/issuedoorcard", "/printroomticket", "/api/payment/sale", "/api/payment/preauth"} {
r := httptest.NewRequest(http.MethodPost, path, strings.NewReader("{"))
r.Header.Set("Origin", "http://retired-browser.invalid")
r.Header.Set("Content-Type", "application/json")
if path == "/printroomticket" {
r.Header.Set("Content-Type", "application/xml")
}
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
if w.Code != http.StatusBadRequest {
t.Errorf("POST %s with malformed payload = %d, want unchanged 400 validation", path, w.Code)
}
for key := range w.Header() {
if strings.HasPrefix(key, "Access-Control-") {
t.Errorf("POST %s header %s = %q, want no browser CORS", path, key, w.Header().Get(key))
}
}
}
if dispatched {
t.Error("Malformed modern POST dispatched a payment, want validation before dispatch")
}
}
func TestModernIssueDoorCardRouteStillDelivers(t *testing.T) {
d := &fakeDoorCardDispenser{}
lock := &fakeDoorCardLockServer{}
app := &App{cfg: &config.ConfigRec{}, disp: d, lockserver: lock}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
r := httptest.NewRequest(http.MethodPost, "/issuedoorcard", strings.NewReader(`{"roomField":"SYNTH-101","checkinTime":"2026-11-04 15:00:00 +0000","checkoutTime":"2026-11-05 11:00:00 +0000","followStr":"0"}`))
r.Header.Set("Content-Type", "application/json")
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
if w.Code != http.StatusOK || lock.sequenceCalls != 1 || !reflect.DeepEqual(d.calls, []string{"prepare current", "deliver current", "begin prepare next"}) {
t.Errorf("Normal issuance status=%d encode=%d dispenser=%v, want 200, one encoding, delivery and next preparation", w.Code, lock.sequenceCalls, d.calls)
}
if got := w.Header().Get("Access-Control-Allow-Origin"); got != "" {
t.Errorf("Normal issuance CORS = %q, want absent", got)
}
}
func TestOperationalDiagnosticsUseGET(t *testing.T) {
previous := http.DefaultTransport
var sidecarCalls int
http.DefaultTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
if r.Method != http.MethodPost || r.URL.Path != "/chipdna-status/" {
return nil, fmt.Errorf("unexpected synthetic sidecar request: %s %s", r.Method, r.URL.Path)
}
sidecarCalls++
deviceXML := `<ArrayOfPaymentDeviceStatus><PaymentDeviceStatus><ConfiguredDeviceId>SYNTH-PED</ConfiguredDeviceId><IsAvailable>true</IsAvailable></PaymentDeviceStatus></ArrayOfPaymentDeviceStatus>`
body, err := xml.Marshal(creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{{Key: creditcall.KeyPaymentDeviceStatus, Value: deviceXML}}})
if err != nil {
return nil, err
}
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(body))), Header: make(http.Header)}, nil
})
t.Cleanup(func() { http.DefaultTransport = previous })
app := &App{cfg: &config.ConfigRec{Hotel: "SYNTH", Kiosk: 9}, cardWellStatus: "Card present"}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
for _, path := range []string{"/dispenserstatus", "/ping-pdq"} {
for _, method := range []string{http.MethodPost, http.MethodOptions, http.MethodDelete} {
w := httptest.NewRecorder()
mux.ServeHTTP(w, httptest.NewRequest(method, path, nil))
if w.Code != 405 || w.Header().Get("Allow") != http.MethodGet {
t.Errorf("%s %s status=%d Allow=%q, want 405 and GET", method, path, w.Code, w.Header().Get("Allow"))
}
}
w := httptest.NewRecorder()
mux.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
var status cmstypes.StatusRec
if err := json.Unmarshal(w.Body.Bytes(), &status); err != nil {
t.Fatal(err)
}
if w.Code != 200 || status.Code != 200 || (path == "/dispenserstatus" && status.Message != "Card present") || (path == "/ping-pdq" && !strings.Contains(status.Message, "SYNTH-PED")) {
t.Errorf("GET %s = %d %+v, want unchanged diagnostic response", path, w.Code, status)
}
}
if sidecarCalls != 1 {
t.Errorf("Diagnostic sidecar calls = %d, want one for GET only", sidecarCalls)
}
}
func TestChipDNAErrorRoutePreservesXMLNotificationsAndDebounce(t *testing.T) {
previousTransport, previousClient, previousRecipients := http.DefaultTransport, http.DefaultClient, mail.SendErrorEmails
var notifications int
http.DefaultTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
if r.URL.Host != "api.mailjet.com" || r.Method != http.MethodPost {
return nil, fmt.Errorf("unexpected synthetic notification transport")
}
notifications++
body, err := io.ReadAll(r.Body)
if err != nil {
return nil, err
}
if !strings.Contains(string(body), "SYNTH-DEVICE-ERROR") || !strings.Contains(string(body), "SYNTH-HOTEL") {
t.Error("ChipDNA notification lacks synthetic hotel/error context")
}
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(`{"Messages":[{"Status":"success"}]}`)), Header: make(http.Header)}, nil
})
http.DefaultClient = &http.Client{Transport: http.DefaultTransport}
mail.SendErrorEmails = []string{"operator@example.test"}
app := &App{cfg: &config.ConfigRec{Hotel: "SYNTH-HOTEL", Kiosk: 9}, availabilityTimers: make(map[string]*time.Timer)}
t.Cleanup(func() {
app.availabilityMu.Lock()
for _, timer := range app.availabilityTimers {
timer.Stop()
}
app.availabilityMu.Unlock()
http.DefaultTransport, http.DefaultClient, mail.SendErrorEmails = previousTransport, previousClient, previousRecipients
})
mux := http.NewServeMux()
app.RegisterRoutes(mux)
post := func(key, value string) {
t.Helper()
body, err := xml.Marshal(creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{{Key: key, Value: value}}})
if err != nil {
t.Fatal(err)
}
r := httptest.NewRequest(http.MethodPost, "/logerror", strings.NewReader(string(body)))
r.Header.Set("Content-Type", "application/xml")
w := httptest.NewRecorder()
mux.ServeHTTP(w, r)
if w.Code != 200 || w.Body.String() != `{"status":"received"}` {
t.Errorf("POST /logerror(%s) = %d %s, want unchanged acknowledgement", key, w.Code, w.Body.String())
}
}
post(creditcall.KeyErrors, "SYNTH-DEVICE-ERROR")
post(creditcall.KeyIsAvailable, "false")
key := app.availabilityKey()
first := app.availabilityTimers[key]
post(creditcall.KeyIsAvailable, "false")
if first == nil || len(app.availabilityTimers) != 1 || app.availabilityTimers[key] != first {
t.Errorf("Repeated unavailable notifications timers=%d, want same single debounce timer", len(app.availabilityTimers))
}
post(creditcall.KeyIsAvailable, "true")
if len(app.availabilityTimers) != 0 || notifications != 1 {
t.Errorf("Restored availability timers=%d notifications=%d, want zero timers and one error notification", len(app.availabilityTimers), notifications)
}
}
+22
View File
@@ -0,0 +1,22 @@
package handlers
import (
"errors"
"net/http"
"os"
"testing"
)
type offlineDefaultTransport struct{}
func (offlineDefaultTransport) RoundTrip(*http.Request) (*http.Response, error) {
return nil, errors.New("offline handler tests prohibit default network access")
}
func TestMain(m *testing.M) {
// Fixtures supply in-memory transports or httptest server-specific clients.
// In particular, error-notification code cannot reach a live email service.
http.DefaultTransport = offlineDefaultTransport{}
http.DefaultClient = &http.Client{Transport: http.DefaultTransport}
os.Exit(m.Run())
}
+147 -296
View File
@@ -2,339 +2,190 @@ package handlers
import (
"context"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/url"
"strings"
"sync"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/mail"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
"github.com/google/uuid"
log "github.com/sirupsen/logrus"
)
type SalePaymentRequest struct {
Reference string `json:"reference,omitempty"`
ConfirmNo string `json:"confirmNo,omitempty"`
Amount int64 `json:"amount"`
Currency string `json:"currency,omitempty"`
}
type paymentStreamMessage struct {
Type string `json:"type"`
Code string `json:"code,omitempty"`
Response *cmstypes.ResponseRec `json:"response,omitempty"`
Result *creditCallStreamResult `json:"result,omitempty"`
}
func (app *App) salePayment(w http.ResponseWriter, r *http.Request) {
const op = logging.Op("salePayment")
if app.creditCallStreamEnabled {
app.streamCreditCallSale(w, r)
return
}
response := cmstypes.ResponseRec{
Status: cmstypes.StatusRec{
Code: http.StatusInternalServerError,
Message: http.StatusText(http.StatusInternalServerError),
},
}
setPaymentCORS(w)
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusNoContent)
return
}
if r.Method != http.MethodPost {
response.Data = buildPaymentFailureURL(types.ResultError, "Method not allowed; use POST")
writeTransactionResult(w, http.StatusMethodNotAllowed, response)
return
}
if app.paymentService == nil {
mail.SendEmailOnError(
app.cfg.Hotel,
app.cfg.Kiosk,
"Payment Service Not Configured",
"Payment service is not configured; cannot process payment requests",
)
response.Data = buildPaymentFailureURL(types.ResultError, "Payment service is not configured")
writeTransactionResult(w, http.StatusInternalServerError, response)
return
}
if ct := r.Header.Get("Content-Type"); ct != "" && !strings.Contains(ct, "application/json") {
response.Data = buildPaymentFailureURL(types.ResultError, "Content-Type must be application/json")
writeTransactionResult(w, http.StatusUnsupportedMediaType, response)
return
}
defer r.Body.Close()
var req SalePaymentRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
logging.Error(
types.ServiceName,
err.Error(),
"ReadJSON",
string(op),
"",
app.cfg.Hotel,
app.cfg.Kiosk,
)
response.Data = buildPaymentFailureURL(types.ResultError, "invalid JSON payload: "+err.Error())
writeTransactionResult(w, http.StatusBadRequest, response)
return
}
if req.Amount <= 0 {
response.Data = buildPaymentFailureURL(types.ResultError, "Amount must be greater than zero")
writeTransactionResult(w, http.StatusBadRequest, response)
return
}
if req.Currency == "" {
req.Currency = "GBP"
}
if req.Reference == "" {
req.Reference = req.ConfirmNo
}
if req.Reference == "" {
req.Reference = uuid.NewString()
}
requestID := buildPaymentRequestID(req.Reference)
timeoutSeconds := app.cfg.TimeoutSeconds
if timeoutSeconds <= 0 {
timeoutSeconds = 300
}
ctx, cancel := context.WithTimeout(
r.Context(),
time.Duration(timeoutSeconds)*time.Second,
)
defer cancel()
flusher, ok := w.(http.Flusher)
if !ok {
response.Data = buildPaymentFailureURL(
types.ResultError,
"Streaming payment updates are not supported",
)
writeTransactionResult(w, http.StatusInternalServerError, response)
return
}
app.streamPayment(w, r, false)
}
func (app *App) streamPayment(w http.ResponseWriter, r *http.Request, preauth bool) {
w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("X-Content-Type-Options", "nosniff")
controller := http.NewResponseController(w)
encoder := json.NewEncoder(w)
var streamMu sync.Mutex
streamStarted := false
streamFailed := false
sendStreamMessage := func(message paymentStreamMessage) {
streamMu.Lock()
defer streamMu.Unlock()
if streamFailed {
return
deliveryFailed := false
deliveryFailure := ""
send := func(frame paymentapi.Frame) bool {
if deliveryFailed {
return false
}
if err := encoder.Encode(message); err != nil {
streamFailed = true
return
if r.Context().Err() != nil {
deliveryFailure = "client_disconnected"
return false
}
streamStarted = true
flusher.Flush()
if err := controller.SetWriteDeadline(time.Now().Add(5 * time.Second)); err != nil && !errors.Is(err, http.ErrNotSupported) {
deliveryFailure = paymentsvc.SafeErrorCategory(err)
return false
}
if err := encoder.Encode(frame); err != nil {
deliveryFailed = true
deliveryFailure = paymentsvc.SafeErrorCategory(err)
return false
}
if err := controller.Flush(); err != nil {
deliveryFailed = true
deliveryFailure = paymentsvc.SafeErrorCategory(err)
return false
}
return true
}
onStatus := func(update paymentsvc.StatusUpdate) {
if update.Code == "" {
return
}
sendStreamMessage(paymentStreamMessage{
Type: "status",
Code: update.Code,
})
reject := func(code int, reason, message string) {
w.WriteHeader(code)
result := paymentapi.Result{Outcome: "error", HTTPStatus: code, Reason: reason, Message: message}
send(paymentapi.Frame{Type: "result", Result: &result})
}
result, err := app.paymentService.Sale(
ctx,
paymentsvc.SaleRequest{
RequestID: requestID,
Reference: req.Reference,
Amount: req.Amount,
Currency: req.Currency,
},
onStatus,
)
if err != nil {
status := http.StatusBadGateway
if errors.Is(err, paymentsvc.ErrPaymentInProgress) {
status = http.StatusConflict
}
logging.Error(
types.ServiceName,
err.Error(),
"Payment provider error",
string(op),
req.Reference,
app.cfg.Hotel,
app.cfg.Kiosk,
)
response.Status.Code = status
response.Status.Message = http.StatusText(status)
response.Data = buildPaymentFailureURL(types.ResultError, err.Error())
if !streamStarted {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
writeTransactionResult(w, status, response)
return
}
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
if r.Method != http.MethodPost {
reject(http.StatusMethodNotAllowed, "invalid_request", "Use POST")
return
}
if result == nil {
response.Status.Code = http.StatusBadGateway
response.Status.Message = "Empty payment result"
response.Data = buildPaymentFailureURL(
types.ResultError,
"Payment provider returned an empty result",
)
if !streamStarted {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
writeTransactionResult(w, http.StatusBadGateway, response)
if !app.isPayment || app.paymentService == nil {
reject(http.StatusServiceUnavailable, "terminal_unavailable", "Payment service is unavailable")
return
}
if ct := r.Header.Get("Content-Type"); ct != "" && !strings.Contains(ct, "application/json") {
reject(http.StatusUnsupportedMediaType, "invalid_request", "Use application/json")
return
}
defer r.Body.Close()
var input paymentapi.Request
if json.NewDecoder(http.MaxBytesReader(w, r.Body, 64*1024)).Decode(&input) != nil {
reject(http.StatusBadRequest, "invalid_request", "Invalid JSON payload")
return
}
if input.Amount < 0 || (!preauth && input.Amount == 0) {
reject(http.StatusBadRequest, "invalid_request", "Invalid payment amount")
return
}
if input.RequiredPreauth != nil && input.RequiredPreauth.Amount < 0 {
reject(http.StatusBadRequest, "invalid_request", "Invalid required preauthorisation amount")
return
}
if _, ok := w.(http.Flusher); !ok {
reject(http.StatusInternalServerError, "stream_unavailable", "Streaming payment updates are unavailable")
return
}
if r.Context().Err() != nil {
return
}
if input.Reference == "" {
input.Reference = uuid.NewString()
}
req := paymentsvc.SaleRequest{RequestID: buildPaymentRequestID(input.Reference), Reference: input.Reference, Amount: input.Amount, Currency: input.Currency, CheckoutDate: input.CheckoutDate, RequiredPreauth: input.RequiredPreauth}
operation := paymentapi.Sale
if preauth {
operation = paymentapi.Preauth
}
reconciliationFields := func(final paymentapi.Result) log.Fields {
return log.Fields{
"hotel": app.cfg.Hotel, "kiosk": app.cfg.Kiosk, "operation": operation,
"request_id": req.RequestID, "request_reference": req.Reference,
"provider": final.Provider, "transaction_reference": final.TransactionReference,
"outcome": final.Outcome, "reason": final.Reason,
}
}
progress := make(chan string, 128)
finished := make(chan paymentapi.Result, 1)
go func() {
// Financial dispatch owns its lifetime; HTTP disconnect only ends observation.
timeout := app.cfg.TimeoutSeconds
if timeout <= 0 {
timeout = 300
}
timeout += 15 // Delivery/status margin; provider financial calls retain their own bounds.
ctx, cancel := context.WithTimeout(context.WithoutCancel(r.Context()), time.Duration(timeout)*time.Second)
defer cancel()
status := func(update paymentsvc.StatusUpdate) {
if update.Code != "" {
select {
case progress <- update.Code:
default:
}
}
}
var result *paymentsvc.Result
var err error
if preauth {
result, err = app.paymentService.Preauth(ctx, req, status)
} else {
result, err = app.paymentService.Sale(ctx, req, status)
}
final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Message: "Payment outcome uncertain; contact reception"}
if result != nil {
final = result.Terminal
}
if err != nil {
switch {
case errors.Is(err, paymentsvc.ErrPaymentInProgress):
final = paymentapi.Result{Outcome: "error", HTTPStatus: http.StatusConflict, Reason: "payment_in_progress", Message: "Payment is already in progress"}
case errors.Is(err, paymentsvc.ErrPreauthUnsupported):
final = paymentapi.Result{Outcome: "error", HTTPStatus: http.StatusUnprocessableEntity, Reason: "unsupported_operation", Message: "Preauthorisation is unavailable; contact reception"}
case errors.Is(err, paymentsvc.ErrProviderNotConfigured):
final = paymentapi.Result{Outcome: "error", HTTPStatus: http.StatusServiceUnavailable, Reason: "terminal_unavailable", Message: "Payment service is unavailable"}
}
}
if final.Outcome == "" {
final = paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Message: "Payment outcome uncertain; contact reception"}
}
if final.Outcome == "unknown" {
log.WithFields(reconciliationFields(final)).WithField("transport_error", err != nil).
Warn("Payment outcome requires reception reconciliation")
}
close(progress)
finished <- final
}()
for {
select {
case code, ok := <-progress:
if !ok {
progress = nil
continue
}
send(paymentapi.Frame{Type: "status", Code: code})
case final := <-finished:
if progress != nil {
for code := range progress {
send(paymentapi.Frame{Type: "status", Code: code})
}
}
if !send(paymentapi.Frame{Type: "result", Result: &final}) {
log.WithFields(reconciliationFields(final)).WithField("error_category", deliveryFailure).
Warn("Payment final result delivery failed; reception reconciliation required")
}
return
}
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
return
}
response.Status.Code = http.StatusOK
if result.Success && strings.EqualFold(result.Status, "APPROVED") {
printer.PrintSaleReceipt(result.CustomerReceipt)
response.Status.Message = result.Message
response.Data = buildPaymentSuccessURL(result)
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
return
}
description := result.ErrorMessage
if description == "" {
description = result.Message
}
if description == "" {
description = result.Status
}
log.Printf("Transaction failed: %s", description)
printer.PrintSaleReceipt(result.CustomerReceipt)
response.Status.Message = "Payment unsuccessful"
response.Data = buildPaymentFailureURL(types.ResultError, description)
sendStreamMessage(paymentStreamMessage{
Type: "result",
Response: &response,
})
}
func buildPaymentRequestID(reference string) string {
const prefix = "REQ_"
const maxLength = 60
suffix := fmt.Sprintf("_%d", time.Now().UnixMilli())
maxReferenceLength := maxLength - len(prefix) - len(suffix)
runes := []rune(reference)
if len(runes) > maxReferenceLength {
runes = runes[:maxReferenceLength]
}
return prefix + string(runes) + suffix
}
func setPaymentCORS(w http.ResponseWriter) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
w.Header().Set("Content-Type", "application/json")
}
func buildPaymentSuccessURL(result *paymentsvc.Result) string {
// txnReference := result.ReferenceNumber
// if txnReference == "" {
// txnReference = result.TransactionID
// }
q := url.Values{}
q.Set("CardNumber", hex.EncodeToString([]byte(result.CardNumber)))
q.Set("CardType", hex.EncodeToString([]byte(result.CardType)))
q.Set("ExpiryDate", hex.EncodeToString([]byte(result.ExpiryDate)))
q.Set("TxnReference", result.RequestID)
q.Set("CardHash", hex.EncodeToString([]byte(result.CardHash)))
q.Set("CardReference", hex.EncodeToString([]byte(result.CardReference)))
return (&url.URL{
Path: types.CheckinSuccessfulEndpoint,
RawQuery: q.Encode(),
}).String()
}
func buildPaymentFailureURL(msgType, description string) string {
log.WithFields(log.Fields{
types.LogFieldError: msgType,
types.LogFieldDescription: description,
}).Error("Transaction failed")
q := url.Values{}
q.Set("MsgType", msgType)
q.Set("Description", description)
return (&url.URL{
Path: types.CheckinUnsuccessfulEndpoint,
RawQuery: q.Encode(),
}).String()
}
+46 -114
View File
@@ -7,156 +7,88 @@ import (
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
)
type paymentProviderFunc func(
context.Context,
paymentsvc.SaleRequest,
paymentsvc.StatusHandler,
) (*paymentsvc.Result, error)
type paymentProviderFunc func(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error)
func (f paymentProviderFunc) Sale(
ctx context.Context,
request paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
return f(ctx, request, onStatus)
func (f paymentProviderFunc) Sale(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return f(ctx, req, status)
}
func (paymentProviderFunc) ValidatePreauth(paymentsvc.SaleRequest) error {
return paymentsvc.ErrPreauthUnsupported
}
func (paymentProviderFunc) Preauth(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return nil, paymentsvc.ErrPreauthUnsupported
}
type paymentStreamMessage = paymentapi.Frame
func TestSalePaymentStreamsTerminalUnavailableAsAuthoritativeUnsuccessfulResult(t *testing.T) {
provider := paymentProviderFunc(func(
_ context.Context,
request paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.TerminalUnavailable})
return &paymentsvc.Result{
RequestID: request.RequestID,
Operation: "SALE",
Status: "TERMINAL_UNAVAILABLE",
ErrorMessage: "Payment terminal is unavailable",
Amount: request.Amount,
Currency: request.Currency,
DeviceUsed: "terminal-1",
DeviceType: "Dojo Terminal",
}, nil
provider := paymentProviderFunc(func(_ context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
status(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
status(paymentsvc.StatusUpdate{Code: paymentstatus.TerminalUnavailable})
return &paymentsvc.Result{Terminal: paymentapi.Result{Outcome: "error", HTTPStatus: 200, Reason: "terminal_unavailable", Message: "Payment terminal is unavailable"}}, nil
})
recorder := performSalePaymentRequest(t, provider)
if recorder.Code != http.StatusOK {
t.Fatalf("outer status = %d, want %d", recorder.Code, http.StatusOK)
frames := decodePaymentStream(t, recorder.Body)
if recorder.Code != 200 || len(frames) != 3 || frames[0].Code != paymentstatus.Starting || frames[1].Code != paymentstatus.TerminalUnavailable || frames[2].Result == nil {
t.Fatalf("SalePayment() HTTP/frames=%d/%+v, want 200 and two statuses plus final", recorder.Code, frames)
}
messages := decodePaymentStream(t, recorder.Body)
if len(messages) != 3 {
t.Fatalf("stream messages = %#v, want two statuses and one result", messages)
final := frames[2].Result
if final.Outcome != "error" || final.Reason != "terminal_unavailable" || final.Retryable {
t.Errorf("SalePayment() final=%+v, want definite nonretryable terminal unavailability", final)
}
if messages[0].Type != "status" || messages[0].Code != paymentstatus.Starting ||
messages[1].Type != "status" || messages[1].Code != paymentstatus.TerminalUnavailable {
t.Fatalf("status frames = %#v", messages[:2])
}
final := messages[2]
if final.Type != "result" || final.Response == nil {
t.Fatalf("final frame = %#v", final)
}
if final.Response.Status.Code != http.StatusOK {
t.Fatalf("nested status = %d, want %d", final.Response.Status.Code, http.StatusOK)
}
resultURL, err := url.Parse(final.Response.Data)
if err != nil {
t.Fatal(err)
}
if resultURL.Path != types.CheckinUnsuccessfulEndpoint {
t.Fatalf("result path = %q, want %q", resultURL.Path, types.CheckinUnsuccessfulEndpoint)
}
if got := resultURL.Query().Get("Description"); got != "Payment terminal is unavailable" {
t.Fatalf("Description = %q", got)
}
body := recorder.Body.String()
for _, forbidden := range []string{
"Dojo returned HTTP 409",
"offline or currently in use",
"traceId",
"docs.dojo.tech",
} {
if strings.Contains(body, forbidden) {
t.Fatalf("stream exposed %q: %s", forbidden, body)
for _, forbidden := range []string{"Dojo returned HTTP 409", "offline or currently in use", "traceId", "docs.dojo.tech", "\"response\""} {
if strings.Contains(recorder.Body.String(), forbidden) {
t.Errorf("SalePayment() leaked %q", forbidden)
}
}
}
func TestSalePaymentRetainsNestedBadGatewayForProviderErrorsAfterStreamingStarts(t *testing.T) {
provider := paymentProviderFunc(func(
_ context.Context,
_ paymentsvc.SaleRequest,
onStatus paymentsvc.StatusHandler,
) (*paymentsvc.Result, error) {
onStatus(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
return nil, errors.New("provider failed")
func TestSalePaymentRetainsUncertaintyForProviderErrorsAfterStreamingStarts(t *testing.T) {
provider := paymentProviderFunc(func(_ context.Context, _ paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
status(paymentsvc.StatusUpdate{Code: paymentstatus.Starting})
return nil, errors.New("raw secret provider error")
})
recorder := performSalePaymentRequest(t, provider)
if recorder.Code != http.StatusOK {
t.Fatalf("outer status = %d, want streaming status %d", recorder.Code, http.StatusOK)
frames := decodePaymentStream(t, recorder.Body)
if len(frames) != 2 || frames[1].Result == nil || frames[1].Result.Outcome != "unknown" || frames[1].Result.Retryable {
t.Fatalf("SalePayment() frames=%+v, want progress then nonretryable uncertainty", frames)
}
messages := decodePaymentStream(t, recorder.Body)
if len(messages) != 2 || messages[1].Type != "result" || messages[1].Response == nil {
t.Fatalf("stream messages = %#v", messages)
}
if messages[1].Response.Status.Code != http.StatusBadGateway {
t.Fatalf("nested status = %d, want %d", messages[1].Response.Status.Code, http.StatusBadGateway)
}
resultURL, err := url.Parse(messages[1].Response.Data)
if err != nil {
t.Fatal(err)
}
if resultURL.Path != types.CheckinUnsuccessfulEndpoint {
t.Fatalf("result path = %q, want %q", resultURL.Path, types.CheckinUnsuccessfulEndpoint)
if strings.Contains(recorder.Body.String(), "secret") {
t.Error("SalePayment() exposed raw provider diagnostics")
}
}
func performSalePaymentRequest(t *testing.T, provider paymentsvc.Provider) *httptest.ResponseRecorder {
t.Helper()
app := &App{
paymentService: paymentsvc.NewService(provider),
cfg: &config.ConfigRec{
Hotel: "HOTEL",
Kiosk: 7,
TimeoutSeconds: 5,
},
}
request := httptest.NewRequest(
http.MethodPost,
"/api/payment/sale",
strings.NewReader(`{"reference":"BOOKING-123","amount":10852,"currency":"GBP"}`),
)
app := &App{isPayment: true, paymentService: paymentsvc.NewService(provider), cfg: &config.ConfigRec{TimeoutSeconds: 1}}
request := httptest.NewRequest(http.MethodPost, paymentapi.SalePath, strings.NewReader(`{"amount":1234,"currency":"GBP","reference":"SYNTH"}`))
request.Header.Set("Content-Type", "application/json")
recorder := httptest.NewRecorder()
app.salePayment(recorder, request)
return recorder
}
func decodePaymentStream(t *testing.T, body io.Reader) []paymentStreamMessage {
func decodePaymentStream(t *testing.T, body io.Reader) []paymentapi.Frame {
t.Helper()
var frames []paymentapi.Frame
decoder := json.NewDecoder(body)
var messages []paymentStreamMessage
for {
var message paymentStreamMessage
if err := decoder.Decode(&message); err != nil {
if errors.Is(err, io.EOF) {
return messages
}
t.Fatal(err)
var frame paymentapi.Frame
err := decoder.Decode(&frame)
if err == io.EOF {
return frames
}
messages = append(messages, message)
if err != nil {
t.Fatalf("DecodePaymentStream() error=%v, want valid frames", err)
}
frames = append(frames, frame)
}
}
+12 -2
View File
@@ -71,7 +71,11 @@ func (app *App) testIssueDoorCard(w http.ResponseWriter, r *http.Request) {
}
// build lock server command
app.lockserver.BuildCommand(doorReq, checkIn, checkOut)
if err := app.lockserver.BuildCommand(doorReq, checkIn, checkOut); err != nil {
logging.Error(types.ServiceName, err.Error(), "Build key command", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusBadGateway, "Build key command failed: "+err.Error())
return
}
// lock server sequence
if err := app.lockserver.LockSequence(); err != nil {
@@ -90,8 +94,14 @@ func (app *App) fetchChipDNAStatus(w http.ResponseWriter, r *http.Request) {
const op = logging.Op("fetchChipDNAStatus")
var theResponse cmstypes.StatusRec
if r.Method != http.MethodGet {
w.Header().Set("Allow", http.MethodGet)
errorhandlers.WriteError(w, http.StatusMethodNotAllowed, "Method not allowed; use GET")
return
}
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS")
w.Header().Set("Access-Control-Allow-Methods", "GET")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
w.Header().Set("Content-Type", "application/json")
status, err := creditcall.ReadPdqStatus(app.cfg.Hotel, app.cfg.Kiosk)
+156
View File
@@ -0,0 +1,156 @@
package handlers
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/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)
}
}
})
}
}
}
@@ -0,0 +1,12 @@
package handlers
import (
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments"
)
// SetTrustPayments selects Trust while preserving the deprecated endpoint guard.
func (app *App) SetTrustPayments(client *trustpayments.Client) {
app.trustSelected = true
app.paymentService = paymentsvc.NewService(&trustpayments.Processor{Client: client})
}
+314
View File
@@ -0,0 +1,314 @@
package handlers
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments"
)
type trustFixtureTransport func(*http.Request) (*http.Response, error)
func (f trustFixtureTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func fixtureTrustApp(t *testing.T, dir string) *trustFixtureApp {
t.Helper()
client, err := trustpayments.New(trustpayments.Config{BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "fixture-site", Password: "synthetic", Terminal: "fixture-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
}
if strings.HasSuffix(r.URL.Path, "/status") {
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(`{"errorcode":2003}`))}, nil
}
f, err := os.OpenFile(filepath.Join(dir, "starts"), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
if err != nil {
return nil, err
}
_, err = f.WriteString(input["refid"] + "\n")
closeErr := f.Close()
if err != nil {
return nil, err
}
if closeErr != nil {
return nil, closeErr
}
outcome, auth := "Approved", "123456"
if _, err := os.Stat(filepath.Join(dir, "decline-preauth")); err == nil && input["type"] == "preauth" {
outcome, auth = "Declined", ""
}
if _, err := os.Stat(filepath.Join(dir, "uncertain")); err == nil {
outcome, auth = "Pending", ""
}
body, _ := json.Marshal(map[string]string{"refid": input["refid"], "siteid": "fixture-site", "terminalserialnumber": "fixture-ped", "type": input["type"], "amount": input["amount"], "finalamount": input["amount"], "resultcode": outcome, "authcode": auth, "cardtype": "Visa", "last4": "1133", "receipt": "Receipt: 31\nSequence number: 42\nPAN: 4111111111111111"})
return &http.Response{StatusCode: 200, Body: io.NopCloser(bytes.NewReader(body))}, nil
})})
if err != nil {
t.Fatal(err)
}
app := &trustFixtureApp{App: &App{isPayment: true, cfg: &config.ConfigRec{Hotel: "SYNTH-HOTEL", Kiosk: 9}}, trustReceipt: func(string) {}}
app.SetTrustPayments(client)
app.SetPaymentService(paymentsvc.NewService(&trustpayments.Processor{Client: client, PrintReceipt: func(s string) { app.trustReceipt(s) }}))
return app
}
// This opt-in subprocess only uses an in-memory gateway and synthetic receipts.
func TestTrustFixtureProcess(t *testing.T) {
dir := os.Getenv("TRUST_FIXTURE_DIR")
if dir == "" {
t.Skip("offline subprocess helper")
}
app := fixtureTrustApp(t, dir)
mux := http.NewServeMux()
app.RegisterRoutes(mux)
server := httptest.NewServer(mux)
defer server.Close()
b, _ := json.Marshal(map[string]string{"url": server.URL})
if err := os.WriteFile(filepath.Join(dir, "ready.json"), b, 0600); err != nil {
t.Fatal(err)
}
for {
if _, err := os.Stat(filepath.Join(dir, "stop")); err == nil {
return
}
time.Sleep(10 * time.Millisecond)
}
}
func trustStreamRequest(preauth bool) *http.Request {
path, body := "/api/payment/sale", `{"reference":"SYNTH-BOOK","amount":2500,"currency":"GBP"}`
if preauth {
path, body = "/api/payment/preauth", `{"amount":2500,"currency":"GBP","transactionType":"Sale","checkoutDate":"synthetic"}`
}
r := httptest.NewRequest(http.MethodPost, path, strings.NewReader(body))
r.Header.Set("Content-Type", "application/json")
return r
}
func TestTrustExistingEndpointsAndSafeFrames(t *testing.T) {
for _, preauth := range []bool{false, true} {
t.Run(map[bool]string{false: "sale", true: "preauth"}[preauth], func(t *testing.T) {
dir := t.TempDir()
app := fixtureTrustApp(t, dir)
prints := 0
app.trustReceipt = func(s string) {
prints++
if strings.Contains(s, "4111111111111111") || !strings.Contains(s, "************1133") {
t.Error("unsafe or missing masked receipt")
}
}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
w := httptest.NewRecorder()
mux.ServeHTTP(w, trustStreamRequest(preauth))
decoder := json.NewDecoder(w.Body)
statuses, results := 0, 0
for {
var frame paymentStreamMessage
if err := decoder.Decode(&frame); err == io.EOF {
break
} else if err != nil {
t.Fatal(err)
}
if frame.Type == "status" {
statuses++
if strings.Contains(frame.Code, "PIN") || strings.Contains(frame.Code, "INSERT") {
t.Error("invented terminal prompt")
}
}
if frame.Result != nil {
results++
if frame.Result.Outcome != "approved" || frame.Result.AmountMinor != 2500 || frame.Result.CurrencyCode != "GBP" || frame.Result.ReceiptNumber != "31" || frame.Result.SequenceNumber != "42" {
t.Errorf("approved result=%+v", frame.Result)
}
}
}
if w.Code != 200 || statuses != 3 || results != 1 || prints != 1 {
t.Errorf("HTTP/statuses/results/prints=%d/%d/%d/%d", w.Code, statuses, results, prints)
}
starts, _ := os.ReadFile(filepath.Join(dir, "starts"))
if strings.Count(string(starts), "\n") != 1 {
t.Errorf("financial starts=%q", starts)
}
if strings.Contains(w.Body.String(), "4111111111111111") || strings.Contains(w.Body.String(), "synthetic") {
t.Error("private provider data escaped")
}
})
}
}
func TestTrustUnknownNeverDeclinesOrReposts(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "uncertain"), nil, 0600); err != nil {
t.Fatal(err)
}
app := fixtureTrustApp(t, dir)
app.trustReceipt = func(string) { t.Error("uncertain payment printed approval") }
w := httptest.NewRecorder()
app.streamTrustPayment(w, trustStreamRequest(false), false)
if !strings.Contains(w.Body.String(), `"outcome":"unknown"`) || strings.Contains(w.Body.String(), `"outcome":"declined"`) {
t.Errorf("uncertain stream=%s", w.Body.String())
}
starts, _ := os.ReadFile(filepath.Join(dir, "starts"))
if strings.Count(string(starts), "\n") != 1 {
t.Errorf("financial starts=%q", starts)
}
}
func TestTrustInvalidRequestsAndNoOperationAPI(t *testing.T) {
app := fixtureTrustApp(t, t.TempDir())
mux := http.NewServeMux()
app.RegisterRoutes(mux)
for _, body := range []string{`{"amount":0,"currency":"GBP"}`, `{`} {
w := httptest.NewRecorder()
r := httptest.NewRequest("POST", "/api/payment/sale", strings.NewReader(body))
mux.ServeHTTP(w, r)
if w.Code != 400 {
t.Errorf("invalid input=%q status=%d", body, w.Code)
}
}
w := httptest.NewRecorder()
mux.ServeHTTP(w, httptest.NewRequest("GET", "/api/payment/trust/v1/capabilities", nil))
if w.Code != 404 {
t.Errorf("removed operation API=%d", w.Code)
}
r := trustStreamRequest(false)
ctx, cancel := context.WithCancel(r.Context())
cancel()
w = httptest.NewRecorder()
mux.ServeHTTP(w, r.WithContext(ctx))
if w.Body.Len() != 0 {
t.Error("cancelled-before-dispatch request produced result")
}
}
type trustBlockingWriter struct {
entered chan struct{}
release chan struct{}
once sync.Once
}
func (w *trustBlockingWriter) Header() http.Header { return make(http.Header) }
func (w *trustBlockingWriter) WriteHeader(int) {}
func (w *trustBlockingWriter) Flush() {}
func (w *trustBlockingWriter) Write(p []byte) (int, error) {
w.once.Do(func() { close(w.entered) })
<-w.release
return len(p), nil
}
func TestTrustBackpressureAndDisconnectDoNotCancelFinancialWorker(t *testing.T) {
for _, disconnect := range []bool{false, true} {
t.Run(map[bool]string{false: "backpressure", true: "disconnect"}[disconnect], func(t *testing.T) {
app := fixtureTrustApp(t, t.TempDir())
printed := make(chan struct{})
var prints atomic.Int32
app.trustReceipt = func(string) { prints.Add(1); close(printed) }
writer := &trustBlockingWriter{entered: make(chan struct{}), release: make(chan struct{})}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() { app.streamTrustPayment(writer, trustStreamRequest(false).WithContext(ctx), false); close(done) }()
var once sync.Once
t.Cleanup(func() { once.Do(func() { close(writer.release) }); <-done })
select {
case <-writer.entered:
case <-time.After(3 * time.Second):
t.Fatal("handler did not reach blocked writer")
}
if disconnect {
cancel()
}
select {
case <-printed:
case <-time.After(3 * time.Second):
t.Fatal("delivery blocked provider finalization/printing")
}
once.Do(func() { close(writer.release) })
select {
case <-done:
case <-time.After(3 * time.Second):
t.Fatal("handler did not finish after delivery released")
}
if prints.Load() != 1 {
t.Errorf("prints=%d, want 1", prints.Load())
}
})
}
}
func TestTrustDisconnectDuringProviderCallAndConcurrentAdmission(t *testing.T) {
entered, release := make(chan struct{}), make(chan struct{})
var calls atomic.Int32
client, err := trustpayments.New(trustpayments.Config{BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "fixture-site", Password: "synthetic", Terminal: "fixture-ped", Currency: "GBP", Timezone: "Europe/London", Transport: trustFixtureTransport(func(r *http.Request) (*http.Response, error) {
calls.Add(1)
var input map[string]string
if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
return nil, err
}
close(entered)
<-release
if r.Context().Err() != nil {
t.Error("incoming disconnect cancelled admitted provider request")
}
body, _ := json.Marshal(map[string]string{"refid": input["refid"], "siteid": "fixture-site", "terminalserialnumber": "fixture-ped", "type": input["type"], "amount": input["amount"], "resultcode": "Approved"})
return &http.Response{StatusCode: 200, Body: io.NopCloser(bytes.NewReader(body))}, nil
})})
if err != nil {
t.Fatal(err)
}
app := &trustFixtureApp{App: &App{isPayment: true, cfg: &config.ConfigRec{}}, trustReceipt: func(string) {}}
app.SetTrustPayments(client)
app.SetPaymentService(paymentsvc.NewService(&trustpayments.Processor{Client: client, PrintReceipt: func(s string) { app.trustReceipt(s) }}))
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() {
app.streamTrustPayment(httptest.NewRecorder(), trustStreamRequest(false).WithContext(ctx), false)
close(done)
}()
var once sync.Once
t.Cleanup(func() { once.Do(func() { close(release) }); <-done })
select {
case <-entered:
case <-time.After(3 * time.Second):
t.Fatal("provider request was not admitted")
}
second := httptest.NewRecorder()
app.streamTrustPayment(second, trustStreamRequest(false), false)
if !strings.Contains(second.Body.String(), `"httpStatus":409`) {
t.Errorf("concurrent admission status=%d, want 409", second.Code)
}
cancel()
once.Do(func() { close(release) })
select {
case <-done:
case <-time.After(3 * time.Second):
t.Fatal("admitted provider did not finish after disconnect")
}
if calls.Load() != 1 {
t.Errorf("financial requests=%d, want 1", calls.Load())
}
}
type trustFixtureApp struct {
*App
trustReceipt func(string)
}
func (a *trustFixtureApp) streamTrustPayment(w http.ResponseWriter, r *http.Request, preauth bool) {
a.streamPayment(w, r, preauth)
}
+99 -25
View File
@@ -3,19 +3,24 @@ package paybridge
import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/url"
"strings"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
"github.com/gorilla/websocket"
log "github.com/sirupsen/logrus"
)
type Client struct {
PrintReceipt func(string)
URL string
APIKey string
TimeoutSeconds int
@@ -46,10 +51,57 @@ func (c *Client) Sale(ctx context.Context, req paymentsvc.SaleRequest, onStatus
TimeoutSeconds: c.TimeoutSeconds,
}
return c.doPayment(ctx, payBridgeReq, onStatus)
result, err := c.doPayment(ctx, payBridgeReq, onStatus)
if result != nil {
result.Terminal = payBridgeTerminalResult(result)
if c.PrintReceipt != nil {
c.PrintReceipt(result.CustomerReceipt)
}
}
return result, err
}
func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus paymentsvc.StatusHandler) (returned *paymentsvc.Result, resultErr error) {
stage := "configure_connection"
var httpStatus int
defer func() {
if resultErr != nil || (returned != nil && payBridgeTerminalResult(returned).Outcome == "unknown") {
fields := log.Fields{
"provider": "paybridge", "operation": "sale", "stage": stage,
"request_id": req.RequestID, "transaction_reference": req.RequestID,
"error_category": paymentsvc.SafeErrorCategory(resultErr),
}
if returned != nil {
if returned.RequestID != "" {
fields["transaction_reference"] = returned.RequestID
}
if returned.TransactionID != "" {
fields["provider_transaction_id"] = returned.TransactionID
}
if returned.ReferenceNumber != "" {
fields["provider_reference"] = returned.ReferenceNumber
}
}
if ctx.Err() != nil {
fields["error_category"] = paymentsvc.SafeErrorCategory(ctx.Err())
} else if errors.Is(resultErr, ErrConnectionFailed) {
fields["error_category"] = "connection_failure"
} else if errors.Is(resultErr, ErrAuthFailed) {
fields["error_category"] = "authentication_failed"
} else if errors.Is(resultErr, ErrUnexpectedMessage) {
fields["error_category"] = "invalid_response"
}
var closeError *websocket.CloseError
if errors.As(resultErr, &closeError) {
fields["error_category"] = "response_lost"
fields["websocket_close_code"] = closeError.Code
}
if httpStatus != 0 {
fields["http_status"] = httpStatus
}
log.WithFields(fields).Warn("PayBridge payment requires reconciliation")
}
}()
emitStatus(onStatus, paymentstatus.Starting)
connectURL, err := c.connectURL()
@@ -57,8 +109,15 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
return nil, err
}
ws, _, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil)
stage = "connect"
ws, response, err := websocket.DefaultDialer.DialContext(ctx, connectURL, nil)
if err != nil {
if response != nil {
httpStatus = response.StatusCode
if response.Body != nil {
response.Body.Close()
}
}
return nil, fmt.Errorf("%w: %v", ErrConnectionFailed, err)
}
defer ws.Close()
@@ -74,6 +133,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
}
}()
stage = "authenticate"
jwt, err := c.readAuthSuccess(ws)
if err != nil {
return nil, err
@@ -82,6 +142,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
log.Info("PayBridge authentication successful")
emitStatus(onStatus, paymentstatus.Started)
stage = "send_payment"
if err := ws.WriteJSON(Envelope{
Type: types.MesTypePaymentRequest,
JWT: jwt,
@@ -101,6 +162,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
emitStatus(onStatus, paymentstatus.RequestSent)
for {
stage = "read_result"
_, raw, err := ws.ReadMessage()
if err != nil {
if ctx.Err() != nil {
@@ -122,26 +184,20 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
switch messageType {
case types.MesTypePaymentStatusUpdate:
stage = "decode_status"
var update StatusUpdateEnvelope
if err := json.Unmarshal(raw, &update); err != nil {
return nil, fmt.Errorf("decode payment_status_update: %w", err)
}
log.WithFields(log.Fields{
"status": update.Data.Status,
"code": update.Data.Code,
}).Info("PayBridge status update")
statusCode, known := mapPayBridgeStatus(
update.Data.Status,
update.Data.Code,
)
log.WithField("status", statusCode).Info("PayBridge status update")
if !known {
log.WithFields(log.Fields{
"status": update.Data.Status,
"code": update.Data.Code,
}).Warn("Unknown PayBridge status update")
log.Warn("Unknown PayBridge status update")
}
emitStatus(onStatus, statusCode)
@@ -151,6 +207,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
emitStatus(onStatus, paymentstatus.Accepted)
case types.MesTypePaymentResult:
stage = "decode_result"
var result PaymentResultEnvelope
// log.Println("PayBridge payment result raw:", string(raw))
if err := json.Unmarshal(raw, &result); err != nil {
@@ -162,7 +219,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapped.Status,
"status": mapPayBridgeFinalStatus(mapped.Status, mapped.Success),
"success": mapped.Success,
}).Info("PayBridge payment result received")
@@ -174,6 +231,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
return mapped, nil
case types.MesTypePaymentError:
stage = "decode_payment_error"
var paymentErr PaymentErrorEnvelope
if err := json.Unmarshal(raw, &paymentErr); err != nil {
return nil, fmt.Errorf("decode payment_error: %w", err)
@@ -182,10 +240,10 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
mapped := mapPaymentError(req, paymentErr)
log.WithFields(log.Fields{
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapped.Status,
"error": mapped.ErrorMessage,
"requestId": mapped.RequestID,
"transactionId": mapped.TransactionID,
"status": mapPayBridgeFinalStatus(mapped.Status, false),
"error_category": "provider_error",
}).Warn("PayBridge payment error received")
emitStatus(
@@ -196,6 +254,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
return mapped, nil
case types.ResultError:
stage = "provider_error"
var genericErr struct {
Error struct {
Code string `json:"code"`
@@ -211,10 +270,8 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
)
}
log.WithFields(log.Fields{
"code": genericErr.Error.Code,
"message": genericErr.Error.Message,
}).Error("PayBridge error message received")
log.WithFields(log.Fields{"provider": "paybridge", "request_id": req.RequestID,
"error_category": "provider_error"}).Error("PayBridge error message received")
emitStatus(onStatus, paymentstatus.Error)
@@ -237,10 +294,7 @@ func (c *Client) doPayment(ctx context.Context, req PaymentRequest, onStatus pay
log.Info("Additional PayBridge auth_success message received")
default:
log.WithField(
"messageType",
head.Type,
).Warn("Unknown PayBridge intermediate message type")
log.Warn("Unknown PayBridge intermediate message type")
emitStatus(onStatus, paymentstatus.Processing)
}
@@ -447,3 +501,23 @@ func mapPayBridgeFinalStatus(
return paymentstatus.Error
}
}
func (*Client) ValidatePreauth(paymentsvc.SaleRequest) error { return paymentsvc.ErrPreauthUnsupported }
func (*Client) Preauth(context.Context, paymentsvc.SaleRequest, paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return nil, paymentsvc.ErrPreauthUnsupported
}
func payBridgeTerminalResult(r *paymentsvc.Result) paymentapi.Result {
final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "paybridge", AmountMinor: r.Amount, CurrencyCode: r.Currency, TransactionReference: r.RequestID, CardType: r.CardType, MaskedCardNumber: creditcall.MaskedCardNumber(r.CardNumber), ExpiryDate: r.ExpiryDate, CardHash: r.CardHash, CardReference: r.CardReference, AuthorizationCode: r.AuthCode, LastFour: r.LastFourDigits, Message: "Payment outcome uncertain; contact reception"}
if r.Success && strings.EqualFold(r.Status, payBridgeFinalStatusApproved) {
final.Outcome, final.Message = "approved", "Payment approved"
return final
}
switch strings.ToUpper(r.Status) {
case payBridgeFinalStatusDeclined:
final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined"
case payBridgeFinalStatusCancelled:
final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled"
}
return final
}
+162
View File
@@ -0,0 +1,162 @@
package paybridge
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/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"])
}
}
})
}
}
+20
View File
@@ -0,0 +1,20 @@
package paybridge
import (
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"testing"
)
func TestTerminalResultKeepsExistingIdentityAndMetadata(t *testing.T) {
raw := &paymentsvc.Result{Success: true, Status: "APPROVED", RequestID: "SYNTH-REQUEST", TransactionID: "SYNTH-PROVIDER-ID", Amount: 1234, Currency: "EUR", CardNumber: "************1133", CardType: "Visa", ExpiryDate: "1228", CardHash: "SYNTH-HASH", CardReference: "SYNTH-CARD"}
result := payBridgeTerminalResult(raw)
if result.Outcome != "approved" || result.TransactionReference != "SYNTH-REQUEST" || result.MaskedCardNumber != raw.CardNumber || result.CardHash != raw.CardHash || result.CardReference != raw.CardReference {
t.Errorf("payBridgeTerminalResult(%+v)=%+v, want current request identity and unchanged metadata", raw, result)
}
}
func TestTimeoutTerminalResultIsUncertain(t *testing.T) {
result := payBridgeTerminalResult(&paymentsvc.Result{Status: "TIMEOUT"})
if result.Outcome != "unknown" || result.Retryable {
t.Errorf("payBridgeTerminalResult(TIMEOUT)=%+v, want nonretryable unknown", result)
}
}
+38
View File
@@ -0,0 +1,38 @@
package paymentsvc
import (
"context"
"encoding/json"
"errors"
"io"
"net"
)
// SafeErrorCategory describes a failure without exposing URLs, payloads or credentials.
// It is diagnostic only and must not determine financial outcomes or retry eligibility.
func SafeErrorCategory(err error) string {
if err == nil {
return "unresolved_result"
}
switch {
case errors.Is(err, context.DeadlineExceeded):
return "timeout"
case errors.Is(err, context.Canceled):
return "cancelled"
case errors.Is(err, io.EOF), errors.Is(err, io.ErrUnexpectedEOF):
return "response_lost"
}
var networkError net.Error
if errors.As(err, &networkError) {
if networkError.Timeout() {
return "timeout"
}
return "connection_failure"
}
var syntaxError *json.SyntaxError
var typeError *json.UnmarshalTypeError
if errors.As(err, &syntaxError) || errors.As(err, &typeError) {
return "invalid_response"
}
return "provider_error"
}
+37
View File
@@ -0,0 +1,37 @@
package paymentsvc
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/url"
"testing"
)
func TestSafeErrorCategory(t *testing.T) {
tests := []struct {
name string
err error
want string
}{
{"missing result", nil, "unresolved_result"},
{"timeout", fmt.Errorf("private URL: %w", context.DeadlineExceeded), "timeout"},
{"cancel", fmt.Errorf("private token: %w", context.Canceled), "cancelled"},
{"eof", fmt.Errorf("raw response: %w", io.EOF), "response_lost"},
{"truncated", io.ErrUnexpectedEOF, "response_lost"},
{"connection", &url.Error{Op: "Post", URL: "https://user:secret@synthetic.invalid", Err: &net.OpError{Op: "dial", Net: "tcp", Err: errors.New("private credential")}}, "connection_failure"},
{"json syntax", &json.SyntaxError{Offset: 1}, "invalid_response"},
{"json type", &json.UnmarshalTypeError{Value: "private card", Field: "secret"}, "invalid_response"},
{"other", errors.New("raw provider response with sensitive content"), "provider_error"},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
if got := SafeErrorCategory(tc.err); got != tc.want {
t.Errorf("SafeErrorCategory(%s)=%q, want %q", tc.name, got, tc.want)
}
})
}
}
+34 -1
View File
@@ -9,6 +9,7 @@ import (
var (
ErrPaymentInProgress = errors.New("payment is already in progress")
ErrProviderNotConfigured = errors.New("payment provider is not configured")
ErrPreauthUnsupported = errors.New("configured payment provider does not support preauthorisation")
)
type StatusUpdate struct {
@@ -23,15 +24,21 @@ type Provider interface {
req SaleRequest,
onStatus StatusHandler,
) (*Result, error)
Preauth(context.Context, SaleRequest, StatusHandler) (*Result, error)
ValidatePreauth(SaleRequest) error
}
type Service struct {
provider Provider
currency string
mu sync.Mutex
busy bool
}
// SetCurrency supplies the currency from the existing CMS hotel response at startup.
func (s *Service) SetCurrency(currency string) { s.currency = currency }
func NewService(provider Provider) *Service {
return &Service{
provider: provider,
@@ -43,9 +50,32 @@ func (s *Service) Sale(
req SaleRequest,
onStatus StatusHandler,
) (*Result, error) {
return s.run(ctx, req, onStatus, false)
}
// Preauth uses the same terminal ownership as Sale.
func (s *Service) Preauth(ctx context.Context, req SaleRequest, onStatus StatusHandler) (*Result, error) {
return s.run(ctx, req, onStatus, true)
}
func (s *Service) run(ctx context.Context, req SaleRequest, onStatus StatusHandler, preauth bool) (*Result, error) {
if s == nil || s.provider == nil {
return nil, ErrProviderNotConfigured
}
if s.currency != "" {
req.Currency = s.currency
}
if preauth {
if err := s.provider.ValidatePreauth(req); err != nil {
return nil, err
}
} else if req.RequiredPreauth != nil {
hold := req
hold.Amount, hold.CheckoutDate = req.RequiredPreauth.Amount, req.RequiredPreauth.CheckoutDate
if err := s.provider.ValidatePreauth(hold); err != nil {
return nil, err
}
}
s.mu.Lock()
if s.busy {
@@ -61,5 +91,8 @@ func (s *Service) Sale(
s.mu.Unlock()
}()
if preauth {
return s.provider.Preauth(ctx, req, onStatus)
}
return s.provider.Sale(ctx, req, onStatus)
}
}
+85
View File
@@ -0,0 +1,85 @@
package paymentsvc
import (
"context"
"errors"
"sync/atomic"
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
)
type testProcessor struct {
entered chan SaleRequest
release chan struct{}
saleCalls atomic.Int32
preauthCalls atomic.Int32
validation func(SaleRequest) error
}
func (p *testProcessor) ValidatePreauth(req SaleRequest) error {
if p.validation != nil {
return p.validation(req)
}
return nil
}
func (p *testProcessor) Sale(_ context.Context, req SaleRequest, _ StatusHandler) (*Result, error) {
p.saleCalls.Add(1)
if p.entered != nil {
p.entered <- req
}
if p.release != nil {
<-p.release
}
return &Result{Terminal: paymentapi.Result{Outcome: "approved", HTTPStatus: 200}}, nil
}
func (p *testProcessor) Preauth(context.Context, SaleRequest, StatusHandler) (*Result, error) {
p.preauthCalls.Add(1)
return &Result{Terminal: paymentapi.Result{Outcome: "approved", HTTPStatus: 200}}, nil
}
func TestSaleAndPreauthShareAdmission(t *testing.T) {
p := &testProcessor{entered: make(chan SaleRequest, 1), release: make(chan struct{})}
s := NewService(p)
done := make(chan error, 1)
go func() { _, err := s.Sale(context.Background(), SaleRequest{Amount: 100}, nil); done <- err }()
<-p.entered
if _, err := s.Preauth(context.Background(), SaleRequest{Amount: 50}, nil); !errors.Is(err, ErrPaymentInProgress) {
t.Errorf("Preauth(during Sale) error=%v, want ErrPaymentInProgress", err)
}
close(p.release)
if err := <-done; err != nil {
t.Fatalf("Sale() error=%v, want nil", err)
}
if _, err := s.Preauth(context.Background(), SaleRequest{Amount: 50}, nil); err != nil {
t.Errorf("Preauth(after Sale) error=%v, want nil", err)
}
if p.saleCalls.Load() != 1 || p.preauthCalls.Load() != 1 {
t.Errorf("Provider calls=%d/%d, want Sale=1/PREAUTH=1", p.saleCalls.Load(), p.preauthCalls.Load())
}
}
func TestRequiredPreauthValidatedBeforeSale(t *testing.T) {
p := &testProcessor{validation: func(req SaleRequest) error {
if req.Amount != 2500 || req.CheckoutDate != "SYNTH-DATE" {
t.Errorf("ValidatePreauth() request=%+v, want planned 2500 hold/date", req)
}
return ErrPreauthUnsupported
}}
_, err := NewService(p).Sale(context.Background(), SaleRequest{Amount: 10000, RequiredPreauth: &paymentapi.PreauthRequirement{Amount: 2500, CheckoutDate: "SYNTH-DATE"}}, nil)
if !errors.Is(err, ErrPreauthUnsupported) || p.saleCalls.Load() != 0 || p.preauthCalls.Load() != 0 {
t.Errorf("Sale(required unsupported hold) error/calls=%v/%d/%d, want unsupported/no dispatch", err, p.saleCalls.Load(), p.preauthCalls.Load())
}
}
func TestCMSCurrencyReachesProviderWithoutLocalDefault(t *testing.T) {
p := &testProcessor{entered: make(chan SaleRequest, 1)}
s := NewService(p)
s.SetCurrency("EUR")
if _, err := s.Sale(context.Background(), SaleRequest{Amount: 100, Currency: "GBP"}, nil); err != nil {
t.Fatal(err)
}
if got := (<-p.entered).Currency; got != "EUR" {
t.Errorf("Sale() provider currency=%q, want CMS EUR", got)
}
}
+16 -10
View File
@@ -1,19 +1,25 @@
package paymentsvc
import "gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
type SaleRequest struct {
RequestID string `json:"requestId"`
Reference string `json:"reference"`
Amount int64 `json:"amount"`
Currency string `json:"currency"`
RequestID string `json:"requestId"`
Reference string `json:"reference"`
Amount int64 `json:"amount"`
Currency string `json:"currency"`
CheckoutDate string `json:"checkoutDate,omitempty"`
RequiredPreauth *paymentapi.PreauthRequirement `json:"requiredPreauth,omitempty"`
}
type Result struct {
Success bool `json:"success"`
RequestID string `json:"requestId,omitempty"`
Operation string `json:"operation,omitempty"`
Status string `json:"status"`
Message string `json:"message,omitempty"`
ErrorMessage string `json:"errorMessage,omitempty"`
// Terminal is the provider-independent result exposed by the modern endpoints.
Terminal paymentapi.Result `json:"-"`
Success bool `json:"success"`
RequestID string `json:"requestId,omitempty"`
Operation string `json:"operation,omitempty"`
Status string `json:"status"`
Message string `json:"message,omitempty"`
ErrorMessage string `json:"errorMessage,omitempty"`
TransactionID string `json:"transactionId,omitempty"`
ReferenceNumber string `json:"referenceNumber,omitempty"`
-15
View File
@@ -55,20 +55,6 @@ type (
CheckOutTimeText string `xml:"CheckOutTimeText"`
RoomMapFolderPath string `xml:"RoomMapFolderPath"`
}
RoomTicket struct {
Logo string
TopMostText string
Name string
BeforeRoomNumberText string
RoomID string
BeforeDirectionsText string
Directions string
HotelSpecificDetails string
Map string
CheckOutTimeText string
Checkout string
}
)
const (
@@ -220,7 +206,6 @@ func PrintSaleReceipt(receipt string) {
buf.Write([]byte{ESC, 'd', 7})
buf.Write([]byte{GS, 'V', 1})
if err := SendToPrinter(buf.Bytes()); err != nil {
log.Errorf("SendToPrinter error: %v", err)
}
+276
View File
@@ -0,0 +1,276 @@
// Package trustpayments implements bounded TRU Link calls without financial retries.
package trustpayments
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/google/uuid"
)
type Config struct {
BaseURL string
SiteID string
Password string
Terminal string
Currency string
Timezone string
// Transport is an explicit fixture seam; production leaves it nil.
Transport http.RoundTripper
}
type Client struct {
cfg Config
http *http.Client
}
func New(cfg Config) (*Client, error) {
u, err := url.Parse(cfg.BaseURL)
if err != nil || u.Scheme != "https" || u.User != nil || u.RawQuery != "" || u.Fragment != "" ||
(u.Host != "link.trustpayments.com" && u.Host != "sandbox.link.trustpayments.com") ||
strings.TrimRight(u.Path, "/") != "/trustpayments/rest" {
return nil, errors.New("invalid CMS ReservationSystem.PaymentGatewayURL for Trust")
}
for _, field := range []struct{ name, value string }{
{"ReservationSystem.PaymentGatewaySiteIDEPOS", cfg.SiteID},
{"ReservationSystem.PaymentGatewayPasswordEPOS", cfg.Password},
{"ReservationSystem.PDQs.Serial", cfg.Terminal},
} {
if strings.TrimSpace(field.value) == "" {
return nil, fmt.Errorf("CMS %s is required for Trust", field.name)
}
}
if _, err := time.LoadLocation(cfg.Timezone); err != nil || cfg.Timezone == "" || cfg.Timezone == "Local" {
return nil, errors.New("valid CMS ReservationSystem.TimeZone is required for Trust")
}
return &Client{cfg: cfg, http: &http.Client{Transport: cfg.Transport, Timeout: 300 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return errors.New("Trust redirects prohibited") }}}, nil
}
func (c *Client) ValidRequest(request Request) bool {
return (request.Kind == "sale" || request.Kind == "preauth") && request.Amount > 0
}
// Process makes one financial request and at most one observational status call.
// Its reference exists for this attempt only; no restart recovery is provided.
func (c *Client) Process(ctx context.Context, request Request) (Result, error) {
if !c.ValidRequest(request) {
return Result{State: Unknown}, errors.New("invalid or unavailable Trust request")
}
op := Operation{Request: request, RefID: strings.ReplaceAll(uuid.NewString(), "-", ""), TxnDate: c.Timestamp(time.Now())}
ctx, cancel := context.WithTimeout(ctx, 315*time.Second)
defer cancel()
result, err := c.Execute(ctx, op, false)
if (result.State == Unknown || result.State == Pending) && ctx.Err() == nil {
return c.Execute(ctx, op, true)
}
return result, err
}
func (c *Client) Timestamp(t time.Time) string {
loc, _ := time.LoadLocation(c.cfg.Timezone)
return t.In(loc).Format("2006-01-02:15:04:05")
}
func Token(site, date, ref, password string) string {
h := sha256.Sum256([]byte(site + ":" + date + ":" + ref + ":" + password))
return hex.EncodeToString(h[:])
}
func Decimal(n int64) string { return fmt.Sprintf("%d.%02d", n/100, n%100) }
func ParseAmount(s string) (int64, error) {
if s == "" || strings.Trim(s, "0123456789.") != "" {
return 0, errors.New("invalid provider amount")
}
parts := strings.Split(s, ".")
if len(parts) != 2 || len(parts[0]) == 0 || len(parts[1]) != 2 {
return 0, errors.New("invalid provider amount scale")
}
n, err := strconv.ParseInt(parts[0]+parts[1], 10, 64)
if err != nil || n <= 0 {
return 0, errors.New("invalid provider amount range")
}
return n, nil
}
type response struct {
RefID string `json:"refid"`
Site string `json:"siteid"`
Terminal string `json:"terminalserialnumber"`
Kind string `json:"type"`
Result string `json:"resultcode"`
Amount string `json:"amount"`
Final string `json:"finalamount"`
Error json.RawMessage `json:"error"`
ErrorMessage string `json:"errormessage"`
Code json.RawMessage `json:"errorcode"`
Auth string `json:"authcode"`
Card string `json:"cardtype"`
Last string `json:"last4"`
Receipt string `json:"receipt"`
}
func safe(s string) string {
if len(s) > 80 || strings.Trim(s, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 -_./") != "" {
return ""
}
return s
}
func receiptFields(s string) (string, string) {
var receipt, sequence string
for _, line := range strings.Split(strings.ReplaceAll(s, "\r\n", "\n"), "\n") {
line = strings.TrimSpace(line)
if strings.HasPrefix(line, "Receipt:") {
receipt = safe(strings.TrimSpace(strings.TrimPrefix(line, "Receipt:")))
}
if strings.HasPrefix(line, "Sequence number:") {
sequence = safe(strings.TrimSpace(strings.TrimPrefix(line, "Sequence number:")))
}
}
return receipt, sequence
}
func (c *Client) Execute(ctx context.Context, op Operation, status bool) (Result, error) {
result := Result{State: Unknown, RefID: op.RefID}
if (op.Request.Kind != "sale" && op.Request.Kind != "preauth") || op.Request.Amount <= 0 || op.RefID == "" || op.TxnDate == "" {
return result, errors.New("invalid Trust operation context")
}
payload := map[string]string{"siteid": c.cfg.SiteID, "txndate": op.TxnDate, "refid": op.RefID}
endpoint := "status"
timeout := 15 * time.Second
if !status {
endpoint = op.Request.Kind
timeout = 300 * time.Second
payload["amount"] = Decimal(op.Request.Amount)
payload["type"] = op.Request.Kind
payload["terminalserialnumber"] = c.cfg.Terminal
payload["wait"] = "y"
}
ctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
b, err := json.Marshal(payload)
if err != nil {
return result, err
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(c.cfg.BaseURL, "/")+"/"+endpoint, bytes.NewReader(b))
if err != nil {
return result, errors.New("invalid Trust endpoint")
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("token", Token(c.cfg.SiteID, op.TxnDate, op.RefID, c.cfg.Password))
resp, err := c.http.Do(req)
if err != nil {
return result, errors.New("Trust transport outcome unavailable")
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return result, fmt.Errorf("Trust HTTP status %d; financial outcome unknown", resp.StatusCode)
}
data, err := io.ReadAll(io.LimitReader(resp.Body, 1024*1024+1))
if err != nil || len(data) > 1024*1024 {
return result, errors.New("Trust result unreadable")
}
var r response
if err = json.Unmarshal(data, &r); err != nil {
return result, errors.New("Trust result invalid")
}
// Preserve bounded, parsed observations for operator reconciliation without
// representing mismatched values as admitted approval evidence.
if n, e := ParseAmount(r.Amount); e == nil {
result.ObservedAmount = n
result.ObservedAmountKnown = true
}
if n, e := ParseAmount(r.Final); e == nil {
result.ObservedFinalAmount = n
result.ObservedFinalKnown = true
}
code := strings.Trim(string(r.Code), `"`)
if code == "null" {
code = ""
}
if len(code) <= 6 && strings.Trim(code, "0123456789") == "" {
result.Code = code
}
// Duplicate identity, any error code and incomplete responses are never refusals.
if code != "" && code != "0" {
// This attempt never resubmits a financial POST. A duplicate on its first
// dispatch may belong to another owner; Status alone cannot prove that
// ownership when terminal/timestamp evidence is absent.
if code == "1008" || code == "1011" {
result.State = Review
}
return result, nil
}
if (len(r.Error) > 0 && string(r.Error) != "null" && string(r.Error) != "0" && string(r.Error) != "\"\"") || r.ErrorMessage != "" {
return result, nil
}
if r.RefID != op.RefID || r.Site != c.cfg.SiteID || (r.Terminal != "" && r.Terminal != c.cfg.Terminal) ||
(status && !strings.EqualFold(r.Kind, op.Request.Kind)) || (!status && r.Terminal != c.cfg.Terminal) ||
(r.Kind != "" && !strings.EqualFold(r.Kind, op.Request.Kind)) {
result.State = Review
return result, nil
}
switch strings.ToLower(r.Result) {
case "pending":
result.State = Pending
return result, nil
case "declined":
if r.Auth != "" {
result.State = Review
return result, nil
}
result.State = Declined
return result, nil
case "cancelled":
if r.Auth != "" {
result.State = Review
return result, nil
}
result.State = Cancelled
return result, nil
case "approved":
default:
return result, nil
}
amountText := r.Amount
if status {
amountText = r.Final
}
amount, err := ParseAmount(amountText)
if err != nil || amount != op.Request.Amount {
result.State = Review
return result, nil
}
if r.Final != "" {
final, e := ParseAmount(r.Final)
if e != nil || final != amount {
result.State = Review
return result, nil
}
}
result.State = Approved
result.Amount = amount
// Legacy TRU approval does not validate currency; this is CMS bookkeeping only.
result.Currency = c.cfg.Currency
receipt, sequence := receiptFields(r.Receipt)
result.Metadata = Metadata{Receipt: shortIdentifier(receipt), Sequence: shortIdentifier(sequence), AuthCode: shortIdentifier(r.Auth)}
if len(r.Card) <= 24 && strings.Trim(r.Card, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == "" {
result.Metadata.CardType = r.Card
}
if len(r.Last) == 4 && strings.Trim(r.Last, "0123456789") == "" {
result.Metadata.LastFour = r.Last
}
return result, nil
}
func shortIdentifier(s string) string {
if len(s) > 12 || strings.Trim(s, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_/") != "" {
return ""
}
return s
}
+137
View File
@@ -0,0 +1,137 @@
package trustpayments
import (
"context"
"encoding/json"
"io"
"net/http"
"strings"
"testing"
)
type transportFunc func(*http.Request) (*http.Response, error)
func (f transportFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func fixtureConfig() Config {
return Config{BaseURL: "https://sandbox.link.trustpayments.com/trustpayments/rest/", SiteID: "site", Password: "test-secret", Terminal: "terminal", Currency: "GBP", Timezone: "Europe/London"}
}
func TestTrustSigningMoneyAndConfiguration(t *testing.T) {
if got := Token("123456", "2020-03-01:10:20:05", "7876547", "tv%61w%5"); got != "990bc7bb7efee9e383a96f6f929fd00c90f4ec94f4344270c1552e4d5d4d80c5" {
t.Errorf("Token=%s", got)
}
for _, s := range []string{"", "0.00", "-1.00", "1.001", "1", "NaN", "92233720368547758.08", "1e2"} {
if _, e := ParseAmount(s); e == nil {
t.Errorf("ParseAmount(%q) accepted", s)
}
}
if n, e := ParseAmount("123456.78"); e != nil || Decimal(n) != "123456.78" {
t.Fatalf("money=%d/%v", n, e)
}
for _, url := range []string{"", "http://link.trustpayments.com/trustpayments/rest/", "https://other.invalid/trustpayments/rest/", "https://link.trustpayments.com:443/trustpayments/rest/", "https://link.trustpayments.com/trustpayments/rest/?x=1"} {
cfg := fixtureConfig()
cfg.BaseURL = url
if _, e := New(cfg); e == nil {
t.Errorf("New(%q) accepted", url)
}
}
}
func TestTrustFinancialEvidenceAndUncertainErrors(t *testing.T) {
for _, tc := range []struct {
name string
change func(map[string]any)
status bool
state string
}{
{"sale", nil, false, Approved}, {"status", nil, true, Approved},
{"adjusted", func(r map[string]any) { r["finalamount"] = "11.00" }, false, Review},
{"wrongAmount", func(r map[string]any) { r["amount"] = "9.00" }, false, Review},
{"providerCurrencyIgnored", func(r map[string]any) { r["currency"] = "EUR" }, false, Approved},
{"wrongRef", func(r map[string]any) { r["refid"] = "other" }, false, Review},
{"wrongSite", func(r map[string]any) { r["siteid"] = "other" }, true, Review},
{"wrongType", func(r map[string]any) { r["type"] = "preauth" }, true, Review},
{"noAmount", func(r map[string]any) { delete(r, "finalamount") }, true, Review},
{"declined", func(r map[string]any) { r["resultcode"] = "Declined"; delete(r, "authcode") }, false, Declined},
{"cancelled", func(r map[string]any) { r["resultcode"] = "Cancelled"; delete(r, "authcode") }, false, Cancelled},
{"pending", func(r map[string]any) { r["resultcode"] = "Pending" }, false, Pending},
{"2003", func(r map[string]any) { r["errorcode"] = 2003 }, false, Unknown},
{"2005", func(r map[string]any) { r["errorcode"] = "2005" }, false, Unknown},
{"2006", func(r map[string]any) { r["errorcode"] = 2006 }, false, Unknown},
{"1011", func(r map[string]any) { r["errorcode"] = 1011 }, false, Review},
{"1008", func(r map[string]any) { r["errorcode"] = 1008 }, false, Review},
{"offline", func(r map[string]any) { r["resultcode"] = "Terminal Busy" }, false, Unknown},
} {
t.Run(tc.name, func(t *testing.T) {
cfg := fixtureConfig()
calls := 0
cfg.Transport = transportFunc(func(req *http.Request) (*http.Response, error) {
calls++
var input map[string]string
if e := json.NewDecoder(req.Body).Decode(&input); e != nil {
t.Fatal(e)
}
if input["txndate"] != "2026-10-23:12:00:00" || req.Header.Get("token") != Token(cfg.SiteID, input["txndate"], "ref", cfg.Password) {
t.Error("signing context changed")
}
if !tc.status && (input["wait"] != "y" || input["amount"] != "10.00") {
t.Error("incorrect financial payload")
}
r := map[string]any{"refid": "ref", "siteid": "site", "terminalserialnumber": "terminal", "type": "sale", "amount": "10.00", "finalamount": "10.00", "resultcode": "Approved", "receipt": "Sequence number: 42\r\nReceipt: 31\r\nPAN: 4111111111111111", "authcode": "123456", "cardtype": "Visa", "last4": "1133"}
if tc.change != nil {
tc.change(r)
}
b, _ := json.Marshal(r)
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(b)))}, nil
})
c, e := New(cfg)
if e != nil {
t.Fatal(e)
}
result, e := c.Execute(context.Background(), Operation{RefID: "ref", TxnDate: "2026-10-23:12:00:00", Request: Request{Kind: "sale", Amount: 1000, Currency: "GBP"}}, tc.status)
if e != nil || result.State != tc.state || calls != 1 {
t.Fatalf("Execute=%+v/%v, calls=%d, want %s/1", result, e, calls, tc.state)
}
if result.State == Approved && (result.Metadata.Receipt != "31" || result.Metadata.Sequence != "42" || result.Metadata.LastFour != "1133") {
t.Error("metadata lost")
}
if result.State == Approved && result.Currency != cfg.Currency {
t.Errorf("currency metadata=%q, want CMS currency %q", result.Currency, cfg.Currency)
}
if tc.name == "adjusted" && (!result.ObservedFinalKnown || result.ObservedFinalAmount != 1100 || result.Amount != 0) {
t.Fatal("financial mismatch evidence was lost or admitted")
}
b, _ := json.Marshal(result)
if strings.Contains(string(b), "4111111111111111") || strings.Contains(string(b), cfg.Password) {
t.Error("sensitive data escaped")
}
})
}
cfg := fixtureConfig()
c, _ := New(cfg)
r, e := c.Execute(context.Background(), Operation{}, false)
if e == nil || r.State == Approved {
t.Fatal("invalid operation admitted")
}
}
func TestTrustTransportHTTPAndMalformedResultsRemainUnknown(t *testing.T) {
for _, tc := range []struct {
name, body string
status int
}{{"http500", `{"resultcode":"Approved"}`, 500}, {"http401", "", 401}, {"malformed", "{", 200}, {"empty", "{}", 200}, {"unexpectedError", `{"resultcode":"Approved","error":"private-token"}`, 200}} {
t.Run(tc.name, func(t *testing.T) {
cfg := fixtureConfig()
calls := 0
cfg.Transport = transportFunc(func(*http.Request) (*http.Response, error) {
calls++
return &http.Response{StatusCode: tc.status, Body: io.NopCloser(strings.NewReader(tc.body))}, nil
})
c, e := New(cfg)
if e != nil {
t.Fatal(e)
}
r, _ := c.Execute(context.Background(), Operation{RefID: "ref", TxnDate: "2026-10-23:12:00:00", Request: Request{Kind: "sale", Amount: 1000, Currency: "GBP"}}, false)
if r.State == Approved || r.State == Declined || calls != 1 {
t.Fatalf("uncertain=%+v calls=%d", r, calls)
}
})
}
}
@@ -0,0 +1,54 @@
package trustpayments
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"testing"
)
func TestLegacyTrustCurrencyDoesNotDetermineApproval(t *testing.T) {
for _, providerCurrency := range []any{nil, "", "GBP", "EUR", "NOT-AN-ISO-CODE", 123, map[string]any{"unexpected": "value"}} {
t.Run(fmt.Sprint("provider=", providerCurrency), func(t *testing.T) {
cfg := fixtureConfig()
cfg.Transport = transportFunc(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
}
if _, exists := input["currency"]; exists {
t.Error("TRU request gained a currency field")
}
body, _ := json.Marshal(map[string]any{"refid": "SYNTH-REF", "siteid": cfg.SiteID, "terminalserialnumber": cfg.Terminal, "type": "sale", "resultcode": "Approved", "amount": "25.00", "currency": providerCurrency})
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(body)))}, nil
})
client, err := New(cfg)
if err != nil {
t.Fatal(err)
}
op := Operation{RefID: "SYNTH-REF", TxnDate: "2026-11-03:12:00:00", Request: Request{Kind: "sale", Amount: 2500, Currency: "REQUEST-CURRENCY-IS-NOT-A-GATE"}}
result, err := client.Execute(context.Background(), op, false)
if err != nil || result.State != Approved || result.Amount != 2500 || result.Currency != cfg.Currency {
t.Fatalf("Execute(provider currency %v)=%+v/%v, want approval and CMS bookkeeping only", providerCurrency, result, err)
}
})
}
}
func TestCMSCurrencyIsMetadataNotAClientValidationFlag(t *testing.T) {
for _, currency := range []string{"", "GBP", "NOT-AN-ISO-CODE"} {
cfg := fixtureConfig()
cfg.Currency = currency
client, err := New(cfg)
if err != nil {
t.Errorf("New(CMS currency %q)=%v, want no Trust currency gate", currency, err)
continue
}
if !client.ValidRequest(Request{Kind: "preauth", Amount: 2500, Currency: "different"}) {
t.Errorf("ValidRequest(CMS currency %q) imposed currency validation", currency)
}
}
}
+110
View File
@@ -0,0 +1,110 @@
package trustpayments
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"strings"
"testing"
"time"
)
func TestTrustProcessOneFinancialPostAndBoundedStatus(t *testing.T) {
for _, first := range []string{"Approved", "Declined", "Cancelled", "Pending", "2003", "2005", "2006", "transport", "1011", "mismatch"} {
t.Run(first, func(t *testing.T) {
cfg := fixtureConfig()
var ref, timestamp string
financial, status := 0, 0
cfg.Transport = transportFunc(func(r *http.Request) (*http.Response, error) {
var input map[string]string
if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
t.Fatal(err)
}
lookup := strings.HasSuffix(r.URL.Path, "/status")
deadline, ok := r.Context().Deadline()
remaining := time.Until(deadline)
if !lookup {
financial++
ref, timestamp = input["refid"], input["txndate"]
if !ok || remaining > 300*time.Second || remaining < 299*time.Second || input["wait"] != "y" {
t.Errorf("financial deadline/payload=%s/%v", remaining, input)
}
} else {
status++
if input["refid"] != ref || input["txndate"] != timestamp || !ok || remaining > 15*time.Second || remaining < 14*time.Second || input["amount"] != "" {
t.Errorf("status changed identity/budget/payload=%s/%v", remaining, input)
}
}
if !lookup && first == "transport" {
return nil, errors.New("synthetic disconnected provider")
}
body := map[string]any{"refid": ref, "siteid": "site", "terminalserialnumber": "terminal", "type": "sale", "amount": "10.00", "finalamount": "10.00", "resultcode": "Approved", "authcode": "123456"}
if !lookup {
switch first {
case "Declined", "Cancelled":
body["resultcode"], body["authcode"] = first, ""
case "Pending":
body["resultcode"] = first
case "2003", "2005", "2006", "1011":
body["errorcode"] = first
case "mismatch":
body["amount"] = "9.00"
}
}
encoded, _ := json.Marshal(body)
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(encoded)))}, nil
})
client, err := New(cfg)
if err != nil {
t.Fatal(err)
}
result, err := client.Process(context.Background(), Request{Kind: "sale", Amount: 1000, Currency: "GBP"})
wantStatus := 0
if first == "Pending" || first == "transport" || first == "2003" || first == "2005" || first == "2006" {
wantStatus = 1
}
want := Approved
if first == "Declined" {
want = Declined
}
if first == "Cancelled" {
want = Cancelled
}
if first == "1011" || first == "mismatch" {
want = Review
}
if err != nil || financial != 1 || status != wantStatus || result.State != want || len(ref) != 32 {
t.Fatalf("Process(%s) state/error/posts/status=%s/%v/%d/%d, want %s/nil/1/%d", first, result.State, err, financial, status, want, wantStatus)
}
})
}
}
func TestTrustProcessStatusStillUnknownAndPreauth(t *testing.T) {
for _, kind := range []string{"sale", "preauth"} {
t.Run(kind, func(t *testing.T) {
cfg := fixtureConfig()
calls := 0
cfg.Transport = transportFunc(func(r *http.Request) (*http.Response, error) {
calls++
if calls == 1 && !strings.HasSuffix(r.URL.Path, "/"+kind) {
t.Errorf("provider endpoint=%s", r.URL.Path)
}
if calls == 2 && !strings.HasSuffix(r.URL.Path, "/status") {
t.Errorf("second call=%s, want status", r.URL.Path)
}
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(`{"errorcode":2003}`))}, nil
})
client, err := New(cfg)
if err != nil {
t.Fatal(err)
}
result, err := client.Process(context.Background(), Request{Kind: kind, Amount: 2500, Currency: "GBP"})
if err != nil || result.State != Unknown || calls != 2 {
t.Fatalf("unresolved result=%+v/%v calls=%d", result, err, calls)
}
})
}
}
+77
View File
@@ -0,0 +1,77 @@
package trustpayments
import (
"context"
"fmt"
"net/http"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/paymentsvc"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/printer"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentapi"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
log "github.com/sirupsen/logrus"
)
// Processor owns Trust execution and terminal receipt printing.
type Processor struct {
Client *Client
PrintReceipt func(string)
}
func (p *Processor) ValidatePreauth(req paymentsvc.SaleRequest) error {
if p.Client == nil || !p.Client.ValidRequest(Request{Kind: "preauth", Amount: req.Amount}) {
return paymentsvc.ErrPreauthUnsupported
}
return nil
}
func (p *Processor) Sale(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return p.run(ctx, req, status, "sale")
}
func (p *Processor) Preauth(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler) (*paymentsvc.Result, error) {
return p.run(ctx, req, status, "preauth")
}
func (p *Processor) run(ctx context.Context, req paymentsvc.SaleRequest, status paymentsvc.StatusHandler, kind string) (*paymentsvc.Result, error) {
for _, code := range []string{paymentstatus.Starting, paymentstatus.RequestSent, paymentstatus.Processing} {
if status != nil {
status(paymentsvc.StatusUpdate{Code: code})
}
}
result, err := p.Client.Process(ctx, Request{Kind: kind, Amount: req.Amount, Currency: req.Currency})
final := paymentapi.Result{Outcome: "unknown", HTTPStatus: http.StatusOK, Provider: "TrustPayments", Message: "Payment outcome uncertain; contact reception", TransactionReference: result.RefID}
switch result.State {
case Approved:
final.Outcome, final.Message = "approved", "Payment approved"
final.AmountMinor, final.CurrencyCode = result.Amount, result.Currency
m := result.Metadata
final.ReceiptNumber, final.SequenceNumber, final.AuthorizationCode = m.Receipt, m.Sequence, m.AuthCode
final.CardType, final.LastFour = m.CardType, m.LastFour
receipt := fmt.Sprintf("Trust Payments\n%s %s\n%s\nCard ************%s", Decimal(result.Amount), result.Currency, m.Description(result.RefID), m.LastFour)
if p.PrintReceipt != nil {
p.PrintReceipt(receipt)
} else {
printer.PrintSaleReceipt(receipt)
}
case Declined:
final.Outcome, final.Retryable, final.Message = "declined", true, "Transaction declined"
case Cancelled:
final.Outcome, final.Retryable, final.Message = "cancelled", true, "Transaction cancelled"
}
if final.Outcome != "unknown" {
err = nil
} else {
fields := log.Fields{
"provider": final.Provider, "operation": kind, "outcome": final.Outcome,
"request_id": req.RequestID, "request_reference": req.Reference,
"transaction_reference": result.RefID, "provider_state": result.State,
"provider_code": result.Code, "error_category": paymentsvc.SafeErrorCategory(err),
}
if result.ObservedAmountKnown {
fields["observed_amount_minor"] = result.ObservedAmount
}
if result.ObservedFinalKnown {
fields["observed_final_amount_minor"] = result.ObservedFinalAmount
}
log.WithFields(fields).Warn("Trust payment outcome requires reception reconciliation")
}
return &paymentsvc.Result{Terminal: final}, err
}
+44
View File
@@ -0,0 +1,44 @@
package trustpayments
// These are provider-call values, not persistent operations or kiosk sessions.
const (
Approved = "APPROVED_VALIDATED"
Declined = "DECLINED"
Cancelled = "CANCELLED"
Pending = "PENDING"
Unknown = "UNKNOWN"
Review = "REVIEW_REQUIRED"
)
type Request struct {
Kind string
Amount int64
Currency string
}
type Operation struct {
Request Request
RefID, TxnDate string
}
type Metadata struct {
Receipt, Sequence, AuthCode, CardType, LastFour string
}
func (m Metadata) Description(ref string) string {
s := "Tx " + ref
for _, v := range [][2]string{{"Rec", m.Receipt}, {"Seq", m.Sequence}, {"Hash", m.AuthCode}, {"Ref", m.CardType + m.LastFour}} {
if v[1] != "" {
s += " " + v[0] + " " + v[1]
}
}
return s
}
type Result struct {
State, RefID, Currency, Code string
Amount int64
Metadata Metadata
ObservedAmount, ObservedFinalAmount int64
ObservedAmountKnown, ObservedFinalKnown bool
}