Go Day 7 — Cheat Sheet

สารบัญ

1. Mockery — ติดตั้ง & คำสั่ง
2. Mockery — .mockery.yml
3. Mockery — เขียนเทสด้วย EXPECT()
4. Testcontainers — ติดตั้ง & environment
5. Testcontainers — โครงที่ก็อปไปใช้ได้
6. Testcontainers — sync.Once + testify suite
7. Goose — คำสั่ง & .env
8. Goose — โครงไฟล์ migration
9. Redis — คำสั่งใน redis-cli
10. Redis — cache-aside ใน Go
11. Redis — KEYS vs SCAN
12. อันไหนใช้เมื่อไหร่ — mock vs container จริง
13. ตารางแปล error ที่เจอบ่อย
14. ตารางกับดักรวม

1 · Mockery — ติดตั้ง & คำสั่ง

go install github.com/vektra/mockery/v3@latest
// → binary ชื่อ `mockery` เฉย ๆ ที่ $GOPATH/bin/mockery (ไม่มี v3 ต่อท้าย)

mockery version      // v3.7.3   ← subcommand ไม่ใช่ flag
mockery --version    // Error: unknown flag: --version

v3 มี subcommand แค่ 5 ตัว: completion · help · init · migrate · showconfig · version — ไม่มี generate เพราะการ generate คือ root command

ขั้นตอนตั้งแต่ศูนย์

cd app                                   # โฟลเดอร์ที่มี go.mod
mockery init example.com/shop            # ใส่ module path จาก go.mod ไม่ใช่ชื่อ package
# แก้ .mockery.yml เติม recursive: true  ← ขั้นที่คนลืมกันมากที่สุด
mockery                                  # generate
go mod tidy                              # testify ไม่ถูกเติมให้เอง ต้องรันเอง

✅ ยืนยันว่า generate สำเร็จ = ต้องเห็นบรรทัดนี้ใน log
INF adding interface to collection ... interface=UserRepository package-path=example.com/shop/user
⚠️ exit code เชื่อไม่ได้ — package ผิดก็ยัง exit 0

2 · Mockery — .mockery.yml

ไฟล์ที่ mockery init สร้างจริงมี 28 บรรทัด · นี่คือฟิลด์ที่ต้องรู้จัก:

all: false                          # ระดับบนสุดเป็น false (ไม่ใช่ true)
dir: '{{.InterfaceDir}}'            # วางไฟล์ mock ข้าง ๆ interface
filename: mocks_test.go               # ← ใช้ข้าม package ไม่ได้ ดูข้อ 8 ในตารางกับดัก
force-file-write: true               # อนุญาตเขียนทับ · false = FTL "outfile exists"
formatter: goimports
generate: true
include-auto-generated: false
log-level: info
structname: '{{.Mock}}{{.InterfaceName}}'   # → MockUserRepository
pkgname: '{{.SrcPackageName}}'
recursive: false                    # ← ตัวที่ทำให้ config เริ่มต้นใช้ไม่ได้
require-template-schema-exists: true
template: testify                     # ได้ EXPECT() แบบ type-safe
template-schema: '{{.Template}}.schema.json'
packages:
  example.com/shop:
    config:
      all: true
      recursive: true                # ← เติมบรรทัดนี้เอง ไม่งั้นไม่เจอ sub-package

ชื่อไฟล์ที่ mockery หาเจอมีแค่ .mockery.yml และ .mockery.yaml — ต้องมีจุดนำหน้า · mockery.yml เฉย ๆ = file not found
มันไล่หาขึ้นไปตาม parent directory ด้วย → รันจากใน sub-package ก็เจอ config ที่ root

3 · Mockery — เขียนเทสด้วย EXPECT()

func TestDisplayName_OK(t *testing.T) {
    repo := NewMockUserRepository(t)      // ← t.Cleanup + AssertExpectations ให้เอง
    repo.EXPECT().GetByID(7).Return(&User{ID: 7, Name: "Somchai"}, nil)

    svc := NewService(repo)
    got, err := svc.DisplayName(7)

    assert.NoError(t, err)
    assert.Equal(t, "Mr. Somchai", got)
}

