scrabble-game/backend/internal/inttest/payments_intake_test.go

//go:build integration

package inttest

import (
	"context"
	"errors"
	"testing"

	"github.com/google/uuid"

	"scrabble/backend/internal/payments"
)

// orderStatus reads an order's status.
func orderStatus(t *testing.T, orderID uuid.UUID) string {
	t.Helper()
	var status string
	if err := testDB.QueryRowContext(context.Background(),
		`SELECT status FROM payments.orders WHERE order_id=$1`, orderID).Scan(&status); err != nil {
		t.Fatalf("read order status: %v", err)
	}
	return status
}

// TestPaymentsOrderFundCreditsOnce verifies the intake path over Postgres: creating an order then
// funding it credits the funded segment exactly once, and a replayed callback (the same order)
// credits nothing more — the ledger idempotency index holds.
func TestPaymentsOrderFundCreditsOnce(t *testing.T) {
	ctx := context.Background()
	svc := newPaymentsService()
	acc := uuid.New()
	prod := seedPackProduct(t, 100, methodPrice{method: "direct", currency: "RUB", amount: 14900}) // 149.00 RUB funds 100 chips

	res, err := svc.CreateOrder(ctx, acc, payments.NewContext("direct", "web"), []payments.Source{payments.SourceDirect}, prod, "robokassa")
	if err != nil {
		t.Fatalf("create order: %v", err)
	}
	if res.Amount.Minor() != 14900 || res.Amount.Currency() != payments.CurrencyRUB {
		t.Fatalf("order amount = %s, want 149.00 RUB", res.Amount)
	}
	if orderStatus(t, res.OrderID) != "pending" {
		t.Errorf("new order status = %s, want pending", orderStatus(t, res.OrderID))
	}

	paid, _ := payments.MoneyFromMinor(14900, payments.CurrencyRUB)
	out, err := svc.Fund(ctx, res.OrderID, "robokassa", res.OrderID.String(), paid)
	if err != nil {
		t.Fatalf("fund: %v", err)
	}
	if out.AlreadyCredited || out.Chips != 100 || out.Source != payments.SourceDirect {
		t.Fatalf("fund outcome = %+v, want 100 chips to direct, not already-credited", out)
	}
	if got := readBalance(t, acc, "direct"); got != 100 {
		t.Errorf("balance after fund = %d, want 100", got)
	}
	if ledgerRows(t, acc, "fund") != 1 {
		t.Errorf("fund ledger rows = %d, want 1", ledgerRows(t, acc, "fund"))
	}
	if orderStatus(t, res.OrderID) != "paid" {
		t.Errorf("order status after fund = %s, want paid", orderStatus(t, res.OrderID))
	}

	// A replayed callback for the same order is rejected by the unique index: no second credit.
	out2, err := svc.Fund(ctx, res.OrderID, "robokassa", res.OrderID.String(), paid)
	if err != nil {
		t.Fatalf("duplicate fund: %v", err)
	}
	if !out2.AlreadyCredited {
		t.Error("duplicate callback not flagged AlreadyCredited")
	}
	if got := readBalance(t, acc, "direct"); got != 100 {
		t.Errorf("balance after duplicate = %d, want 100 (credited once)", got)
	}
	if ledgerRows(t, acc, "fund") != 1 {
		t.Error("duplicate callback wrote a second fund ledger row")
	}
}

// TestPaymentsVKOrderFundCredits exercises the VK Votes rail over Postgres: a VK order prices the
// pack in votes; the get_item lookup returns its title and vote price; a chargeable
// order_status_change credits the vk segment exactly once (idempotent on VK's own order id).
func TestPaymentsVKOrderFundCredits(t *testing.T) {
	ctx := context.Background()
	svc := newPaymentsService()
	acc := uuid.New()
	prod := seedPackProduct(t, 200, methodPrice{method: "vk", currency: "VOTE", amount: 30})

	res, err := svc.CreateOrder(ctx, acc, payments.NewContext("vk", "web"), []payments.Source{payments.SourceVK}, prod, "vk")
	if err != nil {
		t.Fatalf("create vk order: %v", err)
	}
	if res.Amount.Currency() != payments.CurrencyVote || res.Amount.Minor() != 30 {
		t.Fatalf("vk order amount = %s, want 30 VOTE", res.Amount)
	}

	// get_item phase: title + vote price.
	title, amount, err := svc.OrderItem(ctx, res.OrderID)
	if err != nil {
		t.Fatalf("order item: %v", err)
	}
	if title == "" || amount.Minor() != 30 || amount.Currency() != payments.CurrencyVote {
		t.Errorf("order item = %q / %s, want a title + 30 VOTE", title, amount)
	}

	// order_status_change phase: VK's own order id is the idempotency key.
	paid, _ := payments.MoneyFromMinor(30, payments.CurrencyVote)
	out, err := svc.Fund(ctx, res.OrderID, "vk", "vk-order-777", paid)
	if err != nil {
		t.Fatalf("vk fund: %v", err)
	}
	if out.AlreadyCredited || out.Chips != 200 || out.Source != payments.SourceVK {
		t.Fatalf("vk fund outcome = %+v, want 200 chips credited to vk", out)
	}
	if got := readBalance(t, acc, "vk"); got != 200 {
		t.Errorf("vk balance after fund = %d, want 200", got)
	}

	// A duplicate VK callback (same VK order id) credits nothing more.
	out2, err := svc.Fund(ctx, res.OrderID, "vk", "vk-order-777", paid)
	if err != nil {
		t.Fatalf("duplicate vk fund: %v", err)
	}
	if !out2.AlreadyCredited {
		t.Error("duplicate VK callback not flagged AlreadyCredited")
	}
	if got := readBalance(t, acc, "vk"); got != 200 {
		t.Errorf("vk balance after duplicate = %d, want 200 (credited once)", got)
	}
}

