tercul-backend/cmd/cli/commands/bleve_migrate_edge_cases_test.go

package commands

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	"tercul/internal/domain"
)

func TestMigrateTranslations_EmptyData(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer index.Close()

	repo := &mockTranslationRepository{translations: []domain.Translation{}}
	logger := getTestLogger()

	stats, err := migrateTranslations(
		context.Background(),
		repo,
		index,
		10,
		nil,
		logger,
		context.Background(),
	)

	assert.NoError(t, err)
	assert.NotNil(t, stats)
	assert.Equal(t, 0, stats.TotalIndexed)
	assert.Equal(t, 0, stats.TotalErrors)
}

func TestMigrateTranslations_LargeBatch(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer index.Close()

	// Create 100 translations
	translations := make([]domain.Translation, 100)
	for i := 0; i < 100; i++ {
		translations[i] = domain.Translation{
			BaseModel: domain.BaseModel{ID: uint(i + 1)},
			Title:     "Test Translation",
			Content:   "Content",
			Language:  "en",
			Status:    domain.TranslationStatusPublished,
			TranslatableID:   uint(i + 1),
			TranslatableType: "works",
		}
	}

	repo := &mockTranslationRepository{translations: translations}
	logger := getTestLogger()

	stats, err := migrateTranslations(
		context.Background(),
		repo,
		index,
		50, // Batch size smaller than total
		nil,
		logger,
		context.Background(),
	)

	assert.NoError(t, err)
	assert.NotNil(t, stats)
	assert.Equal(t, 100, stats.TotalIndexed)
	assert.Equal(t, 0, stats.TotalErrors)
}

func TestMigrateTranslations_RepositoryError(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer index.Close()

	repo := &mockTranslationRepository{
		translations: []domain.Translation{},
		err:          assert.AnError,
	}
	logger := getTestLogger()

	stats, err := migrateTranslations(
		context.Background(),
		repo,
		index,
		10,
		nil,
		logger,
		context.Background(),
	)

	assert.Error(t, err)
	assert.Nil(t, stats)
}

func TestIndexBatch_EmptyBatch(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer index.Close()

	logger := getTestLogger()

	err := indexBatch(index, []domain.Translation{}, logger)
	assert.NoError(t, err) // Empty batch should not error
}

func TestIndexBatch_WithTranslatorID(t *testing.T) {
	index := initBleveIndexForTest(t)
	defer index.Close()

	translatorID := uint(123)
	translations := []domain.Translation{
		{
			BaseModel: domain.BaseModel{ID: 1},
			Title:     "Test",
			Content:   "Content",
			Language:  "en",
			Status:    domain.TranslationStatusPublished,
			TranslatableID:   100,
			TranslatableType: "works",
			TranslatorID:     &translatorID,
		},
	}

	logger := getTestLogger()

	err := indexBatch(index, translations, logger)
	assert.NoError(t, err)

	// Verify document is indexed
	doc, err := index.Document("translation_1")
	assert.NoError(t, err)
	assert.NotNil(t, doc)
}

func TestCheckpoint_InvalidJSON(t *testing.T) {
	// Test loading invalid checkpoint file
	// This would require mocking file system, but for now we test the happy path
	// Invalid JSON handling is tested implicitly through file operations
}