refactor: test utility cleanup & query builders

codecov.yml

···
   - "**/testdata/**"
   - "**/vendor/**"
   - "internal/**/test_utilities.go"
+  - "internal/handlers/handler_test_suite.go"

internal/articles/parser_test.go

···
 	"github.com/stormlightlabs/noteleaf/internal/models"
 )
 
+func newServerWithHtml(h string) *httptest.Server {
+	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(h))
+	}))
+}
+
 // ExampleParser_Convert demonstrates parsing a local HTML file using Wikipedia rules.
 func ExampleParser_Convert() {
 	parser, err := NewArticleParser(http.DefaultClient)
···
 			</body>
 		</html>`
 
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.WriteHeader(http.StatusOK)
-			w.Write([]byte(wikipediaHTML))
-		}))
+		server := newServerWithHtml(wikipediaHTML)
 		defer server.Close()
 
 		// Create a custom parser with localhost rule for testing
···
 			</body>
 		</html>`
 
-		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.WriteHeader(http.StatusOK)
-			w.Write([]byte(contentHTML))
-		}))
+		server := newServerWithHtml(contentHTML)
 		defer server.Close()
 
-		// Create a custom parser with arXiv-like rule for testing
 		parser, err := NewArticleParser(server.Client())
 		if err != nil {
 			t.Fatalf("Failed to create parser: %v", err)

internal/handlers/articles_test.go

···
 			err := helper.List(ctx, "", "", 0)
 			Expect.AssertNoError(t, err, "List should succeed")
 
-			Expect.AssertArticleExists(t, helper, id1)
-			Expect.AssertArticleExists(t, helper, id2)
+			AssertExists(t, helper.repos.Articles.Get, id1, "article")
+			AssertExists(t, helper.repos.Articles.Get, id2, "article")
 		})
 
 		t.Run("lists with title filter", func(t *testing.T) {
···
 			helper := NewArticleTestHelper(t)
 			ctx := context.Background()
 			id := helper.CreateTestArticle(t, "https://example.com/remove", "Remove Test", "Author", "2024-01-01")
-			Expect.AssertArticleExists(t, helper, id)
+			AssertExists(t, helper.repos.Articles.Get, id, "article")
 
 			err := helper.Remove(ctx, id)
 			Expect.AssertNoError(t, err, "Remove should succeed")
-			Expect.AssertArticleNotExists(t, helper, id)
+			AssertNotExists(t, helper.repos.Articles.Get, id, "article")
 		})
 
 		t.Run("handles non-existent article", func(t *testing.T) {
···
 		err = helper.Remove(ctx, articleID)
 		Expect.AssertNoError(t, err, "Remove should succeed in integration test")
 
-		Expect.AssertArticleNotExists(t, helper, articleID)
+		AssertNotExists(t, helper.repos.Articles.Get, articleID, "article")
 	})
 }

internal/handlers/behaviors.go

···
+package handlers
+
+import (
+	"context"
+	"io"
+)
+
+// Core Handler Behavior Interfaces
+//
+// These interfaces define composable behaviors that handlers can implement
+// to provide consistent functionality across different domain handlers.
+
+// Closeable manages resource cleanup for handlers
+//
+// Implemented by all handlers that manage database connections, services, or other resources
+type Closeable interface {
+	Close() error
+}
+
+// Viewable retrieves and displays a single item by ID (int64)
+//
+// Implemented by handlers that support viewing individual items with integer IDs
+type Viewable interface {
+	View(ctx context.Context, id int64) error
+}
+
+// ViewableByString retrieves and displays a single item by ID (string)
+//
+// Implemented by handlers that support viewing items with string IDs
+type ViewableByString interface {
+	View(ctx context.Context, id string) error
+}
+
+// Note: Listable already defined in media_handler.go
+// We reuse that interface: List(ctx context.Context, status string) error
+
+// Removable handles item removal (already defined in media_handler.go)
+// We extend it with type-specific variants for consistency
+
+// RemovableByInt64 handles removal by integer ID
+type RemovableByInt64 interface {
+	Remove(ctx context.Context, id int64) error
+}
+
+// DeletableByInt64 handles deletion by integer ID
+type DeletableByInt64 interface {
+	Delete(ctx context.Context, id int64) error
+}
+
+// InputReader provides testable input handling
+//
+// Handlers implementing this interface can have their input source replaced for testing
+type InputReader interface {
+	SetInputReader(reader io.Reader)
+}
+
+// InteractiveSupport indicates handler support for interactive/TUI modes
+//
+// Handlers can check if they're running in test mode and adjust behavior accordingly
+type InteractiveSupport interface {
+	SupportsInteractive() bool
+}
+
+// Renderable provides content rendering capabilities
+//
+// Implemented by handlers that need to render markdown or other formatted content
+type Renderable interface {
+	Render(content string) (string, error)
+}
+
+// MediaHandler is already defined in media_handler.go
+// It composes: Searchable, Listable, StatusUpdatable, Removable, InputReader, Closeable
+
+// Compile-time interface checks - verifying shared behaviors across handlers
+//
+// Note: Handlers have domain-specific List() signatures, so we cannot enforce
+// a common Listable interface. Each handler's List method is tailored to its domain:
+// - ArticleHandler: List(ctx, query, author, limit)
+// - NoteHandler: List(ctx, static, showArchived, tags)
+// - TaskHandler: List(ctx, static, showAll, status, priority, project, context)
+// - Media handlers: List(ctx, status) via MediaHandler.Listable
+var (
+	// All handlers implement Closeable for resource cleanup
+	_ Closeable = (*ArticleHandler)(nil)
+	_ Closeable = (*NoteHandler)(nil)
+	_ Closeable = (*TaskHandler)(nil)
+	_ Closeable = (*BookHandler)(nil)
+	_ Closeable = (*MovieHandler)(nil)
+	_ Closeable = (*TVHandler)(nil)
+
+	// Handlers with View by ID (int64)
+	_ Viewable = (*ArticleHandler)(nil)
+	_ Viewable = (*MovieHandler)(nil)
+
+	// Handlers with Remove by ID (int64)
+	_ RemovableByInt64 = (*ArticleHandler)(nil)
+
+	// Handlers with Delete by ID (int64)
+	_ DeletableByInt64 = (*NoteHandler)(nil)
+
+	// Media handlers implement MediaHandler (defined in media_handler.go)
+	_ MediaHandler = (*BookHandler)(nil)
+	_ MediaHandler = (*MovieHandler)(nil)
+	_ MediaHandler = (*TVHandler)(nil)
+
+	// Media handlers support input reading for testing
+	_ InputReader = (*BookHandler)(nil)
+	_ InputReader = (*MovieHandler)(nil)
+	_ InputReader = (*TVHandler)(nil)
+)

internal/handlers/books.go

···
 	reader  io.Reader
 }
 
-// Ensure BookHandler implements MediaHandler interface
 var _ MediaHandler = (*BookHandler)(nil)
 
 // NewBookHandler creates a new book handler

internal/handlers/books_test.go

···
 import (
 	"context"
 	"os"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"testing"
···
 	"github.com/stormlightlabs/noteleaf/internal/services"
 )
 
