Scriberr/tests/database_test.go

package tests

import (
	"os"
	"testing"
	"time"

	"scriberr/internal/database"
	"scriberr/internal/models"
	"scriberr/internal/repository"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/suite"
)

type DatabaseTestSuite struct {
	suite.Suite
	helper *TestHelper
}

func (suite *DatabaseTestSuite) SetupSuite() {
	suite.helper = NewTestHelper(suite.T(), "database_test.db")
}

func (suite *DatabaseTestSuite) TearDownSuite() {
	suite.helper.Cleanup()
}

func (suite *DatabaseTestSuite) SetupTest() {
	suite.helper.ResetDB(suite.T())
}

func (suite *DatabaseTestSuite) TestDatabaseInitialization() {
	testDbPath := "test_init_isolated.db"
	defer os.Remove(testDbPath)

	originalDB := database.DB
	err := database.Initialize(testDbPath)
	assert.NoError(suite.T(), err)
	assert.NotNil(suite.T(), database.DB)

	_, err = os.Stat(testDbPath)
	assert.NoError(suite.T(), err)

	database.Close()
	database.DB = originalDB
}

func (suite *DatabaseTestSuite) TestUserSettingsRoundTrip() {
	db := suite.helper.GetDB()
	profileID := "profile-123"
	user := models.User{
		Username:                 "settings-user",
		Password:                 "hashedpassword123",
		DefaultProfileID:         &profileID,
		AutoTranscriptionEnabled: true,
		SummaryDefaultModel:      "gpt-4o-mini",
	}
	require.NoError(suite.T(), db.Create(&user).Error)

	var found models.User
	require.NoError(suite.T(), db.First(&found, user.ID).Error)
	assert.True(suite.T(), found.AutoTranscriptionEnabled)
	require.NotNil(suite.T(), found.DefaultProfileID)
	assert.Equal(suite.T(), profileID, *found.DefaultProfileID)
	assert.Equal(suite.T(), "gpt-4o-mini", found.SummaryDefaultModel)
}

func (suite *DatabaseTestSuite) TestTranscriptionJobPersistsPipelineMetadata() {
	db := suite.helper.GetDB()
	title := "Persisted Job"
	transcript := `{"text":"hello"}`
	summary := "cached summary"

	job := models.TranscriptionJob{
		ID:         "job-compat-1",
		UserID:     suite.helper.TestUser.ID,
		Title:      &title,
		Status:     models.StatusCompleted,
		AudioPath:  "/tmp/input.wav",
		Transcript: &transcript,
		Summary:    &summary,
		Parameters: models.ASRParams{
			Model:       "whisper-base",
			ModelFamily: "whisper",
			Pipeline: []models.ASRStep{
				{Kind: models.ASRStepTranscription, Model: "whisper-base"},
				{Kind: models.ASRStepDiarization, Model: "diarization-default"},
			},
		},
	}

	require.NoError(suite.T(), db.Create(&job).Error)

	var found models.TranscriptionJob
	require.NoError(suite.T(), db.First(&found, "id = ?", job.ID).Error)
	require.NotNil(suite.T(), found.Transcript)
	assert.Equal(suite.T(), transcript, *found.Transcript)
	require.NotNil(suite.T(), found.Summary)
	assert.Equal(suite.T(), summary, *found.Summary)
	assert.Equal(suite.T(), "whisper-base", found.Parameters.Model)
	assert.True(suite.T(), found.Diarization)
	require.Len(suite.T(), found.Parameters.Pipeline, 2)
	require.NotNil(suite.T(), found.CompletedAt)
}

func (suite *DatabaseTestSuite) TestAPIKeyRepositoryUsesHashedStorage() {
	db := suite.helper.GetDB()
	repo := repository.NewAPIKeyRepository(db)

	rawKey := "test-api-key-crud-12345"
	apiKey := models.APIKey{
		UserID:      suite.helper.TestUser.ID,
		Key:         rawKey,
		KeyPrefix:   rawKey[:8],
		KeyHash:     sha256Hex(rawKey),
		Name:        "Test CRUD API Key",
		Description: stringPtr("Test description"),
		IsActive:    true,
	}

	require.NoError(suite.T(), db.Create(&apiKey).Error)

	found, err := repo.FindByKey(suite.T().Context(), rawKey)
	require.NoError(suite.T(), err)
	assert.Equal(suite.T(), apiKey.Name, found.Name)
	assert.Equal(suite.T(), "Test description", *found.Description)
	assert.True(suite.T(), found.IsActive)

	require.NoError(suite.T(), repo.RevokeForUser(suite.T().Context(), apiKey.ID, suite.helper.TestUser.ID))

	var reloaded models.APIKey
	require.NoError(suite.T(), db.First(&reloaded, apiKey.ID).Error)
	assert.NotNil(suite.T(), reloaded.RevokedAt)
}

func (suite *DatabaseTestSuite) TestRefreshTokenRevocationSemantics() {
	db := suite.helper.GetDB()
	repo := repository.NewRefreshTokenRepository(db)

	token := &models.RefreshToken{
		UserID:    suite.helper.TestUser.ID,
		Hashed:    sha256Hex("refresh-token"),
		ExpiresAt: time.Now().Add(24 * time.Hour),
	}
	require.NoError(suite.T(), repo.Create(suite.T().Context(), token))

	found, err := repo.FindByHash(suite.T().Context(), token.Hashed)
	require.NoError(suite.T(), err)
	assert.False(suite.T(), found.Revoked)

	require.NoError(suite.T(), repo.Revoke(suite.T().Context(), token.ID))
	found, err = repo.FindByHash(suite.T().Context(), token.Hashed)
	require.NoError(suite.T(), err)
	assert.True(suite.T(), found.Revoked)
}

func (suite *DatabaseTestSuite) TestDatabaseConstraints() {
	db := suite.helper.GetDB()
	title := "Constraint job"
	job := models.TranscriptionJob{UserID: suite.helper.TestUser.ID, Title: &title, Status: models.StatusUploaded, AudioPath: "/tmp/audio.wav"}
	require.NoError(suite.T(), db.Create(&job).Error)

	mapping := models.SpeakerMapping{UserID: suite.helper.TestUser.ID, TranscriptionJobID: job.ID, OriginalSpeaker: "speaker_00", CustomName: "Alice"}
	require.NoError(suite.T(), db.Create(&mapping).Error)
	duplicate := models.SpeakerMapping{UserID: suite.helper.TestUser.ID, TranscriptionJobID: job.ID, OriginalSpeaker: "speaker_00", CustomName: "Bob"}
	assert.Error(suite.T(), db.Create(&duplicate).Error)
}

func (suite *DatabaseTestSuite) TestDatabaseClose() {
	assert.NotPanics(suite.T(), func() {
		_ = database.Close
	})
}

func TestDatabaseTestSuite(t *testing.T) {
	suite.Run(t, new(DatabaseTestSuite))
}