build: add tests for shared utilities & main

cmd/commands_test.go

···
 	}
 }
 
+func createTestConfigHandler(t *testing.T) (*handlers.ConfigHandler, func()) {
+	cleanup := setupCommandTest(t)
+	handler, err := handlers.NewConfigHandler()
+	if err != nil {
+		cleanup()
+		t.Fatalf("failed to create test config handler: %v", err)
+	}
+	return handler, cleanup
+}
+
 func findSubcommand(commands []string, target string) bool {
 	return slices.Contains(commands, target)
 }
···
 			err := cmd.Execute()
 			if err == nil {
 				t.Error("expected task done command to fail with non-existent ID")
+			}
+		})
+	})
+
+	t.Run("Config Command", func(t *testing.T) {
+		handler, cleanup := createTestConfigHandler(t)
+		defer cleanup()
+
+		cmd := NewConfigCommand(handler).Create()
+
+		if cmd.Use != "config" {
+			t.Errorf("expected Use 'config', got %s", cmd.Use)
+		}
+		if cmd.Short == "" {
+			t.Errorf("expected Short description to be set")
+		}
+		if len(cmd.Commands()) == 0 {
+			t.Errorf("expected subcommands to be registered")
+		}
+
+		t.Run("path command", func(t *testing.T) {
+			cmd.SetArgs([]string{"path"})
+			if err := cmd.Execute(); err != nil {
+				t.Errorf("config path failed: %v", err)
+			}
+		})
+
+		t.Run("get with no args", func(t *testing.T) {
+			cmd.SetArgs([]string{"get"})
+			if err := cmd.Execute(); err != nil {
+				t.Errorf("config get with no args failed: %v", err)
+			}
+		})
+
+		t.Run("set and get roundtrip", func(t *testing.T) {
+			cmd.SetArgs([]string{"set", "editor", "vim"})
+			if err := cmd.Execute(); err != nil {
+				t.Fatalf("config set failed: %v", err)
+			}
+
+			cmd.SetArgs([]string{"get", "editor"})
+			if err := cmd.Execute(); err != nil {
+				t.Errorf("config get after set failed: %v", err)
+			}
+		})
+
+		t.Run("reset command", func(t *testing.T) {
+			cmd.SetArgs([]string{"reset"})
+			if err := cmd.Execute(); err != nil {
+				t.Errorf("config reset failed: %v", err)
 			}
 		})
 	})

cmd/main.go

···
 	"github.com/stormlightlabs/noteleaf/internal/utils"
 )
 
+var (
+	newTaskHandler    = handlers.NewTaskHandler
+	newMovieHandler   = handlers.NewMovieHandler
+	newTVHandler      = handlers.NewTVHandler
+	newNoteHandler    = handlers.NewNoteHandler
+	newBookHandler    = handlers.NewBookHandler
+	newArticleHandler = handlers.NewArticleHandler
+	exc               = fang.Execute
+)
+
 // App represents the main CLI application
 type App struct {
 	db     *store.Database
 	config *store.Config
 }
 
-// NewApp creates a new CLI application instance
+// NewApp creates a new CLI application instance ([App])
 func NewApp() (*App, error) {
 	db, err := store.NewDatabase()
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize database: %w", err)
 	}
 
-	if config, err := store.LoadConfig(); err != nil {
+	config, err := store.LoadConfig()
+	if err != nil {
 		return nil, fmt.Errorf("failed to load configuration: %w", err)
-	} else {
-		return &App{db, config}, nil
 	}
+
+	return &App{db, config}, nil
 }
 
 // Close cleans up application resources
···
 		Use:   "status",
 		Short: "Show application status and configuration",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return handlers.Status(cmd.Context(), args)
+			return handlers.Status(cmd.Context(), args, cmd.OutOrStdout())
 		},
 	}
 }
···
 			}
 
 			output := strings.Join(args, " ")
-			fmt.Println(output)
+			fmt.Fprintln(c.OutOrStdout(), output)
 			return nil
 		},
 	}
···
 	return NewConfigCommand(handler).Create()
 }
 
