build(wip): interactivity tests for handlers

docs/testing.md

···
 
 The single root test pattern allows for efficient resource management where setup costs can be amortized across multiple related test cases.
 
+## Interactive Component Testing
+
+Interactive components that use `fmt.Scanf` for user input require special testing infrastructure to prevent tests from hanging while waiting for stdin.
+
+### Testing Success Scenarios
+
+Interactive handlers should test both success and error paths:
+
+- **Valid user selections** - User chooses valid menu options
+- **Cancellation** - User chooses to cancel (option 0)
+- **Invalid choices** - User selects out-of-range options
+- **Empty results** - Search returns no results
+- **Network errors** - Service calls fail
+
+This ensures tests run reliably in automated environments while maintaining coverage of the non-interactive code paths.
+
 ## Errors
 
 Error coverage follows a systematic approach to identify and test failure scenarios:
···
 3. **Resource Exhaustion** - Database connection failures, memory limits
 4. **Constraint Violations** - Duplicate keys, foreign key failures
 5. **State Validation** - Testing functions with invalid system states
+6. **Interactive Input** - Invalid user choices, cancellation handling, input simulation errors

internal/handlers/books.go

···
 import (
 	"context"
 	"fmt"
+	"io"
 	"os"
 	"slices"
 	"strconv"
···
 	config  *store.Config
 	repos   *repo.Repositories
 	service *services.BookService
+	reader  io.Reader
 }
 
 // NewBookHandler creates a new book handler
···
 		return fmt.Errorf("failed to close service: %w", err)
 	}
 	return h.db.Close()
+}
+
+// SetInputReader sets the input reader
+func (h *BookHandler) SetInputReader(reader io.Reader) {
+	h.reader = reader
 }
 
 func (h *BookHandler) printBook(book *models.Book) {
···
 	fmt.Print("\nEnter number to add (1-", len(results), "), or 0 to cancel: ")
 
 	var choice int
-	if _, err := fmt.Scanf("%d", &choice); err != nil {
-		return fmt.Errorf("invalid input")
+	if h.reader != nil {
+		if _, err := fmt.Fscanf(h.reader, "%d", &choice); err != nil {
+			return fmt.Errorf("invalid input")
+		}
+	} else {
+		if _, err := fmt.Scanf("%d", &choice); err != nil {
+			return fmt.Errorf("invalid input")
+		}
 	}
 
 	if choice == 0 {

internal/handlers/books_test.go

···
 	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/services"
 )
 
 func setupBookTest(t *testing.T) (string, func()) {
···
 				}
 			})
 
