popertotsandSisyphus
985b114c8b
- webhooks: booking-status gate rejects cancelled bookings, M2 stranded-charge refund row + alert, gift-card rows left pending, payable-booking side-effects, unknown-event 503, refund-before-row 503, webhook-after-sync no-double-complete - giftcards: saved_card_id SCA wire, card_id+token rejected, resume re-issue never over-refunds entitlement, pending-Square-refund blocks, diff re-issue only what is owed - sweep: VAT on split-rescued primary, all-tip rows VAT-free, till status/key-changed-while-locked skip, recordUntrackedTillSalePayment VAT - till: suffixed-key slot scan lock held across Square round-trip Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai> Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)
1678 lines
60 KiB
Go
1678 lines
60 KiB
Go
//go:build test
|
|
|
|
package webhooks
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"crussell/clock"
|
|
"crussell/db"
|
|
"crussell/testutils/fixtures"
|
|
)
|
|
|
|
// nowInRFC3339 returns the current UTC instant (plus an offset) as an RFC3339
|
|
// string. Webhook-event timestamps and gift-card/till-sale created_at values
|
|
// must be clock-relative so sweep/expiry-window logic stays correct forever
|
|
// instead of drifting against a hardcoded 2025 date.
|
|
func nowInRFC3339(offset time.Duration) string {
|
|
return clock.Now().Add(offset).UTC().Format(time.RFC3339)
|
|
}
|
|
|
|
// =============================================================================
|
|
// Helpers — DB-backed state assertions
|
|
// =============================================================================
|
|
|
|
// createWebhookTestPayment inserts a payment row with the given Square charge
|
|
// id and returns the local payment id. The test DB is fresh per package run,
|
|
// so no cleanup is needed.
|
|
func createWebhookTestPayment(t *testing.T, squarePaymentID, status string) string {
|
|
t.Helper()
|
|
var id string
|
|
err := db.Conn.QueryRow(context.Background(), `
|
|
INSERT INTO payments (payment_type, payment_method, status, amount, square_payment_id, created_at, updated_at)
|
|
VALUES ('full', 'online_square', $2, 10.00, $1, NOW(), NOW())
|
|
RETURNING id
|
|
`, squarePaymentID, status).Scan(&id)
|
|
if err != nil {
|
|
t.Fatalf("failed to create webhook test payment: %v", err)
|
|
}
|
|
return id
|
|
}
|
|
|
|
func createWebhookTestRefund(t *testing.T, paymentID, squareRefundID, status string) string {
|
|
t.Helper()
|
|
return createWebhookTestRefundWithReason(t, paymentID, squareRefundID, status, "webhook test refund")
|
|
}
|
|
|
|
// createWebhookTestRefundWithReason is createWebhookTestRefund with an explicit
|
|
// reason — the B1 sweep-dup parent-resolution tests need the
|
|
// "duplicate charge — sweep replay" reason to exercise finding 1.
|
|
func createWebhookTestRefundWithReason(t *testing.T, paymentID, squareRefundID, status, reason string) string {
|
|
t.Helper()
|
|
var id string
|
|
err := db.Conn.QueryRow(context.Background(), `
|
|
INSERT INTO refunds (payment_id, amount, reason, status, square_refund_id, created_at)
|
|
VALUES ($1, 5.00, $4, $3, $2, NOW())
|
|
RETURNING id
|
|
`, paymentID, squareRefundID, status, reason).Scan(&id)
|
|
if err != nil {
|
|
t.Fatalf("failed to create webhook test refund: %v", err)
|
|
}
|
|
return id
|
|
}
|
|
|
|
func getPaymentStatus(t *testing.T, id string) string {
|
|
t.Helper()
|
|
var status string
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT status FROM payments WHERE id = $1", id).Scan(&status); err != nil {
|
|
t.Fatalf("failed to read payment status: %v", err)
|
|
}
|
|
return status
|
|
}
|
|
|
|
func getRefundStatus(t *testing.T, id string) string {
|
|
t.Helper()
|
|
var status string
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT status FROM refunds WHERE id = $1", id).Scan(&status); err != nil {
|
|
t.Fatalf("failed to read refund status: %v", err)
|
|
}
|
|
return status
|
|
}
|
|
|
|
func getDisputeStatus(t *testing.T, squareDisputeID string) string {
|
|
t.Helper()
|
|
var status string
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT status FROM disputes WHERE square_dispute_id = $1", squareDisputeID).Scan(&status); err != nil {
|
|
t.Fatalf("failed to read dispute status: %v", err)
|
|
}
|
|
return status
|
|
}
|
|
|
|
func countCriticalNotifications(t *testing.T) int {
|
|
t.Helper()
|
|
var n int
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT COUNT(*) FROM admin_notifications WHERE reason = 'critical_payment_log'").Scan(&n); err != nil {
|
|
t.Fatalf("failed to count critical_payment_log notifications: %v", err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func countRefundFailedNotifications(t *testing.T) int {
|
|
t.Helper()
|
|
var n int
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT COUNT(*) FROM admin_notifications WHERE reason = 'refund_failed'").Scan(&n); err != nil {
|
|
t.Fatalf("failed to count refund_failed notifications: %v", err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// deliverWebhook signs and dispatches a Square event through the full handler.
|
|
func deliverWebhook(t *testing.T, event SquareWebhookEvent) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
body, err := json.Marshal(event)
|
|
if err != nil {
|
|
t.Fatalf("failed to marshal webhook event: %v", err)
|
|
}
|
|
sig := webhookTestEnv(t, body)
|
|
return makeWebhookRequest(body, sig, context.Background())
|
|
}
|
|
|
|
// createWebhookTestGiftCardAndSale seeds a pending gift-card till sale tied to
|
|
// a Square payment id and returns the sale id and gift card id. When
|
|
// cardCreatedAt == saleCreatedAt the sale created the card (is_create → action
|
|
// 'create'); otherwise the card pre-exists (action 'topup'). cardAmount is the
|
|
// card's starting total_funds_added/amount_remaining.
|
|
func createWebhookTestGiftCardAndSale(t *testing.T, squarePaymentID, cardCreatedAt, saleCreatedAt string, cardAmount float64) (saleID, giftCardID string) {
|
|
t.Helper()
|
|
adminID, err := fixtures.CreateTestAdminUser(db.Conn)
|
|
if err != nil {
|
|
t.Fatalf("failed to create admin user: %v", err)
|
|
}
|
|
if err := db.Conn.QueryRow(context.Background(), `
|
|
INSERT INTO gift_cards (total_funds_added, amount_remaining, created_by, is_inventory, voucher_type_at_purchase, created_at)
|
|
VALUES ($1, $1, $2, FALSE, 'SPV', $3::timestamptz)
|
|
RETURNING id
|
|
`, cardAmount, adminID, cardCreatedAt).Scan(&giftCardID); err != nil {
|
|
t.Fatalf("failed to create gift card: %v", err)
|
|
}
|
|
if err := db.Conn.QueryRow(context.Background(), `
|
|
INSERT INTO till_sales (item_type, item_id, description, quantity, unit_price, total_amount,
|
|
payment_method, status, square_payment_id, created_by, created_at, updated_at)
|
|
VALUES ('gift_card', $1, 'webhook clawback test', 1, 40.00, 40.00, 'online_square', 'pending',
|
|
$2, $3, $4::timestamptz, NOW())
|
|
RETURNING id
|
|
`, giftCardID, squarePaymentID, adminID, saleCreatedAt).Scan(&saleID); err != nil {
|
|
t.Fatalf("failed to create pending till sale: %v", err)
|
|
}
|
|
return saleID, giftCardID
|
|
}
|
|
|
|
// deliverPaymentUpdatedFailed dispatches a payment.updated webhook carrying a
|
|
// definitively FAILED Square status for the given Square payment id.
|
|
func deliverPaymentUpdatedFailed(t *testing.T, squarePaymentID string) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_" + squarePaymentID,
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "FAILED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
return deliverWebhook(t, event)
|
|
}
|
|
|
|
func getTillSaleStatus(t *testing.T, id string) string {
|
|
t.Helper()
|
|
var status string
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT status FROM till_sales WHERE id = $1", id).Scan(&status); err != nil {
|
|
t.Fatalf("failed to read till_sales status: %v", err)
|
|
}
|
|
return status
|
|
}
|
|
|
|
func getGiftCardFunding(t *testing.T, id string) (totalFundsAdded, amountRemaining float64) {
|
|
t.Helper()
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT total_funds_added, amount_remaining FROM gift_cards WHERE id = $1", id).Scan(&totalFundsAdded, &amountRemaining); err != nil {
|
|
t.Fatalf("failed to read gift card funding: %v", err)
|
|
}
|
|
return totalFundsAdded, amountRemaining
|
|
}
|
|
|
|
// =============================================================================
|
|
// Till-sale gift-card clawback — payment.updated FAILED/CANCELED
|
|
// =============================================================================
|
|
|
|
// TestWebhook_PaymentUpdated_Failed_ClawsBackCreatedCard verifies that a
|
|
// definitively-failed Square charge (FAILED) claws back the gift-card funding
|
|
// of a pending till sale that CREATED the card: the card and its purchase
|
|
// transaction are deleted and the sale is marked failed, exactly as the sweep
|
|
// does.
|
|
func TestWebhook_PaymentUpdated_Failed_ClawsBackCreatedCard(t *testing.T) {
|
|
const squarePaymentID = "sqp_clawback_create"
|
|
cardCreatedAt := nowInRFC3339(0)
|
|
saleID, giftCardID := createWebhookTestGiftCardAndSale(t, squarePaymentID, cardCreatedAt, cardCreatedAt, 40.00)
|
|
|
|
w := deliverPaymentUpdatedFailed(t, squarePaymentID)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getTillSaleStatus(t, saleID); got != "failed" {
|
|
t.Errorf("expected till sale 'failed', got %q", got)
|
|
}
|
|
if exists := giftCardExists(t, giftCardID); exists {
|
|
t.Error("expected created gift card to be deleted by the clawback")
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_Failed_ClawsBackTopup verifies the top-up
|
|
// clawback for a pre-existing card: the sale's funding is subtracted back out
|
|
// of the card and the sale is marked failed.
|
|
func TestWebhook_PaymentUpdated_Failed_ClawsBackTopup(t *testing.T) {
|
|
const squarePaymentID = "sqp_clawback_topup"
|
|
cardCreatedAt := nowInRFC3339(0)
|
|
saleID, giftCardID := createWebhookTestGiftCardAndSale(t, squarePaymentID, cardCreatedAt, nowInRFC3339(24*time.Hour), 60.00)
|
|
|
|
w := deliverPaymentUpdatedFailed(t, squarePaymentID)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getTillSaleStatus(t, saleID); got != "failed" {
|
|
t.Errorf("expected till sale 'failed', got %q", got)
|
|
}
|
|
total, remaining := getGiftCardFunding(t, giftCardID)
|
|
if total != 20.00 || remaining != 20.00 {
|
|
t.Errorf("expected top-up clawback to leave £20.00 on the card, got total=%v remaining=%v", total, remaining)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_Failed_AlreadyResolved_Skipped verifies the
|
|
// clawback skips without error when the till sale is already resolved (not
|
|
// pending): the webhook still acknowledges 200 and leaves the terminal state
|
|
// untouched.
|
|
func TestWebhook_PaymentUpdated_Failed_AlreadyResolved_Skipped(t *testing.T) {
|
|
const squarePaymentID = "sqp_clawback_resolved"
|
|
createdAt := nowInRFC3339(0)
|
|
saleID, giftCardID := createWebhookTestGiftCardAndSale(t, squarePaymentID, createdAt, createdAt, 40.00)
|
|
if _, err := db.Conn.Exec(context.Background(),
|
|
"UPDATE till_sales SET status = 'completed', updated_at = NOW() WHERE id = $1", saleID); err != nil {
|
|
t.Fatalf("failed to resolve till sale: %v", err)
|
|
}
|
|
|
|
w := deliverPaymentUpdatedFailed(t, squarePaymentID)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getTillSaleStatus(t, saleID); got != "completed" {
|
|
t.Errorf("expected resolved till sale to stay 'completed', got %q", got)
|
|
}
|
|
if total, remaining := getGiftCardFunding(t, giftCardID); total != 40.00 || remaining != 40.00 {
|
|
t.Errorf("expected gift card untouched when the sale is already resolved, got total=%v remaining=%v", total, remaining)
|
|
}
|
|
}
|
|
|
|
func giftCardExists(t *testing.T, id string) bool {
|
|
t.Helper()
|
|
var n int
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT COUNT(*) FROM gift_cards WHERE id = $1", id).Scan(&n); err != nil {
|
|
t.Fatalf("failed to count gift cards: %v", err)
|
|
}
|
|
return n > 0
|
|
}
|
|
|
|
// =============================================================================
|
|
// Dispute handling — dispute.created
|
|
// =============================================================================
|
|
|
|
func TestWebhook_DisputeCreated_InsertsDisputeRow(t *testing.T) {
|
|
const squarePaymentID = "sqp_dispute_created"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.created",
|
|
EventID: "evt_dispute_created_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "dts_dispute_created_1",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "dts_dispute_created_1",
|
|
"state": "UNDER_REVIEW",
|
|
"amount_money": {"amount": 1234, "currency": "GBP"},
|
|
"reason": "NO_KNOWLEDGE",
|
|
"disputed_payment": {"payment_id": "` + squarePaymentID + `"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
|
|
var (
|
|
status string
|
|
amount float64
|
|
reason string
|
|
pid string
|
|
)
|
|
err := db.Conn.QueryRow(context.Background(), `
|
|
SELECT status, amount, reason, payment_id FROM disputes WHERE square_dispute_id = 'dts_dispute_created_1'
|
|
`).Scan(&status, &amount, &reason, &pid)
|
|
if err != nil {
|
|
t.Fatalf("expected a disputes row to be inserted, got: %v", err)
|
|
}
|
|
if status != "open" {
|
|
t.Errorf("expected dispute status 'open', got %q", status)
|
|
}
|
|
if amount != 12.34 {
|
|
t.Errorf("expected dispute amount 12.34, got %v", amount)
|
|
}
|
|
if reason != "NO_KNOWLEDGE" {
|
|
t.Errorf("expected dispute reason 'NO_KNOWLEDGE', got %q", reason)
|
|
}
|
|
if pid != payID {
|
|
t.Errorf("expected dispute payment_id %s, got %s", payID, pid)
|
|
}
|
|
|
|
// A dispute is a CRITICAL money event — the admin notification centre must
|
|
// surface it.
|
|
if got := countCriticalNotifications(t); got < 1 {
|
|
t.Errorf("expected at least 1 critical_payment_log admin notification, got %d", got)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_DisputeCreated_NoLocalPayment_NoRow(t *testing.T) {
|
|
// Each untracked dispute now gets its own deterministic-id notification, but
|
|
// a booking-scoped (reason, booking_id, acknowledged_at IS NULL) guard still
|
|
// shares the NULL-booking slot for tracked-with-no-booking disputes — so
|
|
// acknowledge any unacknowledged stragglers to keep this assertion scoped.
|
|
if _, err := db.Conn.Exec(context.Background(),
|
|
"UPDATE admin_notifications SET acknowledged_at = NOW() WHERE reason = 'critical_payment_log' AND acknowledged_at IS NULL"); err != nil {
|
|
t.Fatalf("failed to acknowledge prior critical notifications: %v", err)
|
|
}
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.created",
|
|
EventID: "evt_dispute_orphan_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "dts_orphan_1",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "dts_orphan_1",
|
|
"state": "UNDER_REVIEW",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"},
|
|
"disputed_payment": {"payment_id": "sqp_never_seen"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
// No local payment to reconcile against — no disputes row can be written.
|
|
var n int
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT COUNT(*) FROM disputes WHERE square_dispute_id = 'dts_orphan_1'").Scan(&n); err != nil {
|
|
t.Fatalf("failed to count disputes: %v", err)
|
|
}
|
|
if n != 0 {
|
|
t.Errorf("expected no disputes row for an unknown square payment, got %d", n)
|
|
}
|
|
// ...but the chargeback MUST still surface in-app: a dispute on a payment
|
|
// with no local row is exactly the silent money-loss path this guards (no
|
|
// sweep fallback, no reconciliable booking). One unacknowledged
|
|
// NULL-booking critical notification must exist.
|
|
var unack int
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT COUNT(*) FROM admin_notifications WHERE reason = 'critical_payment_log' AND booking_id IS NULL AND acknowledged_at IS NULL").Scan(&unack); err != nil {
|
|
t.Fatalf("failed to count unacknowledged critical notifications: %v", err)
|
|
}
|
|
if unack != 1 {
|
|
t.Errorf("expected exactly 1 unacknowledged NULL-booking critical_payment_log notification, got %d", unack)
|
|
}
|
|
// The dedup row still commits: the handler returned nil, so Square's retry
|
|
// is acknowledged 200 rather than re-dispatched forever.
|
|
if got := countWebhookEvents(t, event.EventID); got != 1 {
|
|
t.Errorf("expected 1 dedup row for the untracked dispute, got %d", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_DisputeCreated_Untracked_DistinctDisputes_DistinctNotifications
|
|
// locks the per-dispute dedup fix: two DISTINCT untracked chargebacks (no local
|
|
// payment row) must each raise their OWN unacknowledged NULL-booking critical
|
|
// notification. The old (reason, booking_id, acknowledged_at IS NULL) dedup
|
|
// collapsed them onto one row, silently suppressing the second chargeback.
|
|
func TestWebhook_DisputeCreated_Untracked_DistinctDisputes_DistinctNotifications(t *testing.T) {
|
|
disputes := []struct{ disputeID, paymentID string }{
|
|
{"dts_untracked_a", "sqp_never_a"},
|
|
{"dts_untracked_b", "sqp_never_b"},
|
|
}
|
|
for i, d := range disputes {
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.created",
|
|
EventID: fmt.Sprintf("evt_untracked_distinct_%d", i),
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "` + d.disputeID + `",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "` + d.disputeID + `",
|
|
"state": "UNDER_REVIEW",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"},
|
|
"disputed_payment": {"payment_id": "` + d.paymentID + `"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 for %s, got %d: %s", d.disputeID, w.Code, w.Body.String())
|
|
}
|
|
}
|
|
|
|
// BOTH distinct disputes must have their own unacknowledged NULL-booking
|
|
// notification (the second must not be suppressed by the first).
|
|
for _, d := range disputes {
|
|
var n int
|
|
if err := db.Conn.QueryRow(context.Background(), `
|
|
SELECT COUNT(*) FROM admin_notifications
|
|
WHERE id = $1 AND reason = 'critical_payment_log'
|
|
AND booking_id IS NULL AND acknowledged_at IS NULL
|
|
`, disputeNotificationID(d.disputeID)).Scan(&n); err != nil {
|
|
t.Fatalf("failed to count notifications for %s: %v", d.disputeID, err)
|
|
}
|
|
if n != 1 {
|
|
t.Errorf("expected exactly 1 unacknowledged notification for dispute %s, got %d", d.disputeID, n)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestWebhook_DisputeCreated_Untracked_SameDisputeRedelivered_SingleNotification
|
|
// locks the per-dispute idempotency: re-delivery of the SAME untracked dispute
|
|
// (under a FRESH event_id, so the handler-level event_id dedup is bypassed)
|
|
// must NOT create a second notification — the deterministic per-dispute id keeps
|
|
// it to one row.
|
|
func TestWebhook_DisputeCreated_Untracked_SameDisputeRedelivered_SingleNotification(t *testing.T) {
|
|
const disputeID = "dts_untracked_redeliv"
|
|
for _, eventID := range []string{"evt_untracked_redeliv_1", "evt_untracked_redeliv_2"} {
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.created",
|
|
EventID: eventID,
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "` + disputeID + `",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "` + disputeID + `",
|
|
"state": "UNDER_REVIEW",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"},
|
|
"disputed_payment": {"payment_id": "sqp_never_redeliv"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 for %s, got %d: %s", eventID, w.Code, w.Body.String())
|
|
}
|
|
}
|
|
var n int
|
|
if err := db.Conn.QueryRow(context.Background(), `
|
|
SELECT COUNT(*) FROM admin_notifications
|
|
WHERE id = $1 AND reason = 'critical_payment_log' AND booking_id IS NULL
|
|
`, disputeNotificationID(disputeID)).Scan(&n); err != nil {
|
|
t.Fatalf("failed to count notifications for %s: %v", disputeID, err)
|
|
}
|
|
if n != 1 {
|
|
t.Errorf("expected exactly 1 notification for the re-delivered dispute, got %d", n)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_DisputeCreated_LongReason_Truncated(t *testing.T) {
|
|
const squarePaymentID = "sqp_dispute_longreason"
|
|
_ = createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
|
|
longReason := strings.Repeat("z", 300)
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.created",
|
|
EventID: "evt_dispute_longreason_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "dts_longreason_1",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "dts_longreason_1",
|
|
"state": "UNDER_REVIEW",
|
|
"amount_money": {"amount": 1234, "currency": "GBP"},
|
|
"reason": "` + longReason + `",
|
|
"disputed_payment": {"payment_id": "` + squarePaymentID + `"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
|
|
// disputes.reason is VARCHAR(192): the over-long reason must be truncated
|
|
// so the INSERT succeeds instead of failing (and, after the dedup row
|
|
// commits, silently dropping the dispute).
|
|
var storedReason string
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT reason FROM disputes WHERE square_dispute_id = 'dts_longreason_1'").Scan(&storedReason); err != nil {
|
|
t.Fatalf("expected a disputes row to be inserted, got: %v", err)
|
|
}
|
|
if len(storedReason) > 192 {
|
|
t.Errorf("expected reason truncated to <=192 chars, got %d", len(storedReason))
|
|
}
|
|
if storedReason != strings.Repeat("z", 192) {
|
|
t.Errorf("expected reason truncated to exactly 192 'z' chars, got %q", storedReason)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_DisputeCreated_Utf8Reason_StoredValid delivers a dispute whose
|
|
// reason is long enough that the old byte-truncation (reason[:192]) would have
|
|
// split a 3-byte rune and stored invalid UTF-8 — which Postgres rejects,
|
|
// failing the INSERT and making Square retry forever. Rune-safe truncation must
|
|
// store a valid, at-most-192-character string.
|
|
func TestWebhook_DisputeCreated_Utf8Reason_StoredValid(t *testing.T) {
|
|
const squarePaymentID = "sqp_dispute_utf8"
|
|
_ = createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
|
|
// 300 three-byte runes = 900 bytes, far past VARCHAR(192).
|
|
reason := strings.Repeat("界", 300)
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.created",
|
|
EventID: "evt_dispute_utf8_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "dts_utf8_1",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "dts_utf8_1",
|
|
"state": "UNDER_REVIEW",
|
|
"amount_money": {"amount": 1234, "currency": "GBP"},
|
|
"reason": "` + reason + `",
|
|
"disputed_payment": {"payment_id": "` + squarePaymentID + `"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
var stored string
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
"SELECT reason FROM disputes WHERE square_dispute_id = 'dts_utf8_1'").Scan(&stored); err != nil {
|
|
t.Fatalf("expected a disputes row to be inserted, got: %v", err)
|
|
}
|
|
if !utf8.ValidString(stored) {
|
|
t.Errorf("expected stored reason to be valid UTF-8, got %q", stored)
|
|
}
|
|
if r := []rune(stored); len(r) != 192 {
|
|
t.Errorf("expected stored reason to be exactly 192 characters, got %d", len(r))
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Dispute handling — dispute.state.updated
|
|
// =============================================================================
|
|
|
|
func TestWebhook_DisputeStateUpdated_Lost_MarksPaymentFailed(t *testing.T) {
|
|
const squarePaymentID = "sqp_dispute_lost"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
// Seed the dispute row as dispute.created would have.
|
|
if _, err := db.Conn.Exec(context.Background(), `
|
|
INSERT INTO disputes (square_dispute_id, payment_id, status, amount, reason)
|
|
VALUES ('dts_lost_1', $1, 'open', 12.34, 'NO_KNOWLEDGE')
|
|
`, payID); err != nil {
|
|
t.Fatalf("failed to seed dispute row: %v", err)
|
|
}
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.state.updated",
|
|
EventID: "evt_dispute_lost_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "dts_lost_1",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "dts_lost_1",
|
|
"state": "LOST",
|
|
"amount_money": {"amount": 1234, "currency": "GBP"},
|
|
"reason": "NO_KNOWLEDGE",
|
|
"disputed_payment": {"payment_id": "` + squarePaymentID + `"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getDisputeStatus(t, "dts_lost_1"); got != "lost" {
|
|
t.Errorf("expected dispute status 'lost', got %q", got)
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "failed" {
|
|
t.Errorf("expected payment status 'failed' after lost dispute, got %q", got)
|
|
}
|
|
if got := countCriticalNotifications(t); got < 1 {
|
|
t.Errorf("expected a critical_payment_log notification for the lost dispute, got %d", got)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_DisputeStateUpdated_Won_KeepsPaymentCompleted(t *testing.T) {
|
|
const squarePaymentID = "sqp_dispute_won"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
|
|
// No seeded dispute row: state.updated arriving before dispute.created must
|
|
// upsert the row.
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.state.updated",
|
|
EventID: "evt_dispute_won_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "dts_won_1",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "dts_won_1",
|
|
"state": "WON",
|
|
"amount_money": {"amount": 1234, "currency": "GBP"},
|
|
"disputed_payment": {"payment_id": "` + squarePaymentID + `"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getDisputeStatus(t, "dts_won_1"); got != "won" {
|
|
t.Errorf("expected dispute status 'won', got %q", got)
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "completed" {
|
|
t.Errorf("expected payment to stay 'completed' after won dispute, got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_DisputeStateUpdated_Open_KeepsOpen(t *testing.T) {
|
|
const squarePaymentID = "sqp_dispute_open"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
if _, err := db.Conn.Exec(context.Background(), `
|
|
INSERT INTO disputes (square_dispute_id, payment_id, status, amount, reason)
|
|
VALUES ('dts_open_1', $1, 'open', 12.34, 'NO_KNOWLEDGE')
|
|
`, payID); err != nil {
|
|
t.Fatalf("failed to seed dispute row: %v", err)
|
|
}
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "dispute.state.updated",
|
|
EventID: "evt_dispute_open_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "dispute",
|
|
"id": "dts_open_1",
|
|
"object": {
|
|
"dispute": {
|
|
"id": "dts_open_1",
|
|
"state": "EVIDENCE_REQUIRED",
|
|
"amount_money": {"amount": 1234, "currency": "GBP"},
|
|
"disputed_payment": {"payment_id": "` + squarePaymentID + `"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getDisputeStatus(t, "dts_open_1"); got != "open" {
|
|
t.Errorf("expected dispute to stay 'open' on EVIDENCE_REQUIRED, got %q", got)
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "completed" {
|
|
t.Errorf("expected payment to stay 'completed', got %q", got)
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// State mutation — payment.updated
|
|
// =============================================================================
|
|
|
|
func TestWebhook_PaymentUpdated_UpdatesPaymentStatus(t *testing.T) {
|
|
const squarePaymentID = "sqp_updated_completed"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "pending")
|
|
// The webhook's booking gate (round-8) only completes booking-attached
|
|
// rows — a booking-less row is a gift-card purchase and is left pending
|
|
// (C6). Attach a payable booking so the gate completes the payment.
|
|
attachWebhookTestBooking(t, payID, 10.00)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_payment_updated_completed_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "COMPLETED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "completed" {
|
|
t.Errorf("expected payment status 'completed', got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_PaymentUpdated_FailedStatus(t *testing.T) {
|
|
const squarePaymentID = "sqp_updated_failed"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "pending")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_payment_updated_failed_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "FAILED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "failed" {
|
|
t.Errorf("expected payment status 'failed', got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_PaymentUpdated_NonTerminal_LeavesPending(t *testing.T) {
|
|
const squarePaymentID = "sqp_updated_approved"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "pending")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_payment_updated_approved_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "APPROVED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "pending" {
|
|
t.Errorf("expected payment to stay 'pending' on non-terminal APPROVED, got %q", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_DoesNotRevertRefunded guards the pending-only
|
|
// transition: Square fires payment.updated for ANY field change (e.g. a fee
|
|
// recalculation on a fully refunded charge), and that must not flip the local
|
|
// row back from 'refunded' to 'completed' — which would reopen the
|
|
// over-refund guard.
|
|
func TestWebhook_PaymentUpdated_DoesNotRevertRefunded(t *testing.T) {
|
|
const squarePaymentID = "sqp_updated_refunded"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "refunded")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_payment_updated_refunded_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "COMPLETED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "refunded" {
|
|
t.Errorf("expected refunded payment to stay 'refunded', got %q", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_Completed_RescuesPendingTillSale verifies the
|
|
// real-time counterpart of the stale-pending sweep's till rescue: a
|
|
// payment.updated carrying COMPLETED flips a PENDING till_sale funded by that
|
|
// Square charge to completed (square.go's
|
|
// `UPDATE till_sales SET status='completed' WHERE square_payment_id=$2 AND status='pending'`).
|
|
// A regression dropping the till_sales reconcile from handlePaymentUpdated
|
|
// would leave gift-card/retail till sales stuck pending until the next sweep.
|
|
func TestWebhook_PaymentUpdated_Completed_RescuesPendingTillSale(t *testing.T) {
|
|
const squarePaymentID = "sqp_updated_till_rescue"
|
|
saleID := createWebhookTestTillSale(t, squarePaymentID, "gift_card", nil)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_payment_updated_till_rescue_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "COMPLETED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getTillSaleStatus(t, saleID); got != "completed" {
|
|
t.Errorf("expected pending till sale 'completed' after COMPLETED payment.updated, got %q", got)
|
|
}
|
|
if n := countWebhookEvents(t, event.EventID); n != 1 {
|
|
t.Errorf("expected 1 dedup row, got %d", n)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_PaymentUpdated_IdempotentReplay(t *testing.T) {
|
|
const squarePaymentID = "sqp_updated_idem"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "pending")
|
|
// The webhook's booking gate (round-8) only completes booking-attached
|
|
// rows — attach a payable booking so the gate completes the payment.
|
|
attachWebhookTestBooking(t, payID, 10.00)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_payment_updated_idem_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "COMPLETED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
// Two deliveries of the SAME event_id: the second is dropped by dedup, the
|
|
// state mutation applies exactly once.
|
|
w1 := deliverWebhook(t, event)
|
|
if w1.Code != http.StatusOK {
|
|
t.Fatalf("expected first delivery 200, got %d: %s", w1.Code, w1.Body.String())
|
|
}
|
|
w2 := deliverWebhook(t, event)
|
|
if w2.Code != http.StatusOK {
|
|
t.Fatalf("expected replay 200, got %d: %s", w2.Code, w2.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "completed" {
|
|
t.Errorf("expected payment status 'completed' after idempotent replay, got %q", got)
|
|
}
|
|
if n := countWebhookEvents(t, event.EventID); n != 1 {
|
|
t.Errorf("expected exactly 1 dedup row after replay, got %d", n)
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// B1-support — orphaned sweep-minted duplicate charge (payment.updated with no
|
|
// local row that resolves to a pending origin row)
|
|
// =============================================================================
|
|
|
|
// createWebhookTestPendingOrigin inserts a pending payments row that carries an
|
|
// idempotency key but NO square_payment_id — exactly the population the keyed
|
|
// stale-pending sweep replays — and returns its local id.
|
|
func createWebhookTestPendingOrigin(t *testing.T, idempotencyKey string) string {
|
|
t.Helper()
|
|
var id string
|
|
// The origin row is aged past the sweep's keyed-replay age
|
|
// (payments.SweepKeyedReplayAge — 22h): the orphan detection only treats a
|
|
// pending row as a sweep-minted duplicate's origin once the row is old
|
|
// enough that the sweep could have replayed it (a fresh pending row is a
|
|
// legit charge whose response was lost and must never be failed by a
|
|
// webhook that raced it).
|
|
err := db.Conn.QueryRow(context.Background(), `
|
|
INSERT INTO payments (payment_type, payment_method, status, amount, idempotency_key, created_at, updated_at)
|
|
VALUES ('full', 'online_square', 'pending', 10.00, $1, NOW() - INTERVAL '23 hours', NOW())
|
|
RETURNING id
|
|
`, idempotencyKey).Scan(&id)
|
|
if err != nil {
|
|
t.Fatalf("failed to create pending origin payment: %v", err)
|
|
}
|
|
return id
|
|
}
|
|
|
|
// seedWebhookTestB1Evidence simulates the sweep having replayed the origin's
|
|
// expired key, minted a duplicate charge, and attempted its B1 auto-refund
|
|
// (b1_attempts > 0). The orphan-detection B1-evidence gate requires this
|
|
// before marking the origin failed.
|
|
func seedWebhookTestB1Evidence(t *testing.T, originID string) {
|
|
t.Helper()
|
|
if _, err := db.Conn.Exec(context.Background(),
|
|
`UPDATE payments SET b1_attempts = 1 WHERE id = $1`, originID); err != nil {
|
|
t.Fatalf("failed to seed b1_attempts on origin payment: %v", err)
|
|
}
|
|
}
|
|
|
|
func countOrphanReplayNotifications(t *testing.T, originID string) int {
|
|
t.Helper()
|
|
var n int
|
|
if err := db.Conn.QueryRow(context.Background(),
|
|
`SELECT COUNT(*) FROM admin_notifications WHERE id = $1 AND reason = 'critical_payment_log'`,
|
|
orphanReplayChargeNotificationID(originID)).Scan(&n); err != nil {
|
|
t.Fatalf("failed to count orphan-replay notifications: %v", err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_OrphanedReplay_MarksOriginFailed locks the
|
|
// B1-support webhook half: a COMPLETED payment.updated for a charge whose
|
|
// square_payment_id matches no local row — the sweep-minted duplicate — finds
|
|
// its pending origin row by the replayed idempotency key, marks it failed (not
|
|
// rescued), and raises exactly one deduped admin notification.
|
|
func TestWebhook_PaymentUpdated_OrphanedReplay_MarksOriginFailed(t *testing.T) {
|
|
const (
|
|
orphanSquareID = "sqp_orphan_c2"
|
|
idemKey = "b1-orphan-key-001"
|
|
)
|
|
originID := createWebhookTestPendingOrigin(t, idemKey)
|
|
// The sweep replayed the origin's expired key and attempted the B1
|
|
// auto-refund — the evidence the orphan-detection gate requires.
|
|
seedWebhookTestB1Evidence(t, originID)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_orphan_c2_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + orphanSquareID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + orphanSquareID + `",
|
|
"status": "COMPLETED",
|
|
"idempotency_key": "` + idemKey + `",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
// The origin row must be settled to 'failed' — NOT rescued to 'completed'
|
|
// (which would hide the duplicate behind the original charge).
|
|
if got := getPaymentStatus(t, originID); got != "failed" {
|
|
t.Errorf("expected origin pending payment 'failed', got %q", got)
|
|
}
|
|
if n := countOrphanReplayNotifications(t, originID); n != 1 {
|
|
t.Errorf("expected exactly 1 orphan-replay notification, got %d", n)
|
|
}
|
|
|
|
// Re-delivery under a FRESH event_id (bypassing the handler's event_id
|
|
// dedup) must not add a second notification — the deterministic per-origin
|
|
// id dedups (and, by extension, the sweep's auto-refund cannot be
|
|
// double-triggered by this path).
|
|
event.EventID = "evt_orphan_c2_2"
|
|
w2 := deliverWebhook(t, event)
|
|
if w2.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 on re-delivery, got %d: %s", w2.Code, w2.Body.String())
|
|
}
|
|
if n := countOrphanReplayNotifications(t, originID); n != 1 {
|
|
t.Errorf("expected notification count to stay 1 after re-delivery, got %d", n)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_OrphanedReplay_NoOrigin_Retries verifies the
|
|
// round-8 fix 3 behavior: a COMPLETED payment whose square_payment_id matches
|
|
// NO local row (payments or till_sales) AND NO pending origin row by
|
|
// idempotency key/reference_id is a GENUINELY unknown charge. It is no longer
|
|
// acked 200 — the handler returns 503 so Square re-delivers (its retry budget
|
|
// bounds the retries) and writes NO dedup row, so the event can never be
|
|
// dropped permanently. No critical notification is raised (there is no issue to
|
|
// attribute, just an unresolved event).
|
|
func TestWebhook_PaymentUpdated_OrphanedReplay_NoOrigin_Retries(t *testing.T) {
|
|
const orphanSquareID = "sqp_orphan_noorigin"
|
|
before := countCriticalNotifications(t)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_orphan_noorigin_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + orphanSquareID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + orphanSquareID + `",
|
|
"status": "COMPLETED",
|
|
"idempotency_key": "b1-orphan-key-never-used",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusServiceUnavailable {
|
|
t.Fatalf("expected 503 for a genuinely unknown COMPLETED payment (unresolved money event must be retried, not acked), got %d. body: %s", w.Code, w.Body.String())
|
|
}
|
|
if n := countCriticalNotifications(t) - before; n != 0 {
|
|
t.Errorf("expected no new critical notification with no origin match, got %d", n)
|
|
}
|
|
if got := countWebhookEvents(t, event.EventID); got != 0 {
|
|
t.Errorf("expected NO dedup row for the unresolved unknown payment (Square must retry), got %d", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_OrphanedReplay_NoB1Evidence_LeavesPending
|
|
// verifies the B1-evidence gate: a COMPLETED payment.updated that matches a
|
|
// pending origin row by idempotency key but with NO B1 evidence (the sweep
|
|
// never replayed + auto-refunded) is treated as a delayed legit completion —
|
|
// the origin is LEFT pending, never marked failed, and no orphan notification
|
|
// is raised. The stale-pending sweep reconciles the row instead.
|
|
func TestWebhook_PaymentUpdated_OrphanedReplay_NoB1Evidence_LeavesPending(t *testing.T) {
|
|
const (
|
|
orphanSquareID = "sqp_orphan_noevidence"
|
|
idemKey = "b1-orphan-key-no-evidence"
|
|
)
|
|
originID := createWebhookTestPendingOrigin(t, idemKey)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_orphan_noevidence_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + orphanSquareID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + orphanSquareID + `",
|
|
"status": "COMPLETED",
|
|
"idempotency_key": "` + idemKey + `",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
// The origin must remain pending — the delayed legit completion must never
|
|
// be failed without sweep B1 evidence.
|
|
if got := getPaymentStatus(t, originID); got != "pending" {
|
|
t.Errorf("expected origin pending payment to stay 'pending', got %q", got)
|
|
}
|
|
if n := countOrphanReplayNotifications(t, originID); n != 0 {
|
|
t.Errorf("expected 0 orphan-replay notifications without B1 evidence, got %d", n)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_OrphanedReplay_ReferenceFallback locks the
|
|
// reference_id fallback of the origin lookup: a COMPLETED orphan event whose
|
|
// payload carries no idempotency key still finds its pending origin row via the
|
|
// replayed reference_id + matching amount.
|
|
func TestWebhook_PaymentUpdated_OrphanedReplay_ReferenceFallback(t *testing.T) {
|
|
const (
|
|
orphanSquareID = "sqp_orphan_refc2"
|
|
refID = "b16bad0000aa"
|
|
)
|
|
var originID string
|
|
// The origin row is aged past the sweep's keyed-replay age (22h) so the
|
|
// orphan detection treats it as a sweep-replayable origin (a fresh pending
|
|
// row is never failed by the orphan detection — see the age gate).
|
|
if err := db.Conn.QueryRow(context.Background(), `
|
|
INSERT INTO payments (payment_type, payment_method, status, amount, gift_card_id, created_at, updated_at)
|
|
VALUES ('full', 'online_square', 'pending', 10.00, $1, NOW() - INTERVAL '23 hours', NOW())
|
|
RETURNING id
|
|
`, refID).Scan(&originID); err != nil {
|
|
t.Fatalf("failed to create reference-origin payment: %v", err)
|
|
}
|
|
seedWebhookTestB1Evidence(t, originID)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_orphan_refc2_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + orphanSquareID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + orphanSquareID + `",
|
|
"status": "COMPLETED",
|
|
"reference_id": "` + refID + `",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, originID); got != "failed" {
|
|
t.Errorf("expected reference-matched origin payment 'failed', got %q", got)
|
|
}
|
|
if n := countOrphanReplayNotifications(t, originID); n != 1 {
|
|
t.Errorf("expected exactly 1 orphan-replay notification, got %d", n)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_PaymentUpdated_SettledRow_NoOrphanDetection verifies the orphan
|
|
// detection NEVER fires for a charge that already has a local row in a settled
|
|
// status (a plain payment.updated replay of a known charge): the row is left
|
|
// untouched and no notification is raised.
|
|
func TestWebhook_PaymentUpdated_SettledRow_NoOrphanDetection(t *testing.T) {
|
|
const squarePaymentID = "sqp_settled_replay"
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
before := countCriticalNotifications(t)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "payment.updated",
|
|
EventID: "evt_settled_replay_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + squarePaymentID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + squarePaymentID + `",
|
|
"status": "COMPLETED",
|
|
"idempotency_key": "b1-settled-key",
|
|
"amount_money": {"amount": 1000, "currency": "GBP"}
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "completed" {
|
|
t.Errorf("expected settled payment to stay 'completed', got %q", got)
|
|
}
|
|
if n := countCriticalNotifications(t) - before; n != 0 {
|
|
t.Errorf("expected no new critical notification for a known settled row, got %d", n)
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// State mutation — refund.updated
|
|
// =============================================================================
|
|
|
|
func TestWebhook_RefundUpdated_UpdatesRefundStatus(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_pay"
|
|
squareRefundID = "sqr_updated_completed"
|
|
)
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
refundID := createWebhookTestRefund(t, payID, squareRefundID, "pending")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_updated_completed_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "COMPLETED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "completed" {
|
|
t.Errorf("expected refund status 'completed', got %q", got)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_RefundUpdated_FailedStatus(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_pay_fail"
|
|
squareRefundID = "sqr_updated_failed"
|
|
)
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
refundID := createWebhookTestRefund(t, payID, squareRefundID, "pending")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_updated_failed_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "FAILED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "failed" {
|
|
t.Errorf("expected refund status 'failed', got %q", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_RefundUpdated_RejectedStatus locks the REJECTED mapping: Square
|
|
// rejects a refund (REJECTED is a terminal state — Square declined to process
|
|
// it), so the local refund must be marked 'failed' and surfaced immediately
|
|
// instead of staying pending until the slow sweep notices.
|
|
func TestWebhook_RefundUpdated_RejectedStatus(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_pay_reject"
|
|
squareRefundID = "sqr_updated_rejected"
|
|
)
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
refundID := createWebhookTestRefund(t, payID, squareRefundID, "pending")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_updated_rejected_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "REJECTED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "failed" {
|
|
t.Errorf("expected refund status 'failed' on REJECTED, got %q", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_RefundUpdated_Failed_RaisesAdminNotification locks the A5d fix:
|
|
// a FAILED (or REJECTED) refund.updated event demotes the pending refund row
|
|
// BEFORE the sweep ever sees it, so the sweep-path refund_failed admin
|
|
// notification would be permanently lost — the webhook path must raise the
|
|
// notification itself, and only once.
|
|
func TestWebhook_RefundUpdated_Failed_RaisesAdminNotification(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_pay_notify"
|
|
squareRefundID = "sqr_updated_failed_notify"
|
|
)
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
refundID := createWebhookTestRefund(t, payID, squareRefundID, "pending")
|
|
|
|
countBefore := countRefundFailedNotifications(t)
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_updated_failed_notify_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "FAILED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "failed" {
|
|
t.Fatalf("expected refund status 'failed', got %q", got)
|
|
}
|
|
if n := countRefundFailedNotifications(t) - countBefore; n != 1 {
|
|
t.Errorf("expected exactly 1 refund_failed admin notification after webhook demotion, got %d", n)
|
|
}
|
|
|
|
// Re-delivery of the SAME event must not add a second notification (the
|
|
// handler's event_id dedup drops the replay before dispatch).
|
|
w2 := deliverWebhook(t, event)
|
|
if w2.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 on re-delivery, got %d: %s", w2.Code, w2.Body.String())
|
|
}
|
|
if n := countRefundFailedNotifications(t) - countBefore; n != 1 {
|
|
t.Errorf("expected the notification count to stay at 1 after re-delivery, got %d", n)
|
|
}
|
|
}
|
|
|
|
func TestWebhook_RefundUpdated_NonTerminal_LeavesPending(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_pay_pending"
|
|
squareRefundID = "sqr_updated_pending"
|
|
)
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
refundID := createWebhookTestRefund(t, payID, squareRefundID, "pending")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_updated_pending_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "PENDING",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "pending" {
|
|
t.Errorf("expected refund to stay 'pending' on non-terminal PENDING, got %q", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_RefundUpdated_Approved_IsNonTerminal locks the webhook-only
|
|
// APPROVED override (finding 2): an APPROVED Square refund is still in flight
|
|
// and may settle COMPLETED or FAILED afterwards, so the webhook must leave the
|
|
// local row 'pending' — NOT promote it to 'completed' the way the synchronous
|
|
// refund handlers resolve a blocking APPROVED result. A later FAILED event
|
|
// must then be able to demote it; promoting on APPROVED would make that
|
|
// demotion a no-op (the FAILED path only demotes 'pending' rows) and the
|
|
// over-refund guard would count money that never actually moved.
|
|
func TestWebhook_RefundUpdated_Approved_IsNonTerminal(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_pay_approved"
|
|
squareRefundID = "sqr_updated_approved"
|
|
)
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
refundID := createWebhookTestRefund(t, payID, squareRefundID, "pending")
|
|
|
|
approved := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_updated_approved_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "APPROVED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, approved)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 on APPROVED, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "pending" {
|
|
t.Fatalf("expected APPROVED to leave the refund 'pending', got %q", got)
|
|
}
|
|
|
|
// A later FAILED event (Square declined the refund) must demote the still-
|
|
// pending row — the exact transition promoting on APPROVED would have broken.
|
|
failed := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_updated_approved_fail_1",
|
|
CreatedAt: nowInRFC3339(time.Second),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "FAILED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w2 := deliverWebhook(t, failed)
|
|
if w2.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 on FAILED after APPROVED, got %d: %s", w2.Code, w2.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "failed" {
|
|
t.Errorf("expected the APPROVED-then-FAILED refund to be demoted to 'failed', got %q", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_RefundUpdated_Completed_SweepDupResolvesParent locks finding 1:
|
|
// a COMPLETED webhook for a B1 sweep auto-refund of a replay-induced duplicate
|
|
// charge (reason "duplicate charge — sweep replay") must ALSO resolve the
|
|
// parent payment row — the B1 re-poll pass (sweepPendingB1Refunds, refunds.go)
|
|
// only queries refunds rows still 'pending', so once the webhook promotes this
|
|
// row to 'completed' the re-poll can never resolve the parent again. A
|
|
// still-pending parent would let the stale-pending sweep re-replay the expired
|
|
// idempotency key each run, minting a NEW charge (HIGH). The parent payment
|
|
// must be marked failed by the same webhook that promoted the refund.
|
|
func TestWebhook_RefundUpdated_Completed_SweepDupResolvesParent(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_sweepdup_parent"
|
|
squareRefundID = "sqr_sweepdup_parent"
|
|
)
|
|
// The parent is a still-PENDING payment row (the sweep-failed row the
|
|
// duplicate was minted for). The refund is attached to it with the B1
|
|
// sweep-dup reason.
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "pending")
|
|
refundID := createWebhookTestRefundWithReason(t, payID, squareRefundID, "pending", "duplicate charge — sweep replay")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_sweepdup_parent_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "COMPLETED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "completed" {
|
|
t.Errorf("expected sweep-dup refund 'completed', got %q", got)
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "failed" {
|
|
t.Errorf("expected the sweep-dup refund's parent payment to be resolved to 'failed', got %q", got)
|
|
}
|
|
}
|
|
|
|
// TestWebhook_RefundUpdated_Completed_SweepDupResolvesTillSale locks the
|
|
// till_sale branch of finding 1: a COMPLETED webhook for a B1 sweep-dup refund
|
|
// whose reason carries "(till_sale <id>)" must claw back the till sale's funded
|
|
// gift card and mark the sale failed — mirroring the sweep's re-poll resolution.
|
|
func TestWebhook_RefundUpdated_Completed_SweepDupResolvesTillSale(t *testing.T) {
|
|
const squareRefundID = "sqr_sweepdup_tillsale"
|
|
createdAt := nowInRFC3339(0)
|
|
saleID, giftCardID := createWebhookTestGiftCardAndSale(t, "sqp_sweepdup_tillsale_pay", createdAt, createdAt, 40.00)
|
|
|
|
// A synthetic completed payments row anchors the refund (mirrors
|
|
// recordSweepDuplicateRefundRow); the till_sale id lives in the reason.
|
|
adminID, err := fixtures.CreateTestAdminUser(db.Conn)
|
|
if err != nil {
|
|
t.Fatalf("failed to create admin for sweep-dup till sale: %v", err)
|
|
}
|
|
var payID string
|
|
if err := db.Conn.QueryRow(context.Background(), `
|
|
INSERT INTO payments (payment_type, payment_method, status, amount, created_by, created_at)
|
|
VALUES ('full', 'in_person_card', 'completed', 40.00, $1, NOW())
|
|
RETURNING id
|
|
`, adminID).Scan(&payID); err != nil {
|
|
t.Fatalf("failed to create synthetic payment for sweep-dup till sale: %v", err)
|
|
}
|
|
refundID := createWebhookTestRefundWithReason(t, payID, squareRefundID, "pending", "duplicate charge — sweep replay (till_sale "+saleID+")")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_sweepdup_tillsale_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "COMPLETED",
|
|
"payment_id": "sqp_sweepdup_tillsale_pay"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "completed" {
|
|
t.Errorf("expected sweep-dup refund 'completed', got %q", got)
|
|
}
|
|
if got := getTillSaleStatus(t, saleID); got != "failed" {
|
|
t.Errorf("expected the sweep-dup refund's till sale to be marked 'failed', got %q", got)
|
|
}
|
|
if exists := giftCardExists(t, giftCardID); exists {
|
|
t.Error("expected the created gift card to be deleted by the till-sale clawback")
|
|
}
|
|
}
|
|
|
|
// TestWebhook_RefundUpdated_DoesNotDemoteCompleted guards the FAILED
|
|
// transition: a completed refund must never be demoted to 'failed' by a late
|
|
// webhook, since the over-refund guard counts 'completed' refunds — demoting
|
|
// would let the guard exclude money that already moved.
|
|
func TestWebhook_RefundUpdated_DoesNotDemoteCompleted(t *testing.T) {
|
|
const (
|
|
squarePaymentID = "sqp_refund_pay_demote"
|
|
squareRefundID = "sqr_demote"
|
|
)
|
|
payID := createWebhookTestPayment(t, squarePaymentID, "completed")
|
|
refundID := createWebhookTestRefund(t, payID, squareRefundID, "completed")
|
|
|
|
event := SquareWebhookEvent{
|
|
Type: "refund.updated",
|
|
EventID: "evt_refund_demote_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "` + squareRefundID + `",
|
|
"object": {
|
|
"refund": {
|
|
"id": "` + squareRefundID + `",
|
|
"status": "FAILED",
|
|
"payment_id": "` + squarePaymentID + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, event)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "completed" {
|
|
t.Errorf("expected completed refund to stay 'completed', got %q", got)
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Event-type aliases — payment.created / refund.created route to the updated
|
|
// handlers (square.go switch cases)
|
|
// =============================================================================
|
|
|
|
// TestWebhook_EventTypeAliases_RouteToUpdatedHandlers locks the switch aliases:
|
|
// payment.created and refund.created (Square's distinct event types for the
|
|
// creation of a payment/refund) must route to the SAME handlers as
|
|
// payment.updated / refund.updated — they carry the identical
|
|
// data.object.payment / data.object.refund envelope and must reconcile state
|
|
// identically. A regression dropping the aliases from the switch would send
|
|
// these events to the 501 default branch, silently visible only as missing
|
|
// state mutations.
|
|
func TestWebhook_EventTypeAliases_RouteToUpdatedHandlers(t *testing.T) {
|
|
const sqPayID = "sqp_alias_pay"
|
|
payID := createWebhookTestPayment(t, sqPayID, "pending")
|
|
// The webhook's booking gate (round-8) only completes booking-attached
|
|
// rows — attach a payable booking so the gate completes the payment.
|
|
attachWebhookTestBooking(t, payID, 10.00)
|
|
|
|
payEvent := SquareWebhookEvent{
|
|
Type: "payment.created",
|
|
EventID: "evt_alias_payment_created_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "payment",
|
|
"id": "` + sqPayID + `",
|
|
"object": {
|
|
"payment": {
|
|
"id": "` + sqPayID + `",
|
|
"status": "COMPLETED"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w := deliverWebhook(t, payEvent)
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 for payment.created, got %d: %s", w.Code, w.Body.String())
|
|
}
|
|
if got := getPaymentStatus(t, payID); got != "completed" {
|
|
t.Errorf("expected payment.created to flip payment to 'completed' (alias of payment.updated), got %q", got)
|
|
}
|
|
if n := countWebhookEvents(t, payEvent.EventID); n != 1 {
|
|
t.Errorf("expected 1 dedup row for payment.created, got %d", n)
|
|
}
|
|
|
|
const sqPayForRefund = "sqp_alias_refund"
|
|
payForRefund := createWebhookTestPayment(t, sqPayForRefund, "completed")
|
|
refundID := createWebhookTestRefund(t, payForRefund, "sqr_alias_refund", "pending")
|
|
|
|
refundEvent := SquareWebhookEvent{
|
|
Type: "refund.created",
|
|
EventID: "evt_alias_refund_created_1",
|
|
CreatedAt: nowInRFC3339(0),
|
|
Data: json.RawMessage(`{
|
|
"type": "refund",
|
|
"id": "sqr_alias_refund",
|
|
"object": {
|
|
"refund": {
|
|
"id": "sqr_alias_refund",
|
|
"status": "COMPLETED",
|
|
"payment_id": "` + sqPayForRefund + `"
|
|
}
|
|
}
|
|
}`),
|
|
}
|
|
w2 := deliverWebhook(t, refundEvent)
|
|
if w2.Code != http.StatusOK {
|
|
t.Fatalf("expected 200 for refund.created, got %d: %s", w2.Code, w2.Body.String())
|
|
}
|
|
if got := getRefundStatus(t, refundID); got != "completed" {
|
|
t.Errorf("expected refund.created to flip refund to 'completed' (alias of refund.updated), got %q", got)
|
|
}
|
|
if n := countWebhookEvents(t, refundEvent.EventID); n != 1 {
|
|
t.Errorf("expected 1 dedup row for refund.created, got %d", n)
|
|
}
|
|
}
|