ไม่ต้องเขียน defer repo.AssertExpectations(t) แล้ว — constructor ลงทะเบียน t.Cleanup(func(){ mock.AssertExpectations(t) }) ไว้ให้ (นี่คือความต่างจาก v2)

EXPECT() เป็นแค่ syntactic sugar ที่ห่อ mock.On("ชื่อ method", args...) ไว้ · .Return() type-safe แต่ argument ยังรับ any เพื่อให้ส่ง mock.Anything ได้

4 · Testcontainers — ติดตั้ง & environment

go mod init tcdemo
go get github.com/testcontainers/testcontainers-go
go get github.com/testcontainers/testcontainers-go/modules/postgres   # ← คนละ module ต้อง get แยก
go get gorm.io/gorm gorm.io/driver/postgres
go get github.com/stretchr/testify

ลืมบรรทัดที่สอง → no required module provides package .../modules/postgres ตั้งแต่ compile

ถ้าไม่ได้ใช้ Docker Desktop (colima / Rancher / Podman บน macOS)

export DOCKER_HOST=$(docker context inspect --format '{{.Endpoints.docker.Host}}')
export TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE=/var/run/docker.sock

testcontainers-go v0.44.0 ไม่อ่าน docker context ของ Docker CLI — docker ps ใช้ได้ ไม่ได้แปลว่าเทสจะรันได้
ตรวจจาก log 2 บรรทัดนี้: Resolved Docker Host: (path ฝั่ง mac) และ Resolved Docker Socket Path: (path ฝั่ง VM) — สองค่านี้ต่างกันได้โดยตั้งใจ

5 · Testcontainers — โครงที่ก็อปไปใช้ได้

func StartPostgres(ctx context.Context) (*tcpostgres.PostgresContainer, time.Duration, error) {
    start := time.Now()
    ctr, err := tcpostgres.Run(ctx,
        "postgres:16-alpine",
        tcpostgres.WithDatabase("testdb"),
        tcpostgres.WithUsername("testuser"),
        tcpostgres.WithPassword("testpass"),
        tcpostgres.BasicWaitStrategies(),      // ← ห้ามลืม
    )
    return ctr, time.Since(start), err
}

func OpenGorm(ctx context.Context, ctr *tcpostgres.PostgresContainer) (*gorm.DB, string, error) {
    dsn, err := ctr.ConnectionString(ctx, "sslmode=disable")   // ← port สุ่มอยู่ในนี้
    if err != nil { return nil, "", err }
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
        Logger: logger.Default.LogMode(logger.Silent),
    })
    if err != nil { return nil, dsn, err }
    if err := db.AutoMigrate(&model.User{}); err != nil { return nil, dsn, err }
    return db, dsn, nil
}

รูปแบบ cleanup ที่ถูกต้อง

ctr, err := tcpostgres.Run(ctx, ...)
if err != nil {
    t.Fatal(err)     // ออกก่อนถึง defer
}
defer ctr.Terminate(ctx)  // panic ถ้า ctr = nil

ctr, err := tcpostgres.Run(ctx, ...)
defer func() {
    _ = testcontainers.TerminateContainer(ctr)
}()
if err != nil {
    t.Fatal(err)
}

Run คืนค่าไม่เหมือนกันสองกรณี: image tag ผิด → ctr = nil · wait strategy timeout → ctr ≠ nil พร้อม error (container start ไปแล้วจริง ๆ)
testcontainers.TerminateContainer(ctr) จัดการได้ทั้งคู่ — เรียกกับ typed nil ก็คืน <nil> ไม่ panic

BasicWaitStrategies() คืออะไร

wait.ForLog("database system is ready to accept connections").WithOccurrence(2)
wait.ForListeningPort("5432/tcp")

ทำไมต้อง 2 ครั้ง — postgres restart ตัวเองหลัง initdb · ทำไมต้องรอ port — macOS/Windows มี docker port-proxy แยก ถ้าไม่รอเทสจะ flaky

