145 lines
5.6 KiB
Go
145 lines
5.6 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"gitea.futuresens.co.uk/futuresens/cmstypes"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/v2/config"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/v2/internal/creditcall"
|
|
"gitea.futuresens.co.uk/futuresens/hardlink/v2/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)
|
|
}
|
|
})
|
|
}
|
|
}
|