-func main() {
+func run() int {
 	logger := utils.NewLogger("info", "text")
 	utils.Logger = logger
 
 	app, err := NewApp()
 	if err != nil {
-		logger.Fatal("Failed to initialize application", "error", err)
+		logger.Error("Failed to initialize application", "error", err)
+		return 1
 	}
 	defer app.Close()
 
-	taskHandler, err := handlers.NewTaskHandler()
+	taskHandler, err := newTaskHandler()
 	if err != nil {
-		log.Fatalf("failed to create task handler: %v", err)
+		log.Error("failed to create task handler", "err", err)
+		return 1
 	}
 
-	movieHandler, err := handlers.NewMovieHandler()
+	movieHandler, err := newMovieHandler()
 	if err != nil {
-		log.Fatalf("failed to create movie handler: %v", err)
+		log.Error("failed to create movie handler", "err", err)
+		return 1
 	}
 
-	tvHandler, err := handlers.NewTVHandler()
+	tvHandler, err := newTVHandler()
 	if err != nil {
-		log.Fatalf("failed to create TV handler: %v", err)
+		log.Error("failed to create TV handler", "err", err)
+		return 1
 	}
 
-	noteHandler, err := handlers.NewNoteHandler()
+	noteHandler, err := newNoteHandler()
 	if err != nil {
-		log.Fatalf("failed to create note handler: %v", err)
+		log.Error("failed to create note handler", "err", err)
+		return 1
 	}
 
-	bookHandler, err := handlers.NewBookHandler()
+	bookHandler, err := newBookHandler()
 	if err != nil {
-		log.Fatalf("failed to create book handler: %v", err)
+		log.Error("failed to create book handler", "err", err)
+		return 1
 	}
 
-	articleHandler, err := handlers.NewArticleHandler()
+	articleHandler, err := newArticleHandler()
 	if err != nil {
-		log.Fatalf("failed to create article handler: %v", err)
+		log.Error("failed to create article handler", "err", err)
+		return 1
 	}
 
 	root := rootCmd()
 
 	coreGroups := []CommandGroup{
-		NewTaskCommand(taskHandler),
-		NewNoteCommand(noteHandler),
-		NewArticleCommand(articleHandler),
+		NewTaskCommand(taskHandler), NewNoteCommand(noteHandler), NewArticleCommand(articleHandler),
 	}
 
 	for _, group := range coreGroups {
···
 		fang.WithColorSchemeFunc(ui.NoteleafColorScheme),
 	}
 
-	if err := fang.Execute(context.Background(), root, opts...); err != nil {
-		os.Exit(1)
+	if err := exc(context.Background(), root, opts...); err != nil {
+		return 1
 	}
+	return 0
+}
+
+func main() {
+	os.Exit(run())
 }

cmd/main_test.go

···
+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/fang"
+	"github.com/spf13/cobra"
+	"github.com/stormlightlabs/noteleaf/internal/handlers"
+	"github.com/stormlightlabs/noteleaf/internal/store"
+)
+
+func executeCommand(t *testing.T, cmd *cobra.Command, args ...string) string {
+	buf := &bytes.Buffer{}
+	cmd.SetOut(buf)
+	cmd.SetArgs(args)
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("command %q failed: %v", args, err)
+	}
+	return buf.String()
+}
+
+func TestNewApp(t *testing.T) {
+	t.Run("Success", func(t *testing.T) {
+		origDB := store.NewDatabase
+		origConfig := store.LoadConfig
+		defer func() {
+			store.NewDatabase = origDB
+			store.LoadConfig = origConfig
+		}()
+
+		store.NewDatabase = func() (*store.Database, error) { return &store.Database{}, nil }
+		store.LoadConfig = func() (*store.Config, error) { return &store.Config{}, nil }
+
+		app, err := NewApp()
+		if err != nil {
+			t.Fatalf("expected no error, got %v", err)
+		}
+		if app.db == nil || app.config == nil {
+			t.Fatalf("expected db and config to be initialized")
+		}
+	})
+
+	t.Run("DBError", func(t *testing.T) {
+		origDB := store.NewDatabase
+		defer func() { store.NewDatabase = origDB }()
+		store.NewDatabase = func() (*store.Database, error) { return nil, errors.New("db boom") }
+
+		_, err := NewApp()
+		if err == nil || !strings.Contains(err.Error(), "failed to initialize database") {
+			t.Errorf("expected db init error, got %v", err)
+		}
+	})
+
+	t.Run("ConfigError", func(t *testing.T) {
+		origDB := store.NewDatabase
+		origConfig := store.LoadConfig
+		defer func() {
+			store.NewDatabase = origDB
+			store.LoadConfig = origConfig
+		}()
+		store.NewDatabase = func() (*store.Database, error) { return &store.Database{}, nil }
+		store.LoadConfig = func() (*store.Config, error) { return nil, errors.New("config boom") }
+
+		_, err := NewApp()
+		if err == nil || !strings.Contains(err.Error(), "failed to load configuration") {
+			t.Errorf("expected config load error, got %v", err)
+		}
+	})
+}
+
+func TestRootCmd(t *testing.T) {
+	t.Run("Help", func(t *testing.T) {
+		root := rootCmd()
+		root.SetArgs([]string{})
+		if err := root.Execute(); err != nil {
+			t.Fatalf("expected no error, got %v", err)
+		}
+	})
+
+	t.Run("PrintArgs", func(t *testing.T) {
+		root := rootCmd()
+		root.SetArgs([]string{"hello", "world"})
+		buf := &bytes.Buffer{}
+		root.SetOut(buf)
+
+		if err := root.Execute(); err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if got := buf.String(); !strings.Contains(got, "hello world") {
+			t.Errorf("expected output to contain 'hello world', got %q", got)
+		}
+	})
+}
+
+func TestStatusCmd(t *testing.T) {
+	output := executeCommand(t, statusCmd(), nil...)
+	if output == "" {
+		t.Errorf("expected some status output, got empty string")
+	}
+}
+
+func TestResetCmd(t *testing.T) {
+	_ = executeCommand(t, resetCmd(), nil...)
+}
+
+func TestSetupCmd(t *testing.T) {
+	_ = executeCommand(t, setupCmd(), nil...)
+}
+
+func TestConfCmd(t *testing.T) {
+	cmd := confCmd()
+	buf := &bytes.Buffer{}
+	cmd.SetOut(buf)
+	cmd.SetArgs([]string{"path"})
+
+	if err := cmd.Execute(); err != nil {
+		t.Errorf("config path command failed: %v", err)
+	}
+}
+
+func TestRun(t *testing.T) {
+	t.Run("Success", func(t *testing.T) {
+		code := run()
+		if code != 0 {
+			t.Errorf("expected exit code 0, got %d", code)
+		}
+	})
+
+	t.Run("TaskHandlerError", func(t *testing.T) {
+		orig := newTaskHandler
+		defer func() { newTaskHandler = orig }()
+		newTaskHandler = func() (*handlers.TaskHandler, error) { return nil, errors.New("boom") }
+
+		if code := run(); code != 1 {
+			t.Errorf("expected exit code 1, got %d", code)
+		}
+	})
+
+	t.Run("MovieHandlerError", func(t *testing.T) {
+		orig := newMovieHandler
+		defer func() { newMovieHandler = orig }()
+		newMovieHandler = func() (*handlers.MovieHandler, error) { return nil, errors.New("boom") }
+
+		if code := run(); code != 1 {
+			t.Errorf("expected exit code 1, got %d", code)
+		}
+	})
+
+	t.Run("TVHandlerError", func(t *testing.T) {
+		orig := newTVHandler
+		defer func() { newTVHandler = orig }()
+		newTVHandler = func() (*handlers.TVHandler, error) { return nil, errors.New("boom") }
+
+		if code := run(); code != 1 {
+			t.Errorf("expected exit code 1, got %d", code)
+		}
+	})
+
+	t.Run("NoteHandlerError", func(t *testing.T) {
+		orig := newNoteHandler
+		defer func() { newNoteHandler = orig }()
+		newNoteHandler = func() (*handlers.NoteHandler, error) { return nil, errors.New("boom") }
+
+		if code := run(); code != 1 {
+			t.Errorf("expected exit code 1, got %d", code)
+		}
+	})
+
+	t.Run("BookHandlerError", func(t *testing.T) {
+		orig := newBookHandler
+		defer func() { newBookHandler = orig }()
+		newBookHandler = func() (*handlers.BookHandler, error) { return nil, errors.New("boom") }
+
+		if code := run(); code != 1 {
+			t.Errorf("expected exit code 1, got %d", code)
+		}
+	})
+
+	t.Run("ArticleHandlerError", func(t *testing.T) {
+		orig := newArticleHandler
+		defer func() { newArticleHandler = orig }()
+		newArticleHandler = func() (*handlers.ArticleHandler, error) { return nil, errors.New("boom") }
+
+		if code := run(); code != 1 {
+			t.Errorf("expected exit code 1, got %d", code)
+		}
+	})
+
+	t.Run("FangExecuteError", func(t *testing.T) {
+		orig := exc
+		defer func() { exc = orig }()
+		exc = func(ctx context.Context, cmd *cobra.Command, opts ...fang.Option) error {
+			return errors.New("fang failed")
+		}
+
+		if code := run(); code != 1 {
+			t.Errorf("expected exit code 1, got %d", code)
+		}
+	})
+}

