Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Get Started Free →

Golang Testing · aiskillstore | DecimalAI

aiskillstore/golang-testing

NewSkillScoreMaintained

Comprehensive Go testing patterns including table-driven tests, mocking, integration testing, benchmarks, and test organization.

Testingby aiskillstore

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/aiskillstore-golang-testing/SKILL.md

decimalai skills pull aiskillstore-golang-testing --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/aiskillstore-golang-testing/SKILL.md https://app.decimal.ai/s/aiskillstore-golang-testing/SKILL.md

Raw file: /s/aiskillstore-golang-testing/SKILL.md ↗ · machine-readable summary at /s/aiskillstore-golang-testing.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

22 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 8d ago

No measurable change+143% tokens0% turns86% of whole cases pass with skill (19/22)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-09	✗→✓	▲ Improved	157%	0%
case-18	✓→✗	▼ Worse	98%	0%
case-02	✓→✓	＝ Same ✓	127%	0%
case-03	✓→✓	＝ Same ✓	150%	0%
case-04	✓→✓	＝ Same ✓	260%	0%

Showing 5 of 22 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/3/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

aiskillstore / marketplace

skills/89jobrien/golang-testing/SKILL.md

View on GitHub ↗

Imported 8/3/2026Version v1

Skill contents

SKILL.md

Golang Testing

This skill provides guidance on comprehensive testing strategies for Go applications including unit tests, integration tests, benchmarks, and test organization.

When to Use This Skill

When writing unit tests for Go code
When creating table-driven tests
When mocking dependencies with interfaces
When writing integration tests with test containers
When benchmarking performance-critical code
When organizing test suites and fixtures

Table-Driven Tests

Basic Pattern

