Skill: Goca Code Generation Testing

Domain: Writing tests for Goca's code generation pipeline. Covers unit tests for validators and template generators, and integration tests that verify generated code compiles and is functionally correct.

Testing Philosophy for Code Generators

Goca generates code, so tests have two distinct layers:

1. Generator tests — verify the generator produces the right output strings
2. Compilation tests — verify the generated output actually compiles as valid Go

Both layers are mandatory. A generator test alone is insufficient — template changes can produce syntactically correct template output but invalid Go code.

Unit Test Patterns

Testing CommandValidator

func TestCommandValidator_ValidateEntityName(t *testing.T) {
    t.Parallel()
    v := NewCommandValidator()

    cases := []struct {
        name    string
        input   string
        wantErr bool
    }{
        {"valid", "Product", false},
        {"valid with numbers", "Product1", false},
        {"empty", "", true},
        {"starts with digit", "1Product", true},
        {"path traversal", "../etc", true},
        {"slash", "foo/bar", true},
        {"dot", "foo.bar", true},
        {"underscore", "foo_bar", false}, // or true depending on your convention
        {"very long", strings.Repeat("A", 1000), true},
        {"null byte", "Product\x00Name", true},
        {"shell meta", "Product;rm -rf /", true},
    }

    for _, tc := range cases {
        tc := tc
        t.Run(tc.name, func(t *testing.T) {
            t.Parallel()
            err := v.ValidateEntityName(tc.input)
            if tc.wantErr {
                assert.Error(t, err)
            } else {
                assert.NoError(t, err)
            }
        })
    }
}

Testing FieldValidator

func TestFieldValidator_ParseFields(t *testing.T) {
    t.Parallel()
    v := NewFieldValidator()

    cases := []struct {
        name       string
        input      string
        wantLen    int
        wantFirst  FieldData
        wantErr    bool
    }{
        {
            name:    "single field",
            input:   "Name:string",
            wantLen: 1,
            wantFirst: FieldData{Name: "Name", Type: "string"},
        },
        {
            name:    "multiple fields",
            input:   "Name:string,Price:float64,Active:bool",
            wantLen: 3,
        },
        {
            name:    "pointer type",
            input:   "Parent:*Category",
            wantLen: 1,
        },
        {
            name:    "map type",
            input:   "Meta:map[string]string",
            wantLen: 1,
        },
        {
            name:    "empty",
            input:   "",
            wantLen: 0,
        },
        {
            name:    "missing type",
            input:   "Name:",
            wantErr: true,
        },
    }
    // ...
}

Testing TemplateGenerator

func TestTemplateGenerator_EntityTemplate(t *testing.T) {
    t.Parallel()

    data := TemplateData{
        Entity: EntityData{
            Name:      "Product",
            NameLower: "product",
            Package:   "domain",
        },
        Fields: []FieldData{
            {Name: "Name", Type: "string", JSONTag: "name", GormTag: "type:varchar(255)"},
            {Name: "Price", Type: "float64", JSONTag: "price", GormTag: "type:decimal(10,2)"},
        },
        Module: "github.com/test/myapp",
        Features: FeatureFlags{Timestamps: true},
    }

    gen := NewTemplateGenerator()
    output, err := gen.GenerateFromTemplate(entityTemplate, data)
    require.NoError(t, err)

    // Verify key patterns in output
    assert.Contains(t, output, "type Product struct")
    assert.Contains(t, output, "Name  string")
    assert.Contains(t, output, "Price float64")
    assert.Contains(t, output, "CreatedAt time.Time") // timestamps enabled
    assert.Contains(t, output, "package domain")
    assert.NotContains(t, output, "{{") // no unrendered template vars
}

Testing Empty Fields Edge Case

func TestTemplateGenerator_EmptyFields(t *testing.T) {
    t.Parallel()

    data := TemplateData{
        Entity: EntityData{Name: "Empty", NameLower: "empty", Package: "domain"},
        Fields: []FieldData{}, // zero fields
        Module: "github.com/test/myapp",
    }

    gen := NewTemplateGenerator()
    output, err := gen.GenerateFromTemplate(entityTemplate, data)
    require.NoError(t, err)

    assert.Contains(t, output, "type Empty struct {")
    assert.NotContains(t, output, "{{") // no unrendered vars
}

Integration Test Patterns

Minimal Go Module Initialization

Every integration test needs a valid Go module to compile generated code in:

