existential-birds/beagle / plugins/beagle-go/skills/go-testing-code-review
go-testing-code-review
VerifiedReviews Go test code for proper table-driven tests, assertions, and coverage patterns. Use when reviewing *_test.go files.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 7.8 KB |
| references/mocking.md | markdown | 5.7 KB |
| references/structure.md | markdown | 8.5 KB |
references/mocking.md
View on GitHub# Mocking
## Interface-Based Mocking
### 1. Define Interface in Consumer
```go
// service.go
type UserStore interface {
Get(id int) (*User, error)
}
type UserService struct {
store UserStore
}
func (s *UserService) GetUser(id int) (*User, error) {
return s.store.Get(id)
}
```
### 2. Create Mock in Test File
```go
// service_test.go
type mockUserStore struct {
users map[int]*User
err error
}
func (m *mockUserStore) Get(id int) (*User, error) {
if m.err != nil {
return nil, m.err
}
user, ok := m.users[id]
if !ok {
return nil, ErrNotFound
}
return user, nil
}
func TestGetUser(t *testing.T) {
mock := &mockUserStore{
users: map[int]*User{
1: {ID: 1, Name: "Alice"},
},
}
svc := &UserService{store: mock}
user, err := svc.GetUser(1)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if user.Name != "Alice" {
t.Errorf("name = %s, want Alice", user.Name)
}
}
```
### 3. Functional Mock Pattern
```go
// More flexible for varying behavior per test
type mockUserStore struct {
getFn func(id int) (*User, error)
}
func (m *mockUserStore) Get(id int) (*User, error) {
return m.getFn(id)
}
func TestGetUser_Error(t *testing.T) {
mock := &mockUserStore{
getFn: func(id int) (*User, error) {
return nil, errors.New("db error")
},
}
svc := &UserService{store: mock}
_, err := svc.GetUser(1)
if err == nil {
t.Error("expected error, got nil")
}
}
```
## Testing HTTP Clients
### 1. httptest Server
```go
func TestFetchUser(t *testing.T) {
// Create test server
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/users/1" {
t.Errorf("unexpected path: %s", r.URL.Path)
}
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{"id": 1, "name": "Alice"}`))
}))
defer ts.Close()
// Use test server URL
client := NewClient(ts.URL)
user, err := client.FetchUser(1)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if user.Name != "Alice" {
t.Errorf("name = %s, want Alice", user.Name)
}
}
```
### 2. RoundTripper Mock
```go
type mockTransport struct {
response *http.Response
err error
}
func (m *mockTransport) RoundTrip(*http.Request) (*http.Response, error) {
return m.response, m.err
}
func TestClient_Error(t *testing.T) {
client := &http.Client{
Transport: &mockTransport{
err: errors.New("network error"),
},
}
_, err := FetchData(client, "http://example.com")
if err == nil {
t.Error("expected error")
}
}
```
## Testing Time
### 1. Inject Time Function
```go
// Code
type Service struct {
now func() time.Time
}
func (s *Service) IsExpired(expiry time.Time) bool {
return s.now().After(expiry)
}
// Test
func TestIsExpired(t *testing.T) {
fixedTime := time.Date(2024, 1, 15, 0, 0, 0, 0, time.UTC)
svc := &Service{
now: func() time.Time { return fixedTime },
}
tests := []struct {
name string
expiry time.Time
want bool
}{
{"past", fixedTime.Add(-time.Hour), true},
{"future", fixedTime.Add(time.Hour), false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := svc.IsExpired(tt.expiry)
if got != tt.want {
t.Errorf("IsExpired() = %v, want %v", got, tt.want)
}
})
}
}
```
## Testing Filesystem
### 1. fstest.MapFS
```go
import "testing/fstest"
func TestReadConfig(t *testing.T) {
fs := fstest.MapFS{
"config.json": &fstest.MapFile{
Data: []byte(`{"key": "value"}`),
},
}
cfg, err := ReadConfig(fs, "config.json")
if err != nil {
t.Fatal(err)
}
if cfg.Key != "value" {
t.Errorf("key = %s, want value", cfg.Key)
}
}
```
### 2. T.TempDir
```go
func TestWriteFile(t *testing.T) {
dir := t.TempDir() // automatically cleaned up
path := filepath.Join(dir, "test.txt")
err := WriteFile(path, "content")
if err != nil {
t.Fatal(err)
}
data, _ := os.ReadFile(path)
if string(data) != "content" {
t.Errorf("got %q, want content", data)
}
}
```
## Verifying Calls
### 1. Call Recording
```go
type mockStore struct {
getCalls []int
}
func (m *mockStore) Get(id int) (*User, error) {
m.getCalls = append(m.getCalls, id)
return &User{ID: id}, nil
}
func TestBatchGet(t *testing.T) {
mock := &mockStore{}
svc := &Service{store: mock}
svc.BatchGet([]int{1, 2, 3})
if len(mock.getCalls) != 3 {
t.Errorf("Get called %d times, want 3", len(mock.getCalls))
}
if !slices.Equal(mock.getCalls, []int{1, 2, 3}) {
t.Errorf("Get called with %v, want [1,2,3]", mock.getCalls)
}
}
```
## Anti-Patterns
### 1. Over-Mocking
```go
// BAD - mocking everything
func TestAdd(t *testing.T) {
mockCalc := &mockCalculator{}
// just test the actual function!
}
// GOOD - only mock external dependencies
func TestService(t *testing.T) {
mockDB := &mockDB{} // external dependency
svc := NewService(mockDB)
// test service logic
}
```
### 2. Mocking Concrete Types
```go
// BAD - can't inject mock
type Service struct {
store *PostgresStore
}
// GOOD - interface allows mocking
type Service struct {
store Store // interface
}
```
## Review Questions
1. Are interfaces defined by consumers, not producers?
2. Are mocks minimal (only implement what's tested)?
3. Are test servers used for HTTP testing?
4. Is time injected for time-dependent tests?
5. Are call recordings used to verify interactions?
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |