veza/veza-backend-api/internal/core/subscription/recovery_test.go

package subscription

import (
	"context"
	"errors"
	"testing"
	"time"

	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

// TestGetPendingPaymentSubscription verifies the recovery probe used by
// distribution.checkEligibility to distinguish "no plan at all" from
// "plan with stalled payment". The most-recently-created pending row
// wins (multiple rows may exist after a retry).
func TestGetPendingPaymentSubscription(t *testing.T) {
	ctx := context.Background()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(&Plan{}, &UserSubscription{}, &Invoice{}))

	svc := NewService(db, zap.NewNop())

	plan := Plan{ID: uuid.New(), Name: PlanCreator, DisplayName: "Creator", PriceMonthly: 999, IsActive: true}
	require.NoError(t, db.Create(&plan).Error)

	t.Run("no row returns ErrNoActiveSubscription", func(t *testing.T) {
		userID := uuid.New()
		_, err := svc.GetPendingPaymentSubscription(ctx, userID)
		require.Error(t, err)
		assert.True(t, errors.Is(err, ErrNoActiveSubscription))
	})

	t.Run("active row is invisible to the recovery probe", func(t *testing.T) {
		userID := uuid.New()
		now := time.Now()
		require.NoError(t, db.Create(&UserSubscription{
			UserID: userID, PlanID: plan.ID, Status: StatusActive,
			BillingCycle:       BillingMonthly,
			CurrentPeriodStart: now, CurrentPeriodEnd: now.AddDate(0, 1, 0),
		}).Error)

		_, err := svc.GetPendingPaymentSubscription(ctx, userID)
		require.Error(t, err)
		assert.True(t, errors.Is(err, ErrNoActiveSubscription),
			"active rows must NOT be returned by the pending-payment probe")
	})

	t.Run("pending row returned, plan preloaded", func(t *testing.T) {
		userID := uuid.New()
		now := time.Now()
		require.NoError(t, db.Create(&UserSubscription{
			UserID: userID, PlanID: plan.ID, Status: StatusPendingPayment,
			BillingCycle:       BillingMonthly,
			CurrentPeriodStart: now, CurrentPeriodEnd: now.AddDate(0, 1, 0),
		}).Error)

		got, err := svc.GetPendingPaymentSubscription(ctx, userID)
		require.NoError(t, err)
		assert.Equal(t, StatusPendingPayment, got.Status)
		assert.Equal(t, plan.ID, got.Plan.ID, "Plan must be preloaded so callers don't issue a second query")
	})

	t.Run("multiple pending rows: most recent wins", func(t *testing.T) {
		userID := uuid.New()
		earlier := time.Now().Add(-1 * time.Hour)
		later := time.Now()
		require.NoError(t, db.Create(&UserSubscription{
			UserID: userID, PlanID: plan.ID, Status: StatusPendingPayment,
			BillingCycle:       BillingMonthly,
			CurrentPeriodStart: earlier, CurrentPeriodEnd: earlier.AddDate(0, 1, 0),
			CreatedAt: earlier,
		}).Error)
		require.NoError(t, db.Create(&UserSubscription{
			UserID: userID, PlanID: plan.ID, Status: StatusPendingPayment,
			BillingCycle:       BillingYearly,
			CurrentPeriodStart: later, CurrentPeriodEnd: later.AddDate(1, 0, 0),
			CreatedAt: later,
		}).Error)

		got, err := svc.GetPendingPaymentSubscription(ctx, userID)
		require.NoError(t, err)
		assert.Equal(t, BillingYearly, got.BillingCycle, "newest pending row should win")
	})
}