// TestPaymentsFundAmountMismatch verifies a callback whose paid amount does not match the order is
// refused and credits nothing (§9: verify the amount after matching by order id).
func TestPaymentsFundAmountMismatch(t *testing.T) {
	ctx := context.Background()
	svc := newPaymentsService()
	acc := uuid.New()
	prod := seedPackProduct(t, 100, methodPrice{method: "direct", currency: "RUB", amount: 14900})

	res, err := svc.CreateOrder(ctx, acc, payments.NewContext("direct", "web"), []payments.Source{payments.SourceDirect}, prod, "robokassa")
	if err != nil {
		t.Fatalf("create order: %v", err)
	}
	underpaid, _ := payments.MoneyFromMinor(100, payments.CurrencyRUB)
	if _, err := svc.Fund(ctx, res.OrderID, "robokassa", res.OrderID.String(), underpaid); !errors.Is(err, payments.ErrAmountMismatch) {
		t.Fatalf("fund = %v, want ErrAmountMismatch", err)
	}
	if got := readBalance(t, acc, "direct"); got != 0 {
		t.Errorf("balance = %d, want 0 (nothing credited on mismatch)", got)
	}
	if ledgerRows(t, acc, "fund") != 0 {
		t.Error("fund ledger row written on an amount mismatch")
	}
}

// TestPaymentsEventDispatchDrain verifies the payment_events dispatcher queue: a recorded event is
// returned as undispatched until marked, then drops out (so the dispatcher delivers it once).
func TestPaymentsEventDispatchDrain(t *testing.T) {
	ctx := context.Background()
	svc := newPaymentsService()
	acc := uuid.New()
	if err := svc.RecordPaymentEvent(ctx, acc, nil, "succeeded", []byte(`{"chips":10,"source":"direct"}`)); err != nil {
		t.Fatalf("record event: %v", err)
	}

	// testDB is shared, so filter the queue to our account.
	find := func() *payments.PaymentEvent {
		evs, err := svc.UndispatchedEvents(ctx, 100)
		if err != nil {
			t.Fatalf("undispatched: %v", err)
		}
		for i := range evs {
			if evs[i].AccountID == acc {
				return &evs[i]
			}
		}
		return nil
	}

	mine := find()
	if mine == nil {
		t.Fatal("recorded event not in the undispatched queue")
	}
	if mine.Type != "succeeded" {
		t.Errorf("event type = %s, want succeeded", mine.Type)
	}
	if err := svc.MarkEventDispatched(ctx, mine.EventID); err != nil {
		t.Fatalf("mark dispatched: %v", err)
	}
	if find() != nil {
		t.Error("event still undispatched after MarkEventDispatched")
	}
}

// TestPaymentsExpiredOrderStillCredits verifies an expired pending order is still honoured by a
// later valid callback (§9/D23: expiry is cosmetic, the money is real).
func TestPaymentsExpiredOrderStillCredits(t *testing.T) {
	ctx := context.Background()
	svc := newPaymentsService()
	acc := uuid.New()
	prod := seedPackProduct(t, 100, methodPrice{method: "direct", currency: "RUB", amount: 14900})

	res, err := svc.CreateOrder(ctx, acc, payments.NewContext("direct", "web"), []payments.Source{payments.SourceDirect}, prod, "robokassa")
	if err != nil {
		t.Fatalf("create order: %v", err)
	}
	// Age the order well past the configured TTL, then sweep it to expired.
	if _, err := testDB.ExecContext(ctx,
		`UPDATE payments.orders SET created_at = now() - interval '1 day' WHERE order_id=$1`, res.OrderID); err != nil {
		t.Fatalf("age order: %v", err)
	}
	if n, err := svc.ExpireOrders(ctx); err != nil || n < 1 {
		t.Fatalf("expire orders = %d (err %v), want at least 1", n, err)
	}
	if orderStatus(t, res.OrderID) != "expired" {
		t.Fatalf("order status = %s, want expired before the late callback", orderStatus(t, res.OrderID))
	}

	paid, _ := payments.MoneyFromMinor(14900, payments.CurrencyRUB)
	out, err := svc.Fund(ctx, res.OrderID, "robokassa", res.OrderID.String(), paid)
	if err != nil {
		t.Fatalf("fund after expiry: %v", err)
	}
	if out.AlreadyCredited || out.Chips != 100 {
		t.Fatalf("fund outcome = %+v, want a fresh 100-chip credit", out)
	}
	if got := readBalance(t, acc, "direct"); got != 100 {
		t.Errorf("balance = %d, want 100 (expired order honoured)", got)
	}
	if orderStatus(t, res.OrderID) != "paid" {
		t.Errorf("order status = %s, want paid after the honoured callback", orderStatus(t, res.OrderID))
	}
}