build: add error path tests for storage abstractions

internal/store/config_test.go

···
 		}
 	})
 
+	t.Run("LoadConfig handles file read permission error", func(t *testing.T) {
+		if runtime.GOOS == "windows" {
+			t.Skip("Permission test not reliable on Windows")
+		}
+
+		tempDir, err := os.MkdirTemp("", "noteleaf-config-perm-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")
+		validTOML := `color_scheme = "dark"`
+		err = os.WriteFile(configPath, []byte(validTOML), 0644)
+		if err != nil {
+			t.Fatalf("Failed to write config file: %v", err)
+		}
+
+		err = os.Chmod(configPath, 0000)
+		if err != nil {
+			t.Fatalf("Failed to change file permissions: %v", err)
+		}
+		defer os.Chmod(configPath, 0644)
+
+		_, err = LoadConfig()
+		if err == nil {
+			t.Error("LoadConfig should fail when config file is not readable")
+		}
+	})
+
+	t.Run("LoadConfig handles GetConfigDir error", func(t *testing.T) {
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			return "", os.ErrPermission
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		_, err := LoadConfig()
+		if err == nil {
+			t.Error("LoadConfig should fail when GetConfigDir fails")
+		}
+	})
+
+	t.Run("LoadConfig handles SaveConfig failure when creating default", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "noteleaf-config-save-fail-test-*")
+		if err != nil {
+			t.Fatalf("Failed to create temp directory: %v", err)
+		}
+		defer os.RemoveAll(tempDir)
+
+		_ = filepath.Join(tempDir, ".noteleaf.conf.toml")
+
+		callCount := 0
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			callCount++
+			if callCount == 1 {
+				return tempDir, nil
+			}
+			return "", os.ErrPermission
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		_, err = LoadConfig()
+		if err == nil {
+			t.Error("LoadConfig should fail when SaveConfig fails during default config creation")
+		}
+	})
+
 	t.Run("SaveConfig handles directory creation failure", func(t *testing.T) {
 		originalGetConfigDir := GetConfigDir
 		GetConfigDir = func() (string, error) {
···
 		}
 	})
 
+	t.Run("SaveConfig handles file write permission error", func(t *testing.T) {
+		if runtime.GOOS == "windows" {
+			t.Skip("Permission test not reliable on Windows")
+		}
+
+		tempDir, err := os.MkdirTemp("", "noteleaf-config-write-perm-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 }()
+
+		err = os.Chmod(tempDir, 0555)
+		if err != nil {
+			t.Fatalf("Failed to change directory permissions: %v", err)
+		}
+		defer os.Chmod(tempDir, 0755)
+
+		config := DefaultConfig()
+		err = SaveConfig(config)
+		if err == nil {
+			t.Error("SaveConfig should fail when directory is not writable")
+		}
+	})
+
 	t.Run("GetConfigPath handles GetConfigDir error", func(t *testing.T) {
 		originalGetConfigDir := GetConfigDir
 		GetConfigDir = func() (string, error) {
···
 			if configDir != expectedPath {
 				t.Errorf("Expected config dir %s, got %s", expectedPath, configDir)
 			}
+		}
+	})
+
+	t.Run("handles HOME directory lookup failure on Unix", func(t *testing.T) {
+		if runtime.GOOS == "windows" {
+			t.Skip("HOME directory test not applicable on Windows")
+		}
+
+		originalXDG := os.Getenv("XDG_CONFIG_HOME")
+		originalHome := os.Getenv("HOME")
+		os.Unsetenv("XDG_CONFIG_HOME")
+		os.Unsetenv("HOME")
+
+		defer func() {
+			os.Setenv("XDG_CONFIG_HOME", originalXDG)
+			os.Setenv("HOME", originalHome)
+		}()
+
+		_, err := GetConfigDir()
+		if err == nil {
+			t.Error("GetConfigDir should fail when both XDG_CONFIG_HOME and HOME are not available")
+		}
+	})
+
+	t.Run("handles directory creation permission failure", func(t *testing.T) {
+		if runtime.GOOS == "windows" {
+			t.Skip("Permission test not reliable on Windows")
+		}
+
+		tempParent, err := os.MkdirTemp("", "noteleaf-parent-test-*")
+		if err != nil {
+			t.Fatalf("Failed to create temp parent directory: %v", err)
+		}
+		defer os.RemoveAll(tempParent)
+
+		err = os.Chmod(tempParent, 0555)
+		if err != nil {
+			t.Fatalf("Failed to change parent directory permissions: %v", err)
+		}
+		defer os.Chmod(tempParent, 0755)
+
+		var originalEnv string
+		var envVar string
+		switch runtime.GOOS {
+		case "windows":
+			envVar = "APPDATA"
+			originalEnv = os.Getenv("APPDATA")
+			os.Setenv("APPDATA", tempParent)
+		default:
+			envVar = "XDG_CONFIG_HOME"
+			originalEnv = os.Getenv("XDG_CONFIG_HOME")
+			os.Setenv("XDG_CONFIG_HOME", tempParent)
+		}
+		defer os.Setenv(envVar, originalEnv)
+
+		_, err = GetConfigDir()
+		if err == nil {
+			t.Error("GetConfigDir should fail when directory creation is not permitted")
 		}
 	})
 }

