feat(hardlink): unify kiosk payments and finalize legacy cleanup
This commit is contained in:
@@ -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)
|
||||
}
|
||||
Reference in New Issue
Block a user