refactor: test helpers & shared utilities

internal/articles/parser.go

···
 
 // ParsingRule represents XPath rules for extracting content from a specific domain
 type ParsingRule struct {
-	Domain string
-	Title  string
-	Author string
-	Date   string
-	Body   string
-	// XPath selectors for elements to remove
-	Strip    []string
+	Domain   string
+	Title    string
+	Author   string
+	Date     string
+	Body     string
+	Strip    []string // XPath selectors for elements to remove
 	TestURLs []string
 }
 
···
 }
 
 // ParseURL extracts article content from a given URL
-func (p *ArticleParser) ParseURL(urlStr string) (*ParsedContent, error) {
-	parsedURL, err := url.Parse(urlStr)
+func (p *ArticleParser) ParseURL(s string) (*ParsedContent, error) {
+	parsedURL, err := url.Parse(s)
 	if err != nil {
 		return nil, fmt.Errorf("invalid URL: %w", err)
 	}
 
 	domain := parsedURL.Hostname()
 
-	resp, err := p.client.Get(urlStr)
+	resp, err := p.client.Get(s)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch URL: %w", err)
 	}
···
 		return nil, fmt.Errorf("failed to read response body: %w", err)
 	}
 
-	return p.Parse(string(htmlBytes), domain, urlStr)
+	return p.Parse(string(htmlBytes), domain, s)
 }
 
 // ParseHTML extracts article content from HTML string using domain-specific rules
···
 }
 
 // SaveArticle saves the parsed content to filesystem and returns file paths
-func (p *ArticleParser) SaveArticle(content *ParsedContent, storageDir string) (markdownPath, htmlPath string, err error) {
-	if err := os.MkdirAll(storageDir, 0755); err != nil {
+func (p *ArticleParser) SaveArticle(content *ParsedContent, dir string) (markdownPath, htmlPath string, err error) {
+	if err := os.MkdirAll(dir, 0755); err != nil {
 		return "", "", fmt.Errorf("failed to create storage directory: %w", err)
 	}
 
···
 		slug = "article"
 	}
 
-	baseMarkdownPath := filepath.Join(storageDir, slug+".md")
-	baseHTMLPath := filepath.Join(storageDir, slug+".html")
+	baseMarkdownPath := filepath.Join(dir, slug+".md")
+	baseHTMLPath := filepath.Join(dir, slug+".html")
 
 	markdownPath = baseMarkdownPath
 	htmlPath = baseHTMLPath
···
 				break
 			}
 		}
-		markdownPath = filepath.Join(storageDir, fmt.Sprintf("%s_%d.md", slug, counter))
-		htmlPath = filepath.Join(storageDir, fmt.Sprintf("%s_%d.html", slug, counter))
+		markdownPath = filepath.Join(dir, fmt.Sprintf("%s_%d.md", slug, counter))
+		htmlPath = filepath.Join(dir, fmt.Sprintf("%s_%d.html", slug, counter))
 		counter++
 	}
 
···
 		return nil, fmt.Errorf("failed to save article: %w", err)
 	}
 
-	article := &models.Article{
+	return &models.Article{
 		URL:          url,
 		Title:        content.Title,
 		Author:       content.Author,
···
 		HTMLPath:     htmlPath,
 		Created:      time.Now(),
 		Modified:     time.Now(),
-	}
-
-	return article, nil
+	}, nil
 }

internal/articles/parser_test.go

···
 	t.Run("slugify", func(t *testing.T) {
 		parser := &ArticleParser{}
 
-		testCases := []struct {
+		tc := []struct {
 			input    string
 			expected string
 		}{
···
 			{strings.Repeat("a", 150), strings.Repeat("a", 100)},
 		}
 
-		for _, tc := range testCases {
-			t.Run(fmt.Sprintf("slugify '%s'", tc.input), func(t *testing.T) {
-				result := parser.slugify(tc.input)
-				if result != tc.expected {
-					t.Errorf("Expected '%s', got '%s'", tc.expected, result)
+		for _, tt := range tc {
+			t.Run(fmt.Sprintf("slugify '%s'", tt.input), func(t *testing.T) {
+				result := parser.slugify(tt.input)
+				if result != tt.expected {
+					t.Errorf("Expected '%s', got '%s'", tt.expected, result)
 				}
 			})
 		}
···
 		}))
 		defer server.Close()
 
-		// Use a direct Wikipedia URL that would be processed by the real function
 		_, err := CreateArticleFromURL("https://en.wikipedia.org/wiki/NonExistentPage12345", tempDir)
 		if err == nil {
 			t.Error("Expected error for HTTP 404")
···
 	})
 
 	t.Run("fails with network error", func(t *testing.T) {
-		// Use a non-existent server to trigger network error
 		_, err := CreateArticleFromURL("http://localhost:99999/test", tempDir)
 		if err == nil {
 			t.Error("Expected error for network failure")
···
 	t.Run("fails with malformed HTML", func(t *testing.T) {
 		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.WriteHeader(http.StatusOK)
-			w.Write([]byte("<html><head><title>Test</head></body>")) // Malformed HTML
+			w.Write([]byte("<html><head><title>Test</head></body>"))
 		}))
 		defer server.Close()
 
-		// Create a custom parser with localhost rule for testing
 		parser, err := NewArticleParser(server.Client())
 		if err != nil {
 			t.Fatalf("Failed to create parser: %v", err)
···
 		if err == nil {
 			t.Error("Expected error for malformed HTML")
 		}
-		// Malformed HTML may either fail to parse or fail to extract title
 		if !strings.Contains(err.Error(), "failed to parse HTML") && !strings.Contains(err.Error(), "could not extract title") {
 			t.Errorf("Expected HTML parsing or title extraction error, got %v", err)
 		}
···
 		}))
 		defer server.Close()
 
-		// Create a custom parser with localhost rule for testing
 		parser, err := NewArticleParser(server.Client())
 		if err != nil {
 			t.Fatalf("Failed to create parser: %v", err)
···
 		server := newServerWithHtml(wikipediaHTML)
 		defer server.Close()
 
-		// Create a custom parser with localhost rule for testing
 		parser, err := NewArticleParser(server.Client())
 		if err != nil {
 			t.Fatalf("Failed to create parser: %v", err)
···
 			t.Error("Expected Modified timestamp to be set")
 		}
 
-		// Check files exist
 		if _, err := os.Stat(article.MarkdownPath); os.IsNotExist(err) {
 			t.Error("Expected markdown file to exist")
 		}
···
 			t.Error("Expected HTML file to exist")
 		}
 
-		// Verify file contents
 		mdContent, err := os.ReadFile(article.MarkdownPath)
 		if err != nil {
 			t.Fatalf("Failed to read markdown file: %v", err)

internal/handlers/articles_test.go

···
 	"github.com/stormlightlabs/noteleaf/internal/articles"
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestArticleHandler(t *testing.T) {
···
 			}
 
 			_, err := NewArticleHandler()
-			Expect.AssertError(t, err, "failed to initialize database", "NewArticleHandler should fail when database initialization fails")
+			shared.AssertErrorContains(t, err, "failed to initialize database", "NewArticleHandler should fail when database initialization fails")
 		})
 
 	})
···
 			helper.AddTestRule("127.0.0.1", testRule)
 
 			err := helper.Add(ctx, server.URL+"/test-article")
-			Expect.AssertNoError(t, err, "Add should succeed with valid URL")
+			shared.AssertNoError(t, err, "Add should succeed with valid URL")
 
 			articles, err := helper.repos.Articles.List(ctx, &repo.ArticleListOptions{})
 			if err != nil {
···
 			}
 
 			err = helper.Add(ctx, duplicateURL)
-			Expect.AssertNoError(t, err, "Add should succeed with duplicate URL and return existing")
+			shared.AssertNoError(t, err, "Add should succeed with duplicate URL and return existing")
 		})
 
 		t.Run("handles unsupported domain", func(t *testing.T) {
···
 			defer server.Close()
 
 			err := helper.Add(ctx, server.URL+"/unsupported")
-			Expect.AssertError(t, err, "failed to parse article", "Add should fail with unsupported domain")
+			shared.AssertErrorContains(t, err, "failed to parse article", "Add should fail with unsupported domain")
 		})
 
 		t.Run("handles HTTP error", func(t *testing.T) {
···
 			defer server.Close()
 
 			err := helper.Add(ctx, server.URL+"/404")
-			Expect.AssertError(t, err, "failed to parse article", "Add should fail with HTTP error")
+			shared.AssertErrorContains(t, err, "failed to parse article", "Add should fail with HTTP error")
 		})
 
 		t.Run("handles storage directory error", func(t *testing.T) {
···
 			}
 
 			err := helper.Add(ctx, "https://example.com/test-article")
-			Expect.AssertError(t, err, "failed to get article storage dir", "Add should fail when storage directory cannot be determined")
+			shared.AssertErrorContains(t, err, "failed to get article storage dir", "Add should fail when storage directory cannot be determined")
 		})
 
 		t.Run("handles database save error", func(t *testing.T) {
···
 			helper.db.Exec("DROP TABLE articles")
 
 			err := helper.Add(ctx, server.URL+"/test")
-			Expect.AssertError(t, err, "failed to save article to database", "Add should fail when database save fails")
+			shared.AssertErrorContains(t, err, "failed to save article to database", "Add should fail when database save fails")
 		})
 	})
 
···
 			id2 := helper.CreateTestArticle(t, "https://example.com/article2", "Second Article", "Jane Smith", "2024-01-02")
 
 			err := helper.List(ctx, "", "", 0)
-			Expect.AssertNoError(t, err, "List should succeed")
+			shared.AssertNoError(t, err, "List should succeed")
 
 			AssertExists(t, helper.repos.Articles.Get, id1, "article")
 			AssertExists(t, helper.repos.Articles.Get, id2, "article")
···
 			helper.CreateTestArticle(t, "https://example.com/second", "Second Article", "Jane", "2024-01-02")
 
 			err := helper.List(ctx, "First", "", 0)
-			Expect.AssertNoError(t, err, "List with title filter should succeed")
+			shared.AssertNoError(t, err, "List with title filter should succeed")
 		})
 
 		t.Run("lists with author filter", func(t *testing.T) {
···
 			helper.CreateTestArticle(t, "https://example.com/jane1", "Article by Jane", "Jane Smith", "2024-01-02")
 
 			err := helper.List(ctx, "", "John", 0)
-			Expect.AssertNoError(t, err, "List with author filter should succeed")
+			shared.AssertNoError(t, err, "List with author filter should succeed")
 		})
 
 		t.Run("lists with limit", func(t *testing.T) {
···
 			helper.CreateTestArticle(t, "https://example.com/3", "Article 3", "Author", "2024-01-03")
 
 			err := helper.List(ctx, "", "", 2)
-			Expect.AssertNoError(t, err, "List with limit should succeed")
+			shared.AssertNoError(t, err, "List with limit should succeed")
 		})
 
 		t.Run("handles empty results", func(t *testing.T) {
···
 			ctx := context.Background()
 
 			err := helper.List(ctx, "nonexistent", "", 0)
-			Expect.AssertNoError(t, err, "List with no matches should succeed")
+			shared.AssertNoError(t, err, "List with no matches should succeed")
 		})
 
 		t.Run("handles database error", func(t *testing.T) {
···
 			helper.db.Exec("DROP TABLE articles")
 
 			err := helper.List(ctx, "", "", 0)
-			Expect.AssertError(t, err, "failed to list articles", "List should fail when database is corrupted")
+			shared.AssertErrorContains(t, err, "failed to list articles", "List should fail when database is corrupted")
 		})
 	})
 
···
 			id := helper.CreateTestArticle(t, "https://example.com/test", "Test Article", "Test Author", "2024-01-01")
 
 			err := helper.View(ctx, id)
-			Expect.AssertNoError(t, err, "View should succeed with valid article ID")
+			shared.AssertNoError(t, err, "View should succeed with valid article ID")
 		})
 
 		t.Run("handles non-existent article", func(t *testing.T) {
···
 			ctx := context.Background()
 
 			err := helper.View(ctx, 99999)
-			Expect.AssertError(t, err, "failed to get article", "View should fail with non-existent article ID")
+			shared.AssertErrorContains(t, err, "failed to get article", "View should fail with non-existent article ID")
 		})
 
 		t.Run("handles missing files gracefully", func(t *testing.T) {
···
 			}
 
 			err = helper.View(ctx, id)
-			Expect.AssertNoError(t, err, "View should succeed even when files are missing")
+			shared.AssertNoError(t, err, "View should succeed even when files are missing")
 		})
 
 		t.Run("handles database error", func(t *testing.T) {
···
 			helper.db.Exec("DROP TABLE articles")
 
 			err := helper.View(ctx, 1)
-			Expect.AssertError(t, err, "failed to get article", "View should fail when database is corrupted")
+			shared.AssertErrorContains(t, err, "failed to get article", "View should fail when database is corrupted")
 		})
 	})
 
···
 			ctx := context.Background()
 			id := helper.CreateTestArticle(t, "https://example.com/read", "Read Test Article", "Test Author", "2024-01-01")
 			err := helper.Read(ctx, id)
-			Expect.AssertNoError(t, err, "Read should succeed with valid article ID")
+			shared.AssertNoError(t, err, "Read should succeed with valid article ID")
 		})
 
 		t.Run("handles non-existent article", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			ctx := context.Background()
 			err := helper.Read(ctx, 99999)
-			Expect.AssertError(t, err, "failed to get article", "Read should fail with non-existent article ID")
+			shared.AssertErrorContains(t, err, "failed to get article", "Read should fail with non-existent article ID")
 		})
 
 		t.Run("handles missing markdown file", func(t *testing.T) {
···
 			}
 
 			err = helper.Read(ctx, id)
-			Expect.AssertError(t, err, "markdown file not found", "Read should fail when markdown file is missing")
+			shared.AssertErrorContains(t, err, "markdown file not found", "Read should fail when markdown file is missing")
 		})
 
 		t.Run("handles database error", func(t *testing.T) {
···
 			ctx := context.Background()
 			helper.db.Exec("DROP TABLE articles")
 			err := helper.Read(ctx, 1)
-			Expect.AssertError(t, err, "failed to get article", "Read should fail when database is corrupted")
+			shared.AssertErrorContains(t, err, "failed to get article", "Read should fail when database is corrupted")
 		})
 	})
 
···
 			AssertExists(t, helper.repos.Articles.Get, id, "article")
 
 			err := helper.Remove(ctx, id)
-			Expect.AssertNoError(t, err, "Remove should succeed")
+			shared.AssertNoError(t, err, "Remove should succeed")
 			AssertNotExists(t, helper.repos.Articles.Get, id, "article")
 		})
 
···
 			helper := NewArticleTestHelper(t)
 			ctx := context.Background()
 			err := helper.Remove(ctx, 99999)
-			Expect.AssertError(t, err, "failed to get article", "Remove should fail with non-existent article ID")
+			shared.AssertErrorContains(t, err, "failed to get article", "Remove should fail with non-existent article ID")
 		})
 
 		t.Run("handles missing files gracefully", func(t *testing.T) {
···
 			}
 
 			err = helper.Remove(ctx, id)
-			Expect.AssertNoError(t, err, "Remove should succeed even when files don't exist")
+			shared.AssertNoError(t, err, "Remove should succeed even when files don't exist")
 		})
 
 		t.Run("handles database error", func(t *testing.T) {
···
 			helper.db.Exec("DROP TABLE articles")
 
 			err := helper.Remove(ctx, id)
-			Expect.AssertError(t, err, "failed to get article", "Remove should fail when database is corrupted")
+			shared.AssertErrorContains(t, err, "failed to get article", "Remove should fail when database is corrupted")
 		})
 	})
 
···
 		t.Run("shows supported domains", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			err := helper.Help()
-			Expect.AssertNoError(t, err, "Help should succeed")
+			shared.AssertNoError(t, err, "Help should succeed")
 		})
 
 		t.Run("handles storage directory error", func(t *testing.T) {
···
 			}
 
 			err := helper.Help()
-			Expect.AssertError(t, err, "failed to get storage directory", "Help should fail when storage directory cannot be determined")
+			shared.AssertErrorContains(t, err, "failed to get storage directory", "Help should fail when storage directory cannot be determined")
 		})
 	})
 
···
 		t.Run("closes successfully", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			err := helper.Close()
-			Expect.AssertNoError(t, err, "Close should succeed")
+			shared.AssertNoError(t, err, "Close should succeed")
 		})
 
 		t.Run("handles nil database gracefully", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			helper.db = nil
 			err := helper.Close()
-			Expect.AssertNoError(t, err, "Close should succeed with nil database")
+			shared.AssertNoError(t, err, "Close should succeed with nil database")
 		})
 	})
 
···
 		t.Run("returns storage directory successfully", func(t *testing.T) {
 			helper := NewArticleTestHelper(t)
 			dir, err := helper.getStorageDirectory()
-			Expect.AssertNoError(t, err, "getStorageDirectory should succeed")
+			shared.AssertNoError(t, err, "getStorageDirectory should succeed")
 
 			if dir == "" {
 				t.Error("Storage directory should not be empty")
···
 			}
 
 			_, err := helper.getStorageDirectory()
-			Expect.AssertError(t, err, "", "getStorageDirectory should fail when home directory cannot be determined")
+			shared.AssertErrorContains(t, err, "", "getStorageDirectory should fail when home directory cannot be determined")
 		})
 	})
 }
···
 		helper.AddTestRule("127.0.0.1", testRule)
 
 		err := helper.Add(ctx, server.URL+"/integration-test")
-		Expect.AssertNoError(t, err, "Add should succeed in integration test")
+		shared.AssertNoError(t, err, "Add should succeed in integration test")
 
 		err = helper.List(ctx, "", "", 0)
-		Expect.AssertNoError(t, err, "List should succeed in integration test")
+		shared.AssertNoError(t, err, "List should succeed in integration test")
 
 		articles, err := helper.repos.Articles.List(ctx, &repo.ArticleListOptions{})
 		if err != nil {
···
 		articleID := articles[0].ID
 
 		err = helper.View(ctx, articleID)
-		Expect.AssertNoError(t, err, "View should succeed in integration test")
+		shared.AssertNoError(t, err, "View should succeed in integration test")
 
 		err = helper.Help()
-		Expect.AssertNoError(t, err, "Help should succeed in integration test")
+		shared.AssertNoError(t, err, "Help should succeed in integration test")
 
 		err = helper.Remove(ctx, articleID)
-		Expect.AssertNoError(t, err, "Remove should succeed in integration test")
+		shared.AssertNoError(t, err, "Remove should succeed in integration test")
 
 		AssertNotExists(t, helper.repos.Articles.Get, articleID, "article")
 	})

internal/handlers/books_test.go

···
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"github.com/stormlightlabs/noteleaf/internal/repo"
 	"github.com/stormlightlabs/noteleaf/internal/services"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
-
-// setupBookTest removed - use NewHandlerTestSuite(t) instead
 
 func createTestBook(t *testing.T, handler *BookHandler, ctx context.Context) *models.Book {
 	t.Helper()
···
 			})
 
 			t.Run("handles HTTP error responses", func(t *testing.T) {
-				mockServer := HTTPErrorMockServer(500, "Internal Server Error")
+				mockServer := shared.HTTPErrorMockServer(500, "Internal Server Error")
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 			})
 
 			t.Run("handles malformed JSON response", func(t *testing.T) {
-				mockServer := InvalidJSONMockServer()
+				mockServer := shared.InvalidJSONMockServer()
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 					NumFound: 0, Start: 0, Docs: []services.OpenLibrarySearchDoc{},
 				}
 
-				mockServer := JSONMockServer(emptyResponse)
+				mockServer := shared.JSONMockServer(emptyResponse)
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 			})
 
 			t.Run("handles network timeouts", func(t *testing.T) {
-				mockServer := TimeoutMockServer(5 * time.Second)
+				mockServer := shared.TimeoutMockServer(5 * time.Second)
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 					{Key: "/works/OL123456W", Title: "Test Book", Authors: []string{"Author"}, Year: 2020},
 				}
 				mockResponse := MockOpenLibraryResponse(mockBooks)
-				mockServer := JSONMockServer(mockResponse)
+				mockServer := shared.JSONMockServer(mockResponse)
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 					{Key: "/works/OL456W", Title: "Test Book 2", Authors: []string{"Author 2"}, Year: 2021, Editions: 3, CoverID: 456},
 				}
 				mockResponse := MockOpenLibraryResponse(mockBooks)
-				mockServer := JSONMockServer(mockResponse)
+				mockServer := shared.JSONMockServer(mockResponse)
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 					{Key: "/works/OL789W", Title: "Another Book", Authors: []string{"Another Author"}, Year: 2022},
 				}
 				mockResponse := MockOpenLibraryResponse(mockBooks)
-				mockServer := JSONMockServer(mockResponse)
+				mockServer := shared.JSONMockServer(mockResponse)
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 					{Key: "/works/OL999W", Title: "Choice Test Book", Authors: []string{"Choice Author"}, Year: 2023},
 				}
 				mockResponse := MockOpenLibraryResponse(mockBooks)
-				mockServer := JSONMockServer(mockResponse)
+				mockServer := shared.JSONMockServer(mockResponse)
 				defer mockServer.Close()
 
 				handler.service = services.NewBookService(mockServer.URL())
···
 	})
 }
 
-// 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)
 
···
 		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)
 
···
 		suite.AssertNoError(err, "NewBookHandler")
 		defer handler.Close()
 
-		// Create a test book first
 		book := &models.Book{
 			Title:  "Suite Test Book",
 			Author: "Suite Test Author",
···
 			Added:  time.Now(),
 		}
 		id, err := handler.repos.Books.Create(suite.Context(), book)
-		suite.AssertNoError(err, "Create test book")
 
-		// Test list operation
+		suite.AssertNoError(err, "Create test book")
 		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_test.go