func initTestModule(t *testing.T, dir, moduleName string) {
    t.Helper()
    cmd := exec.Command("go", "mod", "init", moduleName)
    cmd.Dir = dir
    out, err := cmd.CombinedOutput()
    require.NoError(t, err, "go mod init failed: %s", string(out))
}

Compilation Verification Helper

func assertCompilesClean(t *testing.T, dir string) {
    t.Helper()

    // go build
    buildCmd := exec.Command("go", "build", "./...")
    buildCmd.Dir = dir
    buildOut, err := buildCmd.CombinedOutput()
    require.NoError(t, err, "go build failed:\n%s", string(buildOut))

    // go vet
    vetCmd := exec.Command("go", "vet", "./...")
    vetCmd.Dir = dir
    vetOut, err := vetCmd.CombinedOutput()
    require.NoError(t, err, "go vet failed:\n%s", string(vetOut))
}

Full Feature Integration Test

func TestFeatureCommand_GeneratesAndCompiles(t *testing.T) {
    dir := t.TempDir()
    initTestModule(t, dir, "testapp")

    // Run goca feature
    goca := exec.Command("goca", "feature", "Product",
        "--fields", "Name:string,Price:float64",
        "--database", "sqlite",
        "--handlers", "http",
    )
    goca.Dir = dir
    out, err := goca.CombinedOutput()
    require.NoError(t, err, "goca feature failed:\n%s", string(out))

    // Check files exist
    expectedFiles := []string{
        "internal/domain/product.go",
        "internal/usecase/product_service.go",
        "internal/repository/interfaces.go",
        "internal/handler/http/product_handler.go",
    }
    for _, f := range expectedFiles {
        assert.FileExists(t, filepath.Join(dir, f))
    }

    // Verify output contains no template artifacts
    for _, f := range expectedFiles {
        content, err := os.ReadFile(filepath.Join(dir, f))
        require.NoError(t, err)
        assert.NotContains(t, string(content), "{{", "unrendered template in %s", f)
        assert.NotContains(t, string(content), "}}", "unrendered template in %s", f)
    }

    // Run go mod tidy to get dependencies
    tidyCmd := exec.Command("go", "mod", "tidy")
    tidyCmd.Dir = dir
    tidyCmd.CombinedOutput() // ignore errors from missing real deps

    assertCompilesClean(t, dir)
}

Safety Manager Integration Test Pattern

func TestSafetyManager_DryRunPreventsDiskWrite(t *testing.T) {
    t.Parallel()
    dir := t.TempDir()
    sm := NewSafetyManager(true, false, false) // dryRun=true

    filePath := filepath.Join(dir, "output.go")
    err := sm.WriteFile(filePath, "package test\n")
    require.NoError(t, err, "dry-run should not error")

    // File must NOT exist on disk
    _, statErr := os.Stat(filePath)
    assert.True(t, os.IsNotExist(statErr), "file should not exist in dry-run mode")

    // But should be recorded in created files list
    assert.Contains(t, sm.GetCreatedFiles(), filePath)
}

Template Content Verification Patterns

Use specific string assertions to verify generated code structure:

// Verify struct fields
assert.Regexp(t, `Name\s+string\s+\x60json:"name"`, output)

// Verify method signatures
assert.Contains(t, output, "func (s *productService) Create(")
assert.Contains(t, output, "func NewProductService(repo repository.ProductRepository)")

// Verify import presence
assert.Regexp(t, `"gorm\.io/gorm"`, output)

// Verify no template artifacts
assert.NotRegexp(t, `\{\{[^}]+\}\}`, output, "unrendered template variables found")

Mock Tests

type MockRepository struct {
    mock.Mock
}

func (m *MockRepository) Create(entity *domain.Product) (*domain.Product, error) {
    args := m.Called(entity)
    return args.Get(0).(*domain.Product), args.Error(1)
}

func TestProductService_Create_ValidInput(t *testing.T) {
    t.Parallel()

    mockRepo := new(MockRepository)
    svc := NewProductService(mockRepo)

    input := CreateProductInput{Name: "Widget", Price: 9.99}
    expected := &domain.Product{ID: 1, Name: "Widget", Price: 9.99}

    mockRepo.On("Create", mock.AnythingOfType("*domain.Product")).Return(expected, nil)

    result, err := svc.Create(input)
    require.NoError(t, err)
    assert.Equal(t, expected.Name, result.Name)
    mockRepo.AssertExpectations(t)
}