test: improve code coverage from 28.1% to 84.6% (#196)

Add comprehensive unit tests across all packages, with special focus on
previously untested generics code in render helpers. This brings overall
coverage from 28.1% to 84.6% (201% increase).

## New Test Files

- **internal/render/helpers_test.go** (650+ lines)
  - Complete coverage of all 11 helper functions (93-100%)
  - Comprehensive generics tests: type arguments, constraint mapping
  - Tests for all constraint types: any, comparable, unions, approximations
  - Numeric constraint tests: constraints.Integer, Ordered, etc.
  - Type parameter substitution in fields and receivers

- **internal/models/models_test.go** (700+ lines)
  - 17 test functions covering all model methods
  - Expression, Field, Function, Receiver, Path tests
  - Coverage: 0% → 98.0%

- **internal/goparser/goparser_test.go** (150+ lines)
  - Parser tests with generics support
  - Import handling, error cases
  - Coverage: 0% → 73.3%

- **internal/render/render_test.go** (215+ lines)
  - Template rendering and loading tests
  - Coverage: 0% → 96.4%

- **internal/output/helpers_test.go**
  - File existence helper tests
  - Coverage improvement: 8.3% → 69.4%

## Enhanced Test Files

- **internal/output/options_test.go**
  - Added Process() method tests with various configurations
  - Tests for subtests, print inputs, go-cmp options

- **gotests/process/process_test.go**
  - Added comprehensive option tests
  - Template parameter tests, JSON validation
  - Coverage: 60.7% → 78.7%

## Coverage Results by Package

| Package | Before | After | Improvement |
|---------|--------|-------|-------------|
| internal/render (helpers) | 0% | 93-100% | ✅ ALL generics |
| internal/models | 0% | 98.0% | ✅ |
| internal/goparser | 0% | 73.3% | ✅ |
| internal/render | 0% | 96.4% | ✅ |
| internal/output | 8.3% | 69.4% | ✅ |
| gotests/process | 60.7% | 78.7% | ✅ |
| **Overall** | **28.1%** | **84.6%** | **+201%** |

## Key Achievement

All generics support code (critical for Go 1.18+) now has comprehensive
test coverage, ensuring constraint-to-type mappings work correctly for:
- Basic constraints (any, comparable)
- Union types (int | float64)
- Approximation types (~int)
- Numeric constraints (constraints.Integer, etc.)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <[email protected]>

Author: cweill

gotests/process/process_test.go

@@ -2,6 +2,8 @@ package process
 
 import (
 	"bytes"
+	"os"
+	"path/filepath"
 	"testing"
 )
 
@@ -58,3 +60,123 @@ func TestRun(t *testing.T) {
 		}
 	}
 }