···
 	"strings"
 	"testing"
 
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
-func TestConfigHandlerGet(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-config-handler-get-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
+func TestConfigHandler(t *testing.T) {
+	t.Run("Get", func(t *testing.T) {
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-handler-get-test-*", t)
+		defer cleanup()
 
-	// Set up environment
-	customConfigPath := filepath.Join(tempDir, "test-config.toml")
-	originalEnv := os.Getenv("NOTELEAF_CONFIG")
-	os.Setenv("NOTELEAF_CONFIG", customConfigPath)
-	defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
+		customConfigPath := filepath.Join(tempDir, "test-config.toml")
+		originalEnv := os.Getenv("NOTELEAF_CONFIG")
+		os.Setenv("NOTELEAF_CONFIG", customConfigPath)
+		defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
 
-	// Create a test config
-	config := store.DefaultConfig()
-	config.ColorScheme = "test-scheme"
-	config.Editor = "vim"
-	if err := store.SaveConfig(config); err != nil {
-		t.Fatalf("Failed to save config: %v", err)
-	}
-
-	t.Run("Get all config values", func(t *testing.T) {
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
+		config := store.DefaultConfig()
+		config.ColorScheme = "test-scheme"
+		config.Editor = "vim"
+		if err := store.SaveConfig(config); err != nil {
+			t.Fatalf("Failed to save config: %v", err)
 		}
 
-		// Capture stdout
-		oldStdout := os.Stdout
-		r, w, _ := os.Pipe()
-		os.Stdout = w
+		t.Run("Get all config values", func(t *testing.T) {
+			handler, err := NewConfigHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
 
-		err = handler.Get("")
-		if err != nil {
-			t.Fatalf("Get failed: %v", err)
-		}
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
 
-		w.Close()
-		os.Stdout = oldStdout
+			err = handler.Get("")
+			if err != nil {
+				t.Fatalf("Get failed: %v", err)
+			}
 
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-		output := buf.String()
+			w.Close()
+			os.Stdout = oldStdout
 
-		if !strings.Contains(output, "color_scheme") {
-			t.Error("Output should contain color_scheme")
-		}
-		if !strings.Contains(output, "test-scheme") {
-			t.Error("Output should contain test-scheme value")
-		}
-	})
+			var buf bytes.Buffer
+			io.Copy(&buf, r)
+			output := buf.String()
 
-	t.Run("Get specific config value", func(t *testing.T) {
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
-
-		// Capture stdout
-		oldStdout := os.Stdout
-		r, w, _ := os.Pipe()
-		os.Stdout = w
-
-		err = handler.Get("editor")
-		if err != nil {
-			t.Fatalf("Get failed: %v", err)
-		}
-
-		w.Close()
-		os.Stdout = oldStdout
-
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-		output := buf.String()
+			if !strings.Contains(output, "color_scheme") {
+				t.Error("Output should contain color_scheme")
+			}
+			if !strings.Contains(output, "test-scheme") {
+				t.Error("Output should contain test-scheme value")
+			}
+		})
 
-		if !strings.Contains(output, "editor = vim") {
-			t.Errorf("Output should contain 'editor = vim', got: %s", output)
-		}
-	})
+		t.Run("Get specific config value", func(t *testing.T) {
+			handler, err := NewConfigHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
 
-	t.Run("Get unknown config key", func(t *testing.T) {
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
 
-		err = handler.Get("nonexistent_key")
-		if err == nil {
-			t.Error("Get should fail for unknown key")
-		}
-		if !strings.Contains(err.Error(), "unknown config key") {
-			t.Errorf("Error should mention unknown config key, got: %v", err)
-		}
-	})
-}
+			err = handler.Get("editor")
+			if err != nil {
+				t.Fatalf("Get failed: %v", err)
+			}
 
-func TestConfigHandlerSet(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-config-handler-set-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
+			w.Close()
+			os.Stdout = oldStdout
 
-	// Set up environment
-	customConfigPath := filepath.Join(tempDir, "test-config.toml")
-	originalEnv := os.Getenv("NOTELEAF_CONFIG")
-	os.Setenv("NOTELEAF_CONFIG", customConfigPath)
-	defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
+			var buf bytes.Buffer
+			io.Copy(&buf, r)
+			output := buf.String()
 
-	t.Run("Set string config value", func(t *testing.T) {
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
+			if !strings.Contains(output, "editor = vim") {
+				t.Errorf("Output should contain 'editor = vim', got: %s", output)
+			}
+		})
 
-		// Capture stdout
-		oldStdout := os.Stdout
-		r, w, _ := os.Pipe()
-		os.Stdout = w
+		t.Run("Get unknown config key", func(t *testing.T) {
+			handler, err := NewConfigHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
 
-		err = handler.Set("editor", "emacs")
-		if err != nil {
-			t.Fatalf("Set failed: %v", err)
-		}
+			err = handler.Get("nonexistent_key")
+			if err == nil {
+				t.Error("Get should fail for unknown key")
+			}
+			if !strings.Contains(err.Error(), "unknown config key") {
+				t.Errorf("Error should mention unknown config key, got: %v", err)
+			}
+		})
+	})
 
-		w.Close()
-		os.Stdout = oldStdout
+	t.Run("Set", func(t *testing.T) {
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-handler-set-test-*", t)
+		defer cleanup()
 
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-		output := buf.String()
+		customConfigPath := filepath.Join(tempDir, "test-config.toml")
+		originalEnv := os.Getenv("NOTELEAF_CONFIG")
+		os.Setenv("NOTELEAF_CONFIG", customConfigPath)
+		defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
 
-		if !strings.Contains(output, "Set editor = emacs") {
-			t.Errorf("Output should confirm setting, got: %s", output)
-		}
+		t.Run("Set string config value", func(t *testing.T) {
+			handler, err := NewConfigHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
 
-		// Verify it was actually saved
-		loadedConfig, err := store.LoadConfig()
-		if err != nil {
-			t.Fatalf("Failed to load config: %v", err)
-		}
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
 
-		if loadedConfig.Editor != "emacs" {
-			t.Errorf("Expected editor 'emacs', got '%s'", loadedConfig.Editor)
-		}
-	})
+			err = handler.Set("editor", "emacs")
+			if err != nil {
+				t.Fatalf("Set failed: %v", err)
+			}
 
-	t.Run("Set boolean config value", func(t *testing.T) {
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
+			w.Close()
+			os.Stdout = oldStdout
 
-		err = handler.Set("auto_archive", "true")
-		if err != nil {
-			t.Fatalf("Set failed: %v", err)
-		}
+			var buf bytes.Buffer
+			io.Copy(&buf, r)
+			output := buf.String()
 
-		// Verify it was actually saved
-		loadedConfig, err := store.LoadConfig()
-		if err != nil {
-			t.Fatalf("Failed to load config: %v", err)
-		}
+			if !strings.Contains(output, "Set editor = emacs") {
+				t.Errorf("Output should confirm setting, got: %s", output)
+			}
 
-		if !loadedConfig.AutoArchive {
-			t.Error("Expected auto_archive to be true")
-		}
-	})
+			loadedConfig, err := store.LoadConfig()
+			if err != nil {
+				t.Fatalf("Failed to load config: %v", err)
+			}
 
-	t.Run("Set boolean config value with various formats", func(t *testing.T) {
-		testCases := []struct {
-			value    string
-			expected bool
-		}{
-			{"true", true},
-			{"1", true},
-			{"yes", true},
-			{"false", false},
-			{"0", false},
-			{"no", false},
-		}
+			if loadedConfig.Editor != "emacs" {
+				t.Errorf("Expected editor 'emacs', got '%s'", loadedConfig.Editor)
+			}
+		})
 
-		for _, tc := range testCases {
+		t.Run("Set boolean config value", func(t *testing.T) {
 			handler, err := NewConfigHandler()
 			if err != nil {
 				t.Fatalf("Failed to create handler: %v", err)
 			}
 
-			err = handler.Set("sync_enabled", tc.value)
+			err = handler.Set("auto_archive", "true")
 			if err != nil {
-				t.Fatalf("Set failed for value '%s': %v", tc.value, err)
+				t.Fatalf("Set failed: %v", err)
 			}
 
 			loadedConfig, err := store.LoadConfig()
···
 				t.Fatalf("Failed to load config: %v", err)
 			}
 
-			if loadedConfig.SyncEnabled != tc.expected {
-				t.Errorf("For value '%s', expected sync_enabled %v, got %v", tc.value, tc.expected, loadedConfig.SyncEnabled)
+			if !loadedConfig.AutoArchive {
+				t.Error("Expected auto_archive to be true")
 			}
-		}
-	})
+		})
 
-	t.Run("Set unknown config key", func(t *testing.T) {
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
+		t.Run("Set boolean config value with various formats", func(t *testing.T) {
+			tc := []struct {
+				value    string
+				expected bool
+			}{
+				{"true", true},
+				{"1", true},
+				{"yes", true},
+				{"false", false},
+				{"0", false},
+				{"no", false},
+			}
 
-		err = handler.Set("nonexistent_key", "value")
-		if err == nil {
-			t.Error("Set should fail for unknown key")
-		}
-		if !strings.Contains(err.Error(), "unknown config key") {
-			t.Errorf("Error should mention unknown config key, got: %v", err)
-		}
-	})
-}
+			for _, tt := range tc {
+				handler, err := NewConfigHandler()
+				if err != nil {
+					t.Fatalf("Failed to create handler: %v", err)
+				}
 
-func TestConfigHandlerPath(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-config-handler-path-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
+				err = handler.Set("sync_enabled", tt.value)
+				if err != nil {
+					t.Fatalf("Set failed for value '%s': %v", tt.value, err)
+				}
 
-	customConfigPath := filepath.Join(tempDir, "my-config.toml")
-	originalEnv := os.Getenv("NOTELEAF_CONFIG")
-	os.Setenv("NOTELEAF_CONFIG", customConfigPath)
-	defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
+				loadedConfig, err := store.LoadConfig()
+				if err != nil {
+					t.Fatalf("Failed to load config: %v", err)
+				}
 
-	t.Run("Path returns correct config file path", func(t *testing.T) {
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
+				if loadedConfig.SyncEnabled != tt.expected {
+					t.Errorf("For value '%s', expected sync_enabled %v, got %v", tt.value, tt.expected, loadedConfig.SyncEnabled)
+				}
+			}
+		})
 
-		// Capture stdout
-		oldStdout := os.Stdout
-		r, w, _ := os.Pipe()
-		os.Stdout = w
+		t.Run("Set unknown config key", func(t *testing.T) {
+			handler, err := NewConfigHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
 
-		err = handler.Path()
-		if err != nil {
-			t.Fatalf("Path failed: %v", err)
-		}
+			err = handler.Set("nonexistent_key", "value")
+			if err == nil {
+				t.Error("Set should fail for unknown key")
+			}
+			if !strings.Contains(err.Error(), "unknown config key") {
+				t.Errorf("Error should mention unknown config key, got: %v", err)
+			}
+		})
+	})
+	t.Run("Path", func(t *testing.T) {
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-handler-path-test-*", t)
+		defer cleanup()
 
-		w.Close()
-		os.Stdout = oldStdout
+		customConfigPath := filepath.Join(tempDir, "my-config.toml")
+		originalEnv := os.Getenv("NOTELEAF_CONFIG")
+		os.Setenv("NOTELEAF_CONFIG", customConfigPath)
+		defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
 
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-		output := strings.TrimSpace(buf.String())
+		t.Run("Path returns correct config file path", func(t *testing.T) {
+			handler, err := NewConfigHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
 
-		if output != customConfigPath {
-			t.Errorf("Expected path '%s', got '%s'", customConfigPath, output)
-		}
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
+
+			err = handler.Path()
+			if err != nil {
+				t.Fatalf("Path failed: %v", err)
+			}
+
+			w.Close()
+			os.Stdout = oldStdout
+
+			var buf bytes.Buffer
+			io.Copy(&buf, r)
+			output := strings.TrimSpace(buf.String())
+
+			if output != customConfigPath {
+				t.Errorf("Expected path '%s', got '%s'", customConfigPath, output)
+			}
+		})
 	})
-}
 
-func TestConfigHandlerReset(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-config-handler-reset-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
+	t.Run("Reset", func(t *testing.T) {
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-handler-reset-test-*", t)
+		defer cleanup()
 
-	customConfigPath := filepath.Join(tempDir, "test-config.toml")
-	originalEnv := os.Getenv("NOTELEAF_CONFIG")
-	os.Setenv("NOTELEAF_CONFIG", customConfigPath)
-	defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
+		customConfigPath := filepath.Join(tempDir, "test-config.toml")
+		originalEnv := os.Getenv("NOTELEAF_CONFIG")
+		os.Setenv("NOTELEAF_CONFIG", customConfigPath)
+		defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
 
-	t.Run("Reset restores default config", func(t *testing.T) {
-		// First, modify the config
-		config := store.DefaultConfig()
-		config.ColorScheme = "custom"
-		config.AutoArchive = true
-		config.Editor = "emacs"
-		if err := store.SaveConfig(config); err != nil {
-			t.Fatalf("Failed to save config: %v", err)
-		}
+		t.Run("Reset restores default config", func(t *testing.T) {
+			config := store.DefaultConfig()
+			config.ColorScheme = "custom"
+			config.AutoArchive = true
+			config.Editor = "emacs"
+			if err := store.SaveConfig(config); err != nil {
+				t.Fatalf("Failed to save config: %v", err)
+			}
 
-		handler, err := NewConfigHandler()
-		if err != nil {
-			t.Fatalf("Failed to create handler: %v", err)
-		}
+			handler, err := NewConfigHandler()
+			if err != nil {
+				t.Fatalf("Failed to create handler: %v", err)
+			}
 
-		// Capture stdout
-		oldStdout := os.Stdout
-		r, w, _ := os.Pipe()
-		os.Stdout = w
+			oldStdout := os.Stdout
+			r, w, _ := os.Pipe()
+			os.Stdout = w
 
-		err = handler.Reset()
-		if err != nil {
-			t.Fatalf("Reset failed: %v", err)
-		}
+			err = handler.Reset()
+			if err != nil {
+				t.Fatalf("Reset failed: %v", err)
+			}
 
-		w.Close()
-		os.Stdout = oldStdout
+			w.Close()
+			os.Stdout = oldStdout
 
-		var buf bytes.Buffer
-		io.Copy(&buf, r)
-		output := buf.String()
+			var buf bytes.Buffer
+			io.Copy(&buf, r)
+			output := buf.String()
 
-		if !strings.Contains(output, "reset to defaults") {
-			t.Errorf("Output should confirm reset, got: %s", output)
-		}
+			if !strings.Contains(output, "reset to defaults") {
+				t.Errorf("Output should confirm reset, got: %s", output)
+			}
 
-		// Verify config was reset
-		loadedConfig, err := store.LoadConfig()
-		if err != nil {
-			t.Fatalf("Failed to load config: %v", err)
-		}
+			loadedConfig, err := store.LoadConfig()
+			if err != nil {
+				t.Fatalf("Failed to load config: %v", err)
+			}
 
-		defaultConfig := store.DefaultConfig()
-		if loadedConfig.ColorScheme != defaultConfig.ColorScheme {
-			t.Errorf("ColorScheme should be reset to default '%s', got '%s'", defaultConfig.ColorScheme, loadedConfig.ColorScheme)
-		}
-		if loadedConfig.AutoArchive != defaultConfig.AutoArchive {
-			t.Errorf("AutoArchive should be reset to default %v, got %v", defaultConfig.AutoArchive, loadedConfig.AutoArchive)
-		}
-		if loadedConfig.Editor != defaultConfig.Editor {
-			t.Errorf("Editor should be reset to default '%s', got '%s'", defaultConfig.Editor, loadedConfig.Editor)
-		}
+			defaultConfig := store.DefaultConfig()
+			if loadedConfig.ColorScheme != defaultConfig.ColorScheme {
+				t.Errorf("ColorScheme should be reset to default '%s', got '%s'", defaultConfig.ColorScheme, loadedConfig.ColorScheme)
+			}
+			if loadedConfig.AutoArchive != defaultConfig.AutoArchive {
+				t.Errorf("AutoArchive should be reset to default %v, got %v", defaultConfig.AutoArchive, loadedConfig.AutoArchive)
+			}
+			if loadedConfig.Editor != defaultConfig.Editor {
+				t.Errorf("Editor should be reset to default '%s', got '%s'", defaultConfig.Editor, loadedConfig.Editor)
+			}
+		})
 	})
 }

internal/handlers/notes_test.go

···
 	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
-
-// setupNoteTest removed - use NewHandlerTestSuite(t) instead
 
 func createTestMarkdownFile(t *testing.T, dir, filename, content string) string {
 	filePath := filepath.Join(dir, filename)
···
 	t.Run("New", func(t *testing.T) {
 		t.Run("creates handler successfully", func(t *testing.T) {
 			testHandler, err := NewNoteHandler()
-			Expect.AssertNoError(t, err, "NewNoteHandler should succeed")
+			shared.AssertNoError(t, err, "NewNoteHandler should succeed")
 			if testHandler == nil {
 				t.Fatal("Handler should not be nil")
 			}
···
 			envHelper.UnsetEnv("NOTELEAF_DATA_DIR")
 
 			_, err := NewNoteHandler()
-			Expect.AssertError(t, err, "failed to initialize database", "NewNoteHandler should fail when database initialization fails")
+			shared.AssertErrorContains(t, err, "failed to initialize database", "NewNoteHandler should fail when database initialization fails")
 		})
 	})
 
···
 
 		t.Run("creates note from title only", func(t *testing.T) {
 			err := handler.Create(ctx, "Test Note 1", "", "", false)
-			Expect.AssertNoError(t, err, "Create should succeed")
+			shared.AssertNoError(t, err, "Create should succeed")
 		})
 
 		t.Run("creates note from title and content", func(t *testing.T) {
 			err := handler.Create(ctx, "Test Note 2", "This is test content", "", false)
-			Expect.AssertNoError(t, err, "Create should succeed")
+			shared.AssertNoError(t, err, "Create should succeed")
 		})
 
 		t.Run("creates note from markdown file", func(t *testing.T) {
···
 			filePath := createTestMarkdownFile(t, suite.TempDir(), "test.md", content)
 
 			err := handler.Create(ctx, "", "", filePath, false)
-			Expect.AssertNoError(t, err, "Create from file should succeed")
+			shared.AssertNoError(t, err, "Create from file should succeed")
 		})
 
 		t.Run("handles non-existent file", func(t *testing.T) {
 			err := handler.Create(ctx, "", "", "/non/existent/file.md", false)
-			Expect.AssertError(t, err, "", "Create should fail with non-existent file")
+			shared.AssertErrorContains(t, err, "", "Create should fail with non-existent file")
 		})
 	})
 
···
 
 		t.Run("handles non-existent note", func(t *testing.T) {
 			err := handler.Edit(ctx, 999)
-			Expect.AssertError(t, err, "failed to get note", "Edit should fail with non-existent note ID")
+			shared.AssertErrorContains(t, err, "failed to get note", "Edit should fail with non-existent note ID")
 		})
 
 		t.Run("handles no editor configured", func(t *testing.T) {
···
 			envHelper.SetEnv("PATH", "")
 
 			err := handler.Edit(ctx, 1)
-			Expect.AssertError(t, err, "failed to open editor", "Edit should fail when no editor is configured")
+			shared.AssertErrorContains(t, err, "failed to open editor", "Edit should fail when no editor is configured")
 		})
 
 		t.Run("handles database connection error", func(t *testing.T) {
···
 			defer func() {
 				var err error
 				handler.db, err = store.NewDatabase()
-				Expect.AssertNoError(t, err, "Failed to reconnect to database")
+				shared.AssertNoError(t, err, "Failed to reconnect to database")
 			}()
 
 			err := handler.Edit(ctx, 1)
-			Expect.AssertError(t, err, "failed to get note", "Edit should fail when database is closed")
+			shared.AssertErrorContains(t, err, "failed to get note", "Edit should fail when database is closed")
 		})
 
 		t.Run("handles temp file creation error", func(t *testing.T) {
 			testHandler, err := NewNoteHandler()
-			Expect.AssertNoError(t, err, "Failed to create test handler")
+			shared.AssertNoError(t, err, "Failed to create test handler")
 			defer testHandler.Close()
 
 			err = testHandler.Create(ctx, "Temp File Test Note", "Test content", "", false)
-			Expect.AssertNoError(t, err, "Failed to create test note")
+			shared.AssertNoError(t, err, "Failed to create test note")
 
 			envHelper := NewEnvironmentTestHelper()
 			defer envHelper.RestoreEnv()
 			envHelper.SetEnv("TMPDIR", "/non/existent/path")
 
 			err = testHandler.Edit(ctx, 1)
-			Expect.AssertError(t, err, "failed to create temporary file", "Edit should fail when temp file creation fails")
+			shared.AssertErrorContains(t, err, "failed to create temporary file", "Edit should fail when temp file creation fails")
 		})
 
 		t.Run("handles editor failure", func(t *testing.T) {
 			testHandler, err := NewNoteHandler()
-			Expect.AssertNoError(t, err, "Failed to create test handler")
+			shared.AssertNoError(t, err, "Failed to create test handler")
 			defer testHandler.Close()
 
 			err = testHandler.Create(ctx, "Editor Failure Test Note", "Test content", "", false)
-			Expect.AssertNoError(t, err, "Failed to create test note")
+			shared.AssertNoError(t, err, "Failed to create test note")
 
 			mockEditor := NewMockEditor().WithFailure("editor process failed")
 			testHandler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err = testHandler.Edit(ctx, 1)
-			Expect.AssertError(t, err, "failed to open editor", "Edit should fail when editor fails")
+			shared.AssertErrorContains(t, err, "failed to open editor", "Edit should fail when editor fails")
 		})
 
 		t.Run("handles temp file write error", func(t *testing.T) {
···
 			handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err := handler.Edit(ctx, 1)
-			Expect.AssertError(t, err, "", "Edit should handle temp file write issues")
+			shared.AssertErrorContains(t, err, "", "Edit should handle temp file write issues")
 		})
 
 		t.Run("handles file read error after editing", func(t *testing.T) {
 			testHandler, err := NewNoteHandler()
-			Expect.AssertNoError(t, err, "Failed to create test handler")
+			shared.AssertNoError(t, err, "Failed to create test handler")
 			defer testHandler.Close()
 
 			err = testHandler.Create(ctx, "File Read Error Test Note", "Test content", "", false)
-			Expect.AssertNoError(t, err, "Failed to create test note")
+			shared.AssertNoError(t, err, "Failed to create test note")
 
 			mockEditor := NewMockEditor().WithFileDeleted()
 			testHandler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err = testHandler.Edit(ctx, 1)
-			Expect.AssertError(t, err, "failed to read edited content", "Edit should fail when temp file is deleted")
+			shared.AssertErrorContains(t, err, "failed to read edited content", "Edit should fail when temp file is deleted")
 		})
 
 		t.Run("handles database update error", func(t *testing.T) {
···
 			handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err := handler.Edit(ctx, id)
-			Expect.AssertError(t, err, "failed to get note", "Edit should fail when database is corrupted")
+			shared.AssertErrorContains(t, err, "failed to get note", "Edit should fail when database is corrupted")
 		})
 
 		t.Run("handles validation error - corrupted note content", func(t *testing.T) {
···
 			handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err := handler.Edit(ctx, id)
-			Expect.AssertNoError(t, err, "Edit should succeed")
+			shared.AssertNoError(t, err, "Edit should succeed")
 		})
 
 		t.Run("Edit Errors", func(t *testing.T) {
···
 					handler.openInEditorFunc = mockEditor.GetEditorFunc()
 					err := handler.Edit(ctx, noteID)
 
-					Expect.AssertNoError(t, err, "Edit should succeed")
+					shared.AssertNoError(t, err, "Edit should succeed")
 					AssertExists(t, handler.repos.Notes.Get, noteID, "note")
 				})
 
···
 					handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 					err := handler.Edit(ctx, noteID)
-					Expect.AssertNoError(t, err, "Edit should succeed even with no changes")
+					shared.AssertNoError(t, err, "Edit should succeed even with no changes")
 				})
 
 				t.Run("handles content without title", func(t *testing.T) {
···
 					handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 					err := handler.Edit(ctx, noteID)
-					Expect.AssertNoError(t, err, "Edit should succeed without title")
+					shared.AssertNoError(t, err, "Edit should succeed without title")
 				})
 			})
 		})
···
 			handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err := handler.createInteractive(ctx)
-			Expect.AssertNoError(t, err, "createInteractive should succeed")
+			shared.AssertNoError(t, err, "createInteractive should succeed")
 		})
 
 		t.Run("handles cancelled note creation", func(t *testing.T) {
···
 			handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err := handler.createInteractive(ctx)
-			Expect.AssertNoError(t, err, "createInteractive should succeed even when cancelled")
+			shared.AssertNoError(t, err, "createInteractive should succeed even when cancelled")
 		})
 
 		t.Run("handles editor error", func(t *testing.T) {
···
 			handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err := handler.createInteractive(ctx)
-			Expect.AssertError(t, err, "failed to open editor", "createInteractive should fail when editor fails")
+			shared.AssertErrorContains(t, err, "failed to open editor", "createInteractive should fail when editor fails")
 		})
 
 		t.Run("handles no editor configured", func(t *testing.T) {
···
 			envHelper.SetEnv("PATH", "")
 
 			err := handler.createInteractive(ctx)
-			Expect.AssertError(t, err, "no editor configured", "createInteractive should fail when no editor is configured")
+			shared.AssertErrorContains(t, err, "no editor configured", "createInteractive should fail when no editor is configured")
 		})
 
 		t.Run("handles file read error after editing", func(t *testing.T) {
···
 			handler.openInEditorFunc = mockEditor.GetEditorFunc()
 
 			err := handler.createInteractive(ctx)
-			Expect.AssertError(t, err, "failed to read edited content", "createInteractive should fail when temp file is deleted")
+			shared.AssertErrorContains(t, err, "failed to read edited content", "createInteractive should fail when temp file is deleted")
 		})
 	})
 
···
 		t.Run("creates note successfully without editor prompt", func(t *testing.T) {
 			handler := NewHandlerTestHelper(t)
 			err := handler.CreateWithOptions(ctx, "Test Note", "Test content", "", false, false)
-			Expect.AssertNoError(t, err, "CreateWithOptions should succeed")
+			shared.AssertNoError(t, err, "CreateWithOptions should succeed")
 		})
 
 		t.Run("creates note successfully with editor prompt disabled", func(t *testing.T) {
 			handler := NewHandlerTestHelper(t)
 			err := handler.CreateWithOptions(ctx, "Another Test Note", "More content", "", false, false)
-			Expect.AssertNoError(t, err, "CreateWithOptions should succeed")
+			shared.AssertNoError(t, err, "CreateWithOptions should succeed")
 		})
 
 		t.Run("handles database error during creation", func(t *testing.T) {
···
 			cancel()
 
 			err := handler.CreateWithOptions(cancelCtx, "Test Note", "Test content", "", false, false)
-			Expect.AssertError(t, err, "failed to create note", "CreateWithOptions should fail with cancelled context")
+			shared.AssertErrorContains(t, err, "failed to create note", "CreateWithOptions should fail with cancelled context")
 		})
 
 		t.Run("creates note with empty content", func(t *testing.T) {
 			handler := NewHandlerTestHelper(t)
 			err := handler.CreateWithOptions(ctx, "Empty Content Note", "", "", false, false)
-			Expect.AssertNoError(t, err, "CreateWithOptions should succeed with empty content")
+			shared.AssertNoError(t, err, "CreateWithOptions should succeed with empty content")
 		})
 
 		t.Run("creates note with empty title", func(t *testing.T) {
 			handler := NewHandlerTestHelper(t)
 			err := handler.CreateWithOptions(ctx, "", "Content without title", "", false, false)
-			Expect.AssertNoError(t, err, "CreateWithOptions should succeed with empty title")
+			shared.AssertNoError(t, err, "CreateWithOptions should succeed with empty title")
 		})
 
 		t.Run("handles editor prompt with no editor available", func(t *testing.T) {
···
 			envHelper.SetEnv("PATH", "")
 
 			err := handler.CreateWithOptions(ctx, "Test Note", "Test content", "", false, true)
-			Expect.AssertNoError(t, err, "CreateWithOptions should succeed even when no editor is available")
+			shared.AssertNoError(t, err, "CreateWithOptions should succeed even when no editor is available")
 		})
 	})
 

internal/handlers/seed_test.go

···
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
-// setupSeedTest removed - use NewHandlerTestSuite(t) instead
-
 func countRecords(t *testing.T, db *store.Database, table string) int {
 	t.Helper()
 

internal/handlers/tasks_test.go

···
 
 	"github.com/google/uuid"
 	"github.com/stormlightlabs/noteleaf/internal/models"
-	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 	"github.com/stormlightlabs/noteleaf/internal/ui"
 )
 