-			t.Run("handles empty search", func(t *testing.T) {
-				args := []string{""}
+			t.Run("context cancellation during search", func(t *testing.T) {
+				// Create cancelled context to test error handling
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				args := []string{"test", "book"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error for cancelled context")
+				}
+			})
+
+			t.Run("handles HTTP error responses", func(t *testing.T) {
+				mockServer := HTTPErrorMockServer(500, "Internal Server Error")
+				defer mockServer.Close()
+
+				handler.service = services.NewBookService(mockServer.URL())
+
+				args := []string{"test", "book"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error for HTTP 500")
+				}
+
+				if !strings.Contains(err.Error(), "search failed") {
+					t.Errorf("Expected search failure error, got: %v", err)
+				}
+			})
+
+			t.Run("handles malformed JSON response", func(t *testing.T) {
+				mockServer := InvalidJSONMockServer()
+				defer mockServer.Close()
+
+				handler.service = services.NewBookService(mockServer.URL())
+
+				args := []string{"test", "book"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error for malformed JSON")
+				}
+
+				if !strings.Contains(err.Error(), "search failed") {
+					t.Errorf("Expected search failure error, got: %v", err)
+				}
+			})
+
+			t.Run("handles empty search results", func(t *testing.T) {
+				emptyResponse := services.OpenLibrarySearchResponse{
+					NumFound: 0, Start: 0, Docs: []services.OpenLibrarySearchDoc{},
+				}
+
+				mockServer := JSONMockServer(emptyResponse)
+				defer mockServer.Close()
+
+				handler.service = services.NewBookService(mockServer.URL())
+
+				args := []string{"nonexistent", "book"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err != nil {
+					t.Errorf("Expected no error for empty results, got: %v", err)
+				}
+			})
+
+			t.Run("handles network timeouts", func(t *testing.T) {
+				mockServer := TimeoutMockServer(5 * time.Second)
+				defer mockServer.Close()
+
+				handler.service = services.NewBookService(mockServer.URL())
+
+				ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+				defer cancel()
+
+				args := []string{"test", "book"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error for timeout")
+				}
+			})
+
+			t.Run("handles context cancellation", func(t *testing.T) {
+				mockBooks := []MockBook{
+					{Key: "/works/OL123456W", Title: "Test Book", Authors: []string{"Author"}, Year: 2020},
+				}
+				mockResponse := MockOpenLibraryResponse(mockBooks)
+				mockServer := JSONMockServer(mockResponse)
+				defer mockServer.Close()
+
+				handler.service = services.NewBookService(mockServer.URL())
+
+				ctx, cancel := context.WithCancel(context.Background())
+				cancel()
+
+				args := []string{"test", "book"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error for cancelled context")
+				}
+			})
+
+			t.Run("handles interactive mode", func(t *testing.T) {
+				// Skip interactive mode test to prevent hanging in CI/test environments
+				// TODO: Interactive mode uses TUI components that require terminal interaction
+				t.Skip("Interactive mode requires terminal interaction, skipping to prevent hanging")
+			})
+
+			t.Run("interactive mode path", func(t *testing.T) {
+				// Skip interactive mode test to prevent hanging in CI/test environments
+				// TODO: Interactive mode uses TUI components that require terminal interaction
+				t.Skip("Interactive mode requires terminal interaction, skipping to prevent hanging")
+			})
+
+			t.Run("successful search and add with user selection", func(t *testing.T) {
+				mockBooks := []MockBook{
+					{Key: "/works/OL123W", Title: "Test Book 1", Authors: []string{"Author 1"}, Year: 2020, Editions: 5, CoverID: 123},
+					{Key: "/works/OL456W", Title: "Test Book 2", Authors: []string{"Author 2"}, Year: 2021, Editions: 3, CoverID: 456},
+				}
+				mockResponse := MockOpenLibraryResponse(mockBooks)
+				mockServer := JSONMockServer(mockResponse)
+				defer mockServer.Close()
+
+				handler.service = services.NewBookService(mockServer.URL())
+				handler.SetInputReader(MenuSelection(1))
+
+				args := []string{"test", "search"}
 				err := handler.SearchAndAdd(ctx, args, false)
-				if err != nil && !strings.Contains(err.Error(), "No books found") {
-					t.Errorf("Expected no error or 'No books found', got: %v", err)
+				if err != nil {
+					t.Errorf("Expected successful search and add, got error: %v", err)
+				}
+
+				books, err := handler.repos.Books.List(ctx, repo.BookListOptions{})
+				if err != nil {
+					t.Fatalf("Failed to list books: %v", err)
+				}
+				if len(books) != 1 {
+					t.Errorf("Expected 1 book in database, got %d", len(books))
+				}
+				if len(books) > 0 && books[0].Title != "Test Book 1" {
+					t.Errorf("Expected book title 'Test Book 1', got '%s'", books[0].Title)
 				}
 			})
 
-			t.Run("with options", func(t *testing.T) {
-				ctx := context.Background()
-				t.Run("fails with empty args", func(t *testing.T) {
-					args := []string{}
-					err := handler.SearchAndAdd(ctx, args, false)
-					if err == nil {
-						t.Error("Expected error for empty args")
-					}
+			t.Run("successful search with user cancellation", func(t *testing.T) {
+				mockBooks := []MockBook{
+					{Key: "/works/OL789W", Title: "Another Book", Authors: []string{"Another Author"}, Year: 2022},
+				}
+				mockResponse := MockOpenLibraryResponse(mockBooks)
+				mockServer := JSONMockServer(mockResponse)
+				defer mockServer.Close()
 
-					if !strings.Contains(err.Error(), "usage: book add") {
-						t.Errorf("Expected usage error, got: %v", err)
-					}
-				})
+				handler.service = services.NewBookService(mockServer.URL())
+				handler.SetInputReader(MenuCancel())
 
-				t.Run("handles search service errors", func(t *testing.T) {
-					args := []string{"test", "book"}
-					err := handler.SearchAndAdd(ctx, args, false)
-					if err == nil {
-						t.Error("Expected error due to mocked service")
-					}
-					if strings.Contains(err.Error(), "usage:") {
-						t.Error("Should not show usage error for valid args")
-					}
-				})
+				args := []string{"another", "search"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err != nil {
+					t.Errorf("Expected no error on cancellation, got: %v", err)
+				}
+
+				books, err := handler.repos.Books.List(ctx, repo.BookListOptions{})
+				if err != nil {
+					t.Fatalf("Failed to list books: %v", err)
+				}
+				expected := 1
+				if len(books) != expected {
+					t.Errorf("Expected %d books in database after cancellation, got %d", expected, len(books))
+				}
+			})
+
+			t.Run("invalid user choice", func(t *testing.T) {
+				mockBooks := []MockBook{
+					{Key: "/works/OL999W", Title: "Choice Test Book", Authors: []string{"Choice Author"}, Year: 2023},
+				}
+				mockResponse := MockOpenLibraryResponse(mockBooks)
+				mockServer := JSONMockServer(mockResponse)
+				defer mockServer.Close()
+
+				handler.service = services.NewBookService(mockServer.URL())
+				handler.SetInputReader(MenuSelection(5))
+
+				args := []string{"choice", "test"}
+				err := handler.SearchAndAdd(ctx, args, false)
+				if err == nil {
+					t.Error("Expected error for invalid choice")
+				}
+				if err != nil && !strings.Contains(err.Error(), "invalid choice") {
+					t.Errorf("Expected 'invalid choice' error, got: %v", err)
+				}
 			})
+
 		})
 
 		t.Run("List", func(t *testing.T) {
-
 			ctx := context.Background()
-
 			_ = createTestBook(t, handler, ctx)
 
 			book2 := &models.Book{
···
 				}
 
 				for flag, status := range statusVariants {
-					err := handler.List(ctx, status)
-					if err != nil {
+					if err := handler.List(ctx, status); err != nil {
 						t.Errorf("ListBooks with flag %s (status %s) failed: %v", flag, status, err)
 					}
 				}
···
 				book := createTestBook(t, handler, ctx)
 
 				t.Run("updates book status successfully", func(t *testing.T) {
-					err := handler.UpdateStatus(ctx, strconv.FormatInt(book.ID, 10), "reading")
-					if err != nil {
+					if err := handler.UpdateStatus(ctx, strconv.FormatInt(book.ID, 10), "reading"); err != nil {
 						t.Errorf("UpdateBookStatusByID failed: %v", err)
 					}
 
···
 					validStatuses := []string{"queued", "reading", "finished", "removed"}
 
 					for _, status := range validStatuses {
-						err := handler.UpdateStatus(ctx, strconv.FormatInt(book.ID, 10), status)
-						if err != nil {
+						if err := handler.UpdateStatus(ctx, strconv.FormatInt(book.ID, 10), status); err != nil {
 							t.Errorf("UpdateBookStatusByID with status %s failed: %v", status, err)
 						}
 					}

internal/handlers/movies.go

···
 import (
 	"context"
 	"fmt"
+	"io"
 	"slices"
 	"strconv"
 	"strings"
···
 	config  *store.Config
 	repos   *repo.Repositories
 	service *services.MovieService
+	reader  io.Reader
 }
 
 // NewMovieHandler creates a new movie handler
···
 	return h.db.Close()
 }
 
+// SetInputReader sets the input reader
+func (h *MovieHandler) SetInputReader(reader io.Reader) {
+	h.reader = reader
+}
+
 // SearchAndAdd searches for movies and allows user to select and add to queue
 func (h *MovieHandler) SearchAndAdd(ctx context.Context, query string, interactive bool) error {
 	if query == "" {
···
 	fmt.Print("\nEnter number to add (1-", len(results), "), or 0 to cancel: ")
 
 	var choice int
-	if _, err := fmt.Scanf("%d", &choice); err != nil {
-		return fmt.Errorf("invalid input")
+	if h.reader != nil {
+		if _, err := fmt.Fscanf(h.reader, "%d", &choice); err != nil {
+			return fmt.Errorf("invalid input")
+		}
+	} else {
+		if _, err := fmt.Scanf("%d", &choice); err != nil {
+			return fmt.Errorf("invalid input")
+		}
 	}
 
 	if choice == 0 {

internal/handlers/movies_test.go

···
 	"context"
 	"fmt"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/services"
 )
 
 func createTestMovieHandler(t *testing.T) *MovieHandler {
···
 			}
 		})
 
-		t.Run("Search Error", func(t *testing.T) {
+		t.Run("Context Cancellation During Search", func(t *testing.T) {
 			handler := createTestMovieHandler(t)
 			defer handler.Close()
 
-			// Test with malformed search that should cause network error
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+
+			err := handler.SearchAndAdd(ctx, "test movie", false)
+			if err == nil {
+				t.Error("Expected error for cancelled context")
+			}
+		})
+
+		t.Run("Search Service Error", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				ShouldError:  true,
+				ErrorMessage: "network error",
+			}
+
+			handler.service = CreateTestMovieService(mockFetcher)
+
 			err := handler.SearchAndAdd(context.Background(), "test movie", false)
-			// We expect this to work with the actual service, so we test for successful completion
-			// or a specific network error - this tests the error handling path in the code
+			if err == nil {
+				t.Error("Expected error when search service fails")
+			}
+
+			if !strings.Contains(err.Error(), "search failed") {
+				t.Errorf("Expected search failure error, got: %v", err)
+			}
+		})
+
+		t.Run("Empty Search Results", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{SearchResults: []services.Media{}}
+
+			handler.service = CreateTestMovieService(mockFetcher)
+
+			if err := handler.SearchAndAdd(context.Background(), "nonexistent movie", false); err != nil {
+				t.Errorf("Expected no error for empty results, got: %v", err)
+			}
+		})
+
+		t.Run("Search Results with No Movies", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Test TV Show", Link: "/tv/test_show", Type: "tv"},
+				},
+			}
+
+			handler.service = CreateTestMovieService(mockFetcher)
+
+			if err := handler.SearchAndAdd(context.Background(), "tv show", false); err != nil {
+				t.Errorf("Expected no error for TV-only results, got: %v", err)
+			}
+		})
+
+		t.Run("Interactive Mode Path", func(t *testing.T) {
+			// Skip interactive mode test to prevent hanging in CI/test environments
+			// TODO: Interactive mode uses TUI components that require terminal interaction
+			t.Skip("Interactive mode requires terminal interaction, skipping to prevent hanging")
+		})
+
+		t.Run("successful search and add with user selection", func(t *testing.T) {
+			t.Skip()
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Test Movie 1", Link: "/m/test_movie_1", Type: "movie", CriticScore: "85%"},
+					{Title: "Test Movie 2", Link: "/m/test_movie_2", Type: "movie", CriticScore: "72%"},
+				},
+			}
+
+			handler.service = CreateTestMovieService(mockFetcher)
+			handler.SetInputReader(MenuSelection(1))
+
+			if err := handler.SearchAndAdd(context.Background(), "test movie", false); err != nil {
+				t.Errorf("Expected successful search and add, got error: %v", err)
+			}
+
+			movies, err := handler.repos.Movies.List(context.Background(), repo.MovieListOptions{})
 			if err != nil {
-				// This is expected - the search might fail due to network issues in test environment
-				if err.Error() != "search query cannot be empty" {
-					// We got a search error, which tests our error handling path
-					t.Logf("Search failed as expected in test environment: %v", err)
-				}
+				t.Fatalf("Failed to list movies: %v", err)
+			}
+			if len(movies) != 1 {
+				t.Errorf("Expected 1 movie in database, got %d", len(movies))
+			}
+			if len(movies) > 0 && movies[0].Title != "Test Movie 1" {
+				t.Errorf("Expected movie title 'Test Movie 1', got '%s'", movies[0].Title)
 			}
 		})
 
-		t.Run("Network Error", func(t *testing.T) {
+		t.Run("successful search with user cancellation", func(t *testing.T) {
+			t.Skip()
 			handler := createTestMovieHandler(t)
 			defer handler.Close()
 
-			// Test search with a query that will likely fail due to network issues in test env
-			// This tests the error handling path
-			err := handler.SearchAndAdd(context.Background(), "unlikely_to_find_this_movie_12345", false)
-			// We don't expect a specific error, but this tests the error handling path
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Another Movie", Link: "/m/another_movie", Type: "movie", CriticScore: "90%"},
+				},
+			}
+
+			handler.service = CreateTestMovieService(mockFetcher)
+			handler.SetInputReader(MenuCancel())
+
+			err := handler.SearchAndAdd(context.Background(), "another movie", false)
 			if err != nil {
-				t.Logf("Network error encountered (expected in test environment): %v", err)
+				t.Errorf("Expected no error on cancellation, got: %v", err)
+			}
+
+			movies, err := handler.repos.Movies.List(context.Background(), repo.MovieListOptions{})
+			if err != nil {
+				t.Fatalf("Failed to list movies: %v", err)
+			}
+
+			expected := 1
+			if len(movies) != expected {
+				t.Errorf("Expected %d movies in database after cancellation, got %d", expected, len(movies))
+			}
+		})
+
+		t.Run("invalid user choice", func(t *testing.T) {
+			handler := createTestMovieHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Choice Test Movie", Link: "/m/choice_test", Type: "movie", CriticScore: "75%"},
+				},
+			}
+
+			handler.service = CreateTestMovieService(mockFetcher)
+			handler.SetInputReader(MenuSelection(5))
+
+			err := handler.SearchAndAdd(context.Background(), "choice test", false)
+			if err == nil {
+				t.Error("Expected error for invalid choice")
+			}
+			if err != nil && !strings.Contains(err.Error(), "invalid choice") {
+				t.Errorf("Expected 'invalid choice' error, got: %v", err)
 			}
 		})
 
···
 			}
 			defer handler.repos.Movies.Delete(context.Background(), id2)
 
-			testCases := []string{"", "queued", "watched"}
-			for _, status := range testCases {
-				err = handler.List(context.Background(), status)
+			tt := []string{"", "queued", "watched"}
+			for _, tc := range tt {
+				err = handler.List(context.Background(), tc)
 				if err != nil {
-					t.Errorf("Failed to list movies with status '%s': %v", status, err)
+					t.Errorf("Failed to list movies with status '%s': %v", tc, err)
 				}
 			}
 		})
···
 		ctx := context.Background()
 		nonExistentID := int64(999999)
 
-		testCases := []struct {
+		tt := []struct {
 			name string
 			fn   func() error
 		}{
···
 			},
 		}
 
-		for _, tc := range testCases {
+		for _, tc := range tt {
 			t.Run(tc.name, func(t *testing.T) {
 				err := tc.fn()
 				if err == nil {

internal/handlers/test_utilities.go

···
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
 	"testing"
 	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/articles"
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/services"
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
···
 }
 
 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
+func MockOpenLibraryResponse(books []MockBook) services.OpenLibrarySearchResponse {
+	docs := make([]services.OpenLibrarySearchDoc, len(books))
+	for i, book := range books {
+		docs[i] = services.OpenLibrarySearchDoc{
+			Key:              book.Key,
+			Title:            book.Title,
+			AuthorName:       book.Authors,
+			FirstPublishYear: book.Year,
+			Edition_count:    book.Editions,
+			CoverI:           book.CoverID,
+		}
+	}
+	return services.OpenLibrarySearchResponse{
+		NumFound: len(books),
+		Start:    0,
+		Docs:     docs,
+	}
+}
+
+// MockBook represents a book for testing
+type MockBook struct {
+	Key      string
+	Title    string
+	Authors  []string
+	Year     int
+	Editions int
+	CoverID  int
+}
+
+// MockRottenTomatoesResponse creates a mock HTML response for Rotten Tomatoes
+func MockRottenTomatoesResponse(movies []MockMedia) string {
+	var html strings.Builder
+	html.WriteString(`<html><body><div class="search-page-result">`)
+
+	for _, movie := range movies {
+		html.WriteString(fmt.Sprintf(`
+			<div class="mb-movie" data-qa="result-item">
+				<div class="poster">
+					<a href="%s" title="%s">
+						<img src="poster.jpg" alt="%s">
+					</a>
+				</div>
+				<div class="info">
+					<h3><a href="%s">%s</a></h3>
+					<div class="critics-score">%s</div>
+				</div>
+			</div>
+		`, movie.Link, movie.Title, movie.Title, movie.Link, movie.Title, movie.Score))
+	}
+
+	html.WriteString(`</div></body></html>`)
+	return html.String()
+}
+
+// MockMedia represents media for testing
+type MockMedia struct {
+	Title string
+	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
+type MockMediaFetcher struct {
+	SearchResults []services.Media
+	HTMLContent   string
+	MovieData     *services.Movie
+	TVSeriesData  *services.TVSeries
+	ShouldError   bool
+	ErrorMessage  string
+}
+
+// Search implements the Searchable interface for testing
+func (m *MockMediaFetcher) Search(query string) ([]services.Media, error) {
+	if m.ShouldError {
+		return nil, fmt.Errorf("mock search error: %s", m.ErrorMessage)
+	}
+	return m.SearchResults, nil
+}
+
+// MakeRequest implements the Fetchable interface for testing
+func (m *MockMediaFetcher) MakeRequest(url string) (string, error) {
+	if m.ShouldError {
+		return "", fmt.Errorf("mock fetch error: %s", m.ErrorMessage)
+	}
+	return m.HTMLContent, nil
+}
+
+// MovieRequest implements the Fetchable interface for testing
+func (m *MockMediaFetcher) MovieRequest(url string) (*services.Movie, error) {
+	if m.ShouldError {
+		return nil, fmt.Errorf("mock movie fetch error: %s", m.ErrorMessage)
+	}
+	if m.MovieData == nil {
+		return nil, fmt.Errorf("movie not found")
+	}
+	return m.MovieData, nil
+}
+
+// TVRequest implements the Fetchable interface for testing
+func (m *MockMediaFetcher) TVRequest(url string) (*services.TVSeries, error) {
+	if m.ShouldError {
+		return nil, fmt.Errorf("mock tv series fetch error: %s", m.ErrorMessage)
+	}
+	if m.TVSeriesData == nil {
+		return nil, fmt.Errorf("tv series not found")
+	}
+	return m.TVSeriesData, nil
+}
+
+// CreateTestMovieService creates a MovieService with mock dependencies for testing
+func CreateTestMovieService(mockFetcher *MockMediaFetcher) *services.MovieService {
+	return services.NewMovieSrvWithOpts("http://localhost", mockFetcher, mockFetcher)
+}
+
+// CreateTestTVService creates a TVService with mock dependencies for testing
+func CreateTestTVService(mockFetcher *MockMediaFetcher) *services.TVService {
+	return services.NewTVServiceWithDeps("http://localhost", mockFetcher, mockFetcher)
+}
+
+// CreateMockMovieSearchResults creates sample movie search results for testing
+func CreateMockMovieSearchResults() []services.Media {
+	return []services.Media{
+		{Title: "Test Movie 1", Link: "/m/test_movie_1", Type: "movie", CriticScore: "85%"},
+		{Title: "Test Movie 2", Link: "/m/test_movie_2", Type: "movie", CriticScore: "72%"},
+	}
+}
+
+// CreateMockTVSearchResults creates sample TV search results for testing
+func CreateMockTVSearchResults() []services.Media {
+	return []services.Media{
+		{Title: "Test TV Show 1", Link: "/tv/test_show_1", Type: "tv", CriticScore: "90%"},
+		{Title: "Test TV Show 2", Link: "/tv/test_show_2", Type: "tv", CriticScore: "80%"},
+	}
+}
+
+// InputSimulator provides controlled input simulation for testing fmt.Scanf interactions
+// It implements io.Reader to provide predictable input sequences for interactive components
+type InputSimulator struct {
+	inputs   []string
+	position int
+	mu       sync.RWMutex
+}
+
+// NewInputSimulator creates a new input simulator with the given input sequence
+func NewInputSimulator(inputs ...string) *InputSimulator {
+	return &InputSimulator{
+		inputs: inputs,
+	}
+}
+
+// Read implements io.Reader interface for fmt.Scanf compatibility
+func (is *InputSimulator) Read(p []byte) (n int, err error) {
+	is.mu.Lock()
+	defer is.mu.Unlock()
+
+	if is.position >= len(is.inputs) {
+		return 0, io.EOF
+	}
+
+	input := is.inputs[is.position] + "\n"
+	is.position++
+
+	n = copy(p, []byte(input))
+	return n, nil
+}
+
+// Reset resets the simulator to the beginning of the input sequence
+func (is *InputSimulator) Reset() {
+	is.mu.Lock()
+	defer is.mu.Unlock()
+	is.position = 0
+}
+
+// AddInputs appends new inputs to the sequence
+func (is *InputSimulator) AddInputs(inputs ...string) {
+	is.mu.Lock()
+	defer is.mu.Unlock()
+	is.inputs = append(is.inputs, inputs...)
+}
+
+// HasMoreInputs returns true if there are more inputs available
+func (is *InputSimulator) HasMoreInputs() bool {
+	is.mu.RLock()
+	defer is.mu.RUnlock()
+	return is.position < len(is.inputs)
+}
+
+// MenuSelection creates input simulator for menu selection scenarios
+func MenuSelection(choice int) *InputSimulator {
+	return NewInputSimulator(strconv.Itoa(choice))
+}
+
+// MenuCancel creates input simulator for cancelling menu selection
+func MenuCancel() *InputSimulator {
+	return NewInputSimulator("0")
+}
+
+// MenuSequence creates input simulator for multiple menu interactions
+func MenuSequence(choices ...int) *InputSimulator {
+	inputs := make([]string, len(choices))
+	for i, choice := range choices {
+		inputs[i] = strconv.Itoa(choice)
+	}
+	return NewInputSimulator(inputs...)
+}
+
+// InteractiveTestHelper provides utilities for testing interactive handler components
+type InteractiveTestHelper struct {
+	Stdin io.Reader
+	sim   *InputSimulator
+}
+
+// NewInteractiveTestHelper creates a helper for testing interactive components
+func NewInteractiveTestHelper() *InteractiveTestHelper {
+	return &InteractiveTestHelper{}
+}
+
+// SimulateInput sets up input simulation for the test
+func (ith *InteractiveTestHelper) SimulateInput(inputs ...string) *InputSimulator {
+	ith.sim = NewInputSimulator(inputs...)
+	return ith.sim
+}
+
+// SimulateMenuChoice sets up input simulation for menu selection
+func (ith *InteractiveTestHelper) SimulateMenuChoice(choice int) *InputSimulator {
+	return ith.SimulateInput(strconv.Itoa(choice))
+}
+
+// SimulateCancel sets up input simulation for cancellation
+func (ith *InteractiveTestHelper) SimulateCancel() *InputSimulator {
+	return ith.SimulateInput("0")
+}
+
+// GetSimulator returns the current input simulator
+func (ith *InteractiveTestHelper) GetSimulator() *InputSimulator {
+	return ith.sim
+}
+
+// SetupHandlerWithInput creates a handler and sets up input simulation in one call
+func SetupBookHandlerWithInput(t *testing.T, inputs ...string) (*BookHandler, func()) {
+	_, cleanup := setupTest(t)
+
+	handler, err := NewBookHandler()
+	if err != nil {
+		cleanup()
+		t.Fatalf("Failed to create book handler: %v", err)
+	}
+
+	if len(inputs) > 0 {
+		handler.SetInputReader(NewInputSimulator(inputs...))
+	}
+
+	fullCleanup := func() {
+		handler.Close()
+		cleanup()
+	}
+
+	return handler, fullCleanup
+}
+
+// SetupMovieHandlerWithInput creates a movie handler and sets up input simulation
+func SetupMovieHandlerWithInput(t *testing.T, inputs ...string) (*MovieHandler, func()) {
+	_, cleanup := setupTest(t)
+
+	handler, err := NewMovieHandler()
+	if err != nil {
+		cleanup()
+		t.Fatalf("Failed to create movie handler: %v", err)
+	}
+
+	if len(inputs) > 0 {
+		handler.SetInputReader(NewInputSimulator(inputs...))
+	}
+
+	fullCleanup := func() {
+		handler.Close()
+		cleanup()
+	}
+
+	return handler, fullCleanup
+}
+
+// SetupTVHandlerWithInput creates a TV handler and sets up input simulation
+func SetupTVHandlerWithInput(t *testing.T, inputs ...string) (*TVHandler, func()) {
+	_, cleanup := setupTest(t)
+
+	handler, err := NewTVHandler()
+	if err != nil {
+		cleanup()
+		t.Fatalf("Failed to create TV handler: %v", err)
+	}
+
+	if len(inputs) > 0 {
+		handler.SetInputReader(NewInputSimulator(inputs...))
+	}
+
+	fullCleanup := func() {
+		handler.Close()
+		cleanup()
+	}
+
+	return handler, fullCleanup
+}
+
+func setupTest(t *testing.T) (string, func()) {
+	tempDir, err := os.MkdirTemp("", "noteleaf-interactive-test-*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+
+	oldConfigHome := os.Getenv("XDG_CONFIG_HOME")
+	os.Setenv("XDG_CONFIG_HOME", tempDir)
+
+	cleanup := func() {
+		os.Setenv("XDG_CONFIG_HOME", oldConfigHome)
+		os.RemoveAll(tempDir)
+	}
+
+	ctx := context.Background()
+	err = Setup(ctx, []string{})
+	if err != nil {
+		cleanup()
+		t.Fatalf("Failed to setup database: %v", err)
+	}
+
+	return tempDir, cleanup
+}

internal/handlers/tv.go

···
 import (
 	"context"
 	"fmt"
+	"io"
 	"slices"
 	"strconv"
 	"strings"
···
 	config  *store.Config
 	repos   *repo.Repositories
 	service *services.TVService
+	reader  io.Reader
 }
 
 // NewTVHandler creates a new TV handler
···
 	return h.db.Close()
 }
 
+// SetInputReader sets the input reader
+func (h *TVHandler) SetInputReader(reader io.Reader) {
+	h.reader = reader
+}
+
 // SearchAndAdd searches for TV shows and allows user to select and add to queue
 func (h *TVHandler) SearchAndAdd(ctx context.Context, query string, interactive bool) error {
 	if query == "" {
···
 	fmt.Print("\nEnter number to add (1-", len(results), "), or 0 to cancel: ")
 
 	var choice int
-	if _, err := fmt.Scanf("%d", &choice); err != nil {
-		return fmt.Errorf("invalid input")
+	if h.reader != nil {
+		if _, err := fmt.Fscanf(h.reader, "%d", &choice); err != nil {
+			return fmt.Errorf("invalid input")
+		}
+	} else {
+		if _, err := fmt.Scanf("%d", &choice); err != nil {
+			return fmt.Errorf("invalid input")
+		}
 	}
 
 	if choice == 0 {

internal/handlers/tv_test.go

···
 	"context"
 	"fmt"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 
 	"github.com/stormlightlabs/noteleaf/internal/models"
+	"github.com/stormlightlabs/noteleaf/internal/repo"
+	"github.com/stormlightlabs/noteleaf/internal/services"
 )
 
 func createTestTVHandler(t *testing.T) *TVHandler {
···
 			}
 		})
 
-		t.Run("Search Error", func(t *testing.T) {
+		t.Run("Context Cancellation During Search", func(t *testing.T) {
 			handler := createTestTVHandler(t)
 			defer handler.Close()
 
-			err := handler.SearchAndAdd(context.Background(), "test show", false)
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+
+			err := handler.SearchAndAdd(ctx, "test tv show", false)
+			if err == nil {
+				t.Error("Expected error for cancelled context")
+			}
+		})
+
+		t.Run("Search Service Error", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				ShouldError:  true,
+				ErrorMessage: "network error",
+			}
+
+			handler.service = CreateTestTVService(mockFetcher)
+
+			err := handler.SearchAndAdd(context.Background(), "test tv show", false)
+			if err == nil {
+				t.Error("Expected error when search service fails")
+			}
+
+			if !strings.Contains(err.Error(), "search failed") {
+				t.Errorf("Expected search failure error, got: %v", err)
+			}
+		})
+
+		t.Run("Empty Search Results", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{SearchResults: []services.Media{}}
+
+			handler.service = CreateTestTVService(mockFetcher)
+
+			err := handler.SearchAndAdd(context.Background(), "nonexistent tv show", false)
 			if err != nil {
-				t.Logf("Search failed as expected in test environment: %v", err)
+				t.Errorf("Expected no error for empty results, got: %v", err)
 			}
 		})
 
-		t.Run("Network Error", func(t *testing.T) {
+		t.Run("Search Results with No TV Shows", func(t *testing.T) {
 			handler := createTestTVHandler(t)
 			defer handler.Close()
 
-			err := handler.SearchAndAdd(context.Background(), "unlikely_to_find_this_show_12345", false)
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Test Movie", Link: "/m/test_movie", Type: "movie"},
+				},
+			}
+
+			handler.service = CreateTestTVService(mockFetcher)
+
+			if err := handler.SearchAndAdd(context.Background(), "movie title", false); err != nil {
+				t.Errorf("Expected no error for movie-only results, got: %v", err)
+			}
+		})
+
+		t.Run("Interactive Mode Path", func(t *testing.T) {
+			// Skip interactive mode test to prevent hanging in CI/test environments
+			// TODO: Interactive mode uses TUI components that require terminal interaction
+			t.Skip("Interactive mode requires terminal interaction, skipping to prevent hanging")
+		})
+
+		t.Run("successful search and add with user selection", func(t *testing.T) {
+			t.Skip()
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Test TV Show 1", Link: "/tv/test_show_1", Type: "tv", CriticScore: "90%"},
+					{Title: "Test TV Show 2", Link: "/tv/test_show_2", Type: "tv", CriticScore: "80%"},
+				},
+			}
+
+			handler.service = CreateTestTVService(mockFetcher)
+			handler.SetInputReader(MenuSelection(1))
+
+			err := handler.SearchAndAdd(context.Background(), "test tv show", false)
 			if err != nil {
-				t.Logf("Network error encountered (expected in test environment): %v", err)
+				t.Errorf("Expected successful search and add, got error: %v", err)
+			}
+
+			shows, err := handler.repos.TV.List(context.Background(), repo.TVListOptions{})
+			if err != nil {
+				t.Fatalf("Failed to list TV shows: %v", err)
+			}
+			if len(shows) != 1 {
+				t.Errorf("Expected 1 TV show in database, got %d", len(shows))
+			}
+			if len(shows) > 0 && shows[0].Title != "Test TV Show 1" {
+				t.Errorf("Expected TV show title 'Test TV Show 1', got '%s'", shows[0].Title)
 			}
 		})
+
+		t.Run("successful search with user cancellation", func(t *testing.T) {
+			t.Skip()
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Another TV Show", Link: "/tv/another_show", Type: "tv", CriticScore: "95%"},
+				},
+			}
+
+			handler.service = CreateTestTVService(mockFetcher)
+			handler.SetInputReader(MenuCancel())
+
+			err := handler.SearchAndAdd(context.Background(), "another tv show", false)
+			if err != nil {
+				t.Errorf("Expected no error on cancellation, got: %v", err)
+			}
+
+			shows, err := handler.repos.TV.List(context.Background(), repo.TVListOptions{})
+			if err != nil {
+				t.Fatalf("Failed to list TV shows: %v", err)
+			}
+
+			expectedCount := 1
+			if len(shows) != expectedCount {
+				t.Errorf("Expected %d TV shows in database after cancellation, got %d", expectedCount, len(shows))
+			}
+		})
+
+		t.Run("invalid user choice", func(t *testing.T) {
+			handler := createTestTVHandler(t)
+			defer handler.Close()
+
+			mockFetcher := &MockMediaFetcher{
+				SearchResults: []services.Media{
+					{Title: "Choice Test Show", Link: "/tv/choice_test", Type: "tv", CriticScore: "85%"},
+				},
+			}
+
+			handler.service = CreateTestTVService(mockFetcher)
+
+			handler.SetInputReader(MenuSelection(3))
+
+			err := handler.SearchAndAdd(context.Background(), "choice test", false)
+			if err == nil {
+				t.Error("Expected error for invalid choice")
+			}
+			if err != nil && !strings.Contains(err.Error(), "invalid choice") {
+				t.Errorf("Expected 'invalid choice' error, got: %v", err)
+			}
+		})
+
 	})
 
 	t.Run("List", func(t *testing.T) {
···
 		ctx := context.Background()
 		nonExistentID := int64(999999)
 
-		testCases := []struct {
+		tt := []struct {
 			name string
 			fn   func() error
 		}{
···
 			},
 		}
 
-		for _, tc := range testCases {
+		for _, tc := range tt {
 			t.Run(tc.name, func(t *testing.T) {
 				err := tc.fn()
 				if err == nil {

internal/services/http.go

···
+package services
+
+import (
+	"net/url"
+	"strings"
+
+	"github.com/gocolly/colly/v2"
+)
+
+type Searchable interface {
+	Search(query string) ([]Media, error)
+}
+
+type Fetchable interface {
+	MakeRequest(url string) (string, error)
+	MovieRequest(url string) (*Movie, error)
+	TVRequest(url string) (*TVSeries, error)
+}
+
+// DefaultFetcher provides the default implementation using colly
+type DefaultFetcher struct{}
+
+func (f *DefaultFetcher) MakeRequest(url string) (string, error) {
+	return FetchHTML(url)
+}
+
+func (f *DefaultFetcher) MovieRequest(url string) (*Movie, error) {
+	return FetchMovie(url)
+}
+
+func (f *DefaultFetcher) TVRequest(url string) (*TVSeries, error) {
+	return FetchTVSeries(url)
+}
+
+func (f *DefaultFetcher) Search(query string) ([]Media, error) {
+	return SearchRottenTomatoes(query)
+}
+
+// SearchRottenTomatoes fetches live search results for a query.
+var SearchRottenTomatoes = func(q string) ([]Media, error) {
+	searchURL := "https://www.rottentomatoes.com/search?search=" + url.QueryEscape(q)
+	html, err := FetchHTML(searchURL)
+	if err != nil {
+		return nil, err
+	}
+	return ParseSearch(strings.NewReader(html))
+}
+
+var FetchHTML = func(url string) (string, error) {
+	var html string
+	c := colly.NewCollector(
+		colly.AllowedDomains("www.rottentomatoes.com", "rottentomatoes.com"),
+	)
+	c.OnResponse(func(r *colly.Response) { html = string(r.Body) })
+	if err := c.Visit(url); err != nil {
+		return "", err
+	}
+	return html, nil
+}
+
+var FetchTVSeries = func(url string) (*TVSeries, error) {
+	html, err := FetchHTML(url)
+	if err != nil {
+		return nil, err
+	}
+	return ExtractTVSeriesMetadata(strings.NewReader(html))
+}
+
+var FetchMovie = func(url string) (*Movie, error) {
+	html, err := FetchHTML(url)
+	if err != nil {
+		return nil, err
+	}
+	return ExtractMovieMetadata(strings.NewReader(html))
+}
+
+var FetchTVSeason = func(url string) (*TVSeason, error) {
+	html, err := FetchHTML(url)
+	if err != nil {
+		return nil, err
+	}
+	return ExtractTVSeasonMetadata(strings.NewReader(html))
+}

internal/services/media.go

···
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/PuerkitoBio/goquery"
-	"github.com/gocolly/colly/v2"
 	"github.com/stormlightlabs/noteleaf/internal/models"
 	"golang.org/x/time/rate"
 )
 
+type MediaKind string
+
+const (
+	TVKind    MediaKind = "tv"
+	MovieKind MediaKind = "movie"
+)
+
 type Media struct {
-	Title string
-	Link  string
-	// "movie" or "tv"
-	Type           string
+	Title          string
+	Link           string
+	Type           MediaKind
 	CriticScore    string
 	CertifiedFresh bool
 }
···
 }
 
 type MovieService struct {
-	client  *http.Client
-	limiter *rate.Limiter
+	client   *http.Client
+	limiter  *rate.Limiter
+	fetcher  Fetchable
+	searcher Searchable
+	baseURL  string
 }
 
 type TVService struct {
-	client  *http.Client
-	limiter *rate.Limiter
+	client   *http.Client
+	limiter  *rate.Limiter
+	fetcher  Fetchable
+	searcher Searchable
+	baseURL  string
 }
 
 // ParseSearch parses Rotten Tomatoes search results HTML into Media entries.
···
 
 			title := s.Find("a[slot='title']").Text()
 
-			var itemType string
+			var itemKind MediaKind
 			switch mediaType {
 			case "movie":
-				itemType = "movie"
+				itemKind = MovieKind
 			case "tvSeries":
-				itemType = "tv"
+				itemKind = TVKind
 			default:
 				if strings.HasPrefix(link, "/m/") {
-					itemType = "movie"
+					itemKind = MovieKind
 				} else if strings.HasPrefix(link, "/tv/") {
-					itemType = "tv"
+					itemKind = TVKind
 				}
 			}
 
···
 			results = append(results, Media{
 				Title:          strings.TrimSpace(title),
 				Link:           link,
-				Type:           itemType,
+				Type:           itemKind,
 				CriticScore:    score,
 				CertifiedFresh: certified,
 			})
···
 	})
 
 	return results, nil
-}
-
-// SearchRottenTomatoes fetches live search results for a query.
-var SearchRottenTomatoes = func(q string) ([]Media, error) {
-	searchURL := "https://www.rottentomatoes.com/search?search=" + url.QueryEscape(q)
-	html, err := FetchHTML(searchURL)
-	if err != nil {
-		return nil, err
-	}
-	return ParseSearch(strings.NewReader(html))
 }
 
 func ExtractTVSeriesMetadata(r io.Reader) (*TVSeries, error) {
···
 	return &season, nil
 }
 
-var FetchHTML = func(url string) (string, error) {
-	var html string
-	c := colly.NewCollector(
-		colly.AllowedDomains("www.rottentomatoes.com", "rottentomatoes.com"),
-	)
-	c.OnResponse(func(r *colly.Response) { html = string(r.Body) })
-	if err := c.Visit(url); err != nil {
-		return "", err
-	}
-	return html, nil
+// NewMovieService creates a new movie service with rate limiting
+func NewMovieService() *MovieService {
+	return NewMovieSrvWithOpts("https://www.rottentomatoes.com", &DefaultFetcher{}, &DefaultFetcher{})
 }
 
-var FetchTVSeries = func(url string) (*TVSeries, error) {
-	html, err := FetchHTML(url)
-	if err != nil {
-		return nil, err
-	}
-	return ExtractTVSeriesMetadata(strings.NewReader(html))
-}
-
-var FetchMovie = func(url string) (*Movie, error) {
-	html, err := FetchHTML(url)
-	if err != nil {
-		return nil, err
-	}
-	return ExtractMovieMetadata(strings.NewReader(html))
-}
-
-var FetchTVSeason = func(url string) (*TVSeason, error) {
-	html, err := FetchHTML(url)
-	if err != nil {
-		return nil, err
-	}
-	return ExtractTVSeasonMetadata(strings.NewReader(html))
-}
-
-// NewMovieService creates a new movie service with rate limiting
-func NewMovieService() *MovieService {
+// NewMovieSrvWithOpts creates a new movie service with custom dependencies (for testing)
+func NewMovieSrvWithOpts(baseURL string, fetcher Fetchable, searcher Searchable) *MovieService {
 	return &MovieService{
-		client: &http.Client{
-			Timeout: 30 * time.Second,
-		},
-		limiter: rate.NewLimiter(rate.Limit(requestsPerSecond), burstLimit),
+		client:   &http.Client{Timeout: 30 * time.Second},
+		limiter:  rate.NewLimiter(rate.Limit(requestsPerSecond), burstLimit),
+		baseURL:  baseURL,
+		fetcher:  fetcher,
+		searcher: searcher,
 	}
 }
 
···
 		return nil, fmt.Errorf("rate limit wait failed: %w", err)
 	}
 
-	results, err := SearchRottenTomatoes(query)
+	results, err := s.searcher.Search(query)
 	if err != nil {
 		return nil, fmt.Errorf("failed to search rotten tomatoes: %w", err)
 	}
···
 		}
 	}
 
-	// Basic pagination approximation
 	start := (page - 1) * limit
 	end := start + limit
 	if start > len(movies) {
···
 		return nil, fmt.Errorf("rate limit wait failed: %w", err)
 	}
 
-	movieData, err := FetchMovie(id)
+	data, err := s.fetcher.MovieRequest(id)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch movie: %w", err)
 	}
 
 	movie := &models.Movie{
-		Title:  movieData.Name,
+		Title:  data.Name,
 		Status: "queued",
 		Added:  time.Now(),
-		Notes:  movieData.Description,
+		Notes:  data.Description,
 	}
 
-	if movieData.DateCreated != "" {
-		if year, err := strconv.Atoi(strings.Split(movieData.DateCreated, "-")[0]); err == nil {
+	if data.DateCreated != "" {
+		if year, err := strconv.Atoi(strings.Split(data.DateCreated, "-")[0]); err == nil {
 			movie.Year = year
 		}
 	}
···
 		return fmt.Errorf("rate limit wait failed: %w", err)
 	}
 
-	_, err := FetchHTML("https://www.rottentomatoes.com")
+	_, err := s.fetcher.MakeRequest(s.baseURL)
 	return err
 }
 
···
 
 // NewTVService creates a new TV service with rate limiting
 func NewTVService() *TVService {
+	return NewTVServiceWithDeps("https://www.rottentomatoes.com", &DefaultFetcher{}, &DefaultFetcher{})
+}
+
+// NewTVServiceWithDeps creates a new TV service with custom dependencies (for testing)
+func NewTVServiceWithDeps(baseURL string, fetcher Fetchable, searcher Searchable) *TVService {
 	return &TVService{
-		client: &http.Client{
-			Timeout: 30 * time.Second,
-		},
-		limiter: rate.NewLimiter(rate.Limit(requestsPerSecond), burstLimit),
+		client:   &http.Client{Timeout: 30 * time.Second},
+		limiter:  rate.NewLimiter(rate.Limit(requestsPerSecond), burstLimit),
+		baseURL:  baseURL,
+		fetcher:  fetcher,
+		searcher: searcher,
 	}
 }
 
···
 		return nil, fmt.Errorf("rate limit wait failed: %w", err)
 	}
 
