gochat/internal/repository/direct_upload_repo_test.go

package repository

import (
	"context"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"

	"github.com/gochat/gochat/internal/model"
)

func setupDirectUploadRepoTest(t *testing.T) (*gorm.DB, *DirectUploadRepo) {
	t.Helper()

	db, err := gorm.Open(sqlite.Open("file::memory:"), &gorm.Config{
		Logger: logger.Default.LogMode(logger.Silent),
	})
	require.NoError(t, err, "failed to open test DB")

	require.NoError(t, db.AutoMigrate(&model.DirectUpload{}), "failed to auto-migrate DirectUpload")

	t.Cleanup(func() {
		sqlDB, _ := db.DB()
		sqlDB.Close()
	})

	repo := NewDirectUploadRepo(db)
	return db, repo
}

func makeDirectUpload(accountID uint, source model.DirectUploadSource, uuid string) *model.DirectUpload {
	return &model.DirectUpload{
		UploadUUID:  uuid,
		AccountID:   accountID,
		Status:      model.DirectUploadStatusPending,
		Source:      source,
		OriginalName: "test.png",
		FileType:    "image",
		MimeType:    "image/png",
		FileSize:    1024,
		FileURL:     "/uploads/test.png",
		ExpiresAt:   time.Now().Add(24 * time.Hour),
	}
}

func TestDirectUploadRepo_Create(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	upload := makeDirectUpload(1, model.DirectUploadSourceAccount, "uuid-create-1")
	err := repo.Create(ctx, upload)
	require.NoError(t, err)
	assert.NotZero(t, upload.ID)
	assert.Equal(t, "uuid-create-1", upload.UploadUUID)
}

func TestDirectUploadRepo_FindByID(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	upload := makeDirectUpload(1, model.DirectUploadSourceAccount, "uuid-find-1")
	require.NoError(t, repo.Create(ctx, upload))

	found, err := repo.FindByID(ctx, upload.ID)
	require.NoError(t, err)
	assert.Equal(t, upload.UploadUUID, found.UploadUUID)
	assert.Equal(t, upload.AccountID, found.AccountID)
}

func TestDirectUploadRepo_FindByUUID(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	upload := makeDirectUpload(1, model.DirectUploadSourceAccount, "uuid-lookup-1")
	require.NoError(t, repo.Create(ctx, upload))

	found, err := repo.FindByUUID(ctx, "uuid-lookup-1")
	require.NoError(t, err)
	assert.Equal(t, upload.ID, found.ID)
	assert.Equal(t, "uuid-lookup-1", found.UploadUUID)
}

func TestDirectUploadRepo_FindByAccountAndID(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	upload := makeDirectUpload(5, model.DirectUploadSourceAccount, "uuid-acct-1")
	require.NoError(t, repo.Create(ctx, upload))

	found, err := repo.FindByAccountAndID(ctx, 5, upload.ID)
	require.NoError(t, err)
	assert.Equal(t, upload.UploadUUID, found.UploadUUID)

	// Wrong account should not find it
	_, err = repo.FindByAccountAndID(ctx, 999, upload.ID)
	assert.Error(t, err)
}

func TestDirectUploadRepo_Update(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	upload := makeDirectUpload(1, model.DirectUploadSourceAccount, "uuid-update-1")
	require.NoError(t, repo.Create(ctx, upload))

	upload.Status = model.DirectUploadStatusCompleted
	require.NoError(t, repo.Update(ctx, upload))

	found, err := repo.FindByID(ctx, upload.ID)
	require.NoError(t, err)
	assert.Equal(t, model.DirectUploadStatusCompleted, found.Status)
}



func TestDirectUploadRepo_UpdateStatus_Expired(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	upload := makeDirectUpload(1, model.DirectUploadSourceWidget, "uuid-expired-1")
	require.NoError(t, repo.Create(ctx, upload))

	require.NoError(t, repo.UpdateStatus(ctx, upload.ID, model.DirectUploadStatusExpired))

	found, err := repo.FindByID(ctx, upload.ID)
	require.NoError(t, err)
	assert.Equal(t, model.DirectUploadStatusExpired, found.Status)
}

func TestDirectUploadRepo_UpdateStatus_Completed(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	upload := makeDirectUpload(1, model.DirectUploadSourceWidget, "uuid-completed-1")
	require.NoError(t, repo.Create(ctx, upload))

	require.NoError(t, repo.UpdateStatus(ctx, upload.ID, model.DirectUploadStatusCompleted))

	found, err := repo.FindByID(ctx, upload.ID)
	require.NoError(t, err)
	assert.Equal(t, model.DirectUploadStatusCompleted, found.Status)
}

func TestDirectUploadRepo_BatchDeleteExpired(t *testing.T) {
	_, repo := setupDirectUploadRepoTest(t)
	ctx := context.Background()

	// Create expired upload: pending status with past expires_at
	// BatchDeleteExpired deletes pending uploads where expires_at < now
	expired := makeDirectUpload(1, model.DirectUploadSourceAccount, "uuid-batch-expired")
	expired.Status = model.DirectUploadStatusPending
	expired.ExpiresAt = time.Now().Add(-1 * time.Hour)
	require.NoError(t, repo.Create(ctx, expired))

	// Create active upload (not expired)
	active := makeDirectUpload(1, model.DirectUploadSourceAccount, "uuid-batch-active")
	active.ExpiresAt = time.Now().Add(24 * time.Hour)
	require.NoError(t, repo.Create(ctx, active))

	count, err := repo.BatchDeleteExpired(ctx, time.Now())
	require.NoError(t, err)
	assert.Equal(t, int64(1), count, "should delete 1 expired upload")

	// Active upload should still exist
	found, err := repo.FindByUUID(ctx, "uuid-batch-active")
	require.NoError(t, err)
	assert.Equal(t, model.DirectUploadStatusPending, found.Status)
}