internal/store/database_test.go

···
 import (
 	"os"
 	"path/filepath"
+	"runtime"
 	"testing"
 )
 
···
 		_, err := NewDatabase()
 		if err == nil {
 			t.Error("NewDatabase should fail with invalid database path")
+		}
+	})
+
+	t.Run("handles invalid database connection", func(t *testing.T) {
+		originalGetConfigDir := GetConfigDir
+		GetConfigDir = func() (string, error) {
+			return "/dev/null", nil
+		}
+		defer func() { GetConfigDir = originalGetConfigDir }()
+
+		_, err := NewDatabase()
+		if err == nil {
+			t.Error("NewDatabase should fail when database path is invalid")
+		}
+	})
+
+	t.Run("handles migration failure during database creation", func(t *testing.T) {
+		tempDir, err := os.MkdirTemp("", "noteleaf-db-migration-fail-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 }()
+
+		dbPath := filepath.Join(tempDir, "noteleaf.db")
+		
+		// Create a corrupted database file that will cause issues
+		corruptedSQL := "this is not valid SQL and will cause failures"
+		err = os.WriteFile(dbPath, []byte(corruptedSQL), 0644)
+		if err != nil {
+			t.Fatalf("Failed to create corrupted database file: %v", err)
+		}
+
+		_, err = NewDatabase()
+		if err == nil {
+			t.Error("NewDatabase should fail when database file is corrupted")
+		}
+	})
+
+	t.Run("handles database file permission error", func(t *testing.T) {
+		if runtime.GOOS == "windows" {
+			t.Skip("Permission test not reliable on Windows")
+		}
+
+		tempDir, err := os.MkdirTemp("", "noteleaf-db-perm-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 }()
+
+		err = os.Chmod(tempDir, 0555)
+		if err != nil {
+			t.Fatalf("Failed to change directory permissions: %v", err)
+		}
+		defer os.Chmod(tempDir, 0755)
+
+		_, err = NewDatabase()
+		if err == nil {
+			t.Error("NewDatabase should fail when database directory is not writable")
 		}
 	})
 }

internal/store/migration.go

···
 
 import (
 	"database/sql"
-	"embed"
 	"fmt"
+	"io/fs"
 	"sort"
 	"strings"
 )
···
 	AppliedAt string
 }
 
+// FileSystem interface for reading migration files
+type FileSystem interface {
+	ReadDir(name string) ([]fs.DirEntry, error)
+	ReadFile(name string) ([]byte, error)
+}
+
 // MigrationRunner handles database migrations
 type MigrationRunner struct {
 	db             *sql.DB
-	migrationFiles embed.FS
+	migrationFiles FileSystem
 }
 
 // NewMigrationRunner creates a new migration runner