···
 		t.Run("creates task successfully", func(t *testing.T) {
 			desc := "Buy groceries and cook dinner"
 			err := handler.Create(ctx, desc, "", "", "", "", "", "", "", "", []string{})
-			repo.AssertNoError(t, err, "CreateTask should succeed")
+			shared.AssertNoError(t, err, "CreateTask should succeed")
 
 			tasks, err := handler.repos.Tasks.GetPending(ctx)
-			repo.AssertNoError(t, err, "Failed to get pending tasks")
+			shared.AssertNoError(t, err, "Failed to get pending tasks")
 
 			if len(tasks) != 1 {
 				t.Errorf("Expected 1 task, got %d", len(tasks))
···
 		t.Run("fails with empty description", func(t *testing.T) {
 			desc := ""
 			err := handler.Create(ctx, desc, "", "", "", "", "", "", "", "", []string{})
-			repo.AssertError(t, err, "Expected error for empty description")
-			repo.AssertContains(t, err.Error(), "task description required", "Error message should mention required description")
+			shared.AssertError(t, err, "Expected error for empty description")
+			shared.AssertContains(t, err.Error(), "task description required", "Error message should mention required description")
 		})
 
 		t.Run("creates task with flags", func(t *testing.T) {

internal/handlers/test_utilities.go

···
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
-	"net/http"
-	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strconv"
···
 	"github.com/stormlightlabs/noteleaf/internal/ui"
 )
 
-// HandlerTestHelper wraps NoteHandler with test-specific functionality
+// HandlerTestHelper wraps [NoteHandler] with test-specific functionality
 //
-// Uses HandlerTestSuite internally to avoid code duplication
+// Uses [HandlerTestSuite] internally to avoid code duplication
 type HandlerTestHelper struct {
 	*NoteHandler
 	suite *HandlerTestSuite
 }
 
-// NewHandlerTestHelper creates a NoteHandler with isolated test database
+// NewHandlerTestHelper creates a [NoteHandler] with isolated test database
 func NewHandlerTestHelper(t *testing.T) *HandlerTestHelper {
 	suite := NewHandlerTestSuite(t)
 
···
 	return me
 }
 
-// GetEditorFunc returns the editor function for use with NoteHandler
+// GetEditorFunc returns the editor function for use with [NoteHandler]
 func (me *MockEditor) GetEditorFunc() editorFunc {
 	return func(editor, filePath string) error {
 		if me.shouldFail {
···
 	dth.handler.db = db
 }
 
-// AssertionHelpers provides test assertion utilities
-type AssertionHelpers struct{}
-
-// AssertError checks that an error occurred and optionally contains expected text
-func (ah AssertionHelpers) AssertError(t *testing.T, err error, expectedSubstring string, msg string) {
-	t.Helper()
-	if err == nil {
-		t.Errorf("%s: expected error but got none", msg)
-		return
-	}
-	if expectedSubstring != "" && !containsString(err.Error(), expectedSubstring) {
-		t.Errorf("%s: expected error containing %q, got: %v", msg, expectedSubstring, err)
-	}
-}
-
-// AssertNoError checks that no error occurred
-func (ah AssertionHelpers) AssertNoError(t *testing.T, err error, msg string) {
-	t.Helper()
-	if err != nil {
-		t.Errorf("%s: unexpected error: %v", msg, err)
-	}
-}
-
 // 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
 }
···
 	return tempDir, nil
 }
 
-// Helper function to check if string contains substring (case-insensitive)
-func containsString(haystack, needle string) bool {
-	if needle == "" {
-		return true
-	}
-	return len(haystack) >= len(needle) &&
-		haystack[len(haystack)-len(needle):] == needle ||
-		haystack[:len(needle)] == needle ||
-		(len(haystack) > len(needle) &&
-			func() bool {
-				for i := 1; i <= len(haystack)-len(needle); i++ {
-					if haystack[i:i+len(needle)] == needle {
-						return true
-					}
-				}
-				return false
-			}())
-}
-
-// ArticleTestHelper wraps ArticleHandler with test-specific functionality
+// ArticleTestHelper wraps [ArticleHandler] with test-specific functionality
 type ArticleTestHelper struct {
 	*ArticleHandler
 	suite *HandlerTestSuite
 }
 
-// NewArticleTestHelper creates an ArticleHandler with isolated test database
+// NewArticleTestHelper creates an [ArticleHandler] with isolated test database
 func NewArticleTestHelper(t *testing.T) *ArticleTestHelper {
 	suite := NewHandlerTestSuite(t)
 
···
 	}
 }
 
-var Expect = AssertionHelpers{}
-
-// HTTPMockServer provides utilities for mocking HTTP services in tests
-type HTTPMockServer struct {
-	server   *httptest.Server
-	requests []*http.Request
-}
-
-// NewMockServer creates a new mock HTTP server
-func NewMockServer() *HTTPMockServer {
-	mock := &HTTPMockServer{
-		requests: make([]*http.Request, 0),
-	}
-	return mock
-}
-
-// WithHandler sets up the mock server with a custom handler
-func (m *HTTPMockServer) WithHandler(handler http.HandlerFunc) *HTTPMockServer {
-	m.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		m.requests = append(m.requests, r)
-		handler(w, r)
-	}))
-	return m
-}
-
-// URL returns the mock server URL
-func (m *HTTPMockServer) URL() string {
-	if m.server == nil {
-		panic("mock server not initialized - call WithHandler first")
-	}
-	return m.server.URL
-}
-
-// Close closes the mock server
-func (m *HTTPMockServer) Close() {
-	if m.server != nil {
-		m.server.Close()
-	}
-}
-
-// GetRequests returns all recorded HTTP requests
-func (m *HTTPMockServer) GetRequests() []*http.Request {
-	return m.requests
-}
-
-// GetLastRequest returns the last recorded HTTP request
-func (m *HTTPMockServer) GetLastRequest() *http.Request {
-	if len(m.requests) == 0 {
-		return nil
-	}
-	return m.requests[len(m.requests)-1]
-}
-
-// MockOpenLibraryResponse creates a mock OpenLibrary search response
+// MockOpenLibraryResponse creates a mocked instance of [services.OpenLibrarySearchResponse]
 func MockOpenLibraryResponse(books []MockBook) services.OpenLibrarySearchResponse {
 	docs := make([]services.OpenLibrarySearchDoc, len(books))
 	for i, book := range books {
···
 	Link  string
 	Score string
 	Type  string
-}
-
-// HTTPErrorMockServer creates a mock server that returns HTTP errors
-func HTTPErrorMockServer(statusCode int, message string) *HTTPMockServer {
-	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
-		http.Error(w, message, statusCode)
-	})
-}
-
-// JSONMockServer creates a mock server that returns JSON responses
-func JSONMockServer(response any) *HTTPMockServer {
-	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		if err := json.NewEncoder(w).Encode(response); err != nil {
-			http.Error(w, "Failed to encode response", http.StatusInternalServerError)
-		}
-	})
-}
-
-// TimeoutMockServer creates a mock server that simulates timeouts
-func TimeoutMockServer(delay time.Duration) *HTTPMockServer {
-	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
-		time.Sleep(delay)
-		w.WriteHeader(http.StatusOK)
-	})
-}
-
-// InvalidJSONMockServer creates a mock server that returns malformed JSON
-func InvalidJSONMockServer() *HTTPMockServer {
-	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`{"invalid": json`))
-	})
-}
-
-// EmptyResponseMockServer creates a mock server that returns empty responses
-func EmptyResponseMockServer() *HTTPMockServer {
-	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	})
-}
-
-// ServiceTestHelper provides utilities for testing services with HTTP mocks
-type ServiceTestHelper struct {
-	mockServers []*HTTPMockServer
-}
-
-// NewServiceTestHelper creates a new service test helper
-func NewServiceTestHelper() *ServiceTestHelper {
-	return &ServiceTestHelper{
-		mockServers: make([]*HTTPMockServer, 0),
-	}
-}
-
-// AddMockServer adds a mock server and returns its URL
-func (sth *ServiceTestHelper) AddMockServer(server *HTTPMockServer) string {
-	sth.mockServers = append(sth.mockServers, server)
-	return server.URL()
-}
-
-// Cleanup closes all mock servers
-func (sth *ServiceTestHelper) Cleanup() {
-	for _, server := range sth.mockServers {
-		server.Close()
-	}
-}
-
-// AssertRequestMade verifies that a request was made to the mock server
-func (sth *ServiceTestHelper) AssertRequestMade(t *testing.T, server *HTTPMockServer, expectedPath string) {
-	t.Helper()
-	if len(server.requests) == 0 {
-		t.Error("Expected HTTP request to be made but none were recorded")
-		return
-	}
-
-	lastReq := server.GetLastRequest()
-	if lastReq.URL.Path != expectedPath {
-		t.Errorf("Expected request to path %s, got %s", expectedPath, lastReq.URL.Path)
-	}
 }
 
 // MockMediaFetcher provides a test implementation of Fetchable and Searchable interfaces
···
 		},
 	}
 }
-
-// AssertTaskHasUUID verifies that a task has a non-empty UUID
-func AssertTaskHasUUID(t *testing.T, task *models.Task) {
-	t.Helper()
-	if task.UUID == "" {
-		t.Fatal("Task should have a UUID")
-	}
-}
-
-// AssertTaskDatesSet verifies that Entry and Modified timestamps are set
-func AssertTaskDatesSet(t *testing.T, task *models.Task) {
-	t.Helper()
-	if task.Entry.IsZero() {
-		t.Error("Task Entry timestamp should be set")
-	}
-	if task.Modified.IsZero() {
-		t.Error("Task Modified timestamp should be set")
-	}
-}

internal/models/models_test.go

···
 
 	t.Run("Task Model", func(t *testing.T) {
 		t.Run("Status Methods", func(t *testing.T) {
-			testCases := []struct {
+			tc := []struct {
 				status      string
 				isCompleted bool
 				isPending   bool
···
 				{"unknown", false, false, false},
 			}
 
-			for _, tc := range testCases {
-				task := &Task{Status: tc.status}
+			for _, tt := range tc {
+				task := &Task{Status: tt.status}
 
-				if task.IsCompleted() != tc.isCompleted {
-					t.Errorf("Status %s: expected IsCompleted %v, got %v", tc.status, tc.isCompleted, task.IsCompleted())
+				if task.IsCompleted() != tt.isCompleted {
+					t.Errorf("Status %s: expected IsCompleted %v, got %v", tt.status, tt.isCompleted, task.IsCompleted())
 				}
-				if task.IsPending() != tc.isPending {
-					t.Errorf("Status %s: expected IsPending %v, got %v", tc.status, tc.isPending, task.IsPending())
+				if task.IsPending() != tt.isPending {
+					t.Errorf("Status %s: expected IsPending %v, got %v", tt.status, tt.isPending, task.IsPending())
 				}
-				if task.IsDeleted() != tc.isDeleted {
-					t.Errorf("Status %s: expected IsDeleted %v, got %v", tc.status, tc.isDeleted, task.IsDeleted())
+				if task.IsDeleted() != tt.isDeleted {
+					t.Errorf("Status %s: expected IsDeleted %v, got %v", tt.status, tt.isDeleted, task.IsDeleted())
 				}
 			}
 		})
 
 		t.Run("New Status Tracking Methods", func(t *testing.T) {
-			testCases := []struct {
+			tc := []struct {
 				status       string
 				isTodo       bool
 				isInProgress bool
···
 				{"unknown", false, false, false, false, false},
 			}
 
-			for _, tc := range testCases {
-				task := &Task{Status: tc.status}
+			for _, tt := range tc {
+				task := &Task{Status: tt.status}
 
-				if task.IsTodo() != tc.isTodo {
-					t.Errorf("Status %s: expected IsTodo %v, got %v", tc.status, tc.isTodo, task.IsTodo())
+				if task.IsTodo() != tt.isTodo {
+					t.Errorf("Status %s: expected IsTodo %v, got %v", tt.status, tt.isTodo, task.IsTodo())
 				}
-				if task.IsInProgress() != tc.isInProgress {
-					t.Errorf("Status %s: expected IsInProgress %v, got %v", tc.status, tc.isInProgress, task.IsInProgress())
+				if task.IsInProgress() != tt.isInProgress {
+					t.Errorf("Status %s: expected IsInProgress %v, got %v", tt.status, tt.isInProgress, task.IsInProgress())
 				}
-				if task.IsBlocked() != tc.isBlocked {
-					t.Errorf("Status %s: expected IsBlocked %v, got %v", tc.status, tc.isBlocked, task.IsBlocked())
+				if task.IsBlocked() != tt.isBlocked {
+					t.Errorf("Status %s: expected IsBlocked %v, got %v", tt.status, tt.isBlocked, task.IsBlocked())
 				}
-				if task.IsDone() != tc.isDone {
-					t.Errorf("Status %s: expected IsDone %v, got %v", tc.status, tc.isDone, task.IsDone())
+				if task.IsDone() != tt.isDone {
+					t.Errorf("Status %s: expected IsDone %v, got %v", tt.status, tt.isDone, task.IsDone())
 				}
-				if task.IsAbandoned() != tc.isAbandoned {
-					t.Errorf("Status %s: expected IsAbandoned %v, got %v", tc.status, tc.isAbandoned, task.IsAbandoned())
+				if task.IsAbandoned() != tt.isAbandoned {
+					t.Errorf("Status %s: expected IsAbandoned %v, got %v", tt.status, tt.isAbandoned, task.IsAbandoned())
 				}
 			}
 		})
···
 			})
 
 			t.Run("Priority Weight Calculation", func(t *testing.T) {
-				testCases := []struct {
+				tc := []struct {
 					priority string
 					weight   int
 				}{
···
 					{"invalid", 0},
 				}
 
-				for _, tc := range testCases {
-					task := &Task{Priority: tc.priority}
+				for _, tt := range tc {
+					task := &Task{Priority: tt.priority}
 					weight := task.GetPriorityWeight()
-					if weight != tc.weight {
-						t.Errorf("Priority %s: expected weight %d, got %d", tc.priority, tc.weight, weight)
+					if weight != tt.weight {
+						t.Errorf("Priority %s: expected weight %d, got %d", tt.priority, tt.weight, weight)
 					}
 				}
 			})
···
 
 	t.Run("Movie Model", func(t *testing.T) {
 		t.Run("Status Methods", func(t *testing.T) {
-			testCases := []struct {
+			tc := []struct {
 				status    string
 				isWatched bool
 				isQueued  bool
···
 				{"unknown", false, false},
 			}
 
-			for _, tc := range testCases {
-				movie := &Movie{Status: tc.status}
+			for _, tt := range tc {
+				movie := &Movie{Status: tt.status}
 
-				if movie.IsWatched() != tc.isWatched {
-					t.Errorf("Status %s: expected IsWatched %v, got %v", tc.status, tc.isWatched, movie.IsWatched())
+				if movie.IsWatched() != tt.isWatched {
+					t.Errorf("Status %s: expected IsWatched %v, got %v", tt.status, tt.isWatched, movie.IsWatched())
 				}
-				if movie.IsQueued() != tc.isQueued {
-					t.Errorf("Status %s: expected IsQueued %v, got %v", tc.status, tc.isQueued, movie.IsQueued())
+				if movie.IsQueued() != tt.isQueued {
+					t.Errorf("Status %s: expected IsQueued %v, got %v", tt.status, tt.isQueued, movie.IsQueued())
 				}
 			}
 		})
···
 
 	t.Run("TV Show Model", func(t *testing.T) {
 		t.Run("Status Methods", func(t *testing.T) {
-			testCases := []struct {
+			tc := []struct {
 				status     string
 				isWatching bool
 				isWatched  bool
···
 				{"unknown", false, false, false},
 			}
 
-			for _, tc := range testCases {
-				tvShow := &TVShow{Status: tc.status}
+			for _, tt := range tc {
+				tvShow := &TVShow{Status: tt.status}
 
-				if tvShow.IsWatching() != tc.isWatching {
-					t.Errorf("Status %s: expected IsWatching %v, got %v", tc.status, tc.isWatching, tvShow.IsWatching())
+				if tvShow.IsWatching() != tt.isWatching {
+					t.Errorf("Status %s: expected IsWatching %v, got %v", tt.status, tt.isWatching, tvShow.IsWatching())
 				}
-				if tvShow.IsWatched() != tc.isWatched {
-					t.Errorf("Status %s: expected IsWatched %v, got %v", tc.status, tc.isWatched, tvShow.IsWatched())
+				if tvShow.IsWatched() != tt.isWatched {
+					t.Errorf("Status %s: expected IsWatched %v, got %v", tt.status, tt.isWatched, tvShow.IsWatched())
 				}
-				if tvShow.IsQueued() != tc.isQueued {
-					t.Errorf("Status %s: expected IsQueued %v, got %v", tc.status, tc.isQueued, tvShow.IsQueued())
+				if tvShow.IsQueued() != tt.isQueued {
+					t.Errorf("Status %s: expected IsQueued %v, got %v", tt.status, tt.isQueued, tvShow.IsQueued())
 				}
 			}
 		})
···
 
 	t.Run("Book Model", func(t *testing.T) {
 		t.Run("Status Methods", func(t *testing.T) {
-			testCases := []struct {
+			tc := []struct {
 				status     string
 				isReading  bool
 				isFinished bool
···
 				{"unknown", false, false, false},
 			}
 
-			for _, tc := range testCases {
-				book := &Book{Status: tc.status}
+			for _, tt := range tc {
+				book := &Book{Status: tt.status}
 
-				if book.IsReading() != tc.isReading {
-					t.Errorf("Status %s: expected IsReading %v, got %v", tc.status, tc.isReading, book.IsReading())
+				if book.IsReading() != tt.isReading {
+					t.Errorf("Status %s: expected IsReading %v, got %v", tt.status, tt.isReading, book.IsReading())
 				}
-				if book.IsFinished() != tc.isFinished {
-					t.Errorf("Status %s: expected IsFinished %v, got %v", tc.status, tc.isFinished, book.IsFinished())
+				if book.IsFinished() != tt.isFinished {
+					t.Errorf("Status %s: expected IsFinished %v, got %v", tt.status, tt.isFinished, book.IsFinished())
 				}
-				if book.IsQueued() != tc.isQueued {
-					t.Errorf("Status %s: expected IsQueued %v, got %v", tc.status, tc.isQueued, book.IsQueued())
+				if book.IsQueued() != tt.isQueued {
+					t.Errorf("Status %s: expected IsQueued %v, got %v", tt.status, tt.isQueued, book.IsQueued())
 				}
 			}
 		})

internal/repo/article_repository_test.go

···
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestArticleRepository(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			id, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
-			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
-			AssertEqual(t, id, article.ID, "Expected article ID to be set correctly")
-			AssertFalse(t, article.Created.IsZero(), "Expected Created timestamp to be set")
-			AssertFalse(t, article.Modified.IsZero(), "Expected Modified timestamp to be set")
+			shared.AssertNoError(t, err, "Failed to create article")
+			shared.AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+			shared.AssertEqual(t, id, article.ID, "Expected article ID to be set correctly")
+			shared.AssertFalse(t, article.Created.IsZero(), "Expected Created timestamp to be set")
+			shared.AssertFalse(t, article.Modified.IsZero(), "Expected Modified timestamp to be set")
 		})
 
 		t.Run("Get article", func(t *testing.T) {
···
 
 			original := CreateSampleArticle()
 			id, err := repo.Create(ctx, original)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get article")
-			AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
-			AssertEqual(t, original.URL, retrieved.URL, "URL mismatch")
-			AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
-			AssertEqual(t, original.Author, retrieved.Author, "Author mismatch")
-			AssertEqual(t, original.Date, retrieved.Date, "Date mismatch")
-			AssertEqual(t, original.MarkdownPath, retrieved.MarkdownPath, "MarkdownPath mismatch")
-			AssertEqual(t, original.HTMLPath, retrieved.HTMLPath, "HTMLPath mismatch")
+			shared.AssertNoError(t, err, "Failed to get article")
+			shared.AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
+			shared.AssertEqual(t, original.URL, retrieved.URL, "URL mismatch")
+			shared.AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
+			shared.AssertEqual(t, original.Author, retrieved.Author, "Author mismatch")
+			shared.AssertEqual(t, original.Date, retrieved.Date, "Date mismatch")
+			shared.AssertEqual(t, original.MarkdownPath, retrieved.MarkdownPath, "MarkdownPath mismatch")
+			shared.AssertEqual(t, original.HTMLPath, retrieved.HTMLPath, "HTMLPath mismatch")
 		})
 
 		t.Run("Update article", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			id, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			originalModified := article.Modified
 			article.Title = "Updated Title"
···
 			article.HTMLPath = "/updated/path/article.html"
 
 			err = repo.Update(ctx, article)
-			AssertNoError(t, err, "Failed to update article")
+			shared.AssertNoError(t, err, "Failed to update article")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated article")
-			AssertEqual(t, "Updated Title", retrieved.Title, "Expected updated title")
-			AssertEqual(t, "Updated Author", retrieved.Author, "Expected updated author")
-			AssertEqual(t, "2024-01-02", retrieved.Date, "Expected updated date")
-			AssertEqual(t, "/updated/path/article.md", retrieved.MarkdownPath, "Expected updated markdown path")
-			AssertEqual(t, "/updated/path/article.html", retrieved.HTMLPath, "Expected updated HTML path")
-			AssertTrue(t, retrieved.Modified.After(originalModified), "Expected Modified timestamp to be updated")
+			shared.AssertNoError(t, err, "Failed to get updated article")
+			shared.AssertEqual(t, "Updated Title", retrieved.Title, "Expected updated title")
+			shared.AssertEqual(t, "Updated Author", retrieved.Author, "Expected updated author")
+			shared.AssertEqual(t, "2024-01-02", retrieved.Date, "Expected updated date")
+			shared.AssertEqual(t, "/updated/path/article.md", retrieved.MarkdownPath, "Expected updated markdown path")
+			shared.AssertEqual(t, "/updated/path/article.html", retrieved.HTMLPath, "Expected updated HTML path")
+			shared.AssertTrue(t, retrieved.Modified.After(originalModified), "Expected Modified timestamp to be updated")
 		})
 
 		t.Run("Delete article", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			id, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			err = repo.Delete(ctx, id)
-			AssertNoError(t, err, "Failed to delete article")
+			shared.AssertNoError(t, err, "Failed to delete article")
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "Expected error when getting deleted article")
+			shared.AssertError(t, err, "Expected error when getting deleted article")
 		})
 	})
 
···
 			article := CreateSampleArticle()
 			article.Title = ""
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with empty title")
+			shared.AssertError(t, err, "Expected error when creating article with empty title")
 		})
 
 		t.Run("Fails with missing URL", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.URL = ""
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with empty URL")
+			shared.AssertError(t, err, "Expected error when creating article with empty URL")
 		})
 
 		t.Run("Fails with duplicate URL", func(t *testing.T) {
 			article1 := CreateSampleArticle()
 			_, err := repo.Create(ctx, article1)
-			AssertNoError(t, err, "Failed to create first article")
+			shared.AssertNoError(t, err, "Failed to create first article")
 
 			article2 := CreateSampleArticle()
 			article2.URL = article1.URL
 			_, err = repo.Create(ctx, article2)
-			AssertError(t, err, "Expected error when creating article with duplicate URL")
+			shared.AssertError(t, err, "Expected error when creating article with duplicate URL")
 		})
 
 		t.Run("Fails with missing markdown path", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.MarkdownPath = ""
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with empty markdown path")
-			AssertContains(t, err.Error(), "MarkdownPath", "Expected MarkdownPath validation error")
+			shared.AssertError(t, err, "Expected error when creating article with empty markdown path")
+			shared.AssertContains(t, err.Error(), "MarkdownPath", "Expected MarkdownPath validation error")
 		})
 
 		t.Run("Fails with missing HTML path", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.HTMLPath = ""
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with empty HTML path")
-			AssertContains(t, err.Error(), "HTMLPath", "Expected HTMLPath validation error")
+			shared.AssertError(t, err, "Expected error when creating article with empty HTML path")
+			shared.AssertContains(t, err.Error(), "HTMLPath", "Expected HTMLPath validation error")
 		})
 
 		t.Run("Fails with invalid URL format", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.URL = "not-a-valid-url"
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with invalid URL format")
-			AssertContains(t, err.Error(), "URL", "Expected URL format validation error")
+			shared.AssertError(t, err, "Expected error when creating article with invalid URL format")
+			shared.AssertContains(t, err.Error(), "URL", "Expected URL format validation error")
 		})
 
 		t.Run("Fails with invalid date format", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.Date = "invalid-date"
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with invalid date format")
-			AssertContains(t, err.Error(), "Date", "Expected date validation error")
+			shared.AssertError(t, err, "Expected error when creating article with invalid date format")
+			shared.AssertContains(t, err.Error(), "Date", "Expected date validation error")
 		})
 
 		t.Run("Fails with title too long", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.Title = strings.Repeat("a", 501)
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with title too long")
-			AssertContains(t, err.Error(), "Title", "Expected title length validation error")
+			shared.AssertError(t, err, "Expected error when creating article with title too long")
+			shared.AssertContains(t, err.Error(), "Title", "Expected title length validation error")
 		})
 
 		t.Run("Fails with author too long", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.Author = strings.Repeat("a", 201)
 			_, err := repo.Create(ctx, article)
-			AssertError(t, err, "Expected error when creating article with author too long")
-			AssertContains(t, err.Error(), "Author", "Expected author length validation error")
+			shared.AssertError(t, err, "Expected error when creating article with author too long")
+			shared.AssertContains(t, err.Error(), "Author", "Expected author length validation error")
 		})
 
 		t.Run("Validates timestamps", func(t *testing.T) {
···
 			article.Modified = now
 			article.Created = now.Add(time.Hour)
 			err := repo.Validate(article)
-			AssertError(t, err, "Expected error when created is after modified")
-			AssertContains(t, err.Error(), "Created", "Expected timestamp validation error")
+			shared.AssertError(t, err, "Expected error when created is after modified")
+			shared.AssertContains(t, err.Error(), "Created", "Expected timestamp validation error")
 		})
 
 		t.Run("Succeeds when created equals modified", func(t *testing.T) {
···
 			article.Created = now
 			article.Modified = now
 			err := repo.Validate(article)
-			AssertNoError(t, err, "Expected no error when created equals modified")
+			shared.AssertNoError(t, err, "Expected no error when created equals modified")
 		})
 
 		t.Run("Succeeds when created is before modified", func(t *testing.T) {
···
 			article.Created = now
 			article.Modified = now.Add(time.Hour)
 			err := repo.Validate(article)
-			AssertNoError(t, err, "Expected no error when created is before modified")
+			shared.AssertNoError(t, err, "Expected no error when created is before modified")
 		})
 
 		t.Run("Succeeds with valid optional fields", func(t *testing.T) {
···
 			article.Date = "2024-01-01"
 			article.Author = "Test Author"
 			err := repo.Validate(article)
-			AssertNoError(t, err, "Expected no error with valid optional fields")
+			shared.AssertNoError(t, err, "Expected no error with valid optional fields")
 		})
 
 		t.Run("Succeeds with empty optional fields", func(t *testing.T) {
···
 			article.Date = ""
 			article.Author = ""
 			err := repo.Validate(article)
-			AssertNoError(t, err, "Expected no error with empty optional fields")
+			shared.AssertNoError(t, err, "Expected no error with empty optional fields")
 		})
 	})
 
···
 		t.Run("Successfully retrieves article by URL", func(t *testing.T) {
 			original := CreateSampleArticle()
 			_, err := repo.Create(ctx, original)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			retrieved, err := repo.GetByURL(ctx, original.URL)
-			AssertNoError(t, err, "Failed to get article by URL")
-			AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
-			AssertEqual(t, original.URL, retrieved.URL, "URL mismatch")
-			AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
+			shared.AssertNoError(t, err, "Failed to get article by URL")
+			shared.AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
+			shared.AssertEqual(t, original.URL, retrieved.URL, "URL mismatch")
+			shared.AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
 		})
 
 		t.Run("Fails when URL not found", func(t *testing.T) {
 			nonexistent := "https://example.com/nonexistent"
 			_, err := repo.GetByURL(ctx, nonexistent)
-			AssertError(t, err, "Expected error when getting article by non-existent URL")
-			AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
+			shared.AssertError(t, err, "Expected error when getting article by non-existent URL")
+			shared.AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
 		})
 	})
 
···
 
 		for _, article := range articles {
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create test article")
+			shared.AssertNoError(t, err, "Failed to create test article")
 		}
 
 		t.Run("List all articles", func(t *testing.T) {
 			results, err := repo.List(ctx, nil)
-			AssertNoError(t, err, "Failed to list all articles")
-			AssertEqual(t, 3, len(results), "Expected 3 articles")
+			shared.AssertNoError(t, err, "Failed to list all articles")
+			shared.AssertEqual(t, 3, len(results), "Expected 3 articles")
 		})
 
 		t.Run("Filter by title", func(t *testing.T) {
 			opts := &ArticleListOptions{Title: "Important"}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles by title")
-			AssertEqual(t, 1, len(results), "Expected 1 article matching title")
-			AssertEqual(t, "Important Article", results[0].Title, "Wrong article returned")
+			shared.AssertNoError(t, err, "Failed to list articles by title")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 article matching title")
+			shared.AssertEqual(t, "Important Article", results[0].Title, "Wrong article returned")
 		})
 
 		t.Run("Filter by author", func(t *testing.T) {
 			opts := &ArticleListOptions{Author: "John Doe"}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles by author")
-			AssertEqual(t, 2, len(results), "Expected 2 articles by John Doe")
+			shared.AssertNoError(t, err, "Failed to list articles by author")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 articles by John Doe")
 		})
 
 		t.Run("Filter by URL", func(t *testing.T) {
 			opts := &ArticleListOptions{URL: "different.com"}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles by URL")
-			AssertEqual(t, 1, len(results), "Expected 1 article from different.com")
+			shared.AssertNoError(t, err, "Failed to list articles by URL")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 article from different.com")
 		})
 
 		t.Run("Filter by date range", func(t *testing.T) {
 			opts := &ArticleListOptions{DateFrom: "2024-01-02", DateTo: "2024-01-03"}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles by date range")
-			AssertEqual(t, 2, len(results), "Expected 2 articles in date range")
+			shared.AssertNoError(t, err, "Failed to list articles by date range")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 articles in date range")
 		})
 
 		t.Run("With limit", func(t *testing.T) {
 			opts := &ArticleListOptions{Limit: 2}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles with limit")
-			AssertEqual(t, 2, len(results), "Expected 2 articles due to limit")
+			shared.AssertNoError(t, err, "Failed to list articles with limit")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 articles due to limit")
 		})
 
 		t.Run("With limit and offset", func(t *testing.T) {
 			opts := &ArticleListOptions{Limit: 2, Offset: 1}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles with limit and offset")
-			AssertEqual(t, 2, len(results), "Expected 2 articles due to limit")
+			shared.AssertNoError(t, err, "Failed to list articles with limit and offset")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 articles due to limit")
 		})
 
 		t.Run("Multiple filters", func(t *testing.T) {
 			opts := &ArticleListOptions{Author: "John Doe", DateFrom: "2024-01-02"}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles with multiple filters")
-			AssertEqual(t, 1, len(results), "Expected 1 article matching all filters")
-			AssertEqual(t, "Important Article", results[0].Title, "Wrong article returned")
+			shared.AssertNoError(t, err, "Failed to list articles with multiple filters")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 article matching all filters")
+			shared.AssertEqual(t, "Important Article", results[0].Title, "Wrong article returned")
 		})
 
 		t.Run("No results", func(t *testing.T) {
 			opts := &ArticleListOptions{Title: "Nonexistent"}
 			results, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Failed to list articles")
-			AssertEqual(t, 0, len(results), "Expected no articles")
+			shared.AssertNoError(t, err, "Failed to list articles")
+			shared.AssertEqual(t, 0, len(results), "Expected no articles")
 		})
 	})
 
···
 
 		for _, article := range articles {
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create test article")
+			shared.AssertNoError(t, err, "Failed to create test article")
 		}
 
 		t.Run("Count all articles", func(t *testing.T) {
 			count, err := repo.Count(ctx, nil)
-			AssertNoError(t, err, "Failed to count articles")
-			AssertEqual(t, int64(2), count, "Expected 2 articles")
+			shared.AssertNoError(t, err, "Failed to count articles")
+			shared.AssertEqual(t, int64(2), count, "Expected 2 articles")
 		})
 
 		t.Run("Count with filter", func(t *testing.T) {
 			opts := &ArticleListOptions{Author: "Test Author"}
 			count, err := repo.Count(ctx, opts)
-			AssertNoError(t, err, "Failed to count articles with filter")
-			AssertEqual(t, int64(1), count, "Expected 1 article by Test Author")
+			shared.AssertNoError(t, err, "Failed to count articles with filter")
+			shared.AssertEqual(t, int64(1), count, "Expected 1 article by Test Author")
 		})
 
 		t.Run("Count with no results", func(t *testing.T) {
 			opts := &ArticleListOptions{Title: "Nonexistent"}
 			count, err := repo.Count(ctx, opts)
-			AssertNoError(t, err, "Failed to count articles")
-			AssertEqual(t, int64(0), count, "Expected 0 articles")
+			shared.AssertNoError(t, err, "Failed to count articles")
+			shared.AssertEqual(t, int64(0), count, "Expected 0 articles")
 		})
 	})
 
···
 
 		article := CreateSampleArticle()
 		id, err := repo.Create(ctx, article)
-		AssertNoError(t, err, "Failed to create article")
+		shared.AssertNoError(t, err, "Failed to create article")
 
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newArticle := CreateSampleArticle()
···
 
 		t.Run("Get non-existent article", func(t *testing.T) {
 			_, err := repo.Get(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent article")
-			AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
+			shared.AssertError(t, err, "Expected error for non-existent article")
+			shared.AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
 		})
 
 		t.Run("Update non-existent article", func(t *testing.T) {
 			article := CreateSampleArticle()
 			article.ID = 99999
 			err := repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating non-existent article")
-			AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
+			shared.AssertError(t, err, "Expected error when updating non-existent article")
+			shared.AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
 		})
 
 		t.Run("Delete non-existent article", func(t *testing.T) {
 			err := repo.Delete(ctx, 99999)
-			AssertError(t, err, "Expected error when deleting non-existent article")
-			AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
+			shared.AssertError(t, err, "Expected error when deleting non-existent article")
+			shared.AssertContains(t, err.Error(), "not found", "Expected 'not found' in error message")
 		})
 
 		t.Run("Update validation - remove required title", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			article.Title = ""
 			err = repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating article with empty title")
+			shared.AssertError(t, err, "Expected error when updating article with empty title")
 		})
 
 		t.Run("Update validation - invalid URL format", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			article.URL = "not-a-valid-url"
 			err = repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating article with invalid URL format")
-			AssertContains(t, err.Error(), "URL", "Expected URL format validation error")
+			shared.AssertError(t, err, "Expected error when updating article with invalid URL format")
+			shared.AssertContains(t, err.Error(), "URL", "Expected URL format validation error")
 		})
 
 		t.Run("Update validation - invalid date format", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			article.Date = "invalid-date"
 			err = repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating article with invalid date format")
-			AssertContains(t, err.Error(), "Date", "Expected date validation error")
+			shared.AssertError(t, err, "Expected error when updating article with invalid date format")
+			shared.AssertContains(t, err.Error(), "Date", "Expected date validation error")
 		})
 
 		t.Run("Update validation - title too long", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			article.Title = strings.Repeat("a", 501)
 			err = repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating article with title too long")
-			AssertContains(t, err.Error(), "Title", "Expected title length validation error")
+			shared.AssertError(t, err, "Expected error when updating article with title too long")
+			shared.AssertContains(t, err.Error(), "Title", "Expected title length validation error")
 		})
 
 		t.Run("Update validation - author too long", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			article.Author = strings.Repeat("a", 201)
 			err = repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating article with author too long")
-			AssertContains(t, err.Error(), "Author", "Expected author length validation error")
+			shared.AssertError(t, err, "Expected error when updating article with author too long")
+			shared.AssertContains(t, err.Error(), "Author", "Expected author length validation error")
 		})
 
 		t.Run("Update validation - remove markdown path", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			article.MarkdownPath = ""
 			err = repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating article with empty markdown path")
-			AssertContains(t, err.Error(), "MarkdownPath", "Expected MarkdownPath validation error")
+			shared.AssertError(t, err, "Expected error when updating article with empty markdown path")
+			shared.AssertContains(t, err.Error(), "MarkdownPath", "Expected MarkdownPath validation error")
 		})
 
 		t.Run("Update validation - remove HTML path", func(t *testing.T) {
···
 
 			article := CreateSampleArticle()
 			_, err := repo.Create(ctx, article)
-			AssertNoError(t, err, "Failed to create article")
+			shared.AssertNoError(t, err, "Failed to create article")
 
 			article.HTMLPath = ""
 			err = repo.Update(ctx, article)
-			AssertError(t, err, "Expected error when updating article with empty HTML path")
-			AssertContains(t, err.Error(), "HTMLPath", "Expected HTMLPath validation error")
+			shared.AssertError(t, err, "Expected error when updating article with empty HTML path")
+			shared.AssertContains(t, err.Error(), "HTMLPath", "Expected HTMLPath validation error")
 		})
 
 		t.Run("List with no results", func(t *testing.T) {
 			opts := &ArticleListOptions{Author: "NonExistentAuthor"}
 			articles, err := repo.List(ctx, opts)
-			AssertNoError(t, err, "Should not error when no articles found")
-			AssertEqual(t, 0, len(articles), "Expected empty result set")
+			shared.AssertNoError(t, err, "Should not error when no articles found")
+			shared.AssertEqual(t, 0, len(articles), "Expected empty result set")
 		})
 	})
 }

internal/repo/base_media_repository_test.go

···
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestBaseMediaRepository(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
-			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+			shared.AssertNoError(t, err, "Failed to create book")
+			shared.AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get book")
-			AssertEqual(t, book.Title, retrieved.Title, "Title mismatch")
-			AssertEqual(t, book.Author, retrieved.Author, "Author mismatch")
-			AssertEqual(t, book.Status, retrieved.Status, "Status mismatch")
+			shared.AssertNoError(t, err, "Failed to get book")
+			shared.AssertEqual(t, book.Title, retrieved.Title, "Title mismatch")
+			shared.AssertEqual(t, book.Author, retrieved.Author, "Author mismatch")
+			shared.AssertEqual(t, book.Status, retrieved.Status, "Status mismatch")
 		})
 
 		t.Run("Update", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 
 			book.Title = "Updated Title"
 			book.Author = "Updated Author"
 			book.Status = "reading"
 
 			err = repo.Update(ctx, book)
-			AssertNoError(t, err, "Failed to update book")
+			shared.AssertNoError(t, err, "Failed to update book")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated book")
-			AssertEqual(t, "Updated Title", retrieved.Title, "Title not updated")
-			AssertEqual(t, "Updated Author", retrieved.Author, "Author not updated")
-			AssertEqual(t, "reading", retrieved.Status, "Status not updated")
+			shared.AssertNoError(t, err, "Failed to get updated book")
+			shared.AssertEqual(t, "Updated Title", retrieved.Title, "Title not updated")
+			shared.AssertEqual(t, "Updated Author", retrieved.Author, "Author not updated")
+			shared.AssertEqual(t, "reading", retrieved.Status, "Status not updated")
 		})
 
 		t.Run("Delete", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 
 			err = repo.Delete(ctx, id)
-			AssertNoError(t, err, "Failed to delete book")
+			shared.AssertNoError(t, err, "Failed to delete book")
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "Expected error when getting deleted book")
+			shared.AssertError(t, err, "Expected error when getting deleted book")
 		})
 
 		t.Run("Get non-existent", func(t *testing.T) {
···
 			repo := NewBookRepository(db)
 
 			_, err := repo.Get(ctx, 9999)
-			AssertError(t, err, "Expected error for non-existent book")
-			AssertContains(t, err.Error(), "not found", "Error should mention 'not found'")
+			shared.AssertError(t, err, "Expected error for non-existent book")
+			shared.AssertContains(t, err.Error(), "not found", "Error should mention 'not found'")
 		})
 
 		t.Run("ListQuery with multiple books", func(t *testing.T) {
···
 
 			for _, book := range books {
 				_, err := repo.Create(ctx, book)
-				AssertNoError(t, err, "Failed to create book")
+				shared.AssertNoError(t, err, "Failed to create book")
 			}
 
 			allBooks, err := repo.List(ctx, BookListOptions{})
-			AssertNoError(t, err, "Failed to list books")
+			shared.AssertNoError(t, err, "Failed to list books")
 			if len(allBooks) != 3 {
 				t.Errorf("Expected 3 books, got %d", len(allBooks))
 			}
···
 					Status: "queued",
 				}
 				_, err := repo.Create(ctx, book)
-				AssertNoError(t, err, "Failed to create book")
+				shared.AssertNoError(t, err, "Failed to create book")
 			}
 
 			count, err := repo.Count(ctx, BookListOptions{})
