build: persistence layer tests

internal/models/models_test.go

···
+package models
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+)
+
+func TestModels(t *testing.T) {
+	t.Run("Task Model", func(t *testing.T) {
+		t.Run("Model Interface Implementation", func(t *testing.T) {
+			task := &Task{
+				ID:          1,
+				UUID:        "test-uuid",
+				Description: "Test task",
+				Status:      "pending",
+				Entry:       time.Now(),
+				Modified:    time.Now(),
+			}
+
+			if task.GetID() != 1 {
+				t.Errorf("Expected ID 1, got %d", task.GetID())
+			}
+
+			task.SetID(2)
+			if task.GetID() != 2 {
+				t.Errorf("Expected ID 2 after SetID, got %d", task.GetID())
+			}
+
+			if task.GetTableName() != "tasks" {
+				t.Errorf("Expected table name 'tasks', got '%s'", task.GetTableName())
+			}
+
+			createdAt := time.Now()
+			task.SetCreatedAt(createdAt)
+			if !task.GetCreatedAt().Equal(createdAt) {
+				t.Errorf("Expected created at %v, got %v", createdAt, task.GetCreatedAt())
+			}
+
+			updatedAt := time.Now().Add(time.Hour)
+			task.SetUpdatedAt(updatedAt)
+			if !task.GetUpdatedAt().Equal(updatedAt) {
+				t.Errorf("Expected updated at %v, got %v", updatedAt, task.GetUpdatedAt())
+			}
+		})
+
+		t.Run("Status Methods", func(t *testing.T) {
+			testCases := []struct {
+				status      string
+				isCompleted bool
+				isPending   bool
+				isDeleted   bool
+			}{
+				{"pending", false, true, false},
+				{"completed", true, false, false},
+				{"deleted", false, false, true},
+				{"unknown", false, false, false},
+			}
+
+			for _, tc := range testCases {
+				task := &Task{Status: tc.status}
+
+				if task.IsCompleted() != tc.isCompleted {
+					t.Errorf("Status %s: expected IsCompleted %v, got %v", tc.status, tc.isCompleted, task.IsCompleted())
+				}
+				if task.IsPending() != tc.isPending {
+					t.Errorf("Status %s: expected IsPending %v, got %v", tc.status, tc.isPending, task.IsPending())
+				}
+				if task.IsDeleted() != tc.isDeleted {
+					t.Errorf("Status %s: expected IsDeleted %v, got %v", tc.status, tc.isDeleted, task.IsDeleted())
+				}
+			}
+		})
+
+		t.Run("Priority Methods", func(t *testing.T) {
+			task := &Task{}
+
+			if task.HasPriority() {
+				t.Error("Task with empty priority should return false for HasPriority")
+			}
+
+			task.Priority = "A"
+			if !task.HasPriority() {
+				t.Error("Task with priority should return true for HasPriority")
+			}
+		})
+
+		t.Run("Tags Marshaling", func(t *testing.T) {
+			task := &Task{}
+
+			result, err := task.MarshalTags()
+			if err != nil {
+				t.Fatalf("MarshalTags failed: %v", err)
+			}
+			if result != "" {
+				t.Errorf("Expected empty string for empty tags, got '%s'", result)
+			}
+
+			task.Tags = []string{"work", "urgent", "project-x"}
+			result, err = task.MarshalTags()
+			if err != nil {
+				t.Fatalf("MarshalTags failed: %v", err)
+			}
+
+			expected := `["work","urgent","project-x"]`
+			if result != expected {
+				t.Errorf("Expected %s, got %s", expected, result)
+			}
+
+			newTask := &Task{}
+			err = newTask.UnmarshalTags(result)
+			if err != nil {
+				t.Fatalf("UnmarshalTags failed: %v", err)
+			}
+
+			if len(newTask.Tags) != 3 {
+				t.Errorf("Expected 3 tags, got %d", len(newTask.Tags))
+			}
+			if newTask.Tags[0] != "work" || newTask.Tags[1] != "urgent" || newTask.Tags[2] != "project-x" {
+				t.Errorf("Tags not unmarshaled correctly: %v", newTask.Tags)
+			}
+
+			emptyTask := &Task{}
+			err = emptyTask.UnmarshalTags("")
+			if err != nil {
+				t.Fatalf("UnmarshalTags with empty string failed: %v", err)
+			}
+			if emptyTask.Tags != nil {
+				t.Error("Expected nil tags for empty string")
+			}
+		})
+
+		t.Run("Annotations Marshaling", func(t *testing.T) {
+			task := &Task{}
+
+			result, err := task.MarshalAnnotations()
+			if err != nil {
+				t.Fatalf("MarshalAnnotations failed: %v", err)
+			}
+			if result != "" {
+				t.Errorf("Expected empty string for empty annotations, got '%s'", result)
+			}
+
+			task.Annotations = []string{"Note 1", "Note 2", "Important reminder"}
+			result, err = task.MarshalAnnotations()
+			if err != nil {
+				t.Fatalf("MarshalAnnotations failed: %v", err)
+			}
+
+			expected := `["Note 1","Note 2","Important reminder"]`
+			if result != expected {
+				t.Errorf("Expected %s, got %s", expected, result)
+			}
+
+			newTask := &Task{}
+			err = newTask.UnmarshalAnnotations(result)
+			if err != nil {
+				t.Fatalf("UnmarshalAnnotations failed: %v", err)
+			}
+
+			if len(newTask.Annotations) != 3 {
+				t.Errorf("Expected 3 annotations, got %d", len(newTask.Annotations))
+			}
+			if newTask.Annotations[0] != "Note 1" || newTask.Annotations[1] != "Note 2" || newTask.Annotations[2] != "Important reminder" {
+				t.Errorf("Annotations not unmarshaled correctly: %v", newTask.Annotations)
+			}
+
+			emptyTask := &Task{}
+			err = emptyTask.UnmarshalAnnotations("")
+			if err != nil {
+				t.Fatalf("UnmarshalAnnotations with empty string failed: %v", err)
+			}
+			if emptyTask.Annotations != nil {
+				t.Error("Expected nil annotations for empty string")
+			}
+		})
+
+		t.Run("JSON Marshaling", func(t *testing.T) {
+			now := time.Now()
+			due := now.Add(24 * time.Hour)
+			task := &Task{
+				ID:          1,
+				UUID:        "test-uuid",
+				Description: "Test task",
+				Status:      "pending",
+				Priority:    "A",
+				Project:     "test-project",
+				Tags:        []string{"work", "urgent"},
+				Due:         &due,
+				Entry:       now,
+				Modified:    now,
+				Annotations: []string{"Note 1"},
+			}
+
+			data, err := json.Marshal(task)
+			if err != nil {
+				t.Fatalf("JSON marshal failed: %v", err)
+			}
+
+			var unmarshaled Task
+			err = json.Unmarshal(data, &unmarshaled)
+			if err != nil {
+				t.Fatalf("JSON unmarshal failed: %v", err)
+			}
+
+			if unmarshaled.ID != task.ID {
+				t.Errorf("Expected ID %d, got %d", task.ID, unmarshaled.ID)
+			}
+			if unmarshaled.UUID != task.UUID {
+				t.Errorf("Expected UUID %s, got %s", task.UUID, unmarshaled.UUID)
+			}
+			if unmarshaled.Description != task.Description {
+				t.Errorf("Expected description %s, got %s", task.Description, unmarshaled.Description)
+			}
+		})
+	})
+
+	t.Run("Movie Model", func(t *testing.T) {
+		t.Run("Model Interface Implementation", func(t *testing.T) {
+			movie := &Movie{
+				ID:    1,
+				Title: "Test Movie",
+				Year:  2023,
+				Added: time.Now(),
+			}
+
+			if movie.GetID() != 1 {
+				t.Errorf("Expected ID 1, got %d", movie.GetID())
+			}
+
+			movie.SetID(2)
+			if movie.GetID() != 2 {
+				t.Errorf("Expected ID 2 after SetID, got %d", movie.GetID())
+			}
+
+			if movie.GetTableName() != "movies" {
+				t.Errorf("Expected table name 'movies', got '%s'", movie.GetTableName())
+			}
+
+			createdAt := time.Now()
+			movie.SetCreatedAt(createdAt)
+			if !movie.GetCreatedAt().Equal(createdAt) {
+				t.Errorf("Expected created at %v, got %v", createdAt, movie.GetCreatedAt())
+			}
+
+			updatedAt := time.Now().Add(time.Hour)
+			movie.SetUpdatedAt(updatedAt)
+			if !movie.GetUpdatedAt().Equal(updatedAt) {
+				t.Errorf("Expected updated at %v, got %v", updatedAt, movie.GetUpdatedAt())
+			}
+		})
+
+		t.Run("Status Methods", func(t *testing.T) {
+			testCases := []struct {
+				status    string
+				isWatched bool
+				isQueued  bool
+			}{
+				{"queued", false, true},
+				{"watched", true, false},
+				{"removed", false, false},
+				{"unknown", false, false},
+			}
+
+			for _, tc := range testCases {
+				movie := &Movie{Status: tc.status}
+
+				if movie.IsWatched() != tc.isWatched {
+					t.Errorf("Status %s: expected IsWatched %v, got %v", tc.status, tc.isWatched, movie.IsWatched())
+				}
+				if movie.IsQueued() != tc.isQueued {
+					t.Errorf("Status %s: expected IsQueued %v, got %v", tc.status, tc.isQueued, movie.IsQueued())
+				}
+			}
+		})
+
+		t.Run("JSON Marshaling", func(t *testing.T) {
+			now := time.Now()
+			watched := now.Add(-24 * time.Hour)
+			movie := &Movie{
+				ID:      1,
+				Title:   "Test Movie",
+				Year:    2023,
+				Status:  "watched",
+				Rating:  8.5,
+				Notes:   "Great movie!",
+				Added:   now,
+				Watched: &watched,
+			}
+
+			data, err := json.Marshal(movie)
+			if err != nil {
+				t.Fatalf("JSON marshal failed: %v", err)
+			}
+
+			var unmarshaled Movie
+			err = json.Unmarshal(data, &unmarshaled)
+			if err != nil {
+				t.Fatalf("JSON unmarshal failed: %v", err)
+			}
+
+			if unmarshaled.ID != movie.ID {
+				t.Errorf("Expected ID %d, got %d", movie.ID, unmarshaled.ID)
+			}
+			if unmarshaled.Title != movie.Title {
+				t.Errorf("Expected title %s, got %s", movie.Title, unmarshaled.Title)
+			}
+			if unmarshaled.Rating != movie.Rating {
+				t.Errorf("Expected rating %f, got %f", movie.Rating, unmarshaled.Rating)
+			}
+		})
+	})
+
+	t.Run("TV Show Model", func(t *testing.T) {
+		t.Run("Model Interface Implementation", func(t *testing.T) {
+			tvShow := &TVShow{
+				ID:    1,
+				Title: "Test Show",
+				Added: time.Now(),
+			}
+
+			if tvShow.GetID() != 1 {
+				t.Errorf("Expected ID 1, got %d", tvShow.GetID())
+			}
+
+			tvShow.SetID(2)
+			if tvShow.GetID() != 2 {
+				t.Errorf("Expected ID 2 after SetID, got %d", tvShow.GetID())
+			}
+
+			if tvShow.GetTableName() != "tv_shows" {
+				t.Errorf("Expected table name 'tv_shows', got '%s'", tvShow.GetTableName())
+			}
+
+			createdAt := time.Now()
+			tvShow.SetCreatedAt(createdAt)
+			if !tvShow.GetCreatedAt().Equal(createdAt) {
+				t.Errorf("Expected created at %v, got %v", createdAt, tvShow.GetCreatedAt())
+			}
+
+			updatedAt := time.Now().Add(time.Hour)
+			tvShow.SetUpdatedAt(updatedAt)
+			if !tvShow.GetUpdatedAt().Equal(updatedAt) {
+				t.Errorf("Expected updated at %v, got %v", updatedAt, tvShow.GetUpdatedAt())
+			}
+		})
+
+		t.Run("Status Methods", func(t *testing.T) {
+			testCases := []struct {
+				status     string
+				isWatching bool
+				isWatched  bool
+				isQueued   bool
+			}{
+				{"queued", false, false, true},
+				{"watching", true, false, false},
+				{"watched", false, true, false},
+				{"removed", false, false, false},
+				{"unknown", false, false, false},
+			}
+
+			for _, tc := range testCases {
+				tvShow := &TVShow{Status: tc.status}
+
+				if tvShow.IsWatching() != tc.isWatching {
+					t.Errorf("Status %s: expected IsWatching %v, got %v", tc.status, tc.isWatching, tvShow.IsWatching())
+				}
+				if tvShow.IsWatched() != tc.isWatched {
+					t.Errorf("Status %s: expected IsWatched %v, got %v", tc.status, tc.isWatched, tvShow.IsWatched())
+				}
+				if tvShow.IsQueued() != tc.isQueued {
+					t.Errorf("Status %s: expected IsQueued %v, got %v", tc.status, tc.isQueued, tvShow.IsQueued())
+				}
+			}
+		})
+
+		t.Run("JSON Marshaling", func(t *testing.T) {
+			now := time.Now()
+			lastWatched := now.Add(-24 * time.Hour)
+			tvShow := &TVShow{
+				ID:          1,
+				Title:       "Test Show",
+				Season:      1,
+				Episode:     5,
+				Status:      "watching",
+				Rating:      9.0,
+				Notes:       "Amazing series!",
+				Added:       now,
+				LastWatched: &lastWatched,
+			}
+
+			data, err := json.Marshal(tvShow)
+			if err != nil {
+				t.Fatalf("JSON marshal failed: %v", err)
+			}
+
+			var unmarshaled TVShow
+			err = json.Unmarshal(data, &unmarshaled)
+			if err != nil {
+				t.Fatalf("JSON unmarshal failed: %v", err)
+			}
+
+			if unmarshaled.ID != tvShow.ID {
+				t.Errorf("Expected ID %d, got %d", tvShow.ID, unmarshaled.ID)
+			}
+			if unmarshaled.Title != tvShow.Title {
+				t.Errorf("Expected title %s, got %s", tvShow.Title, unmarshaled.Title)
+			}
+			if unmarshaled.Season != tvShow.Season {
+				t.Errorf("Expected season %d, got %d", tvShow.Season, unmarshaled.Season)
+			}
+			if unmarshaled.Episode != tvShow.Episode {
+				t.Errorf("Expected episode %d, got %d", tvShow.Episode, unmarshaled.Episode)
+			}
+		})
+	})
+
+	t.Run("Book Model", func(t *testing.T) {
+		t.Run("Model Interface Implementation", func(t *testing.T) {
+			book := &Book{
+				ID:    1,
+				Title: "Test Book",
+				Added: time.Now(),
+			}
+
+			if book.GetID() != 1 {
+				t.Errorf("Expected ID 1, got %d", book.GetID())
+			}
+
+			book.SetID(2)
+			if book.GetID() != 2 {
+				t.Errorf("Expected ID 2 after SetID, got %d", book.GetID())
+			}
+
+			if book.GetTableName() != "books" {
+				t.Errorf("Expected table name 'books', got '%s'", book.GetTableName())
+			}
+
+			createdAt := time.Now()
+			book.SetCreatedAt(createdAt)
+			if !book.GetCreatedAt().Equal(createdAt) {
+				t.Errorf("Expected created at %v, got %v", createdAt, book.GetCreatedAt())
+			}
+
+			updatedAt := time.Now().Add(time.Hour)
+			book.SetUpdatedAt(updatedAt)
+			if !book.GetUpdatedAt().Equal(updatedAt) {
+				t.Errorf("Expected updated at %v, got %v", updatedAt, book.GetUpdatedAt())
+			}
+		})
+
+		t.Run("Status Methods", func(t *testing.T) {
+			testCases := []struct {
+				status     string
+				isReading  bool
+				isFinished bool
+				isQueued   bool
+			}{
+				{"queued", false, false, true},
+				{"reading", true, false, false},
+				{"finished", false, true, false},
+				{"removed", false, false, false},
+				{"unknown", false, false, false},
+			}
+
+			for _, tc := range testCases {
+				book := &Book{Status: tc.status}
+
+				if book.IsReading() != tc.isReading {
+					t.Errorf("Status %s: expected IsReading %v, got %v", tc.status, tc.isReading, book.IsReading())
+				}
+				if book.IsFinished() != tc.isFinished {
+					t.Errorf("Status %s: expected IsFinished %v, got %v", tc.status, tc.isFinished, book.IsFinished())
+				}
+				if book.IsQueued() != tc.isQueued {
+					t.Errorf("Status %s: expected IsQueued %v, got %v", tc.status, tc.isQueued, book.IsQueued())
+				}
+			}
+		})
+
+		t.Run("Progress Methods", func(t *testing.T) {
+			book := &Book{Progress: 75}
+
+			if book.ProgressPercent() != 75 {
+				t.Errorf("Expected progress 75%%, got %d%%", book.ProgressPercent())
+			}
+		})
+
+		t.Run("JSON Marshaling", func(t *testing.T) {
+			now := time.Now()
+			started := now.Add(-7 * 24 * time.Hour)
+			finished := now.Add(-24 * time.Hour)
+			book := &Book{
+				ID:       1,
+				Title:    "Test Book",
+				Author:   "Test Author",
+				Status:   "finished",
+				Progress: 100,
+				Pages:    300,
+				Rating:   4.5,
+				Notes:    "Excellent read!",
+				Added:    now,
+				Started:  &started,
+				Finished: &finished,
+			}
+
+			data, err := json.Marshal(book)
+			if err != nil {
+				t.Fatalf("JSON marshal failed: %v", err)
+			}
+
+			var unmarshaled Book
+			err = json.Unmarshal(data, &unmarshaled)
+			if err != nil {
+				t.Fatalf("JSON unmarshal failed: %v", err)
+			}
+
+			if unmarshaled.ID != book.ID {
+				t.Errorf("Expected ID %d, got %d", book.ID, unmarshaled.ID)
+			}
+			if unmarshaled.Title != book.Title {
+				t.Errorf("Expected title %s, got %s", book.Title, unmarshaled.Title)
+			}
+			if unmarshaled.Author != book.Author {
+				t.Errorf("Expected author %s, got %s", book.Author, unmarshaled.Author)
+			}
+			if unmarshaled.Progress != book.Progress {
+				t.Errorf("Expected progress %d, got %d", book.Progress, unmarshaled.Progress)
+			}
+			if unmarshaled.Pages != book.Pages {
+				t.Errorf("Expected pages %d, got %d", book.Pages, unmarshaled.Pages)
+			}
+		})
+	})
+
+	t.Run("Interface Implementations", func(t *testing.T) {
+		t.Run("All models implement Model interface", func(t *testing.T) {
+			var models []Model
+
+			task := &Task{}
+			movie := &Movie{}
+			tvShow := &TVShow{}
+			book := &Book{}
+
+			models = append(models, task, movie, tvShow, book)
+
+			if len(models) != 4 {
+				t.Errorf("Expected 4 models, got %d", len(models))
+			}
+
+			// Test that all models have the required methods
+			for i, model := range models {
+				// Test ID methods
+				model.SetID(int64(i + 1))
+				if model.GetID() != int64(i+1) {
+					t.Errorf("Model %d: ID not set correctly", i)
+				}
+
+				// Test table name method
+				tableName := model.GetTableName()
+				if tableName == "" {
+					t.Errorf("Model %d: table name should not be empty", i)
+				}
+
+				// Test timestamp methods
+				now := time.Now()
+				model.SetCreatedAt(now)
+				model.SetUpdatedAt(now)
+
+				// Note: We don't test exact equality due to potential precision differences
+				if model.GetCreatedAt().IsZero() {
+					t.Errorf("Model %d: created at should not be zero", i)
+				}
+				if model.GetUpdatedAt().IsZero() {
+					t.Errorf("Model %d: updated at should not be zero", i)
+				}
+			}
+		})
+	})
+
+	t.Run("Errors & Edge cases", func(t *testing.T) {
+		t.Run("Marshaling Errors", func(t *testing.T) {
+			t.Run("UnmarshalTags handles invalid JSON", func(t *testing.T) {
+				task := &Task{}
+				err := task.UnmarshalTags(`{"invalid": "json"}`)
+				if err == nil {
+					t.Error("Expected error for invalid JSON, got nil")
+				}
+			})
+
+			t.Run("UnmarshalAnnotations handles invalid JSON", func(t *testing.T) {
+				task := &Task{}
+				err := task.UnmarshalAnnotations(`{"invalid": "json"}`)
+				if err == nil {
+					t.Error("Expected error for invalid JSON, got nil")
+				}
+			})
+		})
+	})
+
+	t.Run("Edge Cases", func(t *testing.T) {
+		t.Run("Task with nil slices", func(t *testing.T) {
+			task := &Task{
+				Tags:        nil,
+				Annotations: nil,
+			}
+
+			tagsJSON, err := task.MarshalTags()
+			if err != nil {
+				t.Errorf("MarshalTags with nil slice failed: %v", err)
+			}
+			if tagsJSON != "" {
+				t.Errorf("Expected empty string for nil tags, got '%s'", tagsJSON)
+			}
+
+			annotationsJSON, err := task.MarshalAnnotations()
+			if err != nil {
+				t.Errorf("MarshalAnnotations with nil slice failed: %v", err)
+			}
+			if annotationsJSON != "" {
+				t.Errorf("Expected empty string for nil annotations, got '%s'", annotationsJSON)
+			}
+		})
+
+		t.Run("Models with zero values", func(t *testing.T) {
+			task := &Task{}
+			movie := &Movie{}
+			tvShow := &TVShow{}
+			book := &Book{}
+
+			// Test that zero values don't cause panics
+			if task.IsCompleted() || task.IsPending() || task.IsDeleted() {
+				t.Error("Zero value task should have false status methods")
+			}
+
+			if movie.IsWatched() || movie.IsQueued() {
+				t.Error("Zero value movie should have false status methods")
+			}
+
+			if tvShow.IsWatching() || tvShow.IsWatched() || tvShow.IsQueued() {
+				t.Error("Zero value TV show should have false status methods")
+			}
+
+			if book.IsReading() || book.IsFinished() || book.IsQueued() {
+				t.Error("Zero value book should have false status methods")
+			}
+
+			if book.ProgressPercent() != 0 {
+				t.Errorf("Zero value book should have 0%% progress, got %d%%", book.ProgressPercent())
+			}
+		})
+	})
+}