codecov.yml

···
   - "**/*_test.go"
   - "**/testdata/**"
   - "**/vendor/**"
-  - "cmd/main.go"
   - "internal/**/test_utilities.go"

internal/handlers/config.go

···
 	"github.com/stormlightlabs/noteleaf/internal/store"
 )
 
-// ConfigHandler handles configuration-related operations
+// ConfigHandler handles [store.Config]-related operations
 type ConfigHandler struct {
 	config *store.Config
 }
 
-// NewConfigHandler creates a new ConfigHandler
+// NewConfigHandler creates a new [ConfigHandler]
 func NewConfigHandler() (*ConfigHandler, error) {
 	config, err := store.LoadConfig()
 	if err != nil {
 		return nil, fmt.Errorf("failed to load config: %w", err)
 	}
 
-	return &ConfigHandler{
-		config: config,
-	}, nil
+	return &ConfigHandler{config: config}, nil
 }
 
 // Get displays one or all configuration values
 func (h *ConfigHandler) Get(key string) error {
 	if key == "" {
-		// Display all configuration values
 		return h.displayAll()
 	}
 
-	// Display specific key
 	value, err := h.getConfigValue(key)
 	if err != nil {
 		return err
···
 		field := t.Field(i)
 		value := v.Field(i)
 
-		// Get the TOML tag name
 		tomlTag := field.Tag.Get("toml")
 		if tomlTag == "" {
 			continue
 		}
 
-		// Remove ",omitempty" suffix if present
 		tagName := strings.Split(tomlTag, ",")[0]
 
-		// Format the output based on field type
 		switch value.Kind() {
 		case reflect.String:
 			if value.String() != "" {
···
 	v := reflect.ValueOf(*h.config)
 	t := reflect.TypeOf(*h.config)
 
-	// Find the field with matching TOML tag
 	for i := 0; i < v.NumField(); i++ {
 		field := t.Field(i)
 		tomlTag := field.Tag.Get("toml")
···
 	v := reflect.ValueOf(h.config).Elem()
 	t := reflect.TypeOf(*h.config)
 
-	// Find the field with matching TOML tag
 	for i := 0; i < v.NumField(); i++ {
 		field := t.Field(i)
 		tomlTag := field.Tag.Get("toml")
···
 		if tagName == key {
 			fieldValue := v.Field(i)
 
-			// Set the value based on field type
 			switch fieldValue.Kind() {
 			case reflect.String:
 				fieldValue.SetString(value)

internal/handlers/handlers.go

···
 import (
 	"context"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 
···
 }
 
 // Status shows the current application status
-func Status(ctx context.Context, args []string) error {
+func Status(ctx context.Context, args []string, w io.Writer) error {
 	configDir, err := store.GetConfigDir()
 	if err != nil {
 		return fmt.Errorf("failed to get config directory: %w", err)
···
 
 	fmt.Printf("Config directory: %s\n", configDir)
 
-	// Load config to determine the actual database path
 	config, err := store.LoadConfig()
 	if err != nil {
 		return fmt.Errorf("failed to load configuration: %w", err)
 	}
 
-	// Determine database path using the same logic as NewDatabase
 	var dbPath string
 	if config.DatabasePath != "" {
 		dbPath = config.DatabasePath
···
 	}
 
 	if _, err := os.Stat(dbPath); err != nil {
-		fmt.Println("Database: Not found")
-		fmt.Println("Run 'noteleaf setup' to initialize.")
+		fmt.Fprintln(w, "Database: Not found")
+		fmt.Fprintln(w, "Run 'noteleaf setup' to initialize.")
 		return nil
 	}
 
-	fmt.Printf("Database: %s\n", dbPath)
+	fmt.Fprintf(w, "Database: %s\n", dbPath)
 
 	configPath, err := store.GetConfigPath()
 	if err != nil {
···
 	}
 
 	if _, err := os.Stat(configPath); err != nil {
-		fmt.Println("Configuration: Not found")
+		fmt.Fprintln(w, "Configuration: Not found")
 	} else {
-		fmt.Printf("Configuration: %s\n", configPath)
+		fmt.Fprintf(w, "Configuration: %s\n", configPath)
 	}
 
 	db, err := store.NewDatabase()
···
 		return fmt.Errorf("failed to get available migrations: %w", err)
 	}
 
-	fmt.Printf("Migrations: %d/%d applied\n", len(applied), len(available))
+	fmt.Fprintf(w, "Migrations: %d/%d applied\n", len(applied), len(available))
 
 	return nil
 }

internal/handlers/handlers_test.go

···
 package handlers
 
 import (
+	"bytes"
 	"context"
 	"os"
 	"path/filepath"
···
 	t.Run("reports status when setup", func(t *testing.T) {
 		_ = createTestDir(t)
 		ctx := context.Background()
+		var buf bytes.Buffer
 
 		err := Setup(ctx, []string{})
 		if err != nil {
 			t.Fatalf("Setup failed: %v", err)
 		}
 
-		err = Status(ctx, []string{})
+		err = Status(ctx, []string{}, &buf)
 		if err != nil {
 			t.Errorf("Status failed: %v", err)
 		}
···
 	t.Run("reports status when not setup", func(t *testing.T) {
 		_ = createTestDir(t)
 		ctx := context.Background()
+		var buf bytes.Buffer
 
-		err := Status(ctx, []string{})
+		err := Status(ctx, []string{}, &buf)
 		if err != nil {
 			t.Errorf("Status should not fail when not setup: %v", err)
 		}
···
 	t.Run("shows migration information", func(t *testing.T) {
 		_ = createTestDir(t)
 		ctx := context.Background()
+		var buf bytes.Buffer
 
 		err := Setup(ctx, []string{})
 		if err != nil {
 			t.Fatalf("Setup failed: %v", err)
 		}
 
-		err = Status(ctx, []string{})
+		err = Status(ctx, []string{}, &buf)
 		if err != nil {
 			t.Errorf("Status failed: %v", err)
 		}
···
 		originalNoteleafConfig := os.Getenv("NOTELEAF_CONFIG")
 		originalNoteleafDataDir := os.Getenv("NOTELEAF_DATA_DIR")
 
-		// Unset all environment variables so GetConfigDir fails
 		os.Unsetenv("NOTELEAF_CONFIG")
 		os.Unsetenv("NOTELEAF_DATA_DIR")
 
···
 			os.Setenv("HOME", originalHome)
 		}()
 
+		var buf bytes.Buffer
 		ctx := context.Background()
-		err := Status(ctx, []string{})
+		err := Status(ctx, []string{}, &buf)
 
 		if err == nil {
 			t.Error("Status should fail when GetConfigDir fails")
···
 			dbPath = filepath.Join(dataDir, "noteleaf.db")
 		}
 
-		// Remove the database file
 		os.Remove(dbPath)
 
-		// Create a directory with the same name as the database file
-		// This will cause database connection to fail
 		if err := os.MkdirAll(dbPath, 0755); err != nil {
 			t.Fatalf("Failed to create directory: %v", err)
 		}
 
-		err = Status(ctx, []string{})
+		var buf bytes.Buffer
+		err = Status(ctx, []string{}, &buf)
 		if err == nil {
 			t.Error("Status should fail when database connection fails")
 		} else if !strings.Contains(err.Error(), "failed to connect to database") && !strings.Contains(err.Error(), "failed to open database") && !strings.Contains(err.Error(), "failed to load config") {
···
 		}
 		db.Close()
 
-		err = Status(ctx, []string{})
+		var buf bytes.Buffer
+		err = Status(ctx, []string{}, &buf)
 		if err == nil {
 			t.Error("Status should fail when migration queries fail")
 		}
···
 					}
 				}
 			},
-			handlerFunc: Status,
+			handlerFunc: func(ctx context.Context, args []string) error {
+				var buf bytes.Buffer
+				return Status(ctx, args, &buf)
+			},
 			expectError: true,
 			errorSubstr: "config directory",
 		},
···
 		_ = createTestDir(t)
 		ctx := context.Background()
 
-		err := Status(ctx, []string{})
+		var buf bytes.Buffer
+		err := Status(ctx, []string{}, &buf)
 		if err != nil {
 			t.Errorf("Initial status failed: %v", err)
 		}
···
 			t.Errorf("Setup failed: %v", err)
 		}
 
-		err = Status(ctx, []string{})
+		buf.Reset()
+		err = Status(ctx, []string{}, &buf)
 		if err != nil {
 			t.Errorf("Status after setup failed: %v", err)
 		}
 
-		// Determine database path using the same logic as Setup
 		config, _ := store.LoadConfig()
 		var dbPath string
 		if config.DatabasePath != "" {
···
 			t.Error("Database should not exist after reset")
 		}
 
-		err = Status(ctx, []string{})
+		buf.Reset()
+		err = Status(ctx, []string{}, &buf)
 		if err != nil {
 			t.Errorf("Status after reset failed: %v", err)
 		}
···
 
 		done := make(chan error, 3)
 
+		var buf bytes.Buffer
 		for range 3 {
 			go func() {
 				time.Sleep(time.Millisecond * 10)
-				done <- Status(ctx, []string{})
+				done <- Status(ctx, []string{}, &buf)
 			}()
 		}
 

internal/handlers/shared.go

···
 	"github.com/charmbracelet/glamour"
 )
 
+type MarkdownRenderer interface {
+	Render(string) (string, error)
+}
+
+var newRenderer = func() (MarkdownRenderer, error) {
+	return glamour.NewTermRenderer(glamour.WithAutoStyle(), glamour.WithWordWrap(80))
+}
+
 func renderMarkdown(content string) (string, error) {
-	renderer, err := glamour.NewTermRenderer(glamour.WithAutoStyle(), glamour.WithWordWrap(80))
+	renderer, err := newRenderer()
 	if err != nil {
 		return "", fmt.Errorf("failed to create markdown renderer: %w", err)
 	}
···
 	if err != nil {
 		return "", fmt.Errorf("failed to render markdown: %w", err)
 	}
-
 	return rendered, nil
 }

internal/handlers/shared_test.go

···
 package handlers
 
 import (
+	"errors"
 	"strings"
 	"testing"
 )
···
 	contains []string
 }
 
+type fakeRenderer struct {
+	fail bool
+}
+
+func (f fakeRenderer) Render(s string) (string, error) {
+	if f.fail {
+		return "", errors.New("render error")
+	}
+	return "fake:" + s, nil
+}
+
+var defaultRenderer = newRenderer
+
 func TestRenderMarkdown(t *testing.T) {
 	tt := []renderMarkdownTC{
 		{name: "simple text", content: "Hello, world!", err: false, contains: []string{"Hello, world!"}},
···
 		{name: "code block", content: "```go\nfunc main() {\n    fmt.Println(\"Hello\")\n}\n```", err: false, contains: []string{"main", "fmt.Println"}},
 		{name: "empty string", content: "", err: false, contains: []string{}},
 		{name: "only whitespace", content: "   \n\t  \n   ", err: false, contains: []string{}},
-		{name: "mixed content", content: "# Title\n\nSome **bold** text and a [link](https://example.com)\n\n- List item", err: false,
-			contains: []string{"Title", "bold", "example.com", "List item"}}}
+		{name: "mixed content", content: "# Title\n\nSome **bold** text and a [link](https://example.com)\n\n- List item",
+			err: false, contains: []string{"Title", "bold", "example.com", "List item"}},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			defer func() { newRenderer = defaultRenderer }()
 
-	for _, tt := range tt {
-		t.Run(tt.name, func(t *testing.T) {
-			result, err := renderMarkdown(tt.content)
-			if tt.err && err == nil {
+			result, err := renderMarkdown(tc.content)
+			if tc.err && err == nil {
 				t.Fatalf("expected error, got nil")
 			}
-
-			if err != nil {
+			if !tc.err && err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
 
-			for _, want := range tt.contains {
-				if strings.Contains(result, want) {
-					continue
+			for _, want := range tc.contains {
+				if !strings.Contains(result, want) {
+					t.Fatalf("result should contain %q, got:\n%s", want, result)
 				}
-				t.Fatalf("result should contain %q, got:\n%s", want, result)
 			}
 		})
 	}
 
 	t.Run("WordWrap", func(t *testing.T) {
+		defer func() { newRenderer = defaultRenderer }()
 		text := strings.Repeat("This is a very long line that should be wrapped at 80 characters. ", 5)
 		result, err := renderMarkdown(text)
 		if err != nil {
···
 			if len(cleaned) > 85 {
 				t.Fatalf("Line at index %d is too long (%d chars): %q", i, len(cleaned), cleaned)
 			}
+		}
+	})
+
+	t.Run("RendererCreationFails", func(t *testing.T) {
+		newRenderer = func() (MarkdownRenderer, error) {
+			return nil, errors.New("forced renderer creation error")
+		}
+		_, err := renderMarkdown("test")
+		if err == nil || !strings.Contains(err.Error(), "failed to create markdown renderer") {
+			t.Fatalf("expected creation error, got %v", err)
+		}
+	})
+
+	t.Run("RenderFails", func(t *testing.T) {
+		newRenderer = func() (MarkdownRenderer, error) {
+			return fakeRenderer{fail: true}, nil
+		}
+		_, err := renderMarkdown("test")
+		if err == nil || !strings.Contains(err.Error(), "failed to render markdown") {
+			t.Fatalf("expected render error, got %v", err)
 		}
 	})
 }

internal/services/http_test.go

···
+package services
+
+import (
+	"errors"
+	"io"
+	"testing"
+)
+
+func TestHTTPFuncs(t *testing.T) {
+	origFetch := FetchHTML
+	origMovie := ExtractMovieMetadata
+	origTV := ExtractTVSeriesMetadata
+	origSeason := ExtractTVSeasonMetadata
+	origSearch := ParseSearch
+
+	defer func() {
+		FetchHTML = origFetch
+		ExtractMovieMetadata = origMovie
+		ExtractTVSeriesMetadata = origTV
+		ExtractTVSeasonMetadata = origSeason
+		ParseSearch = origSearch
+	}()
+
+	tests := []struct {
+		name      string
+		setup     func()
+		call      func() error
+		expectErr bool
+	}{
+		{
+			name: "FetchMovie success",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "<html>movie</html>", nil
+				}
+				ExtractMovieMetadata = func(r io.Reader) (*Movie, error) {
+					return &Movie{Name: "Fake Movie"}, nil
+				}
+			},
+			call: func() error {
+				m, err := FetchMovie("http://fake")
+				if err != nil {
+					return err
+				}
+				if m.Name != "Fake Movie" {
+					return errors.New("unexpected movie title")
+				}
+				return nil
+			},
+		},
+		{
+			name: "FetchMovie error from FetchHTML",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "", errors.New("boom")
+				}
+			},
+			call: func() error {
+				_, err := FetchMovie("http://fake")
+				return err
+			},
+			expectErr: true,
+		},
+		{
+			name: "FetchTVSeries success",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "<html>tv</html>", nil
+				}
+				ExtractTVSeriesMetadata = func(r io.Reader) (*TVSeries, error) {
+					return &TVSeries{Name: "Fake Series"}, nil
+				}
+			},
+			call: func() error {
+				tv, err := FetchTVSeries("http://fake")
+				if err != nil {
+					return err
+				}
+				if tv.Name != "Fake Series" {
+					return errors.New("unexpected series name")
+				}
+				return nil
+			},
+		},
+		{
+			name: "FetchTVSeries error from FetchHTML",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "", errors.New("boom")
+				}
+			},
+			call: func() error {
+				_, err := FetchTVSeries("http://fake")
+				return err
+			},
+			expectErr: true,
+		},
+		{
+			name: "FetchTVSeason success",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "<html>season</html>", nil
+				}
+				ExtractTVSeasonMetadata = func(r io.Reader) (*TVSeason, error) {
+					return &TVSeason{SeasonNumber: 1}, nil
+				}
+			},
+			call: func() error {
+				season, err := FetchTVSeason("http://fake")
+				if err != nil {
+					return err
+				}
+				if season.SeasonNumber != 1 {
+					return errors.New("unexpected season number")
+				}
+				return nil
+			},
+		},
+		{
+			name: "FetchTVSeason error from FetchHTML",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "", errors.New("boom")
+				}
+			},
+			call: func() error {
+				_, err := FetchTVSeason("http://fake")
+				return err
+			},
+			expectErr: true,
+		},
+		{
+			name: "SearchRottenTomatoes success",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "<html>search</html>", nil
+				}
+				ParseSearch = func(r io.Reader) ([]Media, error) {
+					return []Media{{Title: "Fake Result"}}, nil
+				}
+			},
+			call: func() error {
+				results, err := SearchRottenTomatoes("query")
+				if err != nil {
+					return err
+				}
+				if len(results) != 1 || results[0].Title != "Fake Result" {
+					return errors.New("unexpected search results")
+				}
+				return nil
+			},
+		},
+		{
+			name: "SearchRottenTomatoes error from FetchHTML",
+			setup: func() {
+				FetchHTML = func(url string) (string, error) {
+					return "", errors.New("boom")
+				}
+			},
+			call: func() error {
+				_, err := SearchRottenTomatoes("query")
+				return err
+			},
+			expectErr: true,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.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 {
+				t.Fatalf("expected error, got nil")
+			}
+			if !tc.expectErr && err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+		})
+	}
+}

