+163

internal/store/config_test.go

··· 221 221 } 222 222 }) 223 223 224 224 + t.Run("LoadConfig handles file read permission error", func(t *testing.T) { 225 225 + if runtime.GOOS == "windows" { 226 226 + t.Skip("Permission test not reliable on Windows") 227 227 + } 228 228 + 229 229 + tempDir, err := os.MkdirTemp("", "noteleaf-config-perm-test-*") 230 230 + if err != nil { 231 231 + t.Fatalf("Failed to create temp directory: %v", err) 232 232 + } 233 233 + defer os.RemoveAll(tempDir) 234 234 + 235 235 + originalGetConfigDir := GetConfigDir 236 236 + GetConfigDir = func() (string, error) { 237 237 + return tempDir, nil 238 238 + } 239 239 + defer func() { GetConfigDir = originalGetConfigDir }() 240 240 + 241 241 + configPath := filepath.Join(tempDir, ".noteleaf.conf.toml") 242 242 + validTOML := `color_scheme = "dark"` 243 243 + err = os.WriteFile(configPath, []byte(validTOML), 0644) 244 244 + if err != nil { 245 245 + t.Fatalf("Failed to write config file: %v", err) 246 246 + } 247 247 + 248 248 + err = os.Chmod(configPath, 0000) 249 249 + if err != nil { 250 250 + t.Fatalf("Failed to change file permissions: %v", err) 251 251 + } 252 252 + defer os.Chmod(configPath, 0644) 253 253 + 254 254 + _, err = LoadConfig() 255 255 + if err == nil { 256 256 + t.Error("LoadConfig should fail when config file is not readable") 257 257 + } 258 258 + }) 259 259 + 260 260 + t.Run("LoadConfig handles GetConfigDir error", func(t *testing.T) { 261 261 + originalGetConfigDir := GetConfigDir 262 262 + GetConfigDir = func() (string, error) { 263 263 + return "", os.ErrPermission 264 264 + } 265 265 + defer func() { GetConfigDir = originalGetConfigDir }() 266 266 + 267 267 + _, err := LoadConfig() 268 268 + if err == nil { 269 269 + t.Error("LoadConfig should fail when GetConfigDir fails") 270 270 + } 271 271 + }) 272 272 + 273 273 + t.Run("LoadConfig handles SaveConfig failure when creating default", func(t *testing.T) { 274 274 + tempDir, err := os.MkdirTemp("", "noteleaf-config-save-fail-test-*") 275 275 + if err != nil { 276 276 + t.Fatalf("Failed to create temp directory: %v", err) 277 277 + } 278 278 + defer os.RemoveAll(tempDir) 279 279 + 280 280 + _ = filepath.Join(tempDir, ".noteleaf.conf.toml") 281 281 + 282 282 + callCount := 0 283 283 + originalGetConfigDir := GetConfigDir 284 284 + GetConfigDir = func() (string, error) { 285 285 + callCount++ 286 286 + if callCount == 1 { 287 287 + return tempDir, nil 288 288 + } 289 289 + return "", os.ErrPermission 290 290 + } 291 291 + defer func() { GetConfigDir = originalGetConfigDir }() 292 292 + 293 293 + _, err = LoadConfig() 294 294 + if err == nil { 295 295 + t.Error("LoadConfig should fail when SaveConfig fails during default config creation") 296 296 + } 297 297 + }) 298 298 + 224 299 t.Run("SaveConfig handles directory creation failure", func(t *testing.T) { 225 300 originalGetConfigDir := GetConfigDir 226 301 GetConfigDir = func() (string, error) { ··· 235 310 } 236 311 }) 237 312 313 313 + t.Run("SaveConfig handles file write permission error", func(t *testing.T) { 314 314 + if runtime.GOOS == "windows" { 315 315 + t.Skip("Permission test not reliable on Windows") 316 316 + } 317 317 + 318 318 + tempDir, err := os.MkdirTemp("", "noteleaf-config-write-perm-test-*") 319 319 + if err != nil { 320 320 + t.Fatalf("Failed to create temp directory: %v", err) 321 321 + } 322 322 + defer os.RemoveAll(tempDir) 323 323 + 324 324 + originalGetConfigDir := GetConfigDir 325 325 + GetConfigDir = func() (string, error) { 326 326 + return tempDir, nil 327 327 + } 328 328 + defer func() { GetConfigDir = originalGetConfigDir }() 329 329 + 330 330 + err = os.Chmod(tempDir, 0555) 331 331 + if err != nil { 332 332 + t.Fatalf("Failed to change directory permissions: %v", err) 333 333 + } 334 334 + defer os.Chmod(tempDir, 0755) 335 335 + 336 336 + config := DefaultConfig() 337 337 + err = SaveConfig(config) 338 338 + if err == nil { 339 339 + t.Error("SaveConfig should fail when directory is not writable") 340 340 + } 341 341 + }) 342 342 + 238 343 t.Run("GetConfigPath handles GetConfigDir error", func(t *testing.T) { 239 344 originalGetConfigDir := GetConfigDir 240 345 GetConfigDir = func() (string, error) { ··· 342 447 if configDir != expectedPath { 343 448 t.Errorf("Expected config dir %s, got %s", expectedPath, configDir) 344 449 } 450 450 + } 451 451 + }) 452 452 + 453 453 + t.Run("handles HOME directory lookup failure on Unix", func(t *testing.T) { 454 454 + if runtime.GOOS == "windows" { 455 455 + t.Skip("HOME directory test not applicable on Windows") 456 456 + } 457 457 + 458 458 + originalXDG := os.Getenv("XDG_CONFIG_HOME") 459 459 + originalHome := os.Getenv("HOME") 460 460 + os.Unsetenv("XDG_CONFIG_HOME") 461 461 + os.Unsetenv("HOME") 462 462 + 463 463 + defer func() { 464 464 + os.Setenv("XDG_CONFIG_HOME", originalXDG) 465 465 + os.Setenv("HOME", originalHome) 466 466 + }() 467 467 + 468 468 + _, err := GetConfigDir() 469 469 + if err == nil { 470 470 + t.Error("GetConfigDir should fail when both XDG_CONFIG_HOME and HOME are not available") 471 471 + } 472 472 + }) 473 473 + 474 474 + t.Run("handles directory creation permission failure", func(t *testing.T) { 475 475 + if runtime.GOOS == "windows" { 476 476 + t.Skip("Permission test not reliable on Windows") 477 477 + } 478 478 + 479 479 + tempParent, err := os.MkdirTemp("", "noteleaf-parent-test-*") 480 480 + if err != nil { 481 481 + t.Fatalf("Failed to create temp parent directory: %v", err) 482 482 + } 483 483 + defer os.RemoveAll(tempParent) 484 484 + 485 485 + err = os.Chmod(tempParent, 0555) 486 486 + if err != nil { 487 487 + t.Fatalf("Failed to change parent directory permissions: %v", err) 488 488 + } 489 489 + defer os.Chmod(tempParent, 0755) 490 490 + 491 491 + var originalEnv string 492 492 + var envVar string 493 493 + switch runtime.GOOS { 494 494 + case "windows": 495 495 + envVar = "APPDATA" 496 496 + originalEnv = os.Getenv("APPDATA") 497 497 + os.Setenv("APPDATA", tempParent) 498 498 + default: 499 499 + envVar = "XDG_CONFIG_HOME" 500 500 + originalEnv = os.Getenv("XDG_CONFIG_HOME") 501 501 + os.Setenv("XDG_CONFIG_HOME", tempParent) 502 502 + } 503 503 + defer os.Setenv(envVar, originalEnv) 504 504 + 505 505 + _, err = GetConfigDir() 506 506 + if err == nil { 507 507 + t.Error("GetConfigDir should fail when directory creation is not permitted") 345 508 } 346 509 }) 347 510 }

