Compare commits

..
17 Commits
Author SHA1 Message Date
Yurii 814d87768d feat(hardlink): unify kiosk payments and finalize legacy cleanup 2026-11-04 17:43:10 +00:00
Yurii 568adc034b updated readme.md 2026-10-23 14:33:24 +01:00
Yurii 8c5e61efd0 feat(dispenser): recover K720 card position during uncertain encoding 2026-10-22 18:56:22 +01:00
Yurii 28aea4aab2 added detailed logging for preauth payment processing and result streaming 2026-10-19 17:58:46 +01:00
Yurii 8a5325414b feat(logging): add weekly log rotation and retention 2026-09-30 20:43:04 +01:00
Yurii bd15b054dd fix(dispenser): scan ACK responses without assuming 3-byte reads 2026-09-30 00:37:58 +01:00
Yurii aef1bbbe57 feat(dispenser): add worker-owned idle card prestaging 2026-09-29 18:58:26 +01:00
Yurii b9b2a524dd fix(dispenser): tolerate unusable AP observations during card preparation 2026-09-28 19:43:35 +01:00
Yurii e26331ffa9 fix(dispenser): simplify card preparation and recovery 2026-09-27 22:21:28 +01:00
Yurii 99c74f49b6 fix(dispenser): wait for delivery clearance before FC7 2026-09-26 19:27:30 +01:00
Yurii cb5a09e710 Get-Service TeamViewer | Select-Object Status, Name, StartType 2026-09-26 17:15:02 +01:00
Yurii 4dfe139c3b fix(dispenser): recover stuck card preparation with reset 2026-09-24 15:07:40 +01:00
Yurii aeb86f55b9 fix(dispenser): retry on transient prepare failure 2026-09-22 18:27:57 +01:00
Yurii 1969aaa1d2 feat: add CreditCall preauth streaming 2026-09-10 12:04:41 +01:00
Yurii c8cbd1e7a3 feat: improve CreditCall receipt layout 2026-09-08 18:04:33 +01:00
Yurii afb8bb0e9e fix: stream in-transaction card removal prompts 2026-09-08 15:38:21 +01:00
Yurii 93ff67fbb1 feat: stream CreditCall payment progress and results 2026-09-08 13:41:29 +01:00
73 changed files with 9359 additions and 1637 deletions
+1
View File
@@ -29,6 +29,7 @@ _obj
_test
.vscode/
ChipDNAClient/
docs/
# Architecture specific extensions/prefixes
*.[568vq]
+24 -148
View File
@@ -1,153 +1,29 @@
# Access Point
# Hardlink
This service handles door card issuance and room ticket printing for hotels. It interacts with the card dispenser over serial, the Assa Abloy lock server, and prints receipts.
Hardlink is the Windows hotel-kiosk service for K720 card dispensing, door-key
encoding, room-ticket and payment-receipt printing, and terminal payments. It
supports Assa Abloy, Omnitec, Salto, TLJ and dormakaba lock servers, and CreditCall
(ChipDNA), Dojo, PayBridge and Trust Payments providers.
## Deployment
## Documentation
We use Salt for deployment. To build and deploy a new version:
- [Configuration](docs/configuration.md): local service/device settings,
room-ticket layout and CMS-only Trust configuration.
- [Operations](docs/operations.md): builds, deployment layout, hardware HTTP
endpoints, diagnostics, logs and offline verification.
- [Payment API](docs/payment-api.md): unified Sale/PREAUTH requests, NDJSON
results, transaction ownership, receipts and CreditCall streaming details.
- [K720 hardware contract](docs/hardware/k720.md): preparation, uncertain-handoff
recovery, delivery clearance and maintenance invariants.
- [Release history](docs/releases.md).
- [Historical archive](docs/archive/README.md): superseded Trust plans and
audits, retained as dated evidence rather than current operating instructions.
1. **Push your branch** with a meaningful commit message:
```bash
git push origin <branch>
```
2. **Tag and build**:
```bash
./tagbuild.sh
```
This script:
- Builds the latest `hardlink.exe` binary
- Tags the repository with the new version
- Copies `hardlink_<tag>.exe` to `salt/hardlink/files`
3. **Commit the new binary** in Salt:
```bash
cd salt
git add hardlink/files/hardlink_<tag>.exe
git commit -m "added hardlink"
git push
```
4. **Update pillar** (`pillar/hardlink/init.sls`) to point to the new version.
5. **Apply the state** on your hosts:
```bash
salt '*' state.apply hardlink
```
Hardlink owns payment-provider selection and terminal processing. The native
Fyne applications use the common Sale/PREAUTH contract and own their financial
calculations, PMS descriptions, PMS posting and guest journeys. Trust settings
come from CMS; no local `trust:` YAML section or currency-evidence flag is needed.
## Configuration
Place `config.yml` alongside `hardlink.exe`:
```yaml
port: 9091
lockservUrl: "http://192.168.4.109:4000"
encoderAddr: "1"
dispensPort: "COM9"
dispensAddr: "15"
printerName: "EPSON TM-T82II Receipt"
logdir: "./logs"
```
Provide `TicketLayout.xml` for print layout:
```xml
<LayoutOptions>
<LogoPath>C:/Logo/logo.png</LogoPath>
<TopMostText>Welcome to The Bike and Boot</TopMostText>
<BeforeRoomNumberText>Your room number is</BeforeRoomNumberText>
<BeforeDirectionsText></BeforeDirectionsText>
<HotelSpecificDetails>This is the hotel details section</HotelSpecificDetails>
<CheckOutTimeText>Check Out Time</CheckOutTimeText>
<RoomMapFolderPath>C:/Logo/Roommaps</RoomMapFolderPath>
</LayoutOptions>
```
## Build & Run
```bash
# Install dependencies
go mod tidy
# Build the executable
go build -o hardlink.exe
# Run
./hardlink.exe
```
The HTTP server listens on `http://localhost:<port>` (default `9091`).
## API Endpoints
### 1. Issue Door Card
- **Endpoint**: `POST /issuedoorcard`
- **Headers**: `Content-Type: application/json`
- **Body**:
```json
{
"roomField": "101",
"checkinTime": "2025-04-08 11:16:05 +0100",
"checkoutTime": "2025-04-08 12:00:00 +0100",
"followStr": "0"
}
```
- **Responses**:
- `200 OK`
```json
{ "Code": 200, "Message": "Card issued successfully" }
```
- `4XX` / `5XX`
```json
{ "Code": <status>, "Message": "<error>" }
```
### 2. Print Room Ticket
- **Endpoint**: `POST /printroomticket`
- **Headers**: `Content-Type: application/xml`
- **Body**:
```xml
<roomdetails>
<customername>John Doe</customername>
<checkoutdatetime>16/05/2025 11:00 am</checkoutdatetime>
<roomno>103</roomno>
<roommap>map.png</roommap>
<roomdirections>Follow corridor...</roomdirections>
</roomdetails>
```
- **Responses**:
- `200 OK`
```json
{ "Code": 200, "Message": "Print job sent successfully" }
```
- `4XX` / `5XX`
```json
{ "Code": <status>, "Message": "<error>" }
```
## Packages
### `main`
- Entry point: reads config, sets up logging, initializes dispenser and lock server, loads print layout, and starts HTTP server.
### `dispenser`
- Communicates with the card dispenser via serial port.
- Commands: check status, move card, eject card.
### `lockserver`
- Manages TCP connection to the Assa Abloy lock server.
- Sends heartbeat and encoding commands.
### `printer`
- Loads `TicketLayout.xml` into `LayoutOptions`.
- Provides `printLogo`, `printMap`, `BuildRoomTicket`, `SendToPrinter`.
- Converts images to ESC/POS raster commands with dithering and transparency support.
### `cmstypes`
- Defines JSON and XML payload structures for door cards and room details.
## Logging
Logs are written in JSON format to `<logdir>/hardlink.log`.
---
MIT © FutureSens Systems
The deprecated XML payment routes remain solely for legacy compatibility.
`/testissuedoorcard` remains an operational diagnostic available on production
kiosks regardless of TestMode, and retains the encoded card inside the dispenser.
+21 -35
View File
@@ -33,7 +33,7 @@ import (
)
const (
buildVersion = "v1.3.6"
buildVersion = "v2.2.0"
serviceName = "hardlink"
pollingFrequency = 8 * time.Second
)
@@ -46,10 +46,6 @@ func main() {
lockserver.LockServerURL = cfg.LockserverURL
mail.SendErrorEmails = cfg.SendErrorEmails
// Root context for background goroutines
// rootCtx, rootCancel := context.WithCancel(context.Background())
// defer rootCancel()
var (
dispPort *serial.Port
disp *dispenser.Client
@@ -123,19 +119,25 @@ func main() {
log.Info("Payment processing is enabled")
var provider paymentsvc.Provider
reservationSystem, err := cms.ReadHotel(cfg.Hotel, cfg.CMSBaseURL)
hotel, err := cms.ReadHotelDetails(cfg.Hotel, cfg.CMSBaseURL)
if err != nil {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Failed to read hotel from CMS", fmt.Errorf("failed to read hotel from CMS: %v", err))
}
reservationSystem := hotel.ReservationSystem
paymentProvider := reservationSystem.PaymentSystem
if paymentProvider == 0 {
paymentProvider = cms.PaymentSystemIndex(cfg.PaymentProvider)
}
switch paymentProvider {
case cmstypes.PaySystemTrustPayments:
if err := configureTrust(app, cfg, hotel); err != nil {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Failed to initialize Trust Payments", err)
}
case cmstypes.PaySystemCreditCall:
// CreditCall keeps using the existing /takepayment and /takepreauth endpoints.
// CreditCall streaming shares its proven legacy transaction core.
app.EnableCreditCallStreaming()
startChipDnaClient()
go func() {
@@ -151,9 +153,6 @@ func main() {
log.Infof("PDQ available: %v", pdqStatus.IsAvailable)
}()
log.Info("CreditCall payment provider enabled")
fmt.Println("CreditCall payment provider enabled")
case cmstypes.PaySystemPayBridge:
websocketURL := pdqSerialForKiosk(reservationSystem.PDQs, cfg.Kiosk)
@@ -164,11 +163,13 @@ func main() {
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Payment Gateway API Key not found", fmt.Errorf("payment provider paybridge requires paybridge.api_key"))
}
provider = paybridge.NewClient(
payBridgeClient := paybridge.NewClient(
websocketURL,
reservationSystem.PaymentGatewayAPIKeyWeb,
cfg.TimeoutSeconds,
)
payBridgeClient.PrintReceipt = printer.PrintSaleReceipt
provider = payBridgeClient
case cmstypes.PaySystemDojo:
TerminalID := pdqSerialForKiosk(reservationSystem.PDQs, cfg.Kiosk)
@@ -181,6 +182,7 @@ func main() {
}
dojoClient, err := dojo.NewClient(dojo.Config{
PrintReceipt: printer.PrintSaleReceipt,
BaseURL: reservationSystem.PaymentGatewayURL,
APIKey: reservationSystem.PaymentGatewayAPIKeyWeb,
SoftwareHouseID: reservationSystem.PaymentGatewaySiteIDEPOS,
@@ -194,21 +196,22 @@ func main() {
provider = dojoClient
case cmstypes.PaySystemNone:
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "No payment provider selected", fmt.Errorf("payment processing is enabled, but no payment provider selected; expected creditcall, paybridge or dojo"))
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "No payment provider selected", fmt.Errorf("payment processing is enabled, but no payment provider selected; expected creditcall, trustpayments, paybridge or dojo"))
default:
errorhandlers.FatalErrorWithMail(cfg.Hotel, cfg.Kiosk, "Unsupported Payment Provider", fmt.Errorf(
"unsupported payment provider %q; expected creditcall, paybridge or dojo",
"unsupported payment provider %q; expected creditcall, trustpayments, paybridge or dojo",
cfg.PaymentProvider,
))
}
// Only PayBridge and Dojo use POST /api/payment/sale.
// All modern endpoint providers use the same payment service.
if provider != nil {
app.SetPaymentService(paymentsvc.NewService(provider))
log.Infof("Payment provider enabled for POST /api/payment/sale: %s", cmstypes.PaySystemNames[paymentProvider])
fmt.Printf("Payment provider enabled for POST /api/payment/sale: %s\n", cmstypes.PaySystemNames[paymentProvider])
}
app.SetPaymentCurrency(hotel.Currency.Code)
log.Infof("Payment provider enabled for POST /api/payment/sale: %s", cmstypes.PaySystemNames[paymentProvider])
fmt.Printf("Payment provider enabled for POST /api/payment/sale: %s\n", cmstypes.PaySystemNames[paymentProvider])
} else {
fmt.Println("Payment processing is disabled")
log.Info("Payment processing is disabled")
@@ -226,6 +229,7 @@ func main() {
// Start polling for dispenser status every 10 seconds
disp.StartPolling(pollingFrequency)
disp.StartMaintenance()
}
mux := http.NewServeMux()
@@ -240,24 +244,6 @@ func main() {
}
}
// func readTicketLayout() printer.LayoutOptions {
// const layoutName = "TicketLayout.xml"
// var layout printer.LayoutOptions
// // 1) Read the file
// data, err := os.ReadFile(layoutName)
// if err != nil {
// errorhandlers.FatalError(fmt.Errorf("failed to read %s: %v", layoutName, err))
// }
// // 2) Unmarshal into your struct
// if err := xml.Unmarshal(data, &layout); err != nil {
// errorhandlers.FatalError(fmt.Errorf("failed to parse %s: %v", layoutName, err))
// }
// return layout
// }
func startChipDnaClient() {
startClient := func() (*exec.Cmd, error) {
cmd := exec.Command("./ChipDNAClient/ChipDnaClient.exe")
@@ -325,4 +311,4 @@ func pdqSerialForKiosk(pdqs []cmstypes.PDQRec, kiosk int) string {
}
return ""
}
}
+236
View File
@@ -0,0 +1,236 @@
package main
import (
"context"
"encoding/json"
"errors"
"go/ast"
"go/parser"
"go/token"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
log "github.com/sirupsen/logrus"
)
type startupFixtureStop struct{}
type startupLogHook struct{}
func (startupLogHook) Levels() []log.Level { return log.AllLevels }
func (startupLogHook) Fire(entry *log.Entry) error {
if strings.HasPrefix(entry.Message, "Payment provider enabled for POST /api/payment/sale:") {
if err := os.WriteFile("provider-started.txt", []byte(entry.Message), 0600); err != nil {
os.Exit(92)
}
// Stop before main binds HTTP or admits any financial/device operation.
panic(startupFixtureStop{})
}
return nil
}
// This child process executes the real startup/fatal-notification path. TestMode
// and TLJ bypass devices; missing DB configuration returns before opening SQL.
func TestPostAuditStartupFixture(t *testing.T) {
scenario := os.Getenv("HARDLINK_POST_AUDIT_STARTUP")
if scenario == "" {
t.Skip("isolated startup fixture")
}
hotel := syntheticTrustHotel()
switch scenario {
case "gateway":
hotel.ReservationSystem.PaymentGatewayURL = ""
case "password":
hotel.ReservationSystem.PaymentGatewayPasswordEPOS = ""
case "ped":
hotel.ReservationSystem.PDQs = nil
case "timezone":
hotel.ReservationSystem.TimeZone = "SYNTH/INVALID"
case "none":
hotel.ReservationSystem.PaymentSystem = cmstypes.PaySystemNone
case "unsupported":
hotel.ReservationSystem.PaymentSystem = 999
case "ready":
default:
t.Fatal("unrecognized synthetic startup scenario")
}
transport := cmsTrustTransport(func(r *http.Request) (*http.Response, error) {
var body []byte
switch r.URL.Hostname() {
case "cms.invalid":
response := cmstypes.HotelResponseRec{TheHotel: hotel}
response.Status.Code = cmstypes.StatusSuccessCode
var err error
body, err = json.Marshal(response)
if err != nil {
return nil, err
}
case "api.mailjet.com":
var notification struct {
Messages []struct{ Subject, TextPart string }
}
if err := json.NewDecoder(r.Body).Decode(&notification); err != nil {
return nil, err
}
// Retain only notification text, never headers or API authentication.
encoded, err := json.Marshal(notification)
if err != nil {
return nil, err
}
if err := os.WriteFile("notification.json", encoded, 0600); err != nil {
return nil, err
}
body = []byte(`{"Messages":[{"Status":"success"}]}`)
default:
if err := os.WriteFile("unexpected-network.txt", []byte("rejected non-mock request"), 0600); err != nil {
return nil, err
}
return nil, errors.New("offline startup fixture prohibits network")
}
return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(string(body)))}, nil
})
http.DefaultTransport = transport
http.DefaultClient = &http.Client{Transport: transport}
log.AddHook(startupLogHook{})
defer func() {
if stopped := recover(); stopped != nil {
if _, ok := stopped.(startupFixtureStop); !ok {
panic(stopped)
}
}
}()
main()
t.Fatal("startup fixture unexpectedly returned from main")
}
func TestTrustStartupUsesExistingFatalNotification(t *testing.T) {
for _, tc := range []struct{ name, field string }{
{"gateway", "PaymentGatewayURL"}, {"password", "PaymentGatewayPasswordEPOS"},
{"ped", "PED"}, {"timezone", "TimeZone"},
{"none", "expected creditcall, trustpayments, paybridge or dojo"},
{"unsupported", "expected creditcall, trustpayments, paybridge or dojo"},
{"ready", ""},
} {
t.Run(tc.name, func(t *testing.T) {
dir := t.TempDir()
configuration := "hotel: SYNTH-HOTEL\nkiosk: 9\nlockType: tlj\ntestMode: true\nisPayment: true\ncmsurl: http://cms.invalid\nsenderroremails:\n - operator@example.test\nlogdir: ./logs\n"
if err := os.WriteFile(filepath.Join(dir, "config.yml"), []byte(configuration), 0600); err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
defer cancel()
process := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestPostAuditStartupFixture$")
process.Dir = dir
process.Env = append(os.Environ(), "HARDLINK_POST_AUDIT_STARTUP="+tc.name)
process.Stdin = strings.NewReader("\n")
output, err := process.CombinedOutput()
if ctx.Err() != nil {
t.Fatalf("Startup(%s) timed out: %v", tc.name, ctx.Err())
}
if tc.name == "ready" {
if err != nil {
t.Fatalf("Startup(ready) error=%v output=%s, want successful synthetic initialization", err, output)
}
started, readErr := os.ReadFile(filepath.Join(dir, "provider-started.txt"))
if readErr != nil || !strings.HasSuffix(string(started), "trustpayments") {
t.Errorf("Startup(ready) log=%q error=%v, want common Trust provider-enabled log", started, readErr)
}
if _, statErr := os.Stat(filepath.Join(dir, "notification.json")); !os.IsNotExist(statErr) {
t.Errorf("Startup(ready) notification error=%v, want no failure notification", statErr)
}
} else {
var exitError *exec.ExitError
if !errors.As(err, &exitError) || exitError.ExitCode() != 1 {
t.Fatalf("Startup(%s) error=%v output=%s, want fatal exit1", tc.name, err, output)
}
notification, readErr := os.ReadFile(filepath.Join(dir, "notification.json"))
if readErr != nil {
t.Fatalf("Startup(%s) notification error=%v, want existing fatal mail attempted", tc.name, readErr)
}
text := string(notification)
for _, want := range []string{"SYNTH-HOTEL", "kiosk: 9", tc.field} {
if !strings.Contains(text, want) {
t.Errorf("Startup(%s) notification missing %q", tc.name, want)
}
}
if tc.name != "none" && tc.name != "unsupported" && !strings.Contains(text, "Failed to initialize Trust Payments") {
t.Errorf("Startup(%s) notification lacks Trust initialization title", tc.name)
}
logs, _ := os.ReadFile(filepath.Join(dir, "logs", "hardlink.log"))
for _, secret := range []string{"SYNTH-PASSWORD", "SYNTH-PED"} {
if strings.Contains(text+string(output)+string(logs), secret) {
t.Errorf("Startup(%s) diagnostic leaked synthetic secret %q", tc.name, secret)
}
}
}
if _, statErr := os.Stat(filepath.Join(dir, "unexpected-network.txt")); !os.IsNotExist(statErr) {
t.Errorf("Startup(%s) attempted a non-mock request", tc.name)
}
})
}
}
func TestProviderEnabledLoggingIsSharedByAllSelections(t *testing.T) {
file, err := parser.ParseFile(token.NewFileSet(), "main.go", nil, 0)
if err != nil {
t.Fatal(err)
}
var paymentBody *ast.BlockStmt
ast.Inspect(file, func(node ast.Node) bool {
if statement, ok := node.(*ast.IfStmt); ok {
if condition, ok := statement.Cond.(*ast.SelectorExpr); ok && condition.Sel.Name == "IsPayment" {
paymentBody = statement.Body
return false
}
}
return true
})
if paymentBody == nil {
t.Fatal("main has no payment startup block")
}
sharedMessages := 0
for _, statement := range paymentBody.List {
expression, ok := statement.(*ast.ExprStmt)
if !ok {
continue
}
call, ok := expression.X.(*ast.CallExpr)
if !ok || len(call.Args) != 2 {
continue
}
format, ok := call.Args[0].(*ast.BasicLit)
if !ok {
continue
}
text, err := strconv.Unquote(format.Value)
if err != nil || !strings.HasPrefix(text, "Payment provider enabled for POST /api/payment/sale:") {
continue
}
index, ok := call.Args[1].(*ast.IndexExpr)
if !ok {
t.Error("common startup message does not use selected provider name")
continue
}
name, ok := index.X.(*ast.SelectorExpr)
if !ok || name.Sel.Name != "PaySystemNames" {
t.Error("common startup message lost standard provider names")
continue
}
sharedMessages++
}
if sharedMessages != 2 {
t.Errorf("main has %d unconditional common provider messages, want logging and console outside provider-specific branches", sharedMessages)
}
for _, provider := range []int{cmstypes.PaySystemCreditCall, cmstypes.PaySystemTrustPayments, cmstypes.PaySystemDojo, cmstypes.PaySystemPayBridge} {
if cmstypes.PaySystemNames[provider] == "" {
t.Errorf("common startup name for provider%d is empty", provider)
}
}
}
+36
View File
@@ -0,0 +1,36 @@
package main
import (
"errors"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/handlers"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments"
)
func configureTrust(app *handlers.App, cfg config.ConfigRec, hotel cmstypes.Hotel) error {
res := hotel.ReservationSystem
serial, count := "", 0
for _, pdq := range res.PDQs {
if pdq.Kiosk == cfg.Kiosk {
serial = pdq.Serial
count++
}
}
if count != 1 || serial == "" {
return errors.New("exactly one Trust PED serial required")
}
client, err := trustpayments.New(
trustpayments.Config{
BaseURL: res.PaymentGatewayURL,
SiteID: res.PaymentGatewaySiteIDEPOS,
Password: res.PaymentGatewayPasswordEPOS,
Terminal: serial,
Currency: hotel.Currency.Code,
Timezone: res.TimeZone})
if err != nil {
return err
}
app.SetTrustPayments(client)
return nil
}
+155
View File
@@ -0,0 +1,155 @@
package main
import (
"context"
"encoding/json"
"errors"
"io"
"net"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"sync/atomic"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/cms"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/handlers"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/trustpayments"
yaml "gopkg.in/yaml.v3"
)
type cmsTrustTransport func(*http.Request) (*http.Response, error)
func (f cmsTrustTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func syntheticTrustHotel() cmstypes.Hotel {
hotel := cmstypes.Hotel{Currency: cmstypes.CurrencyRec{Code: "GBP", NumDecimals: 2}}
hotel.Updated = 1
hotel.ReservationSystem = cmstypes.ReservationSystemRec{PaymentSystem: cmstypes.PaySystemTrustPayments, PaymentGatewayURL: "https://sandbox.link.trustpayments.com/trustpayments/rest", PaymentGatewaySiteIDEPOS: "SYNTH-SITE", PaymentGatewayPasswordEPOS: "SYNTH-PASSWORD", TimeZone: "Europe/London", PDQs: []cmstypes.PDQRec{{Kiosk: 4, Serial: "OTHER-PED"}, {Kiosk: 9, Serial: "SYNTH-PED"}}}
return hotel
}
func TestConfigureTrustUsesCMSWithoutLocalTrustYAML(t *testing.T) {
var cfg config.ConfigRec
if err := yaml.Unmarshal([]byte("hotel: SYNTH-HOTEL\nkiosk: 9\nlockType: assaabloy\nisPayment: true\n"), &cfg); err != nil {
t.Fatal(err)
}
if _, exists := reflect.TypeOf(cfg).FieldByName("Trust"); exists {
t.Fatal("ConfigRec still exposes local Trust configuration")
}
hotel := syntheticTrustHotel()
var cmsCalls, financialCalls atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
cmsCalls.Add(1)
response := cmstypes.HotelResponseRec{TheHotel: hotel}
response.Status.Code = cmstypes.StatusSuccessCode
_ = json.NewEncoder(w).Encode(response)
}))
defer server.Close()
cfg.CMSBaseURL = server.URL
original := http.DefaultTransport
base := original.(*http.Transport).Clone()
base.Proxy = nil
dialer := &net.Dialer{}
base.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
if address != server.Listener.Addr().String() {
return nil, errors.New("offline test rejected non-mock dial")
}
return dialer.DialContext(ctx, network, address)
}
http.DefaultTransport = cmsTrustTransport(func(r *http.Request) (*http.Response, error) {
if r.URL.Host == server.Listener.Addr().String() {
return base.RoundTrip(r)
}
if r.URL.Host != "sandbox.link.trustpayments.com" || r.URL.Path != "/trustpayments/rest/sale" {
return nil, errors.New("offline test rejected unregistered request")
}
financialCalls.Add(1)
var payload map[string]string
if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
return nil, err
}
if payload["siteid"] != hotel.ReservationSystem.PaymentGatewaySiteIDEPOS || payload["terminalserialnumber"] != "SYNTH-PED" || payload["amount"] != "25.00" {
t.Errorf("provider request = %v, want CMS credentials/PED and exact amount", payload)
}
wantToken := trustpayments.Token(hotel.ReservationSystem.PaymentGatewaySiteIDEPOS, payload["txndate"], payload["refid"], hotel.ReservationSystem.PaymentGatewayPasswordEPOS)
if r.Header.Get("token") != wantToken {
t.Error("request was not signed with CMS credentials")
}
location, _ := time.LoadLocation(hotel.ReservationSystem.TimeZone)
signedAt, err := time.ParseInLocation("2006-01-02:15:04:05", payload["txndate"], location)
if err != nil || time.Since(signedAt) < -time.Second || time.Since(signedAt) > 5*time.Second {
t.Errorf("CMS signing timezone was not used: %q/%v", payload["txndate"], err)
}
// A definite refusal exercises dispatch without invoking any receipt printer.
body, _ := json.Marshal(map[string]string{"refid": payload["refid"], "siteid": payload["siteid"], "terminalserialnumber": payload["terminalserialnumber"], "type": "sale", "resultcode": "Declined"})
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(string(body)))}, nil
})
t.Cleanup(func() { http.DefaultTransport = original; base.CloseIdleConnections() })
loaded, err := cms.ReadHotelDetails(cfg.Hotel, cfg.CMSBaseURL)
if err != nil {
t.Fatal(err)
}
if loaded.Currency != hotel.Currency {
t.Fatal("full CMS hotel currency was discarded")
}
app := handlers.NewApp(nil, cfg.LockType, "synthetic", "", nil, &cfg)
if err := configureTrust(app, cfg, loaded); err != nil {
t.Fatal(err)
}
if cmsCalls.Load() != 1 || financialCalls.Load() != 0 {
t.Fatal("initialization made extra CMS or financial requests")
}
mux := http.NewServeMux()
app.RegisterRoutes(mux)
w := httptest.NewRecorder()
r := httptest.NewRequest("POST", "/api/payment/sale", strings.NewReader(`{"amount":2500,"currency":"DIFFERENT"}`))
mux.ServeHTTP(w, r)
if w.Code != 200 || !strings.Contains(w.Body.String(), `"outcome":"declined"`) || financialCalls.Load() != 1 {
t.Fatalf("CMS-only terminal request = HTTP %d/%s calls=%d", w.Code, w.Body.String(), financialCalls.Load())
}
}
func TestConfigureTrustRejectsMissingEssentialCMSSettingsBeforeDispatch(t *testing.T) {
cases := []struct {
name, field string
change func(*cmstypes.Hotel)
}{
{"gateway", "PaymentGatewayURL", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewayURL = "" }},
{"invalid gateway", "PaymentGatewayURL", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewayURL = "http://synthetic.invalid" }},
{"site", "PaymentGatewaySiteIDEPOS", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewaySiteIDEPOS = "" }},
{"password", "PaymentGatewayPasswordEPOS", func(h *cmstypes.Hotel) { h.ReservationSystem.PaymentGatewayPasswordEPOS = "" }},
{"missing PED", "PED", func(h *cmstypes.Hotel) { h.ReservationSystem.PDQs = nil }},
{"empty PED", "PED", func(h *cmstypes.Hotel) { h.ReservationSystem.PDQs[1].Serial = "" }},
{"duplicate PED", "PED", func(h *cmstypes.Hotel) {
h.ReservationSystem.PDQs = append(h.ReservationSystem.PDQs, h.ReservationSystem.PDQs[1])
}},
{"timezone", "TimeZone", func(h *cmstypes.Hotel) { h.ReservationSystem.TimeZone = "" }},
{"invalid timezone", "TimeZone", func(h *cmstypes.Hotel) { h.ReservationSystem.TimeZone = "SYNTH/INVALID" }},
{"machine timezone", "TimeZone", func(h *cmstypes.Hotel) { h.ReservationSystem.TimeZone = "Local" }},
}
var networkCalls atomic.Int32
original := http.DefaultTransport
http.DefaultTransport = cmsTrustTransport(func(*http.Request) (*http.Response, error) {
networkCalls.Add(1)
return nil, errors.New("offline test rejects all network")
})
t.Cleanup(func() { http.DefaultTransport = original })
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
hotel := syntheticTrustHotel()
tc.change(&hotel)
err := configureTrust(&handlers.App{}, config.ConfigRec{Kiosk: 9}, hotel)
if err == nil || !strings.Contains(err.Error(), tc.field) || strings.Contains(err.Error(), "SYNTH-PASSWORD") {
t.Errorf("configureTrust(%s)=%v, want safe field-specific error", tc.name, err)
}
})
}
if networkCalls.Load() != 0 {
t.Fatalf("invalid CMS settings triggered %d requests", networkCalls.Load())
}
}
+18 -12
View File
@@ -17,14 +17,20 @@ import (
// ReadHotel gets the hotel record from CMS and returns its reservation system
// configuration if the record has been updated since the last read.
func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, error) {
var reservationSystem cmstypes.ReservationSystemRec
hotel, err := ReadHotelDetails(hotelCode, CMSBaseURL)
return hotel.ReservationSystem, err
}
// ReadHotelDetails retains the complete hotel response, including its currency.
func ReadHotelDetails(hotelCode, CMSBaseURL string) (cmstypes.Hotel, error) {
var hotel cmstypes.Hotel
if hotelCode == "" {
return reservationSystem, errors.New("hotel code is empty")
return hotel, errors.New("hotel code is empty")
}
if CMSBaseURL == "" {
return reservationSystem, errors.New("CMS base URL is empty")
return hotel, errors.New("CMS base URL is empty")
}
var request cmstypes.RequestRec
@@ -36,7 +42,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err
requestData, err := json.Marshal(request)
if err != nil {
return reservationSystem, fmt.Errorf(
return hotel, fmt.Errorf(
"marshal CMS hotel request: %w",
err,
)
@@ -46,7 +52,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err
req, err := http.NewRequest(http.MethodPost, requestURL, bytes.NewReader(requestData))
if err != nil {
return reservationSystem, fmt.Errorf(
return hotel, fmt.Errorf(
"create CMS hotel request: %w",
err,
)
@@ -61,7 +67,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err
resp, err := client.Do(req)
if err != nil {
return reservationSystem, fmt.Errorf(
return hotel, fmt.Errorf(
"perform CMS hotel request: %w",
err,
)
@@ -70,7 +76,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err
body, err := io.ReadAll(resp.Body)
if err != nil {
return reservationSystem, fmt.Errorf(
return hotel, fmt.Errorf(
"read CMS hotel response: %w",
err,
)
@@ -78,7 +84,7 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err
if resp.StatusCode < http.StatusOK ||
resp.StatusCode >= http.StatusMultipleChoices {
return reservationSystem, fmt.Errorf(
return hotel, fmt.Errorf(
"CMS hotel request returned HTTP %s: %s",
resp.Status,
string(body),
@@ -88,26 +94,26 @@ func ReadHotel(hotelCode, CMSBaseURL string) (cmstypes.ReservationSystemRec, err
var hotelResponse cmstypes.HotelResponseRec
if err := json.Unmarshal(body, &hotelResponse); err != nil {
return reservationSystem, fmt.Errorf(
return hotel, fmt.Errorf(
"unmarshal CMS hotel response: %w",
err,
)
}
if hotelResponse.Status.Code != cmstypes.StatusSuccessCode {
return reservationSystem, fmt.Errorf(
return hotel, fmt.Errorf(
"CMS hotel request failed: %s",
hotelResponse.Status.Message,
)
}
if hotelResponse.TheHotel.Updated <= -1 {
return reservationSystem, errors.New(
return hotel, errors.New(
"hotel record not updated since last read",
)
}
return hotelResponse.TheHotel.ReservationSystem, nil
return hotelResponse.TheHotel, nil
}
func PaymentSystemIndex(name string) int {
+5 -6
View File
@@ -4,7 +4,6 @@ import (
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
@@ -17,7 +16,7 @@ func TestReadHotelSuccess(t *testing.T) {
expected := cmstypes.ReservationSystemRec{}
server := httptest.NewServer(http.HandlerFunc(
server := newCMSMockServer(http.HandlerFunc(
func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
t.Errorf(
@@ -157,7 +156,7 @@ func TestReadHotelValidation(t *testing.T) {
}
func TestReadHotelNotUpdated(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(
server := newCMSMockServer(http.HandlerFunc(
func(w http.ResponseWriter, _ *http.Request) {
response := cmstypes.HotelResponseRec{}
response.Status.Code = cmstypes.StatusSuccessCode
@@ -185,7 +184,7 @@ func TestReadHotelNotUpdated(t *testing.T) {
}
func TestReadHotelHTTPError(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(
server := newCMSMockServer(http.HandlerFunc(
func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
@@ -211,7 +210,7 @@ func TestReadHotelHTTPError(t *testing.T) {
}
func TestReadHotelInvalidJSON(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(
server := newCMSMockServer(http.HandlerFunc(
func(w http.ResponseWriter, _ *http.Request) {
w.Header().Set("Content-Type", "application/json")
@@ -230,4 +229,4 @@ func TestReadHotelInvalidJSON(t *testing.T) {
if !strings.Contains(err.Error(), "unmarshal CMS hotel response") {
t.Errorf("unexpected error: %v", err)
}
}
}
+60
View File
@@ -0,0 +1,60 @@
package cms
import (
"encoding/json"
"net/http"
"reflect"
"sync/atomic"
"testing"
"gitea.futuresens.co.uk/futuresens/cmstypes"
)
func TestReadHotelDetailsRetainsCMSPaymentConfiguration(t *testing.T) {
var calls atomic.Int32
hotel := cmstypes.Hotel{Currency: cmstypes.CurrencyRec{Code: "GBP", NumDecimals: 2}}
hotel.Updated = 1
hotel.ReservationSystem = cmstypes.ReservationSystemRec{PaymentSystem: cmstypes.PaySystemTrustPayments, PaymentGatewayURL: "https://sandbox.link.trustpayments.com/trustpayments/rest", PaymentGatewaySiteIDEPOS: "SYNTH-SITE", PaymentGatewayPasswordEPOS: "SYNTH-PASSWORD", TimeZone: "Europe/London", PDQs: []cmstypes.PDQRec{{Kiosk: 9, Serial: "SYNTH-PED"}}}
server := newCMSMockServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
calls.Add(1)
if r.Method != http.MethodPost || r.URL.Path != cmstypes.APIHotelDetails {
t.Errorf("CMS request = %s %s, want existing hotel-details POST", r.Method, r.URL.Path)
}
var request cmstypes.RequestRec
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
t.Error(err)
}
if request.Auth.Hotel != "SYNTH-HOTEL" || request.Data != "SYNTH-HOTEL" {
t.Error("CMS hotel identity changed")
}
response := cmstypes.HotelResponseRec{TheHotel: hotel}
response.Status.Code = cmstypes.StatusSuccessCode
if err := json.NewEncoder(w).Encode(response); err != nil {
t.Error(err)
}
}))
defer server.Close()
got, err := ReadHotelDetails("SYNTH-HOTEL", server.URL)
if err != nil || !reflect.DeepEqual(got, hotel) || calls.Load() != 1 {
t.Fatalf("ReadHotelDetails = %+v/%v requests=%d, want complete CMS hotel in one request", got, err, calls.Load())
}
}
func TestReadHotelProjectionPreservesOtherProviderSettings(t *testing.T) {
for _, provider := range []int{cmstypes.PaySystemCreditCall, cmstypes.PaySystemDojo, cmstypes.PaySystemPayBridge} {
t.Run(cmstypes.PaySystemNames[provider], func(t *testing.T) {
var calls atomic.Int32
response := cmstypes.HotelResponseRec{}
response.Status.Code = cmstypes.StatusSuccessCode
response.TheHotel.Updated = 1
response.TheHotel.Currency = cmstypes.CurrencyRec{Code: "GBP", NumDecimals: 2}
response.TheHotel.ReservationSystem = cmstypes.ReservationSystemRec{PaymentSystem: provider, PaymentGatewayURL: "https://synthetic.invalid", PaymentGatewayAPIKeyWeb: "SYNTH-API", PaymentGatewaySiteIDEPOS: "SYNTH-SITE", PaymentGatewayPasswordEPOS: "SYNTH-PASSWORD", PDQs: []cmstypes.PDQRec{{Kiosk: 9, Serial: "SYNTH-PED"}}}
server := newCMSMockServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { calls.Add(1); _ = json.NewEncoder(w).Encode(response) }))
defer server.Close()
got, err := ReadHotel("SYNTH-HOTEL", server.URL)
if err != nil || !reflect.DeepEqual(got, response.TheHotel.ReservationSystem) || calls.Load() != 1 {
t.Fatalf("ReadHotel projection = %+v/%v calls=%d, want unchanged provider settings and one request", got, err, calls.Load())
}
})
}
}
+43
View File
@@ -0,0 +1,43 @@
package cms
import (
"errors"
"net/http"
"net/http/httptest"
"os"
"sync"
"testing"
)
var cmsMockHosts = struct {
sync.RWMutex
values map[string]bool
}{values: make(map[string]bool)}
type cmsOfflineTransport struct{ base http.RoundTripper }
func (t cmsOfflineTransport) RoundTrip(r *http.Request) (*http.Response, error) {
cmsMockHosts.RLock()
allowed := cmsMockHosts.values[r.URL.Host]
cmsMockHosts.RUnlock()
if !allowed {
return nil, errors.New("offline CMS tests reject unregistered endpoints")
}
return t.base.RoundTrip(r)
}
func newCMSMockServer(handler http.Handler) *httptest.Server {
server := httptest.NewServer(handler)
cmsMockHosts.Lock()
cmsMockHosts.values[server.Listener.Addr().String()] = true
cmsMockHosts.Unlock()
return server
}
func TestMain(m *testing.M) {
base := http.DefaultTransport.(*http.Transport).Clone()
base.Proxy = nil
http.DefaultTransport = cmsOfflineTransport{base: base}
http.DefaultClient = &http.Client{Transport: http.DefaultTransport}
os.Exit(m.Run())
}
-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:
}
}
+15 -38
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,32 +93,8 @@ 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) {
// PreauthDecision preserves the returned-type approval and persistence rules.
func PreauthDecision(result map[string]string) (approved, persist bool) {
res := result[types.TransactionResult]
tType := result[types.TransactionType]
@@ -136,7 +106,7 @@ func BuildPreauthRedirectURL(result map[string]string) (string, bool) {
log.WithField(types.LogResult, result[types.TransactionResult]).
Info("Account verification approved")
return BuildSuccessURL(result), false
return true, false
// Transaction type Sale?
case strings.EqualFold(tType, types.SaleTransactionType):
@@ -144,12 +114,12 @@ func BuildPreauthRedirectURL(result map[string]string) (string, bool) {
log.WithField(types.LogResult, result[types.ConfirmResult]).
Info("Amount preauthorized successfully")
return BuildSuccessURL(result), true
return true, true
}
}
// Not approved
return BuildFailureURL(res, result[types.Errors]), false
return false, false
}
func BuildSuccessURL(result map[string]string) string {
@@ -168,9 +138,7 @@ func BuildSuccessURL(result map[string]string) string {
func BuildFailureURL(msgType, description string) string {
q := url.Values{}
if msgType != "" {
description = fmt.Sprintf("Transaction %s", strings.ToLower(msgType))
}
description = FailureDescription(msgType, description)
if description != "" {
msgType = types.ResultError
}
@@ -185,3 +153,12 @@ func BuildFailureURL(msgType, description string) string {
RawQuery: q.Encode(),
}).String()
}
// FailureDescription preserves the description used by the legacy payment flow
// without requiring structured consumers to construct a redirect URL.
func FailureDescription(msgType, description string) string {
if msgType != "" {
return fmt.Sprintf("Transaction %s", strings.ToLower(msgType))
}
return description
}
+34
View File
@@ -0,0 +1,34 @@
package creditcall
import (
"testing"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
)
func TestPreauthLegacyDecision(t *testing.T) {
for _, tc := range []struct {
name, result, kind string
approved, save bool
}{
{"sale", "APPROVED", "SALE", true, true},
{"verification", "APPROVED", "ACCOUNT VERIFICATION", true, false},
{"mixed case", "Approved", "Account Verification", true, false},
{"request spelling is not result spelling", "APPROVED", "AccountVerification", false, false},
{"missing type", "APPROVED", "", false, false},
{"declined sale", "DECLINED", "SALE", false, false},
{"declined verification", "DECLINED", "ACCOUNT VERIFICATION", false, false},
{"missing result", "", "SALE", false, false},
} {
t.Run(tc.name, func(t *testing.T) {
fields := map[string]string{types.TransactionResult: tc.result, types.TransactionType: tc.kind, types.Errors: "provider detail"}
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("PreauthDecision fabricated TOTAL_AMOUNT")
}
})
}
}
+64
View File
@@ -0,0 +1,64 @@
package creditcall
import "gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
// ProgressStatus maps informational SDK events, never financial decisions.
func ProgressStatus(source, value string) string {
switch source {
case "UPDATE":
switch value {
case "CardRequested", "ProvideCard", "InsertOrSwipeCard", "InsertOrContactless":
return paymentstatus.PresentCard
case "InsertCard":
return paymentstatus.InsertCard
case "SwipeCard":
return paymentstatus.SwipeCard
case "CardRemovalRequested", "CardRemovalEnforced":
return paymentstatus.RemoveCard
case "PinEntryStarted", "PinEntryPrompt", "PinEntryInProgress":
return paymentstatus.EnterPIN
case "PinEntryFailed":
return paymentstatus.EnterPINAgain
case "PinEntrySuccessful", "TransactionStarted", "OnlineAuthRequested", "OnlineAuthorizeRequest":
return paymentstatus.Processing
case "OnlineAuthCompleted":
return paymentstatus.PleaseWait
}
case "CARD_STATUS":
switch value {
case "Inserted":
return paymentstatus.DoNotRemoveCard
case "Tapped", "Swiped":
return paymentstatus.Processing
}
case "SIGNATURE":
if value == "Requested" {
return paymentstatus.SignatureRequired
}
case "PAUSE":
if value == "Paused" {
return paymentstatus.PleaseWait
}
}
return ""
}
// MaskedCardNumber excludes unmasked or unexpected SDK data from the new wire contract.
func MaskedCardNumber(value string) string {
digits, masks := 0, 0
for _, ch := range value {
switch {
case ch >= '0' && ch <= '9':
digits++
case ch == '*' || ch == 'x' || ch == 'X':
masks++
case ch == ' ' || ch == '-':
default:
return ""
}
}
if masks < 4 || digits > 10 {
return ""
}
return value
}
+52
View File
@@ -0,0 +1,52 @@
package creditcall
import (
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
"testing"
)
func TestProgressStatus(t *testing.T) {
for _, test := range []struct{ source, value, want string }{
{"UPDATE", "CardRequested", paymentstatus.PresentCard},
{"UPDATE", "ProvideCard", paymentstatus.PresentCard},
{"UPDATE", "InsertOrSwipeCard", paymentstatus.PresentCard},
{"UPDATE", "InsertOrContactless", paymentstatus.PresentCard},
{"UPDATE", "InsertCard", paymentstatus.InsertCard},
{"UPDATE", "SwipeCard", paymentstatus.SwipeCard},
{"UPDATE", "CardRemovalRequested", paymentstatus.RemoveCard},
{"UPDATE", "CardRemovalEnforced", paymentstatus.RemoveCard},
{"UPDATE", "PinEntryStarted", paymentstatus.EnterPIN},
{"UPDATE", "PinEntryPrompt", paymentstatus.EnterPIN},
{"UPDATE", "PinEntryInProgress", paymentstatus.EnterPIN},
{"UPDATE", "PinEntryFailed", paymentstatus.EnterPINAgain},
{"UPDATE", "PinEntrySuccessful", paymentstatus.Processing},
{"UPDATE", "TransactionStarted", paymentstatus.Processing},
{"UPDATE", "OnlineAuthRequested", paymentstatus.Processing},
{"UPDATE", "OnlineAuthorizeRequest", paymentstatus.Processing},
{"UPDATE", "OnlineAuthCompleted", paymentstatus.PleaseWait},
{"CARD_STATUS", "Inserted", paymentstatus.DoNotRemoveCard},
{"CARD_STATUS", "Tapped", paymentstatus.Processing},
{"CARD_STATUS", "Swiped", paymentstatus.Processing},
{"CARD_STATUS", "Removed", ""},
{"SIGNATURE", "Requested", paymentstatus.SignatureRequired},
{"PAUSE", "Paused", paymentstatus.PleaseWait},
{"UPDATE", "Approved", ""}, {"UPDATE", "Declined", ""},
{"UPDATE", "unknown", ""}, {"PAN", "CardRequested", ""},
} {
if got := ProgressStatus(test.source, test.value); got != test.want {
t.Errorf("ProgressStatus(%q, %q) = %q, want %q", test.source, test.value, got, test.want)
}
}
}
func TestMaskedCardNumber(t *testing.T) {
for _, test := range []struct{ value, want string }{
{"123456******1234", "123456******1234"}, {"************1234", "************1234"},
{"1234567890123456", ""}, {"1234567890123456****", ""}, {"3132333435363738", ""},
{"%B1234567890123456^NAME", ""}, {"", ""},
} {
if got := MaskedCardNumber(test.value); got != test.want {
t.Errorf("MaskedCardNumber(%q) = %q, want %q", test.value, got, test.want)
}
}
}
+2 -3
View File
@@ -84,12 +84,12 @@ 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)
}
releaseDate := checkOutDate.Add(48 * time.Hour)
releaseDate := checkOutDate.Add(96 * time.Hour)
const stmt = `
INSERT INTO dbo.Preauthorizations
@@ -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
}
+363
View File
@@ -0,0 +1,363 @@
package dispenser
import (
"context"
"errors"
"io"
"reflect"
"testing"
"time"
)
func apReply(st []byte) []byte {
frame := []byte{STX, 0x30, 0x30, 0, byte(len(st) + 2), 'S', 'F'}
frame = append(frame, st...)
frame = append(frame, ETX)
return append(frame, calculateBCC(frame))
}
func workerRequest(c *Client, ctx context.Context, typ cmdType) cmdResp {
ch := make(chan cmdResp, 1)
c.handle(cmdReq{typ: typ, ctx: ctx, respCh: ch})
return <-ch
}
func TestDeliveryDispatchBoundary(t *testing.T) {
transportAddress(t)
for _, tc := range []struct {
name string
short int
badACK bool
cancelAfter int
pending bool
wantErr bool
}{
{name: "success", pending: true},
{name: "command short write", short: 1, wantErr: true},
{name: "bad ACK", badACK: true, wantErr: true},
{name: "ENQ short write", short: 2, pending: true, wantErr: true},
{name: "cancel before ENQ", cancelAfter: 1, wantErr: true},
{name: "cancel after ENQ", cancelAfter: 2, pending: true, wantErr: true},
} {
t.Run(tc.name, func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
ack := append([]byte(nil), vendorACK...)
if tc.badACK {
ack[0] = 0
}
p := &scriptedTransport{chunks: [][]byte{ack}, shortWrite: tc.short}
p.afterWrite = func() {
if len(p.writes) == tc.cancelAfter {
cancel()
}
}
c := &Client{port: p}
r := workerRequest(c, ctx, cmdOutOfMouth)
if (r.err != nil) != tc.wantErr || c.deliveryPending != tc.pending {
t.Errorf("FC0(%s): err=%v pending=%v, want error=%v pending=%v", tc.name, r.err, c.deliveryPending, tc.wantErr, tc.pending)
}
if len(p.writes) > 2 {
t.Errorf("FC0 writes=%d, want no resend", len(p.writes))
}
})
}
t.Run("definite failure preserves previous pending", func(t *testing.T) {
c := &Client{port: &scriptedTransport{writeErr: io.ErrClosedPipe}, deliveryPending: true}
workerRequest(c, context.Background(), cmdOutOfMouth)
if !c.deliveryPending {
t.Error("failed FC0 erased previous pending")
}
})
t.Run("ENQ transport error remains pending", func(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK}}
p.afterWrite = func() {
if len(p.writes) == 2 {
p.writeErr = io.ErrClosedPipe
}
}
c := &Client{port: p}
r := workerRequest(c, context.Background(), cmdOutOfMouth)
if !errors.Is(r.err, io.ErrClosedPipe) || !c.deliveryPending {
t.Errorf("ENQ error=%v pending=%v, want closed pipe and pending", r.err, c.deliveryPending)
}
})
}
func TestWorkerClearanceValidation(t *testing.T) {
transportAddress(t)
for _, tc := range []struct {
name string
st []byte
clear bool
}{
{"clear", status(0x30), true},
{"low stock clear", []byte{0x30, 0x30, 0x31, 0x30}, true},
{"residual encoder", status(0x33), false},
{"all sensors", status(0x37), false},
{"ready", status(0x34), true},
{"unknown diagnostic", []byte{0x30, 0x30, 0xFF, 0x30}, true},
{"jam", []byte{0x30, 0x30, 0x32, 0x30}, true},
{"overlap", []byte{0x30, 0x30, 0x34, 0x30}, true},
{"rejection", []byte{0x36, 0x30, 0x30, 0x30}, true},
{"empty", status(0x38), false},
{"preparing", []byte{0x31, 0x30, 0x30, 0x30}, false},
{"dispensing", []byte{0x30, 0x38, 0x30, 0x34}, false},
{"capturing", []byte{0x30, 0x34, 0x30, 0x30}, false},
{"ready with stale errors", []byte{0x36, 0x32, 0x34, 0x34}, true},
{"short payload", []byte{0x30, 0x30, 0x30}, false},
{"unknown position", status(0x40), false},
} {
t.Run(tc.name, func(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(tc.st), vendorACK}}
c := &Client{port: p, deliveryPending: true, deliveryStarted: time.Now().Add(-deliveryMinimumWait), lastStatus: status(0x30), lastStatusT: time.Now(), statusTTL: time.Hour}
r := workerRequest(c, context.Background(), cmdStatus)
if c.deliveryPending == tc.clear {
t.Errorf("FC7(% X): err=%v pending=%v, want clear=%v", tc.st, r.err, c.deliveryPending, tc.clear)
}
want := []string{"AP"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("commands=%v, want %v", got, want)
}
})
}
t.Run("bad BCC cannot clear", func(t *testing.T) {
frame := apReply(status(0x30))
frame[len(frame)-1] ^= 1
p := &scriptedTransport{chunks: [][]byte{vendorACK, frame}}
c := &Client{port: p, deliveryPending: true}
r := workerRequest(c, context.Background(), cmdStatus)
if r.err == nil || !c.deliveryPending {
t.Errorf("bad BCC: err=%v pending=%v", r.err, c.deliveryPending)
}
})
}
func wireCommands(p *scriptedTransport) []string {
var commands []string
for _, w := range p.writes {
if len(w) > 6 && w[0] == STX {
commands = append(commands, string(w[5:len(w)-2]))
}
}
return commands
}
func deliveryWorkerClient(t *testing.T, p *scriptedTransport) (*Client, *time.Time) {
t.Helper()
transportAddress(t)
now := time.Unix(0, 0)
c := &Client{port: p, reqCh: make(chan cmdReq, 16), done: make(chan struct{})}
c.sequenceTiming = sequenceTiming{now: func() time.Time { return now }, wait: func(ctx context.Context, d time.Duration) error {
if err := ctx.Err(); err != nil {
return err
}
now = now.Add(d)
return nil
}}
stopped := make(chan struct{})
go func() { defer close(stopped); c.loop() }()
t.Cleanup(func() { c.Close(); <-stopped })
return c, &now
}
func TestDeliveryIncidentReplay(t *testing.T) {
for _, next := range []bool{false, true} {
t.Run(map[bool]string{false: "current", true: "next"}[next], func(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{
vendorACK, apReply(status(0x33)), // current card at encoder; encoding succeeds
vendorACK, // FC0
vendorACK, apReply(status(0x37)), // best effort must defer
vendorACK, apReply(status(0x33)), // previous encoder sensor must not succeed
vendorACK, apReply(status(0x34)),
vendorACK, // FC7
vendorACK, apReply(status(0x33)),
}}
c, now := deliveryWorkerClient(t, p)
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
t.Fatal(err)
}
if _, err := c.DeliverCurrentCard(context.Background()); err != nil {
t.Fatal(err)
}
// A cached clear result must not authorize FC7.
c.mu.Lock()
c.lastStatus = status(0x30)
c.lastStatusT = time.Now()
c.statusTTL = time.Hour
c.mu.Unlock()
if err := c.BeginPrepareNextCard(context.Background()); err != nil {
t.Fatal(err)
}
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP", "FC0", "AP", "AP", "AP", "FC7"}) {
t.Fatalf("prestaging commands=%v, want clearance APs then one FC7", got)
}
prepare := c.PrepareCurrentCard
if next {
prepare = c.PrepareNextCard
}
if _, err := prepare(context.Background()); err != nil {
t.Fatal(err)
}
want := []string{"AP", "FC0", "AP", "AP", "AP", "FC7", "AP"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("incident commands=%v, want %v", got, want)
}
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != 2*time.Second {
t.Errorf("clearance waits=%s, want 2s", elapsed)
}
})
}
}
func TestDeliveryClearWaitsTwoSeconds(t *testing.T) {
for _, position := range []byte{0x30, 0x34} {
p := &scriptedTransport{chunks: [][]byte{vendorACK,
vendorACK, apReply(status(position)), vendorACK, apReply(status(position)), vendorACK, apReply(status(position)),
vendorACK, vendorACK, apReply(status(0x37))}}
c, now := deliveryWorkerClient(t, p)
if _, err := c.DeliverCurrentCard(context.Background()); err != nil {
t.Fatal(err)
}
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
t.Fatal(err)
}
want := []string{"FC0", "AP", "AP", "AP", "FC7", "AP"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("clearance %X commands=%v, want %v", position, got, want)
}
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != deliveryMinimumWait {
t.Errorf("clearance %X elapsed=%s, want 2s", position, elapsed)
}
}
}
func TestDeliveryPendingIsNotPersisted(t *testing.T) {
c := NewClient(nil, 1)
defer c.Close()
if c.deliveryPending {
t.Error("new Client has pending delivery")
}
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x37))}}
fresh, _ := deliveryWorkerClient(t, p)
if _, err := fresh.PrepareCurrentCard(context.Background()); err != nil {
t.Errorf("fresh client encoder status: %v", err)
}
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP"}) {
t.Errorf("restart commands=%v, want AP only", got)
}
}
func TestDeliveryCancellationAfterACKDoesNotSetPending(t *testing.T) {
transportAddress(t)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
p := &scriptedTransport{chunks: [][]byte{vendorACK}, afterRead: cancel}
c := &Client{port: p}
r := workerRequest(c, ctx, cmdOutOfMouth)
if !errors.Is(r.err, context.Canceled) || c.deliveryPending || len(p.writes) != 1 {
t.Errorf("cancel after ACK: err=%v pending=%v writes=%d, want canceled, false, 1", r.err, c.deliveryPending, len(p.writes))
}
}
func TestWorkerSerializesClearanceAndFC7(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x30)), vendorACK, vendorACK, vendorACK, apReply(status(0x37))}}
c, _ := deliveryWorkerClient(t, p)
// Set initial state before any request can reach the worker.
c.deliveryPending = true
c.deliveryStarted = c.now().Add(-deliveryMinimumWait)
reading := make(chan struct{})
resume := make(chan struct{})
p.afterWrite = func() {
if len(p.writes) == 1 {
close(reading)
<-resume
}
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
fc7 := make(chan error, 1)
go func() { fc7 <- c.BeginPrepareNextCard(ctx) }()
select {
case <-reading:
case <-ctx.Done():
t.Fatal("worker did not begin AP")
}
fc0 := make(chan cmdResp, 1)
// This FC0 is queued while AP is in progress. It must not slip between
// the clearance observation and FC7 dispatch.
c.reqCh <- cmdReq{typ: cmdOutOfMouth, ctx: ctx, respCh: fc0}
close(resume)
if err := <-fc7; err != nil {
t.Fatal(err)
}
if r := <-fc0; r.err != nil {
t.Fatal(r.err)
}
want := []string{"AP", "FC7", "FC0"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("serialized commands=%v, want %v", got, want)
}
}
func TestDeliveryCancellationAfterFreshAPKeepsPending(t *testing.T) {
transportAddress(t)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x34))}}
p.afterRead = func() {
if len(p.chunks) == 0 {
cancel()
}
}
c := &Client{port: p, deliveryPending: true, deliveryStarted: time.Now().Add(-time.Minute)}
r := workerRequest(c, ctx, cmdToEncoder)
if !errors.Is(r.err, context.Canceled) || !c.deliveryPending {
t.Errorf("AP cancellation err=%v pending=%t, want canceled and pending", r.err, c.deliveryPending)
}
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP"}) {
t.Errorf("cancelled clearance commands=%v, want AP only", got)
}
}
func TestPreparationWireFailuresNeverShake(t *testing.T) {
badBCC := apReply(status(0x30))
badBCC[len(badBCC)-1] ^= 1
for _, frame := range [][]byte{nil, apReply(status(0x30))[:8], badBCC, apReply(status(0x40))} {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x30)), vendorACK, vendorACK}}
if frame != nil {
p.chunks = append(p.chunks, frame)
}
c, _ := deliveryWorkerClient(t, p)
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
t.Errorf("frame % X: err=%v, want encoder opportunity", frame, err)
}
want := []string{"AP", "FC7", "AP", "AP", "AP", "AP", "AP"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("frame % X commands=%v, want %v without RS or resends", frame, got, want)
}
}
}
func TestBeginPrepareNextCardWaitsForClearanceWithoutReadinessPolling(t *testing.T) {
for _, position := range []byte{0x30, 0x34} {
p := &scriptedTransport{chunks: [][]byte{vendorACK,
vendorACK, apReply(status(position)), vendorACK, apReply(status(position)), vendorACK, apReply(status(position)),
vendorACK}}
c, now := deliveryWorkerClient(t, p)
if _, err := c.DeliverCurrentCard(context.Background()); err != nil {
t.Fatal(err)
}
if err := c.BeginPrepareNextCard(context.Background()); err != nil {
t.Fatal(err)
}
want := []string{"FC0", "AP", "AP", "AP", "FC7"}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("BeginPrepareNextCard(%X) commands = %v, want %v", position, got, want)
}
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != deliveryMinimumWait {
t.Errorf("BeginPrepareNextCard(%X) waited %s, want %s", position, elapsed, deliveryMinimumWait)
}
}
}
+240 -109
View File
@@ -1,8 +1,11 @@
package dispenser
import (
"context"
"encoding/binary"
"errors"
"fmt"
"io"
"strings"
"time"
@@ -27,14 +30,25 @@ const (
CardWellEmptyMessage = "Card well is empty"
)
const (
positionPreDispense = 0x01
positionEncoder = 0x02
positionMouth = 0x04
positionEmpty = 0x08
)
var (
ErrCardWellEmpty = errors.New(CardWellEmptyMessage)
// ErrPreparationExhausted permits a new, independent UI preparation attempt.
ErrPreparationExhausted = errors.New("card preparation exhausted")
SerialPort string
Address []byte
commandFC7 = []byte{ETX, 0x46, 0x43, 0x37} // "FC7"
commandFC0 = []byte{ETX, 0x46, 0x43, 0x30} // "FC0"
commandRS = []byte{0x02, 0x52, 0x53} // Length 2, "RS"
statusPos0 = map[byte]string{
0x38: "Keep",
@@ -58,20 +72,21 @@ var (
0x31: "Card pre-empty",
0x30: "Normal",
}
statusPos3 = map[byte]string{
0x38: "Card empty",
0x34: "Card ready position",
0x33: "Card at encoder position",
0x32: "Card at hold card position",
0x31: "Card out of card mouth position",
0x30: "Normal",
}
)
// --------------------
// Status helpers
// --------------------
// decodePositionStatus decodes the manual's 0x30 + combined sensor/empty flags.
// Sensor 2 (0x02) is the read position; sensor 1 and sensor 2 together give 0x33.
func decodePositionStatus(value byte) (flags byte, valid bool) {
if value&0xF0 != 0x30 {
return 0, false
}
return value & 0x0F, true
}
func statusDescription(statusBytes []byte) string {
if len(statusBytes) < 4 {
return fmt.Sprintf("<invalid len=%d>", len(statusBytes))
@@ -85,7 +100,6 @@ func statusDescription(statusBytes []byte) string {
{pos: 1, value: statusBytes[0], mapper: statusPos0},
{pos: 2, value: statusBytes[1], mapper: statusPos1},
{pos: 3, value: statusBytes[2], mapper: statusPos2},
{pos: 4, value: statusBytes[3], mapper: statusPos3},
}
var result strings.Builder
@@ -98,6 +112,24 @@ func statusDescription(statusBytes []byte) string {
result.WriteString(statusMsg + "; ")
}
}
flags, valid := decodePositionStatus(statusBytes[3])
if !valid {
fmt.Fprintf(&result, "Unknown status 0x%X at position 4; ", statusBytes[3])
} else {
for _, position := range []struct {
mask byte
text string
}{
{positionPreDispense, "Card at pre-dispense position"},
{positionEncoder, "Card at encoder position"},
{positionMouth, "Card at mouth position"},
{positionEmpty, "Card empty"},
} {
if flags&position.mask != 0 {
result.WriteString(position.text + "; ")
}
}
}
return result.String()
}
@@ -106,38 +138,42 @@ func logStatus(statusBytes []byte) {
}
func isAtEncoderPosition(statusBytes []byte) bool {
return len(statusBytes) >= 4 && statusBytes[3] == 0x33
if len(statusBytes) < 4 {
return false
}
flags, valid := decodePositionStatus(statusBytes[3])
return valid && flags&positionEncoder != 0
}
func validateDispenserStatusData(statusBytes []byte) error {
if len(statusBytes) != 4 {
return fmt.Errorf("malformed dispenser status: got %d bytes, want 4", len(statusBytes))
}
type preparationClass string
statusMaps := []map[byte]string{statusPos0, statusPos1, statusPos2, statusPos3}
for position, mapper := range statusMaps {
if _, ok := mapper[statusBytes[position]]; !ok {
return fmt.Errorf("unknown dispenser status 0x%X at position %d", statusBytes[position], position+1)
}
}
return nil
}
const (
encoderConfirmed preparationClass = "encoder confirmed"
positionUncertain preparationClass = "valid but uncertain"
positionWellEmpty preparationClass = "empty"
positionNoCard preparationClass = "no card on sensors"
)
func dispenserStatusError(statusBytes []byte) error {
switch statusBytes[0] {
case 0x34, 0x32, 0x36:
return fmt.Errorf("dispenser error: %s", statusPos0[statusBytes[0]])
// classifyPreparationStatus is the only readiness gate after AP wire validation.
// Diagnostics describe the device; they do not veto a physical position class.
func classifyPreparationStatus(status []byte) (preparationClass, error) {
if len(status) != 4 {
return "", fmt.Errorf("malformed dispenser status: got %d bytes, want 4", len(status))
}
switch statusBytes[1] {
case 0x32, 0x31:
return fmt.Errorf("dispenser error: %s", statusPos1[statusBytes[1]])
flags, valid := decodePositionStatus(status[3])
if !valid {
return "", fmt.Errorf("malformed dispenser position encoding: 0x%X", status[3])
}
switch statusBytes[2] {
case 0x34, 0x32:
return fmt.Errorf("dispenser error: %s", statusPos2[statusBytes[2]])
switch {
case flags&positionEncoder != 0:
return encoderConfirmed, nil
case status[3] == 0x38:
return positionWellEmpty, nil
case status[3] == 0x30:
return positionNoCard, nil
default:
return positionUncertain, nil
}
return nil
}
func isPreparationMoving(statusBytes []byte) bool {
@@ -145,11 +181,6 @@ func isPreparationMoving(statusBytes []byte) bool {
(statusBytes[0] == 0x31 || statusBytes[1] == 0x38)
}
func hasPreparationDiagnostics(statusBytes []byte) bool {
return len(statusBytes) == 4 &&
(statusBytes[0] != 0x30 || statusBytes[1] != 0x30 || statusBytes[2] != 0x30)
}
func stockTake(statusBytes []byte) string {
if len(statusBytes) < 4 {
return ""
@@ -161,14 +192,18 @@ func stockTake(statusBytes []byte) string {
if statusBytes[2] != 0x30 {
status = statusPos2[statusBytes[2]]
}
if statusBytes[3] == 0x38 {
status = statusPos3[statusBytes[3]]
if isCardWellEmpty(statusBytes) {
status = "Card empty"
}
return status
}
func isCardWellEmpty(statusBytes []byte) bool {
return len(statusBytes) >= 4 && statusBytes[3] == 0x38
if len(statusBytes) < 4 {
return false
}
flags, valid := decodePositionStatus(statusBytes[3])
return valid && flags&positionEmpty != 0
}
func checkACK(statusResp []byte) error {
@@ -207,20 +242,154 @@ func createPacket(address []byte, command []byte) []byte {
func buildCheckAP(address []byte) []byte { return createPacket(address, []byte{STX, 0x41, 0x50}) }
func sendAndReceive(port *serial.Port, packet []byte, delay time.Duration) ([]byte, error) {
_, err := port.Write(packet)
if err != nil {
return nil, fmt.Errorf("error writing to port: %w", err)
}
// serialTransport is used only by the serial-port owner.
type serialTransport interface {
io.Reader
io.Writer
}
time.Sleep(delay)
func writePacket(ctx context.Context, port serialTransport, packet []byte) error {
_, err := writePacketAttempt(ctx, port, packet)
return err
}
buf := make([]byte, 128)
n, err := port.Read(buf)
if err != nil {
return nil, fmt.Errorf("error reading from port: %w", err)
// writePacketAttempt distinguishes cancellation before Write from an ambiguous write.
func writePacketAttempt(ctx context.Context, port serialTransport, packet []byte) (bool, error) {
if err := ctx.Err(); err != nil {
return false, err
}
return buf[:n], nil
n, err := port.Write(packet)
if err != nil {
return true, fmt.Errorf("write dispenser packet: %w", err)
}
if n != len(packet) {
return true, fmt.Errorf("write dispenser packet (%d/%d bytes): %w", n, len(packet), io.ErrShortWrite)
}
return true, ctx.Err()
}
func readExact(ctx context.Context, port serialTransport, data []byte) error {
for len(data) > 0 {
if err := ctx.Err(); err != nil {
return err
}
n, err := port.Read(data)
data = data[n:]
if ctxErr := ctx.Err(); ctxErr != nil {
return ctxErr
}
if err != nil {
return fmt.Errorf("read dispenser response: %w", err)
}
if n == 0 {
return fmt.Errorf("read dispenser response: %w", io.ErrNoProgress)
}
}
return nil
}
func sendAndReadACK(ctx context.Context, port serialTransport, packet []byte, processingDelay time.Duration) error {
if err := writePacket(ctx, port, packet); err != nil {
return err
}
if err := waitForSequence(ctx, processingDelay); err != nil {
return err
}
return readACK(ctx, port)
}
// readACK scans sequentially without reading beyond a complete candidate.
// Wrong-address candidates are consumed in full; no bytes persist across calls.
func readACK(ctx context.Context, port serialTransport) (err error) {
const scanLimit = 64
seen := make([]byte, 0, scanLimit)
defer func() {
if err != nil {
log.Warnf("dispenser ACK acquisition failed: address=% X seen=% X error=%v", Address, seen, err)
}
}()
var candidate [3]byte
used := 0
for len(seen) < scanLimit {
if err := ctx.Err(); err != nil {
return err
}
need := 1
if used > 0 {
need = len(candidate) - used
}
need = min(need, scanLimit-len(seen))
chunk := candidate[used : used+need]
n, readErr := port.Read(chunk)
seen = append(seen, chunk[:n]...)
log.Debugf("dispenser ACK RX: address=% X n=%d bytes=% X error=%v", Address, n, chunk[:n], readErr)
if err := ctx.Err(); err != nil {
return err
}
used += n
if used == 1 && candidate[0] != ACK && candidate[0] != NAK {
log.Debugf("dispenser ACK ignored leading byte: % X", candidate[:1])
used = 0
} else if used == len(candidate) {
if len(Address) >= 2 && candidate[1] == Address[0] && candidate[2] == Address[1] {
log.Debugf("dispenser ACK/NAK accepted: address=% X token=% X", Address, candidate[:])
if candidate[0] == ACK && len(seen) > len(candidate) {
log.Warnf("dispenser ACK resynchronized: address=% X ignored=% X accepted=% X", Address, seen[:len(seen)-len(candidate)], candidate[:])
}
return checkACK(candidate[:])
}
log.Debugf("dispenser ACK ignored wrong-address candidate: address=% X candidate=% X", Address, candidate[:])
used = 0
}
if readErr != nil {
return fmt.Errorf("read ACK: %w", readErr)
}
if n == 0 {
return fmt.Errorf("read ACK: %w", io.ErrNoProgress)
}
}
return fmt.Errorf("read ACK: scan limit of %d bytes exhausted", scanLimit)
}
// queryStatus accepts only the fixed RF/AP payload sizes, before reading a body.
func queryStatus(ctx context.Context, port serialTransport, command []byte, statusCount int, processingDelay time.Duration) ([]byte, error) {
if err := sendAndReadACK(ctx, port, createPacket(Address, command), processingDelay); err != nil {
return nil, err
}
if err := writePacket(ctx, port, append([]byte{ENQ}, Address...)); err != nil {
return nil, err
}
if err := waitForSequence(ctx, processingDelay); err != nil {
return nil, err
}
header := make([]byte, 5)
if err := readExact(ctx, port, header); err != nil {
return nil, fmt.Errorf("read status header: %w", err)
}
if header[0] != STX {
return nil, fmt.Errorf("invalid status STX: % X", header)
}
if len(Address) != 2 || header[1] != Address[0] || header[2] != Address[1] {
return nil, fmt.Errorf("unexpected status address: % X", header[1:3])
}
length := int(binary.BigEndian.Uint16(header[3:5]))
if length != statusCount+2 {
return nil, fmt.Errorf("invalid status payload length: got %d, want %d", length, statusCount+2)
}
frame := append(header, make([]byte, length+2)...)
if err := readExact(ctx, port, frame[5:]); err != nil {
return nil, fmt.Errorf("read status body: %w", err)
}
if frame[len(frame)-2] != ETX {
return nil, fmt.Errorf("invalid status ETX: % X", frame)
}
if calculateBCC(frame[:len(frame)-1]) != frame[len(frame)-1] {
return nil, fmt.Errorf("invalid status BCC: % X", frame)
}
if frame[5] != 'S' || frame[6] != 'F' {
return nil, fmt.Errorf("unexpected status response type: % X", frame[5:7])
}
return frame[7 : 7+statusCount], nil
}
// --------------------
@@ -270,69 +439,31 @@ func InitializeDispenser() (*serial.Port, error) {
// --------------------
// checkDispenserStatus talks to the device and returns the 4 status bytes [pos0..pos3].
func checkDispenserStatus(port *serial.Port) ([]byte, error) {
checkCmd := buildCheckAP(Address)
enq := append([]byte{ENQ}, Address...)
statusResp, err := sendAndReceive(port, checkCmd, delay)
if err != nil {
return nil, fmt.Errorf("error sending check command: %w", err)
}
if len(statusResp) == 0 {
return nil, fmt.Errorf("no response from dispenser")
}
if err := checkACK(statusResp); err != nil {
return nil, err
}
statusResp, err = sendAndReceive(port, enq, delay)
if err != nil {
return nil, fmt.Errorf("error sending ENQ: %w", err)
}
if len(statusResp) < 13 {
return nil, fmt.Errorf("incomplete status response from dispenser: % X", statusResp)
}
return statusResp[7:11], nil
func checkDispenserStatus(ctx context.Context, port serialTransport) ([]byte, error) {
return queryStatus(ctx, port, []byte{0x02, 'A', 'P'}, 4, delay)
}
func cardToEncoderPosition(port *serial.Port) error {
enq := append([]byte{ENQ}, Address...)
// dispatchCommand confirms ACK and sends ENQ; it does not wait for movement.
func dispatchCommand(ctx context.Context, port serialTransport, command []byte, processingDelay time.Duration) error {
if err := sendAndReadACK(ctx, port, createPacket(Address, command), processingDelay); err != nil {
return err
}
return writePacket(ctx, port, append([]byte{ENQ}, Address...))
}
dispenseCmd := createPacket(Address, commandFC7)
func cardToEncoderPosition(ctx context.Context, port serialTransport) error {
log.Println("Send card to encoder position")
statusResp, err := sendAndReceive(port, dispenseCmd, delay)
if err != nil {
return fmt.Errorf("error sending card to encoder position: %w", err)
}
if err := checkACK(statusResp); err != nil {
return err
}
_, err = port.Write(enq)
if err != nil {
return fmt.Errorf("error sending ENQ to prompt device: %w", err)
}
return nil
return dispatchCommand(ctx, port, commandFC7, delay)
}
func cardOutOfMouth(port *serial.Port) error {
enq := append([]byte{ENQ}, Address...)
func resetDispenser(ctx context.Context, port serialTransport) error {
return dispatchCommand(ctx, port, commandRS, delay)
}
dispenseCmd := createPacket(Address, commandFC0)
func cardOutOfMouth(ctx context.Context, port serialTransport) (bool, error) {
log.Println("Send card to out mouth position")
statusResp, err := sendAndReceive(port, dispenseCmd, delay)
if err != nil {
return fmt.Errorf("error sending out of mouth command: %w", err)
if err := sendAndReadACK(ctx, port, createPacket(Address, commandFC0), delay); err != nil {
return false, err
}
if err := checkACK(statusResp); err != nil {
return err
}
_, err = port.Write(enq)
if err != nil {
return fmt.Errorf("error sending ENQ to prompt device: %w", err)
}
return nil
return writePacketAttempt(ctx, port, append([]byte{ENQ}, Address...))
}
+518 -140
View File
@@ -3,6 +3,7 @@ package dispenser
import (
"context"
"errors"
"fmt"
"sync"
"time"
@@ -17,17 +18,22 @@ const (
cmdStatus cmdType = iota
cmdToEncoder
cmdOutOfMouth
cmdReset
cmdDeliveryClearance
)
type cmdReq struct {
typ cmdType
ctx context.Context
respCh chan cmdResp
passive bool
generation uint64
typ cmdType
ctx context.Context
respCh chan cmdResp
}
type cmdResp struct {
status []byte
err error
deliveryPending bool
status []byte
err error
}
type sequenceTiming struct {
@@ -36,17 +42,29 @@ type sequenceTiming struct {
}
const (
sequencePollInterval = time.Second
sequenceRetryAfter = 6 * time.Second
sequenceTimeout = 12 * time.Second
sequencePollInterval = time.Second
sequenceShakeAfter = 3 * time.Second
sequenceResetWait = 2 * time.Second
sequenceTimeout = 32 * time.Second
sequenceUncertainWait = 4 * time.Second
sequenceMaxShakes = 3
deliveryClearanceTimeout = 6 * time.Second
deliveryMinimumWait = 2 * time.Second
)
type Client struct {
port *serial.Port
activity activityGuard
activityWake chan struct{}
closeOnce sync.Once
port serialTransport
reqCh chan cmdReq
done chan struct{}
// Owned exclusively by the serial worker.
deliveryPending bool
deliveryStarted time.Time
sequenceTiming sequenceTiming
// status cache
@@ -67,9 +85,10 @@ func NewClient(port *serial.Port, queueSize int) *Client {
queueSize = 16
}
c := &Client{
port: port,
reqCh: make(chan cmdReq, queueSize),
done: make(chan struct{}),
activityWake: make(chan struct{}, 1),
port: port,
reqCh: make(chan cmdReq, queueSize),
done: make(chan struct{}),
sequenceTiming: sequenceTiming{
now: time.Now,
wait: waitForSequence,
@@ -93,12 +112,13 @@ func waitForSequence(ctx context.Context, duration time.Duration) error {
}
func (c *Client) Close() {
select {
case <-c.done:
return
default:
c.closeOnce.Do(func() {
c.activity.Lock()
c.activity.closed = true
c.activity.Unlock()
c.StopMaintenance()
close(c.done)
}
})
}
// SetStatusTTL sets the duration for which cached status is considered fresh.
@@ -137,7 +157,7 @@ func (c *Client) setStock(statusBytes []byte) {
}
// StartPolling performs a periodic status refresh.
// It will NOT interrupt commands: it enqueues only when queue is idle.
// Passive requests are admitted by the worker only for the captured idle generation.
func (c *Client) StartPolling(interval time.Duration) {
if interval <= 0 {
return
@@ -155,8 +175,13 @@ func (c *Client) StartPolling(interval time.Duration) {
if len(c.reqCh) != 0 {
continue
}
generation, idle := c.passiveGeneration()
if !idle {
continue
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
_, err := c.CheckStatus(ctx)
response := c.sendRequest(cmdReq{typ: cmdStatus, ctx: ctx, passive: true, generation: generation})
err := response.err
if err != nil {
log.Debugf("dispenser polling: %v", err)
}
@@ -167,12 +192,28 @@ func (c *Client) StartPolling(interval time.Duration) {
}
func (c *Client) loop() {
timer := time.NewTimer(time.Hour)
defer timer.Stop()
for {
if !timer.Stop() {
select {
case <-timer.C:
default:
}
}
var tick <-chan time.Time
if delay, enabled := c.maintenanceDelay(); enabled {
timer.Reset(delay)
tick = timer.C
}
select {
case <-c.done:
return
case <-c.activityWake:
case req := <-c.reqCh:
c.handle(req)
case <-tick:
c.maintainIdleCard()
}
}
}
@@ -185,26 +226,58 @@ func (c *Client) handle(req cmdReq) {
default:
}
if req.passive {
if !c.admitPassive(req.ctx, req.generation) {
req.respCh <- cmdResp{}
return
}
c.mu.RLock()
st := append([]byte(nil), c.lastStatus...)
fresh := len(st) == 4 && time.Since(c.lastStatusT) <= c.statusTTL
c.mu.RUnlock()
if fresh {
c.setStock(st)
req.respCh <- cmdResp{status: st}
return
}
}
switch req.typ {
case cmdStatus:
st, err := checkDispenserStatus(c.port)
if err == nil && len(st) == 4 {
c.mu.Lock()
c.lastStatus = append([]byte(nil), st...)
c.lastStatusT = time.Now()
c.mu.Unlock()
st, err := c.readWorkerStatus(req.ctx)
req.respCh <- cmdResp{status: st, err: err, deliveryPending: c.deliveryPending}
// publish stock/cardwell
c.setStock(st)
}
req.respCh <- cmdResp{status: st, err: err}
case cmdDeliveryClearance:
st, err := c.waitWorkerDeliveryClearance(req.ctx)
req.respCh <- cmdResp{status: st, err: err, deliveryPending: c.deliveryPending}
case cmdToEncoder:
err := cardToEncoderPosition(c.port)
if c.deliveryPending {
if _, err := c.waitWorkerDeliveryClearance(req.ctx); err != nil {
req.respCh <- cmdResp{err: err}
return
}
}
err := cardToEncoderPosition(req.ctx, c.port)
log.Infof("FC7 dispatch finished; dispatched=%t error=%v", err == nil, err)
c.invalidateStatusCache()
req.respCh <- cmdResp{err: err}
case cmdReset:
err := resetDispenser(req.ctx, c.port)
log.Infof("RS dispatch finished; dispatched=%t error=%v", err == nil, err)
c.invalidateStatusCache()
req.respCh <- cmdResp{err: err}
case cmdOutOfMouth:
err := cardOutOfMouth(c.port)
attempted, err := cardOutOfMouth(req.ctx, c.port)
log.Infof("FC0 dispatch finished; ENQ_attempted=%t error=%v", attempted, err)
if attempted {
c.deliveryPending = true
c.deliveryStarted = c.now()
log.Info("delivery ENQ attempted; awaiting mechanical clearance")
}
// A movement command makes any previously cached position unreliable.
c.invalidateStatusCache()
req.respCh <- cmdResp{err: err}
default:
@@ -212,21 +285,91 @@ func (c *Client) handle(req cmdReq) {
}
}
func (c *Client) do(ctx context.Context, typ cmdType) ([]byte, error) {
rch := make(chan cmdResp, 1)
req := cmdReq{typ: typ, ctx: ctx, respCh: rch}
// deliveryClearance deliberately does not apply encoder-success precedence.
func deliveryClearance(status []byte) (bool, error) {
class, err := classifyPreparationStatus(status)
if err != nil {
return false, err
}
if class == positionWellEmpty {
return false, ErrCardWellEmpty
}
if isPreparationMoving(status) || status[1] == 0x34 {
return false, nil
}
return status[3] == 0x30 || status[3] == 0x34, nil
}
func (c *Client) now() time.Time {
if c.sequenceTiming.now != nil {
return c.sequenceTiming.now()
}
return time.Now()
}
// readWorkerStatus is called only by the serial worker and always reads fresh AP.
func (c *Client) readWorkerStatus(ctx context.Context) ([]byte, error) {
st, err := checkDispenserStatus(ctx, c.port)
if err != nil {
return st, err
}
if err := ctx.Err(); err != nil {
return st, err
}
if c.deliveryPending {
class, _ := classifyPreparationStatus(st)
log.Infof("delivery clearance AP; class=%s elapsed=%s raw status: % X", class, c.now().Sub(c.deliveryStarted), st)
clear, clearanceErr := deliveryClearance(st)
if clearanceErr != nil {
log.Warnf("delivery clearance failed: %v; %s raw status: % X", clearanceErr, statusDescription(st), st)
} else if clear && c.now().Sub(c.deliveryStarted) >= deliveryMinimumWait {
c.deliveryPending = false
log.Infof("previous delivery cleared after %s; FC7 permitted", c.now().Sub(c.deliveryStarted))
}
}
if len(st) == 4 {
c.mu.Lock()
c.lastStatus = append([]byte(nil), st...)
c.lastStatusT = time.Now()
c.mu.Unlock()
c.setStock(st)
}
return st, nil
}
func (c *Client) do(ctx context.Context, typ cmdType) ([]byte, error) {
r := c.doResponse(ctx, typ)
return r.status, r.err
}
func (c *Client) doResponse(ctx context.Context, typ cmdType) cmdResp {
return c.sendRequest(cmdReq{typ: typ, ctx: ctx})
}
func (c *Client) sendRequest(req cmdReq) cmdResp {
if err := req.ctx.Err(); err != nil {
return cmdResp{err: err}
}
req.respCh = make(chan cmdResp, 1)
select {
case <-c.done:
return cmdResp{err: context.Canceled}
default:
}
select {
case c.reqCh <- req:
case <-ctx.Done():
return nil, ctx.Err()
case <-c.done:
return cmdResp{err: context.Canceled}
case <-req.ctx.Done():
return cmdResp{err: req.ctx.Err()}
}
select {
case r := <-rch:
return r.status, r.err
case <-ctx.Done():
return nil, ctx.Err()
case r := <-req.respCh:
return r
case <-c.done:
return cmdResp{err: context.Canceled}
case <-req.ctx.Done():
return cmdResp{err: req.ctx.Err()}
}
}
@@ -246,11 +389,24 @@ func (c *Client) CheckStatus(ctx context.Context) ([]byte, error) {
return c.do(ctx, cmdStatus)
}
func (c *Client) invalidateStatusCache() {
c.mu.Lock()
c.lastStatus = nil
c.lastStatusT = time.Time{}
c.mu.Unlock()
}
func (c *Client) ToEncoder(ctx context.Context) error {
_, err := c.do(ctx, cmdToEncoder)
return err
}
// Reset dispatches RS through the port owner; acceptance does not imply mechanical completion.
func (c *Client) Reset(ctx context.Context) error {
_, err := c.do(ctx, cmdReset)
return err
}
func (c *Client) OutOfMouth(ctx context.Context) error {
_, err := c.do(ctx, cmdOutOfMouth)
return err
@@ -298,13 +454,14 @@ func (c *Client) DispenserPrepare(ctx context.Context) (string, error) {
}
func (c *Client) readSequenceStatus(ctx context.Context, operation string) ([]byte, string, error) {
status, err := c.do(ctx, cmdStatus)
if err != nil {
if ctxErr := ctx.Err(); ctxErr != nil {
return nil, "", fmt.Errorf("[%s] read status: %w", operation, ctxErr)
}
return nil, "", fmt.Errorf("[%s] read status: %w", operation, err)
response := c.doResponse(ctx, cmdStatus)
if err := ctx.Err(); err != nil {
return nil, "", err
}
if response.deliveryPending {
return c.waitForDeliveryClearance(ctx, operation)
}
status := usableObservation(response.status, response.err, operation)
stockStatus := ""
if len(status) == 4 {
@@ -315,115 +472,335 @@ func (c *Client) readSequenceStatus(ctx context.Context, operation string) ([]by
return status, stockStatus, nil
}
func preparationStatus(operation string, status []byte) (bool, error) {
if len(status) != 4 {
return false, fmt.Errorf("[%s] %w", operation, validateDispenserStatusData(status))
}
if isAtEncoderPosition(status) {
if hasPreparationDiagnostics(status) {
log.Warnf(
"[%s] card confirmed at encoder with dispenser diagnostics: %s raw status: % X",
operation,
statusDescription(status),
status,
)
}
return true, nil
}
if err := validateDispenserStatusData(status); err != nil {
return false, fmt.Errorf("[%s] %w", operation, err)
}
if isCardWellEmpty(status) {
return false, fmt.Errorf("[%s] %w", operation, ErrCardWellEmpty)
}
if isPreparationMoving(status) {
return false, nil
}
if err := dispenserStatusError(status); err != nil {
return false, fmt.Errorf("[%s] %w", operation, err)
}
return false, nil
}
func (c *Client) pollForEncoderPosition(
ctx context.Context,
operation string,
retryCommand func(context.Context) error,
) (string, error) {
started := c.sequenceTiming.now()
halfway := started.Add(sequenceRetryAfter)
deadline := started.Add(sequenceTimeout)
retried := false
stockStatus := ""
// waitWorkerDeliveryClearance runs only inside the serial worker.
// An unusable observation never becomes a fabricated physical position.
func (c *Client) waitWorkerDeliveryClearance(parent context.Context) ([]byte, error) {
ctx, cancel := context.WithTimeout(parent, deliveryClearanceTimeout)
defer cancel()
deadline := c.now().Add(deliveryClearanceTimeout)
var latest []byte
for {
if err := ctx.Err(); err != nil {
return stockStatus, fmt.Errorf("[%s] %w", operation, err)
if err := parent.Err(); err != nil {
return nil, err
}
now := c.sequenceTiming.now()
if !now.Before(deadline) {
return stockStatus, fmt.Errorf("[%s] timed out after %s", operation, sequenceTimeout)
}
status, currentStockStatus, err := c.readSequenceStatus(ctx, operation)
stockStatus = currentStockStatus
if err != nil {
return stockStatus, err
}
ready, err := preparationStatus(operation, status)
if err != nil {
return stockStatus, err
}
if ready {
return stockStatus, nil
}
now = c.sequenceTiming.now()
if !now.Before(deadline) {
return stockStatus, fmt.Errorf("[%s] timed out after %s", operation, sequenceTimeout)
}
if retryCommand != nil && !retried && !now.Before(halfway) {
if err := retryCommand(ctx); err != nil {
return stockStatus, fmt.Errorf("[%s] retry command: %w", operation, err)
if !c.now().Before(deadline) || ctx.Err() != nil {
class, err := classifyPreparationStatus(latest)
if err == nil && class == positionWellEmpty {
return latest, ErrCardWellEmpty
}
retried = true
if err == nil && (isPreparationMoving(latest) || latest[1] == 0x34) {
return latest, context.DeadlineExceeded
}
c.deliveryPending = false
log.Warn("delivery clearance assumed after bounded observation fallback")
return latest, nil
}
st, err := c.readWorkerStatus(ctx)
if parent.Err() != nil {
return nil, parent.Err()
}
latest = usableObservation(st, err, "delivery clearance")
if latest != nil && latest[3] == 0x38 {
return latest, ErrCardWellEmpty
}
if !c.deliveryPending {
return latest, nil
}
remaining := deadline.Sub(c.now())
if remaining <= 0 || ctx.Err() != nil {
continue
}
wait := sequencePollInterval
if remaining := deadline.Sub(now); remaining < wait {
if remaining < wait {
wait = remaining
}
if err := c.sequenceTiming.wait(ctx, wait); err != nil {
return stockStatus, fmt.Errorf("[%s] %w", operation, err)
if err := c.sequenceTiming.wait(ctx, wait); err != nil && parent.Err() != nil {
return nil, parent.Err()
}
}
}
// usableObservation preserves strict validation while discarding unusable telemetry.
func usableObservation(status []byte, err error, operation string) []byte {
if err == nil {
_, err = classifyPreparationStatus(status)
}
if err != nil {
log.Warnf("[%s] unusable AP observation; raw status: % X error=%v", operation, status, err)
return nil
}
return status
}
// waitForDeliveryClearance uses a worker request; no worker recursively enqueues.
func (c *Client) waitForDeliveryClearance(ctx context.Context, operation string) ([]byte, string, error) {
r := c.doResponse(ctx, cmdDeliveryClearance)
stock := ""
if len(r.status) == 4 {
stock = stockTake(r.status)
}
if r.err != nil {
return nil, stock, fmt.Errorf("[%s] delivery clearance: %w", operation, r.err)
}
return r.status, stock, nil
}
// PreparationResult carries this issuance attempt's handoff and recovery budget.
type PreparationResult struct {
Stock string
UncertainHandoff bool
ShakesUsed int
lastFC7 time.Time
}
func (c *Client) prepareCardAtEncoder(ctx context.Context, operation string) (string, error) {
status, stockStatus, err := c.readSequenceStatus(ctx, operation)
if err != nil {
return stockStatus, err
}
ready, err := preparationStatus(operation, status)
if err != nil {
return stockStatus, err
}
if ready {
return stockStatus, nil
}
if err := c.ToEncoder(ctx); err != nil {
return stockStatus, fmt.Errorf("[%s] to encoder: %w", operation, err)
}
return c.pollForEncoderPosition(ctx, operation, c.ToEncoder)
preparation, err := c.prepareCardForEncoding(ctx, operation)
return preparation.Stock, err
}
// PrepareCurrentCard authoritatively places the card to be encoded at the encoder.
func (c *Client) prepareCardForEncoding(parent context.Context, operation string) (preparation PreparationResult, resultErr error) {
status, stock, err := c.waitForDeliveryClearance(parent, operation)
preparation.Stock = stock
if err != nil {
return preparation, err
}
status = usableObservation(status, nil, operation)
started := c.now()
deadline := started.Add(sequenceTimeout)
ctx, cancel := context.WithTimeoutCause(parent, sequenceTimeout, ErrPreparationExhausted)
defer cancel()
shakes := 0
stage := "initial status"
var lastFC7, uncertainSince time.Time
var previous preparationClass
defer func() {
preparation.Stock = stock
preparation.ShakesUsed = shakes
preparation.lastFC7 = lastFC7
if resultErr == nil && !lastFC7.IsZero() {
class, _ := classifyPreparationStatus(status)
preparation.UncertainHandoff = class != encoderConfirmed
}
log.Infof("[%s] preparation finished; stage=%s shakes=%d elapsed=%s raw status: % X error=%v", operation, stage, shakes, c.now().Sub(started), status, resultErr)
}()
checkDeadline := func() error {
if err := parent.Err(); err != nil {
return err
}
if !c.now().Before(deadline) || errors.Is(context.Cause(ctx), ErrPreparationExhausted) {
return ErrPreparationExhausted
}
return ctx.Err()
}
// Only observation exhaustion can grant a deadline handoff. Command and
// reset-settle failures never pass through this policy.
observationResult := func(err error) error {
if parent.Err() != nil {
return parent.Err()
}
if !errors.Is(err, ErrPreparationExhausted) || lastFC7.IsZero() {
return err
}
class, _ := classifyPreparationStatus(status)
switch class {
case positionWellEmpty:
return ErrCardWellEmpty
case positionNoCard:
return err
default:
stage = "observation deadline encoder handoff"
return nil
}
}
wait := func(duration time.Duration) error {
if err := checkDeadline(); err != nil {
return err
}
if remaining := deadline.Sub(c.now()); remaining < duration {
duration = remaining
}
if err := c.sequenceTiming.wait(ctx, duration); err != nil {
if deadlineErr := checkDeadline(); deadlineErr != nil {
return deadlineErr
}
return err
}
return checkDeadline()
}
sendFC7 := func() error {
stage = "FC7 dispatch"
if err := checkDeadline(); err != nil {
return err
}
err := c.ToEncoder(ctx)
if deadlineErr := checkDeadline(); deadlineErr != nil {
return deadlineErr
}
if err != nil {
return fmt.Errorf("[%s] FC7 dispatch: %w", operation, err)
}
lastFC7 = c.now()
log.Infof("[%s] FC7 dispatched; shake=%d elapsed=%s", operation, shakes, lastFC7.Sub(started))
return nil
}
for {
if err := checkDeadline(); err != nil {
return preparation, observationResult(err)
}
class, _ := classifyPreparationStatus(status)
// No class means unusable telemetry, sharing the uncertainty timer.
log.Infof("[%s] fresh AP; class=%s previous=%s elapsed=%s shake=%d raw status: % X", operation, class, previous, c.now().Sub(started), shakes, status)
previous = class
switch class {
case encoderConfirmed:
stage = "encoder sensor handoff"
return preparation, observationResult(checkDeadline())
case positionWellEmpty:
stage = "empty"
return preparation, ErrCardWellEmpty
}
if lastFC7.IsZero() {
if err := sendFC7(); err != nil {
return preparation, err
}
} else if class == positionNoCard && c.now().Sub(lastFC7) >= sequenceShakeAfter {
uncertainSince = time.Time{}
if shakes == sequenceMaxShakes {
stage = "three shakes exhausted"
return preparation, ErrPreparationExhausted
}
shakes++
stage = "RS dispatch"
if err := checkDeadline(); err != nil {
return preparation, err
}
err := c.Reset(ctx)
if deadlineErr := checkDeadline(); deadlineErr != nil {
return preparation, deadlineErr
}
if err != nil {
return preparation, fmt.Errorf("[%s] RS dispatch: %w", operation, err)
}
stage = "reset settling"
log.Infof("[%s] RS dispatched; shake=%d settling=%s", operation, shakes, sequenceResetWait)
if err := wait(sequenceResetWait); err != nil {
return preparation, err
}
log.Infof("[%s] reset settle wait completed; shake=%d", operation, shakes)
if err := sendFC7(); err != nil {
return preparation, err
}
} else {
if class == positionUncertain || class == "" {
if uncertainSince.IsZero() {
uncertainSince = c.now()
}
if c.now().Sub(uncertainSince) >= sequenceUncertainWait {
stage = "uncertain position handoff"
return preparation, observationResult(checkDeadline())
}
} else {
uncertainSince = time.Time{}
}
stage = "polling"
if err := wait(sequencePollInterval); err != nil {
return preparation, observationResult(err)
}
}
stage = "fresh AP"
if err := checkDeadline(); err != nil {
return preparation, observationResult(err)
}
status, stock, err = c.readSequenceStatus(ctx, operation)
if deadlineErr := checkDeadline(); deadlineErr != nil {
return preparation, observationResult(deadlineErr)
}
if err != nil {
return preparation, err
}
}
}
// PrepareCurrentCard grants one encoder opportunity after bounded physical preparation.
func (c *Client) PrepareCurrentCard(ctx context.Context) (string, error) {
return c.prepareCardAtEncoder(ctx, "PrepareCurrentCard")
}
// PrepareCurrentCardForEncoding preserves preparation while exposing uncertain handoff.
func (c *Client) PrepareCurrentCardForEncoding(ctx context.Context) (PreparationResult, error) {
return c.prepareCardForEncoding(ctx, "PrepareCurrentCard")
}
// RecoverCurrentCard spends only the remaining issuance budget during encoding.
// It must be cancelled and joined before delivery; all commands use the serial worker.
func (c *Client) RecoverCurrentCard(ctx context.Context, preparation PreparationResult) (resultErr error) {
if !preparation.UncertainHandoff {
return nil
}
const operation = "uncertain encoding recovery"
started := c.now()
shakes, lastFC7 := preparation.ShakesUsed, preparation.lastFC7
reason := "recovery error"
defer func() {
if ctx.Err() != nil {
reason = context.Cause(ctx).Error()
}
log.Infof("[%s] stopped; reason=%s shakes=%d remaining=%d elapsed=%s error=%v", operation, reason, shakes, sequenceMaxShakes-shakes, c.now().Sub(started), resultErr)
}()
log.Infof("[%s] started; shakes=%d remaining=%d", operation, shakes, sequenceMaxShakes-shakes)
observe := func() (bool, error) {
status, _, err := c.readSequenceStatus(ctx, operation)
if err != nil {
return true, err
}
class, _ := classifyPreparationStatus(status)
log.Infof("[%s] fresh AP; class=%s shakes=%d remaining=%d raw status: % X", operation, class, shakes, sequenceMaxShakes-shakes, status)
switch class {
case encoderConfirmed:
reason = "encoder confirmed"
return true, nil
case positionWellEmpty:
reason = "card well empty"
return true, ErrCardWellEmpty
default:
return false, nil
}
}
for {
if stopped, err := observe(); stopped {
return err
}
if shakes >= sequenceMaxShakes {
reason = "shake budget exhausted"
return nil
}
if remaining := sequenceShakeAfter - c.now().Sub(lastFC7); remaining > 0 {
if err := c.sequenceTiming.wait(ctx, min(sequencePollInterval, remaining)); err != nil {
return err
}
continue
}
shakes++
log.Infof("[%s] RS attempt; shake=%d remaining=%d", operation, shakes, sequenceMaxShakes-shakes)
if err := c.Reset(ctx); err != nil {
return fmt.Errorf("[%s] RS dispatch: %w", operation, err)
}
if err := c.sequenceTiming.wait(ctx, sequenceResetWait); err != nil {
return err
}
// A diagnostic AP cannot turn unusable telemetry into a fatal error.
if stopped, err := observe(); stopped {
return err
}
log.Infof("[%s] FC7 attempt; shake=%d remaining=%d", operation, shakes, sequenceMaxShakes-shakes)
if err := c.ToEncoder(ctx); err != nil {
return fmt.Errorf("[%s] FC7 dispatch: %w", operation, err)
}
lastFC7 = c.now()
}
}
// DeliverCurrentCard presents the encoded card and confirms command acceptance.
func (c *Client) DeliverCurrentCard(ctx context.Context) (string, error) {
const operation = "DeliverCurrentCard"
@@ -434,7 +811,8 @@ func (c *Client) DeliverCurrentCard(ctx context.Context) (string, error) {
return "", nil
}
// BeginPrepareNextCard starts moving the next card to the encoder without waiting for readiness.
// BeginPrepareNextCard waits for worker-owned clearance and dispatches one FC7.
// It does not wait for encoder readiness.
func (c *Client) BeginPrepareNextCard(ctx context.Context) error {
if err := c.ToEncoder(ctx); err != nil {
return fmt.Errorf("[BeginPrepareNextCard] to encoder: %w", err)
@@ -442,7 +820,7 @@ func (c *Client) BeginPrepareNextCard(ctx context.Context) error {
return nil
}
// PrepareNextCard places a new card at the encoder for a later issuance attempt.
// PrepareNextCard runs the same bounded physical preparation for a later issuance attempt.
func (c *Client) PrepareNextCard(ctx context.Context) (string, error) {
return c.prepareCardAtEncoder(ctx, "PrepareNextCard")
}
+426 -187
View File
@@ -4,17 +4,19 @@ import (
"bytes"
"context"
"errors"
"fmt"
"reflect"
"strings"
"testing"
"time"
log "github.com/sirupsen/logrus"
)
type fakeSequenceDevice struct {
statusResponses []cmdResp
commandErrors map[cmdType][]error
commands []cmdType
commandTimes []time.Time
onCommand func(cmdType)
}
func newSequenceTestClient(t *testing.T, statusResponses ...cmdResp) (*Client, *fakeSequenceDevice) {
@@ -50,13 +52,25 @@ func newSequenceTestClient(t *testing.T, statusResponses ...cmdResp) (*Client, *
case <-client.done:
return
case request := <-client.reqCh:
clearance := request.typ == cmdDeliveryClearance
if clearance {
request.typ = cmdStatus
}
device.commands = append(device.commands, request.typ)
device.commandTimes = append(device.commandTimes, now)
if device.onCommand != nil {
device.onCommand(request.typ)
}
if request.typ == cmdStatus {
if len(device.statusResponses) == 0 {
request.respCh <- cmdResp{err: errors.New("unexpected status read")}
continue
}
response := device.statusResponses[0]
if clearance && request.ctx.Err() == nil {
response.status = usableObservation(response.status, response.err, "fake clearance")
response.err = nil
}
device.statusResponses = device.statusResponses[1:]
request.respCh <- response
continue
@@ -90,142 +104,159 @@ func commandCount(commands []cmdType, target cmdType) int {
return count
}
func TestPrepareCurrentCardAcceptsEncoderPositionWithStaleDiagnostics(t *testing.T) {
tests := []struct {
name string
status []byte
wantStock string
}{
{
name: "dispense error and jam",
status: []byte{0x30, 0x32, 0x32, 0x33},
wantStock: "Card jammed",
},
{
name: "supply diagnostics",
status: []byte{0x32, 0x30, 0x31, 0x33},
wantStock: "Card pre-empty",
},
{
name: "combined stale jam and supply diagnostics",
status: []byte{0x30, 0x32, 0x33, 0x33},
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
var logOutput bytes.Buffer
standardLogger := log.StandardLogger()
previousOutput := standardLogger.Out
standardLogger.SetOutput(&logOutput)
t.Cleanup(func() {
standardLogger.SetOutput(previousOutput)
})
client, device := newSequenceTestClient(t, cmdResp{status: test.status})
stock, err := client.PrepareCurrentCard(context.Background())
if err != nil {
t.Fatal(err)
}
if stock != test.wantStock {
t.Fatalf("stock status = %q, want %q", stock, test.wantStock)
}
if got := commandCount(device.commands, cmdToEncoder); got != 0 {
t.Fatalf("to-encoder commands = %d, want 0", got)
}
if got := commandCount(device.commands, cmdStatus); got != 1 {
t.Fatalf("status reads = %d, want 1", got)
}
logged := logOutput.String()
if !strings.Contains(logged, "card confirmed at encoder") ||
!strings.Contains(logged, statusDescription(test.status)) ||
!strings.Contains(logged, "raw status") {
t.Fatalf("encoder diagnostic log = %q", logged)
}
})
func TestResetPacket(t *testing.T) {
got := createPacket([]byte{0x30, 0x30}, commandRS)
want := []byte{0x02, 0x30, 0x30, 0x00, 0x02, 0x52, 0x53, 0x03, 0x02}
if !bytes.Equal(got, want) {
t.Errorf("createPacket(RS) = % X, want % X", got, want)
}
}
func TestPrepareCurrentCardPollingAllowsTransientMovementWithStaleErrors(t *testing.T) {
client, device := newSequenceTestClient(t,
cmdResp{status: status(0x34)},
cmdResp{status: []byte{0x31, 0x38, 0x32, 0x30}},
cmdResp{status: []byte{0x30, 0x32, 0x32, 0x33}},
)
stock, err := client.PrepareCurrentCard(context.Background())
if err != nil {
func TestUncertainRecoveryContinuesPreparationBudget(t *testing.T) {
responses := append(positionResponses(0x30, 5), positionResponses(0x35, 5)...)
responses = append(responses, cmdResp{status: status(0x35)}, cmdResp{err: errors.New("unusable diagnostic AP")})
responses = append(responses, positionResponses(0x30, 4)...)
responses = append(responses, cmdResp{status: status(0x35)}, cmdResp{status: status(0x37)})
c, d := newSequenceTestClient(t, responses...)
preparation, err := c.PrepareCurrentCardForEncoding(context.Background())
if err != nil || !preparation.UncertainHandoff || preparation.ShakesUsed != 1 {
t.Fatalf("preparation=%+v error=%v, want uncertain handoff after one shake", preparation, err)
}
before := len(d.commands)
if err := c.RecoverCurrentCard(context.Background(), preparation); err != nil {
t.Fatal(err)
}
if stock != "Card jammed" {
t.Fatalf("stock status = %q, want Card jammed", stock)
want := []cmdType{cmdStatus, cmdReset, cmdStatus, cmdToEncoder, cmdStatus, cmdStatus, cmdStatus, cmdStatus, cmdReset, cmdStatus, cmdToEncoder, cmdStatus}
if !reflect.DeepEqual(d.commands[before:], want) {
t.Errorf("recovery commands=%v, want %v", d.commands[before:], want)
}
if got := commandCount(device.commands, cmdToEncoder); got != 1 {
t.Fatalf("to-encoder commands = %d, want 1", got)
if commandCount(d.commands, cmdReset) != 3 || commandCount(d.commands, cmdToEncoder) != 4 {
t.Errorf("whole issuance commands=%v, want three RS and four FC7", d.commands)
}
if got := commandCount(device.commands, cmdStatus); got != 3 {
t.Fatalf("status reads = %d, want 3", got)
for i := before; i < len(d.commands); i++ {
if d.commands[i] == cmdToEncoder && d.commandTimes[i].Sub(d.commandTimes[i-2]) != sequenceResetWait {
t.Errorf("recovery FC7 at %d did not follow RS, settle and diagnostic AP: %v", i, d.commands)
}
}
}
func TestPrepareCurrentCardRejectsFailureWithoutEncoderOrMovement(t *testing.T) {
tests := []struct {
name string
response cmdResp
wantError string
wantStock string
}{
{
name: "status read error",
response: cmdResp{err: errors.New("serial read failed")},
wantError: "serial read failed",
},
{
name: "malformed status",
response: cmdResp{status: []byte{0x30, 0x30, 0x31}},
wantError: "malformed dispenser status",
},
{
name: "unknown status",
response: cmdResp{status: []byte{0x30, 0x30, 0x30, 0x39}},
wantError: "unknown dispenser status",
},
{
name: "jammed preparation",
response: cmdResp{status: []byte{0x30, 0x30, 0x32, 0x34}},
wantError: "Card jammed",
wantStock: "Card jammed",
},
func TestUncertainRecoveryProductionTrace(t *testing.T) {
responses := []cmdResp{{status: status(0x30)}}
for i := 0; i < 5; i++ {
responses = append(responses, cmdResp{err: errors.New("AP unavailable")})
}
responses = append(responses, cmdResp{status: status(0x35)}, cmdResp{status: status(0x35)}, cmdResp{status: status(0x37)})
c, d := newSequenceTestClient(t, responses...)
preparation, err := c.PrepareCurrentCardForEncoding(context.Background())
if err != nil || !preparation.UncertainHandoff || preparation.ShakesUsed != 0 {
t.Fatalf("production trace preparation=%+v error=%v, want uncertain handoff with unused budget", preparation, err)
}
if err := c.RecoverCurrentCard(context.Background(), preparation); err != nil {
t.Fatal(err)
}
if commandCount(d.commands, cmdReset) != 1 || commandCount(d.commands, cmdToEncoder) != 2 {
t.Errorf("production trace commands=%v, want one shake after initial FC7", d.commands)
}
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
client, _ := newSequenceTestClient(t, test.response)
func TestUncertainRecoveryStopsAtPhysicalPosition(t *testing.T) {
for _, position := range []byte{0x32, 0x33, 0x37, 0x3F, 0x38} {
for _, afterReset := range []bool{false, true} {
t.Run(fmt.Sprintf("position=%X afterReset=%t", position, afterReset), func(t *testing.T) {
responses := []cmdResp{{status: status(position)}}
if afterReset {
responses = append([]cmdResp{{status: status(0x35)}}, responses...)
}
c, d := newSequenceTestClient(t, responses...)
err := c.RecoverCurrentCard(context.Background(), PreparationResult{UncertainHandoff: true})
var wantErr error
if position == 0x38 {
wantErr = ErrCardWellEmpty
}
wantRS := 0
if afterReset {
wantRS = 1
}
if !errors.Is(err, wantErr) || commandCount(d.commands, cmdReset) != wantRS || commandCount(d.commands, cmdToEncoder) != 0 {
t.Errorf("position %X recovery error=%v commands=%v, want error=%v RS=%d FC7=0", position, err, d.commands, wantErr, wantRS)
}
})
}
}
}
stock, err := client.PrepareCurrentCard(context.Background())
if err == nil || !strings.Contains(err.Error(), test.wantError) {
t.Fatalf("error = %v, want containing %q", err, test.wantError)
func TestUncertainRecoveryExhaustsOnlyRemainingShakes(t *testing.T) {
for used := 0; used <= sequenceMaxShakes; used++ {
t.Run(fmt.Sprint(used), func(t *testing.T) {
c, d := newSequenceTestClient(t, positionResponses(0x35, 30)...)
preparation := PreparationResult{UncertainHandoff: true, ShakesUsed: used, lastFC7: c.now().Add(-sequenceShakeAfter)}
if err := c.RecoverCurrentCard(context.Background(), preparation); err != nil {
t.Fatal(err)
}
if stock != test.wantStock {
t.Fatalf("stock status = %q, want %q", stock, test.wantStock)
want := sequenceMaxShakes - used
if commandCount(d.commands, cmdReset) != want || commandCount(d.commands, cmdToEncoder) != want {
t.Errorf("used=%d commands=%v, want %d RS/FC7", used, d.commands, want)
}
})
}
}
func TestPrepareCurrentCardReturnsAuthoritativeEmptyWellError(t *testing.T) {
client, device := newSequenceTestClient(t, cmdResp{status: status(0x38)})
func TestUncertainRecoveryPreservesFC7ObservationDelay(t *testing.T) {
c, d := newSequenceTestClient(t, positionResponses(0x35, 4)...)
d.statusResponses = append(d.statusResponses, cmdResp{status: status(0x37)})
started := c.now()
if err := c.RecoverCurrentCard(context.Background(), PreparationResult{UncertainHandoff: true, lastFC7: started}); err != nil {
t.Fatal(err)
}
if commandCount(d.commands, cmdReset) != 1 || d.commandTimes[4].Sub(started) != sequenceShakeAfter {
t.Errorf("commands=%v times=%v, want first RS after three seconds", d.commands, d.commandTimes)
}
}
stock, err := client.PrepareCurrentCard(context.Background())
if !errors.Is(err, ErrCardWellEmpty) {
t.Fatalf("error = %v, want ErrCardWellEmpty", err)
func TestUncertainRecoveryCommandFailuresAndCancellation(t *testing.T) {
for _, command := range []cmdType{cmdReset, cmdToEncoder} {
c, d := newSequenceTestClient(t, positionResponses(0x35, 3)...)
failure := errors.New("recovery dispatch failed")
d.commandErrors[command] = []error{failure}
if err := c.RecoverCurrentCard(context.Background(), PreparationResult{UncertainHandoff: true}); !errors.Is(err, failure) {
t.Errorf("command=%v error=%v, want %v", command, err, failure)
}
if commandCount(d.commands, command) != 1 {
t.Errorf("failed command=%v commands=%v, want one attempt", command, d.commands)
}
}
if stock != "Card empty" {
t.Fatalf("stock status = %q, want Card empty", stock)
c, d := newSequenceTestClient(t, cmdResp{status: status(0x35)})
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
c.sequenceTiming.wait = func(ctx context.Context, duration time.Duration) error {
if duration != sequenceResetWait {
t.Errorf("wait=%s, want reset settle", duration)
}
cancel()
return ctx.Err()
}
if got := commandCount(device.commands, cmdToEncoder); got != 0 {
t.Fatalf("to-encoder commands = %d, want 0", got)
if err := c.RecoverCurrentCard(ctx, PreparationResult{UncertainHandoff: true}); !errors.Is(err, context.Canceled) {
t.Errorf("settle cancellation=%v, want context.Canceled", err)
}
if !reflect.DeepEqual(d.commands, []cmdType{cmdStatus, cmdReset}) {
t.Errorf("cancelled commands=%v, want AP/RS only", d.commands)
}
if err := c.RecoverCurrentCard(ctx, PreparationResult{UncertainHandoff: true}); !errors.Is(err, context.Canceled) {
t.Errorf("already cancelled recovery=%v, want context.Canceled", err)
}
}
func TestConfirmedPreparationNeverRecovers(t *testing.T) {
c, d := newSequenceTestClient(t, cmdResp{status: status(0x37)})
preparation, err := c.PrepareCurrentCardForEncoding(context.Background())
if err != nil || preparation.UncertainHandoff {
t.Fatalf("confirmed preparation=%+v error=%v", preparation, err)
}
if err := c.RecoverCurrentCard(context.Background(), preparation); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(d.commands, []cmdType{cmdStatus}) {
t.Errorf("confirmed commands=%v, want initial AP only", d.commands)
}
}
@@ -291,42 +322,6 @@ func TestDeliverCurrentCardPreservesContextCancellation(t *testing.T) {
}
}
func TestPrepareCurrentCardRetriesOnceThenTimesOut(t *testing.T) {
responses := make([]cmdResp, 13)
for index := range responses {
responses[index] = cmdResp{status: status(0x34)}
}
client, device := newSequenceTestClient(t, responses...)
_, err := client.PrepareCurrentCard(context.Background())
if err == nil || !strings.Contains(err.Error(), "timed out") {
t.Fatalf("error = %v, want preparation timeout", err)
}
if got := commandCount(device.commands, cmdToEncoder); got != 2 {
t.Fatalf("to-encoder commands = %d, want initial command plus one halfway retry", got)
}
if got := commandCount(device.commands, cmdStatus); got != 13 {
t.Fatalf("status reads = %d, want 13", got)
}
}
func TestPrepareCurrentCardPropagatesContextCancellation(t *testing.T) {
client, _ := newSequenceTestClient(t,
cmdResp{status: status(0x34)},
cmdResp{status: status(0x34)},
)
ctx, cancel := context.WithCancel(context.Background())
client.sequenceTiming.wait = func(context.Context, time.Duration) error {
cancel()
return ctx.Err()
}
_, err := client.PrepareCurrentCard(ctx)
if !errors.Is(err, context.Canceled) {
t.Fatalf("error = %v, want context.Canceled", err)
}
}
func TestBeginPrepareNextCardDispatchesWithoutReadinessPolling(t *testing.T) {
client, device := newSequenceTestClient(t)
@@ -357,48 +352,292 @@ func TestBeginPrepareNextCardReturnsDispatchFailureWithoutPolling(t *testing.T)
}
}
func TestPrepareCardAtEncoderRequiresConfirmedEncoderState(t *testing.T) {
tests := []struct {
name string
responses []cmdResp
wantError string
wantToEncoder int
func TestPositionDescriptions(t *testing.T) {
for _, test := range []struct {
position byte
want string
}{
{
name: "already at encoder",
responses: []cmdResp{{status: status(0x33)}},
wantToEncoder: 0,
},
{
name: "moves ready card to encoder",
responses: []cmdResp{
{status: status(0x34)},
{status: status(0x33)},
},
wantToEncoder: 1,
},
{
name: "empty card well",
responses: []cmdResp{{status: status(0x38)}},
wantError: CardWellEmptyMessage,
wantToEncoder: 0,
},
{0x30, ""},
{0x31, "Card at pre-dispense position; "},
{0x32, "Card at encoder position; "},
{0x34, "Card at mouth position; "},
{0x37, "Card at pre-dispense position; Card at encoder position; Card at mouth position; "},
{0x39, "Card at pre-dispense position; Card empty; "},
{0x3F, "Card at pre-dispense position; Card at encoder position; Card at mouth position; Card empty; "},
{0x40, "Unknown status 0x40 at position 4; "},
} {
if got := statusDescription(status(test.position)); got != test.want {
t.Errorf("statusDescription(position %X) = %q, want %q", test.position, got, test.want)
}
}
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
client, device := newSequenceTestClient(t, test.responses...)
func positionResponses(position byte, count int) []cmdResp {
responses := make([]cmdResp, count)
for i := range responses {
responses[i] = cmdResp{status: status(position)}
}
return responses
}
_, err := client.PrepareNextCard(context.Background())
if test.wantError == "" && err != nil {
t.Fatal(err)
func TestPreparationClasses(t *testing.T) {
classes := map[preparationClass][]byte{
encoderConfirmed: {0x32, 0x33, 0x36, 0x37, 0x3A, 0x3B, 0x3E, 0x3F},
positionUncertain: {0x31, 0x34, 0x35, 0x39, 0x3C, 0x3D},
positionWellEmpty: {0x38}, positionNoCard: {0x30},
}
for want, positions := range classes {
for _, position := range positions {
st := []byte{0xFF, 0x36, 0x32, position}
if got, err := classifyPreparationStatus(st); got != want || err != nil {
t.Errorf("classify(% X)=%s,%v, want %s", st, got, err, want)
}
if test.wantError != "" && (err == nil || !strings.Contains(err.Error(), test.wantError)) {
t.Fatalf("error = %v, want containing %q", err, test.wantError)
}
}
for _, st := range [][]byte{nil, {0x30}, status(0x02), status(0x40), status(0xFF), {0x30, 0x30, 0x30, 0x37, 0x30}} {
if got, err := classifyPreparationStatus(st); err == nil {
t.Errorf("classify(% X)=%s,nil, want malformed error", st, got)
}
}
}
func TestPreparationAllPositionsBothMethods(t *testing.T) {
for _, next := range []bool{false, true} {
for position := byte(0x30); position <= 0x3F; position++ {
t.Run(fmt.Sprintf("next=%t/position=%X", next, position), func(t *testing.T) {
responses := positionResponses(position, 40)
for i := range responses {
responses[i].status[0], responses[i].status[1], responses[i].status[2] = 0xFF, 0x38, 0x34
}
c, d := newSequenceTestClient(t, responses...)
// Passive encoder data must never replace fresh AP.
c.lastStatus, c.lastStatusT, c.statusTTL = status(0x33), time.Now(), time.Hour
prepare := c.PrepareCurrentCard
if next {
prepare = c.PrepareNextCard
}
started := c.now()
_, err := prepare(context.Background())
wantFC7, wantRS, wantElapsed := 0, 0, time.Duration(0)
var wantErr error
switch position {
case 0x30:
wantFC7, wantRS, wantElapsed, wantErr = 4, 3, 18*time.Second, ErrPreparationExhausted
case 0x38:
wantErr = ErrCardWellEmpty
case 0x31, 0x34, 0x35, 0x39, 0x3C, 0x3D:
wantFC7, wantElapsed = 1, 4*time.Second
}
if !errors.Is(err, wantErr) {
t.Errorf("prepare(%X) error=%v, want %v", position, err, wantErr)
}
if commandCount(d.commands, cmdToEncoder) != wantFC7 || commandCount(d.commands, cmdReset) != wantRS {
t.Errorf("prepare(%X) commands=%v, want FC7=%d RS=%d", position, d.commands, wantFC7, wantRS)
}
if got := c.now().Sub(started); got != wantElapsed {
t.Errorf("prepare(%X) elapsed=%s, want %s", position, got, wantElapsed)
}
})
}
}
}
func TestThreeShakesAreRequestLocalAndSettled(t *testing.T) {
c, d := newSequenceTestClient(t, positionResponses(0x30, 34)...)
for request := 0; request < 2; request++ {
start := len(d.commands)
if _, err := c.PrepareCurrentCard(context.Background()); !errors.Is(err, ErrPreparationExhausted) {
t.Fatalf("request %d error=%v, want exhausted", request, err)
}
want := []cmdType{cmdStatus, cmdToEncoder}
for attempt := 0; attempt < 4; attempt++ {
want = append(want, cmdStatus, cmdStatus, cmdStatus, cmdStatus)
if attempt < 3 {
want = append(want, cmdReset, cmdToEncoder)
}
if got := commandCount(device.commands, cmdToEncoder); got != test.wantToEncoder {
t.Fatalf("to-encoder commands = %d, want %d", got, test.wantToEncoder)
}
if !reflect.DeepEqual(d.commands[start:], want) {
t.Errorf("request %d commands=%v, want %v", request, d.commands[start:], want)
}
var lastFC7 time.Time
for i := start; i < len(d.commands); i++ {
if d.commands[i] == cmdReset && d.commandTimes[i].Sub(lastFC7) != 3*time.Second {
t.Errorf("RS at %s after FC7, want 3s", d.commandTimes[i].Sub(lastFC7))
}
if d.commands[i] == cmdToEncoder {
if i > start && d.commands[i-1] == cmdReset && d.commandTimes[i].Sub(d.commandTimes[i-1]) != 2*time.Second {
t.Errorf("FC7 settle=%s, want 2s", d.commandTimes[i].Sub(d.commandTimes[i-1]))
}
lastFC7 = d.commandTimes[i]
}
}
}
}
func TestPreparationReclassifiesEverySample(t *testing.T) {
for _, tc := range []struct {
name string
positions []byte
wantRS int
wantTime time.Duration
wantErr error
}{
{"uncertain changes do not restart timer", []byte{0x30, 0x31, 0x34, 0x35, 0x39, 0x3C}, 0, 4 * time.Second, nil},
{"uncertain becomes encoder", []byte{0x30, 0x34, 0x37}, 0, time.Second, nil},
{"uncertain becomes empty", []byte{0x30, 0x34, 0x38}, 0, time.Second, ErrCardWellEmpty},
{"no sensors becomes empty", []byte{0x30, 0x30, 0x38}, 0, time.Second, ErrCardWellEmpty},
{"uncertain returns to shake path twice", []byte{0x30, 0x34, 0x30, 0x30, 0x30, 0x34, 0x34, 0x30, 0x30, 0x37}, 2, 10 * time.Second, nil},
} {
t.Run(tc.name, func(t *testing.T) {
var responses []cmdResp
for _, p := range tc.positions {
responses = append(responses, cmdResp{status: status(p)})
}
c, d := newSequenceTestClient(t, responses...)
start := c.now()
_, err := c.PrepareCurrentCard(context.Background())
if !errors.Is(err, tc.wantErr) || c.now().Sub(start) != tc.wantTime || commandCount(d.commands, cmdReset) != tc.wantRS {
t.Errorf("prepare(%s) error=%v elapsed=%s commands=%v, want error=%v time=%s RS=%d", tc.name, err, c.now().Sub(start), d.commands, tc.wantErr, tc.wantTime, tc.wantRS)
}
})
}
}
func TestEveryShakeReclassifiesEncoderEmptyAndUncertain(t *testing.T) {
for shake := 1; shake <= 3; shake++ {
for _, position := range []byte{0x37, 0x38, 0x35} {
responses := positionResponses(0x30, 1+4*shake)
responses = append(responses, positionResponses(position, 5)...)
c, d := newSequenceTestClient(t, responses...)
_, err := c.PrepareCurrentCard(context.Background())
var wantErr error
if position == 0x38 {
wantErr = ErrCardWellEmpty
}
if !errors.Is(err, wantErr) || commandCount(d.commands, cmdReset) != shake || commandCount(d.commands, cmdToEncoder) != shake+1 {
t.Errorf("shake %d position=%X error=%v commands=%v, want %v and no further shake", shake, position, err, d.commands, wantErr)
}
}
}
}
func TestPreparationTransportAndDispatchFailuresDoNotShake(t *testing.T) {
failure := errors.New("serial failure")
for _, response := range []cmdResp{{err: failure}, {status: []byte{0x30}}, {status: status(0x40)}} {
c, d := newSequenceTestClient(t, cmdResp{status: status(0x30)}, response)
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
t.Errorf("AP failure %v error=%v, want encoder opportunity", response, err)
}
if commandCount(d.commands, cmdToEncoder) != 1 || commandCount(d.commands, cmdReset) != 0 {
t.Errorf("AP failure commands=%v, want FC7 once and no RS", d.commands)
}
}
for _, command := range []cmdType{cmdToEncoder, cmdReset} {
c, d := newSequenceTestClient(t, positionResponses(0x30, 10)...)
d.commandErrors[command] = []error{failure}
if _, err := c.PrepareCurrentCard(context.Background()); !errors.Is(err, failure) {
t.Errorf("command %v error=%v, want serial failure", command, err)
}
if commandCount(d.commands, command) != 1 {
t.Errorf("command %v retried: %v", command, d.commands)
}
}
}
func TestPreparationStopsAtCancellationAndDeadlineStages(t *testing.T) {
for _, stage := range []string{"initial AP", "FC7", "poll", "RS", "settle"} {
for _, callerCanceled := range []bool{false, true} {
if stage == "initial AP" && !callerCanceled {
continue
}
t.Run(fmt.Sprintf("%s/cancel=%t", stage, callerCanceled), func(t *testing.T) {
c, d := newSequenceTestClient(t, positionResponses(0x30, 30)...)
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
now := c.now()
c.sequenceTiming.now = func() time.Time { return now }
stoppedAt := -1
stop := func() {
if stoppedAt >= 0 {
return
}
stoppedAt = len(d.commands)
if callerCanceled {
cancel()
} else {
now = now.Add(sequenceTimeout)
}
}
c.sequenceTiming.wait = func(_ context.Context, duration time.Duration) error {
now = now.Add(duration)
if (stage == "poll" && duration == sequencePollInterval) || (stage == "settle" && duration == sequenceResetWait) {
stop()
}
return nil
}
d.onCommand = func(cmd cmdType) {
if (stage == "initial AP" && cmd == cmdStatus) || (stage == "FC7" && cmd == cmdToEncoder) || (stage == "RS" && cmd == cmdReset) {
stop()
}
}
_, err := c.PrepareCurrentCard(ctx)
wantErr := error(ErrPreparationExhausted)
if callerCanceled {
wantErr = context.Canceled
} else if stage == "initial AP" {
wantErr = context.DeadlineExceeded
}
if !errors.Is(err, wantErr) || len(d.commands) != stoppedAt {
t.Errorf("stage=%s cancel=%t error=%v commands=%v stoppedAt=%d, want %v and no commands after stop", stage, callerCanceled, err, d.commands, stoppedAt, wantErr)
}
})
}
}
}
func TestPositionFlagsRemainDiagnostic(t *testing.T) {
for position := byte(0x30); position <= 0x3F; position++ {
st := status(position)
if got := isAtEncoderPosition(st); got != (position&0x02 != 0) {
t.Errorf("encoder sensor(%X)=%t", position, got)
}
if got := isCardWellEmpty(st); got != (position&0x08 != 0) {
t.Errorf("stock empty flag(%X)=%t", position, got)
}
wantStock := ""
if position&0x08 != 0 {
wantStock = "Card empty"
}
if got := stockTake(st); got != wantStock {
t.Errorf("stockTake(%X)=%q, want %q", position, got, wantStock)
}
}
}
func TestPreparationCallerDeadlineIsNotRetryableExhaustion(t *testing.T) {
c, d := newSequenceTestClient(t)
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
defer cancel()
_, err := c.PrepareCurrentCard(ctx)
if !errors.Is(err, context.DeadlineExceeded) || errors.Is(err, ErrPreparationExhausted) || len(d.commands) != 0 {
t.Errorf("expired caller: err=%v commands=%v, want caller deadline and no commands", err, d.commands)
}
}
func TestPreparationExpiredEncoderSampleHandsOff(t *testing.T) {
c, d := newSequenceTestClient(t, cmdResp{status: status(0x30)}, cmdResp{status: status(0x37)})
now := c.now()
c.sequenceTiming.now = func() time.Time { return now }
d.onCommand = func(cmd cmdType) {
if cmd == cmdStatus && commandCount(d.commands, cmdStatus) == 2 {
now = now.Add(sequenceTimeout)
}
}
_, err := c.PrepareCurrentCard(context.Background())
if err != nil {
t.Errorf("late encoder sample: err=%v, want handoff", err)
}
if len(d.commands) != 3 {
t.Errorf("late encoder sample commands=%v, want AP FC7 AP", d.commands)
}
}
+180
View File
@@ -0,0 +1,180 @@
package dispenser
import (
"context"
"sync"
"time"
log "github.com/sirupsen/logrus"
)
const maintenanceInterval = time.Minute
const maintenanceTimeout = 5 * time.Second
// activityGuard arbitrates admission, not the duration of serial transactions.
// The serial worker remains the sole owner of the port and deliveryPending.
type activityGuard struct {
sync.Mutex
foreground int
generation uint64
enabled bool
closed bool
next time.Time
cancel context.CancelFunc
finished chan struct{}
}
func (c *Client) wakeWorker() {
select {
case c.activityWake <- struct{}{}:
default:
}
}
// BeginForeground suppresses idle work until the returned release function runs.
func (c *Client) BeginForeground() func() {
c.activity.Lock()
c.activity.foreground++
c.activity.generation++
c.activity.next = time.Time{}
c.activity.Unlock()
c.wakeWorker()
var once sync.Once
return func() {
once.Do(func() {
c.activity.Lock()
c.activity.foreground--
if c.activity.foreground == 0 && c.activity.enabled && !c.activity.closed {
c.activity.next = c.now().Add(maintenanceInterval)
}
c.activity.Unlock()
c.wakeWorker()
})
}
}
// StartMaintenance enables the worker timer once, with an initial one-minute delay.
func (c *Client) StartMaintenance() {
c.activity.Lock()
if !c.activity.enabled && !c.activity.closed {
c.activity.enabled = true
c.activity.generation++
if c.activity.foreground == 0 {
c.activity.next = c.now().Add(maintenanceInterval)
}
}
c.activity.Unlock()
c.wakeWorker()
}
// StopMaintenance prevents new admissions and waits for an admitted attempt to exit.
// An underlying serial read can finish only according to its existing read timeout.
func (c *Client) StopMaintenance() {
c.activity.Lock()
c.activity.enabled = false
c.activity.generation++
c.activity.next = time.Time{}
if c.activity.cancel != nil {
c.activity.cancel()
}
finished := c.activity.finished
c.activity.Unlock()
c.wakeWorker()
if finished != nil {
<-finished
}
}
func (c *Client) maintenanceDelay() (time.Duration, bool) {
c.activity.Lock()
defer c.activity.Unlock()
if !c.activity.enabled || c.activity.closed || c.activity.foreground != 0 || c.activity.next.IsZero() {
return 0, false
}
remaining := c.activity.next.Sub(c.now())
if remaining < 0 {
remaining = 0
}
return remaining, true
}
func (c *Client) passiveGeneration() (uint64, bool) {
c.activity.Lock()
defer c.activity.Unlock()
return c.activity.generation, c.activity.foreground == 0 && !c.activity.closed
}
func (c *Client) admitPassive(ctx context.Context, generation uint64) bool {
c.activity.Lock()
defer c.activity.Unlock()
return ctx.Err() == nil && !c.activity.closed && c.activity.foreground == 0 && c.activity.generation == generation
}
func (c *Client) admitMaintenance(ctx context.Context, generation uint64) bool {
c.activity.Lock()
defer c.activity.Unlock()
return ctx.Err() == nil && c.activity.enabled && !c.activity.closed && c.activity.foreground == 0 && c.activity.generation == generation
}
// maintainIdleCard is called only by the serial worker, never through its queue.
func (c *Client) maintainIdleCard() {
c.activity.Lock()
if !c.activity.enabled || c.activity.closed || c.activity.foreground != 0 || c.activity.next.IsZero() || c.now().Before(c.activity.next) {
c.activity.Unlock()
return
}
ctx, cancel := context.WithTimeout(context.Background(), maintenanceTimeout)
generation := c.activity.generation
finished := make(chan struct{})
c.activity.cancel, c.activity.finished = cancel, finished
c.activity.Unlock()
defer func() {
cancel()
c.activity.Lock()
c.activity.cancel, c.activity.finished = nil, nil
if c.activity.enabled && !c.activity.closed && c.activity.foreground == 0 && c.activity.generation == generation {
c.activity.next = c.now().Add(maintenanceInterval)
}
close(finished)
c.activity.Unlock()
}()
if !c.admitMaintenance(ctx, generation) {
return
}
// Quiet observation: do not publish stock callbacks or manufacture cached status.
st, err := checkDispenserStatus(ctx, c.port)
if err != nil {
log.Debugf("idle dispenser maintenance AP: %v", err)
return
}
class, err := classifyPreparationStatus(st)
if err != nil {
log.Debugf("idle dispenser maintenance unusable AP: %v", err)
return
}
log.Debugf("idle dispenser maintenance AP; class=%s raw status: % X", class, st)
if class == encoderConfirmed || class == positionWellEmpty {
return
}
clear, err := deliveryClearance(st)
if err != nil || !clear {
return
}
if c.deliveryPending && c.now().Sub(c.deliveryStarted) < deliveryMinimumWait {
return
}
// This is the admission boundary shared with foreground registration and stop.
if !c.admitMaintenance(ctx, generation) {
return
}
if c.deliveryPending {
c.deliveryPending = false
}
err = cardToEncoderPosition(ctx, c.port)
c.invalidateStatusCache()
if err != nil {
log.Warnf("idle dispenser maintenance FC7 dispatch: %v", err)
return
}
log.Info("idle dispenser maintenance FC7 dispatched")
}
+370
View File
@@ -0,0 +1,370 @@
package dispenser
import (
"context"
"errors"
"reflect"
"sync"
"testing"
"time"
)
func maintenanceClient(t *testing.T, p *scriptedTransport) (*Client, *time.Time) {
t.Helper()
transportAddress(t)
now := time.Unix(100, 0)
c := &Client{port: p, done: make(chan struct{}), activityWake: make(chan struct{}, 1), sequenceTiming: sequenceTiming{now: func() time.Time { return now }, wait: waitForSequence}}
t.Cleanup(c.Close)
return c, &now
}
func TestMaintenanceIdleScheduling(t *testing.T) {
c, now := maintenanceClient(t, &scriptedTransport{})
c.StartMaintenance()
first := c.activity.next
c.StartMaintenance()
if c.activity.next != first {
t.Fatal("repeated start reset the timer")
}
*now = now.Add(59 * time.Second)
c.maintainIdleCard()
if len(c.port.(*scriptedTransport).writes) != 0 {
t.Fatal("maintenance ran before one minute")
}
release1 := c.BeginForeground()
release2 := c.BeginForeground()
release1()
if _, enabled := c.maintenanceDelay(); enabled {
t.Fatal("timer enabled while another issuance active")
}
*now = now.Add(20 * time.Second)
release2()
release2()
if delay, enabled := c.maintenanceDelay(); !enabled || delay != time.Minute {
t.Fatalf("after last release delay=%v enabled=%t", delay, enabled)
}
c.StopMaintenance()
if _, enabled := c.maintenanceDelay(); enabled {
t.Fatal("stop left timer enabled")
}
}
func TestMaintenanceUsesCommonEligibility(t *testing.T) {
for _, tc := range []struct {
name string
st []byte
pending bool
age time.Duration
fc7 bool
}{
{"clear", status(0x30), false, 0, true},
{"staging", status(0x34), true, 3 * time.Second, true},
{"too early", status(0x30), true, time.Second, false},
{"encoder", status(0x33), true, time.Minute, false},
{"empty", status(0x38), false, 0, false},
{"uncertain", status(0x35), false, 0, false},
{"movement", []byte{0x31, 0x30, 0x30, 0x34}, true, time.Minute, false},
{"invalid", status(0x40), true, time.Minute, false},
} {
t.Run(tc.name, func(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(tc.st), vendorACK}}
c, now := maintenanceClient(t, p)
c.StartMaintenance()
*now = now.Add(time.Minute)
c.deliveryPending = tc.pending
c.deliveryStarted = now.Add(-tc.age)
callbacks := 0
c.OnStockUpdate(func(string) { callbacks++ })
c.maintainIdleCard()
want := []string{"AP"}
if tc.fc7 {
want = append(want, "FC7")
}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("commands=%v want %v", got, want)
}
if callbacks != 0 {
t.Errorf("maintenance published %d stock callbacks", callbacks)
}
if tc.pending && !tc.fc7 && !c.deliveryPending {
t.Error("ineligible maintenance cleared pending")
}
if delay, enabled := c.maintenanceDelay(); !enabled || delay != time.Minute {
t.Errorf("next maintenance delay=%v enabled=%t", delay, enabled)
}
})
}
}
func TestMaintenanceForegroundBetweenAPAndFC7(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x30)), vendorACK}}
c, now := maintenanceClient(t, p)
c.StartMaintenance()
*now = now.Add(time.Minute)
var release func()
p.afterRead = func() {
if len(p.chunks) == 1 && release == nil {
release = c.BeginForeground()
}
}
c.maintainIdleCard()
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP"}) {
t.Errorf("foreground during AP commands=%v want AP only", got)
}
if release == nil {
t.Fatal("barrier not reached")
}
release()
if delay, _ := c.maintenanceDelay(); delay != time.Minute {
t.Errorf("foreground completion delay=%v", delay)
}
}
func TestMaintenanceAdmissionConditions(t *testing.T) {
c, _ := maintenanceClient(t, &scriptedTransport{})
c.StartMaintenance()
generation := c.activity.generation
ctx, cancel := context.WithCancel(context.Background())
if !c.admitMaintenance(ctx, generation) {
t.Fatal("idle admission rejected")
}
cancel()
if c.admitMaintenance(ctx, generation) {
t.Fatal("canceled admission accepted")
}
expired, stop := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
defer stop()
if c.admitMaintenance(expired, generation) {
t.Fatal("expired admission accepted")
}
release := c.BeginForeground()
if c.admitMaintenance(context.Background(), generation) {
t.Fatal("foreground/stale admission accepted")
}
release()
if c.admitMaintenance(context.Background(), generation) {
t.Fatal("obsolete generation accepted")
}
generation = c.activity.generation
c.StopMaintenance()
if c.admitMaintenance(context.Background(), generation) {
t.Fatal("stopped admission accepted")
}
}
func TestPassivePollGenerationAtDispatch(t *testing.T) {
c, _ := maintenanceClient(t, &scriptedTransport{})
generation, _ := c.passiveGeneration()
release := c.BeginForeground()
for _, active := range []bool{true, false} {
if !active {
release()
}
response := make(chan cmdResp, 1)
c.handle(cmdReq{ctx: context.Background(), typ: cmdStatus, passive: true, generation: generation, respCh: response})
<-response
if len(c.port.(*scriptedTransport).writes) != 0 {
t.Errorf("active=%t stale passive request touched port", active)
}
}
}
func TestMaintenanceStopWaitsForAdmittedRead(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x30)), vendorACK}}
c, now := maintenanceClient(t, p)
c.StartMaintenance()
*now = now.Add(time.Minute)
entered, resume := make(chan struct{}), make(chan struct{})
var once sync.Once
p.afterRead = func() { once.Do(func() { close(entered); <-resume }) }
finished := make(chan struct{})
go func() { c.maintainIdleCard(); close(finished) }()
<-entered
stopped := make(chan struct{})
go func() { c.StopMaintenance(); close(stopped) }()
// Wait until stop has disabled admission.
for {
c.activity.Lock()
enabled := c.activity.enabled
c.activity.Unlock()
if !enabled {
break
}
time.Sleep(time.Millisecond)
}
select {
case <-stopped:
t.Fatal("stop returned before admitted read finished")
default:
}
close(resume)
<-finished
<-stopped
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP"}) {
t.Errorf("stop commands=%v want AP only", got)
}
c.StopMaintenance()
c.Close()
c.Close()
}
func TestMaintenanceWorkerTimerWake(t *testing.T) {
c := NewClient(nil, 1)
c.StartMaintenance()
release := c.BeginForeground()
// An immediate obsolete timer is harmless while foreground is registered.
c.activity.Lock()
c.activity.next = time.Now().Add(-time.Second)
c.activity.Unlock()
c.wakeWorker()
release()
if delay, enabled := c.maintenanceDelay(); !enabled || delay <= 59*time.Second {
t.Errorf("worker schedule delay=%v enabled=%t", delay, enabled)
}
c.Close()
if r := c.doResponse(context.Background(), cmdStatus); r.err == nil {
t.Fatal("closed client accepted a request")
}
}
func TestMaintenanceWorkerTimerDispatch(t *testing.T) {
transportAddress(t)
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x30)), vendorACK}}
c := &Client{port: p, reqCh: make(chan cmdReq, 1), done: make(chan struct{}), activityWake: make(chan struct{}, 1), sequenceTiming: sequenceTiming{now: time.Now, wait: waitForSequence}}
c.StartMaintenance()
c.activity.Lock()
c.activity.next = time.Now().Add(-time.Second)
c.activity.Unlock()
workerDone := make(chan struct{})
go func() { defer close(workerDone); c.loop() }()
t.Cleanup(func() { c.Close(); <-workerDone })
dispatched := make(chan struct{})
// Observe completion through the activity guard, without touching the transport concurrently.
go func() {
for {
c.activity.Lock()
next := c.activity.next
c.activity.Unlock()
if time.Until(next) > 50*time.Second {
close(dispatched)
return
}
select {
case <-c.done:
return
case <-time.After(time.Millisecond):
}
}
}()
select {
case <-dispatched:
case <-time.After(4 * time.Second):
t.Fatal("worker timer did not finish maintenance")
}
c.StopMaintenance()
if got := wireCommands(p); !reflect.DeepEqual(got, []string{"AP", "FC7"}) {
t.Errorf("timer commands=%v", got)
}
}
func TestForegroundEncoderClearanceCharacterization(t *testing.T) {
for _, movement := range []bool{false, true} {
st := status(0x33)
if movement {
st[0] = 0x31
}
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(st), vendorACK, apReply(st), vendorACK, apReply(st), vendorACK}}
c, now := maintenanceClient(t, p)
c.deliveryPending = true
c.deliveryStarted = now.Add(-time.Minute)
c.sequenceTiming.wait = func(context.Context, time.Duration) error { *now = now.Add(2 * time.Second); return nil }
r := workerRequest(c, context.Background(), cmdToEncoder)
want := []string{"AP", "AP", "AP"}
if movement {
if !errors.Is(r.err, context.DeadlineExceeded) || !c.deliveryPending {
t.Errorf("movement err=%v pending=%t", r.err, c.deliveryPending)
}
} else {
want = append(want, "FC7")
if r.err != nil || c.deliveryPending {
t.Errorf("internal fallback err=%v pending=%t", r.err, c.deliveryPending)
}
}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("movement=%t commands=%v want %v", movement, got, want)
}
}
}
func TestForegroundEncoderClearanceCallerDeadline(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK, apReply(status(0x33)), vendorACK, apReply(status(0x33)), vendorACK, apReply(status(0x33))}}
c, now := maintenanceClient(t, p)
c.deliveryPending = true
c.deliveryStarted = *now
start := *now
samples := 0
remainingChunks := len(p.chunks)
p.afterRead = func() {
// 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)
defer cancel()
c.sequenceTiming.wait = func(context.Context, time.Duration) error {
if samples == 3 {
<-ctx.Done()
return ctx.Err()
}
*now = now.Add(time.Second)
return nil
}
r := workerRequest(c, ctx, cmdToEncoder)
if !errors.Is(r.err, context.DeadlineExceeded) || !c.deliveryPending {
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 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)
}
}
func TestMaintenanceFailuresAreQuietAndRetryLater(t *testing.T) {
for _, mechanical := range []bool{false, true} {
p := &scriptedTransport{chunks: [][]byte{{0x10, 0x06, 0x30}}}
if mechanical {
p.chunks = [][]byte{vendorACK, apReply(status(0x30))}
}
c, now := maintenanceClient(t, p)
c.StartMaintenance()
*now = now.Add(time.Minute)
callbacks := 0
c.OnStockUpdate(func(string) { callbacks++ })
c.maintainIdleCard()
want := []string{"AP"}
if mechanical {
want = append(want, "FC7")
}
if got := wireCommands(p); !reflect.DeepEqual(got, want) {
t.Errorf("mechanical=%t commands=%v want %v", mechanical, got, want)
}
if callbacks != 0 {
t.Errorf("maintenance failure callbacks=%d", callbacks)
}
if delay, enabled := c.maintenanceDelay(); !enabled || delay != time.Minute {
t.Errorf("retry delay=%v enabled=%t", delay, enabled)
}
}
}
+242
View File
@@ -0,0 +1,242 @@
package dispenser
import (
"context"
"errors"
"fmt"
"io"
"testing"
"time"
)
func TestStrictAPFailuresBecomeUnusablePreparationObservations(t *testing.T) {
transportAddress(t)
cases := []struct {
name string
chunks [][]byte
readErr error
}{
{"invalid ACK 10 06 30", [][]byte{{0x10, 0x06, 0x30}}, nil},
{"truncated", [][]byte{vendorACK, vendorAP[:8]}, nil},
{"no response", nil, nil},
{"timeout", nil, context.DeadlineExceeded},
{"read failure", nil, io.ErrClosedPipe},
}
for _, offset := range []int{0, 1, 2, 3, 4, 5, 6, 11, 12} {
frame := append([]byte(nil), vendorAP...)
frame[offset] ^= 0xff
if offset == 5 || offset == 6 || offset == 11 {
frame[12] = calculateBCC(frame[:12])
}
cases = append(cases, struct {
name string
chunks [][]byte
readErr error
}{fmt.Sprintf("frame byte %d", offset), [][]byte{vendorACK, frame}, nil})
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
p := &scriptedTransport{chunks: tc.chunks, readErr: tc.readErr}
st, err := queryStatus(context.Background(), p, vendorFrames[0].command, 4, 0)
if err == nil {
t.Fatal("strict queryStatus accepted invalid transaction")
}
c, d := newSequenceTestClient(t, cmdResp{status: st, err: err}, cmdResp{status: status(0x37)})
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
t.Errorf("preparation after %s = %v, want opportunity", tc.name, err)
}
if commandCount(d.commands, cmdToEncoder) != 1 || commandCount(d.commands, cmdReset) != 0 {
t.Errorf("commands=%v, want one FC7 and no RS", d.commands)
}
})
}
}
func TestUnusableObservationsReclassifyAndShareUncertainty(t *testing.T) {
for _, later := range []byte{0x38, 0x30, 0x37, 0x35, 0x40} {
t.Run(fmt.Sprintf("later %X", later), func(t *testing.T) {
responses := []cmdResp{{err: io.ErrUnexpectedEOF}, {status: status(0x40)}}
responses = append(responses, positionResponses(later, 25)...)
c, d := newSequenceTestClient(t, responses...)
_, err := c.PrepareCurrentCard(context.Background())
var want error
if later == 0x38 {
want = ErrCardWellEmpty
}
if later == 0x30 {
want = ErrPreparationExhausted
}
if !errors.Is(err, want) {
t.Errorf("later %X error=%v, want %v", later, err, want)
}
resets := 0
if later == 0x30 {
resets = 3
}
if commandCount(d.commands, cmdReset) != resets {
t.Errorf("later %X commands=%v, want %d RS", later, d.commands, resets)
}
})
}
c, d := newSequenceTestClient(t, cmdResp{err: io.EOF}, cmdResp{err: io.EOF}, cmdResp{status: status(0x35)}, cmdResp{status: status(0x40)}, cmdResp{err: io.EOF}, cmdResp{status: status(0x39)})
start := c.now()
if _, err := c.PrepareCurrentCard(context.Background()); err != nil {
t.Fatal(err)
}
if elapsed := c.now().Sub(start); elapsed != sequenceUncertainWait {
t.Errorf("mixed uncertainty elapsed=%v, want %v", elapsed, sequenceUncertainWait)
}
if commandCount(d.commands, cmdToEncoder) != 1 {
t.Errorf("mixed uncertainty commands=%v, want one FC7", d.commands)
}
}
func TestObservationAtPreparationDeadline(t *testing.T) {
for _, last := range []cmdResp{{err: io.EOF}, {status: status(0x40)}, {status: status(0x35)}, {status: status(0x30)}, {status: status(0x38)}} {
c, d := newSequenceTestClient(t, cmdResp{status: status(0x30)}, last)
now := c.now()
c.sequenceTiming.now = func() time.Time { return now }
d.onCommand = func(cmd cmdType) {
if cmd == cmdStatus && commandCount(d.commands, cmdStatus) == 2 {
now = now.Add(sequenceTimeout)
}
}
_, err := c.PrepareCurrentCard(context.Background())
var want error
if len(last.status) == 4 && last.status[3] == 0x30 {
want = ErrPreparationExhausted
}
if len(last.status) == 4 && last.status[3] == 0x38 {
want = ErrCardWellEmpty
}
if !errors.Is(err, want) {
t.Errorf("deadline observation=%v error=%v, want %v", last, err, want)
}
}
}
func TestWorkerClearanceFallbackAndMovement(t *testing.T) {
for _, mode := range []string{"unusable", "ambiguous", "movement", "movement then unusable", "empty", "cancel"} {
t.Run(mode, func(t *testing.T) {
p := &scriptedTransport{}
for i := 0; i < 6; i++ {
switch mode {
case "unusable", "cancel":
p.chunks = append(p.chunks, []byte{0x10, 0x06, 0x30})
case "ambiguous":
p.chunks = append(p.chunks, vendorACK, apReply(status(0x37)))
case "empty":
p.chunks = append(p.chunks, vendorACK, apReply(status(0x38)))
default:
if mode == "movement then unusable" && i > 0 {
p.chunks = append(p.chunks, []byte{0x10, 0x06, 0x30})
} else {
p.chunks = append(p.chunks, vendorACK, apReply([]byte{0x31, 0x30, 0x30, 0x34}))
}
}
}
c, now := deliveryWorkerClient(t, p)
c.sequenceTiming.wait = func(ctx context.Context, d time.Duration) error {
if ctx.Err() != nil {
return ctx.Err()
}
*now = now.Add(2 * d)
return nil
}
c.deliveryPending = true
c.deliveryStarted = c.now()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if mode == "cancel" {
p.afterRead = cancel
}
r := c.doResponse(ctx, cmdDeliveryClearance)
if mode == "cancel" {
if !errors.Is(r.err, context.Canceled) {
t.Errorf("cancel=%v", r.err)
}
return
}
var want error
if mode == "movement" {
want = context.DeadlineExceeded
}
if mode == "empty" {
want = ErrCardWellEmpty
}
if !errors.Is(r.err, want) {
t.Errorf("clearance %s error=%v want %v", mode, r.err, want)
}
if c.deliveryPending != (want != nil) {
t.Errorf("clearance %s pending=%t", mode, c.deliveryPending)
}
if mode != "empty" && now.Sub(time.Unix(0, 0)) != deliveryClearanceTimeout {
t.Errorf("clearance %s wait=%v want 6s", mode, now.Sub(time.Unix(0, 0)))
}
for _, command := range wireCommands(p) {
if command != "AP" {
t.Errorf("clearance issued %s, want AP only", command)
}
}
})
}
}
func TestWorkerAssumedClearanceAllowsOneFC7(t *testing.T) {
for _, prepare := range []bool{false, true} {
p := &scriptedTransport{}
dispatched := false
p.afterWrite = func() {
w := p.writes[len(p.writes)-1]
if len(w) <= 6 || w[0] != STX {
return
}
switch string(w[5 : len(w)-2]) {
case "AP":
if dispatched {
p.chunks = append(p.chunks, vendorACK, apReply(status(0x35)))
} else {
p.chunks = append(p.chunks, []byte{0x10, 0x06, 0x30})
}
case "FC7":
dispatched = true
p.chunks = append(p.chunks, vendorACK)
}
}
c, now := deliveryWorkerClient(t, p)
c.deliveryPending = true
c.deliveryStarted = c.now()
var err error
if prepare {
_, err = c.PrepareCurrentCard(context.Background())
} else {
err = c.BeginPrepareNextCard(context.Background())
}
if err != nil {
t.Fatalf("prepare=%t error=%v", prepare, err)
}
wantElapsed := deliveryClearanceTimeout
if prepare {
wantElapsed += sequenceUncertainWait
}
if elapsed := now.Sub(time.Unix(0, 0)); elapsed != wantElapsed {
t.Errorf("prepare=%t elapsed=%v want %v", prepare, elapsed, wantElapsed)
}
commands := wireCommands(p)
fc7 := 0
for _, cmd := range commands {
if cmd == "FC7" {
fc7++
}
if cmd == "RS" {
t.Errorf("unexpected RS: %v", commands)
}
}
if fc7 != 1 || c.deliveryPending {
t.Errorf("prepare=%t commands=%v pending=%t, want one FC7 and cleared", prepare, commands, c.deliveryPending)
}
if !prepare && commands[len(commands)-1] != "FC7" {
t.Errorf("prestaging polled after FC7: %v", commands)
}
}
}
+417
View File
@@ -0,0 +1,417 @@
package dispenser
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"os"
"testing"
"time"
)
// Golden frames reconstructed from K720_Dll.dll's big-endian length and XOR
// algorithm (SendCmd 0x100050C0, Query 0x10005280, SensorQuery 0x10005420).
var vendorFrames = []struct {
name string
command []byte
frame []byte
}{
{"AP", []byte{2, 'A', 'P'}, []byte{2, 0x30, 0x30, 0, 2, 0x41, 0x50, 3, 0x12}},
{"RF", []byte{2, 'R', 'F'}, []byte{2, 0x30, 0x30, 0, 2, 0x52, 0x46, 3, 0x17}},
{"FC7", commandFC7, []byte{2, 0x30, 0x30, 0, 3, 0x46, 0x43, 0x37, 3, 0x30}},
{"FC0", commandFC0, []byte{2, 0x30, 0x30, 0, 3, 0x46, 0x43, 0x30, 3, 0x37}},
{"RS", commandRS, []byte{2, 0x30, 0x30, 0, 2, 0x52, 0x53, 3, 2}},
}
func TestACKScannerFragmentation(t *testing.T) {
transportAddress(t)
for _, address := range []string{"00", "15"} {
Address = []byte(address)
wrong := []byte("15")
if address == "15" {
wrong = []byte("00")
}
for _, prefix := range [][]byte{nil, {0x30}, {0x10}, {address[1]}, {ACK, wrong[0], wrong[1], 0x30}, {NAK, wrong[0], wrong[1]}} {
for _, token := range []byte{ACK, NAK} {
wire := append(append([]byte(nil), prefix...), token, Address[0], Address[1])
for mask := 0; mask < 1<<(len(wire)-1); mask++ {
t.Run(fmt.Sprintf("%s/%X/%d", address, wire, mask), func(t *testing.T) {
p := &scriptedTransport{}
start := 0
for i := 1; i < len(wire); i++ {
if mask&(1<<(i-1)) != 0 {
p.chunks = append(p.chunks, wire[start:i])
start = i
}
}
p.chunks = append(p.chunks, wire[start:])
err := dispatchCommand(context.Background(), p, commandFC7, 0)
if (err != nil) != (token == NAK) {
t.Fatalf("dispatchCommand(% X)=%v", wire, err)
}
want := [][]byte{createPacket(Address, commandFC7)}
if token == ACK {
want = append(want, append([]byte{ENQ}, Address...))
}
if len(p.writes) != len(want) {
t.Fatalf("writes=% X want=% X", p.writes, want)
}
for i := range want {
if !bytes.Equal(p.writes[i], want[i]) {
t.Errorf("write=% X want=% X", p.writes[i], want[i])
}
}
if len(p.chunks) != 0 {
t.Errorf("unread token bytes=% X", p.chunks)
}
})
}
}
}
}
}
func TestACKScannerBoundsAndFollowingTransaction(t *testing.T) {
transportAddress(t)
for _, address := range []string{"00", "15"} {
Address = []byte(address)
ack := append([]byte{ACK}, Address...)
for _, leading := range []int{61, 62, 64} {
wire := append(bytes.Repeat([]byte{0xff}, leading), ack...)
p := &scriptedTransport{chunks: [][]byte{wire}}
err := dispatchCommand(context.Background(), p, commandRS, 0)
if (err == nil) != (leading == 61) {
t.Errorf("leading=%d error=%v", leading, err)
}
if leading != 61 && (len(p.writes) != 1 || len(bytes.Join(p.chunks, nil)) != len(wire)-64) {
t.Fatalf("scan exceeded bound: writes=% X remaining=% X", p.writes, p.chunks)
}
}
wire := append(append(append([]byte{0x10}, ack...), ack...), 0xfe)
p := &scriptedTransport{chunks: [][]byte{wire}}
for i := 0; i < 2; i++ {
if err := dispatchCommand(context.Background(), p, commandFC7, 0); err != nil {
t.Fatal(err)
}
}
if len(p.writes) != 4 || !bytes.Equal(bytes.Join(p.chunks, nil), []byte{0xfe}) {
t.Fatalf("transaction boundary lost: writes=% X remaining=% X", p.writes, p.chunks)
}
}
}
type ackReadErrorTransport struct {
*scriptedTransport
reads, failAt int
err error
}
func (p *ackReadErrorTransport) Read(b []byte) (int, error) {
p.reads++
n, err := p.scriptedTransport.Read(b)
if p.reads == p.failAt {
return n, p.err
}
return n, err
}
func TestACKScannerReadErrors(t *testing.T) {
transportAddress(t)
for _, address := range []string{"00", "15"} {
Address = []byte(address)
for _, token := range []byte{ACK, NAK} {
for _, readErr := range []error{io.EOF, os.ErrDeadlineExceeded, io.ErrClosedPipe} {
for _, failAt := range []int{1, 2} {
p := &ackReadErrorTransport{scriptedTransport: &scriptedTransport{chunks: [][]byte{{token, Address[0], Address[1]}}}, failAt: failAt, err: readErr}
err := dispatchCommand(context.Background(), p, commandFC7, 0)
if failAt == 1 && !errors.Is(err, readErr) {
t.Fatalf("incomplete token error=%v want=%v", err, readErr)
}
if failAt == 2 && ((err == nil) != (token == ACK) || errors.Is(err, readErr)) {
t.Fatalf("complete token %02X with read error returned %v", token, err)
}
wantWrites := 1
if failAt == 2 && token == ACK {
wantWrites = 2
}
if len(p.writes) != wantWrites || p.reads != failAt {
t.Fatalf("writes=%d reads=%d want=%d/%d", len(p.writes), p.reads, wantWrites, failAt)
}
}
}
}
for _, wire := range [][]byte{nil, {0x30, ACK, Address[0]}, {0xff, 0xfe}, {ACK, Address[0]}} {
p := &scriptedTransport{chunks: [][]byte{wire}}
if err := dispatchCommand(context.Background(), p, commandFC7, 0); err == nil || len(p.writes) != 1 {
t.Fatalf("incomplete/garbage % X: err=%v writes=% X", wire, err, p.writes)
}
}
for _, cancelAt := range []int{1, 2} {
ctx, cancel := context.WithCancel(context.Background())
p := &ackReadErrorTransport{scriptedTransport: &scriptedTransport{chunks: [][]byte{{ACK, Address[0], Address[1]}}}, failAt: 2, err: io.EOF}
p.afterRead = func() {
if p.reads == cancelAt {
cancel()
}
}
err := dispatchCommand(ctx, p, commandFC7, 0)
cancel()
if !errors.Is(err, context.Canceled) || len(p.writes) != 1 || p.reads != cancelAt {
t.Fatalf("cancel read %d: err=%v writes=%d reads=%d", cancelAt, err, len(p.writes), p.reads)
}
}
}
}
func TestVendorOutboundFrames(t *testing.T) {
for _, tc := range vendorFrames {
t.Run(tc.name, func(t *testing.T) {
if got := createPacket([]byte("00"), tc.command); !bytes.Equal(got, tc.frame) {
t.Errorf("createPacket(%s) = % X, want % X", tc.name, got, tc.frame)
}
if got := calculateBCC(tc.frame[:len(tc.frame)-1]); got != tc.frame[len(tc.frame)-1] {
t.Errorf("calculateBCC(%s) = %02X, want %02X", tc.name, got, tc.frame[len(tc.frame)-1])
}
})
}
}
type scriptedTransport struct {
chunks [][]byte
writes [][]byte
readErr error
writeErr error
shortWrite int
afterRead func()
afterWrite func()
}
func (p *scriptedTransport) Read(b []byte) (int, error) {
if len(p.chunks) == 0 {
if p.readErr != nil {
return 0, p.readErr
}
return 0, io.EOF
}
n := copy(b, p.chunks[0])
p.chunks[0] = p.chunks[0][n:]
if len(p.chunks[0]) == 0 {
p.chunks = p.chunks[1:]
}
if p.afterRead != nil {
p.afterRead()
}
return n, nil
}
func (p *scriptedTransport) Write(b []byte) (int, error) {
p.writes = append(p.writes, append([]byte(nil), b...))
if p.afterWrite != nil {
p.afterWrite()
}
if p.writeErr != nil {
return 0, p.writeErr
}
if p.shortWrite == len(p.writes) {
return len(b) - 1, nil
}
return len(b), nil
}
func transportAddress(t *testing.T) {
t.Helper()
old := Address
Address = []byte("00")
t.Cleanup(func() { Address = old })
}
// Independent SF response vectors: status is 30 30 30 [33].
var vendorAP = []byte{2, 0x30, 0x30, 0, 6, 'S', 'F', 0x30, 0x30, 0x30, 0x33, 3, 0x11}
var vendorRF = []byte{2, 0x30, 0x30, 0, 5, 'S', 'F', 0x30, 0x30, 0x30, 3, 0x21}
var vendorACK = []byte{6, 0x30, 0x30}
func TestVendorQueryFragmentation(t *testing.T) {
transportAddress(t)
for i, frame := range [][]byte{vendorAP, vendorRF} {
wire := append(append([]byte(nil), vendorACK...), frame...)
for split := 1; split < len(wire); split++ {
t.Run(fmt.Sprintf("%s/split%d", vendorFrames[i].name, split), func(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{wire[:split], wire[split:]}}
got, err := queryStatus(context.Background(), p, vendorFrames[i].command, 4-i, 0)
if err != nil || !bytes.Equal(got, frame[7:len(frame)-2]) {
t.Fatalf("queryStatus(split=%d) = % X, %v, want % X, nil", split, got, err, frame[7:len(frame)-2])
}
if len(p.writes) != 2 || !bytes.Equal(p.writes[0], vendorFrames[i].frame) || !bytes.Equal(p.writes[1], []byte{5, 0x30, 0x30}) {
t.Errorf("queryStatus writes = % X, want command then ENQ", p.writes)
}
})
}
t.Run(vendorFrames[i].name+"/one-byte", func(t *testing.T) {
p := &scriptedTransport{}
for _, b := range wire {
p.chunks = append(p.chunks, []byte{b})
}
if _, err := queryStatus(context.Background(), p, vendorFrames[i].command, 4-i, 0); err != nil {
t.Errorf("queryStatus(one-byte reads) = %v, want nil", err)
}
})
}
}
func TestVendorQueryRejectsInvalidFrames(t *testing.T) {
transportAddress(t)
for _, tc := range []struct {
name string
offset int
value byte
}{
{"STX", 0, 1}, {"address high", 1, '1'}, {"address low", 2, '1'},
{"zero length", 4, 0}, {"short length", 4, 5}, {"long length", 4, 7}, {"high length", 3, 0xff},
{"type S", 5, 'X'}, {"type F", 6, 'X'}, {"ETX", 11, 4}, {"BCC", 12, 0},
} {
t.Run(tc.name, func(t *testing.T) {
frame := append([]byte(nil), vendorAP...)
frame[tc.offset] = tc.value
// Keep checksum valid when testing type/ETX to isolate those checks.
if tc.offset == 5 || tc.offset == 6 || tc.offset == 11 {
frame[12] = 0
for _, b := range frame[:12] {
frame[12] ^= b
}
}
p := &scriptedTransport{chunks: [][]byte{vendorACK, frame}}
if got, err := queryStatus(context.Background(), p, vendorFrames[0].command, 4, 0); err == nil || got != nil {
t.Errorf("queryStatus(%s) = % X, %v, want nil/error", tc.name, got, err)
}
if len(p.writes) != 2 {
t.Errorf("queryStatus(%s) writes=%d, want 2 without resend", tc.name, len(p.writes))
}
})
}
for n := 0; n < len(vendorAP); n++ {
t.Run(fmt.Sprintf("truncated%d", n), func(t *testing.T) {
p := &scriptedTransport{chunks: [][]byte{vendorACK, vendorAP[:n]}}
if _, err := queryStatus(context.Background(), p, vendorFrames[0].command, 4, 0); err == nil {
t.Errorf("queryStatus(%d-byte frame) succeeded, want error", n)
}
})
}
}
func TestTransportACKAndMechanicalDispatch(t *testing.T) {
transportAddress(t)
for _, tc := range vendorFrames[2:] {
p := &scriptedTransport{chunks: [][]byte{{6}, {'0'}, {'0'}}}
if err := dispatchCommand(context.Background(), p, tc.command, 0); err != nil {
t.Fatalf("dispatchCommand(%s)=%v, want nil", tc.name, err)
}
if len(p.writes) != 2 || !bytes.Equal(p.writes[0], tc.frame) || !bytes.Equal(p.writes[1], []byte{5, '0', '0'}) {
t.Errorf("dispatchCommand(%s) writes=% X, want command then ENQ", tc.name, p.writes)
}
}
for _, ack := range [][]byte{{0x15, '0', '0'}, {6, '1', '0'}, {6, '0', '1'}, {6}, {6, '0'}, {}} {
p := &scriptedTransport{chunks: [][]byte{ack}}
if err := dispatchCommand(context.Background(), p, commandFC7, 0); err == nil {
t.Errorf("dispatchCommand(ACK=% X) succeeded, want error", ack)
}
if len(p.writes) != 1 {
t.Errorf("dispatchCommand(ACK=% X) writes=%d, want 1", ack, len(p.writes))
}
}
}
func TestTransportShortWritesAndErrors(t *testing.T) {
transportAddress(t)
failure := errors.New("serial failure")
for _, stage := range []int{1, 2} {
p := &scriptedTransport{chunks: [][]byte{vendorACK}, shortWrite: stage}
if err := dispatchCommand(context.Background(), p, commandFC7, 0); !errors.Is(err, io.ErrShortWrite) {
t.Errorf("dispatchCommand(short write %d)=%v, want ErrShortWrite", stage, err)
}
if len(p.writes) != stage {
t.Errorf("short write %d writes=%d, want %d", stage, len(p.writes), stage)
}
}
for _, p := range []*scriptedTransport{{writeErr: failure}, {readErr: failure}, {chunks: [][]byte{{}}}} {
if err := dispatchCommand(context.Background(), p, commandRS, 0); err == nil {
t.Error("dispatchCommand(I/O failure) succeeded, want error")
}
if len(p.writes) != 1 {
t.Errorf("dispatchCommand(I/O failure) writes=%d, want 1", len(p.writes))
}
}
}
func TestTransportCancellation(t *testing.T) {
transportAddress(t)
for _, stage := range []string{"before write", "processing wait", "after ACK", "after ENQ", "after header"} {
t.Run(stage, func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
p := &scriptedTransport{chunks: [][]byte{vendorACK, vendorAP}}
wantWrites := 1
switch stage {
case "before write":
cancel()
wantWrites = 0
case "processing wait":
p.afterWrite = cancel
case "after ACK":
p.afterRead = func() {
if len(p.chunks) == 1 {
cancel()
}
}
case "after ENQ":
wantWrites = 2
p.afterWrite = func() {
if len(p.writes) == 2 {
cancel()
}
}
case "after header":
wantWrites = 2
reads := 0
p.afterRead = func() {
reads++
if reads == 3 {
cancel()
}
}
}
if _, err := queryStatus(ctx, p, vendorFrames[0].command, 4, 0); !errors.Is(err, context.Canceled) {
t.Errorf("queryStatus(cancel %s)=%v, want Canceled", stage, err)
}
if len(p.writes) != wantWrites {
t.Errorf("queryStatus(cancel %s) writes=%d, want %d", stage, len(p.writes), wantWrites)
}
})
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
defer cancel()
p := &scriptedTransport{}
if err := dispatchCommand(ctx, p, commandRS, time.Second); !errors.Is(err, context.DeadlineExceeded) {
t.Errorf("dispatchCommand(deadline in wait)=%v, want DeadlineExceeded", err)
}
if len(p.writes) != 1 {
t.Errorf("dispatchCommand(deadline) writes=%d, want 1", len(p.writes))
}
}
func TestTransportTrailingDataNotConsumedAsStatus(t *testing.T) {
transportAddress(t)
frame := append(append([]byte(nil), vendorAP...), 0xff, 0xfe, 0xfd)
p := &scriptedTransport{chunks: [][]byte{vendorACK, frame}}
if _, err := queryStatus(context.Background(), p, vendorFrames[0].command, 4, 0); err != nil {
t.Fatalf("queryStatus(frame with trailing bytes)=%v, want nil", err)
}
if len(p.chunks) != 1 || !bytes.Equal(p.chunks[0], []byte{0xff, 0xfe, 0xfd}) {
t.Fatalf("remaining bytes=% X, want FF FE FD", p.chunks)
}
if err := dispatchCommand(context.Background(), p, commandFC7, 0); err == nil {
t.Error("dispatchCommand(trailing garbage) succeeded, want invalid ACK")
}
if len(p.writes) != 3 {
t.Errorf("writes after trailing garbage=%d, want 3 (no ENQ/resend)", len(p.writes))
}
}
+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)
}
})
}
}
+75
View File
@@ -0,0 +1,75 @@
package handlers
import (
"context"
"net/http"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
log "github.com/sirupsen/logrus"
)
func (app *App) preauthPayment(w http.ResponseWriter, r *http.Request) {
app.streamPayment(w, r, true)
}
// executeCreditCallPreauth finalizes the existing unconfirmed transaction.
// The outcome container and its wire projections are shared with SALE; its execution is not.
func (app *App) executeCreditCallPreauth(ctx context.Context, request cmstypes.TransactionRec,
start func(*http.Client) (creditcall.TransactionResultXML, error)) creditCallSaleOutcome {
const op = logging.Op("takePreauthorization")
entry := log.WithFields(log.Fields{
"operation": "preauth", "hotel": app.cfg.Hotel, "kiosk": app.cfg.Kiosk,
"requestedType": request.TransactionType, "requestedAmount": request.AmountMinorUnits,
})
entry.Info("CreditCall PREAUTH started")
outcome := creditCallSaleOutcome{
HTTPStatus: http.StatusBadGateway,
Status: cmstypes.StatusRec{Code: http.StatusInternalServerError, Message: "500 Internal server error"},
}
transaction, err := start(app.creditCallClient())
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Preauth processing error", string(op), "", "", 0)
entry.Error("CreditCall PREAUTH ended without a processor result")
outcome.FailureType = types.ResultError
outcome.FailureDescription = "No response from payment processor"
return outcome
}
var result creditcall.PaymentResult
result.FillFromTransactionResult(transaction)
entry = entry.WithFields(log.Fields{
"reference": result.Fields[types.Reference],
"transactionResult": result.Fields[types.TransactionResult],
"transactionType": result.Fields[types.TransactionType],
"totalAmount": result.Fields[types.TotalAmount],
"receiptPresent": result.CardholderReceipt != "",
})
entry.Info("CreditCall PREAUTH processor result received")
if result.Fields[types.TransactionType] == "" {
entry.Warn("CreditCall PREAUTH result has no TRANSACTION_TYPE")
}
app.printCreditCallReceipt(result.CardholderReceipt)
approved, persist := creditcall.PreauthDecision(result.Fields)
decision := entry.WithFields(log.Fields{"approved": approved, "persist": persist})
if approved {
decision.Info("CreditCall PREAUTH decision")
} else {
decision.Warn("CreditCall PREAUTH decision")
}
outcome.HTTPStatus = http.StatusOK
outcome.Status = result.Status
outcome.Payment = result
outcome.Approved = approved
outcome.FailureType = result.Fields[types.TransactionResult]
outcome.FailureDescription = result.Fields[types.Errors]
if persist {
if result.Fields[types.TotalAmount] == "" {
entry.Warn("CreditCall PREAUTH persistence requested without TOTAL_AMOUNT")
}
entry.Info("CreditCall PREAUTH persistence scheduled")
go app.persistPreauth(ctx, result.Fields, request.CheckoutDate)
}
return outcome
}
@@ -0,0 +1,144 @@
package handlers
import (
"context"
"errors"
"net/http"
"os"
"path/filepath"
"testing"
"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/types"
log "github.com/sirupsen/logrus"
logtest "github.com/sirupsen/logrus/hooks/test"
)
func capturePreauthLogs(t *testing.T) *logtest.Hook {
t.Helper()
logger := log.StandardLogger()
previousHooks := logger.ReplaceHooks(make(log.LevelHooks))
previousLevel := logger.GetLevel()
logger.SetLevel(log.InfoLevel)
hook := logtest.NewGlobal()
t.Cleanup(func() {
logger.ReplaceHooks(previousHooks)
logger.SetLevel(previousLevel)
})
return hook
}
func requirePreauthLog(t *testing.T, hook *logtest.Hook, message string, level log.Level) *log.Entry {
t.Helper()
for _, entry := range hook.AllEntries() {
if entry.Message == message {
if entry.Level != level {
t.Errorf("log %q level=%v, want %v", message, entry.Level, level)
}
return entry
}
}
t.Fatalf("missing log %q", message)
return nil
}
func TestCreditCallPreauthDecisionLogging(t *testing.T) {
for _, tc := range []struct {
name, result, kind string
approved bool
level log.Level
}{
{"verification", "APPROVED", "ACCOUNT VERIFICATION", true, log.InfoLevel},
{"missing type", "APPROVED", "", false, log.WarnLevel},
{"declined", "DECLINED", "SALE", false, log.WarnLevel},
} {
t.Run(tc.name, func(t *testing.T) {
hook := capturePreauthLogs(t)
app := &App{cfg: &config.ConfigRec{}, creditCallReceipt: func(string) {}}
outcome := app.executeCreditCallPreauth(context.Background(), cmstypes.TransactionRec{TransactionType: "AccountVerification"},
func(*http.Client) (creditcall.TransactionResultXML, error) {
return creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{
{Key: types.TransactionResult, Value: tc.result},
{Key: types.TransactionType, Value: tc.kind},
{Key: types.Reference, Value: "log-test-ref"},
{Key: types.PanMasked, Value: "sensitive-card-sentinel"},
{Key: types.CardHash, Value: "sensitive-hash-sentinel"},
{Key: types.ReceiptDataCardholder, Value: "sensitive-receipt-sentinel"},
}}, nil
})
if outcome.Approved != tc.approved {
t.Errorf("approved=%t, want %t", outcome.Approved, tc.approved)
}
requirePreauthLog(t, hook, "CreditCall PREAUTH started", log.InfoLevel)
provider := requirePreauthLog(t, hook, "CreditCall PREAUTH processor result received", log.InfoLevel)
if provider.Data["transactionType"] != tc.kind || provider.Data["transactionResult"] != tc.result || provider.Data["receiptPresent"] != true {
t.Errorf("provider log=%v, want type=%q result=%q receiptPresent=true", provider.Data, tc.kind, tc.result)
}
decision := requirePreauthLog(t, hook, "CreditCall PREAUTH decision", tc.level)
if decision.Data["approved"] != tc.approved || decision.Data["persist"] != false || decision.Data["reference"] != "log-test-ref" {
t.Errorf("decision log=%v, want approved=%t persist=false reference=log-test-ref", decision.Data, tc.approved)
}
if tc.kind == "" {
requirePreauthLog(t, hook, "CreditCall PREAUTH result has no TRANSACTION_TYPE", log.WarnLevel)
}
for _, entry := range hook.AllEntries() {
for key, value := range entry.Data {
if value == "sensitive-card-sentinel" || value == "sensitive-hash-sentinel" || value == "sensitive-receipt-sentinel" {
t.Errorf("log %q exposed sensitive field %q", entry.Message, key)
}
}
if entry.Message == "CreditCall PREAUTH persistence scheduled" {
t.Error("non-persisting result logged persistence scheduling")
}
}
})
}
}
func TestCreditCallPreauthStartFailureLogging(t *testing.T) {
hook := capturePreauthLogs(t)
app := &App{cfg: &config.ConfigRec{}}
outcome := app.executeCreditCallPreauth(context.Background(), cmstypes.TransactionRec{},
func(*http.Client) (creditcall.TransactionResultXML, error) {
return creditcall.TransactionResultXML{}, errors.New("test transport failure")
})
if outcome.HTTPStatus != http.StatusBadGateway {
t.Errorf("HTTPStatus=%d, want 502", outcome.HTTPStatus)
}
requirePreauthLog(t, hook, "CreditCall PREAUTH started", log.InfoLevel)
requirePreauthLog(t, hook, "CreditCall PREAUTH ended without a processor result", log.ErrorLevel)
}
func TestCreditCallPreauthPersistenceLogging(t *testing.T) {
for _, tc := range []struct {
name, amount, message string
level log.Level
breakSpool bool
}{
{"SQL", "3100", "CreditCall PREAUTH SQL persistence completed", log.InfoLevel, false},
{"spool", "", "CreditCall PREAUTH saved to spool; SQL persistence pending", log.WarnLevel, false},
{"spool failure", "", "failed to spool preauth", log.ErrorLevel, true},
} {
t.Run(tc.name, func(t *testing.T) {
hook := capturePreauthLogs(t)
app := &App{cfg: &config.ConfigRec{}}
preauthTestDatabase(t, app)
if tc.breakSpool {
path := filepath.Join(app.cfg.LogDir, "not-a-directory")
if err := os.WriteFile(path, nil, 0600); err != nil {
t.Fatal(err)
}
app.cfg.LogDir = path
}
app.persistPreauth(context.Background(), map[string]string{
types.Reference: "persist-test-ref", types.TotalAmount: tc.amount,
}, "2026-10-21 00:00:00 +0000")
entry := requirePreauthLog(t, hook, tc.message, tc.level)
if entry.Data["reference"] != "persist-test-ref" || entry.Data["operation"] != "preauth" {
t.Errorf("persistence log=%v, want reference=persist-test-ref operation=preauth", entry.Data)
}
})
}
}
@@ -0,0 +1,402 @@
package handlers
import (
"context"
"database/sql"
"database/sql/driver"
"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"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
)
type preauthTestConnector struct {
inserts chan []driver.NamedValue
count atomic.Int32
}
func (c *preauthTestConnector) Connect(context.Context) (driver.Conn, error) {
return &preauthTestConn{c}, nil
}
func (c *preauthTestConnector) Driver() driver.Driver { return preauthTestDriver{c} }
type preauthTestDriver struct{ c *preauthTestConnector }
func (d preauthTestDriver) Open(string) (driver.Conn, error) { return &preauthTestConn{d.c}, nil }
type preauthTestConn struct{ c *preauthTestConnector }
func (*preauthTestConn) Prepare(string) (driver.Stmt, error) {
return nil, errors.New("unexpected prepare")
}
func (*preauthTestConn) Close() error { return nil }
func (*preauthTestConn) Begin() (driver.Tx, error) { return nil, errors.New("unexpected begin") }
func (*preauthTestConn) Ping(context.Context) error { return nil }
func (c *preauthTestConn) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
if ctx.Err() != nil {
return nil, ctx.Err()
}
if !strings.Contains(query, "INSERT INTO dbo.Preauthorizations") {
return nil, errors.New("unexpected SQL")
}
c.c.count.Add(1)
c.c.inserts <- append([]driver.NamedValue(nil), args...)
return driver.RowsAffected(1), nil
}
func preauthTestDatabase(t *testing.T, app *App) *preauthTestConnector {
t.Helper()
c := &preauthTestConnector{inserts: make(chan []driver.NamedValue, 4)}
app.db = sql.OpenDB(c)
app.cfg.LogDir = t.TempDir()
t.Cleanup(func() { app.db.Close() })
return c
}
func waitPreauthInsert(t *testing.T, c *preauthTestConnector) map[string]any {
t.Helper()
select {
case args := <-c.inserts:
result := map[string]any{}
for _, arg := range args {
result[arg.Name] = arg.Value
}
return result
case <-time.After(3 * time.Second):
t.Fatal("preauth persistence did not reach SQL")
}
return nil
}
func preauthLegacyRequest(amount, kind, checkout string) *http.Request {
body, _ := xml.Marshal(cmstypes.TransactionRec{AmountMinorUnits: amount, TransactionType: kind, CheckoutDate: checkout})
r := httptest.NewRequest(http.MethodPost, "/takepreauth", strings.NewReader(string(body)))
r.Header.Set("Content-Type", "text/xml")
return r
}
func TestCreditCallPreauthLegacyCharacterization(t *testing.T) {
for _, tc := range []struct {
name, amount, requestType, result, resultType, total string
save, approved bool
}{
{"positive", "12000", "Sale", "APPROVED", "SALE", "3100", true, true},
{"declined", "12000", "Sale", "DECLINED", "SALE", "", false, false},
{"verification", "", "AccountVerification", "APPROVED", "ACCOUNT VERIFICATION", "", false, true},
{"verification failure", "", "AccountVerification", "DECLINED", "ACCOUNT VERIFICATION", "", false, false},
{"unexpected type", "12000", "Sale", "APPROVED", "Refund", "", false, false},
} {
t.Run(tc.name, func(t *testing.T) {
var starts, prints int
checkout := ""
if tc.amount != "" {
checkout = "2026-09-11 00:00:00 +0000"
}
fields := map[string]string{types.TransactionResult: tc.result, types.TransactionType: tc.resultType, types.Reference: "preauth-ref", types.PanMasked: "************1133", types.CardType: "Visa", types.ExpiryDate: "1228", types.CardHash: "card-hash", types.CardReference: "card-reference", types.ReceiptDataCardholder: "receipt"}
if tc.total != "" {
fields[types.TotalAmount] = tc.total
}
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
starts++
if r.URL.Path != "/start-transaction/" {
t.Errorf("PREAUTH upstream path=%s, want start only", r.URL.Path)
}
var input cmstypes.TransactionRec
if err := xml.NewDecoder(r.Body).Decode(&input); err != nil {
t.Error(err)
}
if input.AmountMinorUnits != tc.amount || input.TransactionType != tc.requestType || input.CheckoutDate != checkout {
t.Errorf("PREAUTH input=%+v, want amount=%q type=%q checkout=%q", input, tc.amount, tc.requestType, checkout)
}
// Legacy ignores upstream HTTP status when XML contains a result.
w.WriteHeader(http.StatusBadGateway)
io.WriteString(w, chipDNAFixture(t, fields))
})
c := preauthTestDatabase(t, app)
app.creditCallReceipt = func(receipt string) {
prints++
if receipt != "receipt" {
t.Errorf("receipt=%q, want receipt", receipt)
}
}
recorder := httptest.NewRecorder()
app.takePreauthorization(recorder, preauthLegacyRequest(tc.amount, tc.requestType, checkout))
var response cmstypes.ResponseRec
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatal(err)
}
if recorder.Code != 200 || response.Status.Code != 200 || starts != 1 || prints != 1 || strings.HasPrefix(response.Data, "/successful?") != tc.approved {
t.Errorf("PREAUTH response=%+v HTTP=%d starts=%d prints=%d, want approved=%t one start/receipt", response, recorder.Code, starts, prints, tc.approved)
}
if tc.save {
got := waitPreauthInsert(t, c)
if got["TotalMinorUnits"] != "3100" || got["TxnReference"] != "preauth-ref" {
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(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")
}
})
}
}
func preauthStreamRequest(amount, kind, checkout string) *http.Request {
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
}
func TestCreditCallPreauthStreamingParity(t *testing.T) {
for _, tc := range []struct {
name, result, kind, total string
approved, persist bool
}{
{"monetary", "APPROVED", "SALE", "3100", true, true},
{"verification", "APPROVED", "ACCOUNT VERIFICATION", "", true, false},
{"declined", "DECLINED", "SALE", "", false, false},
{"verification failed", "DECLINED", "ACCOUNT VERIFICATION", "", false, false},
{"unknown approved type", "APPROVED", "AccountVerification", "", false, false},
} {
t.Run(tc.name, func(t *testing.T) {
fields := map[string]string{types.TransactionResult: tc.result, types.TransactionType: tc.kind, types.Reference: "preauth-ref", types.PanMasked: "************1133", types.CardType: "Visa", types.ExpiryDate: "1228", types.CardHash: "hash", types.CardReference: "cardref", types.ReceiptDataCardholder: "receipt"}
if tc.total != "" {
fields[types.TotalAmount] = tc.total
}
amount, kind, date := "12000", "Sale", "2026-09-11 00:00:00 +0000"
if strings.Contains(tc.name, "verification") {
amount, kind, date = "", "AccountVerification", ""
}
var legacy cmstypes.ResponseRec
for _, stream := range []bool{false, true} {
calls, prints := 0, 0
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
calls++
if stream {
if r.URL.Path != "/start-transaction-stream/" {
t.Errorf("stream called %s, want one generic start", r.URL.Path)
}
var input creditCallPreauthRequest
if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
t.Error(err)
}
if input.Amount != amount || input.TransactionType != kind {
t.Errorf("upstream input=%+v, want %q/%q", input, amount, kind)
}
for _, event := range []struct{ source, value string }{{"UPDATE", "CardRequested"}, {"CARD_STATUS", "Inserted"}, {"UPDATE", "CardRemovalRequested"}, {"CARD_STATUS", "Removed"}, {"UPDATE", "CardRequested"}, {"UPDATE", "CardRemovalEnforced"}, {"UPDATE", "PinEntryStarted"}, {"UPDATE", "OnlineAuthCompleted"}} {
json.NewEncoder(w).Encode(map[string]any{"type": "status", "source": event.source, "value": event.value})
}
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
} else {
io.WriteString(w, chipDNAFixture(t, fields))
}
})
c := preauthTestDatabase(t, app)
app.creditCallReceipt = func(receipt string) {
prints++
if receipt != "receipt" {
t.Errorf("receipt=%q, want retained receipt", receipt)
}
}
recorder := httptest.NewRecorder()
if stream {
app.preauthPayment(recorder, preauthStreamRequest(amount, kind, date))
frames := decodePaymentStream(t, recorder.Body)
var statuses []string
for _, frame := range frames {
if frame.Type == "status" {
statuses = append(statuses, frame.Code)
}
}
want := []string{paymentstatus.PresentCard, paymentstatus.DoNotRemoveCard, paymentstatus.RemoveCard, paymentstatus.PresentCard, paymentstatus.RemoveCard, paymentstatus.EnterPIN, paymentstatus.PleaseWait}
if !reflect.DeepEqual(statuses, want) {
t.Errorf("preauth statuses=%v, want %v", statuses, want)
}
final := frames[len(frames)-1].Result
if final == nil {
t.Fatal("missing structured final")
}
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") {
t.Errorf("preauth fields lost: %+v", final)
}
if len(frames) != len(want)+1 {
t.Errorf("frames=%d, want one final", len(frames))
}
} else {
app.takePreauthorization(recorder, preauthLegacyRequest(amount, kind, date))
if err := json.Unmarshal(recorder.Body.Bytes(), &legacy); err != nil {
t.Fatal(err)
}
}
if calls != 1 || prints != 1 {
t.Errorf("calls/prints=%d/%d, want 1/1", calls, prints)
}
if tc.persist {
got := waitPreauthInsert(t, c)
if got["TotalMinorUnits"] != tc.total {
t.Errorf("SQL amount=%v, want provider %q", got["TotalMinorUnits"], tc.total)
}
} else if c.count.Load() != 0 {
t.Error("verification/failure persisted")
}
}
})
}
}
func TestCreditCallInboundCancellationAfterDispatch(t *testing.T) {
for _, preauth := range []bool{false, true} {
t.Run(map[bool]string{false: "sale", true: "preauth"}[preauth], func(t *testing.T) {
dispatched := make(chan struct{})
release := make(chan struct{})
var starts, confirms, receipts atomic.Int32
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/confirm-transaction/" {
confirms.Add(1)
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "APPROVED", types.ReceiptDataCardholder: "receipt"}))
return
}
starts.Add(1)
close(dispatched)
<-release
if r.Context().Err() != nil {
t.Errorf("financial upstream was cancelled: %v", r.Context().Err())
return
}
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": map[string]string{types.TransactionResult: "APPROVED", types.TransactionType: "SALE", types.TotalAmount: "3100", types.Reference: "delayed-ref", types.ReceiptDataCardholder: "receipt"}})
})
c := preauthTestDatabase(t, app)
app.creditCallReceipt = func(receipt string) {
if receipt != "receipt" {
t.Errorf("receipt=%q", receipt)
}
receipts.Add(1)
}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
recorder := httptest.NewRecorder()
done := make(chan struct{})
go func() {
defer close(done)
if preauth {
app.preauthPayment(recorder, preauthStreamRequest("12000", "Sale", "2026-09-11 00:00:00 +0000").WithContext(ctx))
} else {
app.salePayment(recorder, saleRequest(true).WithContext(ctx))
}
}()
select {
case <-dispatched:
case <-time.After(3 * time.Second):
close(release)
t.Fatal("no upstream dispatch")
}
cancel() // Exact acceptance boundary: upstream has observed StartTransaction.
close(release)
select {
case <-done:
case <-time.After(3 * time.Second):
t.Fatal("cancelled inbound request stopped finalization")
}
wantConfirms := int32(1)
if preauth {
wantConfirms = 0
got := waitPreauthInsert(t, c)
if got["TotalMinorUnits"] != "3100" {
t.Errorf("delayed persistence=%v", got)
}
if c.count.Load() != 1 {
t.Errorf("delayed persistence count=%d, want exactly one", c.count.Load())
}
}
if starts.Load() != 1 || receipts.Load() != 1 || confirms.Load() != wantConfirms {
t.Errorf("starts/receipts/confirms=%d/%d/%d, want 1/1/%d", starts.Load(), receipts.Load(), confirms.Load(), wantConfirms)
}
if recorder.Body.Len() != 0 {
t.Errorf("cancelled delivery wrote %s", recorder.Body.String())
}
})
}
}
func TestCreditCallPreauthMissingAmountNeverSynthesized(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.Reference: "missing-amount"}})
})
c := preauthTestDatabase(t, app)
app.creditCallReceipt = func(string) {}
recorder := httptest.NewRecorder()
app.preauthPayment(recorder, preauthStreamRequest("9999", "Sale", "2026-09-11 00:00:00 +0000"))
frames := decodePaymentStream(t, recorder.Body)
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)
for {
data, err := os.ReadFile(app.spoolPath())
var record preauthSpoolRecord
if err == nil && json.Unmarshal(data, &record) == nil {
if _, ok := record.Fields[types.TotalAmount]; ok {
t.Errorf("spool fabricated amount: %v", record.Fields)
}
if record.CheckoutDate != "2026-09-11 00:00:00 +0000" {
t.Errorf("spool checkout=%q", record.CheckoutDate)
}
break
}
if time.Now().After(deadline) {
t.Fatal("missing provider amount did not retain existing spool fallback")
}
time.Sleep(time.Millisecond)
}
if c.count.Load() != 0 {
t.Error("SQL inserted fabricated amount")
}
}
func TestCreditCallPreauthStreamFailureAndCancelledBeforeDispatch(t *testing.T) {
for _, body := range []string{"", "{", "{}\n", "<xml/>\n", "{\"type\":\"result\",\"result\":{}}\n", "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"APPROVED\"}}"} {
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, body) })
calls := 0
transport := app.creditCallTransport
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.preauthPayment(recorder, preauthStreamRequest("", "AccountVerification", ""))
frames := decodePaymentStream(t, recorder.Body)
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.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
}
+130
View File
@@ -0,0 +1,130 @@
package handlers
import (
"net/http"
"strings"
"time"
"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/printer"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/logging"
log "github.com/sirupsen/logrus"
)
// creditCallSaleOutcome is the transaction outcome before either wire format is applied.
type creditCallSaleOutcome struct {
HTTPStatus int
Status cmstypes.StatusRec
Payment creditcall.PaymentResult
Approved bool
FailureType string
FailureDescription string
}
func (app *App) creditCallClient() *http.Client {
// Each start/confirm call gets the original independent timeout. In particular,
// neither a kiosk disconnect nor a whole-sale deadline bounds confirmation.
return &http.Client{Timeout: 300 * time.Second, Transport: app.creditCallTransport}
}
func (app *App) printCreditCallReceipt(receipt string) {
if app.creditCallReceipt != nil {
app.creditCallReceipt(receipt)
return
}
printer.PrintReceipt(receipt)
}
func (app *App) executeCreditCallSale(
request cmstypes.TransactionRec,
start func(*http.Client) (creditcall.TransactionResultXML, error),
) creditCallSaleOutcome {
const op = logging.Op("takePayment")
outcome := creditCallSaleOutcome{
HTTPStatus: http.StatusBadGateway,
Status: cmstypes.StatusRec{Code: http.StatusInternalServerError, Message: "500 Internal server error"},
}
client := app.creditCallClient()
trResult, err := start(client)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Start transaction error", string(op), "", "", 0)
outcome.FailureType = types.ResultError
outcome.FailureDescription = "No response from payment processor"
return outcome
}
var result creditcall.PaymentResult
result.FillFromTransactionResult(trResult)
res := result.Fields[types.TransactionResult]
if !strings.EqualFold(res, types.ResultApproved) {
app.printCreditCallReceipt(result.CardholderReceipt)
desc := result.Fields[types.ErrorDescription]
if desc == "" {
desc = result.Fields[types.Errors]
}
logging.Error(types.ServiceName, "Preauthorization failed", "Result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
outcome.HTTPStatus = http.StatusOK
outcome.Status = result.Status
outcome.Payment = result
outcome.FailureType = res
outcome.FailureDescription = result.Fields[types.Errors]
return outcome
}
ref := result.Fields[types.Reference]
log.Printf("Preauth approved, reference: %s. Sending confirm...", ref)
body, err := confirmWithRetry(client, creditcall.ConfirmTransactionRequest{
Amount: request.AmountMinorUnits, Reference: ref,
}, 2)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Confirm transaction error", string(op), "", "", 0)
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Error: "+err.Error())
outcome.FailureType = types.ResultError
outcome.FailureDescription = "ConfirmTransactionError"
return outcome
}
// Intentionally reuse both records: XML appends confirmation entries, and
// missing confirmation fields/receipts retain their existing legacy behavior.
if err := trResult.ParseTransactionResult(body); err != nil {
logging.Error(types.ServiceName, err.Error(), "Parse confirm result error", string(op), "", "", 0)
}
result.FillFromTransactionResult(trResult)
res = result.Fields[types.TransactionResult]
if !strings.EqualFold(res, types.ResultApproved) {
app.printCreditCallReceipt(result.CardholderReceipt)
desc := result.Fields[types.ErrorDescription]
if desc == "" {
desc = result.Fields[types.Errors]
}
logging.Error(types.ServiceName, "Transaction not approved after confirm", "Confirm result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Confirm result: "+res+" Description: "+desc)
outcome.HTTPStatus = http.StatusOK
outcome.Status = result.Status
outcome.Payment = result
outcome.FailureType = res
outcome.FailureDescription = result.Fields[types.Errors]
return outcome
}
app.printCreditCallReceipt(result.CardholderReceipt)
log.Printf("Transaction approved and confirmed, reference: %s", ref)
outcome.HTTPStatus = http.StatusOK
outcome.Status = result.Status
outcome.Payment = result
outcome.Approved = true
return outcome
}
func (outcome creditCallSaleOutcome) legacyResponse() cmstypes.ResponseRec {
response := cmstypes.ResponseRec{Status: outcome.Status}
if outcome.Approved {
response.Data = creditcall.BuildSuccessURL(outcome.Payment.Fields)
} else {
response.Data = creditcall.BuildFailureURL(outcome.FailureType, outcome.FailureDescription)
}
return response
}
+481
View File
@@ -0,0 +1,481 @@
package handlers
import (
"bytes"
"context"
"encoding/json"
"encoding/xml"
"errors"
"io"
"net/http"
"net/http/httptest"
"net/url"
"reflect"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"gitea.futuresens.co.uk/futuresens/cmstypes"
"gitea.futuresens.co.uk/futuresens/hardlink/config"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/creditcall"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
"gitea.futuresens.co.uk/futuresens/hardlink/paymentstatus"
)
type failedCreditCallBody struct{ closed *bool }
func (b failedCreditCallBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF }
func (b failedCreditCallBody) Close() error { *b.closed = true; return nil }
func TestCreditCallConfirmationReadFailureAndHTTPStatus(t *testing.T) {
for _, failFirstRead := range []bool{false, true} {
calls, receipts, firstClosed := 0, 0, false
app := &App{cfg: &config.ConfigRec{}, creditCallReceipt: func(string) { receipts++ }}
app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
calls++
if r.URL.Path != "/confirm-transaction/" {
t.Errorf("confirmation path=%s", r.URL.Path)
}
deadline, ok := r.Context().Deadline()
if !ok || time.Until(deadline) < 299*time.Second {
t.Errorf("confirmation call has no fresh 300-second deadline: %v", deadline)
}
var body io.ReadCloser = io.NopCloser(strings.NewReader(chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved"})))
if failFirstRead && calls == 1 {
body = failedCreditCallBody{closed: &firstClosed}
}
// Legacy confirmation ignores HTTP status when the body can be read.
return &http.Response{StatusCode: http.StatusServiceUnavailable, Body: body}, nil
})
outcome := app.executeCreditCallSale(cmstypes.TransactionRec{AmountMinorUnits: "1234"}, func(*http.Client) (creditcall.TransactionResultXML, error) {
return creditcall.TransactionResultXML{Entries: []creditcall.EntryXML{{Key: types.TransactionResult, Value: "Approved"}, {Key: types.Reference, Value: "ref"}}}, nil
})
wantCalls := 1
if failFirstRead {
wantCalls = 2
}
if calls != wantCalls || receipts != 1 || !outcome.Approved || (failFirstRead && !firstClosed) {
t.Errorf("readFailure=%v calls/receipts/approved/closed=%d/%d/%v/%v", failFirstRead, calls, receipts, outcome.Approved, firstClosed)
}
}
}
func TestCreditCallStreamFailureNeverRestartsOrConfirms(t *testing.T) {
calls := 0
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
calls++
if r.URL.Path != "/start-transaction-stream/" {
t.Errorf("unexpected fallback/confirmation %s", r.URL.Path)
}
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n{partial")
})
app.creditCallReceipt = func(string) { t.Error("invalid upstream stream printed receipt") }
recorder := httptest.NewRecorder()
app.salePayment(recorder, saleRequest(true))
frames := decodePaymentStream(t, recorder.Body)
if calls != 1 || len(frames) != 2 || frames[1].Result == nil || frames[1].Result.Outcome != "unknown" || frames[1].Result.HTTPStatus != 502 {
t.Errorf("malformed stream calls=%d frames=%+v", calls, frames)
}
}
func TestCreditCallStructuredFieldsExcludeRawData(t *testing.T) {
result := (creditCallSaleOutcome{Approved: true, Payment: creditcall.PaymentResult{Fields: map[string]string{
types.Reference: "ref", types.PanMasked: "1234567890123456", types.CardHash: "hash", types.CardReference: "card-ref",
"PAN": "pan-secret", "CVV": "cvv-secret", "PIN": "pin-secret", "TRACK_DATA": "track-secret", types.ReceiptDataCardholder: "receipt-secret",
}}}).streamResult()
body, err := json.Marshal(result)
if err != nil {
t.Fatal(err)
}
for _, forbidden := range []string{"1234567890123456", "pan-secret", "cvv-secret", "pin-secret", "track-secret", "receipt-secret", "/successful", "/unsuccessful"} {
if bytes.Contains(body, []byte(forbidden)) {
t.Errorf("structured result exposed %q", forbidden)
}
}
if result.CardHash != "hash" || result.CardReference != "card-ref" || result.TransactionReference != "ref" {
t.Errorf("required identifiers missing: %+v", result)
}
}
type blockedPaymentWriter struct {
*httptest.ResponseRecorder
started chan struct{}
release chan struct{}
once sync.Once
}
func (w *blockedPaymentWriter) Write(data []byte) (int, error) {
w.once.Do(func() { close(w.started) })
<-w.release
return w.ResponseRecorder.Write(data)
}
func TestCreditCallBackpressureCannotBlockFinalizationOrLoseFinal(t *testing.T) {
nativeRelease, receiptPrinted := make(chan struct{}), make(chan struct{})
var nativeOnce, deliveryOnce sync.Once
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/confirm-transaction/" {
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved"}))
return
}
line := "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n"
io.WriteString(w, line)
w.(http.Flusher).Flush()
<-nativeRelease
for i := 0; i < 1000; i++ {
io.WriteString(w, line)
}
io.WriteString(w, "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"ref\"}}\n")
})
app.creditCallReceipt = func(string) { close(receiptPrinted) }
writer := &blockedPaymentWriter{ResponseRecorder: httptest.NewRecorder(), started: make(chan struct{}), release: make(chan struct{})}
t.Cleanup(func() {
nativeOnce.Do(func() { close(nativeRelease) })
deliveryOnce.Do(func() { close(writer.release) })
})
done := make(chan struct{})
go func() { app.salePayment(writer, saleRequest(true)); close(done) }()
select {
case <-writer.started:
case <-time.After(5 * time.Second):
t.Fatal("progress was not live")
}
nativeOnce.Do(func() { close(nativeRelease) })
select {
case <-receiptPrinted:
case <-time.After(5 * time.Second):
t.Fatal("blocked writer stopped financial finalization")
}
deliveryOnce.Do(func() { close(writer.release) })
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("stream did not deliver final")
}
frames := decodePaymentStream(t, writer.Body)
if len(frames) != 130 || frames[len(frames)-1].Result == nil || frames[len(frames)-1].Result.Outcome != "approved" {
t.Errorf("backpressure frames=%d, last=%+v, want 129 statuses and final approval", len(frames), frames[len(frames)-1])
}
}
type creditCallRoundTrip func(*http.Request) (*http.Response, error)
func (f creditCallRoundTrip) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func chipDNAFixture(t *testing.T, fields map[string]string) string {
t.Helper()
var result creditcall.TransactionResultXML
for key, value := range fields {
result.Entries = append(result.Entries, creditcall.EntryXML{Key: key, Value: value})
}
data, err := xml.Marshal(result)
if err != nil {
t.Fatal(err)
}
return string(data)
}
func newCreditCallTestApp(t *testing.T, handler http.HandlerFunc) *App {
t.Helper()
server := httptest.NewServer(handler)
t.Cleanup(server.Close)
target, err := url.Parse(server.URL)
if err != nil {
t.Fatal(err)
}
app := &App{isPayment: true, cfg: &config.ConfigRec{TimeoutSeconds: 1},
creditCallTransport: creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
clone := r.Clone(r.Context())
clone.URL.Scheme, clone.URL.Host = target.Scheme, target.Host
return server.Client().Transport.RoundTrip(clone)
}),
}
app.EnableCreditCallStreaming()
return app
}
func saleRequest(stream bool) *http.Request {
if stream {
r := httptest.NewRequest(http.MethodPost, "/api/payment/sale", strings.NewReader(`{"amount":1234}`))
r.Header.Set("Content-Type", "application/json")
return r
}
r := httptest.NewRequest(http.MethodPost, "/takepayment", strings.NewReader(`<TransactionPayload><Amount>1234</Amount><TransactionType>Sale</TransactionType></TransactionPayload>`))
r.Header.Set("Content-Type", "text/xml")
return r
}
func TestCreditCallLegacyAndStreamingSaleParity(t *testing.T) {
for _, test := range []struct {
name, startResult, confirmation string
confirms int
approved bool
receipt string
}{
{"approved", "Approved", "Approved", 1, true, "confirm receipt"},
{"declined", "Declined", "", 0, false, "start receipt"},
{"cancelled", "Cancelled", "", 0, false, "start receipt"},
{"timeout", "TIMEOUT", "", 0, false, "start receipt"},
{"confirmation declined", "Approved", "Declined", 1, false, "confirm receipt"},
{"confirmation omissions", "Approved", "omitted", 1, true, "start receipt"},
{"malformed confirmation", "Approved", "malformed", 1, true, "start receipt"},
} {
t.Run(test.name, func(t *testing.T) {
fields := map[string]string{types.TransactionResult: test.startResult, types.Reference: "native-ref",
types.CardType: "Visa", types.PanMasked: "************1234", types.ExpiryDate: "1228",
types.CardHash: "hash", types.CardReference: "card-ref", types.ReceiptDataCardholder: "start receipt"}
var legacy cmstypes.ResponseRec
for _, streaming := range []bool{false, true} {
var starts, confirms atomic.Int32
var receipts []string
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/start-transaction/":
starts.Add(1)
io.WriteString(w, chipDNAFixture(t, fields))
case "/start-transaction-stream/":
starts.Add(1)
var input struct{ Amount, TransactionType string }
if err := json.NewDecoder(r.Body).Decode(&input); err != nil || input.Amount != "1234" || input.TransactionType != "Sale" {
t.Errorf("stream start input = %+v, error %v", input, err)
}
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n")
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n")
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"Approved\"}\n")
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
json.NewEncoder(w).Encode(map[string]any{"type": "result", "result": fields})
case "/confirm-transaction/":
confirms.Add(1)
var input creditcall.ConfirmTransactionRequest
if err := xml.NewDecoder(r.Body).Decode(&input); err != nil || input.Amount != "1234" || input.Reference != "native-ref" {
t.Errorf("confirmation input = %+v, error %v", input, err)
}
switch test.confirmation {
case "omitted":
io.WriteString(w, "<TransactionResult/>")
case "malformed":
io.WriteString(w, "<TransactionResult><Entry>")
default:
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: test.confirmation, types.ReceiptDataCardholder: "confirm receipt"}))
}
default:
t.Errorf("unexpected ChipDNA path %q", r.URL.Path)
}
})
app.creditCallReceipt = func(receipt string) { receipts = append(receipts, receipt) }
if got := app.creditCallClient().Timeout; got != 300*time.Second {
t.Fatalf("per-call timeout = %v, want 300s", got)
}
recorder := httptest.NewRecorder()
if streaming {
app.salePayment(recorder, saleRequest(true))
} else {
app.takePayment(recorder, saleRequest(false))
}
if starts.Load() != 1 || int(confirms.Load()) != test.confirms {
t.Errorf("stream=%v starts/confirms=%d/%d, want 1/%d", streaming, starts.Load(), confirms.Load(), test.confirms)
}
if !reflect.DeepEqual(receipts, []string{test.receipt}) {
t.Errorf("stream=%v receipts=%v, want [%s]", streaming, receipts, test.receipt)
}
if !streaming {
if err := json.Unmarshal(recorder.Body.Bytes(), &legacy); err != nil {
t.Fatal(err)
}
if strings.HasPrefix(legacy.Data, "/successful") != test.approved {
t.Errorf("legacy result = %+v, approved want %v", legacy, test.approved)
}
continue
}
frames := decodePaymentStream(t, recorder.Body)
if len(frames) != 3 || frames[0].Code != paymentstatus.PresentCard || frames[1].Code != paymentstatus.PleaseWait || frames[2].Result == nil {
t.Fatalf("frames = %+v, want two ordered hints and one final", frames)
}
final := frames[2].Result
if final.HTTPStatus != http.StatusOK || (final.Outcome == "approved") != test.approved {
t.Errorf("structured final = %+v, legacy = %+v", final, legacy)
}
parsed, err := url.Parse(legacy.Data)
if err != nil {
t.Fatal(err)
}
if test.approved {
if final.TransactionReference != "native-ref" || final.CardType != "Visa" || final.MaskedCardNumber != "************1234" || final.CardHash != "hash" || final.CardReference != "card-ref" || final.ExpiryDate != "1228" {
t.Errorf("retained structured fields = %+v", final)
}
} else if final.Outcome == "approved" {
t.Errorf("structured message = %q, legacy description = %q", final.Message, parsed.Query().Get("Description"))
}
}
})
}
}
func TestCreditCallConfirmationRetryAndFailureParity(t *testing.T) {
for _, streaming := range []bool{false, true} {
var attempts int
var times []time.Time
app := &App{isPayment: true, cfg: &config.ConfigRec{}}
app.EnableCreditCallStreaming()
app.creditCallReceipt = func(string) { t.Error("transport-failed confirmation must not print a receipt") }
app.creditCallTransport = creditCallRoundTrip(func(r *http.Request) (*http.Response, error) {
if r.Context().Err() != nil {
t.Error("transaction context was cancelled")
}
if r.URL.Path == "/confirm-transaction/" {
attempts++
times = append(times, time.Now())
return nil, errors.New("test transport failure")
}
body := chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved", types.Reference: "native-ref"})
if streaming {
body = "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"native-ref\"}}\n"
}
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(body)), Header: make(http.Header)}, nil
})
recorder := httptest.NewRecorder()
if streaming {
app.salePayment(recorder, saleRequest(true))
} else {
app.takePayment(recorder, saleRequest(false))
}
if attempts != 2 {
t.Fatalf("stream=%v confirms=%d, want 2", streaming, attempts)
}
if times[1].Sub(times[0]) < 2*time.Second {
t.Errorf("retry delay=%v, want at least 2s", times[1].Sub(times[0]))
}
if streaming {
frames := decodePaymentStream(t, recorder.Body)
if len(frames) != 1 || frames[0].Result.HTTPStatus != 502 || frames[0].Result.Outcome != "unknown" || frames[0].Result.Retryable {
t.Fatalf("confirmation failure frames=%+v", frames)
}
} else if recorder.Code != 502 {
t.Errorf("legacy confirm failure HTTP=%d, want 502", recorder.Code)
}
}
}
func TestCreditCallLegacyMalformedStartAndPreauth(t *testing.T) {
for _, test := range []struct{ name, path, result, transactionType string }{
{"malformed sale", "/takepayment", "malformed", ""},
{"approved account verification", "/takepreauth", "Approved", types.AccountVerificationType},
{"declined preauth", "/takepreauth", "Declined", "Sale"},
{"malformed preauth", "/takepreauth", "malformed", ""},
} {
t.Run(test.name, func(t *testing.T) {
calls, prints := 0, 0
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
calls++
if r.URL.Path != "/start-transaction/" {
t.Errorf("legacy/preauth path=%s", r.URL.Path)
}
if test.result == "malformed" {
io.WriteString(w, "<TransactionResult><Entry>")
return
}
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: test.result, types.TransactionType: test.transactionType}))
})
app.creditCallReceipt = func(string) { prints++ }
recorder := httptest.NewRecorder()
request := saleRequest(false)
if test.path == "/takepreauth" {
app.takePreauthorization(recorder, request)
} else {
app.takePayment(recorder, request)
}
var response cmstypes.ResponseRec
if err := json.Unmarshal(recorder.Body.Bytes(), &response); err != nil {
t.Fatal(err)
}
if recorder.Code != 200 || calls != 1 || prints != 1 {
t.Errorf("legacy HTTP/calls/receipts=%d/%d/%d", recorder.Code, calls, prints)
}
if test.result == "malformed" && (response.Status.Code != 0 || response.Data != "/unsuccessful?Description=&MsgType=") {
t.Errorf("malformed legacy result=%+v", response)
}
if test.result == "Approved" && !strings.HasPrefix(response.Data, "/successful?") {
t.Errorf("approved preauth=%+v", response)
}
})
}
}
func TestChipDNAStreamRejectsIncompleteOrInvalidFrames(t *testing.T) {
for _, body := range []string{"", "{", "{}\n", "<xml/>\n", "{\"type\":\"result\"}\n", "{\"type\":\"result\",\"result\":{}}\n", "{\"type\":\"error\",\"error\":\"sensitive diagnostic\"}\n", "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\"}}", "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"Approved\"}\n"} {
client := &http.Client{Transport: creditCallRoundTrip(func(*http.Request) (*http.Response, error) {
return &http.Response{StatusCode: 200, Body: io.NopCloser(strings.NewReader(body))}, nil
})}
_, err := callChipDNAStream(client, 1234, func(code string) { t.Errorf("invalid stream produced status %q", code) })
if err == nil {
t.Errorf("callChipDNAStream(%q) succeeded, want error", body)
}
if err != nil && strings.Contains(err.Error(), "sensitive diagnostic") {
t.Error("raw diagnostic leaked")
}
}
}
type disconnectedPaymentWriter struct {
header http.Header
once sync.Once
failed chan struct{}
writes atomic.Int32
}
func (w *disconnectedPaymentWriter) Header() http.Header { return w.header }
func (w *disconnectedPaymentWriter) WriteHeader(int) {}
func (w *disconnectedPaymentWriter) Flush() {}
func (w *disconnectedPaymentWriter) Write([]byte) (int, error) {
w.writes.Add(1)
w.once.Do(func() { close(w.failed) })
return 0, io.ErrClosedPipe
}
func TestCreditCallDisconnectStillConfirmsAndPrints(t *testing.T) {
release := make(chan struct{})
var confirms atomic.Int32
var receipts atomic.Int32
app := newCreditCallTestApp(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/confirm-transaction/" {
confirms.Add(1)
io.WriteString(w, chipDNAFixture(t, map[string]string{types.TransactionResult: "Approved", types.ReceiptDataCardholder: "receipt"}))
return
}
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"CardRequested\"}\n")
w.(http.Flusher).Flush()
<-release
io.WriteString(w, "{\"type\":\"status\",\"source\":\"UPDATE\",\"value\":\"OnlineAuthCompleted\"}\n")
io.WriteString(w, "{\"type\":\"result\",\"result\":{\"TRANSACTION_RESULT\":\"Approved\",\"REFERENCE\":\"ref\"}}\n")
})
app.creditCallReceipt = func(receipt string) {
if receipt != "receipt" {
t.Errorf("receipt=%q", receipt)
}
receipts.Add(1)
}
writer := &disconnectedPaymentWriter{header: make(http.Header), failed: make(chan struct{})}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() { app.salePayment(writer, saleRequest(true).WithContext(ctx)); close(done) }()
select {
case <-writer.failed:
case <-time.After(5 * time.Second):
close(release)
t.Fatal("no live progress before final result")
}
cancel()
close(release)
select {
case <-done:
case <-time.After(5 * time.Second):
t.Fatal("finalization stopped after disconnect")
}
if confirms.Load() != 1 || receipts.Load() != 1 || writer.writes.Load() != 1 {
t.Errorf("disconnect confirms/receipts/writes=%d/%d/%d, want 1/1/1", confirms.Load(), receipts.Load(), writer.writes.Load())
}
}
+92
View File
@@ -0,0 +1,92 @@
package handlers
import (
"bufio"
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strconv"
"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"
)
// 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) {
return callChipDNATransactionStream(context.Background(), client, cmstypes.TransactionRec{
AmountMinorUnits: strconv.FormatInt(amount, 10), TransactionType: "Sale",
}, onStatus)
}
func callChipDNATransactionStream(ctx context.Context, client *http.Client, transaction cmstypes.TransactionRec, onStatus func(string)) (creditcall.TransactionResultXML, error) {
var result creditcall.TransactionResultXML
payload, err := json.Marshal(struct {
Amount string `json:"amount"`
TransactionType string `json:"transactionType"`
}{transaction.AmountMinorUnits, transaction.TransactionType})
if err != nil {
return result, err
}
// Dispatch owns ctx; Client.Timeout retains the independent 300-second call bound.
req, err := http.NewRequestWithContext(ctx, http.MethodPost, types.LinkStartTransactionStream, bytes.NewReader(payload))
if err != nil {
return result, err
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/x-ndjson")
response, err := client.Do(req)
if err != nil {
return result, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return result, fmt.Errorf("chipdna stream returned HTTP %d", response.StatusCode)
}
reader := bufio.NewReader(response.Body)
for {
line, err := reader.ReadBytes('\n')
if err != nil {
if errors.Is(err, io.EOF) {
return result, fmt.Errorf("chipdna stream ended before a complete final frame")
}
return result, fmt.Errorf("read chipdna stream: %w", err)
}
var frame struct {
Type string `json:"type"`
Source string `json:"source"`
Value string `json:"value"`
Result map[string]string `json:"result"`
}
if err := json.Unmarshal(line, &frame); err != nil {
return result, fmt.Errorf("invalid chipdna JSON frame")
}
switch frame.Type {
case "status":
if code := creditcall.ProgressStatus(frame.Source, frame.Value); code != "" && onStatus != nil {
onStatus(code)
}
case "result":
if len(frame.Result) == 0 {
return result, fmt.Errorf("chipdna final frame has no transaction fields")
}
for key, value := range frame.Result {
result.Entries = append(result.Entries, creditcall.EntryXML{Key: key, Value: value})
}
return result, nil // Later frames cannot repeat confirmation/finalization.
case "error":
return result, fmt.Errorf("chipdna stream reported an error")
default:
return result, fmt.Errorf("unknown chipdna frame type")
}
}
}
+11 -3
View File
@@ -11,6 +11,7 @@ import (
"time"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/db"
"gitea.futuresens.co.uk/futuresens/hardlink/internal/types"
log "github.com/sirupsen/logrus"
)
@@ -74,18 +75,23 @@ func (app *App) spoolPath() string {
// It never returns an error to the caller (so your HTTP flow stays simple),
// but it logs failures.
func (app *App) persistPreauth(ctx context.Context, fields map[string]string, checkoutDate string) {
entry := log.WithFields(log.Fields{
"operation": "preauth", "reference": fields[types.Reference],
"hotel": app.cfg.Hotel, "kiosk": app.cfg.Kiosk,
})
// First, try DB (with your reconnect logic inside getDB)
dbConn, err := app.getDB(ctx)
if err == nil && dbConn != nil {
if err := db.InsertPreauth(ctx, dbConn, fields, checkoutDate); err == nil {
entry.Info("CreditCall PREAUTH SQL persistence completed")
// opportunistic drain once DB is alive
go app.drainPreauthSpool(context.Background())
return
} else {
log.WithError(err).Warn("DB insert failed; will spool preauth")
entry.WithError(err).Warn("DB insert failed; will spool preauth")
}
} else {
log.WithError(err).Warn("DB unavailable; will spool preauth")
entry.WithError(err).Warn("DB unavailable; will spool preauth")
}
// Fallback: spool to file
@@ -95,7 +101,9 @@ func (app *App) persistPreauth(ctx context.Context, fields map[string]string, ch
Fields: fields,
}
if spErr := app.spoolPreauth(rec); spErr != nil {
log.WithError(spErr).Error("failed to spool preauth")
entry.WithError(spErr).Error("failed to spool preauth")
} else {
entry.Warn("CreditCall PREAUTH saved to spool; SQL persistence pending")
}
}
+314 -26
View File
@@ -5,10 +5,12 @@ import (
"context"
"encoding/json"
"errors"
"fmt"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"sync"
"testing"
"time"
@@ -25,21 +27,49 @@ type dispenserCallResult struct {
}
type fakeDoorCardDispenser struct {
prepareCurrent dispenserCallResult
deliverCurrent dispenserCallResult
beginNextErr error
beginNext func() error
prepareNext dispenserCallResult
calls []string
preparation dispenser.PreparationResult
recoverCurrent func(context.Context, dispenser.PreparationResult) error
deliver func()
prepareCurrent dispenserCallResult
deliverCurrent dispenserCallResult
beginNextErr error
beginNext func() error
prepareNext dispenserCallResult
activity int
registrations int
releases int
outsideActivity bool
calls []string
}
func (d *fakeDoorCardDispenser) PrepareCurrentCard(context.Context) (string, error) {
if d.activity == 0 {
d.outsideActivity = true
}
d.calls = append(d.calls, "prepare current")
return d.prepareCurrent.status, d.prepareCurrent.err
}
func (d *fakeDoorCardDispenser) PrepareCurrentCardForEncoding(ctx context.Context) (dispenser.PreparationResult, error) {
stock, err := d.PrepareCurrentCard(ctx)
result := d.preparation
result.Stock = stock
return result, err
}
func (d *fakeDoorCardDispenser) RecoverCurrentCard(ctx context.Context, result dispenser.PreparationResult) error {
if d.recoverCurrent != nil {
return d.recoverCurrent(ctx, result)
}
return nil
}
func (d *fakeDoorCardDispenser) DeliverCurrentCard(context.Context) (string, error) {
d.calls = append(d.calls, "deliver current")
if d.deliver != nil {
d.deliver()
}
return d.deliverCurrent.status, d.deliverCurrent.err
}
@@ -57,18 +87,29 @@ func (d *fakeDoorCardDispenser) PrepareNextCard(context.Context) (string, error)
}
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
}
func (l *fakeDoorCardLockServer) LockSequence() error {
l.sequenceCalls++
if l.sequence != nil {
return l.sequence()
}
return l.sequenceErr
}
@@ -121,11 +162,11 @@ func TestIssueDoorCardPhysicalOutcomeContract(t *testing.T) {
wantCardWell string
}{
{
name: "initial dispenser preparation failure is unavailable",
name: "initial dispenser preparation failure is retryable",
dispenser: fakeDoorCardDispenser{
prepareCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("card jammed")},
},
wantHTTP: http.StatusServiceUnavailable,
wantHTTP: http.StatusBadGateway,
wantMessage: "Dispense error: card jammed",
wantCalls: []string{"prepare current"},
wantCardWell: "Card jammed",
@@ -140,6 +181,13 @@ func TestIssueDoorCardPhysicalOutcomeContract(t *testing.T) {
wantCalls: []string{"prepare current"},
wantCardWell: "Card empty",
},
{
name: "exhausted preparation is retryable without encoding or delivery",
dispenser: fakeDoorCardDispenser{prepareCurrent: dispenserCallResult{err: errors.Join(errors.New("preparation"), dispenser.ErrPreparationExhausted)}},
wantHTTP: http.StatusBadGateway,
wantMessage: "preparation\ncard preparation exhausted",
wantCalls: []string{"prepare current"},
},
{
name: "encoding and accepted delivery command succeed",
wantHTTP: http.StatusOK,
@@ -148,13 +196,13 @@ func TestIssueDoorCardPhysicalOutcomeContract(t *testing.T) {
wantLockSequence: 1,
},
{
name: "successful encoding with delivery command failure is unavailable",
name: "successful encoding with delivery command failure still prestages and succeeds",
dispenser: fakeDoorCardDispenser{
deliverCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("delivery jammed")},
},
wantHTTP: http.StatusServiceUnavailable,
wantMessage: "Card delivery could not be confirmed",
wantCalls: []string{"prepare current", "deliver current"},
wantHTTP: http.StatusOK,
wantMessage: "Card issued successfully",
wantCalls: []string{"prepare current", "deliver current", "begin prepare next"},
wantLockSequence: 1,
wantCardWell: "Card jammed",
},
@@ -169,36 +217,45 @@ func TestIssueDoorCardPhysicalOutcomeContract(t *testing.T) {
wantLockSequence: 1,
},
{
name: "encoding failure with safe recovery remains retryable",
lockErr: encodingErr,
wantHTTP: http.StatusBadGateway,
wantMessage: encodingErr.Error(),
wantCalls: []string{"prepare current", "deliver current", "prepare next"},
name: "delivery clearance deferral does not undo successful issuance",
dispenser: fakeDoorCardDispenser{
beginNextErr: errors.New("next-card preparation deferred: previous delivery is not clear"),
},
wantHTTP: http.StatusOK,
wantMessage: "Card issued successfully",
wantCalls: []string{"prepare current", "deliver current", "begin prepare next"},
wantLockSequence: 1,
},
{
name: "encoding failure with failed-card delivery failure is unavailable",
name: "encoding failure ends after delivery",
lockErr: encodingErr,
wantHTTP: http.StatusBadGateway,
wantMessage: encodingErr.Error(),
wantCalls: []string{"prepare current", "deliver current"},
wantLockSequence: 1,
},
{
name: "encoding failure remains retryable despite FC0 failure",
dispenser: fakeDoorCardDispenser{
deliverCurrent: dispenserCallResult{status: "Card jammed", err: errors.New("delivery jammed")},
},
lockErr: encodingErr,
wantHTTP: http.StatusServiceUnavailable,
wantMessage: "Dispenser recovery failed; another encoding attempt is not safe",
wantHTTP: http.StatusBadGateway,
wantMessage: encodingErr.Error(),
wantCalls: []string{"prepare current", "deliver current"},
wantLockSequence: 1,
wantCardWell: "Card jammed",
},
{
name: "encoding failure with empty card well has stable message",
name: "encoding failure never prepares next card",
dispenser: fakeDoorCardDispenser{
prepareNext: dispenserCallResult{status: "Card empty", err: dispenser.ErrCardWellEmpty},
},
lockErr: encodingErr,
wantHTTP: http.StatusServiceUnavailable,
wantMessage: dispenser.CardWellEmptyMessage,
wantCalls: []string{"prepare current", "deliver current", "prepare next"},
wantHTTP: http.StatusBadGateway,
wantMessage: encodingErr.Error(),
wantCalls: []string{"prepare current", "deliver current"},
wantLockSequence: 1,
wantCardWell: "Card empty",
},
}
@@ -311,3 +368,234 @@ func TestIssueDoorCardLogsNextCardDispatchFailureAndStillSucceeds(t *testing.T)
t.Fatalf("dispatch failure log = %q", logged)
}
}
func TestIssueDoorCardLogsDeliveryFailureWithoutReplacingEncoderOutcome(t *testing.T) {
for _, encodingErr := range []error{nil, errors.New("original encoder failure")} {
var output bytes.Buffer
logger := log.StandardLogger()
previous := logger.Out
logger.SetOutput(&output)
d := &fakeDoorCardDispenser{deliverCurrent: dispenserCallResult{err: errors.New("FC0 dispatch failed")}}
lock := &fakeDoorCardLockServer{sequenceErr: encodingErr}
recorder, response, _ := performIssueDoorCardRequest(t, d, lock)
logger.SetOutput(previous)
wantHTTP := http.StatusOK
if encodingErr != nil {
wantHTTP = http.StatusBadGateway
}
if recorder.Code != wantHTTP {
t.Errorf("issueDoorCard(%v) HTTP = %d, want %d", encodingErr, recorder.Code, wantHTTP)
}
if encodingErr != nil && response.Message != encodingErr.Error() {
t.Errorf("issueDoorCard message = %q, want %q", response.Message, encodingErr.Error())
}
if !strings.Contains(output.String(), "FC0 dispatch failed") || !strings.Contains(output.String(), "Card delivery") {
t.Errorf("issueDoorCard delivery log = %q, want FC0 failure and Card delivery", output.String())
}
}
}
func TestIssueDoorCardOnlyEmptyPreparationReturns503(t *testing.T) {
for _, failure := range []error{
dispenser.ErrCardWellEmpty, errors.Join(errors.New("wrapped"), dispenser.ErrCardWellEmpty),
dispenser.ErrPreparationExhausted, context.Canceled, context.DeadlineExceeded,
errors.New("malformed AP"), errors.New("truncated AP"), errors.New("no response"),
errors.New("serial read failed"), errors.New("serial write failed"), errors.New("FC7 dispatch failed"),
errors.New("RS dispatch failed"), errors.New(dispenser.CardWellEmptyMessage), errors.New("other preparation error"),
} {
d := &fakeDoorCardDispenser{prepareCurrent: dispenserCallResult{err: failure}}
lock := &fakeDoorCardLockServer{}
recorder, response, _ := performIssueDoorCardRequest(t, d, lock)
want := http.StatusBadGateway
if errors.Is(failure, dispenser.ErrCardWellEmpty) {
want = http.StatusServiceUnavailable
}
if recorder.Code != want || response.Code != want {
t.Errorf("preparation %v HTTP=%d body=%d, want %d", failure, recorder.Code, response.Code, want)
}
if lock.sequenceCalls != 0 || !reflect.DeepEqual(d.calls, []string{"prepare current"}) {
t.Errorf("preparation %v encoder=%d calls=%v, want no physical continuation", failure, lock.sequenceCalls, d.calls)
}
}
}
func (d *fakeDoorCardDispenser) BeginForeground() func() {
d.activity++
d.registrations++
return func() { d.activity--; d.releases++ }
}
func TestDoorCardForegroundLifecycle(t *testing.T) {
for _, testEndpoint := range []bool{false, true} {
d := &fakeDoorCardDispenser{prepareCurrent: dispenserCallResult{err: errors.New("stop before encoding")}}
lock := &fakeDoorCardLockServer{}
_, _, app := performIssueDoorCardRequest(t, d, lock)
if d.registrations != 1 || d.releases != 1 || d.activity != 0 || d.outsideActivity {
t.Fatalf("issue registration=%d release=%d active=%d outside=%t", d.registrations, d.releases, d.activity, d.outsideActivity)
}
if testEndpoint {
req := httptest.NewRequest(http.MethodPost, "/testissuedoorcard", strings.NewReader("{}"))
req.Header.Set("Content-Type", "application/json")
app.testIssueDoorCard(httptest.NewRecorder(), req)
if d.registrations != 2 || d.releases != 2 || d.activity != 0 || d.outsideActivity {
t.Errorf("test endpoint registration=%d release=%d active=%d outside=%t", d.registrations, d.releases, d.activity, d.outsideActivity)
}
}
}
}
func waitDoorCardSignal(t *testing.T, signal <-chan struct{}, name string) {
t.Helper()
select {
case <-signal:
case <-time.After(3 * time.Second):
t.Fatalf("timed out waiting for %s", name)
}
}
func startUncertainDoorCardRequest(t *testing.T, ctx context.Context, d *fakeDoorCardDispenser, lock *fakeDoorCardLockServer) (*httptest.ResponseRecorder, <-chan struct{}) {
t.Helper()
app := &App{disp: d, lockserver: lock, cfg: &config.ConfigRec{}}
request := httptest.NewRequest(http.MethodPost, "/issuedoorcard", strings.NewReader(`{"roomField":"101","checkinTime":"2026-07-23 15:00:00 +0100","checkoutTime":"2026-07-24 11:00:00 +0100"}`)).WithContext(ctx)
request.Header.Set("Content-Type", "application/json")
recorder := httptest.NewRecorder()
done := make(chan struct{})
go func() {
defer close(done)
app.issueDoorCard(recorder, request)
}()
return recorder, done
}
func TestIssueDoorCardJoinsUncertainRecoveryBeforeDelivery(t *testing.T) {
for _, encodingErr := range []error{nil, errors.New("original lock-server failure")} {
t.Run(fmt.Sprint(encodingErr), func(t *testing.T) {
lockStarted := make(chan struct{})
recoveryStarted := make(chan struct{})
recoveryStopped := make(chan struct{})
d := &fakeDoorCardDispenser{preparation: dispenser.PreparationResult{UncertainHandoff: true, ShakesUsed: 1}}
d.recoverCurrent = func(ctx context.Context, preparation dispenser.PreparationResult) error {
defer close(recoveryStopped)
<-lockStarted
if preparation.ShakesUsed != 1 || !preparation.UncertainHandoff {
t.Errorf("recovery preparation=%+v, want same uncertain request and used budget", preparation)
}
close(recoveryStarted)
<-ctx.Done()
if context.Cause(ctx).Error() != "LockSequence completed" {
t.Errorf("recovery cause=%v, want LockSequence completed", context.Cause(ctx))
}
return ctx.Err()
}
d.deliver = func() {
select {
case <-recoveryStopped:
default:
t.Error("FC0 started before recovery stopped")
}
}
lock := &fakeDoorCardLockServer{sequence: func() error {
close(lockStarted)
<-recoveryStarted
return encodingErr
}}
recorder, done := startUncertainDoorCardRequest(t, context.Background(), d, lock)
waitDoorCardSignal(t, done, "encoding and recovery shutdown")
wantHTTP := http.StatusOK
wantCalls := []string{"prepare current", "deliver current", "begin prepare next"}
if encodingErr != nil {
wantHTTP = http.StatusBadGateway
wantCalls = []string{"prepare current", "deliver current"}
if !strings.Contains(recorder.Body.String(), encodingErr.Error()) {
t.Errorf("response=%s, want original encoding failure", recorder.Body.String())
}
}
if recorder.Code != wantHTTP || lock.sequenceCalls != 1 || !reflect.DeepEqual(d.calls, wantCalls) {
t.Errorf("HTTP=%d lock calls=%d dispenser calls=%v, want HTTP=%d one encoding and %v", recorder.Code, lock.sequenceCalls, d.calls, wantHTTP, wantCalls)
}
})
}
}
func TestIssueDoorCardRecoveryEndingDoesNotEndEncoding(t *testing.T) {
for _, recoveryErr := range []error{nil, dispenser.ErrCardWellEmpty, errors.New("RS dispatch failed")} {
t.Run(fmt.Sprint(recoveryErr), func(t *testing.T) {
lockStarted := make(chan struct{})
recoveryStopped := make(chan struct{})
releaseLock := make(chan struct{})
var releaseOnce sync.Once
release := func() { releaseOnce.Do(func() { close(releaseLock) }) }
t.Cleanup(release)
encodingErr := errors.New("original encoding timed out")
d := &fakeDoorCardDispenser{preparation: dispenser.PreparationResult{UncertainHandoff: true, ShakesUsed: 3}}
d.recoverCurrent = func(ctx context.Context, preparation dispenser.PreparationResult) error {
<-lockStarted
close(recoveryStopped) // Encoder arrival, exhaustion or a mechanical failure.
return recoveryErr
}
lock := &fakeDoorCardLockServer{sequence: func() error {
close(lockStarted)
<-releaseLock
return encodingErr
}}
recorder, done := startUncertainDoorCardRequest(t, context.Background(), d, lock)
waitDoorCardSignal(t, recoveryStopped, "recovery ending while lock waits")
select {
case <-done:
t.Error("recovery ending replaced still-running LockSequence")
default:
}
release()
waitDoorCardSignal(t, done, "original LockSequence result")
if recorder.Code != http.StatusBadGateway || !strings.Contains(recorder.Body.String(), encodingErr.Error()) || lock.sequenceCalls != 1 || !reflect.DeepEqual(d.calls, []string{"prepare current", "deliver current"}) {
t.Errorf("HTTP=%d body=%s locks=%d commands=%v, want original encoding error and one FC0", recorder.Code, recorder.Body.String(), lock.sequenceCalls, d.calls)
}
})
}
}
func TestIssueDoorCardCancellationStopsOnlyUncertainRecovery(t *testing.T) {
lockStarted := make(chan struct{})
recoveryStarted := make(chan struct{})
recoveryStopped := make(chan struct{})
releaseLock := make(chan struct{})
var releaseOnce sync.Once
release := func() { releaseOnce.Do(func() { close(releaseLock) }) }
t.Cleanup(release)
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
d := &fakeDoorCardDispenser{preparation: dispenser.PreparationResult{UncertainHandoff: true}}
d.recoverCurrent = func(ctx context.Context, preparation dispenser.PreparationResult) error {
defer close(recoveryStopped)
<-lockStarted
close(recoveryStarted)
<-ctx.Done()
return ctx.Err()
}
d.deliver = func() {
select {
case <-recoveryStopped:
default:
t.Error("delivery raced cancelled recovery")
}
}
lock := &fakeDoorCardLockServer{sequence: func() error {
close(lockStarted)
<-releaseLock
return nil
}}
recorder, done := startUncertainDoorCardRequest(t, ctx, d, lock)
waitDoorCardSignal(t, recoveryStarted, "concurrent recovery")
cancel()
waitDoorCardSignal(t, recoveryStopped, "cancelled recovery")
select {
case <-done:
t.Error("caller cancellation ended the original LockSequence")
default:
}
release()
waitDoorCardSignal(t, done, "delivery after encoding")
if recorder.Code != http.StatusOK || lock.sequenceCalls != 1 || !reflect.DeepEqual(d.calls, []string{"prepare current", "deliver current", "begin prepare next"}) {
t.Errorf("cancelled HTTP=%d lock calls=%d commands=%v, want original successful encoding and one delivery", recorder.Code, lock.sequenceCalls, d.calls)
}
}
+101 -176
View File
@@ -6,7 +6,6 @@ import (
"encoding/json"
"encoding/xml"
"errors"
"fmt"
"io"
"net/http"
"strings"
@@ -28,24 +27,30 @@ import (
)
type doorCardDispenser interface {
BeginForeground() func()
PrepareCurrentCard(context.Context) (string, error)
PrepareCurrentCardForEncoding(context.Context) (dispenser.PreparationResult, error)
RecoverCurrentCard(context.Context, dispenser.PreparationResult) error
DeliverCurrentCard(context.Context) (string, error)
BeginPrepareNextCard(context.Context) error
PrepareNextCard(context.Context) (string, error)
}
type App struct {
disp doorCardDispenser
lockserver lockserver.LockServer
paymentService *paymentsvc.Service
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 {
@@ -61,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
}
@@ -75,17 +87,19 @@ 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.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 (
theResponse cmstypes.ResponseRec
theRequest cmstypes.TransactionRec
trResult creditcall.TransactionResultXML
result creditcall.PaymentResult
save bool
)
theResponse.Status.Code = http.StatusInternalServerError
@@ -146,49 +160,30 @@ func (app *App) takePreauthorization(w http.ResponseWriter, r *http.Request) {
theRequest.TransactionType,
)
client := &http.Client{Timeout: 300 * time.Second}
// ---- START TRANSACTION ----
body, err = callChipDNA(client, types.LinkStartTransaction, body)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Preauth processing error", string(op), "", "", 0)
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "No response from payment processor")
writeTransactionResult(w, http.StatusBadGateway, theResponse)
return
}
if err := trResult.ParseTransactionResult(body); err != nil {
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
}
result.FillFromTransactionResult(trResult)
// ---- PRINT RECEIPT ----
printer.PrintReceipt(result.CardholderReceipt)
// ---- REDIRECT ----
theResponse.Status = result.Status
theResponse.Data, save = creditcall.BuildPreauthRedirectURL(result.Fields)
if save {
go app.persistPreauth(context.Background(), result.Fields, theRequest.CheckoutDate)
}
writeTransactionResult(w, http.StatusOK, theResponse)
outcome := app.executeCreditCallPreauth(context.Background(), theRequest, func(client *http.Client) (creditcall.TransactionResultXML, error) {
var transaction creditcall.TransactionResultXML
response, err := callChipDNA(client, types.LinkStartTransaction, body)
if err != nil {
return transaction, err
}
if err := transaction.ParseTransactionResult(response); err != nil {
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
}
return transaction, nil
})
writeTransactionResult(w, outcome.HTTPStatus, outcome.legacyResponse())
}
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 (
theResponse cmstypes.ResponseRec
theRequest cmstypes.TransactionRec
trResult creditcall.TransactionResultXML
result creditcall.PaymentResult
)
theResponse.Status.Code = http.StatusInternalServerError
@@ -250,90 +245,18 @@ func (app *App) takePayment(w http.ResponseWriter, r *http.Request) {
theRequest.TransactionType,
)
client := &http.Client{Timeout: 300 * time.Second}
// ---- START TRANSACTION ----
body, err = callChipDNA(client, types.LinkStartTransaction, body)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Start transaction error", string(op), "", "", 0)
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "No response from payment processor")
writeTransactionResult(w, http.StatusBadGateway, theResponse)
return
}
if err := trResult.ParseTransactionResult(body); err != nil {
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
}
result.FillFromTransactionResult(trResult)
res := result.Fields[types.TransactionResult]
if !strings.EqualFold(res, types.ResultApproved) {
printer.PrintReceipt(result.CardholderReceipt)
desc := result.Fields[types.ErrorDescription]
if desc == "" {
desc = result.Fields[types.Errors]
outcome := app.executeCreditCallSale(theRequest, func(client *http.Client) (creditcall.TransactionResultXML, error) {
var trResult creditcall.TransactionResultXML
body, err := callChipDNA(client, types.LinkStartTransaction, body)
if err != nil {
return trResult, err
}
logging.Error(types.ServiceName, "Preauthorization failed", "Result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
theResponse.Status = result.Status
theResponse.Data = creditcall.BuildFailureURL(res, result.Fields[types.Errors])
writeTransactionResult(w, http.StatusOK, theResponse)
return
}
// ---- CONFIRM TRANSACTION ----
ref := result.Fields[types.Reference]
log.Printf("Preauth approved, reference: %s. Sending confirm...", ref)
confirmReq := creditcall.ConfirmTransactionRequest{
Amount: theRequest.AmountMinorUnits,
Reference: ref,
}
body, err = confirmWithRetry(client, confirmReq, 2)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Confirm transaction error", string(op), "", "", 0)
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Error: "+err.Error())
theResponse.Data = creditcall.BuildFailureURL(types.ResultError, "ConfirmTransactionError")
writeTransactionResult(w, http.StatusBadGateway, theResponse)
return
}
if err := trResult.ParseTransactionResult(body); err != nil {
logging.Error(types.ServiceName, err.Error(), "Parse confirm result error", string(op), "", "", 0)
}
result.FillFromTransactionResult(trResult)
res = result.Fields[types.TransactionResult]
if !strings.EqualFold(res, types.ResultApproved) {
printer.PrintReceipt(result.CardholderReceipt)
desc := result.Fields[types.ErrorDescription]
if desc == "" {
desc = result.Fields[types.Errors]
if err := trResult.ParseTransactionResult(body); err != nil {
logging.Error(types.ServiceName, err.Error(), "Parse transaction result error", string(op), "", "", 0)
}
logging.Error(types.ServiceName, "Transaction not approved after confirm", "Confirm result: "+res+" Description: "+desc, string(op), "", app.cfg.Hotel, app.cfg.Kiosk)
mail.SendEmailOnError(app.cfg.Hotel, app.cfg.Kiosk, "Payment confirmation failed", "Reference: "+ref+", Confirm result: "+res+" Description: "+desc)
theResponse.Status = result.Status
theResponse.Data = creditcall.BuildFailureURL(res, result.Fields[types.Errors])
writeTransactionResult(w, http.StatusOK, theResponse)
return
}
// ---- SUCCESS ----
printer.PrintReceipt(result.CardholderReceipt)
log.Printf("Transaction approved and confirmed, reference: %s", ref)
theResponse.Status = result.Status
theResponse.Data = creditcall.BuildSuccessURL(result.Fields)
writeTransactionResult(w, http.StatusOK, theResponse)
return trResult, nil
})
writeTransactionResult(w, outcome.HTTPStatus, outcome.legacyResponse())
}
func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
@@ -343,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")
@@ -385,24 +300,58 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
return
}
status, err := app.disp.PrepareCurrentCard(r.Context())
app.SetCardWellStatus(status)
release := app.disp.BeginForeground()
defer release()
preparation, err := app.disp.PrepareCurrentCardForEncoding(r.Context())
app.SetCardWellStatus(preparation.Stock)
if err != nil {
logging.Error(types.ServiceName, err.Error(), "Dispense error", string(op), "", "", 0)
if errors.Is(err, dispenser.ErrCardWellEmpty) {
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
return
}
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispense error: "+err.Error())
if errors.Is(err, dispenser.ErrPreparationExhausted) {
errorhandlers.WriteError(w, http.StatusBadGateway, err.Error())
return
}
errorhandlers.WriteError(w, http.StatusBadGateway, "Dispense error: "+err.Error())
return
}
// 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
}
// lock server sequence
// Each request performs at most one encoder operation.
encodingStarted := time.Now()
log.Info("LockSequence started")
var stopRecovery context.CancelCauseFunc
var recoveryDone chan struct{}
if preparation.UncertainHandoff {
log.Infof("uncertain handoff; concurrent K720 recovery enabled; shakes=%d", preparation.ShakesUsed)
var recoveryCtx context.Context
recoveryCtx, stopRecovery = context.WithCancelCause(r.Context())
recoveryDone = make(chan struct{})
go func() {
defer close(recoveryDone)
if err := app.disp.RecoverCurrentCard(recoveryCtx, preparation); err != nil && recoveryCtx.Err() == nil {
log.WithError(err).Warn("K720 recovery failed; awaiting original LockSequence result")
}
}()
}
encodingErr := app.lockserver.LockSequence()
if stopRecovery != nil {
stopRecovery(errors.New("LockSequence completed"))
}
log.Infof("LockSequence finished; success=%t duration=%s", encodingErr == nil, time.Since(encodingStarted))
if recoveryDone != nil {
<-recoveryDone
}
if encodingErr != nil {
logging.Error(types.ServiceName, encodingErr.Error(), "Key encoding", string(op), "", "", 0)
}
@@ -415,32 +364,10 @@ func (app *App) issueDoorCard(w http.ResponseWriter, r *http.Request) {
status, deliveryErr := app.disp.DeliverCurrentCard(finalizeCtx)
app.SetCardWellStatus(status)
if deliveryErr != nil {
if encodingErr != nil {
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, deliveryErr)
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
return
}
logging.Error(types.ServiceName, deliveryErr.Error(), "Card delivery", string(op), "", "", 0)
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Card delivery could not be confirmed")
return
}
if encodingErr != nil {
status, preparationErr := app.disp.PrepareNextCard(finalizeCtx)
app.SetCardWellStatus(status)
if preparationErr != nil {
recoveryErr := fmt.Errorf("key encoding failed: %v; dispenser recovery failed: %w", encodingErr, preparationErr)
logging.Error(types.ServiceName, recoveryErr.Error(), "Dispenser recovery", string(op), "", "", 0)
if errors.Is(preparationErr, dispenser.ErrCardWellEmpty) {
errorhandlers.WriteError(w, http.StatusServiceUnavailable, dispenser.CardWellEmptyMessage)
return
}
errorhandlers.WriteError(w, http.StatusServiceUnavailable, "Dispenser recovery failed; another encoding attempt is not safe")
return
}
// FC0 is attempted once; the next UI request owns all further preparation.
errorhandlers.WriteError(w, http.StatusBadGateway, encodingErr.Error())
return
}
@@ -458,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")
@@ -508,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 -290
View File
@@ -2,333 +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"`
}
func (app *App) salePayment(w http.ResponseWriter, r *http.Request) {
const op = logging.Op("salePayment")
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)
}
}
+15 -2
View File
@@ -59,6 +59,9 @@ func (app *App) testIssueDoorCard(w http.ResponseWriter, r *http.Request) {
// Ensure dispenser ready (card at encoder) BEFORE we attempt encoding.
// With queued dispenser ops, this will not clash with polling.
release := app.disp.BeginForeground()
defer release()
status, err := app.disp.PrepareCurrentCard(r.Context())
app.SetCardWellStatus(status)
if err != nil {
@@ -68,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 {
@@ -87,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)
}
+10 -5
View File
@@ -2,17 +2,22 @@ package logging
import (
"fmt"
"io"
"os"
"path/filepath"
"time"
log "github.com/sirupsen/logrus"
)
// setupLogging ensures log directory, opens log file, and configures logrus.
// Returns the *os.File so caller can defer its Close().
func SetupLogging(logDir, serviceName, buildVersion string) (*os.File, error) {
fileName := logDir + serviceName + ".log"
f, err := os.OpenFile(fileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
// SetupLogging ensures the log directory, opens the rotating log writer, and configures logrus.
func SetupLogging(logDir, serviceName, buildVersion string) (io.WriteCloser, error) {
if err := os.MkdirAll(logDir, 0o755); err != nil {
return nil, fmt.Errorf("create log directory: %w", err)
}
fileName := filepath.Join(logDir, serviceName+".log")
f, err := newWeeklyLogWriter(fileName, time.Local, defaultWeeklyLogRuntime())
if err != nil {
return nil, fmt.Errorf("open log file: %w", err)
}
+319
View File
@@ -0,0 +1,319 @@
package logging
import (
"errors"
"fmt"
"io"
"io/fs"
"log/slog"
"os"
"path/filepath"
"strconv"
"strings"
"sync"
"time"
_ "time/tzdata"
)
const weeklyLogRetention = 13
type logRotationTimer interface {
C() <-chan time.Time
Stop() bool
}
type realLogRotationTimer struct {
*time.Timer
}
func (t realLogRotationTimer) C() <-chan time.Time {
return t.Timer.C
}
type weeklyLogRuntime struct {
now func() time.Time
newTimer func(time.Duration) logRotationTimer
rename func(string, string) error
diagnostic io.Writer
}
func defaultWeeklyLogRuntime() weeklyLogRuntime {
return weeklyLogRuntime{
now: time.Now,
newTimer: func(duration time.Duration) logRotationTimer {
return realLogRotationTimer{Timer: time.NewTimer(duration)}
},
rename: os.Rename,
diagnostic: os.Stderr,
}
}
type weeklyLogWriter struct {
path string
location *time.Location
now func() time.Time
newTimer func(time.Duration) logRotationTimer
rename func(string, string) error
diagnostic io.Writer
mu sync.Mutex
file *os.File
weekStart time.Time
closed bool
stop chan struct{}
done chan struct{}
closeOnce sync.Once
closeErr error
}
func newWeeklyLogWriter(path string, location *time.Location, runtime weeklyLogRuntime) (*weeklyLogWriter, error) {
if location == nil {
location = time.Local
}
if runtime.now == nil {
runtime.now = time.Now
}
if runtime.newTimer == nil {
runtime.newTimer = defaultWeeklyLogRuntime().newTimer
}
if runtime.rename == nil {
runtime.rename = os.Rename
}
if runtime.diagnostic == nil {
runtime.diagnostic = os.Stderr
}
now := runtime.now().In(location)
weekStart := logWeekStart(now, location)
if info, err := os.Stat(path); err == nil {
weekStart = logWeekStart(info.ModTime(), location)
} else if !errors.Is(err, os.ErrNotExist) {
return nil, fmt.Errorf("inspect active log: %w", err)
}
file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o666)
if err != nil {
return nil, err
}
writer := &weeklyLogWriter{
path: path,
location: location,
now: runtime.now,
newTimer: runtime.newTimer,
rename: runtime.rename,
diagnostic: runtime.diagnostic,
file: file,
weekStart: weekStart,
stop: make(chan struct{}),
done: make(chan struct{}),
}
writer.rotateIfNeeded(now)
go writer.run()
return writer, nil
}
func (w *weeklyLogWriter) Write(data []byte) (int, error) {
now := w.now().In(w.location)
w.mu.Lock()
rotationErr := w.rotateIfNeededLocked(now)
if w.closed || w.file == nil {
w.mu.Unlock()
w.reportRotationError(rotationErr)
return 0, os.ErrClosed
}
n, writeErr := w.file.Write(data)
w.mu.Unlock()
w.reportRotationError(rotationErr)
return n, writeErr
}
func (w *weeklyLogWriter) Close() error {
w.closeOnce.Do(func() {
close(w.stop)
<-w.done
w.mu.Lock()
w.closed = true
if w.file != nil {
w.closeErr = w.file.Close()
w.file = nil
}
w.mu.Unlock()
})
return w.closeErr
}
func (w *weeklyLogWriter) run() {
defer close(w.done)
for {
now := w.now().In(w.location)
next := nextLogWeekStart(now, w.location)
duration := next.Sub(now)
if duration <= 0 {
duration = time.Nanosecond
}
timer := w.newTimer(duration)
select {
case <-timer.C():
w.rotateIfNeeded(w.now().In(w.location))
case <-w.stop:
timer.Stop()
return
}
}
}
func (w *weeklyLogWriter) rotateIfNeeded(now time.Time) {
w.mu.Lock()
err := w.rotateIfNeededLocked(now)
w.mu.Unlock()
w.reportRotationError(err)
}
func (w *weeklyLogWriter) rotateIfNeededLocked(now time.Time) error {
if w.closed {
return nil
}
targetWeek := logWeekStart(now, w.location)
if !targetWeek.After(w.weekStart) {
return nil
}
// Record the attempted week even if rotation fails so every write in a
// broken environment does not retry and emit another diagnostic.
w.weekStart = targetWeek
return w.rotateLocked()
}
func (w *weeklyLogWriter) rotateLocked() error {
if w.file == nil {
return fmt.Errorf("active log file is unavailable")
}
if err := w.file.Close(); err != nil {
w.file = nil
return errors.Join(fmt.Errorf("close active log: %w", err), w.reopenActiveLocked())
}
w.file = nil
if err := w.cleanupOlderGenerationsLocked(); err != nil {
return errors.Join(err, w.reopenActiveLocked())
}
if err := removeIfExists(w.generationPath(weeklyLogRetention)); err != nil {
return errors.Join(fmt.Errorf("remove oldest weekly log: %w", err), w.reopenActiveLocked())
}
for generation := weeklyLogRetention - 1; generation >= 1; generation-- {
source := w.generationPath(generation)
if _, err := os.Stat(source); err != nil {
if errors.Is(err, os.ErrNotExist) {
continue
}
return errors.Join(fmt.Errorf("inspect weekly log generation %d: %w", generation, err), w.reopenActiveLocked())
}
if err := w.rename(source, w.generationPath(generation+1)); err != nil {
return errors.Join(fmt.Errorf("shift weekly log generation %d: %w", generation, err), w.reopenActiveLocked())
}
}
activeRenamed := false
if _, err := os.Stat(w.path); err == nil {
if err := w.rename(w.path, w.generationPath(1)); err != nil {
return errors.Join(fmt.Errorf("archive active log: %w", err), w.reopenActiveLocked())
}
activeRenamed = true
} else if !errors.Is(err, os.ErrNotExist) {
return errors.Join(fmt.Errorf("inspect active log: %w", err), w.reopenActiveLocked())
}
file, err := os.OpenFile(w.path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o666)
if err == nil {
w.file = file
return nil
}
rotationErr := fmt.Errorf("open new active log: %w", err)
if activeRenamed {
if rollbackErr := w.rename(w.generationPath(1), w.path); rollbackErr != nil {
rotationErr = errors.Join(rotationErr, fmt.Errorf("restore archived active log: %w", rollbackErr))
}
}
return errors.Join(rotationErr, w.reopenActiveLocked())
}
func (w *weeklyLogWriter) cleanupOlderGenerationsLocked() error {
directory := filepath.Dir(w.path)
entries, err := os.ReadDir(directory)
if err != nil {
return fmt.Errorf("list weekly log directory: %w", err)
}
base := filepath.Base(w.path)
extension := filepath.Ext(base)
stem := strings.TrimSuffix(base, extension)
prefix := stem + "."
for _, entry := range entries {
if entry.IsDir() {
continue
}
name := entry.Name()
if !strings.HasPrefix(name, prefix) || !strings.HasSuffix(name, extension) {
continue
}
generationText := strings.TrimSuffix(strings.TrimPrefix(name, prefix), extension)
generation, err := strconv.Atoi(generationText)
if err != nil || generation <= weeklyLogRetention {
continue
}
if err := os.Remove(filepath.Join(directory, name)); err != nil && !errors.Is(err, os.ErrNotExist) {
return fmt.Errorf("remove weekly log generation %d: %w", generation, err)
}
}
return nil
}
func (w *weeklyLogWriter) reopenActiveLocked() error {
file, err := os.OpenFile(w.path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o666)
if err != nil {
return fmt.Errorf("reopen active log: %w", err)
}
w.file = file
return nil
}
func (w *weeklyLogWriter) generationPath(generation int) string {
extension := filepath.Ext(w.path)
stem := strings.TrimSuffix(w.path, extension)
return fmt.Sprintf("%s.%d%s", stem, generation, extension)
}
func (w *weeklyLogWriter) reportRotationError(err error) {
if err == nil {
return
}
slog.New(slog.NewJSONHandler(w.diagnostic, nil)).Warn(
"weekly log rotation failed",
"module", "logging",
"action", "weekly_log_rotation_failed",
"path", w.path,
"error.message", err.Error(),
)
}
func logWeekStart(value time.Time, location *time.Location) time.Time {
local := value.In(location)
daysSinceMonday := (int(local.Weekday()) + 6) % 7
monday := local.AddDate(0, 0, -daysSinceMonday)
return time.Date(monday.Year(), monday.Month(), monday.Day(), 0, 0, 0, 0, location)
}
func nextLogWeekStart(value time.Time, location *time.Location) time.Time {
return logWeekStart(value, location).AddDate(0, 0, 7)
}
func removeIfExists(path string) error {
err := os.Remove(path)
if errors.Is(err, fs.ErrNotExist) {
return nil
}
return err
}
+387
View File
@@ -0,0 +1,387 @@
package logging
import (
"bytes"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
log "github.com/sirupsen/logrus"
)
func TestWeeklyLogRotationShiftsAndRetainsExactGenerations(t *testing.T) {
directory := t.TempDir()
path := filepath.Join(directory, "hardlink.log")
writeLogTestFile(t, path, "active")
for generation := 1; generation <= 14; generation++ {
writeLogTestFile(t, weeklyLogTestGeneration(path, generation), fmt.Sprintf("generation-%d", generation))
}
writeLogTestFile(t, weeklyLogTestGeneration(path, 19), "generation-19")
for name, contents := range map[string]string{
"hardlink.backup.14.log": "related-looking backup",
"another.14.log": "unrelated log",
"hardlink.14.log.bak": "different extension",
} {
writeLogTestFile(t, filepath.Join(directory, name), contents)
}
sunday := time.Date(2026, time.August, 9, 12, 0, 0, 0, time.UTC)
setLogTestModTime(t, path, sunday)
writer := newLogTestWriter(t, path, sunday, weeklyLogRuntime{})
writer.rotateIfNeeded(time.Date(2026, time.August, 10, 0, 0, 0, 0, time.UTC))
if err := writer.Close(); err != nil {
t.Fatal(err)
}
requireLogTestContents(t, path, "")
requireLogTestContents(t, weeklyLogTestGeneration(path, 1), "active")
requireLogTestContents(t, weeklyLogTestGeneration(path, 2), "generation-1")
requireLogTestContents(t, weeklyLogTestGeneration(path, 13), "generation-12")
for _, generation := range []int{14, 19} {
if _, err := os.Stat(weeklyLogTestGeneration(path, generation)); !errors.Is(err, os.ErrNotExist) {
t.Errorf("generation %d exists after rotation, want removed: %v", generation, err)
}
}
for name, contents := range map[string]string{
"hardlink.backup.14.log": "related-looking backup",
"another.14.log": "unrelated log",
"hardlink.14.log.bak": "different extension",
} {
requireLogTestContents(t, filepath.Join(directory, name), contents)
}
}
func TestWeeklyLogRotationOccursOncePerWeek(t *testing.T) {
directory := t.TempDir()
path := filepath.Join(directory, "hardlink.log")
writeLogTestFile(t, path, "week-zero\n")
sunday := time.Date(2026, time.January, 4, 18, 0, 0, 0, time.UTC)
setLogTestModTime(t, path, sunday)
writer := newLogTestWriter(t, path, sunday, weeklyLogRuntime{})
writer.rotateIfNeeded(time.Date(2026, time.January, 4, 23, 59, 59, 0, time.UTC))
if _, err := os.Stat(weeklyLogTestGeneration(path, 1)); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("rotation before Monday: %v, want no generation", err)
}
writer.rotateIfNeeded(time.Date(2026, time.January, 5, 0, 0, 0, 0, time.UTC))
if _, err := writer.Write([]byte("week-one\n")); err != nil {
t.Fatal(err)
}
writer.rotateIfNeeded(time.Date(2026, time.January, 6, 12, 0, 0, 0, time.UTC))
if err := writer.Close(); err != nil {
t.Fatal(err)
}
requireLogTestContents(t, weeklyLogTestGeneration(path, 1), "week-zero\n")
requireLogTestContents(t, path, "week-one\n")
if _, err := os.Stat(weeklyLogTestGeneration(path, 2)); !errors.Is(err, os.ErrNotExist) {
t.Errorf("same-week rotation created generation 2: %v", err)
}
}
func TestWeeklyLogStartupRotatesOnceAfterSeveralMissedWeeks(t *testing.T) {
directory := t.TempDir()
path := filepath.Join(directory, "hardlink.log")
writeLogTestFile(t, path, "old active")
writeLogTestFile(t, weeklyLogTestGeneration(path, 1), "older history")
setLogTestModTime(t, path, time.Date(2026, time.January, 5, 12, 0, 0, 0, time.UTC))
now := time.Date(2026, time.February, 23, 9, 0, 0, 0, time.UTC)
writer := newLogTestWriter(t, path, now, weeklyLogRuntime{})
if err := writer.Close(); err != nil {
t.Fatal(err)
}
requireLogTestContents(t, weeklyLogTestGeneration(path, 1), "old active")
requireLogTestContents(t, weeklyLogTestGeneration(path, 2), "older history")
if _, err := os.Stat(weeklyLogTestGeneration(path, 3)); !errors.Is(err, os.ErrNotExist) {
t.Errorf("missed weeks created generation 3: %v", err)
}
}
func TestWeeklyLogSchedulerUsesLocalMondayBoundary(t *testing.T) {
location, err := time.LoadLocation("Europe/London")
if err != nil {
t.Fatal(err)
}
directory := t.TempDir()
path := filepath.Join(directory, "hardlink.log")
writeLogTestFile(t, path, "sunday")
sunday := time.Date(2026, time.March, 29, 0, 0, 0, 0, location)
setLogTestModTime(t, path, sunday)
clock := &atomic.Pointer[time.Time]{}
clock.Store(&sunday)
created := make(chan *logTestTimer, 2)
rotated := make(chan struct{})
runtime := weeklyLogRuntime{
now: func() time.Time { return *clock.Load() },
newTimer: func(duration time.Duration) logRotationTimer {
timer := &logTestTimer{duration: duration, ch: make(chan time.Time, 1)}
created <- timer
return timer
},
rename: func(oldPath, newPath string) error {
err := os.Rename(oldPath, newPath)
if oldPath == path && err == nil {
close(rotated)
}
return err
},
}
writer, err := newWeeklyLogWriter(path, location, runtime)
if err != nil {
t.Fatal(err)
}
timer := <-created
if timer.duration != 23*time.Hour {
t.Fatalf("timer duration = %v, want 23h across DST boundary", timer.duration)
}
monday := time.Date(2026, time.March, 30, 0, 0, 0, 0, location)
clock.Store(&monday)
timer.ch <- monday
<-rotated
if err := writer.Close(); err != nil {
t.Fatal(err)
}
requireLogTestContents(t, weeklyLogTestGeneration(path, 1), "sunday")
}
func TestWeeklyLogConcurrentWritesRemainCompleteAcrossRotation(t *testing.T) {
directory := t.TempDir()
path := filepath.Join(directory, "hardlink.log")
sunday := time.Date(2026, time.August, 9, 12, 0, 0, 0, time.UTC)
writer := newLogTestWriter(t, path, sunday, weeklyLogRuntime{})
const goroutines = 8
const recordsPerGoroutine = 100
writeErrors := make(chan error, goroutines)
var writers sync.WaitGroup
writers.Add(goroutines)
for worker := 0; worker < goroutines; worker++ {
go func() {
defer writers.Done()
for record := 0; record < recordsPerGoroutine; record++ {
if _, err := writer.Write([]byte(fmt.Sprintf("%d:%d\n", worker, record))); err != nil {
writeErrors <- err
return
}
}
}()
}
writer.rotateIfNeeded(time.Date(2026, time.August, 10, 0, 0, 0, 0, time.UTC))
writers.Wait()
close(writeErrors)
for err := range writeErrors {
t.Errorf("weeklyLogWriter.Write() error = %v, want nil", err)
}
if err := writer.Close(); err != nil {
t.Fatal(err)
}
contents := readLogTestFile(t, weeklyLogTestGeneration(path, 1)) + readLogTestFile(t, path)
lines := strings.Split(strings.TrimSpace(contents), "\n")
if len(lines) != goroutines*recordsPerGoroutine {
t.Fatalf("record count = %d, want %d", len(lines), goroutines*recordsPerGoroutine)
}
seen := make(map[string]bool, len(lines))
for _, line := range lines {
if _, _, ok := strings.Cut(line, ":"); !ok {
t.Fatalf("record %q has no separator", line)
}
seen[line] = true
}
if len(seen) != goroutines*recordsPerGoroutine {
t.Errorf("unique record count = %d, want %d", len(seen), goroutines*recordsPerGoroutine)
}
}
func TestWeeklyLogCloseWaitsForRotationAndIsIdempotent(t *testing.T) {
directory := t.TempDir()
path := filepath.Join(directory, "hardlink.log")
writeLogTestFile(t, path, "active")
sunday := time.Date(2026, time.August, 9, 12, 0, 0, 0, time.UTC)
setLogTestModTime(t, path, sunday)
started := make(chan struct{})
release := make(chan struct{})
runtime := weeklyLogRuntime{rename: func(oldPath, newPath string) error {
if oldPath == path {
close(started)
<-release
}
return os.Rename(oldPath, newPath)
}}
writer := newLogTestWriter(t, path, sunday, runtime)
rotationDone := make(chan struct{})
go func() {
writer.rotateIfNeeded(time.Date(2026, time.August, 10, 0, 0, 0, 0, time.UTC))
close(rotationDone)
}()
<-started
closeDone := make(chan error, 1)
go func() { closeDone <- writer.Close() }()
select {
case err := <-closeDone:
t.Fatalf("weeklyLogWriter.Close() during rotation returned %v, want blocked", err)
case <-time.After(20 * time.Millisecond):
}
close(release)
<-rotationDone
if err := <-closeDone; err != nil {
t.Fatal(err)
}
if err := writer.Close(); err != nil {
t.Errorf("second weeklyLogWriter.Close() error = %v, want nil", err)
}
if _, err := writer.Write([]byte("after close")); !errors.Is(err, os.ErrClosed) {
t.Errorf("weeklyLogWriter.Write() after close error = %v, want os.ErrClosed", err)
}
}
func TestWeeklyLogRotationFailureIsNonRecursiveAndPreservesWrites(t *testing.T) {
directory := t.TempDir()
path := filepath.Join(directory, "hardlink.log")
writeLogTestFile(t, path, "before\n")
sunday := time.Date(2026, time.August, 9, 12, 0, 0, 0, time.UTC)
setLogTestModTime(t, path, sunday)
var diagnostics bytes.Buffer
runtime := weeklyLogRuntime{
rename: func(oldPath, newPath string) error {
if oldPath == path {
return errors.New("injected rename failure")
}
return os.Rename(oldPath, newPath)
},
diagnostic: &diagnostics,
}
writer := newLogTestWriter(t, path, sunday, runtime)
writer.rotateIfNeeded(time.Date(2026, time.August, 10, 0, 0, 0, 0, time.UTC))
if _, err := writer.Write([]byte("after\n")); err != nil {
t.Fatalf("weeklyLogWriter.Write() after failed rotation error = %v, want nil", err)
}
if err := writer.Close(); err != nil {
t.Fatal(err)
}
requireLogTestContents(t, path, "before\nafter\n")
if !strings.Contains(diagnostics.String(), "weekly_log_rotation_failed") || !strings.Contains(diagnostics.String(), "injected rename failure") {
t.Errorf("rotation diagnostic = %q, want action and injected error", diagnostics.String())
}
if strings.Contains(readLogTestFile(t, path), "weekly log rotation failed") {
t.Error("rotation diagnostic recursively entered active log")
}
}
func TestSetupLoggingKeepsFilenameAndJSONFormat(t *testing.T) {
logger := log.StandardLogger()
previousOutput := logger.Out
previousFormatter := logger.Formatter
previousLevel := logger.Level
t.Cleanup(func() {
logger.SetOutput(previousOutput)
logger.SetFormatter(previousFormatter)
logger.SetLevel(previousLevel)
})
directory := filepath.Join(t.TempDir(), "nested", "logs")
writer, err := SetupLogging(directory, "hardlink", "v-test")
if err != nil {
t.Fatal(err)
}
log.WithField("probe", "value").Info("test record")
if err := writer.Close(); err != nil {
t.Fatal(err)
}
contents := readLogTestFile(t, filepath.Join(directory, "hardlink.log"))
for _, want := range []string{`"buildVersion":"v-test"`, `"msg":"Logging initialized"`, `"probe":"value"`, `"msg":"test record"`} {
if !strings.Contains(contents, want) {
t.Errorf("hardlink.log contents missing %q: %s", want, contents)
}
}
if _, err := os.Stat(filepath.Join(directory, "hardlink.1.log")); !errors.Is(err, os.ErrNotExist) {
t.Errorf("SetupLogging() created archive during current week: %v", err)
}
}
type logTestTimer struct {
duration time.Duration
ch chan time.Time
stopped atomic.Bool
}
func (t *logTestTimer) C() <-chan time.Time {
return t.ch
}
func (t *logTestTimer) Stop() bool {
return !t.stopped.Swap(true)
}
func newLogTestWriter(t *testing.T, path string, now time.Time, overrides weeklyLogRuntime) *weeklyLogWriter {
t.Helper()
runtime := defaultWeeklyLogRuntime()
runtime.now = func() time.Time { return now }
if overrides.now != nil {
runtime.now = overrides.now
}
if overrides.newTimer != nil {
runtime.newTimer = overrides.newTimer
}
if overrides.rename != nil {
runtime.rename = overrides.rename
}
if overrides.diagnostic != nil {
runtime.diagnostic = overrides.diagnostic
}
writer, err := newWeeklyLogWriter(path, now.Location(), runtime)
if err != nil {
t.Fatal(err)
}
return writer
}
func weeklyLogTestGeneration(path string, generation int) string {
extension := filepath.Ext(path)
return fmt.Sprintf("%s.%d%s", strings.TrimSuffix(path, extension), generation, extension)
}
func writeLogTestFile(t *testing.T, path, contents string) {
t.Helper()
if err := os.WriteFile(path, []byte(contents), 0o600); err != nil {
t.Fatal(err)
}
}
func setLogTestModTime(t *testing.T, path string, value time.Time) {
t.Helper()
if err := os.Chtimes(path, value, value); err != nil {
t.Fatal(err)
}
}
func readLogTestFile(t *testing.T, path string) string {
t.Helper()
contents, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
return string(contents)
}
func requireLogTestContents(t *testing.T, path, want string) {
t.Helper()
if got := readLogTestFile(t, path); got != want {
t.Errorf("%s contents = %q, want %q", filepath.Base(path), got, want)
}
}
var _ io.WriteCloser = (*weeklyLogWriter)(nil)
+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"`
+157 -93
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)
}
@@ -245,95 +230,174 @@ func printCardholderReceipt(cardholderReceipt string) error {
return nil
}
// receiptColumns follows the existing 44-column normal-size text convention.
const receiptColumns = 44
func BuildCardholderReceipt(entries []ReceiptEntryXML) ([]byte, error) {
var buf bytes.Buffer
rendered := make([]bool, len(entries))
take := func(id string) string {
for i, entry := range entries {
if !rendered[i] && entry.ReceiptEntryId == id && entry.Value != "" {
rendered[i] = true
return receiptEntryText(entry)
}
}
return ""
}
write := func(b []byte) { buf.Write(b) }
// writeStr := func(s string) { buf.WriteString(s) }
writeln := func(s string) {
buf.WriteString(s)
// Set and restore only text state; leave printer setup and transport alone.
normal := func() { buf.Write([]byte{ESC, 'a', 0, ESC, 'E', BOLD_OFF, GS, '!', NORMAL_FONT}) }
normal()
hasRows, newSection := false, false
beginLine := func(center bool) {
if hasRows && newSection {
buf.WriteString(strings.Repeat("-", receiptColumns) + "\n")
}
hasRows, newSection = true, false
if center {
buf.Write([]byte{ESC, 'a', CENTER})
}
}
text := func(value string, bold bool) {
if bold {
buf.Write([]byte{ESC, 'E', BOLD_ON})
}
buf.WriteString(value)
if bold {
buf.Write([]byte{ESC, 'E', BOLD_OFF})
}
}
line := func(value string, bold, center bool) {
if value == "" {
return
}
beginLine(center)
text(value, bold)
buf.WriteByte('\n')
normal()
}
pair := func(left, right string, boldRight bool) {
if gap, fits := receiptPairGap(left, right); fits {
beginLine(false)
text(left+gap, false)
text(right, boldRight)
buf.WriteByte('\n')
normal()
return
}
line(left, false, false)
line(right, boldRight, false)
}
// Build a lookup map by ReceiptEntryId
m := make(map[string]ReceiptEntryXML, len(entries))
for _, e := range entries {
m[e.ReceiptEntryId] = e
line(take("Recipient"), true, true)
line(take("MerchantName"), false, true)
newSection = true
line(take("CardScheme"), false, false)
line(take("PanMasked"), false, false)
pair(take("Aid"), take("PanSequence"), false)
pair(take("TransactionSource"), take("TransactionType"), false)
newSection = true
// Align the provider amount without parsing or modifying its value.
for i, entry := range entries {
if entry.ReceiptEntryId == "TotalAmount" && entry.Value != "" {
rendered[i] = true
label := entry.Label
if label == "" {
label = "TOTAL"
}
label = strings.TrimSuffix(label, ":") + ":"
if gap, fits := receiptPairGap(label, entry.Value); fits {
line(label+gap+entry.Value, true, false)
} else {
line(receiptEntryText(entry), true, false)
}
break
}
}
// Utility to center text
// center := func(s string) {
// write([]byte{ESC, 'a', CENTER})
// writeln(s)
// write([]byte{ESC, 'a', 0})
// }
// Utility for bold lines
// boldOn := func() { write([]byte{GS, '!', WIDER_FONT}) }
// boldOff := func() { write([]byte{GS, '!', NORMAL_FONT}) }
// boldOn()
// 1) Header: CARDHOLDER COPY
writeln(m["Recipient"].Value)
// writeStr("\n\n")
// 2) Merchant name
writeln(m["MerchantName"].Value)
// writeStr("\n\n")
// 3) AID
writeln("AID: " + m["Aid"].Value)
// 4) Card scheme & pan
writeln(fmt.Sprintf("%s Card: %s", m["CardScheme"].Value, m["PanMasked"].Value))
// 5) PAN Seq No
writeln("PAN Seq No: " + m["PanSequence"].Value)
// 6) Transaction source
writeln(m["TransactionSource"].Value)
// 7) Transaction type (Sale/Account Verification)
writeln(m["TransactionType"].Value)
// 8) Total
// assuming value like "GBP1.50" — insert space after currency
total := m["TotalAmount"].Value
if !strings.HasPrefix(total, "GBP") && len(total) > 3 {
total = total[:3] + " " + total[3:]
pair(take("CardholderVerification"), take("TransactionResult"), true)
newSection = true
line(take("AuthCode"), false, false)
line(take("AuthReference"), false, false)
line(take("TransactionSeqNumber"), false, false)
pair(take("MerchantIdMasked"), take("TerminalIdMasked"), false)
line(take("AuthDateTime"), false, false)
footer := take("RetentionMessage")
// Preserve every remaining occurrence, including unknown IDs, in provider order.
for i, entry := range entries {
if !rendered[i] && entry.Value != "" {
line(receiptEntryText(entry), false, false)
}
}
writeln("TOTAL: " + total)
// 9) Cardholder verification
writeln(m["CardholderVerification"].Value)
// 10) Approved/Declined
writeln(m["TransactionResult"].Value)
// 11) Auth code
writeln("Auth Code: " + m["AuthCode"].Value)
// 12) Reference
writeln("Ref: " + m["AuthReference"].Value)
// 13) Merchant & terminal IDs
writeln("MID: " + m["MerchantIdMasked"].Value)
writeln("TID: " + m["TerminalIdMasked"].Value)
// 14) Date/time
writeln(m["AuthDateTime"].Value)
// 15) Retention message
writeln(m["RetentionMessage"].Value)
// boldOff()
// finally feed & cut
write([]byte{ESC, 'd', 7}) // Feed 5 lines
write([]byte{GS, 'V', 1})
newSection = true
line(footer, false, true)
normal()
buf.Write([]byte{ESC, 'd', 7})
buf.Write([]byte{GS, 'V', 1})
return buf.Bytes(), nil
}
func receiptEntryText(entry ReceiptEntryXML) string {
label := entry.Label
if label == "" {
switch entry.ReceiptEntryId {
case "Recipient", "MerchantName", "CardScheme", "TransactionSource", "TransactionType",
"CardholderVerification", "TransactionResult", "AuthDateTime", "RetentionMessage":
return entry.Value
case "PanMasked":
label = "Card"
case "Aid":
label = "AID"
case "PanSequence":
label = "PAN Seq No"
case "TotalAmount":
label = "TOTAL"
case "AuthCode":
label = "Auth Code"
case "AuthReference":
label = "Ref"
case "TransactionSeqNumber":
label = "Transaction Seq. No"
case "MerchantIdMasked":
label = "MID"
case "TerminalIdMasked":
label = "TID"
default:
var readable strings.Builder
runes := []rune(entry.ReceiptEntryId)
for i, r := range runes {
if i > 0 && r >= 'A' && r <= 'Z' &&
((runes[i-1] >= 'a' && runes[i-1] <= 'z') ||
(i+1 < len(runes) && runes[i+1] >= 'a' && runes[i+1] <= 'z')) {
readable.WriteByte(' ')
}
if r == '_' || r == '-' {
r = ' '
}
readable.WriteRune(r)
}
label = strings.TrimSpace(readable.String())
}
}
if label == "" {
return entry.Value
}
return strings.TrimSuffix(label, ":") + ": " + entry.Value
}
func receiptPairGap(left, right string) (string, bool) {
if left == "" || right == "" || len(left)+2+len(right) > receiptColumns {
return "", false
}
// Only printable ASCII has a predictable single-column width here.
for _, r := range left + right {
if r < ' ' || r > '~' {
return "", false
}
}
return strings.Repeat(" ", receiptColumns-len(left)-len(right)), true
}
func printLogo(path string) ([]byte, error) {
const maxLogoWidth = 384
f, err := os.Open(path)
+280
View File
@@ -0,0 +1,280 @@
package printer
import (
"bytes"
"reflect"
"strings"
"testing"
)
type receiptTestChar struct {
value byte
center, bold bool
}
type receiptTestOutput struct {
lines []string
chars []receiptTestChar
feeds, cuts int
}
// readReceiptText understands only the commands emitted by this receipt builder.
func readReceiptText(t *testing.T, data []byte) receiptTestOutput {
t.Helper()
var out receiptTestOutput
var line strings.Builder
var center, bold bool
for i := 0; i < len(data); {
if data[i] == ESC || data[i] == GS {
if i+2 >= len(data) {
t.Fatalf("BuildCardholderReceipt control bytes = %v, want complete command", data[i:])
}
prefix, command, value := data[i], data[i+1], data[i+2]
switch {
case prefix == ESC && command == 'a':
if value != 0 && value != CENTER {
t.Errorf("receipt alignment = %d, want left or center", value)
}
center = value == CENTER
case prefix == ESC && command == 'E':
if value != BOLD_OFF && value != BOLD_ON {
t.Errorf("receipt bold = %d, want on or off", value)
}
bold = value == BOLD_ON
case prefix == GS && command == '!':
if value != NORMAL_FONT {
t.Errorf("receipt size = %d, want normal size", value)
}
case prefix == ESC && command == 'd':
out.feeds++
if value != 7 || center || bold || i != len(data)-6 {
t.Errorf("receipt feed = %d, center=%t bold=%t offset=%d, want final seven-line feed in normal state", value, center, bold, i)
}
case prefix == GS && command == 'V':
out.cuts++
if value != 1 || i != len(data)-3 {
t.Errorf("receipt cut = %d at %d, want final GS V 1", value, i)
}
default:
t.Fatalf("BuildCardholderReceipt command = %v, want supported text command", data[i:i+3])
}
i += 3
continue
}
if data[i] == '\n' {
out.lines = append(out.lines, line.String())
line.Reset()
} else {
line.WriteByte(data[i])
out.chars = append(out.chars, receiptTestChar{value: data[i], center: center, bold: bold})
}
i++
}
if line.Len() != 0 || center || bold || out.feeds != 1 || out.cuts != 1 {
t.Errorf("receipt termination: trailing=%q center=%t bold=%t feeds=%d cuts=%d, want normal state and one feed/cut", line.String(), center, bold, out.feeds, out.cuts)
}
return out
}
func buildReceiptText(t *testing.T, entries []ReceiptEntryXML) receiptTestOutput {
t.Helper()
before := append([]ReceiptEntryXML(nil), entries...)
data, err := BuildCardholderReceipt(entries)
if err != nil {
t.Fatalf("BuildCardholderReceipt(%v) error = %v, want nil", entries, err)
}
if !reflect.DeepEqual(entries, before) {
t.Errorf("BuildCardholderReceipt input = %v, want unchanged %v", entries, before)
}
if !bytes.HasSuffix(data, []byte{ESC, 'd', 7, GS, 'V', 1}) {
t.Errorf("BuildCardholderReceipt suffix = %v, want unchanged feed/cut", data)
}
return readReceiptText(t, data)
}
func sampleReceipt(recipient string) []ReceiptEntryXML {
return []ReceiptEntryXML{
{ReceiptEntryId: "Recipient", Value: recipient},
{ReceiptEntryId: "MerchantName", Value: "Standard Test Merchant"},
{ReceiptEntryId: "Aid", Value: "A0000000031010", Label: "AID"},
{ReceiptEntryId: "CardScheme", Value: "VISA DEBIT"},
{ReceiptEntryId: "PanMasked", Value: "************1133", Label: "Card"},
{ReceiptEntryId: "PanSequence", Value: "01", Label: "PAN Seq No"},
{ReceiptEntryId: "TransactionSource", Value: "ICC"},
{ReceiptEntryId: "TransactionType", Value: "SALE"},
{ReceiptEntryId: "TotalAmount", Value: "GBP120.00", Label: "TOTAL"},
{ReceiptEntryId: "CardholderVerification", Value: "PIN VERIFIED"},
{ReceiptEntryId: "TransactionResult", Value: "APPROVED"},
{ReceiptEntryId: "AuthCode", Value: "D0A35D", Label: "Auth Code"},
{ReceiptEntryId: "AuthReference", Value: "ChipDNA-Sale-20260908144731", Label: "Ref"},
{ReceiptEntryId: "MerchantIdMasked", Value: "******7897", Label: "MID"},
{ReceiptEntryId: "TerminalIdMasked", Value: "****9508", Label: "TID"},
{ReceiptEntryId: "TransactionSeqNumber", Value: "00001059", Label: "Transaction Seq. No"},
{ReceiptEntryId: "AuthDateTime", Value: "08/09/2026 14:48:06"},
{ReceiptEntryId: "RetentionMessage", Value: "Please retain for your records"},
}
}
func TestBuildCardholderReceiptCompleteLayout(t *testing.T) {
for _, recipient := range []string{"CARDHOLDER COPY", "MERCHANT COPY"} {
t.Run(recipient, func(t *testing.T) {
entries := sampleReceipt(recipient)
out := buildReceiptText(t, entries)
// Ignore padding used for left/right placement, not semantic row order.
var rows []string
for _, line := range out.lines {
rows = append(rows, strings.Join(strings.Fields(line), " "))
}
rule := strings.Repeat("-", 44)
want := []string{recipient, "Standard Test Merchant", rule, "VISA DEBIT", "Card: ************1133",
"AID: A0000000031010 PAN Seq No: 01", "ICC SALE", rule, "TOTAL: GBP120.00", "PIN VERIFIED APPROVED", rule,
"Auth Code: D0A35D", "Ref: ChipDNA-Sale-20260908144731", "Transaction Seq. No: 00001059",
"MID: ******7897 TID: ****9508", "08/09/2026 14:48:06", rule, "Please retain for your records"}
if !reflect.DeepEqual(rows, want) {
t.Errorf("BuildCardholderReceipt(%q) rows = %q, want %q", recipient, rows, want)
}
for _, entry := range entries {
if !strings.Contains(strings.Join(out.lines, "\n"), entry.Value) {
t.Errorf("BuildCardholderReceipt(%q) lost %s=%q", recipient, entry.ReceiptEntryId, entry.Value)
}
}
for _, line := range out.lines {
if line == "" || len(line) > 44 {
t.Errorf("BuildCardholderReceipt(%q) row = %q, want compact nonempty row within 44 columns", recipient, line)
}
}
if len(out.lines) > 19 {
t.Errorf("BuildCardholderReceipt(%q) rows = %d, want representative receipt at most 19", recipient, len(out.lines))
}
})
}
}
func TestBuildCardholderReceiptFormattingState(t *testing.T) {
out := buildReceiptText(t, sampleReceipt("CARDHOLDER COPY"))
var plain strings.Builder
for _, char := range out.chars {
plain.WriteByte(char.value)
}
for _, tc := range []struct {
text string
center, bold bool
}{
{"CARDHOLDER COPY", true, true}, {"Standard Test Merchant", true, false},
{"VISA DEBIT", false, false}, {"TOTAL:", false, true}, {"GBP120.00", false, true},
{"PIN VERIFIED", false, false}, {"APPROVED", false, true}, {"Auth Code:", false, false},
{"Please retain for your records", true, false},
} {
start := strings.Index(plain.String(), tc.text)
if start < 0 {
t.Fatalf("receipt text lacks %q", tc.text)
}
for _, char := range out.chars[start : start+len(tc.text)] {
if char.center != tc.center || char.bold != tc.bold {
t.Errorf("receipt style for %q = center:%t bold:%t, want center:%t bold:%t", tc.text, char.center, char.bold, tc.center, tc.bold)
break
}
}
}
}
func TestBuildCardholderReceiptMissingFields(t *testing.T) {
for _, tc := range []struct {
name string
entries []ReceiptEntryXML
want []string
}{
{name: "empty"},
{name: "empty values", entries: []ReceiptEntryXML{{ReceiptEntryId: "Aid", Label: "AID"}, {ReceiptEntryId: "Unknown", Label: "Unused"}}},
{name: "one partner", entries: []ReceiptEntryXML{{ReceiptEntryId: "PanSequence", Value: "02"}}, want: []string{"PAN Seq No: 02"}},
{name: "result only", entries: []ReceiptEntryXML{{ReceiptEntryId: "TransactionResult", Value: "DECLINED"}}, want: []string{"DECLINED"}},
} {
t.Run(tc.name, func(t *testing.T) {
out := buildReceiptText(t, tc.entries)
if !reflect.DeepEqual(out.lines, tc.want) {
t.Errorf("BuildCardholderReceipt(%v) rows = %q, want %q", tc.entries, out.lines, tc.want)
}
})
}
}
func TestBuildCardholderReceiptPreservesRemainingEntries(t *testing.T) {
entries := []ReceiptEntryXML{
{ReceiptEntryId: "AuthCode", Value: ""},
{ReceiptEntryId: "FooBar", Value: "first-extra", Priority: "9"},
{ReceiptEntryId: "AuthCode", Value: "primary", Label: "Provider authorization"},
{ReceiptEntryId: "AuthCode", Value: "duplicate", Label: "Second authorization"},
{ReceiptEntryId: "FooBar", Value: "second-extra", Label: "Foo", Priority: "1"},
{ReceiptEntryId: "RetentionMessage", Value: "Retain this"},
{ReceiptEntryId: "RetentionMessage", Value: "Extra retention"},
{ReceiptEntryId: "HTTPCode", Value: "provider-code"},
{Value: "unlabelled-value"},
}
out := buildReceiptText(t, entries)
want := []string{"Provider authorization: primary", "Foo Bar: first-extra", "Second authorization: duplicate",
"Foo: second-extra", "Extra retention", "HTTP Code: provider-code", "unlabelled-value", strings.Repeat("-", 44), "Retain this"}
if !reflect.DeepEqual(out.lines, want) {
t.Errorf("BuildCardholderReceipt remaining rows = %q, want %q", out.lines, want)
}
}
func TestBuildCardholderReceiptPairBoundaries(t *testing.T) {
for _, tc := range []struct {
name, left, right string
paired bool
}{
{"short", "ICC", "SALE", true},
{"exact width", strings.Repeat("L", 20), strings.Repeat("R", 22), true},
{"overflow", strings.Repeat("L", 21), strings.Repeat("R", 22), false},
{"unicode", "TAP \u00c9", "SALE", false},
{"multiline", "ICC\nFALLBACK", "SALE", false},
{"left missing", "", "SALE", false},
{"right missing", "ICC", "", false},
} {
t.Run(tc.name, func(t *testing.T) {
out := buildReceiptText(t, []ReceiptEntryXML{{ReceiptEntryId: "TransactionSource", Value: tc.left}, {ReceiptEntryId: "TransactionType", Value: tc.right}})
var want []string
if tc.paired {
want = []string{tc.left + strings.Repeat(" ", 44-len(tc.left)-len(tc.right)) + tc.right}
} else {
if tc.left != "" {
want = append(want, strings.Split(tc.left, "\n")...)
}
if tc.right != "" {
want = append(want, tc.right)
}
}
if !reflect.DeepEqual(out.lines, want) {
t.Errorf("BuildCardholderReceipt pair(%q,%q) rows = %q, want %q", tc.left, tc.right, out.lines, want)
}
})
}
}
func TestBuildCardholderReceiptLongValuesAndLabels(t *testing.T) {
ref := strings.Repeat("long-reference-", 8)
verify := "CONSUMER DEVICE VERIFICATION WITH ADDITIONAL PROVIDER TEXT"
out := buildReceiptText(t, []ReceiptEntryXML{
{ReceiptEntryId: "CardholderVerification", Value: verify},
{ReceiptEntryId: "TransactionResult", Value: "DECLINED"},
{ReceiptEntryId: "AuthReference", Label: "Provider reference:", Value: ref},
{ReceiptEntryId: "MerchantIdMasked", Label: strings.Repeat("Merchant", 6), Value: "******7897"},
{ReceiptEntryId: "TerminalIdMasked", Value: "****9508"},
})
want := []string{verify, "DECLINED", strings.Repeat("-", 44), "Provider reference: " + ref,
strings.Repeat("Merchant", 6) + ": ******7897", "TID: ****9508"}
if !reflect.DeepEqual(out.lines, want) {
t.Errorf("BuildCardholderReceipt long fields rows = %q, want %q", out.lines, want)
}
}
func TestBuildCardholderReceiptProviderAmounts(t *testing.T) {
for _, amount := range []string{"GBP120.00", "EUR 42,50", "USD1.23", "amount supplied verbatim", strings.Repeat("9", 50)} {
t.Run(amount, func(t *testing.T) {
out := buildReceiptText(t, []ReceiptEntryXML{{ReceiptEntryId: "TotalAmount", Label: "Provider total", Value: amount}})
if len(out.lines) != 1 || !strings.HasPrefix(out.lines[0], "Provider total:") || !strings.HasSuffix(out.lines[0], amount) {
t.Errorf("BuildCardholderReceipt amount(%q) rows = %q, want provider label and unchanged amount", amount, out.lines)
}
})
}
}
+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
}
+1
View File
@@ -10,6 +10,7 @@ const (
ServiceName = "hardlink"
DateOnly = "2006-01-02"
CustomLayout = "2006-01-02 15:04:05 -0700"
LinkStartTransactionStream = "http://127.0.0.1:18181/start-transaction-stream/"
LinkStartTransaction = "http://127.0.0.1:18181/start-transaction/"
LinkConfirmTransaction = "http://127.0.0.1:18181/confirm-transaction/"
LinkTransactionInformation = "http://127.0.0.1:18181/transaction-information/"
+116
View File
@@ -0,0 +1,116 @@
package paymentapi
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strings"
)
// Execute sends exactly one request. Missing, malformed or interrupted results are
// uncertain; this client never retries a financial request.
func Execute(ctx context.Context, client *http.Client, baseURL, operation string, request Request, onStatus func(string)) (Result, error) {
var path string
switch operation {
case Sale:
path = SalePath
if request.Amount <= 0 {
return Result{}, errors.New("sale amount must be positive")
}
case Preauth:
path = PreauthPath
if request.Amount < 0 {
return Result{}, errors.New("preauth amount must not be negative")
}
default:
return Result{}, errors.New("invalid terminal operation")
}
if client == nil || strings.TrimSpace(baseURL) == "" {
return Result{}, errors.New("terminal client is not configured")
}
body, err := json.Marshal(request)
if err != nil {
return Result{}, fmt.Errorf("encode terminal request: %w", err)
}
req, err := http.NewRequestWithContext(ctx, http.MethodPost, strings.TrimRight(baseURL, `/\`)+path, bytes.NewReader(body))
if err != nil {
return Result{}, errors.New("invalid terminal endpoint")
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/x-ndjson")
response, err := client.Do(req)
if err != nil {
if ctx.Err() != nil {
return Result{}, fmt.Errorf("terminal request interrupted: %w", ctx.Err())
}
if errors.Is(err, context.DeadlineExceeded) {
return Result{}, fmt.Errorf("terminal request interrupted: %w", context.DeadlineExceeded)
}
if errors.Is(err, context.Canceled) {
return Result{}, fmt.Errorf("terminal request interrupted: %w", context.Canceled)
}
// Do not expose a transport error that may contain a URL or raw payload.
return Result{}, errors.New("terminal request failed; outcome is uncertain")
}
defer response.Body.Close()
if !strings.HasPrefix(response.Header.Get("Content-Type"), "application/x-ndjson") {
return Result{}, fmt.Errorf("terminal returned an invalid response contract (HTTP %d)", response.StatusCode)
}
decoder := json.NewDecoder(response.Body)
for {
var frame struct {
Frame
Legacy json.RawMessage `json:"response"`
}
if err := decoder.Decode(&frame); err != nil {
if ctx.Err() != nil {
return Result{}, fmt.Errorf("terminal stream interrupted: %w", ctx.Err())
}
if errors.Is(err, io.EOF) {
return Result{}, errors.New("terminal stream ended before a final result")
}
return Result{}, errors.New("terminal stream is invalid; outcome is uncertain")
}
if len(frame.Legacy) != 0 {
return Result{}, errors.New("terminal returned a legacy result contract")
}
switch frame.Type {
case "status":
if frame.Code == "" || frame.Result != nil {
return Result{}, errors.New("invalid terminal status frame")
}
if onStatus != nil {
onStatus(frame.Code)
}
case "result":
if frame.Result == nil || frame.Code != "" {
return Result{}, errors.New("invalid terminal result frame")
}
result := *frame.Result
switch result.Outcome {
case "approved", "declined", "cancelled", "timeout", "error", "unknown":
default:
return Result{}, errors.New("invalid terminal outcome")
}
if result.HTTPStatus < 100 || result.HTTPStatus > 599 {
return Result{}, errors.New("invalid terminal operation status")
}
if result.Outcome == "approved" && (result.HTTPStatus < 200 || result.HTTPStatus >= 300 || response.StatusCode < 200 || response.StatusCode >= 300 || result.Retryable) {
return Result{}, errors.New("contradictory terminal approval")
}
if result.Outcome == "unknown" && result.Retryable {
return Result{}, errors.New("uncertain terminal result cannot permit retry")
}
if response.StatusCode < 200 || response.StatusCode >= 300 || result.HTTPStatus < 200 || result.HTTPStatus >= 300 {
return result, fmt.Errorf("terminal operation failed (HTTP %d, operation %d)", response.StatusCode, result.HTTPStatus)
}
return result, nil
default:
return Result{}, errors.New("invalid terminal frame type")
}
}
}
+146
View File
@@ -0,0 +1,146 @@
package paymentapi
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
)
func TestExecuteUsesOneContractForSaleAndPreauth(t *testing.T) {
for _, operation := range []string{Sale, Preauth} {
t.Run(operation, func(t *testing.T) {
input := Request{Reference: "SYNTH-BOOK", Amount: 2500, Currency: "GBP", CheckoutDate: "12 Oct 2030"}
if operation == Sale {
input.RequiredPreauth = &PreauthRequirement{Amount: 5000, CheckoutDate: "12 Oct 2030"}
}
calls := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
calls++
if r.Method != http.MethodPost || r.URL.Path != "/api/payment/"+operation {
t.Errorf("Execute(%q) sent %s %s, want POST modern operation", operation, r.Method, r.URL.Path)
}
var got Request
if err := json.NewDecoder(r.Body).Decode(&got); err != nil {
t.Error(err)
return
}
if !reflect.DeepEqual(got, input) {
t.Errorf("Execute(%q) request=%+v, want %+v", operation, got, input)
}
if r.Header.Get("Accept") != "application/x-ndjson" || r.Header.Get("Content-Type") != "application/json" {
t.Errorf("Execute(%q) headers=%v, want JSON request/NDJSON response", operation, r.Header)
}
w.Header().Set("Content-Type", "application/x-ndjson; charset=utf-8")
encoder := json.NewEncoder(w)
for _, frame := range []Frame{{Type: "status", Code: "PAYMENT_PROCESSING"}, {Type: "status", Code: "FUTURE_OBSERVATIONAL_CODE"}, {Type: "result", Result: &Result{Outcome: "approved", HTTPStatus: 200, Provider: "FutureProcessor", AmountMinor: 2500, TransactionReference: "SYNTH-REFERENCE", CardType: "Visa"}}} {
if err := encoder.Encode(frame); err != nil {
t.Error(err)
return
}
}
}))
t.Cleanup(server.Close)
var progress []string
got, err := Execute(context.Background(), server.Client(), server.URL, operation, input, func(code string) { progress = append(progress, code) })
if err != nil || got.Outcome != "approved" || got.TransactionReference != "SYNTH-REFERENCE" || calls != 1 {
t.Fatalf("Execute(%q)=%+v/%v calls=%d, want one approved request", operation, got, err, calls)
}
if !reflect.DeepEqual(progress, []string{"PAYMENT_PROCESSING", "FUTURE_OBSERVATIONAL_CODE"}) {
t.Errorf("Execute(%q) progress=%v, want observed codes in order", operation, progress)
}
})
}
}
type testTransport func(*http.Request) (*http.Response, error)
func (f testTransport) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
type trackedBody struct {
io.Reader
closed bool
}
func (b *trackedBody) Close() error { b.closed = true; return nil }
func TestExecuteRejectsIncompleteOrContradictoryResultsAndClosesBodies(t *testing.T) {
tests := []struct {
name, body string
status int
}{
{"eof", `{"type":"status","code":"PAYMENT_APPROVED"}`, 200},
{"malformed", `{"type":`, 200},
{"legacy", `{"type":"result","response":{"status":{"code":200},"data":"/successful"}}`, 200},
{"mixed", `{"type":"result","result":{"outcome":"approved","httpStatus":200},"response":{}}`, 200},
{"empty_status", `{"type":"status","code":""}`, 200},
{"status_result", `{"type":"status","code":"X","result":{"outcome":"approved","httpStatus":200}}`, 200},
{"unknown_frame", `{"type":"other"}`, 200},
{"unknown_outcome", `{"type":"result","result":{"outcome":"maybe","httpStatus":200}}`, 200},
{"invalid_status", `{"type":"result","result":{"outcome":"approved","httpStatus":0}}`, 200},
{"http_approval_conflict", `{"type":"result","result":{"outcome":"approved","httpStatus":200}}`, 502},
{"operation_approval_conflict", `{"type":"result","result":{"outcome":"approved","httpStatus":502}}`, 200},
{"retryable_approval", `{"type":"result","result":{"outcome":"approved","httpStatus":200,"retryable":true}}`, 200},
{"retryable_unknown", `{"type":"result","result":{"outcome":"unknown","httpStatus":200,"retryable":true}}`, 200},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
body := &trackedBody{Reader: strings.NewReader(test.body)}
calls := 0
client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) {
calls++
return &http.Response{StatusCode: test.status, Header: http.Header{"Content-Type": []string{"application/x-ndjson"}}, Body: body}, nil
})}
_, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil)
if err == nil || !body.closed || calls != 1 {
t.Errorf("Execute(%s) error=%v closed=%t calls=%d, want error/closed/one request", test.name, err, body.closed, calls)
}
})
}
}
func TestExecuteProgressCannotApproveOrRetryUnknown(t *testing.T) {
client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) {
return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": []string{"application/x-ndjson"}}, Body: io.NopCloser(strings.NewReader("{\"type\":\"status\",\"code\":\"PAYMENT_APPROVED\"}\n{\"type\":\"result\",\"result\":{\"outcome\":\"unknown\",\"httpStatus\":200}}"))}, nil
})}
got, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil)
if err != nil || got.Outcome != "unknown" || got.Retryable {
t.Errorf("Execute(progress approved then unknown)=%+v/%v, want nonretryable unknown", got, err)
}
}
func TestExecutePreservesCancellationWithoutLeakingTransportDiagnostics(t *testing.T) {
for _, cause := range []error{context.Canceled, context.DeadlineExceeded} {
t.Run(cause.Error(), func(t *testing.T) {
calls := 0
client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) {
calls++
return nil, fmt.Errorf("synthetic-private-payload: %w", cause)
})}
_, err := Execute(context.Background(), client, "http://synthetic.invalid", Sale, Request{Amount: 100}, nil)
if !errors.Is(err, cause) || strings.Contains(err.Error(), "synthetic-private-payload") || calls != 1 {
t.Errorf("Execute(transport %v)=%v calls=%d, want sanitized wrapped cause and one attempt", cause, err, calls)
}
})
}
}
func TestExecuteRejectsInvalidRequestsWithoutDispatch(t *testing.T) {
for _, test := range []struct {
operation string
amount int64
}{{Sale, 0}, {Sale, -1}, {Preauth, -1}, {"refund", 1}} {
calls := 0
client := &http.Client{Transport: testTransport(func(*http.Request) (*http.Response, error) { calls++; return nil, errors.New("must not dispatch") })}
_, err := Execute(context.Background(), client, "http://synthetic.invalid", test.operation, Request{Amount: test.amount}, nil)
if err == nil || calls != 0 {
t.Errorf("Execute(%q,%d) error=%v calls=%d, want validation error without dispatch", test.operation, test.amount, err, calls)
}
}
}
+55
View File
@@ -0,0 +1,55 @@
// Package paymentapi defines the modern Hardlink terminal contract and its HTTP client.
// It contains no provider selection, PMS posting or guest-journey logic.
package paymentapi
const (
Sale = "sale"
Preauth = "preauth"
SalePath = "/api/payment/sale"
PreauthPath = "/api/payment/preauth"
)
// PreauthRequirement describes a later required hold; validating it never executes it.
type PreauthRequirement struct {
Amount int64 `json:"amount"`
CheckoutDate string `json:"checkoutDate,omitempty"`
}
// Request uses integer minor units and currency supplied by CMS.
type Request struct {
Reference string `json:"reference,omitempty"`
Amount int64 `json:"amount"`
Currency string `json:"currency,omitempty"`
CheckoutDate string `json:"checkoutDate,omitempty"`
RequiredPreauth *PreauthRequirement `json:"requiredPreauth,omitempty"`
}
// Result is authoritative terminal outcome and metadata, never a PMS description.
// CurrencyCode is configured bookkeeping currency, not settlement-currency evidence.
type Result struct {
Outcome string `json:"outcome"`
HTTPStatus int `json:"httpStatus"`
Reason string `json:"reason,omitempty"`
Retryable bool `json:"retryable"`
Message string `json:"message,omitempty"`
Provider string `json:"provider,omitempty"`
AmountMinor int64 `json:"amountMinor"`
CurrencyCode string `json:"currencyCode,omitempty"`
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"`
ReceiptNumber string `json:"receiptNumber,omitempty"`
SequenceNumber string `json:"sequenceNumber,omitempty"`
AuthorizationCode string `json:"authorizationCode,omitempty"`
LastFour string `json:"lastFour,omitempty"`
}
// Frame carries observational progress or one final result.
type Frame struct {
Type string `json:"type"`
Code string `json:"code,omitempty"`
Result *Result `json:"result,omitempty"`
}
+2 -3
View File
@@ -1,7 +1,6 @@
// Package paymentstatus defines progress codes emitted by Hardlink's
// POST /api/payment/sale stream. These codes are not authoritative final
// transaction decisions: clients may continue check-in only after receiving a
// final result frame whose response.data begins with /successful.
// modern Sale/PREAUTH streams. Progress codes are not final transaction decisions;
// clients must use the structured result frame and their PMS completion rules.
package paymentstatus
const (
-174
View File
@@ -1,174 +0,0 @@
## Release notes
builtVersion is a const in main.go
#### v1.3.6 - 28 August 2026
Refactor PDQ lookup for payment providers
#### v1.3.5 - 23 July 2026
fixed dispenser delivery confirmation
#### v1.3.4 - 23 July 2026
added support for Dojo terminal-unavailable responses
#### v1.3.3 - 21 July 2026
added PDQ status streaming to the payment flow to allow the front end to display the status of the PDQ terminal
#### 1.3.2 - 20 July 2026
make dojo decline payment in case of signature required
#### 1.3.1 - 17 July 2026
added receipt printing functionality to the Dojo and Paybridge payment flow
#### 1.3.0 - 03 July 2026
added pluggable PayBridge and Dojo payment flow with CMS credentials
#### 1.2.11 - 26 June 2026
added PayBridge integration for payment processing functionality
#### 1.2.10 - 26 June 2026
added voucher field to the guest receipt
#### 1.2.9 - 02 June 2026
added Dormakaba lock server integration
#### 1.2.8 - 14 May 2026
Updated hardlink source layout to use cmd/hardlink for the main application entry point and internal/ for application packages. Runtime files and preauth-release layout remain unchanged. No functional changes.
#### 1.2.7 - 13 May 2026
retrieve CardType from the ChepDNA response
#### 1.2.6 - 20 April 2026
added the second attempt to send the card to the encoder after 6 seconds
#### 1.2.5 - 20 March 2026
removed early return on error when checking dispenser status in the start and final loops.
#### 1.2.4 - 18 March 2026
added check if keycard at the encoder position before trying to encode key
#### 1.2.3 - 17 March 2026
added check if keycard at the encoder position before trying to encode key
#### 1.2.2 - 11 February 2026
increased waiting time befor sending email on PDQ unavailability to 30 seconds day time and 10 minutes night time
to give it a chance to become available again
#### 1.2.1 - 09 February 2026
increased waiting time befor sending email on PDQ unavailability to 60 seconds
#### 1.2.0 - 09 February 2026
added testissuedoorcard endpoint for testing the full workflow of encoding a door card without moving the card out
added ping-pdq endpoint to check the status of the pdq terminal
added sending the email on the pdq disconnect event to notify support about the issue
added sending the email on the dispenser error status to notify support about the issue
#### 1.1.3 - 02 February 2026
increased timeout for reading response from the Assa abloy lock server to 20 seconds
#### 1.1.2 - 02 February 2026
added logging for unknown dispenser status positions
#### 1.1.1 - 02 February 2026
added contionuous polling of the dispenser status every 8 seconds to update the card well status
#### 1.1.0 - 26 January 2026
divided `/starttransaction` endpoint into two separate endpoints:
`/takepreauth` to request preauthorization payment
`/takepayment` to request taking payment
added preauth releaser functionality to release preauthorization payments after a defined time period
added db connection check before adding a transaction to the database
and reconnection functionality if the connection to the database is lost
added `/dispenserstatus` endpoint
key card always stays at encoder position
#### 1.0.30 - 09 January 2026
improved logging for preauth releaser
#### 1.0.29 - 08 January 2026
added count down before exiting the preauth releaser 20 seconds
#### 1.0.28 - 10 December 2025
added preauth releaser
#### 1.0.27 - 10 December 2025
updated handling AmountTooSmall response from creditcall
#### 1.0.26 - 10 December 2025
added route for taking preauthorization payment
#### 1.0.25 - 08 December 2025
return masked card number and expiry date in the payment success URL
#### 1.0.24 - 13 November 2025
improved logging for creditcall payment processing
#### 1.0.23 - 13 November 2025
moved handlers from main.go to handlers/handlers.go
#### 1.0.22 - 13 November 2025
added test mode into config file to allow testing without connecting to the dispenser
#### 1.0.21 - 20 October 2025
increased timeout for Salto lock server connection to 40 seconds
#### 1.0.20 - 06 October 2025
removed minutes from the start and expiry time in Salto lock command
#### 1.0.19 - 10 September 2025
allowed to continue if the connection to the lock server fails at startup
#### 1.0.18 - 04 September 2025
increased timeout for TLJ lock server connection to 30 seconds
#### 1.0.17 - 30 August 2025
added functionality to commit transactions
#### 1.0.15 - 27 August 2025
fixed TCP/IP connection to the lock server
#### 1.0.14 - 21 August 2025
fixed issue in creditcall payment processing where error description was not properly set
#### 1.0.13 - 21 August 2025
TCP/IP connection to the lock server is now established before encoding the keycard and closedafter the encoding is done.
#### 1.0.12 - 11 August 2025
added delay before checking dispenser status
#### 1.0.11 - 11 August 2025
updated Salto key encoding workflow
#### 1.0.10 - 08 August 2025
updated logging for TLJ locks
#### 1.0.9 - 08 August 2025
added TLJ lock server and implemented workflow for TLJ locks
#### 1.0.8 - 01 August 2025
improved error handling and logging in Salto
#### 1.0.7 - 25 July 2025
added check if the room exists
#### 1.0.6 - 25 July 2025
updated workflow for Salto locks
#### 1.0.5 - 24 July 2025
added encoding keycard copy for Salto locks
#### 1.0.4 - 22 July 2025
added salto lock server and implemented workflow for Salto
#### 1.0.0 - 30 June 2025
added creditcall payment method
`/starttransaction` - API payment endpoint to start a transaction
#### 0.9.1 - 22 May 2025
added lockserver interface and implemented workflow for Omnitec
#### 0.9.0 - 22 May 2025
The new API has two new endpoints:
- `/issuedoorcard` - encoding the door card for the room.
- `/printroomticket` - printing the room ticket.