XORM框架怎么做单测和Mock数据库
在xorm中做单元测试并mock数据库,核心思路是利用go语言的接口特性,将具体的数据库引擎抽象为接口,并在测试环境中注入一个模拟实现。具体做法是定义一个包含`engineinterface`的上下文或结构体,在测试时创建一个实现了该接口的mock对象,拦截对`exec`、`query`等方法的调用并返回预设结果,从而在不连接真实数据库的情况下验证业务逻辑。

如何基于接口隔离实现可测试的业务层
要实现可测试的业务层,需要将数据访问逻辑从业务逻辑中剥离,通过依赖注入的方式传入数据库操作接口。这样在编写单元测试时,可以完全替换掉真实的XORM引擎,使用自定义的Mock结构体来模拟数据库的增删改查行为,确保测试的快速执行和数据隔离。

Drizzle ORM 是一个轻量级的 TypeScript ORM,提供类型安全的 SQL 模式声明、关系型和类 SQL 查询构建器,以及自动生成迁移。其压缩后仅 7.4kb,且无依赖项,支持 PostgreSQL、MySQL 和 SQLite,包括 Neon、Turso 和 Cloudflare D1 等无服务器数据库。
package main
import (
"fmt"
"log"
)
// EngineInterface 定义数据库操作接口
type EngineInterface interface {
Exec(query string, args ...interface{}) (sql.Result, error)
Query(query string, args ...interface{}) ([]map[string][]byte, error)
}
// MockEngine 模拟数据库引擎
type MockEngine struct {
ExpectError bool
Rows []map[string][]byte
}
func (m *MockEngine) Exec(query string, args ...interface{}) (sql.Result, error) {
if m.ExpectError {
return nil, fmt.Errorf("mock exec error")
}
return &mockResult{}, nil
}
func (m *MockEngine) Query(query string, args ...interface{}) ([]map[string][]byte, error) {
if m.ExpectError {
return nil, fmt.Errorf("mock query error")
}
return m.Rows, nil
}
type mockResult struct{}
func (m *mockResult) LastInsertId() (int64, error) { return 1, nil }
func (m *mockResult) RowsAffected() (int64, error) { return 1, nil }
// UserService 业务服务
type UserService struct {
Engine EngineInterface
}
func (u *UserService) GetUser(id int) (map[string][]byte, error) {
rows, err := u.Engine.Query("SELECT * FROM users WHERE id = ?", id)
if err != nil {
return nil, err
}
if len(rows) == 0 {
return nil, fmt.Errorf("user not found")
}
return rows[0], nil
}
func main() {
// 模拟测试场景
mock := &MockEngine{
Rows: []map[string][]byte{
{"id": []byte("1"), "name": []byte("Alice")},
},
}
userService := &UserService{Engine: mock}
user, err := userService.GetUser(1)
if err != nil {
log.Fatal(err)
}
fmt.Printf("User: %s\n", user["name"])
}如何处理XORM中的事务与复杂查询测试
在处理事务和复杂查询时,Mock策略需要覆盖`Begin`、`Commit`、`Rollback`以及多表关联查询的场景。可以通过在Mock结构中维护状态机来模拟事务的生命周期,或者针对特定的SQL模式返回不同的模拟数据,以验证业务代码在异常分支下的正确性。
package main
import (
"fmt"
"errors"
)
// TransactionalEngine 支持事务的Mock
type TransactionalEngine struct {
InTransaction bool
FailOnCommit bool
}
func (t *TransactionalEngine) Begin() (*Tx, error) {
t.InTransaction = true
return &Tx{engine: t}, nil
}
func (t *TransactionalEngine) Commit() error {
if t.FailOnCommit {
return errors.New("commit failed")
}
t.InTransaction = false
return nil
}
func (t *TransactionalEngine) Rollback() error {
t.InTransaction = false
return nil
}
type Tx struct {
engine *TransactionalEngine
}
func (tx *Tx) Exec(query string, args ...interface{}) (sql.Result, error) {
return &mockResult{}, nil
}
func (tx *Tx) Query(query string, args ...interface{}) ([]map[string][]byte, error) {
return nil, nil
}
// OrderService 订单服务示例
type OrderService struct {
Engine EngineInterface
}
func (o *OrderService) CreateOrder(userId int, productId int) error {
tx, err := o.Engine.Begin()
if err != nil {
return err
}
defer func() {
if r := recover(); r != nil {
tx.Rollback()
}
}()
_, err = tx.Exec("INSERT INTO orders (user_id, product_id) VALUES (?, ?)", userId, productId)
if err != nil {
tx.Rollback()
return err
}
_, err = tx.Exec("UPDATE inventory SET count = count - 1 WHERE product_id = ?", productId)
if err != nil {
tx.Rollback()
return err
}
return tx.Commit()
}
func main() {
mock := &TransactionalEngine{FailOnCommit: false}
service := &OrderService{Engine: mock}
err := service.CreateOrder(1, 100)
if err != nil {
fmt.Println("Order creation failed:", err)
} else {
fmt.Println("Order created successfully")
}
}当Mock返回空结果集时业务逻辑如何应对
当Mock返回空结果集时,业务逻辑通常会进入“未找到”的处理分支。在单元测试中,我们需要专门构造返回空切片或nil的Mock响应,验证代码是否正确处理了这种情况,例如返回特定的错误码或默认值,而不是直接 panic 或产生空指针异常。
package main
import (
"fmt"
"errors"
)
// EmptyResultEngine 返回空结果的Mock
type EmptyResultEngine struct{}
func (e *EmptyResultEngine) Exec(query string, args ...interface{}) (sql.Result, error) {
return &mockResult{}, nil
}
func (e *EmptyResultEngine) Query(query string, args ...interface{}) ([]map[string][]byte, error) {
return []map[string][]byte{}, nil // 返回空切片
}
// ProductService 产品服务
type ProductService struct {
Engine EngineInterface
}
func (p *ProductService) GetProduct(id int) (map[string][]byte, error) {
rows, err := p.Engine.Query("SELECT * FROM products WHERE id = ?", id)
if err != nil {
return nil, err
}
if len(rows) == 0 {
return nil, errors.New("product not found")
}
return rows[0], nil
}
func main() {
mock := &EmptyResultEngine{}
service := &ProductService{Engine: mock}
product, err := service.GetProduct(999)
if err != nil {
fmt.Println("Expected error:", err)
} else {
fmt.Printf("Product: %v\n", product)
}
}

