-func NewMigrationRunner(db *sql.DB, files embed.FS) *MigrationRunner {
+func NewMigrationRunner(db *sql.DB, files FileSystem) *MigrationRunner {
 	return &MigrationRunner{
 		db:             db,
 		migrationFiles: files,

internal/store/migration_test.go

···
 import (
 	"database/sql"
 	"embed"
+	"fmt"
+	"io/fs"
 	"testing"
 
 	_ "github.com/mattn/go-sqlite3"
···
 //go:embed sql/migrations
 var testMigrationFiles embed.FS
 
+type fakeMigrationFS struct {
+	shouldFailRead   bool
+	invalidSQL       bool
+	hasNewMigrations bool
+}
+
+type fakeDirEntry struct {
+	name string
+}
+
+func (f fakeDirEntry) Name() string               { return f.name }
+func (f fakeDirEntry) IsDir() bool                { return false }
+func (f fakeDirEntry) Type() fs.FileMode          { return 0 }
+func (f fakeDirEntry) Info() (fs.FileInfo, error) { return nil, fmt.Errorf("info not available") }
+
+func (f *fakeMigrationFS) ReadDir(name string) ([]fs.DirEntry, error) {
+	if name == "sql/migrations" {
+		entries := []fs.DirEntry{
+			fakeDirEntry{name: "0000_create_migrations_table_up.sql"},
+		}
+		if f.hasNewMigrations {
+			entries = append(entries,
+				fakeDirEntry{name: "0001_test_migration_up.sql"},
+				fakeDirEntry{name: "0001_test_migration_down.sql"},
+			)
+		}
+		return entries, nil
+	}
+	return nil, fmt.Errorf("directory not found: %s", name)
+}
+
+func (f *fakeMigrationFS) ReadFile(name string) ([]byte, error) {
+	if f.shouldFailRead {
+		return nil, fmt.Errorf("simulated read failure")
+	}
+	if f.invalidSQL {
+		return []byte("INVALID SQL SYNTAX GOES HERE AND MAKES DATABASE SAD"), nil
+	}
+	if name == "sql/migrations/0000_create_migrations_table_up.sql" {
+		return []byte("CREATE TABLE migrations (version TEXT PRIMARY KEY, applied_at DATETIME DEFAULT CURRENT_TIMESTAMP);"), nil
+	}
+	if name == "sql/migrations/0001_test_migration_up.sql" {
+		return []byte("CREATE TABLE test_table (id INTEGER PRIMARY KEY);"), nil
+	}
+	if name == "sql/migrations/0001_test_migration_down.sql" {
+		return []byte("DROP TABLE IF EXISTS test_table;"), nil
+	}
+	return nil, fmt.Errorf("file not found: %s", name)
+}
+
 func createTestDB(t *testing.T) *sql.DB {
 	db, err := sql.Open("sqlite3", ":memory:")
 	if err != nil {
···
 		}
 	})
 
+	t.Run("handles migration directory read failure", func(t *testing.T) {
+		db := createTestDB(t)
+
+		emptyFS := embed.FS{}
+		runner := NewMigrationRunner(db, emptyFS)
+
+		err := runner.RunMigrations()
+		if err == nil {
+			t.Error("RunMigrations should fail when migration directory cannot be read")
+		}
+	})
+
+	t.Run("handles migration table check failure", func(t *testing.T) {
+		db := createTestDB(t)
+		db.Close()
+
+		runner := NewMigrationRunner(db, testMigrationFiles)
+		err := runner.RunMigrations()
+		if err == nil {
+			t.Error("RunMigrations should fail when database connection is closed")
+		}
+	})
+
+	t.Run("handles migration file read failure", func(t *testing.T) {
+		db := createTestDB(t)
+
+		fakeFS := &fakeMigrationFS{shouldFailRead: true, hasNewMigrations: true}
+		runner := NewMigrationRunner(db, fakeFS)
+
+		err := runner.RunMigrations()
+		if err == nil {
+			t.Error("RunMigrations should fail when migration file cannot be read")
+		}
+	})
+
+	t.Run("handles invalid SQL in migration file", func(t *testing.T) {
+		db := createTestDB(t)
+
+		fakeFS := &fakeMigrationFS{invalidSQL: true, hasNewMigrations: true}
+		runner := NewMigrationRunner(db, fakeFS)
+
+		err := runner.RunMigrations()
+		if err == nil {
+			t.Error("RunMigrations should fail when migration contains invalid SQL")
+		}
+	})
+
+	t.Run("handles migration record insertion failure", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("First RunMigrations failed: %v", err)
+		}
+
+		_, err = db.Exec("DROP TABLE migrations")
+		if err != nil {
+			t.Fatalf("Failed to drop migrations table: %v", err)
+		}
+
+		_, err = db.Exec("CREATE TABLE migrations (version TEXT PRIMARY KEY CHECK(length(version) < 0))")
+		if err != nil {
+			t.Fatalf("Failed to create migrations table with constraint: %v", err)
+		}
+
+		err = runner.RunMigrations()
+		if err == nil {
+			t.Error("RunMigrations should fail when migration record cannot be inserted")
+		}
+	})
+
 	t.Run("skips already applied migrations", func(t *testing.T) {
 		db := createTestDB(t)
 		runner := NewMigrationRunner(db, testMigrationFiles)
···
 		}
 	})
 
