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

// 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)
}

go test -v