284 lines
8.9 KiB
Markdown
284 lines
8.9 KiB
Markdown
# Testing Patterns
|
||
|
||
**Analysis Date:** 2026-03-21
|
||
|
||
## Test Framework
|
||
|
||
**Runner:**
|
||
- Go standard `testing` package
|
||
- Config: `Makefile` target `test`
|
||
|
||
**Assertion Libraries:**
|
||
- `github.com/stretchr/testify v1.11.1` — `assert` package (preferred in newer tests)
|
||
- Standard `t.Fatal`, `t.Fatalf`, `t.Errorf` (used in most tests, older style)
|
||
|
||
**Mocking Libraries:**
|
||
- `github.com/DATA-DOG/go-sqlmock v1.5.2` — SQL-level DB mocking
|
||
- `github.com/alicebob/miniredis/v2 v2.36.1` — in-process Redis mock server
|
||
- Manual mock structs implementing interfaces (for `core.Context`, logger)
|
||
|
||
**Run Commands:**
|
||
```bash
|
||
make test # Run all tests: go test -v --cover ./internal/...
|
||
go test -v ./internal/service/... # Test specific package
|
||
go test -v -run TestFunctionName ./... # Run single test
|
||
```
|
||
|
||
**Coverage output:** `coverage.out` (present in repo root)
|
||
|
||
## Test File Organization
|
||
|
||
**Location:**
|
||
- Co-located with source files — `foo_test.go` sits in the same directory as `foo.go`
|
||
- No separate `tests/` directory for Go unit/integration tests
|
||
|
||
**Naming:**
|
||
- `<subject>_test.go` matching the function/feature under test
|
||
- Package declaration: same package as source (`package activity`) for white-box tests, or `package game_test` for black-box tests (rare)
|
||
|
||
**Structure:**
|
||
```
|
||
internal/service/activity/
|
||
├── activity_order_service.go
|
||
├── concurrency_test.go # integration (real DB)
|
||
├── reward_snapshot_test.go # integration (SQLite in-memory)
|
||
├── sanitize_test.go # unit (no DB)
|
||
internal/service/game/
|
||
├── token.go
|
||
├── token_test.go # uses miniredis + SQLite
|
||
internal/service/user/
|
||
├── error_test.go # uses go-sqlmock
|
||
├── request_shipping_batch_test.go
|
||
internal/api/app/
|
||
├── store_test.go # HTTP handler integration test
|
||
```
|
||
|
||
## Test Structure
|
||
|
||
**Suite Organization (table-driven tests):**
|
||
```go
|
||
func TestShouldTriggerInstantDraw(t *testing.T) {
|
||
testCases := []struct {
|
||
name string
|
||
orderStatus int32
|
||
drawMode string
|
||
shouldTrigger bool
|
||
}{
|
||
{"已支付+即时开奖", 2, "instant", true},
|
||
{"已支付+定时开奖", 2, "scheduled", false},
|
||
{"未支付+即时开奖", 1, "instant", false},
|
||
}
|
||
|
||
for _, tc := range testCases {
|
||
t.Run(tc.name, func(t *testing.T) {
|
||
result := shouldTriggerInstantDraw(tc.orderStatus, tc.drawMode)
|
||
if result != tc.shouldTrigger {
|
||
t.Errorf("期望触发=%v，实际触发=%v", tc.shouldTrigger, result)
|
||
}
|
||
})
|
||
}
|
||
}
|
||
```
|
||
|
||
**Patterns:**
|
||
- Setup: create repo/DB then initialize service via constructor
|
||
- Teardown: SQLite in-memory DBs are ephemeral (no cleanup needed); miniredis uses `defer mr.Close()`
|
||
- Assertion: `t.Fatalf` for unrecoverable setup failures; `t.Errorf` for assertion failures
|
||
- Skipping: `t.Skipf` when preconditions absent (e.g., real DB unavailable in concurrency tests)
|
||
|
||
## Mocking
|
||
|
||
**In-memory SQLite (primary DB mock):**
|
||
```go
|
||
repo, err := mysql.NewSQLiteRepoForTest() // internal/repository/mysql/testrepo_sqlite.go
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
db := repo.GetDbW()
|
||
// Manually create tables with SQLite-compatible DDL
|
||
db.Exec(`CREATE TABLE products (id INTEGER PRIMARY KEY AUTOINCREMENT, ...)`)
|
||
```
|
||
`NewSQLiteRepoForTest()` → `gorm.Open(sqlite.Open(":memory:"), ...)` → returns `Repo` interface.
|
||
|
||
**TestRepo wrapping real DB (for integration tests with live MySQL):**
|
||
```go
|
||
db, err := gorm.Open(drivermysql.Open(dsn), &gorm.Config{})
|
||
repo := mysql.NewTestRepo(db) // internal/repository/mysql/test_helper.go
|
||
```
|
||
|
||
**go-sqlmock (SQL-level mocking):**
|
||
```go
|
||
db, mock, err := sqlmock.New()
|
||
gormDB, _ := gorm.Open(gormmysql.New(gormmysql.Config{
|
||
Conn: db,
|
||
SkipInitializeWithVersion: true,
|
||
}), &gorm.Config{})
|
||
|
||
mock.ExpectQuery("SELECT .* FROM `system_item_cards`").
|
||
WithArgs(100, sqlmock.AnyArg()).
|
||
WillReturnRows(sqlmock.NewRows([]string{"id", "status"}).AddRow(100, 0))
|
||
```
|
||
|
||
**miniredis (Redis mock):**
|
||
```go
|
||
mr, err := miniredis.Run()
|
||
defer mr.Close()
|
||
rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
|
||
```
|
||
|
||
**Manual interface mock (for `core.Context`):**
|
||
```go
|
||
type mockContext struct {
|
||
core.Context // embed to satisfy interface
|
||
ctx context.Context
|
||
}
|
||
|
||
func (m *mockContext) RequestContext() core.StdContext { return core.StdContext{Context: m.ctx} }
|
||
func (m *mockContext) ShouldBindJSON(obj interface{}) error { return nil }
|
||
func (m *mockContext) AbortWithError(err core.BusinessError) {}
|
||
// ... implement all interface methods with no-op stubs
|
||
```
|
||
|
||
**MockLogger pattern:**
|
||
```go
|
||
type MockLogger struct {
|
||
logger.CustomLogger
|
||
}
|
||
func (l *MockLogger) Info(msg string, fields ...zap.Field) {}
|
||
func (l *MockLogger) Error(msg string, fields ...zap.Field) {}
|
||
func (l *MockLogger) Warn(msg string, fields ...zap.Field) {}
|
||
func (l *MockLogger) Debug(msg string, fields ...zap.Field) {}
|
||
```
|
||
|
||
**What to Mock:**
|
||
- DB connection (use SQLite in-memory or go-sqlmock)
|
||
- Redis (use miniredis)
|
||
- External API clients (use interface injection)
|
||
- Logger (use MockLogger embedding `logger.CustomLogger`)
|
||
- `core.Context` (use manual mock struct)
|
||
|
||
**What NOT to Mock:**
|
||
- Business logic within services under test
|
||
- DAO query building when testing DB query behavior
|
||
|
||
## Fixtures and Factories
|
||
|
||
**Test Data (DDL + seed SQL directly in test):**
|
||
```go
|
||
// Create table
|
||
repo.GetDbW().Exec(`CREATE TABLE orders (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
user_id INTEGER NOT NULL,
|
||
status INTEGER NOT NULL DEFAULT 1,
|
||
...
|
||
)`)
|
||
|
||
// Seed data
|
||
db.Exec("INSERT INTO orders (id, user_id, status, source_type, total_amount, created_at) VALUES (101, ?, 2, 0, 100, ?)", userID, o1Time)
|
||
```
|
||
|
||
**Shared table initialization helpers:**
|
||
```go
|
||
func initTestTables(t *testing.T, db *gorm.DB) { ... } // in task_center package tests
|
||
func ensureExtraTablesForServiceTest(t *testing.T, db *gorm.DB) { ... }
|
||
```
|
||
|
||
**Test helper functions marked with `t.Helper()`:**
|
||
```go
|
||
func assertAttribution(t *testing.T, got map[int64]activityAttribution, activityID, wantChannelID int64, wantChannelCode string) {
|
||
t.Helper()
|
||
...
|
||
}
|
||
```
|
||
|
||
**Location:**
|
||
- No centralized fixtures directory. Each test file creates its own data inline.
|
||
- Shared helpers defined within the same package test files.
|
||
|
||
## Coverage
|
||
|
||
**Requirements:** `make test` runs with `--cover` flag but no enforced minimum threshold.
|
||
|
||
**View Coverage:**
|
||
```bash
|
||
go test -v --cover ./internal/... # prints coverage % per package
|
||
```
|
||
|
||
Coverage output file: `/Users/win/2025/AICoding/bindbox/bindbox_game/coverage.out`
|
||
|
||
## Test Types
|
||
|
||
**Unit Tests (pure logic, no DB):**
|
||
- Scope: individual pure functions — JSON utilities, string parsing, coupon discount math
|
||
- Pattern: call function, assert return value
|
||
- Examples: `internal/service/product/product_test.go` (TestNormalizeJSON, TestSplitImages), `internal/service/order/discount_test.go` (TestApplyCouponDiscount), `internal/service/activity/sanitize_test.go`
|
||
|
||
**Integration Tests (SQLite in-memory DB):**
|
||
- Scope: service methods requiring DB reads/writes, HTTP handler end-to-end via `net/http/httptest`
|
||
- Pattern: `NewSQLiteRepoForTest()` → create DDL → seed data → call service/handler → assert DB state or response
|
||
- Examples: `internal/service/task_center/service_test.go`, `internal/api/app/store_test.go`, `internal/service/activity/reward_snapshot_test.go`
|
||
|
||
**Integration Tests (Real MySQL — skipped when unavailable):**
|
||
- Scope: concurrency/race condition testing requiring real DB transactions
|
||
- Pattern: hardcoded DSN, `t.Skipf` on connection failure
|
||
- Examples: `internal/service/activity/concurrency_test.go`
|
||
|
||
**E2E Tests:** Not present in the current codebase.
|
||
|
||
## Common Patterns
|
||
|
||
**HTTP Handler Testing:**
|
||
```go
|
||
mux, _ := core.New(lg)
|
||
mux.Group("/api/app").GET("/store/items", NewStore(lg, repo).ListStoreItemsForApp())
|
||
|
||
rr := httptest.NewRecorder()
|
||
req, _ := http.NewRequest("GET", "/api/app/store/items?kind=product&page=1&page_size=10", bytes.NewBufferString(""))
|
||
mux.ServeHTTP(rr, req)
|
||
|
||
if rr.Code != http.StatusOK {
|
||
t.Fatalf("code=%d body=%s", rr.Code, rr.Body.String())
|
||
}
|
||
var rsp map[string]interface{}
|
||
json.Unmarshal([]byte(rr.Body.String()), &rsp)
|
||
```
|
||
|
||
**Async/Concurrency Testing:**
|
||
```go
|
||
var wg sync.WaitGroup
|
||
var mu sync.Mutex
|
||
successCount := 0
|
||
|
||
for i := 0; i < concurrency; i++ {
|
||
wg.Add(1)
|
||
go func(idx int) {
|
||
defer wg.Done()
|
||
// ... concurrent operation
|
||
mu.Lock()
|
||
defer mu.Unlock()
|
||
successCount++
|
||
}(i)
|
||
}
|
||
wg.Wait()
|
||
// assert final DB state
|
||
```
|
||
|
||
**Error Path Testing:**
|
||
```go
|
||
err := svc.AddItemCard(context.Background(), 1, 100, 1)
|
||
assert.Error(t, err)
|
||
assert.Equal(t, "record not found", err.Error())
|
||
```
|
||
|
||
**Testify assertion style (preferred in newer tests):**
|
||
```go
|
||
assert.NoError(t, err)
|
||
assert.NotEmpty(t, token)
|
||
assert.Equal(t, userID, claims.UserID)
|
||
assert.Contains(t, err.Error(), "invalid ticket format")
|
||
```
|
||
|
||
---
|
||
|
||
*Testing analysis: 2026-03-21*
|