internal/store/config_test.go

···
+package store
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestDefaultConfig(t *testing.T) {
+	config := DefaultConfig()
+
+	if config == nil {
+		t.Fatal("DefaultConfig should not return nil")
+	}
+
+	expectedDefaults := map[string]interface{}{
+		"DateFormat":   "2006-01-02",
+		"ColorScheme":  "default",
+		"DefaultView":  "list",
+		"AutoArchive":  false,
+		"SyncEnabled":  false,
+		"ExportFormat": "json",
+	}
+
+	if config.DateFormat != expectedDefaults["DateFormat"] {
+		t.Errorf("Expected DateFormat %s, got %s", expectedDefaults["DateFormat"], config.DateFormat)
+	}
+	if config.ColorScheme != expectedDefaults["ColorScheme"] {
+		t.Errorf("Expected ColorScheme %s, got %s", expectedDefaults["ColorScheme"], config.ColorScheme)
+	}
+	if config.DefaultView != expectedDefaults["DefaultView"] {
+		t.Errorf("Expected DefaultView %s, got %s", expectedDefaults["DefaultView"], config.DefaultView)
+	}
+	if config.AutoArchive != expectedDefaults["AutoArchive"] {
+		t.Errorf("Expected AutoArchive %v, got %v", expectedDefaults["AutoArchive"], config.AutoArchive)
+	}
+	if config.SyncEnabled != expectedDefaults["SyncEnabled"] {
+		t.Errorf("Expected SyncEnabled %v, got %v", expectedDefaults["SyncEnabled"], config.SyncEnabled)
+	}
+	if config.ExportFormat != expectedDefaults["ExportFormat"] {
+		t.Errorf("Expected ExportFormat %s, got %s", expectedDefaults["ExportFormat"], config.ExportFormat)
+	}
+}
+
+func TestConfigOperations(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-config-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	originalGetConfigDir := GetConfigDir
+	GetConfigDir = func() (string, error) {
+		return tempDir, nil
+	}
+	defer func() { GetConfigDir = originalGetConfigDir }()
+
+	t.Run("SaveConfig creates config file", func(t *testing.T) {
+		config := DefaultConfig()
+		config.ColorScheme = "dark"
+		config.AutoArchive = true
+
+		err := SaveConfig(config)
+		if err != nil {
+			t.Fatalf("SaveConfig failed: %v", err)
+		}
+
+		configPath := filepath.Join(tempDir, ".noteleaf.conf.toml")
+		if _, err := os.Stat(configPath); os.IsNotExist(err) {
+			t.Error("Config file should exist after SaveConfig")
+		}
+	})
+
+	t.Run("LoadConfig reads existing config", func(t *testing.T) {
+		config, err := LoadConfig()
+		if err != nil {
+			t.Fatalf("LoadConfig failed: %v", err)
+		}
+
+		if config.ColorScheme != "dark" {
+			t.Errorf("Expected ColorScheme 'dark', got '%s'", config.ColorScheme)
+		}
+		if !config.AutoArchive {
+			t.Error("Expected AutoArchive to be true")
+		}
+	})
+
+	t.Run("LoadConfig creates default when file doesn't exist", func(t *testing.T) {
+		configPath := filepath.Join(tempDir, ".noteleaf.conf.toml")
+		os.Remove(configPath)
+
+		config, err := LoadConfig()
+		if err != nil {
+			t.Fatalf("LoadConfig failed: %v", err)
+		}
+
+		if config.ColorScheme != "default" {
+			t.Errorf("Expected default ColorScheme 'default', got '%s'", config.ColorScheme)
+		}
+		if config.AutoArchive {
+			t.Error("Expected AutoArchive to be false by default")
+		}
+
+		if _, err := os.Stat(configPath); os.IsNotExist(err) {
+			t.Error("Config file should be created when it doesn't exist")
+		}
+	})
+
+	t.Run("GetConfigPath returns correct path", func(t *testing.T) {
+		configPath, err := GetConfigPath()
+		if err != nil {
+			t.Fatalf("GetConfigPath failed: %v", err)
+		}
+
+		expectedPath := filepath.Join(tempDir, ".noteleaf.conf.toml")
+		if configPath != expectedPath {
+			t.Errorf("Expected config path %s, got %s", expectedPath, configPath)
+		}
+	})
+}
+
+func TestConfigPersistence(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-config-persist-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	originalGetConfigDir := GetConfigDir
+	GetConfigDir = func() (string, error) {
+		return tempDir, nil
+	}
+	defer func() { GetConfigDir = originalGetConfigDir }()
+
+	t.Run("config values persist across save/load cycles", func(t *testing.T) {
+		originalConfig := &Config{
+			DateFormat:      "01/02/2006",
+			ColorScheme:     "custom",
+			DefaultView:     "kanban",
+			DefaultPriority: "high",
+			AutoArchive:     true,
+			SyncEnabled:     true,
+			SyncEndpoint:    "https://api.example.com",
+			SyncToken:       "secret-token",
+			ExportFormat:    "csv",
+			MovieAPIKey:     "movie-key",
+			BookAPIKey:      "book-key",
+		}
+
+		err := SaveConfig(originalConfig)
+		if err != nil {
+			t.Fatalf("SaveConfig failed: %v", err)
+		}
+
+		loadedConfig, err := LoadConfig()
+		if err != nil {
+			t.Fatalf("LoadConfig failed: %v", err)
+		}
+
+		if loadedConfig.DateFormat != originalConfig.DateFormat {
+			t.Errorf("DateFormat not preserved: expected %s, got %s", originalConfig.DateFormat, loadedConfig.DateFormat)
+		}
+		if loadedConfig.ColorScheme != originalConfig.ColorScheme {
+			t.Errorf("ColorScheme not preserved: expected %s, got %s", originalConfig.ColorScheme, loadedConfig.ColorScheme)
+		}
+		if loadedConfig.DefaultView != originalConfig.DefaultView {
+			t.Errorf("DefaultView not preserved: expected %s, got %s", originalConfig.DefaultView, loadedConfig.DefaultView)
+		}
+		if loadedConfig.DefaultPriority != originalConfig.DefaultPriority {
+			t.Errorf("DefaultPriority not preserved: expected %s, got %s", originalConfig.DefaultPriority, loadedConfig.DefaultPriority)
+		}
+		if loadedConfig.AutoArchive != originalConfig.AutoArchive {
+			t.Errorf("AutoArchive not preserved: expected %v, got %v", originalConfig.AutoArchive, loadedConfig.AutoArchive)
+		}
+		if loadedConfig.SyncEnabled != originalConfig.SyncEnabled {
+			t.Errorf("SyncEnabled not preserved: expected %v, got %v", originalConfig.SyncEnabled, loadedConfig.SyncEnabled)
+		}
+		if loadedConfig.SyncEndpoint != originalConfig.SyncEndpoint {
+			t.Errorf("SyncEndpoint not preserved: expected %s, got %s", originalConfig.SyncEndpoint, loadedConfig.SyncEndpoint)
+		}
+		if loadedConfig.SyncToken != originalConfig.SyncToken {
+			t.Errorf("SyncToken not preserved: expected %s, got %s", originalConfig.SyncToken, loadedConfig.SyncToken)
+		}
+		if loadedConfig.ExportFormat != originalConfig.ExportFormat {
+			t.Errorf("ExportFormat not preserved: expected %s, got %s", originalConfig.ExportFormat, loadedConfig.ExportFormat)
+		}
+		if loadedConfig.MovieAPIKey != originalConfig.MovieAPIKey {
+			t.Errorf("MovieAPIKey not preserved: expected %s, got %s", originalConfig.MovieAPIKey, loadedConfig.MovieAPIKey)
+		}
+		if loadedConfig.BookAPIKey != originalConfig.BookAPIKey {
+			t.Errorf("BookAPIKey not preserved: expected %s, got %s", originalConfig.BookAPIKey, loadedConfig.BookAPIKey)
+		}
+	})
+}
+
+func TestConfigErrorHandling(t *testing.T) {
+	t.Run("LoadConfig handles invalid TOML", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "noteleaf-config-error-test-*")
+		if err != nil {
+			t.Fatalf("Failed to create temp directory: %v", err)
+		}
+		defer os.RemoveAll(tempDir)
+
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			return tempDir, nil
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		configPath := filepath.Join(tempDir, ".noteleaf.conf.toml")
+		invalidTOML := `[invalid toml content`
+		err = os.WriteFile(configPath, []byte(invalidTOML), 0644)
+		if err != nil {
+			t.Fatalf("Failed to write invalid TOML: %v", err)
+		}
+
+		_, err = LoadConfig()
+		if err == nil {
+			t.Error("LoadConfig should fail with invalid TOML")
+		}
+	})
+
+	t.Run("SaveConfig handles directory creation failure", func(t *testing.T) {
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			return "/invalid/path/that/cannot/be/created", nil
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		config := DefaultConfig()
+		err := SaveConfig(config)
+		if err == nil {
+			t.Error("SaveConfig should fail when config directory cannot be accessed")
+		}
+	})
+
+	t.Run("GetConfigPath handles GetConfigDir error", func(t *testing.T) {
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			return "", os.ErrPermission
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		_, err := GetConfigPath()
+		if err == nil {
+			t.Error("GetConfigPath should fail when GetConfigDir fails")
+		}
+	})
+}
+
+func TestGetConfigDir(t *testing.T) {
+	t.Run("returns correct directory based on OS", func(t *testing.T) {
+		configDir, err := GetConfigDir()
+		if err != nil {
+			t.Fatalf("GetConfigDir failed: %v", err)
+		}
+
+		if configDir == "" {
+			t.Error("Config directory should not be empty")
+		}
+
+		if _, err := os.Stat(configDir); os.IsNotExist(err) {
+			t.Error("Config directory should be created if it doesn't exist")
+		}
+
+		if filepath.Base(configDir) != "noteleaf" {
+			t.Errorf("Config directory should end with 'noteleaf', got: %s", configDir)
+		}
+	})
+
+	t.Run("creates directory if it doesn't exist", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "noteleaf-test-*")
+		if err != nil {
+			t.Fatalf("Failed to create temp directory: %v", err)
+		}
+		defer os.RemoveAll(tempDir)
+
+		var originalEnv string
+		var envVar string
+		switch runtime.GOOS {
+		case "windows":
+			envVar = "APPDATA"
+			originalEnv = os.Getenv("APPDATA")
+			os.Setenv("APPDATA", tempDir)
+		default:
+			envVar = "XDG_CONFIG_HOME"
+			originalEnv = os.Getenv("XDG_CONFIG_HOME")
+			os.Setenv("XDG_CONFIG_HOME", tempDir)
+		}
+		defer os.Setenv(envVar, originalEnv)
+
+		configDir, err := GetConfigDir()
+		if err != nil {
+			t.Fatalf("GetConfigDir failed: %v", err)
+		}
+
+		expectedPath := filepath.Join(tempDir, "noteleaf")
+		if configDir != expectedPath {
+			t.Errorf("Expected config dir %s, got %s", expectedPath, configDir)
+		}
+
+		if _, err := os.Stat(configDir); os.IsNotExist(err) {
+			t.Error("Config directory should be created")
+		}
+	})
+
+	t.Run("handles missing environment variables", func(t *testing.T) {
+		switch runtime.GOOS {
+		case "windows":
+			originalAppData := os.Getenv("APPDATA")
+			os.Unsetenv("APPDATA")
+			defer os.Setenv("APPDATA", originalAppData)
+
+			_, err := GetConfigDir()
+			if err == nil {
+				t.Error("GetConfigDir should fail when APPDATA is not set on Windows")
+			}
+		default:
+			originalXDG := os.Getenv("XDG_CONFIG_HOME")
+			originalHome := os.Getenv("HOME")
+			os.Unsetenv("XDG_CONFIG_HOME")
+
+			tempHome, err := os.MkdirTemp("", "noteleaf-home-test-*")
+			if err != nil {
+				t.Fatalf("Failed to create temp home: %v", err)
+			}
+			defer os.RemoveAll(tempHome)
+			os.Setenv("HOME", tempHome)
+
+			defer func() {
+				os.Setenv("XDG_CONFIG_HOME", originalXDG)
+				os.Setenv("HOME", originalHome)
+			}()
+
+			configDir, err := GetConfigDir()
+			if err != nil {
+				t.Fatalf("GetConfigDir should work with HOME fallback: %v", err)
+			}
+
+			expectedPath := filepath.Join(tempHome, ".config", "noteleaf")
+			if configDir != expectedPath {
+				t.Errorf("Expected config dir %s, got %s", expectedPath, configDir)
+			}
+		}
+	})
+}

internal/store/database.go

···
 }
 
 // GetConfigDir returns the appropriate configuration directory based on the OS
-func GetConfigDir() (string, error) {
+var GetConfigDir = func() (string, error) {
 	var configDir string
 
 	switch runtime.GOOS {

internal/store/database_test.go

···
+package store
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestNewDatabase(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-db-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	originalGetConfigDir := GetConfigDir
+	GetConfigDir = func() (string, error) {
+		return tempDir, nil
+	}
+	defer func() { GetConfigDir = originalGetConfigDir }()
+
+	t.Run("creates database successfully", func(t *testing.T) {
+		db, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("NewDatabase failed: %v", err)
+		}
+		defer db.Close()
+
+		if db == nil {
+			t.Fatal("Database should not be nil")
+		}
+
+		dbPath := filepath.Join(tempDir, "noteleaf.db")
+		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
+			t.Error("Database file should exist")
+		}
+
+		if db.GetPath() != dbPath {
+			t.Errorf("Expected database path %s, got %s", dbPath, db.GetPath())
+		}
+	})
+
+	t.Run("enables foreign keys", func(t *testing.T) {
+		db, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("NewDatabase failed: %v", err)
+		}
+		defer db.Close()
+
+		var foreignKeys int
+		err = db.QueryRow("PRAGMA foreign_keys").Scan(&foreignKeys)
+		if err != nil {
+			t.Fatalf("Failed to check foreign keys: %v", err)
+		}
+
+		if foreignKeys != 1 {
+			t.Error("Foreign keys should be enabled")
+		}
+	})
+
+	t.Run("enables WAL mode", func(t *testing.T) {
+		db, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("NewDatabase failed: %v", err)
+		}
+		defer db.Close()
+
+		var journalMode string
+		err = db.QueryRow("PRAGMA journal_mode").Scan(&journalMode)
+		if err != nil {
+			t.Fatalf("Failed to check journal mode: %v", err)
+		}
+
+		if journalMode != "wal" {
+			t.Errorf("Expected WAL journal mode, got %s", journalMode)
+		}
+	})
+
+	t.Run("runs migrations", func(t *testing.T) {
+		db, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("NewDatabase failed: %v", err)
+		}
+		defer db.Close()
+
+		var count int
+		err = db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='migrations'").Scan(&count)
+		if err != nil {
+			t.Fatalf("Failed to check migrations table: %v", err)
+		}
+
+		if count != 1 {
+			t.Error("Migrations table should exist")
+		}
+
+		var migrationCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&migrationCount)
+		if err != nil {
+			t.Fatalf("Failed to count migrations: %v", err)
+		}
+
+		if migrationCount == 0 {
+			t.Error("At least one migration should be applied")
+		}
+	})
+
+	t.Run("creates migration runner", func(t *testing.T) {
+		db, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("NewDatabase failed: %v", err)
+		}
+		defer db.Close()
+
+		runner := db.NewMigrationRunner()
+		if runner == nil {
+			t.Error("Migration runner should not be nil")
+		}
+	})
+
+	t.Run("closes database connection", func(t *testing.T) {
+		db, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("NewDatabase failed: %v", err)
+		}
+
+		err = db.Close()
+		if err != nil {
+			t.Errorf("Close should not return error: %v", err)
+		}
+
+		err = db.Ping()
+		if err == nil {
+			t.Error("Database should be closed and ping should fail")
+		}
+	})
+}
+
+func TestDatabaseErrorHandling(t *testing.T) {
+	t.Run("handles GetConfigDir error", func(t *testing.T) {
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			return "", os.ErrPermission
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		_, err := NewDatabase()
+		if err == nil {
+			t.Error("NewDatabase should fail when GetConfigDir fails")
+		}
+	})
+
+	t.Run("handles invalid database path", func(t *testing.T) {
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			return "/invalid/path/that/does/not/exist", nil
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		_, err := NewDatabase()
+		if err == nil {
+			t.Error("NewDatabase should fail with invalid database path")
+		}
+	})
+}
+
+func TestDatabaseIntegration(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-db-integration-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	originalGetConfigDir := GetConfigDir
+	GetConfigDir = func() (string, error) {
+		return tempDir, nil
+	}
+	defer func() { GetConfigDir = originalGetConfigDir }()
+
+	t.Run("multiple database instances use same file", func(t *testing.T) {
+		db1, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("First NewDatabase failed: %v", err)
+		}
+		defer db1.Close()
+
+		db2, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("Second NewDatabase failed: %v", err)
+		}
+		defer db2.Close()
+
+		if db1.GetPath() != db2.GetPath() {
+			t.Error("Both database instances should use the same file path")
+		}
+	})
+
+	t.Run("database survives connection close and reopen", func(t *testing.T) {
+		db1, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("NewDatabase failed: %v", err)
+		}
+
+		_, err = db1.Exec("CREATE TABLE IF NOT EXISTS test_table (id INTEGER PRIMARY KEY, name TEXT)")
+		if err != nil {
+			t.Fatalf("Failed to create test table: %v", err)
+		}
+
+		_, err = db1.Exec("INSERT INTO test_table (name) VALUES (?)", "test_value")
+		if err != nil {
+			t.Fatalf("Failed to insert test data: %v", err)
+		}
+
+		db1.Close()
+
+		db2, err := NewDatabase()
+		if err != nil {
+			t.Fatalf("Second NewDatabase failed: %v", err)
+		}
+		defer db2.Close()
+
+		var name string
+		err = db2.QueryRow("SELECT name FROM test_table WHERE id = 1").Scan(&name)
+		if err != nil {
+			t.Fatalf("Failed to query test data: %v", err)
+		}
+
+		if name != "test_value" {
+			t.Errorf("Expected 'test_value', got '%s'", name)
+		}
+	})
+}

internal/store/migration_test.go

···
+package store
+
+import (
+	"database/sql"
+	"embed"
+	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+//go:embed sql/migrations
+var testMigrationFiles embed.FS
+
+func createTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to create in-memory database: %v", err)
+	}
+
+	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
+		t.Fatalf("Failed to enable foreign keys: %v", err)
+	}
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	return db
+}
+
+func TestNewMigrationRunner(t *testing.T) {
+	db := createTestDB(t)
+
+	runner := NewMigrationRunner(db, testMigrationFiles)
+	if runner == nil {
+		t.Fatal("NewMigrationRunner should not return nil")
+	}
+
+	if runner.db != db {
+		t.Error("Migration runner should store the database reference")
+	}
+}
+
+func TestMigrationRunner_RunMigrations(t *testing.T) {
+	t.Run("runs migrations successfully", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		var count int
+		err = db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='migrations'").Scan(&count)
+		if err != nil {
+			t.Fatalf("Failed to check migrations table: %v", err)
+		}
+
+		if count != 1 {
+			t.Error("Migrations table should exist after running migrations")
+		}
+
+		var migrationCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&migrationCount)
+		if err != nil {
+			t.Fatalf("Failed to count applied migrations: %v", err)
+		}
+
+		if migrationCount == 0 {
+			t.Error("At least one migration should be applied")
+		}
+	})
+
+	t.Run("skips already applied migrations", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("First RunMigrations failed: %v", err)
+		}
+
+		var initialCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&initialCount)
+		if err != nil {
+			t.Fatalf("Failed to count migrations: %v", err)
+		}
+
+		err = runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("Second RunMigrations failed: %v", err)
+		}
+
+		var finalCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&finalCount)
+		if err != nil {
+			t.Fatalf("Failed to count migrations after second run: %v", err)
+		}
+
+		if finalCount != initialCount {
+			t.Errorf("Expected %d migrations, got %d (migrations should not be re-applied)", initialCount, finalCount)
+		}
+	})
+
+	t.Run("creates expected tables", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		expectedTables := []string{"migrations", "tasks", "movies", "tv_shows", "books"}
+
+		for _, tableName := range expectedTables {
+			var count int
+			err = db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?", tableName).Scan(&count)
+			if err != nil {
+				t.Fatalf("Failed to check table %s: %v", tableName, err)
+			}
+
+			if count != 1 {
+				t.Errorf("Table %s should exist after migrations", tableName)
+			}
+		}
+	})
+}
+
+func TestMigrationRunner_GetAppliedMigrations(t *testing.T) {
+	t.Run("returns empty list when no migrations table", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		migrations, err := runner.GetAppliedMigrations()
+		if err != nil {
+			t.Fatalf("GetAppliedMigrations failed: %v", err)
+		}
+
+		if len(migrations) != 0 {
+			t.Errorf("Expected 0 migrations, got %d", len(migrations))
+		}
+	})
+
+	t.Run("returns applied migrations", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		// Run migrations first
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		migrations, err := runner.GetAppliedMigrations()
+		if err != nil {
+			t.Fatalf("GetAppliedMigrations failed: %v", err)
+		}
+
+		if len(migrations) == 0 {
+			t.Error("Should have applied migrations")
+		}
+
+		for _, migration := range migrations {
+			if migration.Version == "" {
+				t.Error("Migration version should not be empty")
+			}
+			if !migration.Applied {
+				t.Error("Migration should be marked as applied")
+			}
+			if migration.AppliedAt == "" {
+				t.Error("Migration should have applied timestamp")
+			}
+		}
+
+		for i := 1; i < len(migrations); i++ {
+			if migrations[i-1].Version > migrations[i].Version {
+				t.Error("Migrations should be sorted by version")
+			}
+		}
+	})
+}
+
+func TestMigrationRunner_GetAvailableMigrations(t *testing.T) {
+	t.Run("returns available migrations from embedded files", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		migrations, err := runner.GetAvailableMigrations()
+		if err != nil {
+			t.Fatalf("GetAvailableMigrations failed: %v", err)
+		}
+
+		if len(migrations) == 0 {
+			t.Error("Should have available migrations")
+		}
+
+		for _, migration := range migrations {
+			if migration.Version == "" {
+				t.Error("Migration version should not be empty")
+			}
+			if migration.UpSQL == "" {
+				t.Error("Migration should have up SQL")
+			}
+			// Note: Down SQL might be empty for some migrations, so we don't check it
+		}
+
+		for i := 1; i < len(migrations); i++ {
+			if migrations[i-1].Version > migrations[i].Version {
+				t.Error("Migrations should be sorted by version")
+			}
+		}
+	})
+
+	t.Run("includes both up and down SQL when available", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		migrations, err := runner.GetAvailableMigrations()
+		if err != nil {
+			t.Fatalf("GetAvailableMigrations failed: %v", err)
+		}
+
+		var foundMigrationWithDown bool
+		for _, migration := range migrations {
+			if migration.UpSQL != "" && migration.DownSQL != "" {
+				foundMigrationWithDown = true
+				break
+			}
+		}
+
+		if !foundMigrationWithDown {
+			t.Log("Note: No migrations found with both up and down SQL - this may be expected")
+		}
+	})
+}
+
+func TestMigrationRunner_Rollback(t *testing.T) {
+	t.Run("fails when no migrations to rollback", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.Rollback()
+		if err == nil {
+			t.Error("Rollback should fail when no migrations are applied")
+		}
+	})
+
+	t.Run("rolls back last migration", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		var initialCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&initialCount)
+		if err != nil {
+			t.Fatalf("Failed to count migrations: %v", err)
+		}
+
+		if initialCount == 0 {
+			t.Skip("No migrations to rollback")
+		}
+
+		err = runner.Rollback()
+		if err != nil {
+			t.Fatalf("Rollback failed: %v", err)
+		}
+
+		var finalCount int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&finalCount)
+		if err != nil {
+			t.Fatalf("Failed to count migrations after rollback: %v", err)
+		}
+
+		if finalCount != initialCount-1 {
+			t.Errorf("Expected %d migrations after rollback, got %d", initialCount-1, finalCount)
+		}
+	})
+}
+
+func TestMigrationHelperFunctions(t *testing.T) {
+	t.Run("extractVersionFromFilename", func(t *testing.T) {
+		testCases := []struct {
+			filename string
+			expected string
+		}{
+			{"0000_create_migrations_table_up.sql", "0000"},
+			{"0001_create_all_tables_up.sql", "0001"},
+			{"0002_add_indexes_down.sql", "0002"},
+			{"invalid_filename.sql", "invalid"},
+			{"", ""},
+		}
+
+		for _, tc := range testCases {
+			result := extractVersionFromFilename(tc.filename)
+			if result != tc.expected {
+				t.Errorf("extractVersionFromFilename(%s): expected %s, got %s", tc.filename, tc.expected, result)
+			}
+		}
+	})
+
+	t.Run("extractNameFromFilename", func(t *testing.T) {
+		testCases := []struct {
+			filename string
+			expected string
+		}{
+			{"0000_create_migrations_table_up.sql", "create_migrations_table"},
+			{"0001_create_all_tables_up.sql", "create_all_tables"},
+			{"0002_add_indexes_down.sql", "add_indexes"},
+			{"invalid_filename.sql", ""},
+			{"0003_up.sql", ""},
+			{"", ""},
+		}
+
+		for _, tc := range testCases {
+			result := extractNameFromFilename(tc.filename)
+			if result != tc.expected {
+				t.Errorf("extractNameFromFilename(%s): expected %s, got %s", tc.filename, tc.expected, result)
+			}
+		}
+	})
+}
+
+func TestMigrationIntegration(t *testing.T) {
+	t.Run("full migration lifecycle", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		available, err := runner.GetAvailableMigrations()
+		if err != nil {
+			t.Fatalf("GetAvailableMigrations failed: %v", err)
+		}
+
+		if len(available) == 0 {
+			t.Skip("No migrations available for testing")
+		}
+
+		err = runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		applied, err := runner.GetAppliedMigrations()
+		if err != nil {
+			t.Fatalf("GetAppliedMigrations failed: %v", err)
+		}
+
+		if len(applied) == 0 {
+			t.Error("No migrations were applied")
+		}
+
+		tables := []string{"tasks", "movies", "tv_shows", "books"}
+		for _, table := range tables {
+			var count int
+			err = db.QueryRow("SELECT COUNT(*) FROM " + table).Scan(&count)
+			if err != nil {
+				t.Errorf("Failed to query table %s: %v", table, err)
+			}
+		}
+
+		if len(applied) > 1 { // Only test rollback if we have more than one migration
+			err = runner.Rollback()
+			if err != nil {
+				t.Logf("Rollback failed (may be expected): %v", err)
+			}
+		}
+	})
+
+	t.Run("migration runner works with real database", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, migrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations with real files failed: %v", err)
+		}
+
+		var count int
+		err = db.QueryRow("SELECT COUNT(*) FROM migrations").Scan(&count)
+		if err != nil {
+			t.Fatalf("Failed to count real migrations: %v", err)
+		}
+
+		if count == 0 {
+			t.Error("Real migrations should be applied")
+		}
+	})
+}