Go 测试框架大比拼：Testify vs GoConvey vs Ginkgo — 如何为你的项目选择最佳测试工具

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package user_test

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

// 单元测试：语义化断言
func TestCalculateDiscount(t *testing.T) {
    result := CalculateDiscount(100, 0.2)
    assert.Equal(t, 80.0, result, "discount calculation failed")
    assert.Greater(t, result, 0.0)
    assert.InDelta(t, 80.0, result, 0.01)
}

// require 断言失败会立即终止测试
func TestDatabaseConnection(t *testing.T) {
    db, err := ConnectDB("postgres://localhost:5432/testdb")
    require.NoError(t, err, "database connection is required")
    require.NotNil(t, db)
    defer db.Close()
    // 后续测试...
}

// 测试套件：共享 setup/teardown
type UserServiceSuite struct {
    suite.Suite
    db     *sql.DB
    service *UserService
}

func (s *UserServiceSuite) SetupSuite() {
    var err error
    s.db, err = sql.Open("postgres", testDSN)
    s.Require().NoError(err)
    s.service = NewUserService(s.db)
}

func (s *UserServiceSuite) TearDownSuite() {
    s.db.Close()
}

func (s *UserServiceSuite) SetupTest() {
    s.db.Exec("TRUNCATE users")
}

func (s *UserServiceSuite) TestCreateUser() {
    user, err := s.service.CreateUser("alice", "alice@example.com")
    s.Require().NoError(err)
    s.Equal("alice", user.Name)
    s.Equal("alice@example.com", user.Email)
}

func TestUserServiceSuite(t *testing.T) {
    suite.Run(t, new(UserServiceSuite))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

type MockEmailSender struct {
    mock.Mock
}

func (m *MockEmailSender) Send(to, subject, body string) error {
    args := m.Called(to, subject, body)
    return args.Error(0)
}

func TestUserRegistration(t *testing.T) {
    mockEmail := new(MockEmailSender)
    mockEmail.On("Send", "alice@example.com", "Welcome", mock.Anything).Return(nil)

    service := NewRegistrationService(mockEmail)
    err := service.Register("alice", "alice@example.com")
    
    assert.NoError(t, err)
    mockEmail.AssertExpectations(t)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package user_test

import (
    "testing"
    . "github.com/smartystreets/goconvey/convey"
)

func TestUserService(t *testing.T) {
    Convey("Given a user service with an empty database", t, func() {
        db := setupTestDB()
        defer db.Close()
        service := NewUserService(db)

        Convey("When creating a new user with valid data", func() {
            user, err := service.CreateUser("bob", "bob@example.com")

            Convey("Then the user should be created successfully", func() {
                So(err, ShouldBeNil)
                So(user.Name, ShouldEqual, "bob")
                So(user.ID, ShouldBeGreaterThan, 0)
            })

            Convey("Then the user count should increase by 1", func() {
                count := service.CountUsers()
                So(count, ShouldEqual, 1)
            })
        })

        Convey("When creating a user with an empty name", func() {
            _, err := service.CreateUser("", "test@example.com")

            Convey("Then an error should be returned", func() {
                So(err, ShouldNotBeNil)
                So(err.Error(), ShouldContainSubstring, "name is required")
            })
        })
    })
}

1
2

# 启动 GoConvey Web UI
goconvey -port 8080

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

package user_test

import (
    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
)

var _ = Describe("UserService", func() {
    var (
        db      *sql.DB
        service *UserService
    )

    BeforeEach(func() {
        db = setupTestDB()
        service = NewUserService(db)
    })

    AfterEach(func() {
        db.Close()
    })

    Context("when creating a user", func() {
        It("should succeed with valid data", func() {
            user, err := service.CreateUser("carol", "carol@example.com")
            Expect(err).NotTo(HaveOccurred())
            Expect(user.Name).To(Equal("carol"))
            Expect(user.Email).To(ContainSubstring("@"))
        })

        It("should fail with an empty name", func() {
            _, err := service.CreateUser("", "test@example.com")
            Expect(err).To(HaveOccurred())
            Expect(err.Error()).To(ContainSubstring("name"))
        })
    })

    Context("when querying users", func() {
        BeforeEach(func() {
            service.CreateUser("user1", "user1@example.com")
            service.CreateUser("user2", "user2@example.com")
        })

        It("should return all users", func() {
            users := service.ListUsers()
            Expect(users).To(HaveLen(2))
        })

        It("should support pagination", Label("slow"), func() {
            page := service.ListUsersPaginated(0, 1)
            Expect(page).To(HaveLen(1))
        })
    })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 为包生成测试套件
ginkgo bootstrap

# 生成测试骨架
ginkgo generate user

# 运行测试（带标签过滤）
ginkgo --label-filter="!slow" ./...

# 持续监听模式
ginkgo watch ./...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

name: Go Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16-alpine
        env:
          POSTGRES_PASSWORD: testpass
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.23'
      - name: Run unit tests
        run: go test -v -race -coverprofile=coverage.out ./...
      - name: Run Ginkgo tests
        run: |
          go install github.com/onsi/ginkgo/v2/ginkgo@latest
          ginkgo -r --cover --coverprofile=cover.out
      - name: Upload coverage
        uses: codecov/codecov-action@v4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

version: '3.8'
services:
  test:
    build:
      context: .
      dockerfile: Dockerfile.test
    environment:
      - TEST_DB_HOST=postgres
      - TEST_REDIS_HOST=redis
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    command: go test -v -count=1 -tags=integration ./...
  
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: testdb
      POSTGRES_PASSWORD: testpass
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
  
  redis:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]

1
2
3
4

strategy:
  matrix:
    go-version: ['1.21', '1.22', '1.23']
    go-testing-framework: ['testify', 'ginkgo']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import (
    "embed"
    "testing"
)

//go:embed testdata/users.json
var usersFixture []byte

func TestUserImport(t *testing.T) {
    var users []User
    err := json.Unmarshal(usersFixture, &users)
    require.NoError(t, err)
    assert.Len(t, users, 10)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

func setupTestDB(t *testing.T) (*sql.DB, func()) {
    ctx := context.Background()
    container, err := postgres.Run(ctx,
        "postgres:16-alpine",
        postgres.WithDatabase("testdb"),
        postgres.WithUsername("test"),
        postgres.WithPassword("test"),
    )
    require.NoError(t, err)
    
    connStr, _ := container.ConnectionString(ctx)
    db, _ := sql.Open("postgres", connStr)
    
    return db, func() {
        db.Close()
        container.Terminate(ctx)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func TestRenderReport(t *testing.T) {
    result := RenderReport(testData)
    golden := filepath.Join("testdata", t.Name()+".golden")
    
    if *update {
        os.WriteFile(golden, []byte(result), 0644)
    }
    
    expected, _ := os.ReadFile(golden)
    assert.Equal(t, string(expected), result)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package testutil

func NewTestUser(t *testing.T, opts ...UserOption) *User {
    u := &User{Name: "testuser", Email: "test@example.com"}
    for _, opt := range opts {
        opt(u)
    }
    return u
}

func WithEmail(email string) UserOption {
    return func(u *User) { u.Email = email }
}