-			AssertNoError(t, err, "Failed to count books")
+			shared.AssertNoError(t, err, "Failed to count books")
 			if count != 5 {
 				t.Errorf("Expected count of 5, got %d", count)
 			}
···
 			}
 
 			id, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
-			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+			shared.AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get movie")
-			AssertEqual(t, movie.Title, retrieved.Title, "Title mismatch")
-			AssertEqual(t, movie.Year, retrieved.Year, "Year mismatch")
-			AssertEqual(t, movie.Status, retrieved.Status, "Status mismatch")
+			shared.AssertNoError(t, err, "Failed to get movie")
+			shared.AssertEqual(t, movie.Title, retrieved.Title, "Title mismatch")
+			shared.AssertEqual(t, movie.Year, retrieved.Year, "Year mismatch")
+			shared.AssertEqual(t, movie.Status, retrieved.Status, "Status mismatch")
 		})
 
 		t.Run("Update", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 
 			movie.Title = "Updated Movie"
 			movie.Year = 2023
 			movie.Status = "watched"
 
 			err = repo.Update(ctx, movie)
-			AssertNoError(t, err, "Failed to update movie")
+			shared.AssertNoError(t, err, "Failed to update movie")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated movie")
-			AssertEqual(t, "Updated Movie", retrieved.Title, "Title not updated")
-			AssertEqual(t, 2023, retrieved.Year, "Year not updated")
-			AssertEqual(t, "watched", retrieved.Status, "Status not updated")
+			shared.AssertNoError(t, err, "Failed to get updated movie")
+			shared.AssertEqual(t, "Updated Movie", retrieved.Title, "Title not updated")
+			shared.AssertEqual(t, 2023, retrieved.Year, "Year not updated")
+			shared.AssertEqual(t, "watched", retrieved.Status, "Status not updated")
 		})
 
 		t.Run("Delete", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 
 			err = repo.Delete(ctx, id)
-			AssertNoError(t, err, "Failed to delete movie")
+			shared.AssertNoError(t, err, "Failed to delete movie")
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "Expected error when getting deleted movie")
+			shared.AssertError(t, err, "Expected error when getting deleted movie")
 		})
 	})
 
···
 			}
 
 			id, err := repo.Create(ctx, show)
-			AssertNoError(t, err, "Failed to create TV show")
-			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+			shared.AssertNoError(t, err, "Failed to create TV show")
+			shared.AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get TV show")
-			AssertEqual(t, show.Title, retrieved.Title, "Title mismatch")
-			AssertEqual(t, show.Season, retrieved.Season, "Season mismatch")
-			AssertEqual(t, show.Episode, retrieved.Episode, "Episode mismatch")
-			AssertEqual(t, show.Status, retrieved.Status, "Status mismatch")
+			shared.AssertNoError(t, err, "Failed to get TV show")
+			shared.AssertEqual(t, show.Title, retrieved.Title, "Title mismatch")
+			shared.AssertEqual(t, show.Season, retrieved.Season, "Season mismatch")
+			shared.AssertEqual(t, show.Episode, retrieved.Episode, "Episode mismatch")
+			shared.AssertEqual(t, show.Status, retrieved.Status, "Status mismatch")
 		})
 
 		t.Run("Update", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, show)
-			AssertNoError(t, err, "Failed to create TV show")
+			shared.AssertNoError(t, err, "Failed to create TV show")
 
 			show.Title = "Updated Show"
 			show.Season = 2
···
 			show.Status = "watching"
 
 			err = repo.Update(ctx, show)
-			AssertNoError(t, err, "Failed to update TV show")
+			shared.AssertNoError(t, err, "Failed to update TV show")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated TV show")
-			AssertEqual(t, "Updated Show", retrieved.Title, "Title not updated")
-			AssertEqual(t, 2, retrieved.Season, "Season not updated")
-			AssertEqual(t, 5, retrieved.Episode, "Episode not updated")
-			AssertEqual(t, "watching", retrieved.Status, "Status not updated")
+			shared.AssertNoError(t, err, "Failed to get updated TV show")
+			shared.AssertEqual(t, "Updated Show", retrieved.Title, "Title not updated")
+			shared.AssertEqual(t, 2, retrieved.Season, "Season not updated")
+			shared.AssertEqual(t, 5, retrieved.Episode, "Episode not updated")
+			shared.AssertEqual(t, "watching", retrieved.Status, "Status not updated")
 		})
 
 		t.Run("Delete", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, show)
-			AssertNoError(t, err, "Failed to create TV show")
+			shared.AssertNoError(t, err, "Failed to create TV show")
 
 			err = repo.Delete(ctx, id)
-			AssertNoError(t, err, "Failed to delete TV show")
+			shared.AssertNoError(t, err, "Failed to delete TV show")
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "Expected error when getting deleted TV show")
+			shared.AssertError(t, err, "Expected error when getting deleted TV show")
 		})
 	})
 

internal/repo/book_repository_test.go

···
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestBookRepository(t *testing.T) {
···
 			book := CreateSampleBook()
 
 			id, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
-			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
-			AssertEqual(t, id, book.ID, "Expected book ID to be set correctly")
-			AssertFalse(t, book.Added.IsZero(), "Expected Added timestamp to be set")
+			shared.AssertNoError(t, err, "Failed to create book")
+			shared.AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+			shared.AssertEqual(t, id, book.ID, "Expected book ID to be set correctly")
+			shared.AssertFalse(t, book.Added.IsZero(), "Expected Added timestamp to be set")
 		})
 
 		t.Run("Get Book", func(t *testing.T) {
 			original := CreateSampleBook()
 			id, err := repo.Create(ctx, original)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get book")
+			shared.AssertNoError(t, err, "Failed to get book")
 
-			AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
-			AssertEqual(t, original.Author, retrieved.Author, "Author mismatch")
-			AssertEqual(t, original.Status, retrieved.Status, "Status mismatch")
-			AssertEqual(t, original.Progress, retrieved.Progress, "Progress mismatch")
-			AssertEqual(t, original.Pages, retrieved.Pages, "Pages mismatch")
-			AssertEqual(t, original.Rating, retrieved.Rating, "Rating mismatch")
-			AssertEqual(t, original.Notes, retrieved.Notes, "Notes mismatch")
+			shared.AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
+			shared.AssertEqual(t, original.Author, retrieved.Author, "Author mismatch")
+			shared.AssertEqual(t, original.Status, retrieved.Status, "Status mismatch")
+			shared.AssertEqual(t, original.Progress, retrieved.Progress, "Progress mismatch")
+			shared.AssertEqual(t, original.Pages, retrieved.Pages, "Pages mismatch")
+			shared.AssertEqual(t, original.Rating, retrieved.Rating, "Rating mismatch")
+			shared.AssertEqual(t, original.Notes, retrieved.Notes, "Notes mismatch")
 		})
 
 		t.Run("Update Book", func(t *testing.T) {
 			book := CreateSampleBook()
 			id, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 
 			book.Title = "Updated Book"
 			book.Status = "reading"
···
 			book.Started = &now
 
 			err = repo.Update(ctx, book)
-			AssertNoError(t, err, "Failed to update book")
+			shared.AssertNoError(t, err, "Failed to update book")
 
 			updated, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated book")
+			shared.AssertNoError(t, err, "Failed to get updated book")
 
-			AssertEqual(t, "Updated Book", updated.Title, "Expected updated title")
-			AssertEqual(t, "reading", updated.Status, "Expected reading status")
-			AssertEqual(t, 50, updated.Progress, "Expected progress 50")
-			AssertEqual(t, 5.0, updated.Rating, "Expected rating 5.0")
-			AssertTrue(t, updated.Started != nil, "Expected started time to be set")
+			shared.AssertEqual(t, "Updated Book", updated.Title, "Expected updated title")
+			shared.AssertEqual(t, "reading", updated.Status, "Expected reading status")
+			shared.AssertEqual(t, 50, updated.Progress, "Expected progress 50")
+			shared.AssertEqual(t, 5.0, updated.Rating, "Expected rating 5.0")
+			shared.AssertTrue(t, updated.Started != nil, "Expected started time to be set")
 		})
 
 		t.Run("Delete Book", func(t *testing.T) {
 			book := CreateSampleBook()
 			id, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 
 			err = repo.Delete(ctx, id)
-			AssertNoError(t, err, "Failed to delete book")
+			shared.AssertNoError(t, err, "Failed to delete book")
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "Expected error when getting deleted book")
+			shared.AssertError(t, err, "Expected error when getting deleted book")
 		})
 	})
 
···
 
 		for _, book := range books {
 			_, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 		}
 
 		t.Run("List All Books", func(t *testing.T) {
 			results, err := repo.List(ctx, BookListOptions{})
-			AssertNoError(t, err, "Failed to list books")
-			AssertEqual(t, 4, len(results), "Expected 4 books")
+			shared.AssertNoError(t, err, "Failed to list books")
+			shared.AssertEqual(t, 4, len(results), "Expected 4 books")
 		})
 
 		t.Run("List Books with Status Filter", func(t *testing.T) {
 			results, err := repo.List(ctx, BookListOptions{Status: "queued"})
-			AssertNoError(t, err, "Failed to list books")
-			AssertEqual(t, 2, len(results), "Expected 2 queued books")
+			shared.AssertNoError(t, err, "Failed to list books")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 queued books")
 
 			for _, book := range results {
-				AssertEqual(t, "queued", book.Status, "Expected queued status")
+				shared.AssertEqual(t, "queued", book.Status, "Expected queued status")
 			}
 		})
 
 		t.Run("List Books by Author", func(t *testing.T) {
 			results, err := repo.List(ctx, BookListOptions{Author: "Author A"})
-			AssertNoError(t, err, "Failed to list books")
-			AssertEqual(t, 2, len(results), "Expected 2 books by Author A")
+			shared.AssertNoError(t, err, "Failed to list books")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 books by Author A")
 
 			for _, book := range results {
-				AssertEqual(t, "Author A", book.Author, "Expected author 'Author A'")
+				shared.AssertEqual(t, "Author A", book.Author, "Expected author 'Author A'")
 			}
 		})
 
 		t.Run("List Books with Progress Filter", func(t *testing.T) {
 			results, err := repo.List(ctx, BookListOptions{MinProgress: 50})
-			AssertNoError(t, err, "Failed to list books")
-			AssertEqual(t, 2, len(results), "Expected 2 books with progress >= 50")
+			shared.AssertNoError(t, err, "Failed to list books")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 books with progress >= 50")
 
 			for _, book := range results {
-				AssertTrue(t, book.Progress >= 50, "Expected progress >= 50")
+				shared.AssertTrue(t, book.Progress >= 50, "Expected progress >= 50")
 			}
 		})
 
 		t.Run("List Books with Rating Filter", func(t *testing.T) {
 			results, err := repo.List(ctx, BookListOptions{MinRating: 4.5})
-			AssertNoError(t, err, "Failed to list books")
-			AssertEqual(t, 2, len(results), "Expected 2 books with rating >= 4.5")
+			shared.AssertNoError(t, err, "Failed to list books")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 books with rating >= 4.5")
 
 			for _, book := range results {
-				AssertTrue(t, book.Rating >= 4.5, "Expected rating >= 4.5")
+				shared.AssertTrue(t, book.Rating >= 4.5, "Expected rating >= 4.5")
 			}
 		})
 
 		t.Run("List Books with Search", func(t *testing.T) {
 			results, err := repo.List(ctx, BookListOptions{Search: "Book 1"})
-			AssertNoError(t, err, "Failed to list books")
-			AssertEqual(t, 1, len(results), "Expected 1 book matching search")
+			shared.AssertNoError(t, err, "Failed to list books")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 book matching search")
 
 			if len(results) > 0 {
-				AssertEqual(t, "Book 1", results[0].Title, "Expected 'Book 1'")
+				shared.AssertEqual(t, "Book 1", results[0].Title, "Expected 'Book 1'")
 			}
 		})
 
 		t.Run("List Books with Limit", func(t *testing.T) {
 			results, err := repo.List(ctx, BookListOptions{Limit: 2})
-			AssertNoError(t, err, "Failed to list books")
-			AssertEqual(t, 2, len(results), "Expected 2 books due to limit")
+			shared.AssertNoError(t, err, "Failed to list books")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 books due to limit")
 		})
 	})
 
···
 		var book1ID int64
 		for _, book := range []*models.Book{book1, book2, book3, book4} {
 			id, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 			if book == book1 {
 				book1ID = id
 			}
···
 
 		t.Run("GetQueued", func(t *testing.T) {
 			results, err := repo.GetQueued(ctx)
-			AssertNoError(t, err, "Failed to get queued books")
-			AssertEqual(t, 2, len(results), "Expected 2 queued books")
+			shared.AssertNoError(t, err, "Failed to get queued books")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 queued books")
 
 			for _, book := range results {
-				AssertEqual(t, "queued", book.Status, "Expected queued status")
+				shared.AssertEqual(t, "queued", book.Status, "Expected queued status")
 			}
 		})
 
 		t.Run("GetReading", func(t *testing.T) {
 			results, err := repo.GetReading(ctx)
-			AssertNoError(t, err, "Failed to get reading books")
-			AssertEqual(t, 1, len(results), "Expected 1 reading book")
+			shared.AssertNoError(t, err, "Failed to get reading books")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 reading book")
 
 			if len(results) > 0 {
-				AssertEqual(t, "reading", results[0].Status, "Expected reading status")
+				shared.AssertEqual(t, "reading", results[0].Status, "Expected reading status")
 			}
 		})
 
 		t.Run("GetFinished", func(t *testing.T) {
 			results, err := repo.GetFinished(ctx)
-			AssertNoError(t, err, "Failed to get finished books")
-			AssertEqual(t, 1, len(results), "Expected 1 finished book")
+			shared.AssertNoError(t, err, "Failed to get finished books")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 finished book")
 
 			if len(results) > 0 {
-				AssertEqual(t, "finished", results[0].Status, "Expected finished status")
+				shared.AssertEqual(t, "finished", results[0].Status, "Expected finished status")
 			}
 		})
 
 		t.Run("GetByAuthor", func(t *testing.T) {
 			results, err := repo.GetByAuthor(ctx, "Author A")
-			AssertNoError(t, err, "Failed to get books by author")
-			AssertEqual(t, 2, len(results), "Expected 2 books by Author A")
+			shared.AssertNoError(t, err, "Failed to get books by author")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 books by Author A")
 
 			for _, book := range results {
-				AssertEqual(t, "Author A", book.Author, "Expected author 'Author A'")
+				shared.AssertEqual(t, "Author A", book.Author, "Expected author 'Author A'")
 			}
 		})
 
 		t.Run("StartReading", func(t *testing.T) {
 			err := repo.StartReading(ctx, book1ID)
-			AssertNoError(t, err, "Failed to start reading book")
+			shared.AssertNoError(t, err, "Failed to start reading book")
 
 			updated, err := repo.Get(ctx, book1ID)
-			AssertNoError(t, err, "Failed to get updated book")
+			shared.AssertNoError(t, err, "Failed to get updated book")
 
-			AssertEqual(t, "reading", updated.Status, "Expected status to be reading")
-			AssertTrue(t, updated.Started != nil, "Expected started timestamp to be set")
+			shared.AssertEqual(t, "reading", updated.Status, "Expected status to be reading")
+			shared.AssertTrue(t, updated.Started != nil, "Expected started timestamp to be set")
 		})
 
 		t.Run("FinishReading", func(t *testing.T) {
 			newBook := &models.Book{Title: "New Book", Status: "reading", Progress: 80}
 			id, err := repo.Create(ctx, newBook)
-			AssertNoError(t, err, "Failed to create new book")
+			shared.AssertNoError(t, err, "Failed to create new book")
 
 			err = repo.FinishReading(ctx, id)
-			AssertNoError(t, err, "Failed to finish reading book")
+			shared.AssertNoError(t, err, "Failed to finish reading book")
 
 			updated, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated book")
+			shared.AssertNoError(t, err, "Failed to get updated book")
 
-			AssertEqual(t, "finished", updated.Status, "Expected status to be finished")
-			AssertEqual(t, 100, updated.Progress, "Expected progress to be 100")
-			AssertTrue(t, updated.Finished != nil, "Expected finished timestamp to be set")
+			shared.AssertEqual(t, "finished", updated.Status, "Expected status to be finished")
+			shared.AssertEqual(t, 100, updated.Progress, "Expected progress to be 100")
+			shared.AssertTrue(t, updated.Finished != nil, "Expected finished timestamp to be set")
 		})
 
 		t.Run("UpdateProgress", func(t *testing.T) {
 			newBook := &models.Book{Title: "Progress Book", Status: "queued", Progress: 0}
 			id, err := repo.Create(ctx, newBook)
-			AssertNoError(t, err, "Failed to create new book")
+			shared.AssertNoError(t, err, "Failed to create new book")
 
 			err = repo.UpdateProgress(ctx, id, 25)
-			AssertNoError(t, err, "Failed to update progress")
+			shared.AssertNoError(t, err, "Failed to update progress")
 
 			updated, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated book")
+			shared.AssertNoError(t, err, "Failed to get updated book")
 
-			AssertEqual(t, "reading", updated.Status, "Expected status to be reading when progress > 0")
-			AssertEqual(t, 25, updated.Progress, "Expected progress 25")
-			AssertTrue(t, updated.Started != nil, "Expected started timestamp to be set when progress > 0")
+			shared.AssertEqual(t, "reading", updated.Status, "Expected status to be reading when progress > 0")
+			shared.AssertEqual(t, 25, updated.Progress, "Expected progress 25")
+			shared.AssertTrue(t, updated.Started != nil, "Expected started timestamp to be set when progress > 0")
 
 			err = repo.UpdateProgress(ctx, id, 100)
-			AssertNoError(t, err, "Failed to update progress to 100")
+			shared.AssertNoError(t, err, "Failed to update progress to 100")
 
 			updated, err = repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated book")
+			shared.AssertNoError(t, err, "Failed to get updated book")
 
-			AssertEqual(t, "finished", updated.Status, "Expected status to be finished when progress = 100")
-			AssertEqual(t, 100, updated.Progress, "Expected progress 100")
-			AssertTrue(t, updated.Finished != nil, "Expected finished timestamp to be set when progress = 100")
+			shared.AssertEqual(t, "finished", updated.Status, "Expected status to be finished when progress = 100")
+			shared.AssertEqual(t, 100, updated.Progress, "Expected progress 100")
+			shared.AssertTrue(t, updated.Finished != nil, "Expected finished timestamp to be set when progress = 100")
 		})
 	})
 
