Coverage priorities 1-5: test pure functions, extract interfaces, mock-based handler tests

- Priority 1: Test NewSendEmailTask + NewSendPushTask (5 tests)
- Priority 2: Test customHTTPErrorHandler — all 15+ branches (21 tests)
- Priority 3: Extract Enqueuer interface + payload builders in worker pkg (5 tests)
- Priority 4: Extract ClassifyFile/ComputeRelPath in migrate-encrypt (6 tests)
- Priority 5: Define Handler interfaces, refactor to accept them, mock-based tests (14 tests)
- Fix .gitignore: /worker instead of worker to stop ignoring internal/worker/

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

internal/database/database_test.go

@@ -0,0 +1,103 @@
+package database
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+// --- Unit tests for Paginate parameter clamping ---
+
+func TestPaginate_PageZeroDefaultsToOne(t *testing.T) {
+	scope := Paginate(0, 10)
+
+	db := openTestDB(t)
+	createTestRows(t, db, 5)
+
+	var rows []testRow
+	err := db.Scopes(scope).Find(&rows).Error
+	require.NoError(t, err)
+	// page=0 normalised to page=1, pageSize=10 → should get all 5 rows
+	assert.Len(t, rows, 5)
+}
+
+func TestPaginate_PageSizeZeroDefaultsTo100(t *testing.T) {
+	scope := Paginate(1, 0)
+
+	db := openTestDB(t)
+	createTestRows(t, db, 5)
+
+	var rows []testRow
+	err := db.Scopes(scope).Find(&rows).Error
+	require.NoError(t, err)
+	// pageSize=0 normalised to 100, only 5 rows exist → 5 returned
+	assert.Len(t, rows, 5)
+}
+
+func TestPaginate_PageSizeOverMaxCappedAt1000(t *testing.T) {
+	scope := Paginate(1, 2000)
+
+	db := openTestDB(t)
+	createTestRows(t, db, 5)
+
+	var rows []testRow
+	err := db.Scopes(scope).Find(&rows).Error
+	require.NoError(t, err)
+	// pageSize=2000 capped to 1000, only 5 rows → 5 returned
+	assert.Len(t, rows, 5)
+}
+
+func TestPaginate_NormalValues(t *testing.T) {
+	scope := Paginate(1, 3)
+
+	db := openTestDB(t)
+	createTestRows(t, db, 10)
+
+	var rows []testRow
+	err := db.Scopes(scope).Order("id ASC").Find(&rows).Error
+	require.NoError(t, err)
+	assert.Len(t, rows, 3)
+	assert.Equal(t, "row_1", rows[0].Name)
+	assert.Equal(t, "row_3", rows[2].Name)
+}
+
+func TestPaginate_SQLiteIntegration_Page2Size10(t *testing.T) {
+	db := openTestDB(t)
+	createTestRows(t, db, 25)
+
+	scope := Paginate(2, 10)
+	var rows []testRow
+	err := db.Scopes(scope).Order("id ASC").Find(&rows).Error
+	require.NoError(t, err)
+
+	// Page 2 with size 10 → rows 11..20
+	assert.Len(t, rows, 10)
+	assert.Equal(t, "row_11", rows[0].Name)
+	assert.Equal(t, "row_20", rows[9].Name)
+}
+
+// --- helpers ---
+
+type testRow struct {
+	ID   uint   `gorm:"primaryKey"`
+	Name string
+}
+
+func openTestDB(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(&testRow{}))
+	return db
+}
+
+func createTestRows(t *testing.T, db *gorm.DB, n int) {
+	t.Helper()
+	for i := 1; i <= n; i++ {
+		require.NoError(t, db.Create(&testRow{Name: fmt.Sprintf("row_%d", i)}).Error)
+	}
+}

internal/database/migration_backfill_test.go