// TestCompletePendingPayment exercises the recovery endpoint logic:
// happy path threads the same idempotency key as Phase 1, and the
// state-guard branches return distinct errors so the handler can map
// them to 404 / 409 / 503.
func TestCompletePendingPayment(t *testing.T) {
	ctx := context.Background()

	newDB := func(t *testing.T) *gorm.DB {
		t.Helper()
		db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
		require.NoError(t, err)
		require.NoError(t, db.AutoMigrate(&Plan{}, &UserSubscription{}, &Invoice{}))
		return db
	}

	seedPending := func(t *testing.T, db *gorm.DB, userID uuid.UUID, paymentID string) (*UserSubscription, *Invoice) {
		t.Helper()
		plan := Plan{ID: uuid.New(), Name: PlanCreator, DisplayName: "Creator", PriceMonthly: 999, Currency: "USD", IsActive: true}
		require.NoError(t, db.Create(&plan).Error)
		now := time.Now()
		sub := UserSubscription{
			UserID: userID, PlanID: plan.ID, Status: StatusPendingPayment,
			BillingCycle:       BillingMonthly,
			CurrentPeriodStart: now, CurrentPeriodEnd: now.AddDate(0, 1, 0),
		}
		require.NoError(t, db.Create(&sub).Error)
		inv := Invoice{
			SubscriptionID: sub.ID, UserID: userID,
			AmountCents: 999, Currency: "USD", Status: InvoicePending,
			BillingPeriodStart: now, BillingPeriodEnd: now.AddDate(0, 1, 0),
			HyperswitchPaymentID: paymentID,
		}
		require.NoError(t, db.Create(&inv).Error)
		return &sub, &inv
	}

	t.Run("happy path returns existing client_secret + payment_id", func(t *testing.T) {
		db := newDB(t)
		provider := &fakePaymentProvider{}
		svc := NewService(db, zap.NewNop(), WithPaymentProvider(provider))

		userID := uuid.New()
		sub, _ := seedPending(t, db, userID, "pay_existing")

		resp, err := svc.CompletePendingPayment(ctx, userID, sub.ID)
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.NotNil(t, resp.Subscription)
		assert.Equal(t, sub.ID, resp.Subscription.ID)
		assert.NotEmpty(t, resp.ClientSecret, "client_secret must be returned for the SPA to drive payment UI")
		assert.NotEmpty(t, resp.PaymentID, "payment_id must be returned")

		// Idempotency key must match the Phase 1 pattern (sub.ID.String())
		// so the PSP returns the existing intent rather than creating a
		// duplicate.
		require.Len(t, provider.calls, 1)
		assert.Equal(t, sub.ID.String(), provider.calls[0].idempotencyKey)
		assert.Equal(t, "true", provider.calls[0].metadata["recovery"], "metadata.recovery flag lets the PSP audit recovery calls")
	})

	t.Run("not owned by caller returns ErrSubscriptionNotFound", func(t *testing.T) {
		db := newDB(t)
		svc := NewService(db, zap.NewNop(), WithPaymentProvider(&fakePaymentProvider{}))

		owner := uuid.New()
		sub, _ := seedPending(t, db, owner, "pay_other")
		intruder := uuid.New()

		_, err := svc.CompletePendingPayment(ctx, intruder, sub.ID)
		require.Error(t, err)
		assert.True(t, errors.Is(err, ErrSubscriptionNotFound),
			"ownership mismatch must surface as not-found, not as a permission error (avoids leaking sub IDs)")
	})

	t.Run("not in pending_payment returns ErrSubscriptionNotPending", func(t *testing.T) {
		db := newDB(t)
		svc := NewService(db, zap.NewNop(), WithPaymentProvider(&fakePaymentProvider{}))

		userID := uuid.New()
		sub, _ := seedPending(t, db, userID, "pay_already_active")
		// Webhook arrived between the user opening the recovery page and
		// posting it — sub is now active.
		require.NoError(t, db.Model(&UserSubscription{}).
			Where("id = ?", sub.ID).
			Update("status", StatusActive).Error)

		_, err := svc.CompletePendingPayment(ctx, userID, sub.ID)
		require.Error(t, err)
		assert.True(t, errors.Is(err, ErrSubscriptionNotPending),
			"active rows must reject recovery so the SPA refreshes /me instead of starting a duplicate flow")
	})

	t.Run("no provider configured returns ErrPaymentProviderRequired", func(t *testing.T) {
		db := newDB(t)
		// No WithPaymentProvider — simulates HYPERSWITCH_ENABLED=false.
		svc := NewService(db, zap.NewNop())

		userID := uuid.New()
		sub, _ := seedPending(t, db, userID, "pay_noprov")

		_, err := svc.CompletePendingPayment(ctx, userID, sub.ID)
		require.Error(t, err)
		assert.True(t, errors.Is(err, ErrPaymentProviderRequired),
			"recovery must fail loud when the PSP is not wired (mirrors Subscribe's fail-closed behaviour)")
	})

	t.Run("provider error propagates wrapped", func(t *testing.T) {
		db := newDB(t)
		provider := &fakePaymentProvider{createErr: errors.New("PSP 503")}
		svc := NewService(db, zap.NewNop(), WithPaymentProvider(provider))

		userID := uuid.New()
		sub, _ := seedPending(t, db, userID, "pay_pspfail")

		_, err := svc.CompletePendingPayment(ctx, userID, sub.ID)
		require.Error(t, err)
		assert.Contains(t, err.Error(), "PSP 503", "underlying PSP error must surface to ops via wrapped message")
	})
}