Go 单位测试之Mysql数据库集成测试

目录

• 一、 sqlmock先容
  
• 二、安装
  
• 三、基本用法
  
• 四、一个小案例
  
• 五、Gorm 初始化留意点
  

一、 sqlmock先容

sqlmock 是一个用于测试数据库交互的 Go 模拟库。它可以模拟 SQL 查询、插入、更新等操作，并且可以验证 SQL 语句的实行环境，非常得当用于单位测试中。
二、安装

1. go get github.com/DATA-DOG/go-sqlmock

复制代码

三、基本用法

使用 sqlmock 举行 MySQL 数据库集成测试的基本步骤如下：

• 创建模拟 DB 毗连：
  

1. import (
2.     "database/sql"
3.     "testing"
4.     "github.com/DATA-DOG/go-sqlmock"
5. )
7. func TestMyDBFunction(t *testing.T) {
8.     db, mock, err := sqlmock.New()
9.     if err != nil {
10.         t.Fatalf("Error creating mock database: %v", err)
11.     }
12.     defer db.Close()
13.    
14.     // 使用 mock 来替代真实的数据库连接
15.     // db 可以传递给被测试的函数进行测试
16. }

复制代码

• 设置模拟 SQL 查询和预期效果：
  

1. // 模拟 SQL 查询并设置预期结果
2. rows := sqlmock.NewRows([]string{"id", "name"}).AddRow(1, "Alice").AddRow(2, "Bob")
3. mock.ExpectQuery("SELECT id, name FROM users").WillReturnRows(rows)

复制代码

• 调用被测试的函数，并传入模拟的数据库毗连：
  

1. // 调用被测试的函数，传入模拟的数据库连接
2. result := MyDBFunction(db)
4. // 验证结果是否符合预期
5. if result != expected {
6.     t.Errorf("Expected %d, got %d", expected, result)
7. }

复制代码

四、一个小案例

这里我们定义了一个 GORMUserDAO 结构体，它实现了 UserDAO 接口，用于与用户表举行交互。这个结构体通过 gorm.DB 实例与数据库举行通信。
具体来说，GORMUserDAO 提供了 Insert 方法，用于在数据库中创建新用户。这个方法担当一个 User 类型的结构体作为参数，该结构体定义了用户的基本信息，包括 ID、邮箱、暗码、手机号、生日、昵称、自我先容、微信 UnionID 和 OpenID 等字段。
在 Insert 方法中，起首获取当前时间戳（以毫秒为单位），并设置用户的创建时间和更新时间。然后，使用 gorm.DB 的 Create 方法将用户信息插入到数据库中。如果插入操作碰到唯一性约束错误（例如邮箱或手机号已存在），方法会返回一个特定的错误 ErrUserDuplicate。
User 结构体定义了数据库表的结构，其中包含了一些列的定义，如 Email 和 Phone 被设置为唯一索引。此外，还定义了一些列的类型和约束，如 AboutMe 字段被设置为最大长度为 1024 的字符串类型。
提供了一个使用 GORM 举行数据库操作的 DAO 层，用于处置惩罚用户数据的创建。

1. // internal/user/dao/user.go
2. package dao
4. import (
5.         "context"
6.         "database/sql"
7.         "errors"
8.         "github.com/go-sql-driver/mysql"
9.         "gorm.io/gorm"
10.         "time"
11. )
13. var (
14.         ErrUserDuplicate = errors.New("邮箱冲突")
15. )
17. type UserDAO interface {
18.         Insert(ctx context.Context, u User) error
19. }
21. type GORMUserDAO struct {
22.         db *gorm.DB
23. }
25. func NewUserDAO(db *gorm.DB) UserDAO {
26.         return &GORMUserDAO{
27.                 db: db,
28.         }
29. }
31. func (dao *GORMUserDAO) Insert(ctx context.Context, u User) error {
32.         // 存毫秒数
33.         now := time.Now().UnixMilli()
34.         u.Utime = now
35.         u.Ctime = now
36.         err := dao.db.WithContext(ctx).Create(&u).Error
37.         if mysqlErr, ok := err.(*mysql.MySQLError); ok {
38.                 const uniqueConflictsErrNo uint16 = 1062
39.                 if mysqlErr.Number == uniqueConflictsErrNo {
40.                         // 邮箱冲突 or 手机号码冲突
41.                         return ErrUserDuplicate
42.                 }
43.         }
44.         return err
45. }
47. // User 直接对应数据库表结构
48. // 有些人叫做 entity，有些人叫做 model，有些人叫做 PO(persistent object)
49. type User struct {
50.         Id int64 `gorm:"primaryKey,autoIncrement"`
51.         // 设置为唯一索引
52.         Email    sql.NullString `gorm:"unique"`
53.         Password string
55.         //Phone *string
56.         Phone sql.NullString `gorm:"unique"`
58.         Birthday sql.NullInt64
59.         // 昵称
60.         Nickname sql.NullString
61.         // 自我介绍
62.         AboutMe       sql.NullString `gorm:"type=varchar(1024)"`
63.         WechatUnionID sql.NullString
64.         WechatOpenID  sql.NullString `gorm:"unique"`
66.         // 创建时间
67.         Ctime int64
68.         // 更新时间
69.         Utime int64
70. }