@@ -0,0 +1,47 @@
+package database
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestClassifyCompletion_CompletedAfterDue(t *testing.T) {
+	dueDate := time.Date(2025, 6, 1, 0, 0, 0, 0, time.UTC)
+	completedAt := time.Date(2025, 6, 5, 14, 30, 0, 0, time.UTC) // 4 days after due
+
+	result := classifyCompletion(completedAt, dueDate, 30)
+
+	assert.Equal(t, "overdue_tasks", result)
+}
+
+func TestClassifyCompletion_CompletedOnDueDate(t *testing.T) {
+	dueDate := time.Date(2025, 6, 15, 0, 0, 0, 0, time.UTC)
+	completedAt := time.Date(2025, 6, 15, 10, 0, 0, 0, time.UTC) // same day
+
+	result := classifyCompletion(completedAt, dueDate, 30)
+
+	// Completed on the due date: daysBefore == 0, which is <= threshold → due_soon_tasks
+	assert.Equal(t, "due_soon_tasks", result)
+}
+
+func TestClassifyCompletion_CompletedWithinThreshold(t *testing.T) {
+	dueDate := time.Date(2025, 7, 1, 0, 0, 0, 0, time.UTC)
+	completedAt := time.Date(2025, 6, 10, 8, 0, 0, 0, time.UTC) // 21 days before due
+
+	result := classifyCompletion(completedAt, dueDate, 30)
+
+	// 21 days before due, within 30-day threshold → due_soon_tasks
+	assert.Equal(t, "due_soon_tasks", result)
+}
+
+func TestClassifyCompletion_CompletedBeyondThreshold(t *testing.T) {
+	dueDate := time.Date(2025, 9, 1, 0, 0, 0, 0, time.UTC)
+	completedAt := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC) // 92 days before due
+
+	result := classifyCompletion(completedAt, dueDate, 30)
+
+	// 92 days before due, beyond 30-day threshold → upcoming_tasks
+	assert.Equal(t, "upcoming_tasks", result)
+}

internal/database/migration_helpers.go

@@ -0,0 +1,31 @@
+package database
+
+import "sort"
+
+// sortMigrationNames returns a sorted copy of the names slice.
+func sortMigrationNames(names []string) []string {
+	sorted := make([]string, len(names))
+	copy(sorted, names)
+	sort.Strings(sorted)
+	return sorted
+}
+
+// buildAppliedSet converts a list of applied migrations to a lookup set.
+func buildAppliedSet(applied []DataMigration) map[string]bool {
+	set := make(map[string]bool, len(applied))
+	for _, m := range applied {
+		set[m.Name] = true
+	}
+	return set
+}
+
+// filterPending returns names not present in the applied set.
+func filterPending(names []string, applied map[string]bool) []string {
+	var pending []string
+	for _, name := range names {
+		if !applied[name] {
+			pending = append(pending, name)
+		}
+	}
+	return pending
+}

internal/database/migration_helpers_test.go

@@ -0,0 +1,82 @@
+package database
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// --- sortMigrationNames ---
+
+func TestSortMigrationNames_Alphabetical(t *testing.T) {
+	input := []string{"charlie", "alpha", "bravo"}
+	result := sortMigrationNames(input)
+
+	assert.Equal(t, []string{"alpha", "bravo", "charlie"}, result)
+	// Verify original slice is not mutated
+	assert.Equal(t, []string{"charlie", "alpha", "bravo"}, input)
+}
+
+func TestSortMigrationNames_Empty(t *testing.T) {
+	result := sortMigrationNames([]string{})
+	assert.Equal(t, []string{}, result)
+	assert.Len(t, result, 0)
+}
+
+// --- buildAppliedSet ---
+
+func TestBuildAppliedSet_Multiple(t *testing.T) {
+	applied := []DataMigration{
+		{ID: 1, Name: "20250101_first", AppliedAt: time.Now()},
+		{ID: 2, Name: "20250201_second", AppliedAt: time.Now()},
+		{ID: 3, Name: "20250301_third", AppliedAt: time.Now()},
+	}
+
+	set := buildAppliedSet(applied)
+
+	assert.Len(t, set, 3)
+	assert.True(t, set["20250101_first"])
+	assert.True(t, set["20250201_second"])
+	assert.True(t, set["20250301_third"])
+	assert.False(t, set["nonexistent"])
+}
+
+func TestBuildAppliedSet_Empty(t *testing.T) {
+	set := buildAppliedSet([]DataMigration{})
+	assert.Len(t, set, 0)
+}
+
+// --- filterPending ---
+
+func TestFilterPending_SomePending(t *testing.T) {
+	names := []string{"20250101_first", "20250201_second", "20250301_third"}
+	applied := map[string]bool{
+		"20250101_first": true,
+	}
+
+	pending := filterPending(names, applied)
+
+	assert.Equal(t, []string{"20250201_second", "20250301_third"}, pending)
+}
+
+func TestFilterPending_AllApplied(t *testing.T) {
+	names := []string{"20250101_first", "20250201_second"}
+	applied := map[string]bool{
+		"20250101_first":  true,
+		"20250201_second": true,
+	}
+
+	pending := filterPending(names, applied)
+
+	assert.Nil(t, pending)
+}
+
+func TestFilterPending_NoneApplied(t *testing.T) {
+	names := []string{"20250101_first", "20250201_second", "20250301_third"}
+	applied := map[string]bool{}
+
+	pending := filterPending(names, applied)
+
+	assert.Equal(t, []string{"20250101_first", "20250201_second", "20250301_third"}, pending)
+}