build: add context cancellation tests for repositories

internal/handlers/tasks_test.go

···
 				}
 			})
 		})
+
+		t.Run("contextListStaticMode", func(t *testing.T) {
+			oldStdout := os.Stdout
+			defer func() { os.Stdout = oldStdout }()
+
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			outputChan := make(chan string, 1)
+			go func() {
+				var buf bytes.Buffer
+				buf.ReadFrom(r)
+				outputChan <- buf.String()
+			}()
+
+			t.Run("lists contexts with tasks", func(t *testing.T) {
+				err := handler.listContextsStatic(ctx, false)
+				w.Close()
+				capturedOutput := <-outputChan
+
+				if err != nil {
+					t.Errorf("listContextsStatic should succeed: %v", err)
+				}
+				if !strings.Contains(capturedOutput, "test-context") {
+					t.Error("Output should contain 'test-context' context")
+				}
+			})
+
+			r, w, _ = os.Pipe()
+			os.Stdout = w
+			go func() {
+				var buf bytes.Buffer
+				buf.ReadFrom(r)
+				outputChan <- buf.String()
+			}()
+
+			t.Run("lists contexts with todo.txt format", func(t *testing.T) {
+				err := handler.listContextsStatic(ctx, true)
+				w.Close()
+				capturedOutput := <-outputChan
+
+				if err != nil {
+					t.Errorf("listContextsStatic with todoTxt should succeed: %v", err)
+				}
+				if !strings.Contains(capturedOutput, "@test-context") {
+					t.Error("Output should contain '@test-context' in todo.txt format")
+				}
+			})
+
+			t.Run("handles no contexts", func(t *testing.T) {
+				_, cleanup2 := setupTaskTest(t)
+				defer cleanup2()
+
+				handler2, err := NewTaskHandler()
+				if err != nil {
+					t.Fatalf("Failed to create handler: %v", err)
+				}
+				defer handler2.Close()
+
+				r, w, _ = os.Pipe()
+				os.Stdout = w
+				go func() {
+					var buf bytes.Buffer
+					buf.ReadFrom(r)
+					outputChan <- buf.String()
+				}()
+
+				err = handler2.listContextsStatic(ctx, false)
+				w.Close()
+				capturedOutput := <-outputChan
+
+				if err != nil {
+					t.Errorf("listContextsStatic with no contexts should succeed: %v", err)
+				}
+				if !strings.Contains(capturedOutput, "No contexts found") {
+					t.Error("Output should contain 'No contexts found'")
+				}
+			})
+
+			t.Run("handles repository error", func(t *testing.T) {
+				cancelCtx, cancel := context.WithCancel(ctx)
+				cancel()
+
+				err := handler.listContextsStatic(cancelCtx, false)
+				if err == nil {
+					t.Error("Expected error with cancelled context")
+				}
+				if !strings.Contains(err.Error(), "failed to list tasks for contexts") {
+					t.Errorf("Expected specific error message, got: %v", err)
+				}
+			})
+
+			t.Run("counts tasks per context correctly", func(t *testing.T) {
+				r, w, _ = os.Pipe()
+				os.Stdout = w
+				go func() {
+					var buf bytes.Buffer
+					buf.ReadFrom(r)
+					outputChan <- buf.String()
+				}()
+
+				err := handler.listContextsStatic(ctx, false)
+				w.Close()
+				capturedOutput := <-outputChan
+
+				if err != nil {
+					t.Errorf("listContextsStatic should succeed: %v", err)
+				}
+
+				if !strings.Contains(capturedOutput, "test-context (2 tasks)") {
+					t.Error("Output should show correct count for test-context context")
+				}
+			})
+		})
 	})
 }

internal/repo/article_repository_test.go

···
 			AssertNoError(t, err, "Failed to count articles")
 			AssertEqual(t, int64(0), count, "Expected 0 articles")
 		})