···
 
 		for _, book := range books {
 			_, err := repo.Create(ctx, book)
-			AssertNoError(t, err, "Failed to create book")
+			shared.AssertNoError(t, err, "Failed to create book")
 		}
 
 		t.Run("Count all books", func(t *testing.T) {
 			count, err := repo.Count(ctx, BookListOptions{})
-			AssertNoError(t, err, "Failed to count books")
-			AssertEqual(t, int64(4), count, "Expected 4 books")
+			shared.AssertNoError(t, err, "Failed to count books")
+			shared.AssertEqual(t, int64(4), count, "Expected 4 books")
 		})
 
 		t.Run("Count queued books", func(t *testing.T) {
 			count, err := repo.Count(ctx, BookListOptions{Status: "queued"})
-			AssertNoError(t, err, "Failed to count queued books")
-			AssertEqual(t, int64(2), count, "Expected 2 queued books")
+			shared.AssertNoError(t, err, "Failed to count queued books")
+			shared.AssertEqual(t, int64(2), count, "Expected 2 queued books")
 		})
 
 		t.Run("Count books by progress", func(t *testing.T) {
 			count, err := repo.Count(ctx, BookListOptions{MinProgress: 50})
-			AssertNoError(t, err, "Failed to count books with progress >= 50")
-			AssertEqual(t, int64(2), count, "Expected 2 books with progress >= 50")
+			shared.AssertNoError(t, err, "Failed to count books with progress >= 50")
+			shared.AssertEqual(t, int64(2), count, "Expected 2 books with progress >= 50")
 		})
 
 		t.Run("Count books by rating", func(t *testing.T) {
 			count, err := repo.Count(ctx, BookListOptions{MinRating: 4.0})
-			AssertNoError(t, err, "Failed to count high-rated books")
-			AssertEqual(t, int64(3), count, "Expected 3 books with rating >= 4.0")
+			shared.AssertNoError(t, err, "Failed to count high-rated books")
+			shared.AssertEqual(t, int64(3), count, "Expected 3 books with rating >= 4.0")
 		})
 
 		t.Run("Count with context cancellation", func(t *testing.T) {
···
 
 		book := NewBookBuilder().WithTitle("Test Book").WithAuthor("Test Author").Build()
 		id, err := repo.Create(ctx, book)
-		AssertNoError(t, err, "Failed to create book")
+		shared.AssertNoError(t, err, "Failed to create book")
 
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newBook := NewBookBuilder().WithTitle("Cancelled").Build()
···
 
 		t.Run("Get non-existent book", func(t *testing.T) {
 			_, err := repo.Get(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent book")
+			shared.AssertError(t, err, "Expected error for non-existent book")
 		})
 
 		t.Run("Update non-existent book succeeds with no rows affected", func(t *testing.T) {
 			book := NewBookBuilder().WithTitle("Non-existent").Build()
 			book.ID = 99999
 			err := repo.Update(ctx, book)
-			AssertNoError(t, err, "Update should not error when no rows affected")
+			shared.AssertNoError(t, err, "Update should not error when no rows affected")
 		})
 
 		t.Run("Delete non-existent book succeeds with no rows affected", func(t *testing.T) {
 			err := repo.Delete(ctx, 99999)
-			AssertNoError(t, err, "Delete should not error when no rows affected")
+			shared.AssertNoError(t, err, "Delete should not error when no rows affected")
 		})
 
 		t.Run("StartReading non-existent book", func(t *testing.T) {
 			err := repo.StartReading(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent book")
+			shared.AssertError(t, err, "Expected error for non-existent book")
 		})
 
 		t.Run("FinishReading non-existent book", func(t *testing.T) {
 			err := repo.FinishReading(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent book")
+			shared.AssertError(t, err, "Expected error for non-existent book")
 		})
 
 		t.Run("UpdateProgress non-existent book", func(t *testing.T) {
 			err := repo.UpdateProgress(ctx, 99999, 50)
-			AssertError(t, err, "Expected error for non-existent book")
+			shared.AssertError(t, err, "Expected error for non-existent book")
 		})
 
 		t.Run("GetByAuthor with no results", func(t *testing.T) {
 			books, err := repo.GetByAuthor(ctx, "NonExistentAuthor")
-			AssertNoError(t, err, "Should not error when no books found")
-			AssertEqual(t, 0, len(books), "Expected empty result set")
+			shared.AssertNoError(t, err, "Should not error when no books found")
+			shared.AssertEqual(t, 0, len(books), "Expected empty result set")
 		})
 	})
 }

internal/repo/find_methods_test.go

···
 import (
 	"context"
 	"testing"
+
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestFindMethods(t *testing.T) {
···
 				Status: "pending",
 			}
 			tasks, err := repos.Tasks.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(tasks) >= 1, "Should find at least one pending task")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(tasks) >= 1, "Should find at least one pending task")
 			for _, task := range tasks {
-				AssertEqual(t, "pending", task.Status, "All returned tasks should be pending")
+				shared.AssertEqual(t, "pending", task.Status, "All returned tasks should be pending")
 			}
 		})
 
···
 				Priority: "high",
 			}
 			tasks, err := repos.Tasks.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(tasks) >= 1, "Should find at least one high priority task")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(tasks) >= 1, "Should find at least one high priority task")
 			for _, task := range tasks {
-				AssertEqual(t, "high", task.Priority, "All returned tasks should be high priority")
+				shared.AssertEqual(t, "high", task.Priority, "All returned tasks should be high priority")
 			}
 		})
 
···
 				Project: "test-project",
 			}
 			tasks, err := repos.Tasks.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(tasks) >= 1, "Should find tasks in test-project")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(tasks) >= 1, "Should find tasks in test-project")
 			for _, task := range tasks {
-				AssertEqual(t, "test-project", task.Project, "All returned tasks should be in test-project")
+				shared.AssertEqual(t, "test-project", task.Project, "All returned tasks should be in test-project")
 			}
 		})
 
···
 				Context: "test-context",
 			}
 			tasks, err := repos.Tasks.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(tasks) >= 1, "Should find tasks in test-context")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(tasks) >= 1, "Should find tasks in test-context")
 			for _, task := range tasks {
-				AssertEqual(t, "test-context", task.Context, "All returned tasks should be in test-context")
+				shared.AssertEqual(t, "test-context", task.Context, "All returned tasks should be in test-context")
 			}
 		})
 
···
 				Project:  "test-project",
 			}
 			tasks, err := repos.Tasks.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
+			shared.AssertNoError(t, err, "Find should succeed")
 			for _, task := range tasks {
-				AssertEqual(t, "pending", task.Status, "Task should be pending")
-				AssertEqual(t, "high", task.Priority, "Task should be high priority")
-				AssertEqual(t, "test-project", task.Project, "Task should be in test-project")
+				shared.AssertEqual(t, "pending", task.Status, "Task should be pending")
+				shared.AssertEqual(t, "high", task.Priority, "Task should be high priority")
+				shared.AssertEqual(t, "test-project", task.Project, "Task should be in test-project")
 			}
 		})
 
···
 				Status: "non-existent-status",
 			}
 			tasks, err := repos.Tasks.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed even with no results")
-			AssertEqual(t, 0, len(tasks), "Should find no tasks")
+			shared.AssertNoError(t, err, "Find should succeed even with no results")
+			shared.AssertEqual(t, 0, len(tasks), "Should find no tasks")
 		})
 
 		t.Run("returns all tasks with empty options", func(t *testing.T) {
 			options := TaskListOptions{}
 			tasks, err := repos.Tasks.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed with empty options")
-			AssertTrue(t, len(tasks) >= 2, "Should return all tasks for empty options")
+			shared.AssertNoError(t, err, "Find should succeed with empty options")
+			shared.AssertTrue(t, len(tasks) >= 2, "Should return all tasks for empty options")
 		})
 	})
 
···
 				Status: "reading",
 			}
 			books, err := repos.Books.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(books) >= 1, "Should find at least one book being read")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(books) >= 1, "Should find at least one book being read")
 			for _, book := range books {
-				AssertEqual(t, "reading", book.Status, "All returned books should be reading")
+				shared.AssertEqual(t, "reading", book.Status, "All returned books should be reading")
 			}
 		})
 
···
 				Author: "Test Author",
 			}
 			books, err := repos.Books.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(books) >= 1, "Should find at least one book by Test Author")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(books) >= 1, "Should find at least one book by Test Author")
 			for _, book := range books {
-				AssertEqual(t, "Test Author", book.Author, "All returned books should be by Test Author")
+				shared.AssertEqual(t, "Test Author", book.Author, "All returned books should be by Test Author")
 			}
 		})
 
···
 				MinProgress: 0,
 			}
 			books, err := repos.Books.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(books) >= 1, "Should find books with progress >= 0")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(books) >= 1, "Should find books with progress >= 0")
 			for _, book := range books {
-				AssertTrue(t, book.Progress >= 0, "All returned books should have progress >= 0")
+				shared.AssertTrue(t, book.Progress >= 0, "All returned books should have progress >= 0")
 			}
 		})
 
···
 				MinProgress: 0,
 			}
 			books, err := repos.Books.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
+			shared.AssertNoError(t, err, "Find should succeed")
 			for _, book := range books {
-				AssertEqual(t, "reading", book.Status, "Book should be reading")
-				AssertEqual(t, "Test Author", book.Author, "Book should be by Test Author")
-				AssertTrue(t, book.Progress >= 0, "Book should have progress >= 0")
+				shared.AssertEqual(t, "reading", book.Status, "Book should be reading")
+				shared.AssertEqual(t, "Test Author", book.Author, "Book should be by Test Author")
+				shared.AssertTrue(t, book.Progress >= 0, "Book should have progress >= 0")
 			}
 		})
 
···
 				Status: "non-existent-status",
 			}
 			books, err := repos.Books.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed even with no results")
-			AssertEqual(t, 0, len(books), "Should find no books")
+			shared.AssertNoError(t, err, "Find should succeed even with no results")
+			shared.AssertEqual(t, 0, len(books), "Should find no books")
 		})
 
 		t.Run("returns all books with empty options", func(t *testing.T) {
 			options := BookListOptions{}
 			books, err := repos.Books.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed with empty options")
-			AssertTrue(t, len(books) >= 2, "Should return all books for empty options")
+			shared.AssertNoError(t, err, "Find should succeed with empty options")
+			shared.AssertTrue(t, len(books) >= 2, "Should return all books for empty options")
 		})
 	})
 
···
 				Status: "watched",
 			}
 			movies, err := repos.Movies.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(movies) >= 1, "Should find at least one watched movie")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(movies) >= 1, "Should find at least one watched movie")
 			for _, movie := range movies {
-				AssertEqual(t, "watched", movie.Status, "All returned movies should be watched")
+				shared.AssertEqual(t, "watched", movie.Status, "All returned movies should be watched")
 			}
 		})
 
···
 				Year: 2023,
 			}
 			movies, err := repos.Movies.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(movies) >= 1, "Should find movies from 2023")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(movies) >= 1, "Should find movies from 2023")
 			for _, movie := range movies {
-				AssertEqual(t, 2023, movie.Year, "Movie should be from 2023")
+				shared.AssertEqual(t, 2023, movie.Year, "Movie should be from 2023")
 			}
 		})
 
···
 				MinRating: 0.0,
 			}
 			movies, err := repos.Movies.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(movies) >= 1, "Should find movies with rating >= 0")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(movies) >= 1, "Should find movies with rating >= 0")
 			for _, movie := range movies {
-				AssertTrue(t, movie.Rating >= 0.0, "Movie rating should be >= 0")
+				shared.AssertTrue(t, movie.Rating >= 0.0, "Movie rating should be >= 0")
 			}
 		})
 
···
 				MinRating: 0.0,
 			}
 			movies, err := repos.Movies.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
+			shared.AssertNoError(t, err, "Find should succeed")
 			for _, movie := range movies {
-				AssertEqual(t, "watched", movie.Status, "Movie should be watched")
-				AssertEqual(t, 2023, movie.Year, "Movie should be from 2023")
-				AssertTrue(t, movie.Rating >= 0.0, "Movie rating should be >= 0")
+				shared.AssertEqual(t, "watched", movie.Status, "Movie should be watched")
+				shared.AssertEqual(t, 2023, movie.Year, "Movie should be from 2023")
+				shared.AssertTrue(t, movie.Rating >= 0.0, "Movie rating should be >= 0")
 			}
 		})
 
···
 				Status: "non-existent-status",
 			}
 			movies, err := repos.Movies.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed even with no results")
-			AssertEqual(t, 0, len(movies), "Should find no movies")
+			shared.AssertNoError(t, err, "Find should succeed even with no results")
+			shared.AssertEqual(t, 0, len(movies), "Should find no movies")
 		})
 
 		t.Run("returns all movies with empty options", func(t *testing.T) {
 			options := MovieListOptions{}
 			movies, err := repos.Movies.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed with empty options")
-			AssertTrue(t, len(movies) >= 2, "Should return all movies for empty options")
+			shared.AssertNoError(t, err, "Find should succeed with empty options")
+			shared.AssertTrue(t, len(movies) >= 2, "Should return all movies for empty options")
 		})
 	})
 
···
 				Status: "watching",
 			}
 			shows, err := repos.TV.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(shows) >= 1, "Should find at least one TV show being watched")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(shows) >= 1, "Should find at least one TV show being watched")
 			for _, show := range shows {
-				AssertEqual(t, "watching", show.Status, "All returned shows should be watching")
+				shared.AssertEqual(t, "watching", show.Status, "All returned shows should be watching")
 			}
 		})
 
···
 				Season: 1,
 			}
 			shows, err := repos.TV.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(shows) >= 1, "Should find TV shows with season 1")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(shows) >= 1, "Should find TV shows with season 1")
 			for _, show := range shows {
-				AssertEqual(t, 1, show.Season, "All returned shows should be season 1")
+				shared.AssertEqual(t, 1, show.Season, "All returned shows should be season 1")
 			}
 		})
 
···
 				MinRating: 0.0,
 			}
 			shows, err := repos.TV.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
-			AssertTrue(t, len(shows) >= 1, "Should find TV shows with rating >= 0")
+			shared.AssertNoError(t, err, "Find should succeed")
+			shared.AssertTrue(t, len(shows) >= 1, "Should find TV shows with rating >= 0")
 			for _, show := range shows {
-				AssertTrue(t, show.Rating >= 0.0, "Show rating should be >= 0")
+				shared.AssertTrue(t, show.Rating >= 0.0, "Show rating should be >= 0")
 			}
 		})
 
···
 				MinRating: 0.0,
 			}
 			shows, err := repos.TV.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed")
+			shared.AssertNoError(t, err, "Find should succeed")
 			for _, show := range shows {
-				AssertEqual(t, "watching", show.Status, "Show should be watching")
-				AssertEqual(t, 1, show.Season, "Show should be season 1")
-				AssertTrue(t, show.Rating >= 0.0, "Show rating should be >= 0")
+				shared.AssertEqual(t, "watching", show.Status, "Show should be watching")
+				shared.AssertEqual(t, 1, show.Season, "Show should be season 1")
+				shared.AssertTrue(t, show.Rating >= 0.0, "Show rating should be >= 0")
 			}
 		})
 
···
 				Status: "non-existent-status",
 			}
 			shows, err := repos.TV.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed even with no results")
-			AssertEqual(t, 0, len(shows), "Should find no TV shows")
+			shared.AssertNoError(t, err, "Find should succeed even with no results")
+			shared.AssertEqual(t, 0, len(shows), "Should find no TV shows")
 		})
 
 		t.Run("returns all TV shows with empty options", func(t *testing.T) {
 			options := TVListOptions{}
 			shows, err := repos.TV.Find(ctx, options)
-			AssertNoError(t, err, "Find should succeed with empty options")
-			AssertTrue(t, len(shows) >= 2, "Should return all TV shows for empty options")
+			shared.AssertNoError(t, err, "Find should succeed with empty options")
+			shared.AssertTrue(t, len(shows) >= 2, "Should return all TV shows for empty options")
 		})
 	})
 }

internal/repo/movie_repository_test.go

···
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestMovieRepository(t *testing.T) {
···
 			movie := CreateSampleMovie()
 
 			id, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
-			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
-			AssertEqual(t, id, movie.ID, "Expected movie ID to be set correctly")
-			AssertFalse(t, movie.Added.IsZero(), "Expected Added timestamp to be set")
+			shared.AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+			shared.AssertEqual(t, id, movie.ID, "Expected movie ID to be set correctly")
+			shared.AssertFalse(t, movie.Added.IsZero(), "Expected Added timestamp to be set")
 		})
 
 		t.Run("Get Movie", func(t *testing.T) {
 			original := CreateSampleMovie()
 			id, err := repo.Create(ctx, original)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get movie")
+			shared.AssertNoError(t, err, "Failed to get movie")
 
-			AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
-			AssertEqual(t, original.Year, retrieved.Year, "Year mismatch")
-			AssertEqual(t, original.Status, retrieved.Status, "Status mismatch")
-			AssertEqual(t, original.Rating, retrieved.Rating, "Rating mismatch")
-			AssertEqual(t, original.Notes, retrieved.Notes, "Notes mismatch")
+			shared.AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
+			shared.AssertEqual(t, original.Year, retrieved.Year, "Year mismatch")
+			shared.AssertEqual(t, original.Status, retrieved.Status, "Status mismatch")
+			shared.AssertEqual(t, original.Rating, retrieved.Rating, "Rating mismatch")
+			shared.AssertEqual(t, original.Notes, retrieved.Notes, "Notes mismatch")
 		})
 
 		t.Run("Update Movie", func(t *testing.T) {
 			movie := CreateSampleMovie()
 			id, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 
 			movie.Title = "Updated Movie"
 			movie.Status = "watched"
···
 			movie.Watched = &now
 
 			err = repo.Update(ctx, movie)
-			AssertNoError(t, err, "Failed to update movie")
+			shared.AssertNoError(t, err, "Failed to update movie")
 
 			updated, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated movie")
+			shared.AssertNoError(t, err, "Failed to get updated movie")
 
-			AssertEqual(t, "Updated Movie", updated.Title, "Expected updated title")
-			AssertEqual(t, "watched", updated.Status, "Expected watched status")
-			AssertEqual(t, 9.0, updated.Rating, "Expected rating 9.0")
-			AssertTrue(t, updated.Watched != nil, "Expected watched time to be set")
+			shared.AssertEqual(t, "Updated Movie", updated.Title, "Expected updated title")
+			shared.AssertEqual(t, "watched", updated.Status, "Expected watched status")
+			shared.AssertEqual(t, 9.0, updated.Rating, "Expected rating 9.0")
+			shared.AssertTrue(t, updated.Watched != nil, "Expected watched time to be set")
 		})
 
 		t.Run("Delete Movie", func(t *testing.T) {
 			movie := CreateSampleMovie()
 			id, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 
 			err = repo.Delete(ctx, id)
-			AssertNoError(t, err, "Failed to delete movie")
+			shared.AssertNoError(t, err, "Failed to delete movie")
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "Expected error when getting deleted movie")
+			shared.AssertError(t, err, "Expected error when getting deleted movie")
 		})
 	})
 
···
 
 		for _, movie := range movies {
 			_, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 		}
 
 		t.Run("List All Movies", func(t *testing.T) {
 			results, err := repo.List(ctx, MovieListOptions{})
-			AssertNoError(t, err, "Failed to list movies")
-			AssertEqual(t, 3, len(results), "Expected 3 movies")
+			shared.AssertNoError(t, err, "Failed to list movies")
+			shared.AssertEqual(t, 3, len(results), "Expected 3 movies")
 		})
 
 		t.Run("List Movies with Status Filter", func(t *testing.T) {
 			results, err := repo.List(ctx, MovieListOptions{Status: "queued"})
-			AssertNoError(t, err, "Failed to list movies")
-			AssertEqual(t, 2, len(results), "Expected 2 queued movies")
+			shared.AssertNoError(t, err, "Failed to list movies")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 queued movies")
 
 			for _, movie := range results {
-				AssertEqual(t, "queued", movie.Status, "Expected queued status")
+				shared.AssertEqual(t, "queued", movie.Status, "Expected queued status")
 			}
 		})
 
 		t.Run("List Movies with Year Filter", func(t *testing.T) {
 			results, err := repo.List(ctx, MovieListOptions{Year: 2021})
-			AssertNoError(t, err, "Failed to list movies")
-			AssertEqual(t, 1, len(results), "Expected 1 movie from 2021")
+			shared.AssertNoError(t, err, "Failed to list movies")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 movie from 2021")
 
 			if len(results) > 0 {
-				AssertEqual(t, 2021, results[0].Year, "Expected year 2021")
+				shared.AssertEqual(t, 2021, results[0].Year, "Expected year 2021")
 			}
 		})
 
 		t.Run("List Movies with Rating Filter", func(t *testing.T) {
 			results, err := repo.List(ctx, MovieListOptions{MinRating: 8.0})
-			AssertNoError(t, err, "Failed to list movies")
-			AssertEqual(t, 2, len(results), "Expected 2 movies with rating >= 8.0")
+			shared.AssertNoError(t, err, "Failed to list movies")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 movies with rating >= 8.0")
 
 			for _, movie := range results {
-				AssertTrue(t, movie.Rating >= 8.0, "Expected rating >= 8.0")
+				shared.AssertTrue(t, movie.Rating >= 8.0, "Expected rating >= 8.0")
 			}
 		})
 
 		t.Run("List Movies with Search", func(t *testing.T) {
 			results, err := repo.List(ctx, MovieListOptions{Search: "Movie 1"})
-			AssertNoError(t, err, "Failed to list movies")
-			AssertEqual(t, 1, len(results), "Expected 1 movie matching search")
+			shared.AssertNoError(t, err, "Failed to list movies")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 movie matching search")
 
 			if len(results) > 0 {
-				AssertEqual(t, "Movie 1", results[0].Title, "Expected 'Movie 1'")
+				shared.AssertEqual(t, "Movie 1", results[0].Title, "Expected 'Movie 1'")
 			}
 		})
 
 		t.Run("List Movies with Limit", func(t *testing.T) {
 			results, err := repo.List(ctx, MovieListOptions{Limit: 2})
-			AssertNoError(t, err, "Failed to list movies")
-			AssertEqual(t, 2, len(results), "Expected 2 movies due to limit")
+			shared.AssertNoError(t, err, "Failed to list movies")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 movies due to limit")
 		})
 	})
 
···
 		var movie1ID int64
 		for _, movie := range []*models.Movie{movie1, movie2, movie3} {
 			id, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 			if movie == movie1 {
 				movie1ID = id
 			}
···
 
 		t.Run("GetQueued", func(t *testing.T) {
 			results, err := repo.GetQueued(ctx)
-			AssertNoError(t, err, "Failed to get queued movies")
-			AssertEqual(t, 2, len(results), "Expected 2 queued movies")
+			shared.AssertNoError(t, err, "Failed to get queued movies")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 queued movies")
 
 			for _, movie := range results {
-				AssertEqual(t, "queued", movie.Status, "Expected queued status")
+				shared.AssertEqual(t, "queued", movie.Status, "Expected queued status")
 			}
 		})
 
 		t.Run("GetWatched", func(t *testing.T) {
 			results, err := repo.GetWatched(ctx)
-			AssertNoError(t, err, "Failed to get watched movies")
-			AssertEqual(t, 1, len(results), "Expected 1 watched movie")
+			shared.AssertNoError(t, err, "Failed to get watched movies")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 watched movie")
 
 			if len(results) > 0 {
-				AssertEqual(t, "watched", results[0].Status, "Expected watched status")
+				shared.AssertEqual(t, "watched", results[0].Status, "Expected watched status")
 			}
 		})
 
 		t.Run("MarkWatched", func(t *testing.T) {
 			err := repo.MarkWatched(ctx, movie1ID)
-			AssertNoError(t, err, "Failed to mark movie as watched")
+			shared.AssertNoError(t, err, "Failed to mark movie as watched")
 
 			updated, err := repo.Get(ctx, movie1ID)
-			AssertNoError(t, err, "Failed to get updated movie")
+			shared.AssertNoError(t, err, "Failed to get updated movie")
 
-			AssertEqual(t, "watched", updated.Status, "Expected status to be watched")
-			AssertTrue(t, updated.Watched != nil, "Expected watched timestamp to be set")
+			shared.AssertEqual(t, "watched", updated.Status, "Expected status to be watched")
+			shared.AssertTrue(t, updated.Watched != nil, "Expected watched timestamp to be set")
 		})
 	})
 