go
func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -2, -3, -5},
        {"mixed numbers", -2, 3, 1},
        {"zeros", 0, 0, 0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

With Error Cases

go
func TestDivide(t *testing.T) {
    tests := []struct {
        name      string
        a, b      int
        expected  int
        wantErr   bool
        errString string
    }{
        {"valid division", 10, 2, 5, false, ""},
        {"divide by zero", 10, 0, 0, true, "division by zero"},
        {"negative result", -10, 2, -5, false, ""},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result, err := Divide(tt.a, tt.b)

            if tt.wantErr {
                if err == nil {
                    t.Fatalf("expected error, got nil")
                }
                if !strings.Contains(err.Error(), tt.errString) {
                    t.Errorf("error = %v; want containing %q", err, tt.errString)
                }
                return
            }

            if err != nil {
                t.Fatalf("unexpected error: %v", err)
            }
            if result != tt.expected {
                t.Errorf("Divide(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

Interface-Based Mocking

Define Interfaces

go
// repository.go
type UserRepository interface {
    FindByID(ctx context.Context, id string) (*User, error)
    Save(ctx context.Context, user *User) error
}

type EmailSender interface {
    Send(ctx context.Context, to, subject, body string) error
}

Create Mock Implementations

go
// mocks/user_repository.go
type MockUserRepository struct {
    FindByIDFunc func(ctx context.Context, id string) (*User, error)
    SaveFunc     func(ctx context.Context, user *User) error
}

func (m *MockUserRepository) FindByID(ctx context.Context, id string) (*User, error) {
    if m.FindByIDFunc != nil {
        return m.FindByIDFunc(ctx, id)
    }
    return nil, nil
}

func (m *MockUserRepository) Save(ctx context.Context, user *User) error {
    if m.SaveFunc != nil {
        return m.SaveFunc(ctx, user)
    }
    return nil
}

Use in Tests

go
func TestUserService_GetUser(t *testing.T) {
    expectedUser := &User{ID: "123", Name: "John"}

    repo := &MockUserRepository{
        FindByIDFunc: func(ctx context.Context, id string) (*User, error) {
            if id == "123" {
                return expectedUser, nil
            }
            return nil, ErrNotFound
        },
    }

    service := NewUserService(repo)

    t.Run("existing user", func(t *testing.T) {
        user, err := service.GetUser(context.Background(), "123")
        if err != nil {
            t.Fatalf("unexpected error: %v", err)
        }
        if user.Name != expectedUser.Name {
            t.Errorf("got name %q; want %q", user.Name, expectedUser.Name)
        }
    })

    t.Run("non-existing user", func(t *testing.T) {
        _, err := service.GetUser(context.Background(), "456")
        if !errors.Is(err, ErrNotFound) {
            t.Errorf("got error %v; want ErrNotFound", err)
        }
    })
}

Testify Assertions

go
import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

func TestWithTestify(t *testing.T) {
    // assert continues on failure
    assert.Equal(t, 5, Add(2, 3), "addition should work")
    assert.NotNil(t, result)
    assert.Len(t, items, 3)
    assert.Contains(t, slice, item)
    assert.True(t, condition)
    assert.NoError(t, err)
    assert.ErrorIs(t, err, ErrNotFound)

    // require stops test on failure
    require.NoError(t, err, "setup must succeed")
    require.NotNil(t, config)
}

Integration Tests with Testcontainers

go
import (
    "context"
    "testing"
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/modules/postgres"
)

func TestUserRepository_Integration(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping integration test in short mode")
    }

    ctx := context.Background()

    // Start PostgreSQL container
    pgContainer, err := postgres.Run(ctx,
        "postgres:15-alpine",
        postgres.WithDatabase("testdb"),
        postgres.WithUsername("test"),
        postgres.WithPassword("test"),
    )
    require.NoError(t, err)
    defer pgContainer.Terminate(ctx)

    // Get connection string
    connStr, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
    require.NoError(t, err)

    // Connect and run migrations
    db, err := sql.Open("postgres", connStr)
    require.NoError(t, err)
    defer db.Close()

    runMigrations(db)

    // Create repository and test
    repo := NewUserRepository(db)

    t.Run("save and find user", func(t *testing.T) {
        user := &User{ID: "123", Name: "John", Email: "john@example.com"}

        err := repo.Save(ctx, user)
        require.NoError(t, err)

        found, err := repo.FindByID(ctx, "123")
        require.NoError(t, err)
        assert.Equal(t, user.Name, found.Name)
    })
}

Test Fixtures

Setup/Teardown Pattern

go
func TestMain(m *testing.M) {
    // Global setup
    setup()

    code := m.Run()

    // Global teardown
    teardown()

    os.Exit(code)
}

func setup() {
    // Initialize test database, load fixtures, etc.
}

func teardown() {
    // Clean up resources
}

Per-Test Setup

go
func setupTest(t *testing.T) (*UserService, func()) {
    t.Helper()

    db := setupTestDB(t)
    repo := NewUserRepository(db)
    service := NewUserService(repo)

    cleanup := func() {
        db.Close()
    }

    return service, cleanup
}

func TestUserService(t *testing.T) {
    service, cleanup := setupTest(t)
    defer cleanup()

    // Run tests using service
}

Benchmarks

go
func BenchmarkFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Fibonacci(20)
    }
}

func BenchmarkFibonacciParallel(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            Fibonacci(20)
        }
    })
}

// With sub-benchmarks
func BenchmarkSort(b *testing.B) {
    sizes := []int{100, 1000, 10000}

    for _, size := range sizes {
        b.Run(fmt.Sprintf("size-%d", size), func(b *testing.B) {
            data := generateData(size)
            b.ResetTimer()

            for i := 0; i < b.N; i++ {
                sort.Ints(data)
            }
        })
    }
}

Testing HTTP Handlers

go
func TestHandler_GetUser(t *testing.T) {
    // Setup mock service
    service := &MockUserService{
        GetUserFunc: func(ctx context.Context, id string) (*User, error) {
            return &User{ID: id, Name: "John"}, nil
        },
    }

    handler := NewHandler(service)

    t.Run("success", func(t *testing.T) {
        req := httptest.NewRequest(http.MethodGet, "/users/123", nil)
        rec := httptest.NewRecorder()

        handler.GetUser(rec, req)

        assert.Equal(t, http.StatusOK, rec.Code)

        var response User
        err := json.NewDecoder(rec.Body).Decode(&response)
        require.NoError(t, err)
        assert.Equal(t, "John", response.Name)
    })

    t.Run("not found", func(t *testing.T) {
        service.GetUserFunc = func(ctx context.Context, id string) (*User, error) {
            return nil, ErrNotFound
        }

        req := httptest.NewRequest(http.MethodGet, "/users/999", nil)
        rec := httptest.NewRecorder()

        handler.GetUser(rec, req)

        assert.Equal(t, http.StatusNotFound, rec.Code)
    })
}