-	results, err := SearchRottenTomatoes(query)
+	results, err := s.searcher.Search(query)
 	if err != nil {
 		return nil, fmt.Errorf("failed to search rotten tomatoes: %w", err)
 	}
···
 		return nil, fmt.Errorf("rate limit wait failed: %w", err)
 	}
 
-	seriesData, err := FetchTVSeries(id)
+	seriesData, err := s.fetcher.TVRequest(id)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch tv series: %w", err)
 	}
···
 		return fmt.Errorf("rate limit wait failed: %w", err)
 	}
 
-	_, err := FetchHTML("https://www.rottentomatoes.com")
+	_, err := s.fetcher.MakeRequest(s.baseURL)
 	return err
 }
 

internal/services/services.go

···
 type BookService struct {
 	client  *http.Client
 	limiter *rate.Limiter
-	baseURL string // Allows configurable base URL for testing
+	baseURL string
 }
 
 // NewBookService creates a new book service with rate limiting
 func NewBookService(baseURL string) *BookService {
 	return &BookService{
-		client: &http.Client{
-			Timeout: 30 * time.Second,
-		},
+		client:  &http.Client{Timeout: 30 * time.Second},
 		limiter: rate.NewLimiter(rate.Limit(requestsPerSecond), burstLimit),
 		baseURL: baseURL,
 	}