···
 
 		for _, movie := range movies {
 			_, err := repo.Create(ctx, movie)
-			AssertNoError(t, err, "Failed to create movie")
+			shared.AssertNoError(t, err, "Failed to create movie")
 		}
 
 		t.Run("Count all movies", func(t *testing.T) {
 			count, err := repo.Count(ctx, MovieListOptions{})
-			AssertNoError(t, err, "Failed to count movies")
-			AssertEqual(t, int64(3), count, "Expected 3 movies")
+			shared.AssertNoError(t, err, "Failed to count movies")
+			shared.AssertEqual(t, int64(3), count, "Expected 3 movies")
 		})
 
 		t.Run("Count queued movies", func(t *testing.T) {
 			count, err := repo.Count(ctx, MovieListOptions{Status: "queued"})
-			AssertNoError(t, err, "Failed to count queued movies")
-			AssertEqual(t, int64(2), count, "Expected 2 queued movies")
+			shared.AssertNoError(t, err, "Failed to count queued movies")
+			shared.AssertEqual(t, int64(2), count, "Expected 2 queued movies")
 		})
 
 		t.Run("Count movies by rating", func(t *testing.T) {
 			count, err := repo.Count(ctx, MovieListOptions{MinRating: 8.0})
-			AssertNoError(t, err, "Failed to count high-rated movies")
-			AssertEqual(t, int64(2), count, "Expected 2 movies with rating >= 8.0")
+			shared.AssertNoError(t, err, "Failed to count high-rated movies")
+			shared.AssertEqual(t, int64(2), count, "Expected 2 movies with rating >= 8.0")
 		})
 
 		t.Run("Count with context cancellation", func(t *testing.T) {
···
 
 		movie := NewMovieBuilder().WithTitle("Test Movie").WithYear(2023).Build()
 		id, err := repo.Create(ctx, movie)
-		AssertNoError(t, err, "Failed to create movie")
+		shared.AssertNoError(t, err, "Failed to create movie")
 
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newMovie := NewMovieBuilder().WithTitle("Cancelled").Build()
···
 
 		t.Run("Get non-existent movie", func(t *testing.T) {
 			_, err := repo.Get(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent movie")
+			shared.AssertError(t, err, "Expected error for non-existent movie")
 		})
 
 		t.Run("Update non-existent movie succeeds with no rows affected", func(t *testing.T) {
 			movie := NewMovieBuilder().WithTitle("Non-existent").Build()
 			movie.ID = 99999
 			err := repo.Update(ctx, movie)
-			AssertNoError(t, err, "Update should not error when no rows affected")
+			shared.AssertNoError(t, err, "Update should not error when no rows affected")
 		})
 
 		t.Run("Delete non-existent movie succeeds with no rows affected", func(t *testing.T) {
 			err := repo.Delete(ctx, 99999)
-			AssertNoError(t, err, "Delete should not error when no rows affected")
+			shared.AssertNoError(t, err, "Delete should not error when no rows affected")
 		})
 
 		t.Run("MarkWatched non-existent movie", func(t *testing.T) {
 			err := repo.MarkWatched(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent movie")
+			shared.AssertError(t, err, "Expected error for non-existent movie")
 		})
 
 		t.Run("List with no results", func(t *testing.T) {
 			movies, err := repo.List(ctx, MovieListOptions{Year: 1900})
-			AssertNoError(t, err, "Should not error when no movies found")
-			AssertEqual(t, 0, len(movies), "Expected empty result set")
+			shared.AssertNoError(t, err, "Should not error when no movies found")
+			shared.AssertEqual(t, 0, len(movies), "Expected empty result set")
 		})
 	})
 }

internal/repo/note_repository_test.go

···
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestNoteRepository(t *testing.T) {
···
 			note := CreateSampleNote()
 
 			id, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create note")
-			AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
-			AssertEqual(t, id, note.ID, "Expected note ID to be set correctly")
-			AssertFalse(t, note.Created.IsZero(), "Expected Created timestamp to be set")
-			AssertFalse(t, note.Modified.IsZero(), "Expected Modified timestamp to be set")
+			shared.AssertNoError(t, err, "Failed to create note")
+			shared.AssertNotEqual(t, int64(0), id, "Expected non-zero ID")
+			shared.AssertEqual(t, id, note.ID, "Expected note ID to be set correctly")
+			shared.AssertFalse(t, note.Created.IsZero(), "Expected Created timestamp to be set")
+			shared.AssertFalse(t, note.Modified.IsZero(), "Expected Modified timestamp to be set")
 		})
 
 		t.Run("Get Note", func(t *testing.T) {
 			original := CreateSampleNote()
 			id, err := repo.Create(ctx, original)
-			AssertNoError(t, err, "Failed to create note")
+			shared.AssertNoError(t, err, "Failed to create note")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
+			shared.AssertNoError(t, err, "Failed to get note")
 
-			AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
-			AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
-			AssertEqual(t, original.Content, retrieved.Content, "Content mismatch")
-			AssertEqual(t, len(original.Tags), len(retrieved.Tags), "Tags length mismatch")
-			AssertEqual(t, original.Archived, retrieved.Archived, "Archived mismatch")
-			AssertEqual(t, original.FilePath, retrieved.FilePath, "FilePath mismatch")
+			shared.AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
+			shared.AssertEqual(t, original.Title, retrieved.Title, "Title mismatch")
+			shared.AssertEqual(t, original.Content, retrieved.Content, "Content mismatch")
+			shared.AssertEqual(t, len(original.Tags), len(retrieved.Tags), "Tags length mismatch")
+			shared.AssertEqual(t, original.Archived, retrieved.Archived, "Archived mismatch")
+			shared.AssertEqual(t, original.FilePath, retrieved.FilePath, "FilePath mismatch")
 		})
 
 		t.Run("Update Note", func(t *testing.T) {
 			note := CreateSampleNote()
 			id, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create note")
+			shared.AssertNoError(t, err, "Failed to create note")
 
 			originalModified := note.Modified
 
···
 			note.FilePath = "/new/path/note.md"
 
 			err = repo.Update(ctx, note)
-			AssertNoError(t, err, "Failed to update note")
+			shared.AssertNoError(t, err, "Failed to update note")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get updated note")
+			shared.AssertNoError(t, err, "Failed to get updated note")
 
-			AssertEqual(t, "Updated Title", retrieved.Title, "Expected updated title")
-			AssertEqual(t, "Updated content", retrieved.Content, "Expected updated content")
-			AssertEqual(t, 2, len(retrieved.Tags), "Expected 2 tags")
+			shared.AssertEqual(t, "Updated Title", retrieved.Title, "Expected updated title")
+			shared.AssertEqual(t, "Updated content", retrieved.Content, "Expected updated content")
+			shared.AssertEqual(t, 2, len(retrieved.Tags), "Expected 2 tags")
 			if len(retrieved.Tags) >= 2 {
-				AssertEqual(t, "updated", retrieved.Tags[0], "Expected first tag to be 'updated'")
-				AssertEqual(t, "test", retrieved.Tags[1], "Expected second tag to be 'test'")
+				shared.AssertEqual(t, "updated", retrieved.Tags[0], "Expected first tag to be 'updated'")
+				shared.AssertEqual(t, "test", retrieved.Tags[1], "Expected second tag to be 'test'")
 			}
-			AssertTrue(t, retrieved.Archived, "Expected note to be archived")
-			AssertEqual(t, "/new/path/note.md", retrieved.FilePath, "Expected updated file path")
-			AssertTrue(t, retrieved.Modified.After(originalModified), "Expected Modified timestamp to be updated")
+			shared.AssertTrue(t, retrieved.Archived, "Expected note to be archived")
+			shared.AssertEqual(t, "/new/path/note.md", retrieved.FilePath, "Expected updated file path")
+			shared.AssertTrue(t, retrieved.Modified.After(originalModified), "Expected Modified timestamp to be updated")
 		})
 
 		t.Run("Delete Note", func(t *testing.T) {
 			note := CreateSampleNote()
 			id, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create note")
+			shared.AssertNoError(t, err, "Failed to create note")
 
 			err = repo.Delete(ctx, id)
-			AssertNoError(t, err, "Failed to delete note")
+			shared.AssertNoError(t, err, "Failed to delete note")
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "Expected error when getting deleted note")
+			shared.AssertError(t, err, "Expected error when getting deleted note")
 		})
 	})
 
···
 
 		for _, note := range notes {
 			_, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create test note")
+			shared.AssertNoError(t, err, "Failed to create test note")
 		}
 
 		t.Run("List All Notes", func(t *testing.T) {
 			results, err := repo.List(ctx, NoteListOptions{})
-			AssertNoError(t, err, "Failed to list notes")
-			AssertEqual(t, 3, len(results), "Expected 3 notes")
+			shared.AssertNoError(t, err, "Failed to list notes")
+			shared.AssertEqual(t, 3, len(results), "Expected 3 notes")
 		})
 
 		t.Run("List Archived Notes Only", func(t *testing.T) {
 			archived := true
 			results, err := repo.List(ctx, NoteListOptions{Archived: &archived})
-			AssertNoError(t, err, "Failed to list archived notes")
-			AssertEqual(t, 1, len(results), "Expected 1 archived note")
+			shared.AssertNoError(t, err, "Failed to list archived notes")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 archived note")
 			if len(results) > 0 {
-				AssertTrue(t, results[0].Archived, "Retrieved note should be archived")
+				shared.AssertTrue(t, results[0].Archived, "Retrieved note should be archived")
 			}
 		})
 
 		t.Run("List Active Notes Only", func(t *testing.T) {
 			archived := false
 			results, err := repo.List(ctx, NoteListOptions{Archived: &archived})
-			AssertNoError(t, err, "Failed to list active notes")
-			AssertEqual(t, 2, len(results), "Expected 2 active notes")
+			shared.AssertNoError(t, err, "Failed to list active notes")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 active notes")
 			for _, note := range results {
-				AssertFalse(t, note.Archived, "Retrieved note should not be archived")
+				shared.AssertFalse(t, note.Archived, "Retrieved note should not be archived")
 			}
 		})
 
 		t.Run("Search by Title", func(t *testing.T) {
 			results, err := repo.List(ctx, NoteListOptions{Title: "First"})
-			AssertNoError(t, err, "Failed to search by title")
-			AssertEqual(t, 1, len(results), "Expected 1 note")
+			shared.AssertNoError(t, err, "Failed to search by title")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 note")
 			if len(results) > 0 {
-				AssertEqual(t, "First Note", results[0].Title, "Expected 'First Note'")
+				shared.AssertEqual(t, "First Note", results[0].Title, "Expected 'First Note'")
 			}
 		})
 
 		t.Run("Search by Content", func(t *testing.T) {
 			results, err := repo.List(ctx, NoteListOptions{Content: "Important"})
-			AssertNoError(t, err, "Failed to search by content")
-			AssertEqual(t, 1, len(results), "Expected 1 note")
+			shared.AssertNoError(t, err, "Failed to search by content")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 note")
 			if len(results) > 0 {
-				AssertEqual(t, "Third Note", results[0].Title, "Expected 'Third Note'")
+				shared.AssertEqual(t, "Third Note", results[0].Title, "Expected 'Third Note'")
 			}
 		})
 
 		t.Run("Limit and Offset", func(t *testing.T) {
 			results, err := repo.List(ctx, NoteListOptions{Limit: 2})
-			AssertNoError(t, err, "Failed to list with limit")
-			AssertEqual(t, 2, len(results), "Expected 2 notes")
+			shared.AssertNoError(t, err, "Failed to list with limit")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 notes")
 
 			results, err = repo.List(ctx, NoteListOptions{Limit: 2, Offset: 1})
-			AssertNoError(t, err, "Failed to list with limit and offset")
-			AssertEqual(t, 2, len(results), "Expected 2 notes with offset")
+			shared.AssertNoError(t, err, "Failed to list with limit and offset")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 notes with offset")
 		})
 	})
 
···
 
 		for _, note := range notes {
 			_, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create test note")
+			shared.AssertNoError(t, err, "Failed to create test note")
 		}
 
 		t.Run("GetByTitle", func(t *testing.T) {
 			results, err := repo.GetByTitle(ctx, "Work")
-			AssertNoError(t, err, "Failed to get by title")
-			AssertEqual(t, 1, len(results), "Expected 1 note")
+			shared.AssertNoError(t, err, "Failed to get by title")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 note")
 			if len(results) > 0 {
-				AssertEqual(t, "Work Note", results[0].Title, "Expected 'Work Note'")
+				shared.AssertEqual(t, "Work Note", results[0].Title, "Expected 'Work Note'")
 			}
 		})
 
 		t.Run("GetArchived", func(t *testing.T) {
 			results, err := repo.GetArchived(ctx)
-			AssertNoError(t, err, "Failed to get archived notes")
-			AssertEqual(t, 1, len(results), "Expected 1 archived note")
+			shared.AssertNoError(t, err, "Failed to get archived notes")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 archived note")
 			if len(results) > 0 {
-				AssertTrue(t, results[0].Archived, "Retrieved note should be archived")
+				shared.AssertTrue(t, results[0].Archived, "Retrieved note should be archived")
 			}
 		})
 
 		t.Run("GetActive", func(t *testing.T) {
 			results, err := repo.GetActive(ctx)
-			AssertNoError(t, err, "Failed to get active notes")
-			AssertEqual(t, 2, len(results), "Expected 2 active notes")
+			shared.AssertNoError(t, err, "Failed to get active notes")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 active notes")
 			for _, note := range results {
-				AssertFalse(t, note.Archived, "Retrieved note should not be archived")
+				shared.AssertFalse(t, note.Archived, "Retrieved note should not be archived")
 			}
 		})
 
···
 				Archived: false,
 			}
 			id, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create note")
+			shared.AssertNoError(t, err, "Failed to create note")
 
 			err = repo.Archive(ctx, id)
-			AssertNoError(t, err, "Failed to archive note")
+			shared.AssertNoError(t, err, "Failed to archive note")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
-			AssertTrue(t, retrieved.Archived, "Note should be archived")
+			shared.AssertNoError(t, err, "Failed to get note")
+			shared.AssertTrue(t, retrieved.Archived, "Note should be archived")
 
 			err = repo.Unarchive(ctx, id)
-			AssertNoError(t, err, "Failed to unarchive note")
+			shared.AssertNoError(t, err, "Failed to unarchive note")
 
 			retrieved, err = repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
-			AssertFalse(t, retrieved.Archived, "Note should not be archived")
+			shared.AssertNoError(t, err, "Failed to get note")
+			shared.AssertFalse(t, retrieved.Archived, "Note should not be archived")
 		})
 
 		t.Run("SearchContent", func(t *testing.T) {
 			results, err := repo.SearchContent(ctx, "Important")
-			AssertNoError(t, err, "Failed to search content")
-			AssertEqual(t, 1, len(results), "Expected 1 note")
+			shared.AssertNoError(t, err, "Failed to search content")
+			shared.AssertEqual(t, 1, len(results), "Expected 1 note")
 			if len(results) > 0 {
-				AssertEqual(t, "Important Note", results[0].Title, "Expected 'Important Note'")
+				shared.AssertEqual(t, "Important Note", results[0].Title, "Expected 'Important Note'")
 			}
 		})
 
 		t.Run("GetRecent", func(t *testing.T) {
 			results, err := repo.GetRecent(ctx, 2)
-			AssertNoError(t, err, "Failed to get recent notes")
-			AssertEqual(t, 2, len(results), "Expected 2 notes")
+			shared.AssertNoError(t, err, "Failed to get recent notes")
+			shared.AssertEqual(t, 2, len(results), "Expected 2 notes")
 		})
 	})
 
···
 			Tags:    []string{"initial"},
 		}
 		id, err := repo.Create(ctx, note)
-		AssertNoError(t, err, "Failed to create note")
+		shared.AssertNoError(t, err, "Failed to create note")
 
 		t.Run("AddTag", func(t *testing.T) {
 			err := repo.AddTag(ctx, id, "new-tag")
-			AssertNoError(t, err, "Failed to add tag")
+			shared.AssertNoError(t, err, "Failed to add tag")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
+			shared.AssertNoError(t, err, "Failed to get note")
 
-			AssertEqual(t, 2, len(retrieved.Tags), "Expected 2 tags")
+			shared.AssertEqual(t, 2, len(retrieved.Tags), "Expected 2 tags")
 
 			found := false
 			for _, tag := range retrieved.Tags {
···
 					break
 				}
 			}
-			AssertTrue(t, found, "New tag not found in note")
+			shared.AssertTrue(t, found, "New tag not found in note")
 		})
 
 		t.Run("AddTag Duplicate", func(t *testing.T) {
 			err := repo.AddTag(ctx, id, "new-tag")
-			AssertNoError(t, err, "Failed to add duplicate tag")
+			shared.AssertNoError(t, err, "Failed to add duplicate tag")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
+			shared.AssertNoError(t, err, "Failed to get note")
 
-			AssertEqual(t, 2, len(retrieved.Tags), "Expected 2 tags (no duplicate)")
+			shared.AssertEqual(t, 2, len(retrieved.Tags), "Expected 2 tags (no duplicate)")
 		})
 
 		t.Run("RemoveTag", func(t *testing.T) {
 			err := repo.RemoveTag(ctx, id, "initial")
-			AssertNoError(t, err, "Failed to remove tag")
+			shared.AssertNoError(t, err, "Failed to remove tag")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
+			shared.AssertNoError(t, err, "Failed to get note")
 
-			AssertEqual(t, 1, len(retrieved.Tags), "Expected 1 tag after removal")
+			shared.AssertEqual(t, 1, len(retrieved.Tags), "Expected 1 tag after removal")
 
 			for _, tag := range retrieved.Tags {
-				AssertNotEqual(t, "initial", tag, "Removed tag still found in note")
+				shared.AssertNotEqual(t, "initial", tag, "Removed tag still found in note")
 			}
 		})
 
···
 			}
 
 			_, err := repo.Create(ctx, note1)
-			AssertNoError(t, err, "Failed to create note1")
+			shared.AssertNoError(t, err, "Failed to create note1")
 			_, err = repo.Create(ctx, note2)
-			AssertNoError(t, err, "Failed to create note2")
+			shared.AssertNoError(t, err, "Failed to create note2")
 			_, err = repo.Create(ctx, note3)
-			AssertNoError(t, err, "Failed to create note3")
+			shared.AssertNoError(t, err, "Failed to create note3")
 
 			results, err := repo.GetByTags(ctx, []string{"work"})
-			AssertNoError(t, err, "Failed to get notes by tag")
-			AssertTrue(t, len(results) >= 2, "Expected at least 2 notes with 'work' tag")
+			shared.AssertNoError(t, err, "Failed to get notes by tag")
+			shared.AssertTrue(t, len(results) >= 2, "Expected at least 2 notes with 'work' tag")
 
 			results, err = repo.GetByTags(ctx, []string{"nonexistent"})
-			AssertNoError(t, err, "Failed to get notes by nonexistent tag")
-			AssertEqual(t, 0, len(results), "Expected 0 notes with nonexistent tag")
+			shared.AssertNoError(t, err, "Failed to get notes by nonexistent tag")
+			shared.AssertEqual(t, 0, len(results), "Expected 0 notes with nonexistent tag")
 
 			results, err = repo.GetByTags(ctx, []string{})
-			AssertNoError(t, err, "Failed to get notes with empty tags")
-			AssertEqual(t, 0, len(results), "Expected 0 notes with empty tag list")
+			shared.AssertNoError(t, err, "Failed to get notes with empty tags")
+			shared.AssertEqual(t, 0, len(results), "Expected 0 notes with empty tag list")
 		})
 	})
 
···
 
 		note := NewNoteBuilder().WithTitle("Test Note").WithContent("Test content").Build()
 		id, err := repo.Create(ctx, note)
-		AssertNoError(t, err, "Failed to create note")
+		shared.AssertNoError(t, err, "Failed to create note")
 
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newNote := NewNoteBuilder().WithTitle("Cancelled").Build()
···
 
 		t.Run("Get non-existent note", func(t *testing.T) {
 			_, err := repo.Get(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent note")
+			shared.AssertError(t, err, "Expected error for non-existent note")
 		})
 
 		t.Run("Update non-existent note", func(t *testing.T) {
···
 			}
 
 			err := repo.Update(ctx, note)
-			AssertError(t, err, "Expected error when updating non-existent note")
+			shared.AssertError(t, err, "Expected error when updating non-existent note")
 		})
 
 		t.Run("Delete non-existent note", func(t *testing.T) {
 			err := repo.Delete(ctx, 99999)
-			AssertError(t, err, "Expected error when deleting non-existent note")
+			shared.AssertError(t, err, "Expected error when deleting non-existent note")
 		})
 
 		t.Run("Archive non-existent note", func(t *testing.T) {
 			err := repo.Archive(ctx, 99999)
-			AssertError(t, err, "Expected error when archiving non-existent note")
+			shared.AssertError(t, err, "Expected error when archiving non-existent note")
 		})
 
 		t.Run("AddTag to non-existent note", func(t *testing.T) {
 			err := repo.AddTag(ctx, 99999, "tag")
-			AssertError(t, err, "Expected error when adding tag to non-existent note")
+			shared.AssertError(t, err, "Expected error when adding tag to non-existent note")
 		})
 
 		t.Run("Note with empty tags", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create note with empty tags")
+			shared.AssertNoError(t, err, "Failed to create note with empty tags")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
+			shared.AssertNoError(t, err, "Failed to get note")
 
-			AssertEqual(t, 0, len(retrieved.Tags), "Expected empty tags slice")
+			shared.AssertEqual(t, 0, len(retrieved.Tags), "Expected empty tags slice")
 		})
 
 		t.Run("Note with nil tags", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create note with nil tags")
+			shared.AssertNoError(t, err, "Failed to create note with nil tags")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
+			shared.AssertNoError(t, err, "Failed to get note")
 
-			AssertEqual(t, 0, len(retrieved.Tags), "Expected empty tags")
+			shared.AssertEqual(t, 0, len(retrieved.Tags), "Expected empty tags")
 		})
 
 		t.Run("Note with long content", func(t *testing.T) {
···
 			}
 
 			id, err := repo.Create(ctx, note)
-			AssertNoError(t, err, "Failed to create note with long content")
+			shared.AssertNoError(t, err, "Failed to create note with long content")
 
 			retrieved, err := repo.Get(ctx, id)
-			AssertNoError(t, err, "Failed to get note")
+			shared.AssertNoError(t, err, "Failed to get note")
 
-			AssertEqual(t, longContent, retrieved.Content, "Long content was not stored/retrieved correctly")
+			shared.AssertEqual(t, longContent, retrieved.Content, "Long content was not stored/retrieved correctly")
 		})
 
 		t.Run("List with no results", func(t *testing.T) {
 			notes, err := repo.List(ctx, NoteListOptions{Title: "NonexistentTitle"})
-			AssertNoError(t, err, "Should not error when no notes found")
-			AssertEqual(t, 0, len(notes), "Expected empty result set")
+			shared.AssertNoError(t, err, "Should not error when no notes found")
+			shared.AssertEqual(t, 0, len(notes), "Expected empty result set")
 		})
 	})
 }

internal/repo/task_repository_test.go

