codegen-testing

Files (1)

• SKILL.md

SKILL.md (first lines)

# 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`

```go
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`

```go
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`

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

    data := TemplateData{
        Entity: EntityData{
            Name:      "Product",
            NameLower: "product",
            Package:   "domain",

From sazardev/goca, MIT.

More from sazardev/goca