-func setupBookTest(t *testing.T) (string, func()) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-book-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-
-	oldNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
-	oldNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
-	os.Setenv("NOTELEAF_CONFIG", filepath.Join(tempDir, ".noteleaf.conf.toml"))
-	os.Setenv("NOTELEAF_DATA_DIR", tempDir)
-
-	cleanup := func() {
-		os.Setenv("NOTELEAF_CONFIG", oldNoteleafConfig)
-		os.Setenv("NOTELEAF_DATA_DIR", oldNoteleafDataDir)
-		os.RemoveAll(tempDir)
-	}
-
-	ctx := context.Background()
-	err = Setup(ctx, []string{})
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to setup database: %v", err)
-	}
-
-	return tempDir, cleanup
-}
+// setupBookTest removed - use NewHandlerTestSuite(t) instead
 
 func createTestBook(t *testing.T, handler *BookHandler, ctx context.Context) *models.Book {
 	t.Helper()
···
 func TestBookHandler(t *testing.T) {
 	t.Run("New", func(t *testing.T) {
 		t.Run("creates handler successfully", func(t *testing.T) {
-			_, cleanup := setupBookTest(t)
-			defer cleanup()
+			_ = NewHandlerTestSuite(t)
 
 			handler, err := NewBookHandler()
 			if err != nil {
···
 	})
 
 	t.Run("BookHandler instance methods", func(t *testing.T) {
-		_, cleanup := setupBookTest(t)
-		defer cleanup()
+		_ = NewHandlerTestSuite(t)
 
 		handler, err := NewBookHandler()
 		if err != nil {
···
 			})
 
 			t.Run("handles interactive mode", func(t *testing.T) {
-				_, cleanup := setupBookTest(t)
-				defer cleanup()
+				_ = NewHandlerTestSuite(t)
 
 				handler, err := NewBookHandler()
 				if err != nil {
···
 			})
 
 			t.Run("interactive mode path", func(t *testing.T) {
-				_, cleanup := setupBookTest(t)
-				defer cleanup()
+				_ = NewHandlerTestSuite(t)
 
 				handler, err := NewBookHandler()
 				if err != nil {
···
 			})
 
 			t.Run("progress", func(t *testing.T) {
-				_, cleanup := setupBookTest(t)
-				defer cleanup()
+				_ = NewHandlerTestSuite(t)
 
 				ctx := context.Background()
 
···
 
 	t.Run("Close", func(t *testing.T) {
 		t.Run("closes handler resources", func(t *testing.T) {
-			_, cleanup := setupBookTest(t)
-			defer cleanup()
+			_ = NewHandlerTestSuite(t)
 
 			handler, err := NewBookHandler()
 			if err != nil {
···
 		})
 
 		t.Run("handles service close gracefully", func(t *testing.T) {
-			_, cleanup := setupBookTest(t)
-			defer cleanup()
+			_ = NewHandlerTestSuite(t)
 
 			handler, err := NewBookHandler()
 			if err != nil {
···
 	})
 
 	t.Run("Print", func(t *testing.T) {
-		_, cleanup := setupBookTest(t)
-		defer cleanup()
+		_ = NewHandlerTestSuite(t)
 
 		handler, err := NewBookHandler()
 		if err != nil {
···
 
 	t.Run("Integration", func(t *testing.T) {
 		t.Run("full book lifecycle", func(t *testing.T) {
-			_, cleanup := setupBookTest(t)
-			defer cleanup()
+			_ = NewHandlerTestSuite(t)
 
 			ctx := context.Background()
 
···
 		})
 
 		t.Run("concurrent book operations", func(t *testing.T) {
-			_, cleanup := setupBookTest(t)
-			defer cleanup()
+			_ = NewHandlerTestSuite(t)
 
 			ctx := context.Background()
 
···
 		})
 	})
 }
+
+// TestBookHandlerWithSuite demonstrates using HandlerTestSuite for cleaner tests
+func TestBookHandlerWithSuite(t *testing.T) {
+	// Example: Using HandlerTestSuite for lifecycle testing
+	t.Run("Lifecycle", func(t *testing.T) {
+		suite := NewMediaHandlerTestSuite(t)
+
+		handler, err := NewBookHandler()
+		suite.AssertNoError(err, "NewBookHandler")
+		defer handler.Close()
+
+		// Test basic behaviors using reusable patterns
+		InputReaderTest(t, handler)
+	})
+
+	// Example: Using generic CreateHandler
+	t.Run("GenericHandlerCreation", func(t *testing.T) {
+		_ = NewHandlerTestSuite(t)
+
+		// Generic CreateHandler replaces CreateBookHandler
+		handler := CreateHandler(t, NewBookHandler)
+
+		// Handler automatically cleaned up via t.Cleanup
+		_ = handler
+	})
+
+	// Example: Using HandlerTestSuite for media operations
+	t.Run("MediaOperations", func(t *testing.T) {
+		suite := NewMediaHandlerTestSuite(t)
+
+		handler, err := NewBookHandler()
+		suite.AssertNoError(err, "NewBookHandler")
+		defer handler.Close()
+
+		// Create a test book first
+		book := &models.Book{
+			Title:  "Suite Test Book",
+			Author: "Suite Test Author",
+			Status: "queued",
+			Added:  time.Now(),
+		}
+		id, err := handler.repos.Books.Create(suite.Context(), book)
+		suite.AssertNoError(err, "Create test book")
+
+		// Test list operation
+		suite.TestList(handler, "")
+
+		// Test status update
+		suite.TestUpdateStatus(handler, strconv.FormatInt(id, 10), "reading", true)
+
+		// Test invalid status update
+		suite.TestUpdateStatus(handler, strconv.FormatInt(id, 10), "invalid", false)
+
+		// Test remove operation
+		suite.TestRemove(handler, strconv.FormatInt(id, 10), true)
+	})
+
+	// Example: Generic lifecycle test
+	t.Run("GenericLifecycle", func(t *testing.T) {
+		_ = NewHandlerTestSuite(t)
+
+		// Demonstrates using generic HandlerLifecycleTest
+		HandlerLifecycleTest(t, NewBookHandler)
+	})
+}

internal/handlers/config.go

···
 	return nil
 }
 
-func (h *ConfigHandler) getConfigValue(key string) (interface{}, error) {
+func (h *ConfigHandler) getConfigValue(key string) (any, error) {
 	v := reflect.ValueOf(*h.config)
 	t := reflect.TypeOf(*h.config)
 

internal/handlers/handler_test_suite.go

···
+package handlers
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+)
+
+// HandlerTestSuite provides reusable test infrastructure for handlers
+type HandlerTestSuite struct {
+	t       *testing.T
+	tempDir string
+	ctx     context.Context
+	cleanup func()
+}
+
+// NewHandlerTestSuite creates a new test suite with isolated environment
+func NewHandlerTestSuite(t *testing.T) *HandlerTestSuite {
+	t.Helper()
+
+	tempDir, err := os.MkdirTemp("", "noteleaf-handler-suite-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+
+	oldNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
+	oldNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
+	os.Setenv("NOTELEAF_CONFIG", filepath.Join(tempDir, ".noteleaf.conf.toml"))
+	os.Setenv("NOTELEAF_DATA_DIR", tempDir)
+
+	cleanup := func() {
+		os.Setenv("NOTELEAF_CONFIG", oldNoteleafConfig)
+		os.Setenv("NOTELEAF_DATA_DIR", oldNoteleafDataDir)
+		os.RemoveAll(tempDir)
+	}
+
+	ctx := context.Background()
+	if err := Setup(ctx, []string{}); err != nil {
+		cleanup()
+		t.Fatalf("Failed to setup database: %v", err)
+	}
+
+	suite := &HandlerTestSuite{
+		t:       t,
+		tempDir: tempDir,
+		ctx:     ctx,
+		cleanup: cleanup,
+	}
+
+	t.Cleanup(suite.Cleanup)
+
+	return suite
+}
+
+// Context returns the test context
+func (s *HandlerTestSuite) Context() context.Context {
+	return s.ctx
+}
+
+// TempDir returns the temporary directory for this test
+func (s *HandlerTestSuite) TempDir() string {
+	return s.tempDir
+}
+
+// Cleanup performs test cleanup
+func (s *HandlerTestSuite) Cleanup() {
+	if s.cleanup != nil {
+		s.cleanup()
+	}
+}
+
+// AssertNoError fails the test if err is not nil
+func (s *HandlerTestSuite) AssertNoError(err error, msg string) {
+	s.t.Helper()
+	if err != nil {
+		s.t.Fatalf("%s: unexpected error: %v", msg, err)
+	}
+}
+
+// AssertError fails the test if err is nil
+func (s *HandlerTestSuite) AssertError(err error, msg string) {
+	s.t.Helper()
+	if err == nil {
+		s.t.Fatalf("%s: expected error but got nil", msg)
+	}
+}
+
+// CreateTestDatabase creates an isolated test database
+func (s *HandlerTestSuite) CreateTestDatabase() (*store.Database, *repo.Repositories, error) {
+	db, err := store.NewDatabase()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	repos := repo.NewRepositories(db.DB)
+	return db, repos, nil
+}
+
+// HandlerLifecycleTest tests basic handler lifecycle (create, close)
+//
+// This is a reusable test pattern for any handler implementing Closeable
+func HandlerLifecycleTest[H Closeable](t *testing.T, createHandler func() (H, error)) {
+	t.Helper()
+
+	t.Run("creates handler successfully", func(t *testing.T) {
+		handler, err := createHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+
+		if err := handler.Close(); err != nil {
+			t.Errorf("Close failed: %v", err)
+		}
+	})
+
+	t.Run("handles close gracefully", func(t *testing.T) {
+		handler, err := createHandler()
+		if err != nil {
+			t.Fatalf("Failed to create handler: %v", err)
+		}
+
+		if err := handler.Close(); err != nil {
+			t.Errorf("First close should succeed: %v", err)
+		}
+
+		_ = handler.Close()
+	})
+}
+
+// ViewableTest tests View functionality for handlers
+func ViewableTest[H Viewable](t *testing.T, handler H, validID, invalidID int64) {
+	t.Helper()
+	ctx := context.Background()
+
+	t.Run("views valid item", func(t *testing.T) {
+		err := handler.View(ctx, validID)
+		if err != nil {
+			t.Errorf("View with valid ID should succeed: %v", err)
+		}
+	})
+
+	t.Run("fails with invalid ID", func(t *testing.T) {
+		err := handler.View(ctx, invalidID)
+		if err == nil {
+			t.Error("View with invalid ID should fail")
+		}
+	})
+}
+
+// InputReaderTest tests SetInputReader functionality
+func InputReaderTest[H InputReader](t *testing.T, handler H) {
+	t.Helper()
+
+	t.Run("sets input reader", func(t *testing.T) {
+		sim := NewInputSimulator("test")
+		handler.SetInputReader(sim)
+		// If we get here without panic, the test passes
+	})
+
+	t.Run("handles nil reader", func(t *testing.T) {
+		handler.SetInputReader(nil)
+		// If we get here without panic, the test passes
+	})
+}
+
+// MediaHandlerTestSuite provides specialized test utilities for media handlers
+type MediaHandlerTestSuite struct {
+	*HandlerTestSuite
+}
+
+// NewMediaHandlerTestSuite creates a test suite for media handlers
+func NewMediaHandlerTestSuite(t *testing.T) *MediaHandlerTestSuite {
+	return &MediaHandlerTestSuite{
+		HandlerTestSuite: NewHandlerTestSuite(t),
+	}
+}
+
+// TestSearchAndAdd is a reusable test pattern for SearchAndAdd operations
+func (s *MediaHandlerTestSuite) TestSearchAndAdd(handler MediaHandler, query string, shouldSucceed bool) {
+	s.t.Helper()
+
+	err := handler.SearchAndAdd(s.ctx, query, false)
+	if shouldSucceed && err != nil {
+		s.t.Errorf("SearchAndAdd should succeed: %v", err)
+	}
+	if !shouldSucceed && err == nil {
+		s.t.Error("SearchAndAdd should fail")
+	}
+}
+
+// TestList is a reusable test pattern for List operations
+func (s *MediaHandlerTestSuite) TestList(handler MediaHandler, status string) {
+	s.t.Helper()
+
+	err := handler.List(s.ctx, status)
+	if err != nil {
+		s.t.Errorf("List should succeed: %v", err)
+	}
+}
+
+// TestUpdateStatus is a reusable test pattern for UpdateStatus operations
+func (s *MediaHandlerTestSuite) TestUpdateStatus(handler MediaHandler, id, status string, shouldSucceed bool) {
+	s.t.Helper()
+
+	err := handler.UpdateStatus(s.ctx, id, status)
+	if shouldSucceed && err != nil {
+		s.t.Errorf("UpdateStatus should succeed: %v", err)
+	}
+	if !shouldSucceed && err == nil {
+		s.t.Error("UpdateStatus should fail")
+	}
+}
+
+// TestRemove is a reusable test pattern for Remove operations
+func (s *MediaHandlerTestSuite) TestRemove(handler MediaHandler, id string, shouldSucceed bool) {
+	s.t.Helper()
+
+	err := handler.Remove(s.ctx, id)
+	if shouldSucceed && err != nil {
+		s.t.Errorf("Remove should succeed: %v", err)
+	}
+	if !shouldSucceed && err == nil {
+		s.t.Error("Remove should fail")
+	}
+}
+
+// CreateHandler creates a handler with automatic cleanup
+func CreateHandler[H Closeable](t *testing.T, factory func() (H, error)) H {
+	t.Helper()
+
+	handler, err := factory()
+	if err != nil {
+		t.Fatalf("Failed to create handler: %v", err)
+	}
+
+	t.Cleanup(func() {
+		handler.Close()
+	})
+
+	return handler
+}
+
+// AssertExists verifies that an item exists using a getter
+func AssertExists[T any](t *testing.T, getter func(context.Context, int64) (*T, error), id int64, itemType string) {
+	t.Helper()
+
+	ctx := context.Background()
+	_, err := getter(ctx, id)
+	if err != nil {
+		t.Errorf("%s %d should exist but got error: %v", itemType, id, err)
+	}
+}
+
+// AssertNotExists verifies that an item does not exist using a getter
+func AssertNotExists[T any](t *testing.T, getter func(context.Context, int64) (*T, error), id int64, itemType string) {
+	t.Helper()
+
+	ctx := context.Background()
+	_, err := getter(ctx, id)
+	if err == nil {
+		t.Errorf("%s %d should not exist but was found", itemType, id)
+	}
+}

internal/handlers/handlers_test.go

···
 	return tempDir
 }
 
+func getDbPath(config *store.Config) string {
+	var dbPath string
+	if config.DatabasePath != "" {
+		dbPath = config.DatabasePath
+	} else if config.DataDir != "" {
+		dbPath = filepath.Join(config.DataDir, "noteleaf.db")
+	} else {
+		dataDir, _ := store.GetDataDir()
+		dbPath = filepath.Join(dataDir, "noteleaf.db")
+	}
+
+	return dbPath
+}
+
 func TestSetup(t *testing.T) {
 	t.Run("creates database and config files", func(t *testing.T) {
 		_ = createTestDir(t)
···
 			t.Errorf("Setup failed: %v", err)
 		}
 
-		// Determine database path using the same logic as Setup
 		config, err := store.LoadConfig()
 		if err != nil {
 			t.Fatalf("Failed to load config: %v", err)
 		}
 
-		var dbPath string
-		if config.DatabasePath != "" {
-			dbPath = config.DatabasePath
-		} else if config.DataDir != "" {
-			dbPath = filepath.Join(config.DataDir, "noteleaf.db")
-		} else {
-			dataDir, _ := store.GetDataDir()
-			dbPath = filepath.Join(dataDir, "noteleaf.db")
-		}
+		dbPath := getDbPath(config)
 
 		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
 			t.Error("Database file was not created")
···
 			t.Fatalf("Failed to load config: %v", err)
 		}
 
-		var dbPath string
-		if config.DatabasePath != "" {
-			dbPath = config.DatabasePath
-		} else if config.DataDir != "" {
-			dbPath = filepath.Join(config.DataDir, "noteleaf.db")
-		} else {
-			dataDir, _ := store.GetDataDir()
-			dbPath = filepath.Join(dataDir, "noteleaf.db")
-		}
+		dbPath := getDbPath(config)
 
 		configPath, err := store.GetConfigPath()
 		if err != nil {
···
 			t.Fatalf("Failed to load config: %v", err)
 		}
 
-		var dbPath string
-		if config.DatabasePath != "" {
-			dbPath = config.DatabasePath
-		} else if config.DataDir != "" {
-			dbPath = filepath.Join(config.DataDir, "noteleaf.db")
-		} else {
-			dataDir, _ := store.GetDataDir()
-			dbPath = filepath.Join(dataDir, "noteleaf.db")
-		}
+		dbPath := getDbPath(config)
 
 		os.Remove(dbPath)
 
···
 		}
 
 		config, _ := store.LoadConfig()
-		var dbPath string
-		if config.DatabasePath != "" {
-			dbPath = config.DatabasePath
-		} else if config.DataDir != "" {
-			dbPath = filepath.Join(config.DataDir, "noteleaf.db")
-		} else {
-			dataDir, _ := store.GetDataDir()
-			dbPath = filepath.Join(dataDir, "noteleaf.db")
-		}
+		dbPath := getDbPath(config)
 
 		if _, err := os.Stat(dbPath); os.IsNotExist(err) {
 			t.Error("Database should exist after setup")

internal/handlers/media_handler.go

···
 	"io"
 )
 
-// MediaHandler defines common operations for media handlers
-//
-// This interface captures the shared behavior across media handlers for polymorphic handling of different media types.
+// MediaHandler defines common operations for media handlers and captures the shared behavior across media handlers for polymorphic handling of different media types.
 type MediaHandler interface {
-	// SearchAndAdd searches for media and allows user to select and add to queue
-	SearchAndAdd(ctx context.Context, query string, interactive bool) error
-	// List lists all media items with optional status filtering
-	List(ctx context.Context, status string) error
-	// UpdateStatus changes the status of a media item
-	UpdateStatus(ctx context.Context, id, status string) error
-	// Remove removes a media item from the queue
-	Remove(ctx context.Context, id string) error
-	// SetInputReader sets the input reader for interactive prompts
-	SetInputReader(reader io.Reader)
-	// Close cleans up resources
-	Close() error
+	SearchAndAdd(ctx context.Context, query string, interactive bool) error // SearchAndAdd searches for media and allows user to select and add to queue
+	List(ctx context.Context, status string) error                          // List lists all media items with optional status filtering
+	UpdateStatus(ctx context.Context, id, status string) error              // UpdateStatus changes the status of a media item
+	Remove(ctx context.Context, id string) error                            // Remove removes a media item from the queue
+	SetInputReader(reader io.Reader)                                        // SetInputReader sets the input reader for interactive prompts
+	Close() error                                                           // Close cleans up resources
 }
 
 // Searchable defines search behavior for media handlers

internal/handlers/notes_test.go

···
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
-func setupNoteTest(t *testing.T) (string, func()) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-note-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-
-	oldNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
-	oldNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
-	os.Setenv("NOTELEAF_CONFIG", filepath.Join(tempDir, ".noteleaf.conf.toml"))
-	os.Setenv("NOTELEAF_DATA_DIR", tempDir)
-
-	cleanup := func() {
-		os.Setenv("NOTELEAF_CONFIG", oldNoteleafConfig)
-		os.Setenv("NOTELEAF_DATA_DIR", oldNoteleafDataDir)
-		os.RemoveAll(tempDir)
-	}
-
-	ctx := context.Background()
-	err = Setup(ctx, []string{})
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to setup database: %v", err)
-	}
-
-	return tempDir, cleanup
-}
+// setupNoteTest removed - use NewHandlerTestSuite(t) instead
 
 func createTestMarkdownFile(t *testing.T, dir, filename, content string) string {
 	filePath := filepath.Join(dir, filename)
···
 }
 
 func TestNoteHandler(t *testing.T) {
-	tempDir, cleanup := setupNoteTest(t)
-	defer cleanup()
+	suite := NewHandlerTestSuite(t)
 
 	handler, err := NewNoteHandler()
 	if err != nil {
···
 <!-- tags: personal, work -->
 
 This is the content of my note.`
-			filePath := createTestMarkdownFile(t, tempDir, "test.md", content)
+			filePath := createTestMarkdownFile(t, suite.TempDir(), "test.md", content)
 
 			err := handler.Create(ctx, "", "", filePath, false)
 			Expect.AssertNoError(t, err, "Create from file should succeed")
···
 					err := handler.Edit(ctx, noteID)
 
 					Expect.AssertNoError(t, err, "Edit should succeed")
-					Expect.AssertNoteExists(t, handler, noteID)
+					AssertExists(t, handler.repos.Notes.Get, noteID, "note")
 				})
 
 				t.Run("handles no changes made", func(t *testing.T) {
···
 		})
 
 		t.Run("handles empty note list", func(t *testing.T) {
-			_, emptyCleanup := setupNoteTest(t)
-			defer emptyCleanup()
+			_ = NewHandlerTestSuite(t)
 
 			emptyHandler, err := NewNoteHandler()
 			if err != nil {
···
 		})
 
 		t.Run("interactive mode path", func(t *testing.T) {
-			_, cleanup := setupNoteTest(t)
-			defer cleanup()
+			_ = NewHandlerTestSuite(t)
 
 			testHandler, err := NewNoteHandler()
 			if err != nil {
···
 		})
 
 		t.Run("interactive mode path with filters", func(t *testing.T) {
-			_, cleanup := setupNoteTest(t)
-			defer cleanup()
+			_ = NewHandlerTestSuite(t)
 
 			testHandler, err := NewNoteHandler()
 			if err != nil {
···
 		})
 
 		t.Run("deletes note with file path", func(t *testing.T) {
-			testTempDir, testCleanup := setupNoteTest(t)
-			defer testCleanup()
+			testSuite := NewHandlerTestSuite(t)
 
 			testHandler, err := NewNoteHandler()
 			if err != nil {
···
 			}
 			defer testHandler.Close()
 
-			filePath := createTestMarkdownFile(t, testTempDir, "delete-test.md", "# Test Note\n\nTest content")
+			filePath := createTestMarkdownFile(t, testSuite.TempDir(), "delete-test.md", "# Test Note\n\nTest content")
 
 			err = testHandler.Create(ctx, "", "", filePath, false)
 			if err != nil {

internal/handlers/seed_test.go

···
 import (
 	"context"
 	"os"
-	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"
···
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
-func setupSeedTest(t *testing.T) (string, func()) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-seed-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-
-	oldNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
-	oldNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
-	os.Setenv("NOTELEAF_CONFIG", filepath.Join(tempDir, ".noteleaf.conf.toml"))
-	os.Setenv("NOTELEAF_DATA_DIR", tempDir)
-
-	cleanup := func() {
-		os.Setenv("NOTELEAF_CONFIG", oldNoteleafConfig)
-		os.Setenv("NOTELEAF_DATA_DIR", oldNoteleafDataDir)
-		os.RemoveAll(tempDir)
-	}
-
-	ctx := context.Background()
-	err = Setup(ctx, []string{})
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to setup database: %v", err)
-	}
-
-	return tempDir, cleanup
-}
+// setupSeedTest removed - use NewHandlerTestSuite(t) instead
 
 func countRecords(t *testing.T, db *store.Database, table string) int {
 	t.Helper()
···
 }
 
 func TestSeedHandler(t *testing.T) {
-	_, cleanup := setupSeedTest(t)
-	defer cleanup()
+	_ = NewHandlerTestSuite(t)
 
 	handler, err := NewSeedHandler()
 	if err != nil {

internal/handlers/tasks_test.go

···
 	ctx := context.Background()
 	t.Run("New", func(t *testing.T) {
 		t.Run("creates handler successfully", func(t *testing.T) {
-			_, cleanup := SetupHandlerTest(t)
-			defer cleanup()
+			suite := NewHandlerTestSuite(t)
+			defer suite.cleanup()
 
 			handler, err := NewTaskHandler()
 			if err != nil {
···
 	})
 
 	t.Run("Create", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
-		handler := CreateTaskHandler(t)
+		handler := CreateHandler(t, NewTaskHandler)
 
 		t.Run("creates task successfully", func(t *testing.T) {
 			desc := "Buy groceries and cook dinner"
···
 	})
 
 	t.Run("List", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("Update", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
-
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 		handler, err := NewTaskHandler()
 		if err != nil {
 			t.Fatalf("Failed to create handler: %v", err)
···
 	})
 
 	t.Run("Delete", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
-		handler := CreateTaskHandler(t)
+		handler := CreateHandler(t, NewTaskHandler)
 
 		task := &models.Task{
 			UUID:        uuid.New().String(),
···
 	})
 
 	t.Run("View", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("Done", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("Print", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("ListProjects", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 		})
 
 		t.Run("returns no projects when none exist", func(t *testing.T) {
-			_, cleanup2 := SetupHandlerTest(t)
-			defer cleanup2()
+			suite := NewHandlerTestSuite(t)
+			defer suite.cleanup()
 
 			err := handler.ListProjects(ctx, true)
 			if err != nil {
···
 	})
 
 	t.Run("ListTags", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 		})
 
 		t.Run("returns no tags when none exist", func(t *testing.T) {
-			_, cleanup2 := SetupHandlerTest(t)
-			defer cleanup2()
+			suite := NewHandlerTestSuite(t)
+			defer suite.cleanup()
 
 			err := handler.ListTags(ctx, true)
 			if err != nil {
···
 	})
 
 	t.Run("InteractiveComponentsStatic", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 			})
 
 			t.Run("handles no contexts", func(t *testing.T) {
-				_, cleanup2 := SetupHandlerTest(t)
-				defer cleanup2()
+				suite := NewHandlerTestSuite(t)
+				defer suite.cleanup()
 
 				handler2, err := NewTaskHandler()
 				if err != nil {
···
 	})
 
 	t.Run("ListContexts", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 		})
 
 		t.Run("returns no contexts when none exist", func(t *testing.T) {
-			_, cleanup_ := SetupHandlerTest(t)
-			defer cleanup_()
+			suite := NewHandlerTestSuite(t)
+			defer suite.cleanup()
 
 			handler_, err := NewTaskHandler()
 			if err != nil {
···
 	})
 
 	t.Run("SetRecur", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("ClearRecur", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("ShowRecur", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("AddDep", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("RemoveDep", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("ListDeps", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {
···
 	})
 
 	t.Run("BlockedByDep", func(t *testing.T) {
-		_, cleanup := SetupHandlerTest(t)
-		defer cleanup()
+		suite := NewHandlerTestSuite(t)
+		defer suite.cleanup()
 
 		handler, err := NewTaskHandler()
 		if err != nil {

internal/handlers/test_utilities.go

···
 )
 
 // HandlerTestHelper wraps NoteHandler with test-specific functionality
+//
+// Uses HandlerTestSuite internally to avoid code duplication
 type HandlerTestHelper struct {
 	*NoteHandler
-	tempDir string
-	cleanup func()
+	suite *HandlerTestSuite
 }
 
 // NewHandlerTestHelper creates a NoteHandler with isolated test database
 func NewHandlerTestHelper(t *testing.T) *HandlerTestHelper {
-	tempDir, err := os.MkdirTemp("", "noteleaf-handler-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-
-	oldNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
-	oldNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
-	os.Setenv("NOTELEAF_CONFIG", filepath.Join(tempDir, ".noteleaf.conf.toml"))
-	os.Setenv("NOTELEAF_DATA_DIR", tempDir)
-
-	cleanup := func() {
-		os.Setenv("NOTELEAF_CONFIG", oldNoteleafConfig)
-		os.Setenv("NOTELEAF_DATA_DIR", oldNoteleafDataDir)
-		os.RemoveAll(tempDir)
-	}
-
-	ctx := context.Background()
-	err = Setup(ctx, []string{})
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to setup database: %v", err)
-	}
+	suite := NewHandlerTestSuite(t)
 
 	handler, err := NewNoteHandler()
 	if err != nil {
-		cleanup()
 		t.Fatalf("Failed to create note handler: %v", err)
 	}
 
 	testHandler := &HandlerTestHelper{
 		NoteHandler: handler,
-		tempDir:     tempDir,
-		cleanup:     cleanup,
+		suite:       suite,
 	}
 
 	t.Cleanup(func() {
 		testHandler.Close()
-		testHandler.cleanup()
 	})
 
 	return testHandler
···
 
 // CreateTestFile creates a temporary markdown file with content
 func (th *HandlerTestHelper) CreateTestFile(t *testing.T, filename, content string) string {
-	filePath := filepath.Join(th.tempDir, filename)
+	filePath := filepath.Join(th.suite.TempDir(), filename)
 	err := os.WriteFile(filePath, []byte(content), 0644)
 	if err != nil {
 		t.Fatalf("Failed to create test file: %v", err)
···
 	}
 }
 
-// AssertNoteExists checks that a note exists in the database
-func (ah AssertionHelpers) AssertNoteExists(t *testing.T, handler *HandlerTestHelper, id int64) {
-	t.Helper()
-	ctx := context.Background()
-	_, err := handler.repos.Notes.Get(ctx, id)
-	if err != nil {
-		t.Errorf("Note %d should exist but got error: %v", id, err)
-	}
-}
-
-// AssertNoteNotExists checks that a note does not exist in the database
-func (ah AssertionHelpers) AssertNoteNotExists(t *testing.T, handler *HandlerTestHelper, id int64) {
-	t.Helper()
-	ctx := context.Background()
-	_, err := handler.repos.Notes.Get(ctx, id)
-	if err == nil {
-		t.Errorf("Note %d should not exist but was found", id)
-	}
-}
-
-// AssertArticleExists checks that an article exists in the database
-func (ah AssertionHelpers) AssertArticleExists(t *testing.T, handler *ArticleTestHelper, id int64) {
-	t.Helper()
-	ctx := context.Background()
-	_, err := handler.repos.Articles.Get(ctx, id)
-	if err != nil {
-		t.Errorf("Article %d should exist but got error: %v", id, err)
-	}
-}
-
-// AssertArticleNotExists checks that an article does not exist in the database
-func (ah AssertionHelpers) AssertArticleNotExists(t *testing.T, handler *ArticleTestHelper, id int64) {
-	t.Helper()
-	ctx := context.Background()
-	_, err := handler.repos.Articles.Get(ctx, id)
-	if err == nil {
-		t.Errorf("Article %d should not exist but was found", id)
-	}
-}
-
 // EnvironmentTestHelper provides environment manipulation utilities for testing
+//
+// Use this for tests requiring fine-grained environment control beyond HandlerTestSuite.
+// Examples: testing missing EDITOR, invalid PATH, corrupt TMPDIR, etc.
 type EnvironmentTestHelper struct {
 	originalVars map[string]string
 }
···
 // ArticleTestHelper wraps ArticleHandler with test-specific functionality
 type ArticleTestHelper struct {
 	*ArticleHandler
-	tempDir string
-	cleanup func()
+	suite *HandlerTestSuite
 }
 
 // NewArticleTestHelper creates an ArticleHandler with isolated test database
 func NewArticleTestHelper(t *testing.T) *ArticleTestHelper {
-	tempDir, err := os.MkdirTemp("", "noteleaf-article-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-
-	oldNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
-	oldNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
-	os.Setenv("NOTELEAF_CONFIG", filepath.Join(tempDir, ".noteleaf.conf.toml"))
-	os.Setenv("NOTELEAF_DATA_DIR", tempDir)
-
-	cleanup := func() {
-		os.Setenv("NOTELEAF_CONFIG", oldNoteleafConfig)
-		os.Setenv("NOTELEAF_DATA_DIR", oldNoteleafDataDir)
-		os.RemoveAll(tempDir)
-	}
-
-	ctx := context.Background()
-	err = Setup(ctx, []string{})
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to setup database: %v", err)
-	}
+	suite := NewHandlerTestSuite(t)
 
 	handler, err := NewArticleHandler()
 	if err != nil {
-		cleanup()
 		t.Fatalf("Failed to create article handler: %v", err)
 	}
 
 	testHelper := &ArticleTestHelper{
 		ArticleHandler: handler,
-		tempDir:        tempDir,
-		cleanup:        cleanup,
+		suite:          suite,
 	}
 
 	t.Cleanup(func() {
 		testHelper.Close()
-		testHelper.cleanup()
 	})
 
 	return testHelper
···
 func (ath *ArticleTestHelper) CreateTestArticle(t *testing.T, url, title, author, date string) int64 {
 	ctx := context.Background()
 
-	mdPath := filepath.Join(ath.tempDir, fmt.Sprintf("%s.md", title))
-	htmlPath := filepath.Join(ath.tempDir, fmt.Sprintf("%s.html", title))
+	mdPath := filepath.Join(ath.suite.TempDir(), fmt.Sprintf("%s.md", title))
+	htmlPath := filepath.Join(ath.suite.TempDir(), fmt.Sprintf("%s.html", title))
 
 	mdContent := fmt.Sprintf("# %s\n\n**Author:** %s\n**Date:** %s\n\nTest content", title, author, date)
 	err := os.WriteFile(mdPath, []byte(mdContent), 0644)
···
 	return ith.sim
 }
 
-// SetupHandlerWithInput creates a handler and sets up input simulation in one call
-func SetupBookHandlerWithInput(t *testing.T, inputs ...string) (*BookHandler, func()) {
-	_, cleanup := SetupHandlerTest(t)
-
-	handler, err := NewBookHandler()
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to create book handler: %v", err)
-	}
-
-	if len(inputs) > 0 {
-		handler.SetInputReader(NewInputSimulator(inputs...))
-	}
-
-	fullCleanup := func() {
-		handler.Close()
-		cleanup()
-	}
-
-	return handler, fullCleanup
-}
-
-// SetupMovieHandlerWithInput creates a movie handler and sets up input simulation
-func SetupMovieHandlerWithInput(t *testing.T, inputs ...string) (*MovieHandler, func()) {
-	_, cleanup := SetupHandlerTest(t)
-
-	handler, err := NewMovieHandler()
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to create movie handler: %v", err)
-	}
-
-	if len(inputs) > 0 {
-		handler.SetInputReader(NewInputSimulator(inputs...))
-	}
-
-	fullCleanup := func() {
-		handler.Close()
-		cleanup()
-	}
-
-	return handler, fullCleanup
-}
-
-// SetupTVHandlerWithInput creates a TV handler and sets up input simulation
-func SetupTVHandlerWithInput(t *testing.T, inputs ...string) (*TVHandler, func()) {
-	_, cleanup := SetupHandlerTest(t)
-
-	handler, err := NewTVHandler()
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to create TV handler: %v", err)
-	}
-
-	if len(inputs) > 0 {
-		handler.SetInputReader(NewInputSimulator(inputs...))
-	}
-
-	fullCleanup := func() {
-		handler.Close()
-		cleanup()
-	}
-
-	return handler, fullCleanup
-}
-
-func SetupHandlerTest(t *testing.T) (string, func()) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-interactive-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-
-	oldNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
-	oldNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
-	os.Setenv("NOTELEAF_CONFIG", filepath.Join(tempDir, ".noteleaf.conf.toml"))
-	os.Setenv("NOTELEAF_DATA_DIR", tempDir)
-
-	cleanup := func() {
-		os.Setenv("NOTELEAF_CONFIG", oldNoteleafConfig)
-		os.Setenv("NOTELEAF_DATA_DIR", oldNoteleafDataDir)
-		os.RemoveAll(tempDir)
-	}
-
-	ctx := context.Background()
-	err = Setup(ctx, []string{})
-	if err != nil {
-		cleanup()
-		t.Fatalf("Failed to setup database: %v", err)
-	}
-
-	return tempDir, cleanup
-}
-
 // TUICapableHandler interface for handlers that can expose TUI models for testing
 type TUICapableHandler interface {
 	GetTUIModel(ctx context.Context, opts TUITestOptions) (tea.Model, error)
···
 	}
 }
 
-// CreateTaskHandler creates a TaskHandler for testing with automatic cleanup
-func CreateTaskHandler(t *testing.T) *TaskHandler {
-	t.Helper()
-
-	handler, err := NewTaskHandler()
-	if err != nil {
-		t.Fatalf("Failed to create task handler: %v", err)
-	}
-
-	t.Cleanup(func() {
-		handler.Close()
-	})
-
-	return handler
-}
-
 // AssertTaskHasUUID verifies that a task has a non-empty UUID
 func AssertTaskHasUUID(t *testing.T, task *models.Task) {
 	t.Helper()
···
 		t.Error("Task Modified timestamp should be set")
 	}
 }
-
-// CreateBookHandler creates a [BookHandler] for testing with automatic cleanup
-func CreateBookHandler(t *testing.T) *BookHandler {
-	t.Helper()
-	handler, err := NewBookHandler()
-	if err != nil {
-		t.Fatalf("Failed to create book handler: %v", err)
-	}
-	t.Cleanup(func() { handler.Close() })
-	return handler
-}
-
-// CreateMovieHandler creates a [MovieHandler] for testing with automatic cleanup
-func CreateMovieHandler(t *testing.T) *MovieHandler {
-	t.Helper()
-	handler, err := NewMovieHandler()
-	if err != nil {
-		t.Fatalf("Failed to create movie handler: %v", err)
-	}
-	t.Cleanup(func() { handler.Close() })
-	return handler
-}
-
-// CreateTVHandler creates a [TVHandler] for testing with automatic cleanup
-func CreateTVHandler(t *testing.T) *TVHandler {
-	t.Helper()
-	handler, err := NewTVHandler()
-	if err != nil {
-		t.Fatalf("Failed to create TV handler: %v", err)
-	}
-	t.Cleanup(func() { handler.Close() })
-	return handler
-}

internal/handlers/tv.go

···
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
-// TVHandler handles all TV show-related commands
-//
-// Implements MediaHandler interface for polymorphic media handling
+// TVHandler handles all TV show-related commands. Implements [MediaHandler] for polymorphic media handling
 type TVHandler struct {
 	db      *store.Database
 	config  *store.Config
···
 	reader  io.Reader
 }
 
-// Ensure TVHandler implements MediaHandler interface
 var _ MediaHandler = (*TVHandler)(nil)
 
 // NewTVHandler creates a new TV handler

internal/models/behaviors.go

···
-package models
-
-import "time"
-
-// Stateful represents entities with status management behavior
-//
-// Implemented by: [Book], [Movie], [TVShow], [Task]
-type Stateful interface {
-	GetStatus() string
-	ValidStatuses() []string
-}
-
-// Queueable represents media that can be queued for later consumption
-//
-// Implemented by: [Book], [Movie], [TVShow]
-type Queueable interface {
-	Stateful
-	IsQueued() bool
-}
-
-// Completable represents media that can be marked as completed/finished/watched. It tracks completion timestamps for media consumption.
-//
-// Implemented by: [Book] (finished), [Movie] (watched), [TVShow] (watched)
-type Completable interface {
-	Stateful
-	IsCompleted() bool
-	GetCompletionTime() *time.Time
-}
-
-// Progressable represents media with measurable progress tracking
-//
-// Implemented by: [Book] (percentage-based reading progress)
-type Progressable interface {
-	Completable
-	GetProgress() int
-	SetProgress(progress int) error
-}
-
-// Compile-time interface checks
-var (
-	_ Stateful     = (*Task)(nil)
-	_ Stateful     = (*Book)(nil)
-	_ Stateful     = (*Movie)(nil)
-	_ Stateful     = (*TVShow)(nil)
-	_ Queueable    = (*Book)(nil)
-	_ Queueable    = (*Movie)(nil)
-	_ Queueable    = (*TVShow)(nil)
-	_ Completable  = (*Book)(nil)
-	_ Completable  = (*Movie)(nil)
-	_ Completable  = (*TVShow)(nil)
-	_ Progressable = (*Book)(nil)
-)

internal/models/models.go

···
 
 // Model defines the common interface that all domain models must implement
 type Model interface {
-	// GetID returns the primary key identifier
-	GetID() int64
-	// SetID sets the primary key identifier
-	SetID(id int64)
-	// GetTableName returns the database table name for this model
-	GetTableName() string
-	// GetCreatedAt returns when the model was created
-	GetCreatedAt() time.Time
-	// SetCreatedAt sets when the model was created
-	SetCreatedAt(t time.Time)
-	// GetUpdatedAt returns when the model was last updated
-	GetUpdatedAt() time.Time
-	// SetUpdatedAt sets when the model was last updated
-	SetUpdatedAt(t time.Time)
+	GetID() int64             // GetID returns the primary key identifier
+	SetID(id int64)           // SetID sets the primary key identifier
+	GetTableName() string     // GetTableName returns the database table name for this model
+	GetCreatedAt() time.Time  // GetCreatedAt returns when the model was created
+	SetCreatedAt(t time.Time) // SetCreatedAt sets when the model was created
+	GetUpdatedAt() time.Time  // GetUpdatedAt returns when the model was last updated
+	SetUpdatedAt(t time.Time) // SetUpdatedAt sets when the model was last updated
+}
+
+// Stateful represents entities with status management behavior
+//
+// Implemented by: [Book], [Movie], [TVShow], [Task]
+type Stateful interface {
+	GetStatus() string
+	ValidStatuses() []string
 }
 
+// Queueable represents media that can be queued for later consumption
+//
+// Implemented by: [Book], [Movie], [TVShow]
+type Queueable interface {
+	Stateful
+	IsQueued() bool
+}
+
+// Completable represents media that can be marked as completed/finished/watched. It tracks completion timestamps for media consumption.
+//
+// Implemented by: [Book] (finished), [Movie] (watched), [TVShow] (watched)
+type Completable interface {
+	Stateful
+	IsCompleted() bool
+	GetCompletionTime() *time.Time
+}
+
+// Progressable represents media with measurable progress tracking
+//
+// Implemented by: [Book] (percentage-based reading progress)
+type Progressable interface {
+	Completable
+	GetProgress() int
+	SetProgress(progress int) error
+}
+
+// Compile-time interface checks
+var (
+	_ Stateful     = (*Task)(nil)
+	_ Stateful     = (*Book)(nil)
+	_ Stateful     = (*Movie)(nil)
+	_ Stateful     = (*TVShow)(nil)
+	_ Queueable    = (*Book)(nil)
+	_ Queueable    = (*Movie)(nil)
+	_ Queueable    = (*TVShow)(nil)
+	_ Completable  = (*Book)(nil)
+	_ Completable  = (*Movie)(nil)
+	_ Completable  = (*TVShow)(nil)
+	_ Progressable = (*Book)(nil)
+)
+
 // Task represents a task item with TaskWarrior-inspired fields
 type Task struct {
 	ID          int64      `json:"id"`
···
 }
 
 // IsCompleted returns true if the task is marked as completed
-func (t *Task) IsCompleted() bool {
-	return t.Status == "completed"
-}
+func (t *Task) IsCompleted() bool { return t.Status == "completed" }
 
 // IsPending returns true if the task is pending
-func (t *Task) IsPending() bool {
-	return t.Status == "pending"
-}
+func (t *Task) IsPending() bool { return t.Status == "pending" }
 
 // IsDeleted returns true if the task is deleted
-func (t *Task) IsDeleted() bool {
-	return t.Status == "deleted"
-}
+func (t *Task) IsDeleted() bool { return t.Status == "deleted" }
 
 // HasPriority returns true if the task has a priority set
-func (t *Task) HasPriority() bool {
-	return t.Priority != ""
-}
+func (t *Task) HasPriority() bool { return t.Priority != "" }
 
-// New status tracking methods
-func (t *Task) IsTodo() bool {
-	return t.Status == StatusTodo
-}
-
-func (t *Task) IsInProgress() bool {
-	return t.Status == StatusInProgress
-}
-
-func (t *Task) IsBlocked() bool {
-	return t.Status == StatusBlocked
-}
-
-func (t *Task) IsDone() bool {
-	return t.Status == StatusDone
-}
-
-func (t *Task) IsAbandoned() bool {
-	return t.Status == StatusAbandoned
-}
+func (t *Task) IsTodo() bool       { return t.Status == StatusTodo }
+func (t *Task) IsInProgress() bool { return t.Status == StatusInProgress }
+func (t *Task) IsBlocked() bool    { return t.Status == StatusBlocked }
+func (t *Task) IsDone() bool       { return t.Status == StatusDone }
+func (t *Task) IsAbandoned() bool  { return t.Status == StatusAbandoned }
 
 // IsValidStatus returns true if the status is one of the defined valid statuses
 func (t *Task) IsValidStatus() bool {
···
 	return false
 }
 
-// GetPriorityWeight returns a numeric weight for sorting priorities
-//
-//	Higher numbers = higher priority
+// GetPriorityWeight returns a numeric weight for sorting priorities. A higher number = higher priority
 func (t *Task) GetPriorityWeight() int {
 	switch t.Priority {
 	case PriorityHigh, "5":
···
 }
 
 // HasRating returns true if the album has a rating set
-func (a *Album) HasRating() bool {
-	return a.Rating > 0
-}
+func (a *Album) HasRating() bool { return a.Rating > 0 }
 
 // IsValidRating returns true if the rating is between 1 and 5
-func (a *Album) IsValidRating() bool {
-	return a.Rating >= 1 && a.Rating <= 5
-}
+func (a *Album) IsValidRating() bool { return a.Rating >= 1 && a.Rating <= 5 }
 
 func (a *Album) GetID() int64                { return a.ID }
 func (a *Album) SetID(id int64)              { a.ID = id }
···
 }
 
 // HasAuthor returns true if the article has an author
-func (a *Article) HasAuthor() bool {
-	return a.Author != ""
-}
+func (a *Article) HasAuthor() bool { return a.Author != "" }
 
 // HasDate returns true if the article has a date
-func (a *Article) HasDate() bool {
-	return a.Date != ""
-}
+func (a *Article) HasDate() bool { return a.Date != "" }

internal/repo/article_repository.go

···
 	"github.com/stormlightlabs/noteleaf/internal/services"
 )
 
+func ArticleNotFoundError(id int64) error {
+	return fmt.Errorf("article with id %d not found", id)
+}
+
 // ArticleRepository provides database operations for articles
 type ArticleRepository struct {
 	db *sql.DB
···
 	Offset   int
 }
 
-// Create stores a new article and returns its assigned ID
-func (r *ArticleRepository) Create(ctx context.Context, article *models.Article) (int64, error) {
-	if err := r.Validate(article); err != nil {
-		return 0, err
-	}
-
-	now := time.Now()
-	article.Created = now
-	article.Modified = now
-
-	query := `
-		INSERT INTO articles (url, title, author, date, markdown_path, html_path, created, modified)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
-
-	result, err := r.db.ExecContext(ctx, query,
-		article.URL, article.Title, article.Author, article.Date,
-		article.MarkdownPath, article.HTMLPath, article.Created, article.Modified)
-	if err != nil {
-		return 0, fmt.Errorf("failed to insert article: %w", err)
-	}
-
-	id, err := result.LastInsertId()
-	if err != nil {
-		return 0, fmt.Errorf("failed to get last insert id: %w", err)
-	}
-
-	article.ID = id
-	return id, nil
-}
-
-// Get retrieves an article by its ID
-func (r *ArticleRepository) Get(ctx context.Context, id int64) (*models.Article, error) {
-	query := `
-		SELECT id, url, title, author, date, markdown_path, html_path, created, modified
-		FROM articles WHERE id = ?`
-
-	row := r.db.QueryRowContext(ctx, query, id)
-
+// scanArticle scans a database row into an Article model
+func (r *ArticleRepository) scanArticle(s scanner) (*models.Article, error) {
 	var article models.Article
-	err := row.Scan(&article.ID, &article.URL, &article.Title, &article.Author, &article.Date,
+	err := s.Scan(&article.ID, &article.URL, &article.Title, &article.Author, &article.Date,
 		&article.MarkdownPath, &article.HTMLPath, &article.Created, &article.Modified)
 	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, fmt.Errorf("article with id %d not found", id)
-		}
-		return nil, fmt.Errorf("failed to scan article: %w", err)
+		return nil, err
 	}
-
 	return &article, nil
 }
 
-// GetByURL retrieves an article by its URL
-func (r *ArticleRepository) GetByURL(ctx context.Context, url string) (*models.Article, error) {
-	query := `
-		SELECT id, url, title, author, date, markdown_path, html_path, created, modified
-		FROM articles WHERE url = ?`
-
-	row := r.db.QueryRowContext(ctx, query, url)
-
-	var article models.Article
-	err := row.Scan(&article.ID, &article.URL, &article.Title, &article.Author, &article.Date,
-		&article.MarkdownPath, &article.HTMLPath, &article.Created, &article.Modified)
+// queryOne executes a query that returns a single article
+func (r *ArticleRepository) queryOne(ctx context.Context, query string, args ...any) (*models.Article, error) {
+	row := r.db.QueryRowContext(ctx, query, args...)
+	article, err := r.scanArticle(row)
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, fmt.Errorf("article with url %s not found", url)
+			return nil, fmt.Errorf("article not found")
 		}
 		return nil, fmt.Errorf("failed to scan article: %w", err)
 	}
-
-	return &article, nil
-}
-
-// Update modifies an existing article
-func (r *ArticleRepository) Update(ctx context.Context, article *models.Article) error {
-	if err := r.Validate(article); err != nil {
-		return err
-	}
-
-	article.Modified = time.Now()
-
-	query := `
-		UPDATE articles
-		SET title = ?, author = ?, date = ?, markdown_path = ?, html_path = ?, modified = ?
-		WHERE id = ?`
-
-	result, err := r.db.ExecContext(ctx, query,
-		article.Title, article.Author, article.Date, article.MarkdownPath,
-		article.HTMLPath, article.Modified, article.ID)
-	if err != nil {
-		return fmt.Errorf("failed to update article: %w", err)
-	}
-
-	rowsAffected, err := result.RowsAffected()
-	if err != nil {
-		return fmt.Errorf("failed to get rows affected: %w", err)
-	}
-
-	if rowsAffected == 0 {
-		return fmt.Errorf("article with id %d not found", article.ID)
-	}
-
-	return nil
+	return article, nil
 }
 
-// Delete removes an article from the database
-func (r *ArticleRepository) Delete(ctx context.Context, id int64) error {
-	query := "DELETE FROM articles WHERE id = ?"
-
-	result, err := r.db.ExecContext(ctx, query, id)
+// queryMany executes a query that returns multiple articles
+func (r *ArticleRepository) queryMany(ctx context.Context, query string, args ...any) ([]*models.Article, error) {
+	rows, err := r.db.QueryContext(ctx, query, args...)
 	if err != nil {
-		return fmt.Errorf("failed to delete article: %w", err)
+		return nil, fmt.Errorf("failed to query articles: %w", err)
 	}
+	defer rows.Close()
 
-	rowsAffected, err := result.RowsAffected()
-	if err != nil {
-		return fmt.Errorf("failed to get rows affected: %w", err)
+	var articles []*models.Article
+	for rows.Next() {
+		article, err := r.scanArticle(rows)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan article: %w", err)
+		}
+		articles = append(articles, article)
 	}
 
-	if rowsAffected == 0 {
-		return fmt.Errorf("article with id %d not found", id)
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over articles: %w", err)
 	}
 
-	return nil
+	return articles, nil
 }
 
-// List retrieves articles with optional filtering
-func (r *ArticleRepository) List(ctx context.Context, opts *ArticleListOptions) ([]*models.Article, error) {
-	query := `
-		SELECT id, url, title, author, date, markdown_path, html_path, created, modified
-		FROM articles`
-
+// buildListQuery constructs a query and arguments for the List method
+func (r *ArticleRepository) buildListQuery(opts *ArticleListOptions) (string, []any) {
+	query := queryArticlesList
 	var conditions []string
 	var args []any
 
···
 		}
 	}
 
-	rows, err := r.db.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query articles: %w", err)
-	}
-	defer rows.Close()
-
-	var articles []*models.Article
-	for rows.Next() {
-		var article models.Article
-		err := rows.Scan(&article.ID, &article.URL, &article.Title, &article.Author, &article.Date,
-			&article.MarkdownPath, &article.HTMLPath, &article.Created, &article.Modified)
-		if err != nil {
-			return nil, fmt.Errorf("failed to scan article: %w", err)
-		}
-		articles = append(articles, &article)
-	}
-
-	if err = rows.Err(); err != nil {
-		return nil, fmt.Errorf("error iterating over articles: %w", err)
-	}
-
-	return articles, nil
+	return query, args
 }
 
-// Count returns the total number of articles matching the given options
-func (r *ArticleRepository) Count(ctx context.Context, opts *ArticleListOptions) (int64, error) {
-	query := "SELECT COUNT(*) FROM articles"
-
+// buildCountQuery constructs a count query and arguments
+func (r *ArticleRepository) buildCountQuery(opts *ArticleListOptions) (string, []any) {
+	query := queryArticlesCount
 	var conditions []string
 	var args []any
 
···
 	if len(conditions) > 0 {
 		query += " WHERE " + strings.Join(conditions, " AND ")
 	}
+
+	return query, args
+}
+
+// Create stores a new article and returns its assigned ID
+func (r *ArticleRepository) Create(ctx context.Context, article *models.Article) (int64, error) {
+	if err := r.Validate(article); err != nil {
+		return 0, err
+	}
+
+	now := time.Now()
+	article.Created = now
+	article.Modified = now
+
+	result, err := r.db.ExecContext(ctx, queryArticleInsert,
+		article.URL, article.Title, article.Author, article.Date,
+		article.MarkdownPath, article.HTMLPath, article.Created, article.Modified)
+	if err != nil {
+		return 0, fmt.Errorf("failed to insert article: %w", err)
+	}
+
+	id, err := result.LastInsertId()
+	if err != nil {
+		return 0, fmt.Errorf("failed to get last insert id: %w", err)
+	}
+
+	article.ID = id
+	return id, nil
+}
+
+// Get retrieves an article by its ID
+func (r *ArticleRepository) Get(ctx context.Context, id int64) (*models.Article, error) {
+	article, err := r.queryOne(ctx, queryArticleByID, id)
+	if err != nil {
+		return nil, ArticleNotFoundError(id)
+	}
+	return article, nil
+}
+
+// GetByURL retrieves an article by its URL
+func (r *ArticleRepository) GetByURL(ctx context.Context, url string) (*models.Article, error) {
+	article, err := r.queryOne(ctx, queryArticleByURL, url)
+	if err != nil {
+		return nil, fmt.Errorf("article with url %s not found", url)
+	}
+	return article, nil
+}
+
+// Update modifies an existing article
+func (r *ArticleRepository) Update(ctx context.Context, article *models.Article) error {
+	if err := r.Validate(article); err != nil {
+		return err
+	}
+
+	article.Modified = time.Now()
+
+	result, err := r.db.ExecContext(ctx, queryArticleUpdate,
+		article.Title, article.Author, article.Date, article.MarkdownPath,
+		article.HTMLPath, article.Modified, article.ID)
+	if err != nil {
+		return fmt.Errorf("failed to update article: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("failed to get rows affected: %w", err)
+	}
+
+	if rowsAffected == 0 {
+		return ArticleNotFoundError(article.ID)
+	}
+
+	return nil
+}
+
+// Delete removes an article from the database
+func (r *ArticleRepository) Delete(ctx context.Context, id int64) error {
+	result, err := r.db.ExecContext(ctx, queryArticleDelete, id)
+	if err != nil {
+		return fmt.Errorf("failed to delete article: %w", err)
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("failed to get rows affected: %w", err)
+	}
+
+	if rowsAffected == 0 {
+		return ArticleNotFoundError(id)
+	}
+
+	return nil
+}
+
+// List retrieves articles with optional filtering
+func (r *ArticleRepository) List(ctx context.Context, opts *ArticleListOptions) ([]*models.Article, error) {
+	query, args := r.buildListQuery(opts)
+	return r.queryMany(ctx, query, args...)
+}
+
+// Count returns the total number of articles matching the given options
+func (r *ArticleRepository) Count(ctx context.Context, opts *ArticleListOptions) (int64, error) {
+	query, args := r.buildCountQuery(opts)
 
 	var count int64
 	err := r.db.QueryRowContext(ctx, query, args...).Scan(&count)

internal/repo/article_repository_test.go

···
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newArticle := CreateSampleArticle()
 			_, err := repo.Create(NewCanceledContext(), newArticle)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Get with cancelled context", func(t *testing.T) {
 			_, err := repo.Get(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetByURL with cancelled context", func(t *testing.T) {
 			_, err := repo.GetByURL(NewCanceledContext(), article.URL)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Update with cancelled context", func(t *testing.T) {
 			article.Title = "Updated"
 			err := repo.Update(NewCanceledContext(), article)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Delete with cancelled context", func(t *testing.T) {
 			err := repo.Delete(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("List with cancelled context", func(t *testing.T) {
 			_, err := repo.List(NewCanceledContext(), nil)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Count with cancelled context", func(t *testing.T) {
 			_, err := repo.Count(NewCanceledContext(), nil)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 

internal/repo/base_media_repository.go

···
 )
 
 // MediaConfig defines configuration for a media repository
-//
-// T should be a pointer type (*models.Book, *models.Movie, *models.TVShow)
 type MediaConfig[T models.Model] struct {
 	TableName     string                             // TableName is the database table name (e.g., "books", "movies", "tv_shows")
 	New           func() T                           // New creates a new zero-value instance of T
···
 }
 
 // BaseMediaRepository provides shared CRUD operations for media types
-//
-// This generic implementation eliminates duplicate code across Book, Movie, and TV repositories.
-// Type-specific behavior is configured via MediaConfig.
-//
-// T should be a pointer type (*models.Book, *models.Movie, *models.TVShow)
 type BaseMediaRepository[T models.Model] struct {
 	db     *sql.DB
 	config MediaConfig[T]
···
 }
 
 // Get retrieves a media item by ID
-//
-// Returns T directly (which is already a pointer type like *models.Book)
 func (r *BaseMediaRepository[T]) Get(ctx context.Context, id int64) (T, error) {
 	query := fmt.Sprintf("SELECT * FROM %s WHERE id = ?", r.config.TableName)
 	row := r.db.QueryRowContext(ctx, query, id)
···
 }
 
 // ListQuery executes a custom query and scans results
-//
-// Returns []T where T is a pointer type (e.g., []*models.Book)
 func (r *BaseMediaRepository[T]) ListQuery(ctx context.Context, query string, args ...any) ([]T, error) {
 	rows, err := r.db.QueryContext(ctx, query, args...)
 	if err != nil {
···
 	return count, nil
 }
 
-// buildPlaceholders generates "?,?,?" for SQL placeholders
 func buildPlaceholders(values []any) string {
 	if len(values) == 0 {
 		return ""

internal/repo/book_repository_test.go

···
 
 		t.Run("Count with context cancellation", func(t *testing.T) {
 			_, err := repo.Count(NewCanceledContext(), BookListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 
···
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newBook := NewBookBuilder().WithTitle("Cancelled").Build()
 			_, err := repo.Create(NewCanceledContext(), newBook)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Get with cancelled context", func(t *testing.T) {
 			_, err := repo.Get(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Update with cancelled context", func(t *testing.T) {
 			book.Title = "Updated"
 			err := repo.Update(NewCanceledContext(), book)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Delete with cancelled context", func(t *testing.T) {
 			err := repo.Delete(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("List with cancelled context", func(t *testing.T) {
 			_, err := repo.List(NewCanceledContext(), BookListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetQueued with cancelled context", func(t *testing.T) {
 			_, err := repo.GetQueued(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetReading with cancelled context", func(t *testing.T) {
 			_, err := repo.GetReading(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetFinished with cancelled context", func(t *testing.T) {
 			_, err := repo.GetFinished(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetByAuthor with cancelled context", func(t *testing.T) {
 			_, err := repo.GetByAuthor(NewCanceledContext(), "Test Author")
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("StartReading with cancelled context", func(t *testing.T) {
 			err := repo.StartReading(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("FinishReading with cancelled context", func(t *testing.T) {
 			err := repo.FinishReading(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("UpdateProgress with cancelled context", func(t *testing.T) {
 			err := repo.UpdateProgress(NewCanceledContext(), id, 50)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 

internal/repo/media_repository.go

···
 )
 
 // MediaRepository defines CRUD operations for media types (Books, Movies, TV)
-//
-// This interface captures the shared behavior across media repositories
 type MediaRepository[T models.Model] interface {
-	// Create stores a new media item and returns its assigned ID
-	Create(ctx context.Context, item *T) (int64, error)
-
-	// Get retrieves a media item by ID
-	Get(ctx context.Context, id int64) (*T, error)
-
-	// Update modifies an existing media item
-	Update(ctx context.Context, item *T) error
-
-	// Delete removes a media item by ID
-	Delete(ctx context.Context, id int64) error
-
-	// List retrieves media items with optional filtering and sorting
-	List(ctx context.Context, opts any) ([]*T, error)
-
-	// Count returns the number of media items matching conditions
-	Count(ctx context.Context, opts any) (int64, error)
+	Create(ctx context.Context, item *T) (int64, error) // Create stores a new media item and returns its assigned ID
+	Get(ctx context.Context, id int64) (*T, error)      // Get retrieves a media item by ID
+	Update(ctx context.Context, item *T) error          // Update modifies an existing media item
+	Delete(ctx context.Context, id int64) error         // Delete removes a media item by ID
+	List(ctx context.Context, opts any) ([]*T, error)   // List retrieves media items with optional filtering and sorting
+	Count(ctx context.Context, opts any) (int64, error) // Count returns the number of media items matching conditions
 }
 
-// StatusFilterable extends MediaRepository with status-based filtering
-//
-// Media types (Books, Movies, TV) support status-based queries like "queued", "reading", "watching", "watched", "finished"
+// StatusFilterable extends MediaRepository with status-based filtering for queries like "queued", "reading", "watching", "watched", "finished"
 type StatusFilterable[T models.Model] interface {
 	MediaRepository[T]
-
 	// GetByStatus retrieves all items with the given status
 	GetByStatus(ctx context.Context, status string) ([]*T, error)
 }

internal/repo/movie_repository.go

···
 	"github.com/stormlightlabs/noteleaf/internal/models"
 )
 
+// MovieListOptions defines options for listing movies
+type MovieListOptions struct {
+	Status    string
+	Year      int
+	MinRating float64
+	Search    string
+	SortBy    string
+	SortOrder string
+	Limit     int
+	Offset    int
+}
+
 // MovieRepository provides database operations for movies
 type MovieRepository struct {
 	*BaseMediaRepository[*models.Movie]
···
 		},
 	}
 
-	return &MovieRepository{
-		BaseMediaRepository: NewBaseMediaRepository(db, config),
-		db:                  db,
-	}
+	return &MovieRepository{BaseMediaRepository: NewBaseMediaRepository(db, config), db: db}
 }
 
 // Create stores a new movie and returns its assigned ID
···
 	movie.Watched = &now
 	return r.Update(ctx, movie)
 }
-
-// MovieListOptions defines options for listing movies
-type MovieListOptions struct {
-	Status    string
-	Year      int
-	MinRating float64
-	Search    string
-	SortBy    string
-	SortOrder string
-	Limit     int
-	Offset    int
-}

internal/repo/movie_repository_test.go

···
 
 		t.Run("Count with context cancellation", func(t *testing.T) {
 			_, err := repo.Count(NewCanceledContext(), MovieListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 
···
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newMovie := NewMovieBuilder().WithTitle("Cancelled").Build()
 			_, err := repo.Create(NewCanceledContext(), newMovie)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Get with cancelled context", func(t *testing.T) {
 			_, err := repo.Get(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Update with cancelled context", func(t *testing.T) {
 			movie.Title = "Updated"
 			err := repo.Update(NewCanceledContext(), movie)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Delete with cancelled context", func(t *testing.T) {
 			err := repo.Delete(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("List with cancelled context", func(t *testing.T) {
 			_, err := repo.List(NewCanceledContext(), MovieListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetQueued with cancelled context", func(t *testing.T) {
 			_, err := repo.GetQueued(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetWatched with cancelled context", func(t *testing.T) {
 			_, err := repo.GetWatched(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("MarkWatched with cancelled context", func(t *testing.T) {
 			err := repo.MarkWatched(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 

internal/repo/note_repository.go

···
 	"github.com/stormlightlabs/noteleaf/internal/models"
 )
 
+func NoteNotFoundError(id int64) error {
+	return fmt.Errorf("note with id %d not found", id)
+}
+
 // NoteRepository provides database operations for notes
 type NoteRepository struct {
 	db *sql.DB
···
 	Offset   int
 }
 
+func (r *NoteRepository) scanNote(s scanner) (*models.Note, error) {
+	var note models.Note
+	var tags string
+	err := s.Scan(&note.ID, &note.Title, &note.Content, &tags, &note.Archived,
+		&note.Created, &note.Modified, &note.FilePath)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := note.UnmarshalTags(tags); err != nil {
+		return nil, UnmarshalTagsError(err)
+	}
+
+	return &note, nil
+}
+
+func (r *NoteRepository) queryOne(ctx context.Context, query string, args ...any) (*models.Note, error) {
+	row := r.db.QueryRowContext(ctx, query, args...)
+	note, err := r.scanNote(row)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, fmt.Errorf("note not found")
+		}
+		return nil, fmt.Errorf("failed to scan note: %w", err)
+	}
+	return note, nil
+}
+
+func (r *NoteRepository) queryMany(ctx context.Context, query string, args ...any) ([]*models.Note, error) {
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query notes: %w", err)
+	}
+	defer rows.Close()
+
+	var notes []*models.Note
+	for rows.Next() {
+		note, err := r.scanNote(rows)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan note: %w", err)
+		}
+		notes = append(notes, note)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over notes: %w", err)
+	}
+
+	return notes, nil
+}
+
 // Create stores a new note and returns its assigned ID
 func (r *NoteRepository) Create(ctx context.Context, note *models.Note) (int64, error) {
 	now := time.Now()
···
 		return 0, fmt.Errorf("failed to marshal tags: %w", err)
 	}
 
-	query := `
-		INSERT INTO notes (title, content, tags, archived, created, modified, file_path)
-		VALUES (?, ?, ?, ?, ?, ?, ?)`
-
-	result, err := r.db.ExecContext(ctx, query,
+	result, err := r.db.ExecContext(ctx, queryNoteInsert,
 		note.Title, note.Content, tags, note.Archived, note.Created, note.Modified, note.FilePath)
 	if err != nil {
 		return 0, fmt.Errorf("failed to insert note: %w", err)
···
 
 // Get retrieves a note by its ID
 func (r *NoteRepository) Get(ctx context.Context, id int64) (*models.Note, error) {
-	query := `
-		SELECT id, title, content, tags, archived, created, modified, file_path
-		FROM notes WHERE id = ?`
-
-	row := r.db.QueryRowContext(ctx, query, id)
-
-	var note models.Note
-	var tags string
-	err := row.Scan(&note.ID, &note.Title, &note.Content, &tags, &note.Archived,
-		&note.Created, &note.Modified, &note.FilePath)
+	note, err := r.queryOne(ctx, queryNoteByID, id)
 	if err != nil {
-		if err == sql.ErrNoRows {
-			return nil, fmt.Errorf("note with id %d not found", id)
-		}
-		return nil, fmt.Errorf("failed to scan note: %w", err)
-	}
-
-	if err := note.UnmarshalTags(tags); err != nil {
-		return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
+		return nil, NoteNotFoundError(id)
 	}
-
-	return &note, nil
+	return note, nil
 }
 
 // Update modifies an existing note
···
 		return fmt.Errorf("failed to marshal tags: %w", err)
 	}
 
-	query := `
-		UPDATE notes
-		SET title = ?, content = ?, tags = ?, archived = ?, modified = ?, file_path = ?
-		WHERE id = ?`
-
-	result, err := r.db.ExecContext(ctx, query,
+	result, err := r.db.ExecContext(ctx, queryNoteUpdate,
 		note.Title, note.Content, tags, note.Archived, note.Modified, note.FilePath, note.ID)
 	if err != nil {
 		return fmt.Errorf("failed to update note: %w", err)
···
 	}
 
 	if rowsAffected == 0 {
-		return fmt.Errorf("note with id %d not found", note.ID)
+		return NoteNotFoundError(note.ID)
 	}
 
 	return nil
···
 
 // Delete removes a note by its ID
 func (r *NoteRepository) Delete(ctx context.Context, id int64) error {
-	query := `DELETE FROM notes WHERE id = ?`
-
-	result, err := r.db.ExecContext(ctx, query, id)
+	result, err := r.db.ExecContext(ctx, queryNoteDelete, id)
 	if err != nil {
 		return fmt.Errorf("failed to delete note: %w", err)
 	}
···
 	}
 
 	if rowsAffected == 0 {
-		return fmt.Errorf("note with id %d not found", id)
+		return NoteNotFoundError(id)
 	}
 
 	return nil
 }
 
-// List retrieves notes with optional filtering
-func (r *NoteRepository) List(ctx context.Context, options NoteListOptions) ([]*models.Note, error) {
-	query := "SELECT id, title, content, tags, archived, created, modified, file_path FROM notes"
+func (r *NoteRepository) buildListQuery(options NoteListOptions) (string, []any) {
+	query := queryNotesList
 	args := []any{}
 	conditions := []string{}
 
···
 		}
 	}
 
-	rows, err := r.db.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query notes: %w", err)
-	}
-	defer rows.Close()
-
-	var notes []*models.Note
-	for rows.Next() {
-		var note models.Note
-		var tags string
-		err := rows.Scan(&note.ID, &note.Title, &note.Content, &tags, &note.Archived,
-			&note.Created, &note.Modified, &note.FilePath)
-		if err != nil {
-			return nil, fmt.Errorf("failed to scan note: %w", err)
-		}
-
-		if err := note.UnmarshalTags(tags); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
-		}
-
-		notes = append(notes, &note)
-	}
+	return query, args
+}
 
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("error iterating over notes: %w", err)
-	}
-
-	return notes, nil
+// List retrieves notes with optional filtering
+func (r *NoteRepository) List(ctx context.Context, options NoteListOptions) ([]*models.Note, error) {
+	query, args := r.buildListQuery(options)
+	return r.queryMany(ctx, query, args...)
 }
 
 // GetByTitle searches for notes by title pattern
···
 	if err != nil {
 		return err
 	}
-
 	for i, existingTag := range note.Tags {
 		if existingTag == tag {
 			note.Tags = append(note.Tags[:i], note.Tags[i+1:]...)
 			break
 		}
 	}
-
 	return r.Update(ctx, note)
 }
 
-// GetByTags retrieves notes that have any of the specified tags
-func (r *NoteRepository) GetByTags(ctx context.Context, tags []string) ([]*models.Note, error) {
-	if len(tags) == 0 {
-		return []*models.Note{}, nil
-	}
-
-	placeholders := make([]string, len(tags))
+func (r *NoteRepository) buildTagsQuery(tags []string) (string, []any) {
+	conditions := make([]string, len(tags))
 	args := make([]any, len(tags))
 	for i, tag := range tags {
-		placeholders[i] = "?"
+		conditions[i] = "tags LIKE ?"
 		args[i] = "%\"" + tag + "\"%"
 	}
+	return fmt.Sprintf(`SELECT %s FROM notes WHERE %s ORDER BY modified DESC`, noteColumns, strings.Join(conditions, " OR ")), args
+}
 
-	query := fmt.Sprintf(`
-		SELECT id, title, content, tags, archived, created, modified, file_path
-		FROM notes
-		WHERE %s
-		ORDER BY modified DESC`,
-		strings.Join(func() []string {
-			conditions := make([]string, len(tags))
-			for i := range tags {
-				conditions[i] = "tags LIKE ?"
-			}
-			return conditions
-		}(), " OR "))
-
-	rows, err := r.db.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to query notes by tags: %w", err)
+// GetByTags retrieves notes that have any of the specified tags
+func (r *NoteRepository) GetByTags(ctx context.Context, tags []string) ([]*models.Note, error) {
+	if len(tags) == 0 {
+		return []*models.Note{}, nil
 	}
-	defer rows.Close()
-
-	var notes []*models.Note
-	for rows.Next() {
-		var note models.Note
-		var tagsJSON string
-		err := rows.Scan(&note.ID, &note.Title, &note.Content, &tagsJSON, &note.Archived,
-			&note.Created, &note.Modified, &note.FilePath)
-		if err != nil {
-			return nil, fmt.Errorf("failed to scan note: %w", err)
-		}
-
-		if err := note.UnmarshalTags(tagsJSON); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
-		}
-
-		notes = append(notes, &note)
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, fmt.Errorf("error iterating over notes: %w", err)
-	}
-
-	return notes, nil
+	query, args := r.buildTagsQuery(tags)
+	return r.queryMany(ctx, query, args...)
 }

internal/repo/note_repository_test.go

···
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newNote := NewNoteBuilder().WithTitle("Cancelled").Build()
 			_, err := repo.Create(NewCanceledContext(), newNote)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Get with cancelled context", func(t *testing.T) {
 			_, err := repo.Get(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Update with cancelled context", func(t *testing.T) {
 			note.Title = "Updated"
 			err := repo.Update(NewCanceledContext(), note)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Delete with cancelled context", func(t *testing.T) {
 			err := repo.Delete(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("List with cancelled context", func(t *testing.T) {
 			_, err := repo.List(NewCanceledContext(), NoteListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetByTitle with cancelled context", func(t *testing.T) {
 			_, err := repo.GetByTitle(NewCanceledContext(), "Test")
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetArchived with cancelled context", func(t *testing.T) {
 			_, err := repo.GetArchived(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetActive with cancelled context", func(t *testing.T) {
 			_, err := repo.GetActive(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Archive with cancelled context", func(t *testing.T) {
 			err := repo.Archive(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Unarchive with cancelled context", func(t *testing.T) {
 			err := repo.Unarchive(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("SearchContent with cancelled context", func(t *testing.T) {
 			_, err := repo.SearchContent(NewCanceledContext(), "test")
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetRecent with cancelled context", func(t *testing.T) {
 			_, err := repo.GetRecent(NewCanceledContext(), 10)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("AddTag with cancelled context", func(t *testing.T) {
 			err := repo.AddTag(NewCanceledContext(), id, "tag")
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("RemoveTag with cancelled context", func(t *testing.T) {
 			err := repo.RemoveTag(NewCanceledContext(), id, "tag")
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetByTags with cancelled context", func(t *testing.T) {
 			_, err := repo.GetByTags(NewCanceledContext(), []string{"tag"})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 

internal/repo/queries.go

···
+package repo
+
+const (
+	noteColumns     = "id, title, content, tags, archived, created, modified, file_path"
+	queryNoteByID   = "SELECT " + noteColumns + " FROM notes WHERE id = ?"
+	queryNoteInsert = `INSERT INTO notes (title, content, tags, archived, created, modified, file_path) VALUES (?, ?, ?, ?, ?, ?, ?)`
+	queryNoteUpdate = `UPDATE notes SET title = ?, content = ?, tags = ?, archived = ?, modified = ?, file_path = ? WHERE id = ?`
+	queryNoteDelete = "DELETE FROM notes WHERE id = ?"
+	queryNotesList  = "SELECT " + noteColumns + " FROM notes"
+)
+const (
+	articleColumns     = "id, url, title, author, date, markdown_path, html_path, created, modified"
+	queryArticleByID   = "SELECT " + articleColumns + " FROM articles WHERE id = ?"
+	queryArticleByURL  = "SELECT " + articleColumns + " FROM articles WHERE url = ?"
+	queryArticleInsert = `INSERT INTO articles (url, title, author, date, markdown_path, html_path, created, modified) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+	queryArticleUpdate = `UPDATE articles SET title = ?, author = ?, date = ?, markdown_path = ?, html_path = ?, modified = ? WHERE id = ?`
+	queryArticleDelete = "DELETE FROM articles WHERE id = ?"
+	queryArticlesList  = "SELECT " + articleColumns + " FROM articles"
+	queryArticlesCount = "SELECT COUNT(*) FROM articles"
+)
+
+const (
+	taskColumns     = "id, uuid, description, status, priority, project, context, tags, due, entry, modified, end, start, annotations, recur, until, parent_uuid"
+	queryTaskByID   = "SELECT " + taskColumns + " FROM tasks WHERE id = ?"
+	queryTaskByUUID = "SELECT " + taskColumns + " FROM tasks WHERE uuid = ?"
+	queryTaskInsert = `
+		INSERT INTO tasks (
+			uuid, description, status, priority, project, context,
+			tags, due, entry, modified, end, start, annotations,
+			recur, until, parent_uuid
+		)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+	queryTaskUpdate = `
+		UPDATE tasks SET
+			uuid = ?, description = ?, status = ?, priority = ?, project = ?, context = ?,
+			tags = ?, due = ?, modified = ?, end = ?, start = ?, annotations = ?,
+			recur = ?, until = ?, parent_uuid = ?
+		WHERE id = ?`
+	queryTaskDelete = "DELETE FROM tasks WHERE id = ?"
+	queryTasksList  = "SELECT " + taskColumns + " FROM tasks"
+)
+
+type scanner interface {
+	Scan(dest ...any) error
+}

internal/repo/repo.go

···
 
 import (
 	"database/sql"
+	"fmt"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
 )
···
 		Articles:    NewArticleRepository(db),
 	}
 }
+
+func UnmarshalTagsError(err error) error {
+	return fmt.Errorf("failed to unmarshal tags: %w", err)
+}

internal/repo/task_repository.go

···
+// TODO: extend queryMany composition for GetTasksBy... methods
 package repo
 
 import (
···
 }
 
 // TaskRepository provides database operations for tasks
-//
-// TODO: Implement Repository interface (Validate method) similar to ArticleRepository
 type TaskRepository struct {
 	db *sql.DB
 }
···
 	return &TaskRepository{db: db}
 }
 
+// scanTask scans a database row into a Task model
+func (r *TaskRepository) scanTask(s scanner) (*models.Task, error) {
+	task := &models.Task{}
+	var tags, annotations sql.NullString
+	var parentUUID sql.NullString
+	var priority, project, context sql.NullString
+
+	if err := s.Scan(
+		&task.ID, &task.UUID, &task.Description, &task.Status, &priority,
+		&project, &context, &tags,
+		&task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations,
+		&task.Recur, &task.Until, &parentUUID,
+	); err != nil {
+		return nil, err
+	}
+
+	if priority.Valid {
+		task.Priority = priority.String
+	}
+	if project.Valid {
+		task.Project = project.String
+	}
+	if context.Valid {
+		task.Context = context.String
+	}
+	if parentUUID.Valid {
+		task.ParentUUID = &parentUUID.String
+	}
+
+	if tags.Valid {
+		if err := unmarshalTaskTags(task, tags.String); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
+		}
+	}
+
+	if annotations.Valid {
+		if err := unmarshalTaskAnnotations(task, annotations.String); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal annotations: %w", err)
+		}
+	}
+
+	return task, nil
+}
+
+// queryOne executes a query that returns a single task
+func (r *TaskRepository) queryOne(ctx context.Context, query string, args ...any) (*models.Task, error) {
+	row := r.db.QueryRowContext(ctx, query, args...)
+	task, err := r.scanTask(row)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, fmt.Errorf("task not found")
+		}
+		return nil, fmt.Errorf("failed to scan task: %w", err)
+	}
+	return task, nil
+}
+
+// queryMany executes a query that returns multiple tasks
+func (r *TaskRepository) queryMany(ctx context.Context, query string, args ...any) ([]*models.Task, error) {
+	rows, err := r.db.QueryContext(ctx, query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query tasks: %w", err)
+	}
+	defer rows.Close()
+
+	var tasks []*models.Task
+	for rows.Next() {
+		task, err := r.scanTask(rows)
+		if err != nil {
+			return nil, fmt.Errorf("failed to scan task: %w", err)
+		}
+		tasks = append(tasks, task)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("error iterating over tasks: %w", err)
+	}
+
+	return tasks, nil
+}
+
 // Create stores a new task and returns its assigned ID
 func (r *TaskRepository) Create(ctx context.Context, task *models.Task) (int64, error) {
 	now := time.Now()
···
 		return 0, fmt.Errorf("failed to marshal annotations: %w", err)
 	}
 
-	query := `
-		INSERT INTO tasks (
-			uuid, description, status, priority, project, context,
-			tags, due, entry, modified, end, start, annotations,
-			recur, until, parent_uuid
-		)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-
-	result, err := r.db.ExecContext(ctx, query,
+	result, err := r.db.ExecContext(ctx, queryTaskInsert,
 		task.UUID, task.Description, task.Status, task.Priority, task.Project, task.Context,
 		tags, task.Due, task.Entry, task.Modified, task.End, task.Start, annotations,
 		task.Recur, task.Until, task.ParentUUID,
···
 
 	task.ID = id
 
-	// Sync dependencies to task_dependencies table
 	for _, depUUID := range task.DependsOn {
 		if err := r.AddDependency(ctx, task.UUID, depUUID); err != nil {
 			return 0, fmt.Errorf("failed to add dependency: %w", err)
···
 
 // Get retrieves a task by ID
 func (r *TaskRepository) Get(ctx context.Context, id int64) (*models.Task, error) {
-	query := `
-		SELECT id, uuid, description, status, priority, project, context, tags,
-		       due, entry, modified, end, start, annotations,
-		       recur, until, parent_uuid
-		FROM tasks WHERE id = ?`
-
-	task := &models.Task{}
-	var tags, annotations sql.NullString
-	var parentUUID sql.NullString
-
-	if err := r.db.QueryRowContext(ctx, query, id).Scan(
-		&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority,
-		&task.Project, &task.Context, &tags,
-		&task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations,
-		&task.Recur, &task.Until, &parentUUID,
-	); err != nil {
+	task, err := r.queryOne(ctx, queryTaskByID, id)
+	if err != nil {
 		return nil, fmt.Errorf("failed to get task: %w", err)
 	}
 
-	if tags.Valid {
-		if err := unmarshalTaskTags(task, tags.String); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
-		}
-	}
-
-	if annotations.Valid {
-		if err := unmarshalTaskAnnotations(task, annotations.String); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal annotations: %w", err)
-		}
-	}
-	if parentUUID.Valid {
-		task.ParentUUID = &parentUUID.String
-	}
-
-	// Populate dependencies from task_dependencies table
 	if err := r.PopulateDependencies(ctx, task); err != nil {
 		return nil, fmt.Errorf("failed to populate dependencies: %w", err)
 	}
···
 		return fmt.Errorf("failed to marshal annotations: %w", err)
 	}
 
-	query := `
-		UPDATE tasks SET
-			uuid = ?, description = ?, status = ?, priority = ?, project = ?, context = ?,
-			tags = ?, due = ?, modified = ?, end = ?, start = ?, annotations = ?,
-			recur = ?, until = ?, parent_uuid = ?
-		WHERE id = ?`
-
-	if _, err = r.db.ExecContext(ctx, query,
+	if _, err = r.db.ExecContext(ctx, queryTaskUpdate,
 		task.UUID, task.Description, task.Status, task.Priority, task.Project, task.Context,
 		tags, task.Due, task.Modified, task.End, task.Start, annotations,
 		task.Recur, task.Until, task.ParentUUID,
···
 		return fmt.Errorf("failed to update task: %w", err)
 	}
 
-	// Sync dependencies: clear existing and add new ones
 	if err := r.ClearDependencies(ctx, task.UUID); err != nil {
 		return fmt.Errorf("failed to clear dependencies: %w", err)
 	}
···
 
 // Delete removes a task by ID
 func (r *TaskRepository) Delete(ctx context.Context, id int64) error {
-	query := "DELETE FROM tasks WHERE id = ?"
-	_, err := r.db.ExecContext(ctx, query, id)
+	_, err := r.db.ExecContext(ctx, queryTaskDelete, id)
 	if err != nil {
 		return fmt.Errorf("failed to delete task: %w", err)
 	}
···
 func (r *TaskRepository) List(ctx context.Context, opts TaskListOptions) ([]*models.Task, error) {
 	query := r.buildListQuery(opts)
 	args := r.buildListArgs(opts)
-
-	rows, err := r.db.QueryContext(ctx, query, args...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to list tasks: %w", err)
-	}
-	defer rows.Close()
-
-	var tasks []*models.Task
-	for rows.Next() {
-		task := &models.Task{}
-		if err := r.scanTaskRow(rows, task); err != nil {
-			return nil, err
-		}
-		tasks = append(tasks, task)
-	}
-
-	return tasks, rows.Err()
+	return r.queryMany(ctx, query, args...)
 }
 
 func (r *TaskRepository) buildListQuery(opts TaskListOptions) string {
-	query := `
-    SELECT id, uuid, description, status, priority, project, context, tags,
-           due, entry, modified, end, start, annotations,
-           recur, until, parent_uuid
-    FROM tasks`
-
+	query := queryTasksList
 	var conditions []string
 
 	if opts.Status != "" {
···
 	return args
 }
 
-func (r *TaskRepository) scanTaskRow(rows *sql.Rows, task *models.Task) error {
-	var tags, annotations sql.NullString
-	var parentUUID sql.NullString
-	var priority, project, context sql.NullString
-
-	if err := rows.Scan(
-		&task.ID, &task.UUID, &task.Description, &task.Status, &priority,
-		&project, &context, &tags,
-		&task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations,
-		&task.Recur, &task.Until, &parentUUID,
-	); err != nil {
-		return fmt.Errorf("failed to scan task row: %w", err)
-	}
-
-	if priority.Valid {
-		task.Priority = priority.String
-	}
-	if project.Valid {
-		task.Project = project.String
-	}
-	if context.Valid {
-		task.Context = context.String
-	}
-
-	if parentUUID.Valid {
-		task.ParentUUID = &parentUUID.String
-	}
-
-	if tags.Valid {
-		if err := unmarshalTaskTags(task, tags.String); err != nil {
-			return fmt.Errorf("failed to unmarshal tags: %w", err)
-		}
-	}
-
-	if annotations.Valid {
-		if err := unmarshalTaskAnnotations(task, annotations.String); err != nil {
-			return fmt.Errorf("failed to unmarshal annotations: %w", err)
-		}
-	}
-
-	return nil
-}
-
 // Find retrieves tasks matching specific conditions
 func (r *TaskRepository) Find(ctx context.Context, conditions TaskListOptions) ([]*models.Task, error) {
 	return r.List(ctx, conditions)
···
 
 // GetByUUID retrieves a task by UUID
 func (r *TaskRepository) GetByUUID(ctx context.Context, uuid string) (*models.Task, error) {
-	query := `
-		SELECT id, uuid, description, status, priority, project, context, tags,
-		       due, entry, modified, end, start, annotations,
-		       recur, until, parent_uuid
-		FROM tasks WHERE uuid = ?`
-
-	task := &models.Task{}
-	var tags, annotations sql.NullString
-	var parentUUID sql.NullString
-
-	if err := r.db.QueryRowContext(ctx, query, uuid).Scan(
-		&task.ID, &task.UUID, &task.Description, &task.Status, &task.Priority,
-		&task.Project, &task.Context, &tags,
-		&task.Due, &task.Entry, &task.Modified, &task.End, &task.Start, &annotations,
-		&task.Recur, &task.Until, &parentUUID,
-	); err != nil {
+	task, err := r.queryOne(ctx, queryTaskByUUID, uuid)
+	if err != nil {
 		return nil, fmt.Errorf("failed to get task by UUID: %w", err)
 	}
 
-	if tags.Valid {
-		if err := unmarshalTaskTags(task, tags.String); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal tags: %w", err)
-		}
-	}
-
-	if annotations.Valid {
-		if err := unmarshalTaskAnnotations(task, annotations.String); err != nil {
-			return nil, fmt.Errorf("failed to unmarshal annotations: %w", err)
-		}
-	}
-
-	if parentUUID.Valid {
-		task.ParentUUID = &parentUUID.String
-	}
-
 	// Populate dependencies from task_dependencies table
 	if err := r.PopulateDependencies(ctx, task); err != nil {
 		return nil, fmt.Errorf("failed to populate dependencies: %w", err)
···
 		WHERE t.tags != '' AND t.tags IS NOT NULL AND json_each.value = ?
 		ORDER BY t.modified DESC`
 
-	rows, err := r.db.QueryContext(ctx, query, tag)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get tasks by tag: %w", err)
-	}
-	defer rows.Close()
-
-	var tasks []*models.Task
-	for rows.Next() {
-		task := &models.Task{}
-		if err := r.scanTaskRow(rows, task); err != nil {
-			return nil, err
-		}
-		tasks = append(tasks, task)
-	}
-
-	return tasks, rows.Err()
+	return r.queryMany(ctx, query, tag)
 }
 
 // GetTodo retrieves all tasks with todo status
···
 // GetByPriority retrieves all tasks with a specific priority with special handling for empty priority by using raw SQL
 func (r *TaskRepository) GetByPriority(ctx context.Context, priority string) ([]*models.Task, error) {
 	if priority == "" {
-		query := `SELECT id, uuid, description, status, priority, project, context,
-			tags, due, entry, modified, end, start, annotations, recur, until, parent_uuid
-			FROM tasks WHERE priority = '' OR priority IS NULL ORDER BY modified DESC`
-
-		rows, err := r.db.QueryContext(ctx, query)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get tasks by empty priority: %w", err)
-		}
-		defer rows.Close()
-
-		var tasks []*models.Task
-		for rows.Next() {
-			task := &models.Task{}
-			if err := r.scanTaskRow(rows, task); err != nil {
-				return nil, err
-			}
-			tasks = append(tasks, task)
-		}
-		return tasks, rows.Err()
+		query := "SELECT " + taskColumns + " FROM tasks WHERE priority = '' OR priority IS NULL ORDER BY modified DESC"
+		return r.queryMany(ctx, query)
 	}
 
 	return r.List(ctx, TaskListOptions{Priority: priority})
···
 		       t.tags, t.due, t.entry, t.modified, t.end, t.start, t.annotations, t.recur, t.until, t.parent_uuid
 		FROM tasks t JOIN task_dependencies d ON t.uuid = d.task_uuid WHERE d.depends_on_uuid = ?`
 
-	rows, err := r.db.QueryContext(ctx, query, blockingUUID)
+	tasks, err := r.queryMany(ctx, query, blockingUUID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get dependents: %w", err)
 	}
-	defer rows.Close()
-
-	var tasks []*models.Task
-	for rows.Next() {
-		task := &models.Task{}
-		if err := r.scanTaskRow(rows, task); err != nil {
-			return nil, err
-		}
-		tasks = append(tasks, task)
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
 
 	for _, task := range tasks {
 		if err := r.PopulateDependencies(ctx, task); err != nil {
···
 // GetBlockedTasks finds tasks that are blocked by a given UUID.
 func (r *TaskRepository) GetBlockedTasks(ctx context.Context, blockingUUID string) ([]*models.Task, error) {
 	query := `
-	SELECT t.id, t.uuid, t.description, t.status, t.priority, t.project, t.context,
-	       t.tags, t.due, t.entry, t.modified, t.end, t.start, t.annotations, t.recur, t.until, t.parent_uuid
-	FROM tasks t
-	JOIN task_dependencies d ON t.uuid = d.task_uuid
-	WHERE d.depends_on_uuid = ?`
-	rows, err := r.db.QueryContext(ctx, query, blockingUUID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
+		SELECT t.id, t.uuid, t.description, t.status, t.priority, t.project, t.context,
+		       t.tags, t.due, t.entry, t.modified, t.end, t.start, t.annotations, t.recur, t.until, t.parent_uuid
+		FROM tasks t
+		JOIN task_dependencies d ON t.uuid = d.task_uuid
+		WHERE d.depends_on_uuid = ?`
 
-	var tasks []*models.Task
-	for rows.Next() {
-		task := &models.Task{}
-		if err := r.scanTaskRow(rows, task); err != nil {
-			return nil, err
-		}
-		tasks = append(tasks, task)
-	}
-	if err := rows.Err(); err != nil {
+	tasks, err := r.queryMany(ctx, query, blockingUUID)
+	if err != nil {
 		return nil, err
 	}
 

internal/repo/task_repository_test.go

···
 			t.Run("when called with context cancellation", func(t *testing.T) {
 				task := CreateSampleTask()
 				_, err := repo.Create(NewCanceledContext(), task)
-				AssertError(t, err, "Expected error with cancelled context")
+				AssertCancelledContext(t, err)
 			})
 		})
 	})
···
 
 				task.Description = "Updated"
 				err = repo.Update(NewCanceledContext(), task)
-				AssertError(t, err, "Expected error with cancelled context")
+				AssertCancelledContext(t, err)
 			})
 		})
 	})
···
 
 		t.Run("GetByUUID with context cancellation", func(t *testing.T) {
 			_, err := repo.GetByUUID(NewCanceledContext(), task1.UUID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 
···
 
 		t.Run("Count with context cancellation", func(t *testing.T) {
 			_, err := repo.Count(NewCanceledContext(), TaskListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 

internal/repo/test_utilities.go

···
 		t.Fatalf("Failed to enable foreign keys: %v", err)
 	}
 
-	// if _, err := db.Exec(testSchema); err != nil {
-	// 	t.Fatalf("Failed to create schema: %v", err)
-	// }
-
 	mr := store.NewMigrationRunner(&store.Database{DB: db})
 	if err := mr.RunMigrations(); err != nil {
 		t.Errorf("failed to run migrations %v", err)
···
 	}
 }
 
+func AssertCancelledContext(t *testing.T, err error) {
+	AssertError(t, err, "Expected error with cancelled context")
+}
+
 func AssertEqual[T comparable](t *testing.T, expected, actual T, msg string) {
 	t.Helper()
 	if expected != actual {
···
 	}
 }
 
-func AssertNil(t *testing.T, value interface{}, msg string) {
+func AssertNil(t *testing.T, value any, msg string) {
 	t.Helper()
 	if value != nil {
 		t.Fatalf("%s: expected nil, got %v", msg, value)
 	}
 }
 
-func AssertNotNil(t *testing.T, value interface{}, msg string) {
+func AssertNotNil(t *testing.T, value any, msg string) {
 	t.Helper()
 	if value == nil {
 		t.Fatalf("%s: expected non-nil value", msg)
···
 	t.Helper()
 	if actual >= threshold {
 		t.Fatalf("%s: expected %v < %v", msg, actual, threshold)
-	}
-}
-
-func AssertStringContains(t *testing.T, str, substr, msg string) {
-	t.Helper()
-	if !strings.Contains(str, substr) {
-		t.Fatalf("%s: expected string to contain '%s', got '%s'", msg, substr, str)
 	}
 }
 

internal/repo/time_entry_repository_test.go

···
 			task := createTestTask(t, db)
 
 			_, err := repo.Start(NewCanceledContext(), task.ID, "Cancelled")
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Get with cancelled context", func(t *testing.T) {
 			_, err := repo.Get(NewCanceledContext(), entry.ID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Stop with cancelled context", func(t *testing.T) {
 			_, err := repo.Stop(NewCanceledContext(), entry.ID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetActiveByTaskID with cancelled context", func(t *testing.T) {
 			_, err := repo.GetActiveByTaskID(NewCanceledContext(), task.ID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("StopActiveByTaskID with cancelled context", func(t *testing.T) {
 			_, err := repo.StopActiveByTaskID(NewCanceledContext(), task.ID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetByTaskID with cancelled context", func(t *testing.T) {
 			_, err := repo.GetByTaskID(NewCanceledContext(), task.ID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetTotalTimeByTaskID with cancelled context", func(t *testing.T) {
 			_, err := repo.GetTotalTimeByTaskID(NewCanceledContext(), task.ID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Delete with cancelled context", func(t *testing.T) {
 			err := repo.Delete(NewCanceledContext(), entry.ID)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetByDateRange with cancelled context", func(t *testing.T) {
···
 			end := time.Now()
 
 			_, err := repo.GetByDateRange(NewCanceledContext(), start, end)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 

internal/repo/tv_repository_test.go

···
 
 		t.Run("Count with context cancellation", func(t *testing.T) {
 			_, err := repo.Count(NewCanceledContext(), TVListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 
···
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newShow := NewTVShowBuilder().WithTitle("Cancelled").Build()
 			_, err := repo.Create(NewCanceledContext(), newShow)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Get with cancelled context", func(t *testing.T) {
 			_, err := repo.Get(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Update with cancelled context", func(t *testing.T) {
 			tvShow.Title = "Updated"
 			err := repo.Update(NewCanceledContext(), tvShow)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("Delete with cancelled context", func(t *testing.T) {
 			err := repo.Delete(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("List with cancelled context", func(t *testing.T) {
 			_, err := repo.List(NewCanceledContext(), TVListOptions{})
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetQueued with cancelled context", func(t *testing.T) {
 			_, err := repo.GetQueued(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetWatching with cancelled context", func(t *testing.T) {
 			_, err := repo.GetWatching(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetWatched with cancelled context", func(t *testing.T) {
 			_, err := repo.GetWatched(NewCanceledContext())
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetByTitle with cancelled context", func(t *testing.T) {
 			_, err := repo.GetByTitle(NewCanceledContext(), "Test Show")
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("GetBySeason with cancelled context", func(t *testing.T) {
 			_, err := repo.GetBySeason(NewCanceledContext(), "Test Show", 1)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("MarkWatched with cancelled context", func(t *testing.T) {
 			err := repo.MarkWatched(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 
 		t.Run("StartWatching with cancelled context", func(t *testing.T) {
 			err := repo.StartWatching(NewCanceledContext(), id)
-			AssertError(t, err, "Expected error with cancelled context")
+			AssertCancelledContext(t, err)
 		})
 	})
 

internal/ui/data_table_test.go

···
 	}
 }
 
+func testViewHandler(record DataRecord) string {
+	return fmt.Sprintf("Viewing: %v", record.GetField("name"))
+}
+
 func TestDataTable(t *testing.T) {
 	t.Run("TestDataTableOptions", func(t *testing.T) {
 		t.Run("default options", func(t *testing.T) {
···
 			var buf bytes.Buffer
 			source := &MockDataSource{records: createMockRecords()}
 			opts := DataTableOptions{
-				Output: &buf,
-				Static: true,
-				Title:  "Test Table",
-				Fields: createTestFields(),
-				ViewHandler: func(record DataRecord) string {
-					return fmt.Sprintf("Viewing: %v", record.GetField("name"))
-				},
+				Output:      &buf,
+				Static:      true,
+				Title:       "Test Table",
+				Fields:      createTestFields(),
+				ViewHandler: testViewHandler,
 			}
 
 			table := NewDataTable(source, opts)
···
 		})
 
 		t.Run("view record command", func(t *testing.T) {
-			viewHandler := func(record DataRecord) string {
-				return fmt.Sprintf("Viewing: %v", record.GetField("name"))
-			}
-
 			model := dataTableModel{
 				opts: DataTableOptions{
-					ViewHandler: viewHandler,
+					ViewHandler: testViewHandler,
 					Fields:      createTestFields(),
 				},
 			}

internal/ui/project_list_adapter_test.go

···
 				t.Errorf("GetTableName() = %q, want 'projects'", record.GetTableName())
 			}
 
-			if !record.GetCreatedAt().IsZero() {
-				t.Error("GetCreatedAt() should return zero time")
-			}
-
-			if !record.GetUpdatedAt().IsZero() {
-				t.Error("GetUpdatedAt() should return zero time")
-			}
+			Expect.AssertZeroTime(t, record.GetCreatedAt, "GetCreatedAt")
+			Expect.AssertZeroTime(t, record.GetUpdatedAt, "GetUpdatedAt")
 		})
 	})
 

internal/ui/tag_list_adapter_test.go

···
 				t.Errorf("GetTableName() = %q, want 'tags'", record.GetTableName())
 			}
 
-			if !record.GetCreatedAt().IsZero() {
-				t.Error("GetCreatedAt() should return zero time")
-			}
-
-			if !record.GetUpdatedAt().IsZero() {
-				t.Error("GetUpdatedAt() should return zero time")
-			}
+			Expect.AssertZeroTime(t, record.GetCreatedAt, "GetCreatedAt")
+			Expect.AssertZeroTime(t, record.GetUpdatedAt, "GetUpdatedAt")
 		})
 	})
 

internal/ui/test_utilities.go

···
 	}
 }
 
+func (ah *AssertionHelpers) AssertZeroTime(t *testing.T, getter func() time.Time, label string) {
+	t.Helper()
+	if !getter().IsZero() {
+		t.Errorf("%v() should return zero time", label)
+	}
+}
+
 var Expect = AssertionHelpers{}
 
 func containsString(haystack, needle string) bool {