···
 	"github.com/google/uuid"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func newUUID() string {
···
 			t.Run("when called with context cancellation", func(t *testing.T) {
 				task := CreateSampleTask()
 				_, err := repo.Create(ctx, task)
-				AssertNoError(t, err, "Failed to create task")
+				shared.AssertNoError(t, err, "Failed to create task")
 
 				task.Description = "Updated"
 				err = repo.Update(NewCanceledContext(), task)
···
 			defer func() { marshalTaskTags = orig }()
 
 			_, err := repo.Create(ctx, CreateSampleTask())
-			AssertError(t, err, "expected MarshalTags error")
-			AssertContains(t, err.Error(), "failed to marshal tags", "error message")
+			shared.AssertError(t, err, "expected MarshalTags error")
+			shared.AssertContains(t, err.Error(), "failed to marshal tags", "error message")
 		})
 
 		t.Run("Create fails on MarshalAnnotations error", func(t *testing.T) {
···
 			defer func() { marshalTaskAnnotations = orig }()
 
 			_, err := repo.Create(ctx, CreateSampleTask())
-			AssertError(t, err, "expected MarshalAnnotations error")
-			AssertContains(t, err.Error(), "failed to marshal annotations", "error message")
+			shared.AssertError(t, err, "expected MarshalAnnotations error")
+			shared.AssertContains(t, err.Error(), "failed to marshal annotations", "error message")
 		})
 
 		t.Run("Update fails on MarshalTags error", func(t *testing.T) {
 			task := CreateSampleTask()
 			id, err := repo.Create(ctx, task)
-			AssertNoError(t, err, "create should succeed")
+			shared.AssertNoError(t, err, "create should succeed")
 
 			orig := marshalTaskTags
 			marshalTaskTags = func(t *models.Task) (string, error) {
···
 
 			task.ID = id
 			err = repo.Update(ctx, task)
-			AssertError(t, err, "expected MarshalTags error")
-			AssertContains(t, err.Error(), "failed to marshal tags", "error message")
+			shared.AssertError(t, err, "expected MarshalTags error")
+			shared.AssertContains(t, err.Error(), "failed to marshal tags", "error message")
 		})
 
 		t.Run("Update fails on MarshalAnnotations error", func(t *testing.T) {
 			task := CreateSampleTask()
 			id, err := repo.Create(ctx, task)
-			AssertNoError(t, err, "create should succeed")
+			shared.AssertNoError(t, err, "create should succeed")
 
 			orig := marshalTaskAnnotations
 			marshalTaskAnnotations = func(t *models.Task) (string, error) {
···
 
 			task.ID = id
 			err = repo.Update(ctx, task)
-			AssertError(t, err, "expected MarshalAnnotations error")
-			AssertContains(t, err.Error(), "failed to marshal annotations", "error message")
+			shared.AssertError(t, err, "expected MarshalAnnotations error")
+			shared.AssertContains(t, err.Error(), "failed to marshal annotations", "error message")
 		})
 
 		t.Run("Get fails on UnmarshalTags error", func(t *testing.T) {
 			task := CreateSampleTask()
 			task.Tags = []string{"test"}
 			id, err := repo.Create(ctx, task)
-			AssertNoError(t, err, "create should succeed")
+			shared.AssertNoError(t, err, "create should succeed")
 
 			orig := unmarshalTaskTags
 			unmarshalTaskTags = func(t *models.Task, s string) error {
···
 			defer func() { unmarshalTaskTags = orig }()
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "expected UnmarshalTags error")
-			AssertContains(t, err.Error(), "failed to unmarshal tags", "error message")
+			shared.AssertError(t, err, "expected UnmarshalTags error")
+			shared.AssertContains(t, err.Error(), "failed to unmarshal tags", "error message")
 		})
 
 		t.Run("Get fails on UnmarshalAnnotations error", func(t *testing.T) {
 			task := CreateSampleTask()
 			task.Annotations = []string{"test"}
 			id, err := repo.Create(ctx, task)
-			AssertNoError(t, err, "create should succeed")
+			shared.AssertNoError(t, err, "create should succeed")
 
 			orig := unmarshalTaskAnnotations
 			unmarshalTaskAnnotations = func(t *models.Task, s string) error {
···
 			defer func() { unmarshalTaskAnnotations = orig }()
 
 			_, err = repo.Get(ctx, id)
-			AssertError(t, err, "expected UnmarshalAnnotations error")
-			AssertContains(t, err.Error(), "failed to unmarshal annotations", "error message")
+			shared.AssertError(t, err, "expected UnmarshalAnnotations error")
+			shared.AssertContains(t, err.Error(), "failed to unmarshal annotations", "error message")
 		})
 
 		t.Run("GetByUUID fails on UnmarshalTags error", func(t *testing.T) {
 			task := CreateSampleTask()
 			task.Tags = []string{"test"}
 			_, err := repo.Create(ctx, task)
-			AssertNoError(t, err, "create should succeed")
+			shared.AssertNoError(t, err, "create should succeed")
 
 			orig := unmarshalTaskTags
 			unmarshalTaskTags = func(t *models.Task, s string) error {
···
 			defer func() { unmarshalTaskTags = orig }()
 
 			_, err = repo.GetByUUID(ctx, task.UUID)
-			AssertError(t, err, "expected UnmarshalTags error")
-			AssertContains(t, err.Error(), "failed to unmarshal tags", "error message")
+			shared.AssertError(t, err, "expected UnmarshalTags error")
+			shared.AssertContains(t, err.Error(), "failed to unmarshal tags", "error message")
 		})
 
 		t.Run("GetByUUID fails on UnmarshalAnnotations error", func(t *testing.T) {
 			task := CreateSampleTask()
 			task.Annotations = []string{"test"}
 			_, err := repo.Create(ctx, task)
-			AssertNoError(t, err, "create should succeed")
+			shared.AssertNoError(t, err, "create should succeed")
 
 			orig := unmarshalTaskAnnotations
 			unmarshalTaskAnnotations = func(t *models.Task, s string) error {
···
 			defer func() { unmarshalTaskAnnotations = orig }()
 
 			_, err = repo.GetByUUID(ctx, task.UUID)
-			AssertError(t, err, "expected UnmarshalAnnotations error")
-			AssertContains(t, err.Error(), "failed to unmarshal annotations", "error message")
+			shared.AssertError(t, err, "expected UnmarshalAnnotations error")
+			shared.AssertContains(t, err.Error(), "failed to unmarshal annotations", "error message")
 		})
 	})
 
···
 	t.Run("GetByContext", func(t *testing.T) {
 		task1 := NewTaskBuilder().WithContext("work").WithDescription("Work task 1").Build()
 		_, err := repo.Create(ctx, task1)
-		AssertNoError(t, err, "Failed to create task1")
+		shared.AssertNoError(t, err, "Failed to create task1")
 
 		task2 := NewTaskBuilder().WithContext("home").WithDescription("Home task 1").Build()
 		_, err = repo.Create(ctx, task2)
-		AssertNoError(t, err, "Failed to create task2")
+		shared.AssertNoError(t, err, "Failed to create task2")
 
 		task3 := NewTaskBuilder().WithContext("work").WithDescription("Work task 2").Build()
 		_, err = repo.Create(ctx, task3)
-		AssertNoError(t, err, "Failed to create task3")
+		shared.AssertNoError(t, err, "Failed to create task3")
 
 		workTasks, err := repo.GetByContext(ctx, "work")
 		if err != nil {
···
 		blocker := CreateSampleTask()
 		blocker.Description = "Blocker task"
 		_, err := repo.Create(ctx, blocker)
-		AssertNoError(t, err, "create blocker should succeed")
+		shared.AssertNoError(t, err, "create blocker should succeed")
 
 		blocked1 := CreateSampleTask()
 		blocked1.Description = "Blocked task 1"
 		blocked1.DependsOn = []string{blocker.UUID}
 		_, err = repo.Create(ctx, blocked1)
-		AssertNoError(t, err, "create blocked1 should succeed")
+		shared.AssertNoError(t, err, "create blocked1 should succeed")
 
 		blocked2 := CreateSampleTask()
 		blocked2.Description = "Blocked task 2"
 		blocked2.DependsOn = []string{blocker.UUID}
 		_, err = repo.Create(ctx, blocked2)
-		AssertNoError(t, err, "create blocked2 should succeed")
+		shared.AssertNoError(t, err, "create blocked2 should succeed")
 
 		independent := CreateSampleTask()
 		independent.Description = "Independent task"
 		_, err = repo.Create(ctx, independent)
-		AssertNoError(t, err, "create independent should succeed")
+		shared.AssertNoError(t, err, "create independent should succeed")
 
 		blockedTasks, err := repo.GetBlockedTasks(ctx, blocker.UUID)
-		AssertNoError(t, err, "GetBlockedTasks should succeed")
-		AssertEqual(t, 2, len(blockedTasks), "should find 2 blocked tasks")
+		shared.AssertNoError(t, err, "GetBlockedTasks should succeed")
+		shared.AssertEqual(t, 2, len(blockedTasks), "should find 2 blocked tasks")
 
 		for _, task := range blockedTasks {
-			AssertTrue(t, slices.Contains(task.DependsOn, blocker.UUID), "task should depend on blocker")
+			shared.AssertTrue(t, slices.Contains(task.DependsOn, blocker.UUID), "task should depend on blocker")
 		}
 
 		emptyBlocked, err := repo.GetBlockedTasks(ctx, independent.UUID)
-		AssertNoError(t, err, "GetBlockedTasks for independent should succeed")
-		AssertEqual(t, 0, len(emptyBlocked), "independent task should not block anything")
+		shared.AssertNoError(t, err, "GetBlockedTasks for independent should succeed")
+		shared.AssertEqual(t, 0, len(emptyBlocked), "independent task should not block anything")
 	})
 }

internal/repo/test_utilities.go

···
 	"github.com/jaswdr/faker/v2"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
···
 	return articles
 }
 
-func AssertNoError(t *testing.T, err error, msg string) {
-	t.Helper()
-	if err != nil {
-		t.Fatalf("%s: %v", msg, err)
-	}
-}
-
-func AssertError(t *testing.T, err error, msg string) {
-	t.Helper()
-	if err == nil {
-		t.Fatalf("%s: expected error but got none", msg)
-	}
-}
-
 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 {
-		t.Fatalf("%s: expected %v, got %v", msg, expected, actual)
-	}
-}
-
-func AssertNotEqual[T comparable](t *testing.T, notExpected, actual T, msg string) {
-	t.Helper()
-	if notExpected == actual {
-		t.Fatalf("%s: expected value to not equal %v", msg, notExpected)
-	}
-}
-
-func AssertTrue(t *testing.T, condition bool, msg string) {
-	t.Helper()
-	if !condition {
-		t.Fatalf("%s: expected true", msg)
-	}
-}
-
-func AssertFalse(t *testing.T, condition bool, msg string) {
-	t.Helper()
-	if condition {
-		t.Fatalf("%s: expected false", msg)
-	}
-}
-
-func AssertContains(t *testing.T, str, substr, msg string) {
-	t.Helper()
-	if !strings.Contains(str, substr) {
-		t.Fatalf("%s: expected string '%s' to contain '%s'", msg, str, substr)
-	}
-}
-
-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 any, msg string) {
-	t.Helper()
-	if value == nil {
-		t.Fatalf("%s: expected non-nil value", msg)
-	}
-}
-
-func AssertGreaterThan[T interface{ int | int64 | float64 }](t *testing.T, actual, threshold T, msg string) {
-	t.Helper()
-	if actual <= threshold {
-		t.Fatalf("%s: expected %v > %v", msg, actual, threshold)
-	}
-}
-
-func AssertLessThan[T interface{ int | int64 | float64 }](t *testing.T, actual, threshold T, msg string) {
-	t.Helper()
-	if actual >= threshold {
-		t.Fatalf("%s: expected %v < %v", msg, actual, threshold)
-	}
+	shared.AssertError(t, err, "Expected error with cancelled context")
 }
 
 // NewCanceledContext returns a pre-canceled context for testing error conditions
···
 	task2.Priority = "low"
 
 	id1, err := repos.Tasks.Create(ctx, task1)
-	AssertNoError(t, err, "Failed to create sample task 1")
+	shared.AssertNoError(t, err, "Failed to create sample task 1")
 	task1.ID = id1
 
 	id2, err := repos.Tasks.Create(ctx, task2)
-	AssertNoError(t, err, "Failed to create sample task 2")
+	shared.AssertNoError(t, err, "Failed to create sample task 2")
 	task2.ID = id2
 
 	book1 := CreateSampleBook()
···
 	book2.Status = "finished"
 
 	bookID1, err := repos.Books.Create(ctx, book1)
-	AssertNoError(t, err, "Failed to create sample book 1")
+	shared.AssertNoError(t, err, "Failed to create sample book 1")
 	book1.ID = bookID1
 
 	bookID2, err := repos.Books.Create(ctx, book2)
-	AssertNoError(t, err, "Failed to create sample book 2")
+	shared.AssertNoError(t, err, "Failed to create sample book 2")
 	book2.ID = bookID2
 
 	movie1 := CreateSampleMovie()
···
 	movie2.Status = "watched"
 
 	movieID1, err := repos.Movies.Create(ctx, movie1)
-	AssertNoError(t, err, "Failed to create sample movie 1")
+	shared.AssertNoError(t, err, "Failed to create sample movie 1")
 	movie1.ID = movieID1
 
 	movieID2, err := repos.Movies.Create(ctx, movie2)
-	AssertNoError(t, err, "Failed to create sample movie 2")
+	shared.AssertNoError(t, err, "Failed to create sample movie 2")
 	movie2.ID = movieID2
 
 	tv1 := CreateSampleTVShow()
···
 	tv2.Status = "watching"
 
 	tvID1, err := repos.TV.Create(ctx, tv1)
-	AssertNoError(t, err, "Failed to create sample TV show 1")
+	shared.AssertNoError(t, err, "Failed to create sample TV show 1")
 	tv1.ID = tvID1
 
 	tvID2, err := repos.TV.Create(ctx, tv2)
-	AssertNoError(t, err, "Failed to create sample TV show 2")
+	shared.AssertNoError(t, err, "Failed to create sample TV show 2")
 	tv2.ID = tvID2
 
 	note1 := CreateSampleNote()
···
 	note2.Archived = true
 
 	noteID1, err := repos.Notes.Create(ctx, note1)
-	AssertNoError(t, err, "Failed to create sample note 1")
+	shared.AssertNoError(t, err, "Failed to create sample note 1")
 	note1.ID = noteID1
 
 	noteID2, err := repos.Notes.Create(ctx, note2)
-	AssertNoError(t, err, "Failed to create sample note 2")
+	shared.AssertNoError(t, err, "Failed to create sample note 2")
 	note2.ID = noteID2
 
 	return repos

internal/repo/time_entry_repository_test.go

···
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func createTestTask(t *testing.T, db *sql.DB) *models.Task {
···
 	}
 
 	id, err := taskRepo.Create(ctx, task)
-	AssertNoError(t, err, "Failed to create test task")
+	shared.AssertNoError(t, err, "Failed to create test task")
 	task.ID = id
 	return task
 }
···
 			description := "Working on feature"
 			entry, err := repo.Start(ctx, task.ID, description)
 
-			AssertNoError(t, err, "Failed to start time tracking")
-			AssertNotEqual(t, int64(0), entry.ID, "Expected non-zero entry ID")
-			AssertEqual(t, task.ID, entry.TaskID, "Expected TaskID to match")
-			AssertEqual(t, description, entry.Description, "Expected description to match")
-			AssertTrue(t, entry.EndTime == nil, "Expected EndTime to be nil for active entry")
-			AssertTrue(t, entry.IsActive(), "Expected entry to be active")
+			shared.AssertNoError(t, err, "Failed to start time tracking")
+			shared.AssertNotEqual(t, int64(0), entry.ID, "Expected non-zero entry ID")
+			shared.AssertEqual(t, task.ID, entry.TaskID, "Expected TaskID to match")
+			shared.AssertEqual(t, description, entry.Description, "Expected description to match")
+			shared.AssertTrue(t, entry.EndTime == nil, "Expected EndTime to be nil for active entry")
+			shared.AssertTrue(t, entry.IsActive(), "Expected entry to be active")
 		})
 
 		t.Run("Prevent starting already active task", func(t *testing.T) {
 			_, err := repo.Start(ctx, task.ID, "Another attempt")
 
-			AssertError(t, err, "Expected error when starting already active task")
-			AssertContains(t, err.Error(), "task already has an active time entry", "Expected specific error message")
+			shared.AssertError(t, err, "Expected error when starting already active task")
+			shared.AssertContains(t, err.Error(), "task already has an active time entry", "Expected specific error message")
 		})
 
 		t.Run("Stop active time entry", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			entry, err := repo.Start(ctx, task.ID, "Test work")
-			AssertNoError(t, err, "Failed to start time tracking")
+			shared.AssertNoError(t, err, "Failed to start time tracking")
 
 			time.Sleep(1010 * time.Millisecond)
 
 			stoppedEntry, err := repo.Stop(ctx, entry.ID)
-			AssertNoError(t, err, "Failed to stop time tracking")
-			AssertTrue(t, stoppedEntry.EndTime != nil, "Expected EndTime to be set")
-			AssertGreaterThan(t, stoppedEntry.DurationSeconds, int64(0), "Expected duration > 0")
-			AssertFalse(t, stoppedEntry.IsActive(), "Expected entry to not be active after stopping")
+			shared.AssertNoError(t, err, "Failed to stop time tracking")
+			shared.AssertTrue(t, stoppedEntry.EndTime != nil, "Expected EndTime to be set")
+			shared.AssertGreaterThan(t, stoppedEntry.DurationSeconds, int64(0), "Expected duration > 0")
+			shared.AssertFalse(t, stoppedEntry.IsActive(), "Expected entry to not be active after stopping")
 		})
 
 		t.Run("Fail to stop already stopped entry", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			entry, err := repo.Start(ctx, task.ID, "Test work")
-			AssertNoError(t, err, "Failed to start time tracking")
+			shared.AssertNoError(t, err, "Failed to start time tracking")
 
 			time.Sleep(1010 * time.Millisecond)
 			_, err = repo.Stop(ctx, entry.ID)
-			AssertNoError(t, err, "Failed to stop time tracking")
+			shared.AssertNoError(t, err, "Failed to stop time tracking")
 
 			_, err = repo.Stop(ctx, entry.ID)
-			AssertError(t, err, "Expected error when stopping already stopped entry")
-			AssertContains(t, err.Error(), "time entry is not active", "Expected specific error message")
+			shared.AssertError(t, err, "Expected error when stopping already stopped entry")
+			shared.AssertContains(t, err.Error(), "time entry is not active", "Expected specific error message")
 		})
 
 		t.Run("Get time entry", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			original, err := repo.Start(ctx, task.ID, "Test entry")
-			AssertNoError(t, err, "Failed to start time tracking")
+			shared.AssertNoError(t, err, "Failed to start time tracking")
 
 			retrieved, err := repo.Get(ctx, original.ID)
-			AssertNoError(t, err, "Failed to get time entry")
-			AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
-			AssertEqual(t, original.TaskID, retrieved.TaskID, "TaskID mismatch")
-			AssertEqual(t, original.Description, retrieved.Description, "Description mismatch")
+			shared.AssertNoError(t, err, "Failed to get time entry")
+			shared.AssertEqual(t, original.ID, retrieved.ID, "ID mismatch")
+			shared.AssertEqual(t, original.TaskID, retrieved.TaskID, "TaskID mismatch")
+			shared.AssertEqual(t, original.Description, retrieved.Description, "Description mismatch")
 		})
 
 		t.Run("Delete time entry", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			entry, err := repo.Start(ctx, task.ID, "To be deleted")
-			AssertNoError(t, err, "Failed to create entry")
+			shared.AssertNoError(t, err, "Failed to create entry")
 
 			err = repo.Delete(ctx, entry.ID)
-			AssertNoError(t, err, "Failed to delete entry")
+			shared.AssertNoError(t, err, "Failed to delete entry")
 
 			_, err = repo.Get(ctx, entry.ID)
-			AssertError(t, err, "Expected error when getting deleted entry")
-			AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
+			shared.AssertError(t, err, "Expected error when getting deleted entry")
+			shared.AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
 		})
 	})
 
···
 
 		t.Run("GetActiveByTaskID returns error when no active entry", func(t *testing.T) {
 			_, err := repo.GetActiveByTaskID(ctx, task.ID)
-			AssertError(t, err, "Expected error when no active entry exists")
-			AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
+			shared.AssertError(t, err, "Expected error when no active entry exists")
+			shared.AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
 		})
 
 		t.Run("GetActiveByTaskID returns active entry", func(t *testing.T) {
 			startedEntry, err := repo.Start(ctx, task.ID, "Test work")
-			AssertNoError(t, err, "Failed to start time tracking")
+			shared.AssertNoError(t, err, "Failed to start time tracking")
 
 			activeEntry, err := repo.GetActiveByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Failed to get active entry")
-			AssertEqual(t, startedEntry.ID, activeEntry.ID, "Expected entry IDs to match")
-			AssertTrue(t, activeEntry.IsActive(), "Expected entry to be active")
+			shared.AssertNoError(t, err, "Failed to get active entry")
+			shared.AssertEqual(t, startedEntry.ID, activeEntry.ID, "Expected entry IDs to match")
+			shared.AssertTrue(t, activeEntry.IsActive(), "Expected entry to be active")
 		})
 
 		t.Run("StopActiveByTaskID stops active entry", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			_, err := repo.Start(ctx, task.ID, "Test work")
-			AssertNoError(t, err, "Failed to start time tracking")
+			shared.AssertNoError(t, err, "Failed to start time tracking")
 
 			stoppedEntry, err := repo.StopActiveByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Failed to stop time tracking by task ID")
-			AssertTrue(t, stoppedEntry.EndTime != nil, "Expected EndTime to be set")
-			AssertFalse(t, stoppedEntry.IsActive(), "Expected entry to not be active")
+			shared.AssertNoError(t, err, "Failed to stop time tracking by task ID")
+			shared.AssertTrue(t, stoppedEntry.EndTime != nil, "Expected EndTime to be set")
+			shared.AssertFalse(t, stoppedEntry.IsActive(), "Expected entry to not be active")
 		})
 
 		t.Run("StopActiveByTaskID fails when no active entry", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			_, err := repo.StopActiveByTaskID(ctx, task.ID)
-			AssertError(t, err, "Expected error when no active entry exists")
-			AssertContains(t, err.Error(), "no active time entry found for task", "Expected specific error message")
+			shared.AssertError(t, err, "Expected error when no active entry exists")
+			shared.AssertContains(t, err.Error(), "no active time entry found for task", "Expected specific error message")
 		})
 
 		t.Run("GetByTaskID returns empty when no entries", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			entries, err := repo.GetByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Failed to get entries")
-			AssertEqual(t, 0, len(entries), "Expected 0 entries")
+			shared.AssertNoError(t, err, "Failed to get entries")
+			shared.AssertEqual(t, 0, len(entries), "Expected 0 entries")
 		})
 
 		t.Run("GetByTaskID returns all entries for task", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			_, err := repo.Start(ctx, task.ID, "First session")
-			AssertNoError(t, err, "Failed to start first session")
+			shared.AssertNoError(t, err, "Failed to start first session")
 
 			_, err = repo.StopActiveByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Failed to stop first session")
+			shared.AssertNoError(t, err, "Failed to stop first session")
 
 			_, err = repo.Start(ctx, task.ID, "Second session")
-			AssertNoError(t, err, "Failed to start second session")
+			shared.AssertNoError(t, err, "Failed to start second session")
 
 			entries, err := repo.GetByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Failed to get entries")
-			AssertEqual(t, 2, len(entries), "Expected 2 entries")
-			AssertEqual(t, "Second session", entries[0].Description, "Expected newest entry first")
-			AssertEqual(t, "First session", entries[1].Description, "Expected oldest entry second")
+			shared.AssertNoError(t, err, "Failed to get entries")
+			shared.AssertEqual(t, 2, len(entries), "Expected 2 entries")
+			shared.AssertEqual(t, "Second session", entries[0].Description, "Expected newest entry first")
+			shared.AssertEqual(t, "First session", entries[1].Description, "Expected oldest entry second")
 		})
 
 		t.Run("GetTotalTimeByTaskID returns zero when no entries", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			duration, err := repo.GetTotalTimeByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Failed to get total time")
-			AssertEqual(t, time.Duration(0), duration, "Expected 0 duration")
+			shared.AssertNoError(t, err, "Failed to get total time")
+			shared.AssertEqual(t, time.Duration(0), duration, "Expected 0 duration")
 		})
 
 		t.Run("GetTotalTimeByTaskID calculates total including active entries", func(t *testing.T) {
···
 			task := createTestTask(t, db)
 
 			entry1, err := repo.Start(ctx, task.ID, "Completed work")
-			AssertNoError(t, err, "Failed to start first entry")
+			shared.AssertNoError(t, err, "Failed to start first entry")
 
 			time.Sleep(1010 * time.Millisecond)
 			_, err = repo.Stop(ctx, entry1.ID)
-			AssertNoError(t, err, "Failed to stop first entry")
+			shared.AssertNoError(t, err, "Failed to stop first entry")
 
 			_, err = repo.Start(ctx, task.ID, "Active work")
-			AssertNoError(t, err, "Failed to start second entry")
+			shared.AssertNoError(t, err, "Failed to start second entry")
 
 			time.Sleep(1010 * time.Millisecond)
 
 			totalTime, err := repo.GetTotalTimeByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Failed to get total time")
-			AssertTrue(t, totalTime > 0, "Expected total time > 0")
-			AssertTrue(t, totalTime >= 2*time.Second, "Expected total time >= 2s")
+			shared.AssertNoError(t, err, "Failed to get total time")
+			shared.AssertTrue(t, totalTime > 0, "Expected total time > 0")
+			shared.AssertTrue(t, totalTime >= 2*time.Second, "Expected total time >= 2s")
 		})
 	})
 
···
 			end := time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC)
 
 			entries, err := repo.GetByDateRange(ctx, start, end)
-			AssertNoError(t, err, "Failed to get entries by date range")
-			AssertEqual(t, 0, len(entries), "Expected 0 entries")
+			shared.AssertNoError(t, err, "Failed to get entries by date range")
+			shared.AssertEqual(t, 0, len(entries), "Expected 0 entries")
 		})
 
 		t.Run("Returns entries within date range", func(t *testing.T) {
 			task := createTestTask(t, db)
 
 			entry, err := repo.Start(ctx, task.ID, "Test entry")
-			AssertNoError(t, err, "Failed to start entry")
+			shared.AssertNoError(t, err, "Failed to start entry")
 
 			_, err = repo.Stop(ctx, entry.ID)
-			AssertNoError(t, err, "Failed to stop entry")
+			shared.AssertNoError(t, err, "Failed to stop entry")
 
 			now := time.Now()
 			start := now.Add(-time.Hour)
 			end := now.Add(time.Hour)
 
 			entries, err := repo.GetByDateRange(ctx, start, end)
-			AssertNoError(t, err, "Failed to get entries by date range")
+			shared.AssertNoError(t, err, "Failed to get entries by date range")
 
 			found := false
 			for _, e := range entries {
···
 					break
 				}
 			}
-			AssertTrue(t, found, "Expected to find 'Test entry' in results")
+			shared.AssertTrue(t, found, "Expected to find 'Test entry' in results")
 		})
 
 		t.Run("Respects date range boundaries", func(t *testing.T) {
 			task := createTestTask(t, db)
 
 			entry, err := repo.Start(ctx, task.ID, "Boundary test")
-			AssertNoError(t, err, "Failed to start entry")
+			shared.AssertNoError(t, err, "Failed to start entry")
 
 			_, err = repo.Stop(ctx, entry.ID)
-			AssertNoError(t, err, "Failed to stop entry")
+			shared.AssertNoError(t, err, "Failed to stop entry")
 
 			start := time.Now().Add(time.Hour)
 			end := time.Now().Add(2 * time.Hour)
 
 			entries, err := repo.GetByDateRange(ctx, start, end)
-			AssertNoError(t, err, "Failed to get entries by date range")
+			shared.AssertNoError(t, err, "Failed to get entries by date range")
 
 			for _, e := range entries {
 				if e.Description == "Boundary test" {
···
 			end := time.Now().AddDate(0, 0, -1)
 
 			entries, err := repo.GetByDateRange(ctx, start, end)
-			AssertNoError(t, err, "Should not error with invalid date range")
-			AssertEqual(t, 0, len(entries), "Expected 0 entries with invalid range")
+			shared.AssertNoError(t, err, "Should not error with invalid date range")
+			shared.AssertEqual(t, 0, len(entries), "Expected 0 entries with invalid range")
 		})
 	})
 
···
 		task := createTestTask(t, db)
 
 		entry, err := repo.Start(ctx, task.ID, "Test entry")