+
+		t.Run("Count with context cancellation", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			_, err := repo.Count(cancelCtx, nil)
+			if err == nil {
+				t.Error("Expected error with cancelled context")
+			}
+		})
 	})
 
 	t.Run("Validate", func(t *testing.T) {

internal/repo/book_repository_test.go

···
 			AssertNoError(t, err, "Failed to count high-rated books")
 			AssertEqual(t, int64(3), count, "Expected 3 books with rating >= 4.0")
 		})
+
+		t.Run("Count with context cancellation", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			_, err := repo.Count(cancelCtx, BookListOptions{})
+			if err == nil {
+				t.Error("Expected error with cancelled context")
+			}
+		})
 	})
 }

internal/repo/movie_repository_test.go

···
 			AssertNoError(t, err, "Failed to count high-rated movies")
 			AssertEqual(t, int64(2), count, "Expected 2 movies with rating >= 8.0")
 		})
+
+		t.Run("Count with context cancellation", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			_, err := repo.Count(cancelCtx, MovieListOptions{})
+			if err == nil {
+				t.Error("Expected error with cancelled context")
+			}
+		})
 	})
 }

internal/repo/task_repository_test.go

···
 		if task.Modified.IsZero() {
 			t.Error("Expected Modified timestamp to be set")
 		}
+
+		t.Run("Errors", func(t *testing.T) {
+			t.Run("when called with duplicate UUID", func(t *testing.T) {
+				task1 := CreateSampleTask()
+				task1.UUID = "duplicate-test-uuid"
+
+				_, err := repo.Create(ctx, task1)
+				if err != nil {
+					t.Fatalf("Failed to create first task: %v", err)
+				}
+
+				task2 := CreateSampleTask()
+				task2.UUID = "duplicate-test-uuid"
+
+				_, err = repo.Create(ctx, task2)
+				if err == nil {
+					t.Error("Expected error when creating task with duplicate UUID")
+				}
+			})
+
+			t.Run("when called with context cancellation", func(t *testing.T) {
+				cancelCtx, cancel := context.WithCancel(ctx)
+				cancel()
+
+				task := CreateSampleTask()
+				_, err := repo.Create(cancelCtx, task)
+				if err == nil {
+					t.Error("Expected error with cancelled context")
+				}
+			})
+		})
 	})
 
 	t.Run("Get Task", func(t *testing.T) {
···
 		if updated.End == nil {
 			t.Error("Expected end time to be set")
 		}
+
+		t.Run("Update Task Error Cases", func(t *testing.T) {
+			t.Run("when called with context cancellation", func(t *testing.T) {
+				task := CreateSampleTask()
+				_, err := repo.Create(ctx, task)
+				if err != nil {
+					t.Fatalf("Failed to create task: %v", err)
+				}
+
+				cancelCtx, cancel := context.WithCancel(ctx)
+				cancel()
+
+				task.Description = "Updated"
+				err = repo.Update(cancelCtx, task)
+				if err == nil {
+					t.Error("Expected error with cancelled context")
+				}
+			})
+		})
 	})
 
 	t.Run("Delete Task", func(t *testing.T) {
···
 				t.Errorf("Expected description %s, got %s", task1.Description, result.Description)
 			}
 		})
+
+		t.Run("GetByUUID with invalid UUID", func(t *testing.T) {
+			_, err := repo.GetByUUID(ctx, "invalid-uuid-format")
+			if err == nil {
+				t.Error("Expected error with invalid UUID format")
+			}
+		})
+
+		t.Run("GetByUUID with non-existent UUID", func(t *testing.T) {
+			nonExistentUUID := newUUID()
+			_, err := repo.GetByUUID(ctx, nonExistentUUID)
+			if err == nil {
+				t.Error("Expected error with non-existent UUID")
+			}
+		})
+
+		t.Run("GetByUUID with context cancellation", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			_, err := repo.GetByUUID(cancelCtx, task1.UUID)
+			if err == nil {
+				t.Error("Expected error with cancelled context")
+			}
+		})
 	})
 
 	t.Run("Count", func(t *testing.T) {
···
 
 			if count < 1 {
 				t.Errorf("Expected at least 1 completed task, got %d", count)
+			}
+		})
+
+		t.Run("Count with context cancellation", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			_, err := repo.Count(cancelCtx, TaskListOptions{})
+			if err == nil {
+				t.Error("Expected error with cancelled context")
 			}
 		})
 	})