internal/services/media.go

···
 }
 
 // ParseSearch parses Rotten Tomatoes search results HTML into Media entries.
-func ParseSearch(r io.Reader) ([]Media, error) {
+var ParseSearch = func(r io.Reader) ([]Media, error) {
 	doc, err := goquery.NewDocumentFromReader(r)
 	if err != nil {
 		return nil, err
···
 	return results, nil
 }
 
-func ExtractTVSeriesMetadata(r io.Reader) (*TVSeries, error) {
+var ExtractTVSeriesMetadata = func(r io.Reader) (*TVSeries, error) {
 	doc, err := goquery.NewDocumentFromReader(r)
 	if err != nil {
 		return nil, err
···
 	return &series, nil
 }
 
-func ExtractMovieMetadata(r io.Reader) (*Movie, error) {
+var ExtractMovieMetadata = func(r io.Reader) (*Movie, error) {
 	doc, err := goquery.NewDocumentFromReader(r)
 	if err != nil {
 		return nil, err
···
 	return &movie, nil
 }
 
-func ExtractTVSeasonMetadata(r io.Reader) (*TVSeason, error) {
+var ExtractTVSeasonMetadata = func(r io.Reader) (*TVSeason, error) {
 	doc, err := goquery.NewDocumentFromReader(r)
 	if err != nil {
 		return nil, err

internal/store/config.go

···
 }
 
 // LoadConfig loads configuration from the config directory or NOTELEAF_CONFIG path
-func LoadConfig() (*Config, error) {
+var LoadConfig = func() (*Config, error) {
 	var configPath string
 
-	// Check for NOTELEAF_CONFIG environment variable
 	if envConfigPath := os.Getenv("NOTELEAF_CONFIG"); envConfigPath != "" {
 		configPath = envConfigPath
 	} else {

internal/store/database.go

···
 }
 
 // NewDatabase creates and initializes a new database connection
-func NewDatabase() (*Database, error) {
+var NewDatabase = func() (*Database, error) {
 	return NewDatabaseWithConfig(nil)
 }