GIN、GORM、TESTIFY、MYSQL 的 GOLANG 集成测试

gin、gorm、testify、mysql 的 golang 集成测试

使用 gin、gorm、testify 和 mysql（使用内存解决方案）等库为 golang 应用程序创建全面的集成测试涉及设置测试环境、定义路由和处理程序，并针对实际数据库对其进行测试（尽管为了简单起见，在内存中使用 mysql 可能需要一种解决方法，例如在内存模式中使用 sqlite）。

这是集成测试设置的示例：

1. 依赖关系：

gin：用于创建 http 服务器。
gorm：用于 orm 与数据库交互。
作证：用于断言。
内存中的 sqlite：在测试期间充当 mysql 的替代品。

2. 设置：

定义基本模型和 gorm 设置。
创建 http 路由和处理程序。
使用 testify 和 sqlite 作为内存数据库编写测试。

这是完整的示例：

// main.go
package main

import (
    "github.com/gin-gonic/gin"
    "gorm.io/driver/mysql"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "net/http"
)

// user represents a simple user model.
type user struct {
    id    uint   `gorm:"primarykey"`
    name  string `json:"name"`
    email string `json:"email" gorm:"unique"`
}

// setuprouter initializes the gin engine with routes.
func setuprouter(db *gorm.db) *gin.engine {
    r := gin.default()

    // inject the database into the handler
    r.post("/users", func(c *gin.context) {
        var user user
        if err := c.shouldbindjson(&user); err != nil {
            c.json(http.statusbadrequest, gin.h{"error": err.error()})
            return
        }
        if err := db.create(&user).error; err != nil {
            c.json(http.statusinternalservererror, gin.h{"error": err.error()})
            return
        }
        c.json(http.statuscreated, user)
    })

    r.get("/users/:id", func(c *gin.context) {
        var user user
        id := c.param("id")
        if err := db.first(&user, id).error; err != nil {
            c.json(http.statusnotfound, gin.h{"error": "user not found"})
            return
        }
        c.json(http.statusok, user)
    })

    return r
}

func main() {
    // for production, use mysql
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parsetime=true&loc=local"
    db, err := gorm.open(mysql.open(dsn), &gorm.config{})
    if err != nil {
        panic("failed to connect database")
    }

    db.automigrate(&user{})

    r := setuprouter(db)
    r.run(":8080")
}

集成测试

// main_test.go
package main

import (
    "bytes"
    "encoding/json"
    "github.com/stretchr/testify/assert"
    "net/http"
    "net/http/httptest"
    "testing"

    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

// setuptestdb sets up an in-memory sqlite database for testing.
func setuptestdb() *gorm.db {
    db, err := gorm.open(sqlite.open(":memory:"), &gorm.config{})
    if err != nil {
        panic("failed to connect to the test database")
    }
    db.automigrate(&user{})
    return db
}

func testcreateuser(t *testing.t) {
    db := setuptestdb()
    r := setuprouter(db)

    // create a new user.
    user := user{name: "john doe", email: "john@example.com"}
    jsonvalue, _ := json.marshal(user)
    req, _ := http.newrequest("post", "/users", bytes.newbuffer(jsonvalue))
    req.header.set("content-type", "application/json")
    w := httptest.newrecorder()
    r.servehttp(w, req)

    assert.equal(t, http.statuscreated, w.code)

    var createduser user
    json.unmarshal(w.body.bytes(), &createduser)
    assert.equal(t, "john doe", createduser.name)
    assert.equal(t, "john@example.com", createduser.email)
}

func testgetuser(t *testing.t) {
    db := setuptestdb()
    r := setuprouter(db)

    // insert a user into the in-memory database.
    user := user{name: "jane doe", email: "jane@example.com"}
    db.create(&user)

    // make a get request.
    req, _ := http.newrequest("get", "/users/1", nil)
    w := httptest.newrecorder()
    r.servehttp(w, req)

    assert.equal(t, http.statusok, w.code)

    var fetcheduser user
    json.unmarshal(w.body.bytes(), &fetcheduser)
    assert.equal(t, "jane doe", fetcheduser.name)
    assert.equal(t, "jane@example.com", fetcheduser.email)
}

func testgetusernotfound(t *testing.t) {
    db := setuptestdb()
    r := setuprouter(db)

    // make a get request for a non-existent user.
    req, _ := http.newrequest("get", "/users/999", nil)
    w := httptest.newrecorder()
    r.servehttp(w, req)

    assert.equal(t, http.statusnotfound, w.code)
}

解释

main.go：
- 定义一个 user 结构并使用 gin 设置基本的 crud 操作。
- 使用 gorm 进行数据库交互并自动迁移 user 表。
- setuprouter 配置 http 端点。
main_test.go：
- setuptestdb 初始化内存 sqlite 数据库以进行隔离测试。
- testcreateuser：测试用户的创建。
- testgetuser：测试获取现有用户。
- testgetusernotfound：测试获取不存在的用户。
- 使用 httptest.newrecorder 和 http.newrequest 来模拟 http 请求和响应。
- 使用 testify 进行断言，例如检查 http 状态代码和验证 json 响应。

运行测试

要运行测试，请使用：

go test -v

注意事项

用于内存测试的 sqlite：此示例使用 sqlite 进行内存测试，因为 mysql 本身并不支持 gorm 的内存模式。对于依赖于 mysql 特定功能的测试，请考虑使用基于 docker 的设置和 mysql 容器。
数据库迁移：在测试中使用 automigrate 始终确保数据库架构是最新的。
隔离：每个测试函数都会初始化一个新的内存数据库，确保测试不会相互干扰。

以上就是GIN、GORM、TESTIFY、MYSQL 的 GOLANG 集成测试的详细内容，更多请关注www.sxiaw.com其它相关文章！