6 · Testcontainers — sync.Once + testify suite

var (
    sharedOnce sync.Once
    sharedCtr  *tcpostgres.PostgresContainer
    sharedDB   *gorm.DB
    sharedErr  error
    SharedBoot time.Duration
)

func SharedDB(t *testing.T) (*gorm.DB, string) {
    t.Helper()
    sharedOnce.Do(func() {
        ctx := context.Background()
        var d time.Duration
        sharedCtr, d, sharedErr = StartPostgres(ctx)
        SharedBoot = d
        if sharedErr != nil { return }
        sharedDB, sharedDSN, sharedErr = OpenGorm(ctx, sharedCtr)
    })
    if sharedErr != nil { t.Fatalf("shared container failed: %v", sharedErr) }
    return sharedDB, sharedDSN
}

// TestMain ทำแค่นี้ — ห้าม boot container ก่อน m.Run()
func TestMain(m *testing.M) {
    code := m.Run()
    testutil.TerminateShared()
    os.Exit(code)
}

เร็วขึ้น 2.47 เท่าที่ 4 เทส · ต้นทุนต่อเทสต่างกัน ~380 เท่า · boot ตัวแรกของ process ~1.0–1.3 วิ (รวมเวลา start Ryuk) ตัวถัดไป ~0.75–0.80 วิ

-short ต้องไม่แตะ Docker

func (s *UserRepoSuite) SetupSuite() {
    if testing.Short() { s.T().Skip("skipping integration suite in -short mode") }
    s.db, s.dsn = testutil.SharedDB(s.T())
    s.repo = repository.NewUserRepository(s.db)
}

func (s *UserRepoSuite) SetupTest() {          // ก่อนทุกเทส: ล้างตาราง ไม่เปิด container ใหม่
    testutil.TruncateUsers(s.T(), s.db)
}

func TestUserRepoSuite(t *testing.T) { suite.Run(t, new(UserRepoSuite)) }

ลำดับ hook ของ testify suite

SetupSuite
  SetupTest → BeforeTest(suite, test) → body → AfterTest(suite, test) → TearDownTest
  ... วนซ้ำทุกเทส ...
TearDownSuite

⚠️ suite รัน method เรียงตามตัวอักษร ไม่ใช่ลำดับที่ประกาศ — ประกาศ TestZebra ก่อน TestApple แต่ TestApple รันก่อน
→ ห้ามเขียนเทสที่พึ่งพาลำดับ

nil slice — จำเป็นเฉพาะบางเส้นทาง

GORM Find reflect-allocate slice ให้เอง → ปัญหา null ไม่เกิด · เกิดจริงกับ Raw().Scan() และ repository ที่เขียน rows.Next() เอง — แก้ด้วย make([]T, 0)

7 · Goose — คำสั่ง & .env

go install github.com/pressly/goose/v3/cmd/goose@latest
goose --version      # goose version: v3.27.3

วาง .env ที่ราก repo — goose อ่านให้เอง (flag -env default คือ .env):

GOOSE_DRIVER=postgres
GOOSE_DBSTRING=postgres://postgres:secret@localhost:55433/shopdb?sslmode=disable
GOOSE_MIGRATION_DIR=./migrations

⚠️ -dir default คือ "." ไม่ใช่ ./migrations — ไม่ตั้ง GOOSE_MIGRATION_DIR ไฟล์จะไปโผล่ที่ราก repo ทั้งที่มีโฟลเดอร์ migrations/ อยู่

ตาราง goose_db_version

 Column     | Type                        | Nullable | Default
------------+-----------------------------+----------+----------------------------------
 id         | integer                     | not null | generated by default as identity
 version_id | bigint                      | not null |
 is_applied | boolean                     | not null |
 tstamp     | timestamp without time zone | not null | now()