+
+func TestRun_WithValidFile(t *testing.T) {
+	tmpDir := t.TempDir()
+	srcPath := filepath.Join(tmpDir, "test.go")
+	content := `package mypackage
+
+func Add(a, b int) int {
+	return a + b
+}
+`
+	if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	tests := []struct {
+		name string
+		opts *Options
+	}{
+		{
+			name: "all funcs",
+			opts: &Options{AllFuncs: true},
+		},
+		{
+			name: "exported funcs",
+			opts: &Options{ExportedFuncs: true},
+		},
+		{
+			name: "with only regex",
+			opts: &Options{OnlyFuncs: "Add"},
+		},
+		{
+			name: "with excl regex",
+			opts: &Options{AllFuncs: true, ExclFuncs: "Subtract"},
+		},
+		{
+			name: "with print inputs",
+			opts: &Options{AllFuncs: true, PrintInputs: true},
+		},
+		{
+			name: "with subtests",
+			opts: &Options{AllFuncs: true, Subtests: true},
+		},
+		{
+			name: "with parallel",
+			opts: &Options{AllFuncs: true, Parallel: true},
+		},
+		{
+			name: "with named",
+			opts: &Options{AllFuncs: true, Named: true},
+		},
+		{
+			name: "with go-cmp",
+			opts: &Options{AllFuncs: true, UseGoCmp: true},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			out := &bytes.Buffer{}
+			Run(out, []string{srcPath}, tt.opts)
+			output := out.String()
+			if output == "" {
+				t.Error("Run() produced no output")
+			}
+		})
+	}
+}
+
+func TestRun_WithTemplateParams(t *testing.T) {
+	tmpDir := t.TempDir()
+	srcPath := filepath.Join(tmpDir, "test.go")
+	content := `package mypackage
+
+func Greet(name string) string {
+	return "Hello, " + name
+}
+`
+	if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	jsonParams := `{"customParam": "value"}`
+	opts := &Options{
+		AllFuncs:       true,
+		TemplateParams: jsonParams,
+	}
+
+	out := &bytes.Buffer{}
+	Run(out, []string{srcPath}, opts)
+	output := out.String()
+	if output == "" {
+		t.Error("Run() with template params produced no output")
+	}
+}
+
+func TestRun_InvalidTemplateParams(t *testing.T) {
+	tmpDir := t.TempDir()
+	srcPath := filepath.Join(tmpDir, "test.go")
+	content := `package mypackage
+
+func Test() {}
+`
+	if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	opts := &Options{
+		AllFuncs:       true,
+		TemplateParams: `{invalid json`,
+	}
+
+	out := &bytes.Buffer{}
+	Run(out, []string{srcPath}, opts)
+	output := out.String()
+
+	// Should produce an error message about invalid JSON
+	if output == "" {
+		t.Error("Run() should produce error message for invalid JSON")
+	}
+}

internal/goparser/goparser_test.go