-		AssertNoError(t, err, "Failed to create entry")
+		shared.AssertNoError(t, err, "Failed to create entry")
 
 		t.Run("Start with cancelled context", func(t *testing.T) {
 			db := CreateTestDB(t)
···
 
 		t.Run("Get non-existent entry", func(t *testing.T) {
 			_, err := repo.Get(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent entry")
-			AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
+			shared.AssertError(t, err, "Expected error for non-existent entry")
+			shared.AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
 		})
 
 		t.Run("Stop non-existent entry", func(t *testing.T) {
 			_, err := repo.Stop(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent entry")
+			shared.AssertError(t, err, "Expected error for non-existent entry")
 		})
 
 		t.Run("Delete non-existent entry", func(t *testing.T) {
 			err := repo.Delete(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent entry")
-			AssertContains(t, err.Error(), "time entry not found", "Expected specific error message")
+			shared.AssertError(t, err, "Expected error for non-existent entry")
+			shared.AssertContains(t, err.Error(), "time entry not found", "Expected specific error message")
 		})
 
 		t.Run("Start with non-existent task", func(t *testing.T) {
 			_, err := repo.Start(ctx, 99999, "Test")
-			AssertError(t, err, "Expected error for non-existent task")
+			shared.AssertError(t, err, "Expected error for non-existent task")
 		})
 
 		t.Run("GetActiveByTaskID with no results", func(t *testing.T) {
 			task := createTestTask(t, db)
 			_, err := repo.GetActiveByTaskID(ctx, task.ID)
-			AssertError(t, err, "Expected error when no active entry")
-			AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
+			shared.AssertError(t, err, "Expected error when no active entry")
+			shared.AssertEqual(t, sql.ErrNoRows, err, "Expected sql.ErrNoRows")
 		})
 
 		t.Run("GetByTaskID with no results", func(t *testing.T) {
 			task := createTestTask(t, db)
 			entries, err := repo.GetByTaskID(ctx, task.ID)
-			AssertNoError(t, err, "Should not error when no entries found")
-			AssertEqual(t, 0, len(entries), "Expected empty result set")
+			shared.AssertNoError(t, err, "Should not error when no entries found")
+			shared.AssertEqual(t, 0, len(entries), "Expected empty result set")
 		})
 	})
 }

internal/repo/tv_repository_test.go

···
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestTVRepository(t *testing.T) {
···
 
 		tvShow := NewTVShowBuilder().WithTitle("Test Show").WithSeason(1).WithEpisode(1).Build()
 		id, err := repo.Create(ctx, tvShow)
-		AssertNoError(t, err, "Failed to create TV show")
+		shared.AssertNoError(t, err, "Failed to create TV show")
 
 		t.Run("Create with cancelled context", func(t *testing.T) {
 			newShow := NewTVShowBuilder().WithTitle("Cancelled").Build()
···
 
 		t.Run("Get non-existent TV show", func(t *testing.T) {
 			_, err := repo.Get(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent TV show")
+			shared.AssertError(t, err, "Expected error for non-existent TV show")
 		})
 
 		t.Run("Update non-existent TV show succeeds with no rows affected", func(t *testing.T) {
 			show := NewTVShowBuilder().WithTitle("Non-existent").Build()
 			show.ID = 99999
 			err := repo.Update(ctx, show)
-			AssertNoError(t, err, "Update should not error when no rows affected")
+			shared.AssertNoError(t, err, "Update should not error when no rows affected")
 		})
 
 		t.Run("Delete non-existent TV show succeeds with no rows affected", func(t *testing.T) {
 			err := repo.Delete(ctx, 99999)
-			AssertNoError(t, err, "Delete should not error when no rows affected")
+			shared.AssertNoError(t, err, "Delete should not error when no rows affected")
 		})
 
 		t.Run("MarkWatched non-existent TV show", func(t *testing.T) {
 			err := repo.MarkWatched(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent TV show")
+			shared.AssertError(t, err, "Expected error for non-existent TV show")
 		})
 
 		t.Run("StartWatching non-existent TV show", func(t *testing.T) {
 			err := repo.StartWatching(ctx, 99999)
-			AssertError(t, err, "Expected error for non-existent TV show")
+			shared.AssertError(t, err, "Expected error for non-existent TV show")
 		})
 
 		t.Run("GetByTitle with no results", func(t *testing.T) {
 			shows, err := repo.GetByTitle(ctx, "NonExistentShow")
-			AssertNoError(t, err, "Should not error when no shows found")
-			AssertEqual(t, 0, len(shows), "Expected empty result set")
+			shared.AssertNoError(t, err, "Should not error when no shows found")
+			shared.AssertEqual(t, 0, len(shows), "Expected empty result set")
 		})
 
 		t.Run("GetBySeason with no results", func(t *testing.T) {
 			shows, err := repo.GetBySeason(ctx, "NonExistentShow", 1)
-			AssertNoError(t, err, "Should not error when no shows found")
-			AssertEqual(t, 0, len(shows), "Expected empty result set")
+			shared.AssertNoError(t, err, "Should not error when no shows found")
+			shared.AssertEqual(t, 0, len(shows), "Expected empty result set")
 		})
 	})
 }

internal/services/http_test.go

···
 		ParseSearch = origSearch
 	}()
 
-	tests := []struct {
+	tc := []struct {
 		name      string
 		setup     func()
 		call      func() error
···
 		},
 	}
 
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
+	for _, tt := range tc {
+		t.Run(tt.name, func(t *testing.T) {
 			FetchHTML = origFetch
 			ExtractMovieMetadata = origMovie
 			ExtractTVSeriesMetadata = origTV
 			ExtractTVSeasonMetadata = origSeason
 			ParseSearch = origSearch
 
-			tc.setup()
-			err := tc.call()
-			if tc.expectErr && err == nil {
+			tt.setup()
+			err := tt.call()
+			if tt.expectErr && err == nil {
 				t.Fatalf("expected error, got nil")
 			}
-			if !tc.expectErr && err != nil {
+			if !tt.expectErr && err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
 		})

internal/shared/shared.go

···
+// package shared contains constants used across the codebase
+package shared
+
+import (
+	"errors"
+	"fmt"
+)
+
+var (
+	ErrConfig error = fmt.Errorf("configuration error")
+)
+
+func ConfigError(m string, err error) error {
+	return errors.Join(ErrConfig, fmt.Errorf("%s: %w", m, err))
+}
+
+func IsConfigError(err error) bool {
+	return errors.Is(err, ErrConfig)
+}

internal/shared/shared_test.go

···
+package shared
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestErrors(t *testing.T) {
+	t.Run("ConfigError", func(t *testing.T) {
+		t.Run("creates joined error with message", func(t *testing.T) {
+			baseErr := errors.New("invalid format")
+			err := ConfigError("database connection failed", baseErr)
+
+			AssertError(t, err, "ConfigError should create an error")
+			AssertContains(t, err.Error(), "configuration error", "error should contain config error marker")
+			AssertContains(t, err.Error(), "database connection failed", "error should contain custom message")
+			AssertContains(t, err.Error(), "invalid format", "error should contain base error")
+		})
+
+		t.Run("preserves both error chains", func(t *testing.T) {
+			baseErr := errors.New("connection timeout")
+			err := ConfigError("failed to connect", baseErr)
+
+			AssertTrue(t, errors.Is(err, ErrConfig), "should identify as config error")
+			AssertTrue(t, errors.Is(err, baseErr), "should preserve original error in chain")
+		})
+
+		t.Run("wraps multiple errors with Join", func(t *testing.T) {
+			baseErr := errors.New("parse error")
+			err := ConfigError("invalid config file", baseErr)
+
+			AssertTrue(t, errors.Is(err, ErrConfig), "joined error should contain ErrConfig")
+			AssertTrue(t, errors.Is(err, baseErr), "joined error should contain base error")
+		})
+	})
+
+	t.Run("IsConfigError", func(t *testing.T) {
+		t.Run("identifies config errors", func(t *testing.T) {
+			baseErr := errors.New("test error")
+			err := ConfigError("test message", baseErr)
+
+			AssertTrue(t, IsConfigError(err), "should identify config error")
+		})
+
+		t.Run("returns false for regular errors", func(t *testing.T) {
+			err := errors.New("regular error")
+
+			AssertFalse(t, IsConfigError(err), "should not identify regular error as config error")
+		})
+
+		t.Run("returns false for nil error", func(t *testing.T) {
+			AssertFalse(t, IsConfigError(nil), "should return false for nil error")
+		})
+
+		t.Run("returns false for wrapped non-config errors", func(t *testing.T) {
+			baseErr := errors.New("base error")
+			wrappedErr := errors.New("wrapped: " + baseErr.Error())
+
+			AssertFalse(t, IsConfigError(wrappedErr), "should not identify wrapped non-config error")
+		})
+
+		t.Run("identifies wrapped config errors", func(t *testing.T) {
+			baseErr := errors.New("original error")
+			configErr := ConfigError("config issue", baseErr)
+			wrappedAgain := errors.Join(errors.New("outer error"), configErr)
+
+			AssertTrue(t, IsConfigError(wrappedAgain), "should identify config error in join chain")
+		})
+	})
+}

internal/shared/test_utilities.go

···
+// shared test utilities & helpers
+package shared
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+func CreateTempDir(p string, t *testing.T) (string, func()) {
+	t.Helper()
+	tempDir, err := os.MkdirTemp("", p)
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	return tempDir, func() { os.RemoveAll(tempDir) }
+}
+
+func AssertNoError(t *testing.T, err error, msg string) {
+	t.Helper()
+	if err != nil {
+		t.Fatalf("%s: %v", msg, err)
+	}
+}
+
+func AssertError(t *testing.T, err error, msg string) {
+	t.Helper()
+	if err == nil {
+		t.Fatalf("%s: expected error but got none", msg)
+	}
+}
+
+// AssertErrorContains checks that an error occurred and optionally contains expected text
+func AssertErrorContains(t *testing.T, err error, expected, msg string) {
+	t.Helper()
+	if err == nil {
+		t.Errorf("%s: expected error but got none", msg)
+		return
+	}
+	if expected != "" && !ContainsString(err.Error(), expected) {
+		t.Errorf("%s: expected error containing %q, got: %v", msg, expected, err)
+	}
+}
+
+func AssertTrue(t *testing.T, condition bool, msg string) {
+	t.Helper()
+	if !condition {
+		t.Fatalf("%s: expected true", msg)
+	}
+}
+
+func AssertFalse(t *testing.T, condition bool, msg string) {
+	t.Helper()
+	if condition {
+		t.Fatalf("%s: expected false", msg)
+	}
+}
+
+func AssertContains(t *testing.T, str, substr, msg string) {
+	t.Helper()
+	if !strings.Contains(str, substr) {
+		t.Fatalf("%s: expected string '%s' to contain '%s'", msg, str, substr)
+	}
+}
+
+func AssertEqual[T comparable](t *testing.T, expected, actual T, msg string) {
+	t.Helper()
+	if expected != actual {
+		t.Fatalf("%s: expected %v, got %v", msg, expected, actual)
+	}
+}
+
+func AssertNotEqual[T comparable](t *testing.T, not, actual T, msg string) {
+	t.Helper()
+	if not == actual {
+		t.Fatalf("%s: expected value to not equal %v", msg, not)
+	}
+}
+
+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 any, msg string) {
+	t.Helper()
+	if value == nil {
+		t.Fatalf("%s: expected non-nil value", msg)
+	}
+}
+
+func AssertGreaterThan[T interface{ int | int64 | float64 }](t *testing.T, actual, threshold T, msg string) {
+	t.Helper()
+	if actual <= threshold {
+		t.Fatalf("%s: expected %v > %v", msg, actual, threshold)
+	}
+}
+
+func AssertLessThan[T interface{ int | int64 | float64 }](t *testing.T, actual, threshold T, msg string) {
+	t.Helper()
+	if actual >= threshold {
+		t.Fatalf("%s: expected %v < %v", msg, actual, threshold)
+	}
+}
+
+// Helper function to check if string contains substring (case-insensitive)
+func ContainsString(haystack, needle string) bool {
+	if needle == "" {
+		return true
+	}
+	return len(haystack) >= len(needle) &&
+		haystack[len(haystack)-len(needle):] == needle ||
+		haystack[:len(needle)] == needle ||
+		(len(haystack) > len(needle) &&
+			func() bool {
+				for i := 1; i <= len(haystack)-len(needle); i++ {
+					if haystack[i:i+len(needle)] == needle {
+						return true
+					}
+				}
+				return false
+			}())
+}
+
+// HTTPMockServer provides utilities for mocking HTTP services in tests
+type HTTPMockServer struct {
+	server   *httptest.Server
+	requests []*http.Request
+}
+
+// NewMockServer creates a new mock HTTP server
+func NewMockServer() *HTTPMockServer {
+	mock := &HTTPMockServer{
+		requests: make([]*http.Request, 0),
+	}
+	return mock
+}
+
+// WithHandler sets up the mock server with a custom handler
+func (m *HTTPMockServer) WithHandler(handler http.HandlerFunc) *HTTPMockServer {
+	m.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		m.requests = append(m.requests, r)
+		handler(w, r)
+	}))
+	return m
+}
+
+// URL returns the mock server URL
+func (m *HTTPMockServer) URL() string {
+	if m.server == nil {
+		panic("mock server not initialized - call WithHandler first")
+	}
+	return m.server.URL
+}
+
+// Close closes the mock server
+func (m *HTTPMockServer) Close() {
+	if m.server != nil {
+		m.server.Close()
+	}
+}
+
+// GetRequests returns all recorded HTTP requests
+func (m *HTTPMockServer) GetRequests() []*http.Request {
+	return m.requests
+}
+
+// GetLastRequest returns the last recorded HTTP request
+func (m *HTTPMockServer) GetLastRequest() *http.Request {
+	if len(m.requests) == 0 {
+		return nil
+	}
+	return m.requests[len(m.requests)-1]
+}
+
+func (m HTTPMockServer) Requests() []*http.Request {
+	return m.requests
+}
+
+// HTTPErrorMockServer creates a mock server that returns HTTP errors
+func HTTPErrorMockServer(statusCode int, message string) *HTTPMockServer {
+	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, message, statusCode)
+	})
+}
+
+// JSONMockServer creates a mock server that returns JSON responses
+func JSONMockServer(response any) *HTTPMockServer {
+	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		if err := json.NewEncoder(w).Encode(response); err != nil {
+			http.Error(w, "Failed to encode response", http.StatusInternalServerError)
+		}
+	})
+}
+
+// TimeoutMockServer creates a mock server that simulates timeouts
+func TimeoutMockServer(delay time.Duration) *HTTPMockServer {
+	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
+		time.Sleep(delay)
+		w.WriteHeader(http.StatusOK)
+	})
+}
+
+// InvalidJSONMockServer creates a mock server that returns malformed JSON
+func InvalidJSONMockServer() *HTTPMockServer {
+	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.Write([]byte(`{"invalid": json`))
+	})
+}
+
+// EmptyResponseMockServer creates a mock server that returns empty responses
+func EmptyResponseMockServer() *HTTPMockServer {
+	return NewMockServer().WithHandler(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+}
+
+// AssertRequestMade verifies that a request was made to the mock server
+func AssertRequestMade(t *testing.T, server *HTTPMockServer, expected string) {
+	t.Helper()
+	if len(server.requests) == 0 {
+		t.Error("Expected HTTP request to be made but none were recorded")
+		return
+	}
+
+	lastReq := server.GetLastRequest()
+	if lastReq.URL.Path != expected {
+		t.Errorf("Expected request to path %s, got %s", expected, lastReq.URL.Path)
+	}
+}

internal/store/config.go

···
 package store
 
 import (
-	"fmt"
 	"os"
 	"path/filepath"
 
 	"github.com/BurntSushi/toml"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 // Config holds application configuration
···
 	} else {
 		configDir, err := GetConfigDir()
 		if err != nil {
-			return nil, fmt.Errorf("failed to get config directory: %w", err)
+			return nil, shared.ConfigError("failed to get config directory", err)
 		}
 		configPath = filepath.Join(configDir, ".noteleaf.conf.toml")
 	}
···
 	if _, err := os.Stat(configPath); os.IsNotExist(err) {
 		config := DefaultConfig()
 		if err := SaveConfig(config); err != nil {
-			return nil, fmt.Errorf("failed to create default config: %w", err)
+			return nil, shared.ConfigError("failed to create default config", err)
 		}
 		return config, nil
 	}
 
 	data, err := os.ReadFile(configPath)
 	if err != nil {
-		return nil, fmt.Errorf("failed to read config file: %w", err)
+		return nil, shared.ConfigError("failed to read config file", err)
 	}
 
 	config := DefaultConfig()
 	if err := toml.Unmarshal(data, config); err != nil {
-		return nil, fmt.Errorf("failed to parse config file: %w", err)
+		return nil, shared.ConfigError("failed to parse config file", err)
 	}
 
 	return config, nil
···
 func SaveConfig(config *Config) error {
 	var configPath string
 
-	// Check for NOTELEAF_CONFIG environment variable
 	if envConfigPath := os.Getenv("NOTELEAF_CONFIG"); envConfigPath != "" {
 		configPath = envConfigPath
-		// Ensure the directory exists for custom config path
 		configDir := filepath.Dir(configPath)
 		if err := os.MkdirAll(configDir, 0755); err != nil {
-			return fmt.Errorf("failed to create config directory: %w", err)
+			return shared.ConfigError("failed to create config directory", err)
 		}
 	} else {
 		configDir, err := GetConfigDir()
 		if err != nil {
-			return fmt.Errorf("failed to get config directory: %w", err)
+			return shared.ConfigError("failed to get config directory", err)
 		}
 		configPath = filepath.Join(configDir, ".noteleaf.conf.toml")
 	}
 
 	data, err := toml.Marshal(config)
 	if err != nil {
-		return fmt.Errorf("failed to marshal config: %w", err)
+		return shared.ConfigError("failed to marshal config", err)
 	}
 
 	if err := os.WriteFile(configPath, data, 0644); err != nil {
-		return fmt.Errorf("failed to write config file: %w", err)
+		return shared.ConfigError("failed to write config file", err)
 	}
 
 	return nil
···
 
 // GetConfigPath returns the path to the configuration file
 func GetConfigPath() (string, error) {
-	// Check for NOTELEAF_CONFIG environment variable
 	if envConfigPath := os.Getenv("NOTELEAF_CONFIG"); envConfigPath != "" {
 		return envConfigPath, nil
 	}

internal/store/config_test.go

···
 	"testing"
 
 	"github.com/BurntSushi/toml"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestDefaultConfig(t *testing.T) {
···
 }
 
 func TestConfigOperations(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-config-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
+	tempDir, cleanup := shared.CreateTempDir("noteleaf-config-test-*", t)
+	defer cleanup()
 
 	originalGetConfigDir := GetConfigDir
 	GetConfigDir = func() (string, error) {
···
 }
 
 func TestConfigPersistence(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", "noteleaf-config-persist-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
+	tempDir, cleanup := shared.CreateTempDir("noteleaf-config-persist-test-*", t)
+	defer cleanup()
 
 	originalGetConfigDir := GetConfigDir
 	GetConfigDir = func() (string, error) {
···
 
 func TestConfigErrorHandling(t *testing.T) {
 	t.Run("LoadConfig handles invalid TOML", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-config-error-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-error-test-*", t)
+		defer cleanup()
 
 		originalGetConfigDir := GetConfigDir
 		GetConfigDir = func() (string, error) {
···
 
 		configPath := filepath.Join(tempDir, ".noteleaf.conf.toml")
 		invalidTOML := `[invalid toml content`
-		err = os.WriteFile(configPath, []byte(invalidTOML), 0644)
-		if err != nil {
+		if err := os.WriteFile(configPath, []byte(invalidTOML), 0644); err != nil {
 			t.Fatalf("Failed to write invalid TOML: %v", err)
 		}
 
-		_, err = LoadConfig()
-		if err == nil {
+		if _, err := LoadConfig(); err == nil {
 			t.Error("LoadConfig should fail with invalid TOML")
 		}
 	})
···
 			t.Skip("Permission test not reliable on Windows")
 		}
 
-		tempDir, err := os.MkdirTemp("", "noteleaf-config-perm-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-perm-test-*", t)
+		defer cleanup()
 
 		originalGetConfigDir := GetConfigDir
 		GetConfigDir = func() (string, error) {
···
 
 		configPath := filepath.Join(tempDir, ".noteleaf.conf.toml")
 		validTOML := `color_scheme = "dark"`
-		err = os.WriteFile(configPath, []byte(validTOML), 0644)
-		if err != nil {
+		if err := os.WriteFile(configPath, []byte(validTOML), 0644); err != nil {
 			t.Fatalf("Failed to write config file: %v", err)
 		}
 
-		err = os.Chmod(configPath, 0000)
-		if err != nil {
+		if err := os.Chmod(configPath, 0000); err != nil {
 			t.Fatalf("Failed to change file permissions: %v", err)
 		}
 		defer os.Chmod(configPath, 0644)
 
-		_, err = LoadConfig()
-		if err == nil {
+		if _, err := LoadConfig(); err == nil {
 			t.Error("LoadConfig should fail when config file is not readable")
 		}
 	})
···
 	})
 
 	t.Run("LoadConfig handles SaveConfig failure when creating default", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-config-save-fail-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-save-fail-test-*", t)
+		defer cleanup()
 
 		_ = filepath.Join(tempDir, ".noteleaf.conf.toml")
 
···
 		}
 		defer func() { GetConfigDir = originalGetConfigDir }()
 
-		_, err = LoadConfig()
-		if err == nil {
+		if _, err := LoadConfig(); err == nil {
 			t.Error("LoadConfig should fail when SaveConfig fails during default config creation")
 		}
 	})
···
 		defer func() { GetConfigDir = originalGetConfigDir }()
 
 		config := DefaultConfig()
-		err := SaveConfig(config)
-		if err == nil {
+		if err := SaveConfig(config); err == nil {
 			t.Error("SaveConfig should fail when config directory cannot be accessed")
 		}
 	})
···
 			t.Skip("Permission test not reliable on Windows")
 		}
 
-		tempDir, err := os.MkdirTemp("", "noteleaf-config-write-perm-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-config-write-perm-test-*", t)
+		defer cleanup()
 
 		originalGetConfigDir := GetConfigDir
 		GetConfigDir = func() (string, error) {
···
 		}
 		defer func() { GetConfigDir = originalGetConfigDir }()
 
-		err = os.Chmod(tempDir, 0555)
-		if err != nil {
+		if err := os.Chmod(tempDir, 0555); err != nil {
 			t.Fatalf("Failed to change directory permissions: %v", err)
 		}
 		defer os.Chmod(tempDir, 0755)
 
 		config := DefaultConfig()
-		err = SaveConfig(config)
-		if err == nil {
+		if err := SaveConfig(config); err == nil {
 			t.Error("SaveConfig should fail when directory is not writable")
 		}
 	})
···
 	})
 
 	t.Run("creates directory if it doesn't exist", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-test-*", t)
+		defer cleanup()
 
 		var originalEnv string
 		var envVar string
···
 
 func TestEnvironmentVariableOverrides(t *testing.T) {
 	t.Run("NOTELEAF_CONFIG overrides default config path for LoadConfig", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-env-config-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-env-config-test-*", t)
+		defer cleanup()
 
 		customConfigPath := filepath.Join(tempDir, "custom-config.toml")
 		originalEnv := os.Getenv("NOTELEAF_CONFIG")
 		os.Setenv("NOTELEAF_CONFIG", customConfigPath)
 		defer os.Setenv("NOTELEAF_CONFIG", originalEnv)
 
-		// Create a custom config
 		customConfig := DefaultConfig()
 		customConfig.ColorScheme = "custom-env-test"
 		if err := SaveConfig(customConfig); err != nil {
 			t.Fatalf("Failed to save custom config: %v", err)
 		}
 
-		// Load config should use the custom path
 		loadedConfig, err := LoadConfig()
 		if err != nil {
 			t.Fatalf("LoadConfig failed: %v", err)
···
 	})
 
 	t.Run("NOTELEAF_CONFIG overrides default config path for SaveConfig", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-env-save-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-env-save-test-*", t)
+		defer cleanup()
 
 		customConfigPath := filepath.Join(tempDir, "subdir", "config.toml")
 		originalEnv := os.Getenv("NOTELEAF_CONFIG")
···
 			t.Fatalf("SaveConfig failed: %v", err)
 		}
 
-		// Verify the file was created at the custom path
 		if _, err := os.Stat(customConfigPath); os.IsNotExist(err) {
 			t.Error("Config file should be created at custom NOTELEAF_CONFIG path")
 		}
 
-		// Verify the content
 		data, err := os.ReadFile(customConfigPath)
 		if err != nil {
 			t.Fatalf("Failed to read config file: %v", err)
···
 	})
 
 	t.Run("NOTELEAF_CONFIG overrides default config path for GetConfigPath", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-env-path-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-env-path-test-*", t)
+		defer cleanup()
 
 		customConfigPath := filepath.Join(tempDir, "my-config.toml")
 		originalEnv := os.Getenv("NOTELEAF_CONFIG")
···
 	})
 
 	t.Run("NOTELEAF_CONFIG creates parent directories if needed", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-env-mkdir-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-env-mkdir-test-*", t)
+		defer cleanup()
 
 		customConfigPath := filepath.Join(tempDir, "nested", "deep", "config.toml")
 		originalEnv := os.Getenv("NOTELEAF_CONFIG")
···
 
 func TestGetDataDir(t *testing.T) {
 	t.Run("NOTELEAF_DATA_DIR overrides default data directory", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-data-dir-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-data-dir-test-*", t)
+		defer cleanup()
 
 		customDataDir := filepath.Join(tempDir, "my-data")
 		originalEnv := os.Getenv("NOTELEAF_DATA_DIR")
···
 			t.Errorf("Expected data dir '%s', got '%s'", customDataDir, dataDir)
 		}
 
-		// Verify directory was created
 		if _, err := os.Stat(customDataDir); os.IsNotExist(err) {
 			t.Error("Data directory should be created")
 		}
 	})
 
 	t.Run("GetDataDir returns correct directory based on OS", func(t *testing.T) {
-		// Temporarily unset NOTELEAF_DATA_DIR
 		originalEnv := os.Getenv("NOTELEAF_DATA_DIR")
 		os.Unsetenv("NOTELEAF_DATA_DIR")
 		defer os.Setenv("NOTELEAF_DATA_DIR", originalEnv)
···
 	})
 
 	t.Run("GetDataDir handles NOTELEAF_DATA_DIR with nested path", func(t *testing.T) {
-		tempDir, err := os.MkdirTemp("", "noteleaf-nested-data-test-*")
-		if err != nil {
-			t.Fatalf("Failed to create temp directory: %v", err)
-		}
-		defer os.RemoveAll(tempDir)
+		tempDir, cleanup := shared.CreateTempDir("noteleaf-nested-data-test-*", t)
+		defer cleanup()
 
 		customDataDir := filepath.Join(tempDir, "level1", "level2", "data")
 		originalEnv := os.Getenv("NOTELEAF_DATA_DIR")
···
 			t.Errorf("Expected data dir '%s', got '%s'", customDataDir, dataDir)
 		}
 
-		// Verify nested directories were created
 		if _, err := os.Stat(customDataDir); os.IsNotExist(err) {
 			t.Error("Nested data directories should be created")
 		}
 	})
 
 	t.Run("GetDataDir uses platform-specific defaults", func(t *testing.T) {
-		// Temporarily unset NOTELEAF_DATA_DIR
 		originalEnv := os.Getenv("NOTELEAF_DATA_DIR")
 		os.Unsetenv("NOTELEAF_DATA_DIR")
 		defer os.Setenv("NOTELEAF_DATA_DIR", originalEnv)
 
-		// Create temporary environment for testing
 		tempHome, err := os.MkdirTemp("", "noteleaf-home-test-*")
 		if err != nil {
 			t.Fatalf("Failed to create temp home: %v", err)
···
 			t.Fatalf("GetDataDir failed: %v", err)
 		}
 
-		// Verify the path contains our temp directory
 		if !strings.Contains(dataDir, tempHome) {
 			t.Errorf("Data directory should be under temp home, got: %s", dataDir)
 		}

internal/store/database_test.go

···
 	"runtime"
 	"strings"
 	"testing"
+
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func withTempDirs(t *testing.T) string {
 	t.Helper()
-	tempDir, err := os.MkdirTemp("", "noteleaf-db-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp directory: %v", err)
-	}
-	t.Cleanup(func() { os.RemoveAll(tempDir) })
+	tempDir, cleanup := shared.CreateTempDir("noteleaf-db-test-*", t)
+	t.Cleanup(func() { cleanup() })
 
 	origConfig, origData := GetConfigDir, GetDataDir
 	GetConfigDir = func() (string, error) { return tempDir, nil }

internal/ui/data_list_tui_test.go

···
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 type mockListModel struct {
···
 
 		if err := suite.WaitFor(func(m tea.Model) bool {
 			view := m.View()
-			return !containsString(view, "help")
+			return !shared.ContainsString(view, "help")
 		}, 1*time.Second); err != nil {
 			t.Errorf("Help should have been hidden: %v", err)
 		}

internal/ui/project_list_adapter.go

···
 	GetProjects(ctx context.Context) ([]repo.ProjectSummary, error)
 }
 
-
 func pluralizeCount(count int) string {
 	if count == 1 {
 		return ""

internal/ui/tag_list_adapter.go

···
 	GetTags(ctx context.Context) ([]repo.TagSummary, error)
 }
 
-
 // TagSummaryRecord adapts repo.TagSummary to work with DataTable
 type TagSummaryRecord struct {
 	summary repo.TagSummary

internal/ui/task_edit_interactive_test.go

···
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 func TestInteractiveTUIBehavior(t *testing.T) {
···
 			t.Error("View should not be empty")
 		}
 
-		if !containsString(view, "Test Output") {
+		if !shared.ContainsString(view, "Test Output") {
 			t.Error("View should contain task description")
 		}
 	})

internal/ui/test_utilities.go

···
 
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/shared"
 )
 
 type AssertionHelpers struct{}
···
 func (suite *TUITestSuite) WaitForView(contains string, timeout time.Duration) error {
 	return suite.WaitFor(func(model tea.Model) bool {
 		view := model.View()
-		return len(view) > 0 && containsString(view, contains)
+		return len(view) > 0 && shared.ContainsString(view, contains)
 	}, timeout)
 }
 
···
 func (ah *AssertionHelpers) AssertViewContains(t *testing.T, suite *TUITestSuite, expected string, msg string) {
 	t.Helper()
 	view := suite.GetCurrentView()
-	if !containsString(view, expected) {
+	if !shared.ContainsString(view, expected) {
 		t.Errorf("View assertion failed: %s\nView content: %s\nExpected to contain: %s", msg, view, expected)
 	}
 }
···
 func (ah *AssertionHelpers) AssertViewNotContains(t *testing.T, suite *TUITestSuite, unexpected string, msg string) {
 	t.Helper()
 	view := suite.GetCurrentView()
-	if containsString(view, unexpected) {
+	if shared.ContainsString(view, unexpected) {
 		t.Errorf("View assertion failed: %s\nView content: %s\nShould not contain: %s", msg, view, unexpected)
 	}
 }
···
 }
 
 var Expect = AssertionHelpers{}
-
-func containsString(haystack, needle string) bool {
-	if needle == "" {
-		return true
-	}
-
-	for i := 0; i <= len(haystack)-len(needle); i++ {
-		if haystack[i:i+len(needle)] == needle {
-			return true
-		}
-	}
-	return false
-}
 
 // Test generators for switch case coverage
 type SwitchCaseTest struct {