Test Organization

File Structure

text
/internal
  /user
    user.go
    user_test.go          # Unit tests
    user_integration_test.go  # Integration tests (build tag)
    testdata/             # Test fixtures
      users.json

Build Tags for Integration Tests

go
//go:build integration

package user

func TestIntegration(t *testing.T) {
    // Integration test code
}

Run with: go test -tags=integration ./...

Coverage

bash
# Generate coverage
go test -coverprofile=coverage.out ./...

# View in browser
go tool cover -html=coverage.out

# Check coverage percentage
go test -cover ./...

Best Practices

Test behavior, not implementation - Focus on inputs and outputs
One assertion per test - Keep tests focused and clear
Use t.Helper() - Mark helper functions for better error reporting
Parallel tests - Use t.Parallel() for independent tests
Descriptive names - TestUserService_CreateUser_WithInvalidEmail
Test edge cases - Empty inputs, nil values, boundary conditions
Keep tests fast - Use mocks, skip slow tests with -short
Avoid test pollution - Each test should be independent

Want to see if aiskillstore/golang-testing would activate on your phrasing? Try it before you install — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/21/2026, 19:50 UTC · 22 cases

Lift

0%

86% vs 86%

Agent turns

0%

1.0 vs 1.0

Tokens

+143%

4,345.82 vs 1,786.5

fail → pass · 1pass → pass · 18fail → fail · 2pass → fail · 1