复制代码

接着我们用编写测试用例

1. package dao
3. import (
4.         "context"
5.         "database/sql"
6.         "errors"
7.         "github.com/DATA-DOG/go-sqlmock"
8.         "github.com/go-sql-driver/mysql"
9.         "github.com/stretchr/testify/assert"
10.         "github.com/stretchr/testify/require"
11.         gormMysql "gorm.io/driver/mysql"
12.         "gorm.io/gorm"
13.         "testing"
14. )
16. func TestGORMUserDAO_Insert(t *testing.T) {
17.         //
18.         testCases := []struct {
19.                 name string
21.                 // 为什么不用 ctrl ?
22.                 // 因为你这里是 sqlmock，不是 gomock
23.                 mock func(t *testing.T) *sql.DB
25.                 ctx  context.Context
26.                 user User
28.                 wantErr error
29.         }{
30.                 {
31.                         name: "插入成功",
32.                         mock: func(t *testing.T) *sql.DB {
33.                                 mockDB, mock, err := sqlmock.New()
34.                                 res := sqlmock.NewResult(3, 1)
35.                                 // 这边预期的是正则表达式
36.                                 // 这个写法的意思就是，只要是 INSERT 到 users 的语句
37.                                 mock.ExpectExec("INSERT INTO `users` .*").
38.                                         WillReturnResult(res)
39.                                 require.NoError(t, err)
40.                                 return mockDB
41.                         },
42.                         user: User{
43.                                 Email: sql.NullString{
44.                                         String: "123@qq.com",
45.                                         Valid:  true,
46.                                 },
47.                         },
48.                 },
49.                 {
50.                         name: "邮箱冲突",
51.                         mock: func(t *testing.T) *sql.DB {
52.                                 mockDB, mock, err := sqlmock.New()
53.                                 // 这边预期的是正则表达式
54.                                 // 这个写法的意思就是，只要是 INSERT 到 users 的语句
55.                                 mock.ExpectExec("INSERT INTO `users` .*").
56.                                         WillReturnError(&mysql.MySQLError{
57.                                                 Number: 1062,
58.                                         })
59.                                 require.NoError(t, err)
60.                                 return mockDB
61.                         },
62.                         user:    User{},
63.                         wantErr: ErrUserDuplicate,
64.                 },
65.                 {
66.                         name: "数据库错误",
67.                         mock: func(t *testing.T) *sql.DB {
68.                                 mockDB, mock, err := sqlmock.New()
69.                                 // 这边预期的是正则表达式
70.                                 // 这个写法的意思就是，只要是 INSERT 到 users 的语句
71.                                 mock.ExpectExec("INSERT INTO `users` .*").
72.                                         WillReturnError(errors.New("数据库错误"))
73.                                 require.NoError(t, err)
74.                                 return mockDB
75.                         },
76.                         user:    User{},
77.                         wantErr: errors.New("数据库错误"),
78.                 },
79.         }
80.         for _, tc := range testCases {
81.                 t.Run(tc.name, func(t *testing.T) {
82.                         db, err := gorm.Open(gormMysql.New(gormMysql.Config{
83.                                 Conn: tc.mock(t),
84.                                 // SELECT VERSION;
85.                                 SkipInitializeWithVersion: true,
86.                         }), &gorm.Config{
87.                                 // 你 mock DB 不需要 ping
88.                                 DisableAutomaticPing: true,
89.                                 // 这个是什么呢？
90.                                 SkipDefaultTransaction: true,
91.                         })
92.                         d := NewUserDAO(db)
93.                         u := tc.user
94.                         err = d.Insert(tc.ctx, u)
95.                         assert.Equal(t, tc.wantErr, err)
97.                 })
98.         }
99. }

复制代码

五、Gorm 初始化留意点

这里运行测试的代码也有点与众不同，在初始化 GORM 的时候必要额外设置三个参数。

• SkipInitializeWithVersion：如果为 false，那么 GORM 在初始化的时候，会先调用 show version。
  
• DisableAutomiticPing：为 true 不允许 Ping 数据库。
  
• SkipDefaultTransaction：为 false 的时候，即便是一个单一增删改语句，GORM 也会开启事务。
  

这三个选项禁用之后，就可以确保 GORM 不会在初始化的过程中发起额外的调用。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。