···
 	repo := NewTaskRepository(db)
 	ctx := context.Background()
 
-	// Create tasks with different contexts
 	task1 := CreateSampleTask()
 	task1.Context = "work"
 	_, err := repo.Create(ctx, task1)

internal/repo/time_entries_test.go

···
 	return task
 }
 
-func TestTimeEntryRepository_Start(t *testing.T) {
-	_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
-	defer cleanup()
+func TestTimeEntryRepository(t *testing.T) {
+	t.Run("Start", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
+
+		ctx := context.Background()
+		task := createTestTask(t, taskRepo)
+
+		t.Run("starts time tracking successfully", func(t *testing.T) {
+			description := "Working on feature"
+			entry, err := repo.Start(ctx, task.ID, description)
+
+			if err != nil {
+				t.Fatalf("Failed to start time tracking: %v", err)
+			}
+
+			if entry.ID == 0 {
+				t.Error("Expected entry to have an ID")
+			}
+			if entry.TaskID != task.ID {
+				t.Errorf("Expected TaskID %d, got %d", task.ID, entry.TaskID)
+			}
+			if entry.Description != description {
+				t.Errorf("Expected description %q, got %q", description, entry.Description)
+			}
+			if entry.EndTime != nil {
+				t.Error("Expected EndTime to be nil for active entry")
+			}
+			if !entry.IsActive() {
+				t.Error("Expected entry to be active")
+			}
+		})
+
+		t.Run("prevents starting already active task", func(t *testing.T) {
+			_, err := repo.Start(ctx, task.ID, "Another attempt")
+
+			if err == nil {
+				t.Error("Expected error when starting already active task")
+			}
+			if err.Error() != "task already has an active time entry" {
+				t.Errorf("Expected specific error message, got: %v", err)
+			}
+		})
+	})
 
-	ctx := context.Background()
-	task := createTestTask(t, taskRepo)
+	t.Run("Stop", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
 
-	t.Run("starts time tracking successfully", func(t *testing.T) {
-		description := "Working on feature"
-		entry, err := repo.Start(ctx, task.ID, description)
+		ctx := context.Background()
+		task := createTestTask(t, taskRepo)
 
+		entry, err := repo.Start(ctx, task.ID, "Test work")
 		if err != nil {
 			t.Fatalf("Failed to start time tracking: %v", err)
 		}
 
-		if entry.ID == 0 {
-			t.Error("Expected entry to have an ID")
-		}
-		if entry.TaskID != task.ID {
-			t.Errorf("Expected TaskID %d, got %d", task.ID, entry.TaskID)
-		}
-		if entry.Description != description {
-			t.Errorf("Expected description %q, got %q", description, entry.Description)
-		}
-		if entry.EndTime != nil {
-			t.Error("Expected EndTime to be nil for active entry")
-		}
-		if !entry.IsActive() {
-			t.Error("Expected entry to be active")
-		}
+		time.Sleep(1010 * time.Millisecond)
+
+		t.Run("stops active time entry", func(t *testing.T) {
+			stoppedEntry, err := repo.Stop(ctx, entry.ID)
+
+			if err != nil {
+				t.Fatalf("Failed to stop time tracking: %v", err)
+			}
+
+			if stoppedEntry.EndTime == nil {
+				t.Error("Expected EndTime to be set")
+			}
+			if stoppedEntry.DurationSeconds <= 0 {
+				t.Error("Expected duration to be greater than 0")
+			}
+			if stoppedEntry.IsActive() {
+				t.Error("Expected entry to not be active after stopping")
+			}
+		})
+
+		t.Run("fails to stop already stopped entry", func(t *testing.T) {
+			_, err := repo.Stop(ctx, entry.ID)
+
+			if err == nil {
+				t.Error("Expected error when stopping already stopped entry")
+			}
+			if err.Error() != "time entry is not active" {
+				t.Errorf("Expected specific error message, got: %v", err)
+			}
+		})
 	})
 
-	t.Run("prevents starting already active task", func(t *testing.T) {
-		_, err := repo.Start(ctx, task.ID, "Another attempt")
+	t.Run("StopActiveByTaskID", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
+
+		ctx := context.Background()
+		task := createTestTask(t, taskRepo)
+
+		t.Run("stops active entry by task ID", func(t *testing.T) {
+			_, err := repo.Start(ctx, task.ID, "Test work")
+			if err != nil {
+				t.Fatalf("Failed to start time tracking: %v", err)
+			}
 
-		if err == nil {
-			t.Error("Expected error when starting already active task")
-		}
-		if err.Error() != "task already has an active time entry" {
-			t.Errorf("Expected specific error message, got: %v", err)
-		}
+			stoppedEntry, err := repo.StopActiveByTaskID(ctx, task.ID)
+
+			if err != nil {
+				t.Fatalf("Failed to stop time tracking by task ID: %v", err)
+			}
+
+			if stoppedEntry.EndTime == nil {
+				t.Error("Expected EndTime to be set")
+			}
+			if stoppedEntry.IsActive() {
+				t.Error("Expected entry to not be active")
+			}
+		})
+
+		t.Run("fails when no active entry exists", func(t *testing.T) {
+			_, err := repo.StopActiveByTaskID(ctx, task.ID)
+
+			if err == nil {
+				t.Error("Expected error when no active entry exists")
+			}
+			if err.Error() != "no active time entry found for task" {
+				t.Errorf("Expected specific error message, got: %v", err)
+			}
+		})
 	})
-}
 
-func TestTimeEntryRepository_Stop(t *testing.T) {
-	_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
-	defer cleanup()
+	t.Run("GetActiveByTaskID", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
+
+		ctx := context.Background()
+		task := createTestTask(t, taskRepo)
 
-	ctx := context.Background()
-	task := createTestTask(t, taskRepo)
+		t.Run("returns nil when no active entry exists", func(t *testing.T) {
+			_, err := repo.GetActiveByTaskID(ctx, task.ID)
 
-	entry, err := repo.Start(ctx, task.ID, "Test work")
-	if err != nil {
-		t.Fatalf("Failed to start time tracking: %v", err)
-	}
+			if err != sql.ErrNoRows {
+				t.Errorf("Expected sql.ErrNoRows, got: %v", err)
+			}
+		})
 
-	time.Sleep(1010 * time.Millisecond)
+		t.Run("returns active entry when one exists", func(t *testing.T) {
+			startedEntry, err := repo.Start(ctx, task.ID, "Test work")
+			if err != nil {
+				t.Fatalf("Failed to start time tracking: %v", err)
+			}
 
-	t.Run("stops active time entry", func(t *testing.T) {
-		stoppedEntry, err := repo.Stop(ctx, entry.ID)
+			activeEntry, err := repo.GetActiveByTaskID(ctx, task.ID)
 
-		if err != nil {
-			t.Fatalf("Failed to stop time tracking: %v", err)
-		}
+			if err != nil {
+				t.Fatalf("Failed to get active entry: %v", err)
+			}
 
-		if stoppedEntry.EndTime == nil {
-			t.Error("Expected EndTime to be set")
-		}
-		if stoppedEntry.DurationSeconds <= 0 {
-			t.Error("Expected duration to be greater than 0")
-		}
-		if stoppedEntry.IsActive() {
-			t.Error("Expected entry to not be active after stopping")
-		}
+			if activeEntry.ID != startedEntry.ID {
+				t.Errorf("Expected entry ID %d, got %d", startedEntry.ID, activeEntry.ID)
+			}
+			if !activeEntry.IsActive() {
+				t.Error("Expected entry to be active")
+			}
+		})
 	})
 
-	t.Run("fails to stop already stopped entry", func(t *testing.T) {
-		_, err := repo.Stop(ctx, entry.ID)
+	t.Run("GetByTaskID", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
+
+		ctx := context.Background()
+		task := createTestTask(t, taskRepo)
+
+		t.Run("returns empty slice when no entries exist", func(t *testing.T) {
+			entries, err := repo.GetByTaskID(ctx, task.ID)
+
+			if err != nil {
+				t.Fatalf("Failed to get entries: %v", err)
+			}
+
+			if len(entries) != 0 {
+				t.Errorf("Expected 0 entries, got %d", len(entries))
+			}
+		})
 
-		if err == nil {
-			t.Error("Expected error when stopping already stopped entry")
-		}
-		if err.Error() != "time entry is not active" {
-			t.Errorf("Expected specific error message, got: %v", err)
-		}
-	})
-}
+		t.Run("returns all entries for task", func(t *testing.T) {
+			_, err := repo.Start(ctx, task.ID, "First session")
+			if err != nil {
+				t.Fatalf("Failed to start first session: %v", err)
+			}
 
-func TestTimeEntryRepository_StopActiveByTaskID(t *testing.T) {
-	_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
-	defer cleanup()
+			_, err = repo.StopActiveByTaskID(ctx, task.ID)
+			if err != nil {
+				t.Fatalf("Failed to stop first session: %v", err)
+			}
 
-	ctx := context.Background()
-	task := createTestTask(t, taskRepo)
+			_, err = repo.Start(ctx, task.ID, "Second session")
+			if err != nil {
+				t.Fatalf("Failed to start second session: %v", err)
+			}
 
-	t.Run("stops active entry by task ID", func(t *testing.T) {
-		_, err := repo.Start(ctx, task.ID, "Test work")
-		if err != nil {
-			t.Fatalf("Failed to start time tracking: %v", err)
-		}
+			entries, err := repo.GetByTaskID(ctx, task.ID)
 
-		stoppedEntry, err := repo.StopActiveByTaskID(ctx, task.ID)
+			if err != nil {
+				t.Fatalf("Failed to get entries: %v", err)
+			}
 
-		if err != nil {
-			t.Fatalf("Failed to stop time tracking by task ID: %v", err)
-		}
+			if len(entries) != 2 {
+				t.Errorf("Expected 2 entries, got %d", len(entries))
+			}
 
-		if stoppedEntry.EndTime == nil {
-			t.Error("Expected EndTime to be set")
-		}
-		if stoppedEntry.IsActive() {
-			t.Error("Expected entry to not be active")
-		}
+			if entries[0].Description != "Second session" {
+				t.Errorf("Expected first entry to be 'Second session', got %q", entries[0].Description)
+			}
+			if entries[1].Description != "First session" {
+				t.Errorf("Expected second entry to be 'First session', got %q", entries[1].Description)
+			}
+		})
 	})
 
-	t.Run("fails when no active entry exists", func(t *testing.T) {
-		_, err := repo.StopActiveByTaskID(ctx, task.ID)
+	t.Run("GetTotalTimeByTaskID", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
 
-		if err == nil {
-			t.Error("Expected error when no active entry exists")
-		}
-		if err.Error() != "no active time entry found for task" {
-			t.Errorf("Expected specific error message, got: %v", err)
-		}
-	})
-}
+		ctx := context.Background()
+		task := createTestTask(t, taskRepo)
+
+		t.Run("returns zero duration when no entries exist", func(t *testing.T) {
+			duration, err := repo.GetTotalTimeByTaskID(ctx, task.ID)
+
+			if err != nil {
+				t.Fatalf("Failed to get total time: %v", err)
+			}
+
+			if duration != 0 {
+				t.Errorf("Expected 0 duration, got %v", duration)
+			}
+		})
 
-func TestTimeEntryRepository_GetActiveByTaskID(t *testing.T) {
-	_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
-	defer cleanup()
+		t.Run("calculates total time including active entries", func(t *testing.T) {
+			entry1, err := repo.Start(ctx, task.ID, "Completed work")
+			if err != nil {
+				t.Fatalf("Failed to start first entry: %v", err)
+			}
 
-	ctx := context.Background()
-	task := createTestTask(t, taskRepo)
+			time.Sleep(1010 * time.Millisecond)
+			_, err = repo.Stop(ctx, entry1.ID)
+			if err != nil {
+				t.Fatalf("Failed to stop first entry: %v", err)
+			}
 
-	t.Run("returns nil when no active entry exists", func(t *testing.T) {
-		_, err := repo.GetActiveByTaskID(ctx, task.ID)
+			_, err = repo.Start(ctx, task.ID, "Active work")
+			if err != nil {
+				t.Fatalf("Failed to start second entry: %v", err)
+			}
 
-		if err != sql.ErrNoRows {
-			t.Errorf("Expected sql.ErrNoRows, got: %v", err)
-		}
-	})
+			time.Sleep(1010 * time.Millisecond)
 
-	t.Run("returns active entry when one exists", func(t *testing.T) {
-		startedEntry, err := repo.Start(ctx, task.ID, "Test work")
-		if err != nil {
-			t.Fatalf("Failed to start time tracking: %v", err)
-		}
+			totalTime, err := repo.GetTotalTimeByTaskID(ctx, task.ID)
 
-		activeEntry, err := repo.GetActiveByTaskID(ctx, task.ID)
+			if err != nil {
+				t.Fatalf("Failed to get total time: %v", err)
+			}
 
-		if err != nil {
-			t.Fatalf("Failed to get active entry: %v", err)
-		}
+			if totalTime <= 0 {
+				t.Error("Expected total time to be greater than 0")
+			}
 
-		if activeEntry.ID != startedEntry.ID {
-			t.Errorf("Expected entry ID %d, got %d", startedEntry.ID, activeEntry.ID)
-		}
-		if !activeEntry.IsActive() {
-			t.Error("Expected entry to be active")
-		}
+			if totalTime < 2*time.Second {
+				t.Errorf("Expected total time to be at least 2s, got %v", totalTime)
+			}
+		})
 	})
-}
+
+	t.Run("Delete", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
+
+		ctx := context.Background()
+		task := createTestTask(t, taskRepo)
+
+		t.Run("deletes existing entry", func(t *testing.T) {
+			entry, err := repo.Start(ctx, task.ID, "To be deleted")
+			if err != nil {
+				t.Fatalf("Failed to create entry: %v", err)
+			}
 
-func TestTimeEntryRepository_GetByTaskID(t *testing.T) {
-	_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
-	defer cleanup()
+			err = repo.Delete(ctx, entry.ID)
 
-	ctx := context.Background()
-	task := createTestTask(t, taskRepo)
+			if err != nil {
+				t.Fatalf("Failed to delete entry: %v", err)
+			}
 
-	t.Run("returns empty slice when no entries exist", func(t *testing.T) {
-		entries, err := repo.GetByTaskID(ctx, task.ID)
+			_, err = repo.Get(ctx, entry.ID)
+			if err != sql.ErrNoRows {
+				t.Errorf("Expected entry to be deleted, but got: %v", err)
+			}
+		})
 
-		if err != nil {
-			t.Fatalf("Failed to get entries: %v", err)
-		}
+		t.Run("fails to delete non-existent entry", func(t *testing.T) {
+			err := repo.Delete(ctx, 99999)
 
-		if len(entries) != 0 {
-			t.Errorf("Expected 0 entries, got %d", len(entries))
-		}
+			if err == nil {
+				t.Error("Expected error when deleting non-existent entry")
+			}
+			if err.Error() != "time entry not found" {
+				t.Errorf("Expected specific error message, got: %v", err)
+			}
+		})
 	})
 
-	t.Run("returns all entries for task", func(t *testing.T) {
-		_, err := repo.Start(ctx, task.ID, "First session")
-		if err != nil {
-			t.Fatalf("Failed to start first session: %v", err)
-		}
+	t.Run("GetByDateRange", func(t *testing.T) {
+		_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
+		defer cleanup()
 
-		_, err = repo.StopActiveByTaskID(ctx, task.ID)
-		if err != nil {
-			t.Fatalf("Failed to stop first session: %v", err)
-		}
+		ctx := context.Background()
 
-		_, err = repo.Start(ctx, task.ID, "Second session")
-		if err != nil {
-			t.Fatalf("Failed to start second session: %v", err)
-		}
+		t.Run("returns empty slice when no entries in range", func(t *testing.T) {
+			start := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+			end := time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC)
 
-		entries, err := repo.GetByTaskID(ctx, task.ID)
+			entries, err := repo.GetByDateRange(ctx, start, end)
 
-		if err != nil {
-			t.Fatalf("Failed to get entries: %v", err)
-		}
+			if err != nil {
+				t.Fatalf("Failed to get entries by date range: %v", err)
+			}
 
-		if len(entries) != 2 {
-			t.Errorf("Expected 2 entries, got %d", len(entries))
-		}
+			if len(entries) != 0 {
+				t.Errorf("Expected 0 entries, got %d", len(entries))
+			}
+		})
 
-		if entries[0].Description != "Second session" {
-			t.Errorf("Expected first entry to be 'Second session', got %q", entries[0].Description)
-		}
-		if entries[1].Description != "First session" {
-			t.Errorf("Expected second entry to be 'First session', got %q", entries[1].Description)
-		}
-	})
-}
+		t.Run("returns entries within date range", func(t *testing.T) {
+			task := createTestTask(t, taskRepo)
 
-func TestTimeEntryRepository_GetTotalTimeByTaskID(t *testing.T) {
-	_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
-	defer cleanup()
+			entry, err := repo.Start(ctx, task.ID, "Test entry")
+			if err != nil {
+				t.Fatalf("Failed to start entry: %v", err)
+			}
 
-	ctx := context.Background()
-	task := createTestTask(t, taskRepo)
+			_, err = repo.Stop(ctx, entry.ID)
+			if err != nil {
+				t.Fatalf("Failed to stop entry: %v", err)
+			}
 
-	t.Run("returns zero duration when no entries exist", func(t *testing.T) {
-		duration, err := repo.GetTotalTimeByTaskID(ctx, task.ID)
+			now := time.Now()
+			start := now.Add(-time.Hour)
+			end := now.Add(time.Hour)
 
-		if err != nil {
-			t.Fatalf("Failed to get total time: %v", err)
-		}
+			entries, err := repo.GetByDateRange(ctx, start, end)
 
-		if duration != 0 {
-			t.Errorf("Expected 0 duration, got %v", duration)
-		}
-	})
+			if err != nil {
+				t.Fatalf("Failed to get entries by date range: %v", err)
+			}
 
-	t.Run("calculates total time including active entries", func(t *testing.T) {
-		entry1, err := repo.Start(ctx, task.ID, "Completed work")
-		if err != nil {
-			t.Fatalf("Failed to start first entry: %v", err)
-		}
+			found := false
+			for _, e := range entries {
+				if e.Description == "Test entry" {
+					found = true
+					break
+				}
+			}
 
-		time.Sleep(1010 * time.Millisecond)
-		_, err = repo.Stop(ctx, entry1.ID)
-		if err != nil {
-			t.Fatalf("Failed to stop first entry: %v", err)
-		}
+			if !found {
+				t.Error("Expected to find 'Test entry' in results")
+			}
+		})
 
-		_, err = repo.Start(ctx, task.ID, "Active work")
-		if err != nil {
-			t.Fatalf("Failed to start second entry: %v", err)
-		}
+		t.Run("respects date range boundaries", func(t *testing.T) {
+			task := createTestTask(t, taskRepo)
 
-		time.Sleep(1010 * time.Millisecond)
+			entry, err := repo.Start(ctx, task.ID, "Boundary test")
+			if err != nil {
+				t.Fatalf("Failed to start entry: %v", err)
+			}
 
-		totalTime, err := repo.GetTotalTimeByTaskID(ctx, task.ID)
+			_, err = repo.Stop(ctx, entry.ID)
+			if err != nil {
+				t.Fatalf("Failed to stop entry: %v", err)
+			}
 
-		if err != nil {
-			t.Fatalf("Failed to get total time: %v", err)
-		}
+			start := time.Now().Add(time.Hour)
+			end := time.Now().Add(2 * time.Hour)
 
-		if totalTime <= 0 {
-			t.Error("Expected total time to be greater than 0")
-		}
+			entries, err := repo.GetByDateRange(ctx, start, end)
 
-		if totalTime < 2*time.Second {
-			t.Errorf("Expected total time to be at least 2s, got %v", totalTime)
-		}
-	})
-}
+			if err != nil {
+				t.Fatalf("Failed to get entries by date range: %v", err)
+			}
 
-func TestTimeEntryRepository_Delete(t *testing.T) {
-	_, repo, taskRepo, cleanup := setupTimeEntryTestDB(t)
-	defer cleanup()
+			for _, e := range entries {
+				if e.Description == "Boundary test" {
+					t.Error("Should not find 'Boundary test' in future date range")
+				}
+			}
+		})
 
-	ctx := context.Background()
-	task := createTestTask(t, taskRepo)
+		t.Run("handles context cancellation", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
 
-	t.Run("deletes existing entry", func(t *testing.T) {
-		entry, err := repo.Start(ctx, task.ID, "To be deleted")
-		if err != nil {
-			t.Fatalf("Failed to create entry: %v", err)
-		}
+			start := time.Now().AddDate(0, 0, -1)
+			end := time.Now()
 
-		err = repo.Delete(ctx, entry.ID)
+			_, err := repo.GetByDateRange(cancelCtx, start, end)
+			if err == nil {
+				t.Error("Expected error with cancelled context")
+			}
+		})
 
-		if err != nil {
-			t.Fatalf("Failed to delete entry: %v", err)
-		}
+		t.Run("handles invalid date range", func(t *testing.T) {
+			start := time.Now()
+			end := time.Now().AddDate(0, 0, -1)
 
-		_, err = repo.Get(ctx, entry.ID)
-		if err != sql.ErrNoRows {
-			t.Errorf("Expected entry to be deleted, but got: %v", err)
-		}
-	})
+			entries, err := repo.GetByDateRange(ctx, start, end)
 
-	t.Run("fails to delete non-existent entry", func(t *testing.T) {
-		err := repo.Delete(ctx, 99999)
+			if err != nil {
+				t.Fatalf("Unexpected error with invalid date range: %v", err)
+			}
 
-		if err == nil {
-			t.Error("Expected error when deleting non-existent entry")
-		}
-		if err.Error() != "time entry not found" {
-			t.Errorf("Expected specific error message, got: %v", err)
-		}
+			if len(entries) != 0 {
+				t.Errorf("Expected 0 entries with invalid range, got %d", len(entries))
+			}
+		})
 	})
 }

internal/repo/tv_repository_test.go

···
 				t.Errorf("Expected 3 TV shows with rating >= 8.0, got %d", count)
 			}
 		})
+
+		t.Run("Count with context cancellation", func(t *testing.T) {
+			cancelCtx, cancel := context.WithCancel(ctx)
+			cancel()
+
+			_, err := repo.Count(cancelCtx, TVListOptions{})
+			if err == nil {
+				t.Error("Expected error with cancelled context")
+			}
+		})
 	})
 }