+	t.Run("handles database connection failure", func(t *testing.T) {
+		db := createTestDB(t)
+		db.Close()
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		_, err := runner.GetAppliedMigrations()
+		if err == nil {
+			t.Error("GetAppliedMigrations should fail when database connection is closed")
+		}
+	})
+
+	t.Run("handles query execution failure", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		// Close the database to trigger a query failure
+		db.Close()
+
+		_, err = runner.GetAppliedMigrations()
+		if err == nil {
+			t.Error("GetAppliedMigrations should fail when database is closed")
+		}
+	})
+
+	t.Run("handles row scan failure", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		// Insert a record with NULL applied_at which should cause scan issues
+		_, err = db.Exec("INSERT INTO migrations (version, applied_at) VALUES ('test', NULL)")
+		if err != nil {
+			t.Fatalf("Failed to insert NULL migration record: %v", err)
+		}
+
+		_, err = runner.GetAppliedMigrations()
+		if err == nil {
+			t.Error("GetAppliedMigrations should fail when scanning NULL applied_at field")
+		}
+	})
+
 	t.Run("returns applied migrations", func(t *testing.T) {
 		db := createTestDB(t)
 		runner := NewMigrationRunner(db, testMigrationFiles)
···
 		}
 	})
 
+	t.Run("handles migration directory read failure", func(t *testing.T) {
+		db := createTestDB(t)
+
+		emptyFS := embed.FS{}
+		runner := NewMigrationRunner(db, emptyFS)
+
+		_, err := runner.GetAvailableMigrations()
+		if err == nil {
+			t.Error("GetAvailableMigrations should fail when migration directory cannot be read")
+		}
+	})
+
+	t.Run("handles migration file read failure", func(t *testing.T) {
+		db := createTestDB(t)
+
+		fakeFS := &fakeMigrationFS{shouldFailRead: true}
+		runner := NewMigrationRunner(db, fakeFS)
+
+		_, err := runner.GetAvailableMigrations()
+		if err == nil {
+			t.Error("GetAvailableMigrations should fail when migration file cannot be read")
+		}
+	})
+
 	t.Run("includes both up and down SQL when available", 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("handles database connection failure", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		db.Close()
+
+		err = runner.Rollback()
+		if err == nil {
+			t.Error("Rollback should fail when database connection is closed")
+		}
+	})
+
+	t.Run("handles migration directory read failure during rollback", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		emptyFS := embed.FS{}
+		runner.migrationFiles = emptyFS
+
+		err = runner.Rollback()
+		if err == nil {
+			t.Error("Rollback should fail when migration directory cannot be read")
+		}
+	})
+
+	t.Run("handles missing down migration file", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		fakeFS := &fakeMigrationFS{}
+		runner.migrationFiles = fakeFS
+
+		err = runner.Rollback()
+		if err == nil {
+			t.Error("Rollback should fail when down migration file is not found")
+		}
+	})
+
+	t.Run("handles down migration file read failure", func(t *testing.T) {
+		db := createTestDB(t)
+
+		fakeFS := &fakeMigrationFS{}
+		runner := NewMigrationRunner(db, fakeFS)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		fakeFS.shouldFailRead = true
+
+		err = runner.Rollback()
+		if err == nil {
+			t.Error("Rollback should fail when down migration file cannot be read")
+		}
+	})
+
+	t.Run("handles invalid down migration SQL", func(t *testing.T) {
+		db := createTestDB(t)
+
+		fakeFS := &fakeMigrationFS{}
+		runner := NewMigrationRunner(db, fakeFS)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		fakeFS.invalidSQL = true
+
+		err = runner.Rollback()
+		if err == nil {
+			t.Error("Rollback should fail when down migration contains invalid SQL")
+		}
+	})
+
+	t.Run("handles migration record deletion failure", func(t *testing.T) {
+		db := createTestDB(t)
+		runner := NewMigrationRunner(db, testMigrationFiles)
+
+		err := runner.RunMigrations()
+		if err != nil {
+			t.Fatalf("RunMigrations failed: %v", err)
+		}
+
+		_, err = db.Exec("DROP TABLE migrations")
+		if err != nil {
+			t.Fatalf("Failed to drop migrations table: %v", err)
+		}
+
+		err = runner.Rollback()
+		if err == nil {
+			t.Error("Rollback should fail when migration record cannot be deleted")
 		}
 	})