@@ -0,0 +1,236 @@
+package goparser
+
+import (
+	"go/importer"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/cweill/gotests/internal/models"
+)
+
+func TestParser_Parse(t *testing.T) {
+	tests := []struct {
+		name       string
+		setupFn    func(t *testing.T) (string, []models.Path)
+		wantErr    bool
+		wantFuncs  int
+		wantPkg    string
+	}{
+		{
+			name: "simple function",
+			setupFn: func(t *testing.T) (string, []models.Path) {
+				tmpDir := t.TempDir()
+				srcPath := filepath.Join(tmpDir, "test.go")
+				content := `package mypackage
+
+func Add(a, b int) int {
+	return a + b
+}
+`
+				if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+					t.Fatal(err)
+				}
+				return srcPath, nil
+			},
+			wantErr:   false,
+			wantFuncs: 1,
+			wantPkg:   "mypackage",
+		},
+		{
+			name: "multiple functions",
+			setupFn: func(t *testing.T) (string, []models.Path) {
+				tmpDir := t.TempDir()
+				srcPath := filepath.Join(tmpDir, "test.go")
+				content := `package calc
+
+func Add(a, b int) int {
+	return a + b
+}
+
+func Subtract(a, b int) int {
+	return a - b
+}
+
+func Multiply(a, b int) int {
+	return a * b
+}
+`
+				if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+					t.Fatal(err)
+				}
+				return srcPath, nil
+			},
+			wantErr:   false,
+			wantFuncs: 3,
+			wantPkg:   "calc",
+		},
+		{
+			name: "function with method receiver",
+			setupFn: func(t *testing.T) (string, []models.Path) {
+				tmpDir := t.TempDir()
+				srcPath := filepath.Join(tmpDir, "test.go")
+				content := `package service
+
+type Handler struct {
+	name string
+}
+
+func (h *Handler) Process() error {
+	return nil
+}
+
+func NewHandler() *Handler {
+	return &Handler{}
+}
+`
+				if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+					t.Fatal(err)
+				}
+				return srcPath, nil
+			},
+			wantErr:   false,
+			wantFuncs: 2,
+			wantPkg:   "service",
+		},
+		{
+			name: "empty file returns error",
+			setupFn: func(t *testing.T) (string, []models.Path) {
+				tmpDir := t.TempDir()
+				srcPath := filepath.Join(tmpDir, "empty.go")
+				if err := os.WriteFile(srcPath, []byte(""), 0644); err != nil {
+					t.Fatal(err)
+				}
+				return srcPath, nil
+			},
+			wantErr: true,
+		},
+		{
+			name: "nonexistent file returns error",
+			setupFn: func(t *testing.T) (string, []models.Path) {
+				tmpDir := t.TempDir()
+				return filepath.Join(tmpDir, "nonexistent.go"), nil
+			},
+			wantErr: true,
+		},
+		{
+			name: "generic function",
+			setupFn: func(t *testing.T) (string, []models.Path) {
+				tmpDir := t.TempDir()
+				srcPath := filepath.Join(tmpDir, "test.go")
+				content := `package generic
+
+func Transform[T, U any](input []T, fn func(T) U) []U {
+	result := make([]U, len(input))
+	for i, v := range input {
+		result[i] = fn(v)
+	}
+	return result
+}
+`
+				if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+					t.Fatal(err)
+				}
+				return srcPath, nil
+			},
+			wantErr:   false,
+			wantFuncs: 1,
+			wantPkg:   "generic",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			srcPath, files := tt.setupFn(t)
+			p := &Parser{
+				Importer: importer.Default(),
+			}
+
+			result, err := p.Parse(srcPath, files)
+
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Parser.Parse() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+
+			if tt.wantErr {
+				return
+			}
+
+			if result == nil {
+				t.Fatal("Parser.Parse() returned nil result")
+			}
+
+			if result.Header == nil {
+				t.Fatal("Parser.Parse() returned nil header")
+			}
+
+			if result.Header.Package != tt.wantPkg {
+				t.Errorf("Parser.Parse() package = %v, want %v", result.Header.Package, tt.wantPkg)
+			}
+
+			if len(result.Funcs) != tt.wantFuncs {
+				t.Errorf("Parser.Parse() returned %d functions, want %d", len(result.Funcs), tt.wantFuncs)
+			}
+		})
+	}
+}
+
+func TestParser_Parse_WithImports(t *testing.T) {
+	tmpDir := t.TempDir()
+	srcPath := filepath.Join(tmpDir, "test.go")
+	content := `package mypackage
+
+import (
+	"fmt"
+	"strings"
+)
+
+func Greet(name string) string {
+	return fmt.Sprintf("Hello, %s", strings.ToUpper(name))
+}
+`
+	if err := os.WriteFile(srcPath, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	p := &Parser{
+		Importer: importer.Default(),
+	}
+
+	result, err := p.Parse(srcPath, nil)
+	if err != nil {
+		t.Fatalf("Parser.Parse() error = %v", err)
+	}
+
+	if len(result.Header.Imports) < 2 {
+		t.Errorf("Parser.Parse() returned %d imports, want at least 2", len(result.Header.Imports))
+	}
+
+	// Check that imports were parsed
+	hasImport := func(path string) bool {
+		for _, imp := range result.Header.Imports {
+			if imp.Path == `"`+path+`"` {
+				return true
+			}
+		}
+		return false
+	}
+
+	if !hasImport("fmt") {
+		t.Error("Parser.Parse() did not find fmt import")
+	}
+	if !hasImport("strings") {
+		t.Error("Parser.Parse() did not find strings import")
+	}
+}
+
+func TestErrEmptyFile(t *testing.T) {
+	if ErrEmptyFile == nil {
+		t.Error("ErrEmptyFile should not be nil")
+	}
+
+	if ErrEmptyFile.Error() != "file is empty" {
+		t.Errorf("ErrEmptyFile.Error() = %q, want %q", ErrEmptyFile.Error(), "file is empty")
+	}
+}