goose เก็บแค่ เลข version + เวลา — ไม่มี checksum ของไฟล์ (ต่างจาก Flyway/Liquibase) นี่คือรากของกับดัก "แก้ไฟล์ย้อนหลัง" และ "dev/prod แตกกัน"
goose down = DELETE แถวทิ้ง ไม่ใช่ set is_applied = false (ทุกแถวเป็น t เสมอ · id จึงไม่ต่อเนื่องหลัง down/up หลายรอบ)

🕐 output มี สองโซนเวลาปนกัน — prefix ของ log เป็นเวลาเครื่อง (19:51) ส่วนชื่อไฟล์และคอลัมน์ Applied At เป็น UTC (12:51)

8 · Goose — โครงไฟล์ migration

template ที่ goose create ... sql สร้างให้มี แค่ 4 บรรทัด (ไม่มี StatementBegin/End มาให้ — ต้องพิมพ์เอง):

-- +goose Up
SELECT 'up SQL query';

-- +goose Down
SELECT 'down SQL query';

DDL ปกติ

-- +goose Up
CREATE TABLE products (
    id         BIGSERIAL PRIMARY KEY,
    name       TEXT NOT NULL,
    price      NUMERIC(10,2) NOT NULL DEFAULT 0,
    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

-- +goose Down
DROP TABLE products;

function / trigger — ต้องครอบ StatementBegin/End

-- +goose Up
ALTER TABLE products ADD COLUMN updated_at TIMESTAMPTZ NOT NULL DEFAULT now();

-- +goose StatementBegin
CREATE OR REPLACE FUNCTION set_updated_at() RETURNS trigger AS $$
BEGIN
    NEW.updated_at = now();
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;
-- +goose StatementEnd

CREATE TRIGGER trg_products_updated_at
BEFORE UPDATE ON products
FOR EACH ROW EXECUTE FUNCTION set_updated_at();

-- +goose Down
DROP TRIGGER trg_products_updated_at ON products;
DROP FUNCTION set_updated_at();
ALTER TABLE products DROP COLUMN updated_at;

goose แบ่ง statement ด้วย ; แบบง่าย ๆ ไม่รู้จัก dollar-quoted string — ครอบเฉพาะ block ที่มี ; ข้างในก็พอ statement อื่นในไฟล์เดียวกันปล่อยไว้ได้

CREATE INDEX CONCURRENTLY — ต้องปิด transaction

-- +goose NO TRANSACTION
-- +goose Up
CREATE INDEX CONCURRENTLY idx_items_sku ON items (sku);

-- +goose Down
DROP INDEX CONCURRENTLY idx_items_sku;

goose ห่อทุกไฟล์ด้วย transaction โดย default (ไฟล์ที่พังกลางทางจึง rollback ทั้งไฟล์ ไม่มี state ค้าง) แต่ Postgres ห้าม CONCURRENTLY อยู่ใน transaction block
ใส่ NO TRANSACTION แล้ว = ไฟล์นั้นไม่มี rollback อัตโนมัติ → ใส่ statement เดียวต่อไฟล์

seed master data = migration ตัวหนึ่ง

-- +goose Up
INSERT INTO categories (code, name) VALUES
    ('ELEC', 'Electronics'),
    ('BOOK', 'Books'),
    ('FOOD', 'Food & Drink');

-- +goose Down
DELETE FROM categories WHERE code IN ('ELEC','BOOK','FOOD');

รัน goose up ซ้ำ 3 รอบ ข้อมูลยังเป็น 3 แถว — ตัวที่กันซ้ำคือ goose_db_version ไม่ใช่ SQL (INSERT ธรรมดาไม่มี ON CONFLICT ก็ไม่ซ้ำ เพราะ goose ไม่รันไฟล์นั้นอีกเลย)

goose vs GORM AutoMigrate

⚠️ rollback = ย้อน schema ไม่ใช่ย้อนข้อมูล · Down ที่ DROP COLUMN แล้ว up ใหม่ → ค่าเดิม 42, 7 กลายเป็น 0, 0 ถาวร

9 · Redis — คำสั่งใน redis-cli

docker run -d --name day7-redis -p 55379:6379 redis:7-alpine
docker exec day7-redis redis-cli INFO server   # redis_version:7.4.10

TTL สามค่าที่ต้องจำ: -2 = ไม่มี key · -1 = มี key แต่ไม่มีวันหมดอายุ · เลขบวก = วินาทีที่เหลือ
หมดอายุแล้ว key หายจริง (TTL -2 · EXISTS 0 · TYPE none) — แยกไม่ออกจาก key ที่ไม่เคยมี

⚠️ output ของ redis-cli ต่างกันเมื่อมี TTY กับตอน pipe — ในเทอร์มินัลเห็น (nil) / (integer) 1 แต่ตอน pipe ได้บรรทัดว่างกับเลขเปล่า · script ที่เช็คผลต้องเขียนตามแบบหลัง

เรื่อง persistence ที่มักเข้าใจผิด

CONFIG GET save          # 3600 1 300 100 60 10000   ← RDB เปิดอยู่ default
CONFIG GET appendonly    # no                        ← AOF ปิดอยู่ default

Redis ทำงานบน RAM แต่ persist ลงดิสก์ได้และ default เปิด RDB ไว้ — ข้อมูลรอด docker restart (SIGTERM = save ก่อนตาย) แต่ หายถ้าโดน SIGKILL (สิ่งที่เขียนหลัง save ล่าสุด)

10 · Redis — cache-aside ใน Go

go get github.com/redis/go-redis/v9   // v9.22.0

rdb := redis.NewClient(&redis.Options{Addr: "127.0.0.1:55379"})
defer rdb.Close()
if err := rdb.Ping(ctx).Err(); err != nil {   // ← NewClient เป็น lazy ไม่เคย error
    log.Fatal(err)
}

func getUser(ctx context.Context, rdb *redis.Client, id int) (User, string, error) {
    key := fmt.Sprintf("user:%d", id)

    val, err := rdb.Get(ctx, key).Result()
    if err == nil {                          // HIT
        var u User
        if err := json.Unmarshal([]byte(val), &u); err != nil {
            return User{}, "", err
        }
        return u, "HIT", nil
    }
    if !errors.Is(err, redis.Nil) {           // error จริง — ต้องแยกจาก cache miss
        return User{}, "", fmt.Errorf("redis error: %w", err)
    }

    u := queryDB(id)                          // MISS
    b, err := json.Marshal(u)                  // ← อย่าใส่ _ ทิ้ง error
    if err != nil { return User{}, "", err }
    if err := rdb.Set(ctx, key, b, 60*time.Second).Err(); err != nil {
        return User{}, "", err
    }
    return u, "MISS", nil
}

val, err := rdb.Get(ctx, k).Result()
if err != nil {
    return err      // redis: nil ก็เข้าตรงนี้
}

val, err := rdb.Get(ctx, k).Result()
switch {
case errors.Is(err, redis.Nil):  // miss
case err != nil:                 // error จริง
default:                        // hit
}

ใช้ errors.Is ไม่ใช่ == (บทเรียน 12) เพราะโค้ดชั้นบนอาจ %w ห่อไว้

ชนิดที่ Set รับได้

// ✅ string · int · float64 · bool (เก็บเป็น "1") · []byte · time.Duration (nanosecond)
// ❌ struct · *struct · map · slice  →  redis: can't marshal ...

b, err := json.Marshal(u)
rdb.Set(ctx, key, b, ttl)      // marshal เองก่อนเสมอ

cache stampede

var mu sync.Mutex

func getGuarded(ctx context.Context, rdb *redis.Client) string {
    if v, err := rdb.Get(ctx, "hot").Result(); err == nil { return v }
    mu.Lock()
    defer mu.Unlock()
    // เช็คซ้ำหลังได้ lock — คนอื่นอาจเติม cache ไปแล้ว
    if v, err := rdb.Get(ctx, "hot").Result(); err == nil { return v }
    v := queryDB()
    rdb.Set(ctx, "hot", v, 60*time.Second)
    return v
}

ต้นทุนแทบเป็นศูนย์ (269 vs 282 ms) — แต่ sync.Mutex (บทเรียน 24) กันได้แค่ภายในโปรเซสเดียว · หลาย instance ต้องใช้ distributed lock

11 · Redis — KEYS vs SCAN

var cursor uint64
for {
    batch, cur, err := rdb.Scan(ctx, cursor, "user:*", 1000).Result()
    if err != nil { return err }
    // ใช้ len(batch) จริง อย่ายึด COUNT เป็นขนาดตายตัว
    cursor = cur
    if cursor == 0 { break }      // ← cursor 0 เท่านั้นที่แปลว่าจบ
}

⚠️ SCAN ไม่ได้ "เร็วกว่า" — มันช้ากว่า 5.7 เท่าในแง่เวลารวม
เหตุผลที่ต้องใช้คือ Redis ประมวลผลทีละคำสั่งบน thread เดียว → KEYS แช่แข็ง client ทุกคน 146 ms ส่วน SCAN ตัดงานเป็นชิ้นละ 57 µs

COUNT เป็นแค่ hint ไม่ใช่ limit — ขอ 1000 ได้กลับมา 1004 · ขอ COUNT 2 อาจได้ key 1 ตัวพร้อม cursor 3 (ยังไม่จบ)

🛠 อยากสร้าง key เยอะ ๆ ทดสอบ — DEBUG POPULATE ถูกปิดใน Redis 7 ให้ใช้ Lua แทน:
redis-cli EVAL "for i=1,100000 do redis.call('SET', KEYS[1]..i, i) end return 1" 1 "bulk:0:"

12 · อันไหนใช้เมื่อไหร่ — mock vs container จริง

คำถามเดียวที่ต้องถามกับเทสทุกตัว:

  "สิ่งที่เทสนี้จะพัง คือ logic ของเรา หรือ สัญญากับของข้างนอก?"

        logic ของเรา                        สัญญากับของข้างนอก
   (if/else · การคำนวณ · error path)   (column · ตาราง · constraint · type · migration)
              │                                        │
              ▼                                        ▼
     mock (mockery)                       container จริง (testcontainers)
        ~1.25 ms/เทส                    boot 1.03 วิ ครั้งเดียว แล้ว ~2 ms/เทส

หลักฐานว่าทำไมต้องมีทั้งคู่

ฟังก์ชันเดียวกัน SearchByCity ที่ query column city ซึ่งไม่มีในตาราง:

=== RUN   TestMockedSearchByCity_PASSES_WITH_A_BUG
    MOCK RESULT: len=1 first=Ploy  (took 166.042µs)
--- PASS  (0.00s)

=== RUN   TestSearchByCity_CaughtByRealPostgres
    VERBATIM real-postgres error:
    ERROR: column "city" does not exist (SQLSTATE 42703)
--- PASS  (1.07s)

ไม่ใช่คำถาม "อันไหนดีกว่า" แต่เป็น "อันไหนตอบคำถามอะไร"
mock ตรวจว่า logic ของเราเรียกถูกไหม · container ตรวจว่า SQL ใช้ได้กับของจริงไหม
ทุกอย่างที่เป็นสัญญากับ DB — column, ตาราง, constraint, type, migration — ต้องมี integration test ไม่มีทางลัด

ราคาที่จ่ายจริง

⚠️ ข้อจำกัดของ sync.Once ที่ต้องรู้ — ทุกเทสใช้ DB ตัวเดียวกัน ดังนั้น TRUNCATE ใน SetupTest จะชนกันทันทีถ้าเปิด t.Parallel()

13 · ตารางแปล error ที่เจอบ่อย

Redis / go-redis

testcontainers-go

goose / PostgreSQL SQLSTATE

14 · ตารางกับดักรวม

อ้างอิง

• Mockery Documentation (v3)
• Testcontainers for Go — PostgreSQL module
• testify/suite — hook ของ suite
• Goose Documentation
• PostgreSQL Error Codes — ตาราง SQLSTATE ฉบับเต็ม
• Redis SCAN — cursor semantics และข้อรับประกัน
• Redis configuration — maxmemory-policy, save, appendonly
• go-redis Documentation