Writing Go Tests

Go Testing Best Practices

This skill provides actionable testing guidelines. For detailed implementation patterns, code examples, rationale, and production system references, consult go-testing-best-practices.md.

When Working with Go Tests

Always apply these current best practices:

1. Test Organisation

• Place test files alongside source code using *_test.go naming
• Use internal tests (same package) for unit testing unexported functions
• Use external tests (package foo_test) for integration testing and examples
• Split test files by functionality when they exceed 500-800 lines (e.g., handler_auth_test.go, handler_validation_test.go)

2. Table-Driven Testing

• Prefer map-based tables over slice-based for automatic unique test names
• Use descriptive test case names that appear in failure output
• See detailed guide for complete pattern and examples

3. Concurrent Testing

• Use testing/synctest for deterministic concurrent testing (Go 1.24+)
• This eliminates flaky time-based tests and runs in microseconds instead of seconds
• For traditional parallel tests, always call t.Parallel() first in test functions

4. Assertions and Comparisons

• Use cmp.Diff() from google/go-cmp for complex comparisons
• Standard library is sufficient for simple tests
• Testify is the dominant third-party framework when richer assertions are needed

5. Mocking and Test Doubles

• Favour integration testing with real dependencies over heavy mocking
• Use Testcontainers for database/service integration tests
• When mocking is necessary, prefer simple function-based test doubles over code generation
• Use interface-based design ("accept interfaces, return structs")

6. Coverage Targets

• Aim for 70-80% coverage as a practical target
• Focus on meaningful tests over percentage metrics
• Use go test -cover and go tool cover -html for analysis

7. Test Fixtures

• Use testdata directory for test fixtures (automatically ignored by Go toolchain)
• Implement golden file testing for validating complex output
• Use functional builder patterns for complex test data

8. Helpers and Cleanup

• Always mark helper functions with t.Helper() for accurate error reporting
• Use t.Cleanup() for resource cleanup (superior to defer in tests)

9. Benchmarking (Go 1.24+)

• Use B.Loop() method as the preferred pattern (prevents compiler optimisations)
• Combine with benchstat for statistical analysis
• Use -benchmem for memory profiling

10. Naming Conventions

• Test functions: Test*, Benchmark*, Fuzz*, Example* (capital letter after prefix)
• Use got and want for actual vs expected values
• Use descriptive test case names in table-driven tests

Integration vs Unit Testing

• Separate tests by environment variable (preferred over build tags)
• See detailed guide for implementation pattern

Additional Reference Material

Load go-testing-best-practices.md when you need:

• Complete code examples for table-driven tests, mocking patterns, golden files, helpers, or benchmarks
• Detailed explanation of testing/synctest concurrent testing patterns
• Rationale behind why specific patterns are preferred over alternatives
• Production system examples and statistics (Kubernetes, Docker, Uber, Netflix, ByteDance)
• Context on testing framework choices (Testify, GoMock, Testcontainers)
• Comprehensive coverage strategies and tooling details
• Integration testing patterns with containerisation

The detailed guide contains full context, examples with explanations, and production-proven patterns. This SKILL.md provides the actionable rules to apply.

Key Principle

Focus on meaningful tests that validate behaviour rather than implementation. Pragmatic excellence over theoretical perfection.

Converted and distributed by TomeVault — claim your Tome and manage your conversions.