+71

internal/store/database_test.go

··· 3 3 import ( 4 4 "os" 5 5 "path/filepath" 6 6 + "runtime" 6 7 "testing" 7 8 ) 8 9 ··· 159 160 _, err := NewDatabase() 160 161 if err == nil { 161 162 t.Error("NewDatabase should fail with invalid database path") 163 163 + } 164 164 + }) 165 165 + 166 166 + t.Run("handles invalid database connection", func(t *testing.T) { 167 167 + originalGetConfigDir := GetConfigDir 168 168 + GetConfigDir = func() (string, error) { 169 169 + return "/dev/null", nil 170 170 + } 171 171 + defer func() { GetConfigDir = originalGetConfigDir }() 172 172 + 173 173 + _, err := NewDatabase() 174 174 + if err == nil { 175 175 + t.Error("NewDatabase should fail when database path is invalid") 176 176 + } 177 177 + }) 178 178 + 179 179 + t.Run("handles migration failure during database creation", func(t *testing.T) { 180 180 + tempDir, err := os.MkdirTemp("", "noteleaf-db-migration-fail-test-*") 181 181 + if err != nil { 182 182 + t.Fatalf("Failed to create temp directory: %v", err) 183 183 + } 184 184 + defer os.RemoveAll(tempDir) 185 185 + 186 186 + originalGetConfigDir := GetConfigDir 187 187 + GetConfigDir = func() (string, error) { 188 188 + return tempDir, nil 189 189 + } 190 190 + defer func() { GetConfigDir = originalGetConfigDir }() 191 191 + 192 192 + dbPath := filepath.Join(tempDir, "noteleaf.db") 193 193 + 194 194 + // Create a corrupted database file that will cause issues 195 195 + corruptedSQL := "this is not valid SQL and will cause failures" 196 196 + err = os.WriteFile(dbPath, []byte(corruptedSQL), 0644) 197 197 + if err != nil { 198 198 + t.Fatalf("Failed to create corrupted database file: %v", err) 199 199 + } 200 200 + 201 201 + _, err = NewDatabase() 202 202 + if err == nil { 203 203 + t.Error("NewDatabase should fail when database file is corrupted") 204 204 + } 205 205 + }) 206 206 + 207 207 + t.Run("handles database file permission error", func(t *testing.T) { 208 208 + if runtime.GOOS == "windows" { 209 209 + t.Skip("Permission test not reliable on Windows") 210 210 + } 211 211 + 212 212 + tempDir, err := os.MkdirTemp("", "noteleaf-db-perm-test-*") 213 213 + if err != nil { 214 214 + t.Fatalf("Failed to create temp directory: %v", err) 215 215 + } 216 216 + defer os.RemoveAll(tempDir) 217 217 + 218 218 + originalGetConfigDir := GetConfigDir 219 219 + GetConfigDir = func() (string, error) { 220 220 + return tempDir, nil 221 221 + } 222 222 + defer func() { GetConfigDir = originalGetConfigDir }() 223 223 + 224 224 + err = os.Chmod(tempDir, 0555) 225 225 + if err != nil { 226 226 + t.Fatalf("Failed to change directory permissions: %v", err) 227 227 + } 228 228 + defer os.Chmod(tempDir, 0755) 229 229 + 230 230 + _, err = NewDatabase() 231 231 + if err == nil { 232 232 + t.Error("NewDatabase should fail when database directory is not writable") 162 233 } 163 234 }) 164 235 }

+9 -3

internal/store/migration.go

··· 2 2 3 3 import ( 4 4 "database/sql" 5 5 - "embed" 6 5 "fmt" 6 6 + "io/fs" 7 7 "sort" 8 8 "strings" 9 9 ) ··· 18 18 AppliedAt string 19 19 } 20 20 21 21 + // FileSystem interface for reading migration files 22 22 + type FileSystem interface { 23 23 + ReadDir(name string) ([]fs.DirEntry, error) 24 24 + ReadFile(name string) ([]byte, error) 25 25 + } 26 26 + 21 27 // MigrationRunner handles database migrations 22 28 type MigrationRunner struct { 23 29 db *sql.DB 24 24 - migrationFiles embed.FS 30 30 + migrationFiles FileSystem 25 31 } 26 32 27 33 // NewMigrationRunner creates a new migration runner 28 28 - func NewMigrationRunner(db *sql.DB, files embed.FS) *MigrationRunner { 34 34 + func NewMigrationRunner(db *sql.DB, files FileSystem) *MigrationRunner { 29 35 return &MigrationRunner{ 30 36 db: db, 31 37 migrationFiles: files,

+309

internal/store/migration_test.go

··· 3 3 import ( 4 4 "database/sql" 5 5 "embed" 6 6 + "fmt" 7 7 + "io/fs" 6 8 "testing" 7 9 8 10 _ "github.com/mattn/go-sqlite3" ··· 11 13 //go:embed sql/migrations 12 14 var testMigrationFiles embed.FS 13 15 16 16 + type fakeMigrationFS struct { 17 17 + shouldFailRead bool 18 18 + invalidSQL bool 19 19 + hasNewMigrations bool 20 20 + } 21 21 + 22 22 + type fakeDirEntry struct { 23 23 + name string 24 24 + } 25 25 + 26 26 + func (f fakeDirEntry) Name() string { return f.name } 27 27 + func (f fakeDirEntry) IsDir() bool { return false } 28 28 + func (f fakeDirEntry) Type() fs.FileMode { return 0 } 29 29 + func (f fakeDirEntry) Info() (fs.FileInfo, error) { return nil, fmt.Errorf("info not available") } 30 30 + 31 31 + func (f *fakeMigrationFS) ReadDir(name string) ([]fs.DirEntry, error) { 32 32 + if name == "sql/migrations" { 33 33 + entries := []fs.DirEntry{ 34 34 + fakeDirEntry{name: "0000_create_migrations_table_up.sql"}, 35 35 + } 36 36 + if f.hasNewMigrations { 37 37 + entries = append(entries, 38 38 + fakeDirEntry{name: "0001_test_migration_up.sql"}, 39 39 + fakeDirEntry{name: "0001_test_migration_down.sql"}, 40 40 + ) 41 41 + } 42 42 + return entries, nil 43 43 + } 44 44 + return nil, fmt.Errorf("directory not found: %s", name) 45 45 + } 46 46 + 47 47 + func (f *fakeMigrationFS) ReadFile(name string) ([]byte, error) { 48 48 + if f.shouldFailRead { 49 49 + return nil, fmt.Errorf("simulated read failure") 50 50 + } 51 51 + if f.invalidSQL { 52 52 + return []byte("INVALID SQL SYNTAX GOES HERE AND MAKES DATABASE SAD"), nil 53 53 + } 54 54 + if name == "sql/migrations/0000_create_migrations_table_up.sql" { 55 55 + return []byte("CREATE TABLE migrations (version TEXT PRIMARY KEY, applied_at DATETIME DEFAULT CURRENT_TIMESTAMP);"), nil 56 56 + } 57 57 + if name == "sql/migrations/0001_test_migration_up.sql" { 58 58 + return []byte("CREATE TABLE test_table (id INTEGER PRIMARY KEY);"), nil 59 59 + } 60 60 + if name == "sql/migrations/0001_test_migration_down.sql" { 61 61 + return []byte("DROP TABLE IF EXISTS test_table;"), nil 62 62 + } 63 63 + return nil, fmt.Errorf("file not found: %s", name) 64 64 + } 65 65 + 14 66 func createTestDB(t *testing.T) *sql.DB { 15 67 db, err := sql.Open("sqlite3", ":memory:") 16 68 if err != nil { ··· 72 124 } 73 125 }) 74 126 127 127 + t.Run("handles migration directory read failure", func(t *testing.T) { 128 128 + db := createTestDB(t) 129 129 + 130 130 + emptyFS := embed.FS{} 131 131 + runner := NewMigrationRunner(db, emptyFS) 132 132 + 133 133 + err := runner.RunMigrations() 134 134 + if err == nil { 135 135 + t.Error("RunMigrations should fail when migration directory cannot be read") 136 136 + } 137 137 + }) 138 138 + 139 139 + t.Run("handles migration table check failure", func(t *testing.T) { 140 140 + db := createTestDB(t) 141 141 + db.Close() 142 142 + 143 143 + runner := NewMigrationRunner(db, testMigrationFiles) 144 144 + err := runner.RunMigrations() 145 145 + if err == nil { 146 146 + t.Error("RunMigrations should fail when database connection is closed") 147 147 + } 148 148 + }) 149 149 + 150 150 + t.Run("handles migration file read failure", func(t *testing.T) { 151 151 + db := createTestDB(t) 152 152 + 153 153 + fakeFS := &fakeMigrationFS{shouldFailRead: true, hasNewMigrations: true} 154 154 + runner := NewMigrationRunner(db, fakeFS) 155 155 + 156 156 + err := runner.RunMigrations() 157 157 + if err == nil { 158 158 + t.Error("RunMigrations should fail when migration file cannot be read") 159 159 + } 160 160 + }) 161 161 + 162 162 + t.Run("handles invalid SQL in migration file", func(t *testing.T) { 163 163 + db := createTestDB(t) 164 164 + 165 165 + fakeFS := &fakeMigrationFS{invalidSQL: true, hasNewMigrations: true} 166 166 + runner := NewMigrationRunner(db, fakeFS) 167 167 + 168 168 + err := runner.RunMigrations() 169 169 + if err == nil { 170 170 + t.Error("RunMigrations should fail when migration contains invalid SQL") 171 171 + } 172 172 + }) 173 173 + 174 174 + t.Run("handles migration record insertion failure", func(t *testing.T) { 175 175 + db := createTestDB(t) 176 176 + runner := NewMigrationRunner(db, testMigrationFiles) 177 177 + 178 178 + err := runner.RunMigrations() 179 179 + if err != nil { 180 180 + t.Fatalf("First RunMigrations failed: %v", err) 181 181 + } 182 182 + 183 183 + _, err = db.Exec("DROP TABLE migrations") 184 184 + if err != nil { 185 185 + t.Fatalf("Failed to drop migrations table: %v", err) 186 186 + } 187 187 + 188 188 + _, err = db.Exec("CREATE TABLE migrations (version TEXT PRIMARY KEY CHECK(length(version) < 0))") 189 189 + if err != nil { 190 190 + t.Fatalf("Failed to create migrations table with constraint: %v", err) 191 191 + } 192 192 + 193 193 + err = runner.RunMigrations() 194 194 + if err == nil { 195 195 + t.Error("RunMigrations should fail when migration record cannot be inserted") 196 196 + } 197 197 + }) 198 198 + 75 199 t.Run("skips already applied migrations", func(t *testing.T) { 76 200 db := createTestDB(t) 77 201 runner := NewMigrationRunner(db, testMigrationFiles) ··· 143 267 } 144 268 }) 145 269 270 270 + t.Run("handles database connection failure", func(t *testing.T) { 271 271 + db := createTestDB(t) 272 272 + db.Close() 273 273 + runner := NewMigrationRunner(db, testMigrationFiles) 274 274 + 275 275 + _, err := runner.GetAppliedMigrations() 276 276 + if err == nil { 277 277 + t.Error("GetAppliedMigrations should fail when database connection is closed") 278 278 + } 279 279 + }) 280 280 + 281 281 + t.Run("handles query execution failure", func(t *testing.T) { 282 282 + db := createTestDB(t) 283 283 + runner := NewMigrationRunner(db, testMigrationFiles) 284 284 + 285 285 + err := runner.RunMigrations() 286 286 + if err != nil { 287 287 + t.Fatalf("RunMigrations failed: %v", err) 288 288 + } 289 289 + 290 290 + // Close the database to trigger a query failure 291 291 + db.Close() 292 292 + 293 293 + _, err = runner.GetAppliedMigrations() 294 294 + if err == nil { 295 295 + t.Error("GetAppliedMigrations should fail when database is closed") 296 296 + } 297 297 + }) 298 298 + 299 299 + t.Run("handles row scan failure", func(t *testing.T) { 300 300 + db := createTestDB(t) 301 301 + runner := NewMigrationRunner(db, testMigrationFiles) 302 302 + 303 303 + err := runner.RunMigrations() 304 304 + if err != nil { 305 305 + t.Fatalf("RunMigrations failed: %v", err) 306 306 + } 307 307 + 308 308 + // Insert a record with NULL applied_at which should cause scan issues 309 309 + _, err = db.Exec("INSERT INTO migrations (version, applied_at) VALUES ('test', NULL)") 310 310 + if err != nil { 311 311 + t.Fatalf("Failed to insert NULL migration record: %v", err) 312 312 + } 313 313 + 314 314 + _, err = runner.GetAppliedMigrations() 315 315 + if err == nil { 316 316 + t.Error("GetAppliedMigrations should fail when scanning NULL applied_at field") 317 317 + } 318 318 + }) 319 319 + 146 320 t.Run("returns applied migrations", func(t *testing.T) { 147 321 db := createTestDB(t) 148 322 runner := NewMigrationRunner(db, testMigrationFiles) ··· 213 387 } 214 388 }) 215 389 390 390 + t.Run("handles migration directory read failure", func(t *testing.T) { 391 391 + db := createTestDB(t) 392 392 + 393 393 + emptyFS := embed.FS{} 394 394 + runner := NewMigrationRunner(db, emptyFS) 395 395 + 396 396 + _, err := runner.GetAvailableMigrations() 397 397 + if err == nil { 398 398 + t.Error("GetAvailableMigrations should fail when migration directory cannot be read") 399 399 + } 400 400 + }) 401 401 + 402 402 + t.Run("handles migration file read failure", func(t *testing.T) { 403 403 + db := createTestDB(t) 404 404 + 405 405 + fakeFS := &fakeMigrationFS{shouldFailRead: true} 406 406 + runner := NewMigrationRunner(db, fakeFS) 407 407 + 408 408 + _, err := runner.GetAvailableMigrations() 409 409 + if err == nil { 410 410 + t.Error("GetAvailableMigrations should fail when migration file cannot be read") 411 411 + } 412 412 + }) 413 413 + 216 414 t.Run("includes both up and down SQL when available", func(t *testing.T) { 217 415 db := createTestDB(t) 218 416 runner := NewMigrationRunner(db, testMigrationFiles) ··· 244 442 err := runner.Rollback() 245 443 if err == nil { 246 444 t.Error("Rollback should fail when no migrations are applied") 445 445 + } 446 446 + }) 447 447 + 448 448 + t.Run("handles database connection failure", func(t *testing.T) { 449 449 + db := createTestDB(t) 450 450 + runner := NewMigrationRunner(db, testMigrationFiles) 451 451 + 452 452 + err := runner.RunMigrations() 453 453 + if err != nil { 454 454 + t.Fatalf("RunMigrations failed: %v", err) 455 455 + } 456 456 + 457 457 + db.Close() 458 458 + 459 459 + err = runner.Rollback() 460 460 + if err == nil { 461 461 + t.Error("Rollback should fail when database connection is closed") 462 462 + } 463 463 + }) 464 464 + 465 465 + t.Run("handles migration directory read failure during rollback", func(t *testing.T) { 466 466 + db := createTestDB(t) 467 467 + runner := NewMigrationRunner(db, testMigrationFiles) 468 468 + 469 469 + err := runner.RunMigrations() 470 470 + if err != nil { 471 471 + t.Fatalf("RunMigrations failed: %v", err) 472 472 + } 473 473 + 474 474 + emptyFS := embed.FS{} 475 475 + runner.migrationFiles = emptyFS 476 476 + 477 477 + err = runner.Rollback() 478 478 + if err == nil { 479 479 + t.Error("Rollback should fail when migration directory cannot be read") 480 480 + } 481 481 + }) 482 482 + 483 483 + t.Run("handles missing down migration file", func(t *testing.T) { 484 484 + db := createTestDB(t) 485 485 + runner := NewMigrationRunner(db, testMigrationFiles) 486 486 + 487 487 + err := runner.RunMigrations() 488 488 + if err != nil { 489 489 + t.Fatalf("RunMigrations failed: %v", err) 490 490 + } 491 491 + 492 492 + fakeFS := &fakeMigrationFS{} 493 493 + runner.migrationFiles = fakeFS 494 494 + 495 495 + err = runner.Rollback() 496 496 + if err == nil { 497 497 + t.Error("Rollback should fail when down migration file is not found") 498 498 + } 499 499 + }) 500 500 + 501 501 + t.Run("handles down migration file read failure", func(t *testing.T) { 502 502 + db := createTestDB(t) 503 503 + 504 504 + fakeFS := &fakeMigrationFS{} 505 505 + runner := NewMigrationRunner(db, fakeFS) 506 506 + 507 507 + err := runner.RunMigrations() 508 508 + if err != nil { 509 509 + t.Fatalf("RunMigrations failed: %v", err) 510 510 + } 511 511 + 512 512 + fakeFS.shouldFailRead = true 513 513 + 514 514 + err = runner.Rollback() 515 515 + if err == nil { 516 516 + t.Error("Rollback should fail when down migration file cannot be read") 517 517 + } 518 518 + }) 519 519 + 520 520 + t.Run("handles invalid down migration SQL", func(t *testing.T) { 521 521 + db := createTestDB(t) 522 522 + 523 523 + fakeFS := &fakeMigrationFS{} 524 524 + runner := NewMigrationRunner(db, fakeFS) 525 525 + 526 526 + err := runner.RunMigrations() 527 527 + if err != nil { 528 528 + t.Fatalf("RunMigrations failed: %v", err) 529 529 + } 530 530 + 531 531 + fakeFS.invalidSQL = true 532 532 + 533 533 + err = runner.Rollback() 534 534 + if err == nil { 535 535 + t.Error("Rollback should fail when down migration contains invalid SQL") 536 536 + } 537 537 + }) 538 538 + 539 539 + t.Run("handles migration record deletion failure", func(t *testing.T) { 540 540 + db := createTestDB(t) 541 541 + runner := NewMigrationRunner(db, testMigrationFiles) 542 542 + 543 543 + err := runner.RunMigrations() 544 544 + if err != nil { 545 545 + t.Fatalf("RunMigrations failed: %v", err) 546 546 + } 547 547 + 548 548 + _, err = db.Exec("DROP TABLE migrations") 549 549 + if err != nil { 550 550 + t.Fatalf("Failed to drop migrations table: %v", err) 551 551 + } 552 552 + 553 553 + err = runner.Rollback() 554 554 + if err == nil { 555 555 + t.Error("Rollback should fail when migration record cannot be deleted") 247 556 } 248 557 }) 249 558