tdd-workflow

Files (1)

• SKILL.md

SKILL.md (first lines)

# TDD Workflow

Detailed workflow for Test-Driven Development. For core principles, see `../../rules/test-driven-development.mdc`.

---

## The Cycle

```
RED (failing test) → GREEN (minimal code) → REFACTOR (clean up) → Repeat
```

---

## RED Phase - Write Failing Test

Write one minimal test showing what should happen.

### Good Example

```go
func TestRetryOperation_WithFailingOperation_RetriesThreeTimes(t *testing.T) {
    t.Run("retries until success", func(t *testing.T) {
        attempts := 0
        operation := func() (string, error) {
            attempts++
            if attempts < 3 {
                return "", errors.New("fail")
            }
            return "success", nil
        }

        result, err := RetryOperation(operation)

        assert.NoError(t, err)
        assert.Equal(t, "success", result)
        assert.Equal(t, 3, attempts)
    })
}
```
Clear name, tests real behavior, one thing.

### Bad Example

```go
func TestRetry(t *testing.T) {
    t.Run("works", func(t *testing.T) {
        mockFn := new(mocks.MockOperation)
        mockFn.On("Execute").Return("", errors.New("fail")).Twice()
        mockFn.On("Execute").Return("success", nil).Once()

        RetryOperation(mockFn.Execute)

        mockFn.AssertNumberOfCalls(t, "Execute", 3)
    })
}
```
Vague name, tests mock not code.

**Do not use string-based expectations like `On("MethodName", ...)`.** For Go, use gomock with generated mocks and `EXPECT().MethodName(...)` so refactoring method names causes compile errors. See go-testing-practices.mdc.

### RED Phase Requirements

- One behavior per test
- Clear, descriptive name
- Real code (no mocks unless unavoidable)

---

## Verify RED - Watch It Fail

**MANDATORY. Never skip.**

```bash
go test -v ./path/to/package -run TestRetryOperation
```

Confirm:
- Test fails (not errors)
- Failure message is expected
- Fails because feature missing (not typos)

**Test passes?** You're testing existing behavior. Fix test.

**Test errors?** Fix error, re-run until it fails correctly.

---

## GREEN Phase - Minimal Code

Write simplest code to pass the test.

### Good Example

```go
func RetryOperation(fn func() (string, error)) (string, error) {
    for i := 0; i < 3; i++ {
        result, err := fn()
        if err == nil {
            return result, nil
        }
        if i == 2 {
            return "", err
        }
    }
    return "", errors.New("unreachable")
}
```
Just enough to pass.

### Bad Example

```go
func RetryOperation(
    fn func() (string, error),
    opts ...RetryOption,
) (string, error) {
    config := &RetryConfig{
        MaxRetries: 3,

From pedromsmoreira/ai-configs, MIT.

More from pedromsmoreira/ai-configs