Files
hardlink/internal/handlers/creditcall_preauth_logging_test.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)
}
})
}
}