Per-case results (22)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-01 I have a Go function `ParseConfig(raw string) (*Config, error)` that I need to thoroughly test. Please write a Go test file that uses a table-driven pattern to cover both valid inputs and various error conditions, running each case as a subtest with descriptive test names.	fail→fail	18,422	12,821	-30%	1	1	0%	3,651	5,307	+45%	0	0	—
case-02 When writing table-driven tests in Go that check both success and error paths, what error logging call should be used when an unexpected error occurs on a non-error subtest case?	pass→pass	10,229	5,931	-42%	1	1	0%	1,726	3,918	+127%	0	0	—
case-03 I need to unit test a Go service depending on a `Repository` interface with a `Save(ctx context.Context, item *Item) error` method. Write a manual struct mock without using external mock generation packages.	pass→pass	12,748	15,284	+20%	1	1	0%	2,425	6,065	+150%	0	0	—
case-04 Write a Go integration test function `TestDatabaseQuery` that checks a fast-test CLI flag and skips execution if short test mode is enabled.	pass→pass	7,286	8,014	+10%	1	1	0%	1,182	4,257	+260%	0	0	—
case-05 Write a Go integration test function that programmatically starts an isolated PostgreSQL 15 container, configures database credentials, and obtains its database connection string.	pass→pass	12,131	10,099	-17%	1	1	0%	2,569	4,958	+93%	0	0	—
case-06 In a Go integration test using programmatic Docker containers, how should container resource cleanup be handled to prevent container leaks upon test completion?	fail→fail	16,698	14,321	-14%	1	1	0%	2,833	5,414	+91%	0	0	—
case-07 Write a Go `TestMain` function for package-level setup and teardown that runs all tests and exits with the appropriate status code.	pass→pass	9,696	6,095	-37%	1	1	0%	1,721	3,934	+129%	0	0	—
case-08 Write a Go helper function `newTestClient(t *testing.T)` that sets up dependencies for subtests. How do you instruct the testing framework to report caller line numbers for failures inside the helper?	pass→pass	8,494	8,275	-3%	1	1	0%	1,490	4,389	+195%	0	0	—
case-09 Write the signature and structure for a Go per-test setup helper `setupService(t *testing.T)` that initializes a service and provides resource cleanup to the calling test.	fail→pass	9,537	8,102	-15%	1	1	0%	1,584	4,067	+157%	0	0	—
case-10 Write a standard Go benchmark function `BenchmarkCalculate` measuring performance of `Calculate(20)`.	pass→pass	4,678	4,374	-6%	1	1	0%	789	3,632	+360%	0	0	—
case-11 Write a Go benchmark function `BenchmarkCryptoHash` that executes hash calculations concurrently across multiple goroutines.	pass→pass	9,088	11,427	+26%	1	1	0%	1,557	4,303	+176%	0	0	—
case-12 Write a Go benchmark `BenchmarkSort` that runs sub-benchmarks across slice sizes 100, 1000, and 10000, ensuring slice allocation time is excluded from timings.	pass→pass	9,069	9,919	+9%	1	1	0%	1,656	4,692	+183%	0	0	—
case-13 Write a Go unit test `TestGetUserHandler` for an HTTP handler function `GetUser(w http.ResponseWriter, r *http.Request)`. Record the HTTP response and decode the returned JSON body into a User struct.	pass→pass	8,094	10,082	+25%	1	1	0%	1,750	4,866	+178%	0	0	—
case-14 When using testifying assertion functions in Go tests, when should `require` functions be used instead of `assert` functions?	pass→pass	11,685	10,186	-13%	1	1	0%	1,930	4,692	+143%	0	0	—
case-15 Provide the build tag line required at the top of a Go integration test file so it is excluded from standard `go test ./...` runs in Go 1.17+.	pass→pass	7,044	2,615	-63%	1	1	0%	648	3,327	+413%	0	0	—
case-16 What exact `go test` command executes tests tagged with `integration` across all subpackages in a Go module?	pass→pass	6,085	3,211	-47%	1	1	0%	984	3,406	+246%	0	0	—
case-17 What CLI commands generate a Go coverage profile file named `coverage.out` and open it as interactive HTML in a web browser?	pass→pass	3,591	1,927	-46%	1	1	0%	586	3,216	+449%	0	0	—
case-18 What is the idiomatic Go naming convention for unit test functions testing a specific scenario on a struct method, such as testing user creation with an invalid email address on `UserService`?	pass→fail	11,037	6,117	-45%	1	1	0%	2,005	3,962	+98%	0	0	—
case-19 Where should static test fixture files, such as JSON test data, be placed within a Go package folder structure according to standard Go conventions?	pass→pass	9,281	4,451	-52%	1	1	0%	1,605	3,718	+132%	0	0	—
case-20 I need to implement a worker pool in Go that listens on a channel of jobs and shuts down gracefully when a context is canceled. Provide the worker loop structure in Go.	pass→pass	15,416	8,765	-43%	1	1	0%	2,760	4,590	+66%	0	0	—
case-21 How do I create and run database schema migrations in a Go project using the golang-migrate CLI tool for PostgreSQL?	pass→pass	13,486	12,140	-10%	1	1	0%	2,676	5,384	+101%	0	0	—
case-22 Provide the shell command to generate Go gRPC server and client code from a `service.proto` protobuf schema file using protoc.	pass→pass	6,660	3,697	-44%	1	1	0%	1,176	3,511	+199%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 22 cases were attempted. The headline lift of 0 percentage points is the difference between those two pass rates over the 22 comparable cases. 1 case got worse with the skill loaded, and it is included in that figure.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 86.4%
Pass rate with the skill: 86.4%
Cases attempted: 22
Cases counted toward lift: 22
Cases that regressed: 1
Skill version measured: v1
Run completed: 8/21/2026, 19:50 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-09

Prompt

Write the signature and structure for a Go per-test setup helper `setupService(t *testing.T)` that initializes a service and provides resource cleanup to the calling test.

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signalsno signals yet

BenchmarkRun a verified benchmark with positive lift

Live evalNeeds ≥20 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+163% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

No signals yet — run a benchmark or collect evaluated traces to earn a score.

Verified on gemini-3.6-flash · re-tested 7 days ago

Other measured skills in the registry, with their headline benchmark lift.