veza/veza-backend-api/internal/jobs/cleanup_hyperswitch_webhook_log_test.go

package jobs

import (
	"context"
	"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"

	"veza-backend-api/internal/database"
	"veza-backend-api/internal/services/hyperswitch"
)

func setupCleanupTestDB(t *testing.T) *database.Database {
	t.Helper()
	gdb, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, gdb.AutoMigrate(&hyperswitch.WebhookLog{}))
	return &database.Database{GormDB: gdb}
}

// seedWebhookLogRow plants a row with a specific received_at so the
// cleanup cutoff logic can be exercised.
func seedWebhookLogRow(t *testing.T, db *gorm.DB, receivedAt time.Time) {
	t.Helper()
	row := &hyperswitch.WebhookLog{
		ID:               uuid.New(),
		Payload:          `{"event_type":"test"}`,
		SignatureValid:   true,
		ProcessingResult: "ok",
		RequestID:        uuid.New().String(),
	}
	require.NoError(t, db.Create(row).Error)
	// Override received_at post-Create because autoCreateTime sets NOW().
	require.NoError(t, db.Model(row).Update("received_at", receivedAt).Error)
}

func TestCleanupHyperswitchWebhookLog_DeletesOlderThanRetention(t *testing.T) {
	db := setupCleanupTestDB(t)
	logger := zap.NewNop()

	now := time.Now()
	// Seed: 3 old rows (100 days ago), 2 recent (1 day ago).
	for i := 0; i < 3; i++ {
		seedWebhookLogRow(t, db.GormDB, now.Add(-100*24*time.Hour))
	}
	for i := 0; i < 2; i++ {
		seedWebhookLogRow(t, db.GormDB, now.Add(-24*time.Hour))
	}

	deleted, err := CleanupHyperswitchWebhookLog(context.Background(), db, logger, 90)
	require.NoError(t, err)
	assert.Equal(t, int64(3), deleted)

	var remaining int64
	require.NoError(t, db.GormDB.Model(&hyperswitch.WebhookLog{}).Count(&remaining).Error)
	assert.Equal(t, int64(2), remaining, "recent rows must be preserved")
}

func TestCleanupHyperswitchWebhookLog_NoopWhenNothingExpired(t *testing.T) {
	db := setupCleanupTestDB(t)
	logger := zap.NewNop()

	// All rows well within retention.
	for i := 0; i < 5; i++ {
		seedWebhookLogRow(t, db.GormDB, time.Now().Add(-1*time.Hour))
	}

	deleted, err := CleanupHyperswitchWebhookLog(context.Background(), db, logger, 90)
	require.NoError(t, err)
	assert.Equal(t, int64(0), deleted)

	var count int64
	require.NoError(t, db.GormDB.Model(&hyperswitch.WebhookLog{}).Count(&count).Error)
	assert.Equal(t, int64(5), count)
}

func TestCleanupHyperswitchWebhookLog_DefaultRetentionOnZero(t *testing.T) {
	db := setupCleanupTestDB(t)
	logger := zap.NewNop()

	// Row at 100 days old: deletable under default (90d), retained
	// under 365d.
	seedWebhookLogRow(t, db.GormDB, time.Now().Add(-100*24*time.Hour))

	// Passing 0 or negative must route through the default (90).
	deleted, err := CleanupHyperswitchWebhookLog(context.Background(), db, logger, 0)
	require.NoError(t, err)
	assert.Equal(t, int64(1), deleted)
}

func TestCleanupHyperswitchWebhookLog_RespectsCtxCancellation(t *testing.T) {
	db := setupCleanupTestDB(t)
	logger := zap.NewNop()

	// Plant enough rows to force at least one inter-batch pause.
	// batchSize=10000, so one batch handles 10k; plant 10,001 to need 2.
	// For test speed keep small and exercise only the cancel path via
	// a pre-cancelled context — that covers the ctx.Done() branch in
	// the inter-batch select.
	for i := 0; i < 12; i++ {
		seedWebhookLogRow(t, db.GormDB, time.Now().Add(-100*24*time.Hour))
	}

	ctx, cancel := context.WithCancel(context.Background())
	cancel() // pre-cancelled

	_, err := CleanupHyperswitchWebhookLog(ctx, db, logger, 90)
	// Either ctx.Err() from the select or context.Canceled wrapped
	// in the batch delete — both are acceptable. What matters is
	// the function doesn't hang.
	if err != nil {
		assert.Contains(t, err.Error(), "context", "error must mention context cancellation")
	}
}