在 Go 中测试 REST API：使用 Go 标准测试库进行单元和集成测试的指南
介绍
本文将带您了解如何使用单元测试和集成测试来改善您在 golang 中创建 REST API 时的开发体验。
单元测试旨在验证应用程序最小的各个部分的功能，通常侧重于单个函数或方法。这些测试与代码的其他部分隔离进行，以确保每个组件都能按预期工作。
另一方面，集成测试评估应用程序的不同模块或组件如何协同工作。在本文中，我们将重点关注 Go 应用程序的集成测试，特别是通过成功创建和执行 SQL 查询来检查它是否与 PostgreSQL 数据库正确交互。
本文假设您熟悉 golang 以及如何在 golang 中创建 Rest api，主要重点是为您的路由创建测试（单元测试）和测试您的 sql 查询函数（集成测试）以供参考，请访问 github来看看这个项目。
设置
假设您已设置与上面链接的项目类似的项目，您将拥有与此类似的文件夹结构
test_project
|__cmd
|__api
|__api.go
|__main.go
|__db
|___seed.go
|__internal
|___db
|___db.go
|___services
|___records
|___routes_test.go
|___routes.go
|___store_test.go
|___store.go
|___user
|___routes_test.go
|___routes.go
|___store_test.go
|___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile
与您可能遇到过的其他语言相比，golang 中的测试很容易，因为内置的测试包提供了编写测试所需的工具。
测试文件以 _test.go 命名，此后缀允许 go 在运行 go test 命令时以该文件为目标执行。
我们项目的入口点是位于 cmd 文件夹中的 main.go 文件
// main.go
package main
import (
"log"
"finance-crud-app/cmd/api"
"finance-crud-app/internal/db"
"github.com/gorilla/mux"
"github.com/jmoiron/sqlx"
_ "github.com/lib/pq"
)
type Server struct {
db *sqlx.DB
mux *mux.Router
}
func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
return &Server{
db: db,
mux: mux,
}
}
func main() {
connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"
dbconn, err := db.NewPGStorage(connStr)
if err != nil {
log.Fatal(err)
}
defer dbconn.Close()
server := api.NewAPIServer(":8085", dbconn)
if err := server.Run(); err != nil {
log.Fatal(err)
}
}
从代码中您可以看到我们正在通过传递数据库连接和端口号来创建一个新的 api 服务器。创建服务器后，我们在指定的端口上运行它。
NewAPIServer 命令来自 api.go 文件，其中
// api.go
package api
import (
"finance-crud-app/internal/services/records"
"finance-crud-app/internal/services/user"
"log"
"net/http"
"github.com/gorilla/mux"
"github.com/jmoiron/sqlx"
)
type APIServer struct {
addr string
db *sqlx.DB
}
func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
return &APIServer{
addr: addr,
db: db,
}
}
func (s *APIServer) Run() error {
router := mux.NewRouter()
subrouter := router.PathPrefix("/api/v1").Subrouter()
userStore := user.NewStore(s.db)
userHandler := user.NewHandler(userStore)
userHandler.RegisterRoutes(subrouter)
recordsStore := records.NewStore(s.db)
recordsHandler := records.NewHandler(recordsStore, userStore)
recordsHandler.RegisterRoutes(subrouter)
log.Println("Listening on", s.addr)
return http.ListenAndServe(s.addr, router)
}
对于这个 api，我们使用 mux 作为我们的 http 路由器。
集成测试
我们有一个用户存储结构，用于处理与用户实体相关的 SQL 查询。
// store.go
package user
import (
"errors"
"finance-crud-app/internal/types"
"fmt"
"log"
"github.com/jmoiron/sqlx"
)
var (
CreateUserError = errors.New("cannot create user")
RetrieveUserError = errors.New("cannot retrieve user")
DeleteUserError = errors.New("cannot delete user")
)
type Store struct {
db *sqlx.DB
}
func NewStore(db *sqlx.DB) *Store {
return &Store{db: db}
}
func (s *Store) CreateUser(user types.User) (user_id int, err error) {
query := `
INSERT INTO users
(firstName, lastName, email, password)
VALUES (, , , )
RETURNING id`
var userId int
err = s.db.QueryRow(query, user.FirstName, user.LastName, user.Email, user.Password).Scan(&userId)
if err != nil {
return -1, CreateUserError
}
return userId, nil
}
func (s *Store) GetUserByEmail(email string) (types.User, error) {
var user types.User
err := s.db.Get(&user, "SELECT * FROM users WHERE email = ", email)
if err != nil {
return types.User{}, RetrieveUserError
}
if user.ID == 0 {
log.Fatalf("user not found")
return types.User{}, RetrieveUserError
}
return user, nil
}
func (s *Store) GetUserByID(id int) (*types.User, error) {
var user types.User
err := s.db.Get(&user, "SELECT * FROM users WHERE id = ", id)
if err != nil {
return nil, RetrieveUserError
}
if user.ID == 0 {
return nil, fmt.Errorf("user not found")
}
return &user, nil
}
func (s *Store) DeleteUser(email string) error {
user, err := s.GetUserByEmail(email)
if err != nil {
return DeleteUserError
}
// delete user records first
_, err = s.db.Exec("DELETE FROM records WHERE userid = ", user.ID)
if err != nil {
return DeleteUserError
}
_, err = s.db.Exec("DELETE FROM users WHERE email = ", email)
if err != nil {
return DeleteUserError
}
return nil
}
在上面的文件中，我们有 3 个指针接收器方法：
- 创建用户
- 通过电子邮件获取用户
- 获取UserById
为了让这些方法执行其功能，它们必须与外部系统交互，在本例中为 Postgres DB .
为了测试这个方法，我们首先创建一个 store_test.go 文件。在 go 中，我们通常以要测试的文件命名测试文件，并添加后缀 _test.go .
// store_test.go
package user_test
import (
"finance-crud-app/internal/db"
"finance-crud-app/internal/services/user"
"finance-crud-app/internal/types"
"log"
"os"
"testing"
"github.com/jmoiron/sqlx"
_ "github.com/lib/pq"
)
var (
userTestStore *user.Store
testDB *sqlx.DB
)
func TestMain(m *testing.M) {
// database
ConnStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"
testDB, err := db.NewPGStorage(ConnStr)
if err != nil {
log.Fatalf("could not connect %v", err)
}
defer testDB.Close()
userTestStore = user.NewStore(testDB)
code := m.Run()
os.Exit(code)
}
func TestCreateUser(t *testing.T) {
test_data := map[string]struct {
user types.User
result any
}{
"should PASS valid user email used": {
user: types.User{
FirstName: "testfirsjjlkjt-1",
LastName: "testlastkjh-1",
Email: "validuser@email.com",
Password: "00000000",
},
result: nil,
},
"should FAIL invalid user email used": {
user: types.User{
FirstName: "testFirstName1",
LastName: "testLastName1",
Email: "test1@email.com",
Password: "800890",
},
result: user.CreateUserError,
},
}
for name, tc := range test_data {
t.Run(name, func(t *testing.T) {
value, got := userTestStore.CreateUser(tc.user)
if got != tc.result {
t.Errorf("test fail expected %v got %v instead and value %v", tc.result, got, value)
}
})
}
t.Cleanup(func() {
err := userTestStore.DeleteUser("validuser@email.com")
if err != nil {
t.Errorf("could not delete user %v got error %v", "validuser@email.com", err)
}
})
}
func TestGetUserByEmail(t *testing.T) {
test_data := map[string]struct {
email string
result any
}{
"should pass valid user email address used": {
email: "test1@email.com",
result: nil,
},
"should fail invalid user email address used": {
email: "validuser@email.com",
result: user.RetrieveUserError,
},
}
for name, tc := range test_data {
got, err := userTestStore.GetUserByEmail(tc.email)
if err != tc.result {
t.Errorf("test fail expected %v instead got %v", name, got)
}
}
}
func TestGetUserById(t *testing.T) {
testUserId, err := userTestStore.CreateUser(types.User{
FirstName: "userbyid",
LastName: "userbylast",
Email: "unique_email",
Password: "unique_password",
})
if err != nil {
log.Panicf("got %v when creating testuser", testUserId)
}
test_data := map[string]struct {
user_id int
result any
}{
"should pass valid user id used": {
user_id: testUserId,
result: nil,
},
"should fail invalid user id used": {
user_id: 0,
result: user.RetrieveUserError,
},
}
for name, tc := range test_data {
t.Run(name, func(t *testing.T) {
_, got := userTestStore.GetUserByID(tc.user_id)
if got != tc.result {
t.Errorf("error retrieving user by id got %v want %v", got, tc.result)
}
})
}
t.Cleanup(func() {
err := userTestStore.DeleteUser("unique_email")
if err != nil {
t.Errorf("could not delete user %v got error %v", "unique_email", err)
}
})
}
func TestDeleteUser(t *testing.T) {
testUserId, err := userTestStore.CreateUser(types.User{
FirstName: "userbyid",
LastName: "userbylast",
Email: "delete_user@email.com",
Password: "unique_password",
})
if err != nil {
log.Panicf("got %v when creating testuser", testUserId)
}
test_data := map[string]struct {
user_email string
result error
}{
"should pass user email address used": {
user_email: "delete_user@email.com",
result: nil,
},
}
for name, tc := range test_data {
t.Run(name, func(t *testing.T) {
err = userTestStore.DeleteUser(tc.user_email)
if err != tc.result {
t.Errorf("error deletig user got %v instead of %v", err, tc.result)
}
})
}
t.Cleanup(func() {
err := userTestStore.DeleteUser("delete_user@email.com")
if err != nil {
log.Printf("could not delete user %v got error %v", "delete_user@email.com", err)
}
})
}
让我们浏览一下文件，看看每个部分的作用。
第一个操作是声明变量 userTestStore 和 testDB。这些变量将用于分别存储指向用户存储和数据库的指针。我们在全局文件作用域中声明它们的原因是因为我们希望测试文件中的所有函数都可以访问指针。
TestMain 函数允许我们在运行主测试之前执行一些设置操作。我们最初连接到 postgres 存储并将指针保存到我们的全局变量中。
我们已经使用该指针创建了一个 userTestStore，我们将使用它来执行我们尝试连接的 sql 查询。
defer testDB.Close() 测试完成后关闭数据库连接
code := m.Run() 在返回和退出之前运行测试函数的其余部分。
TestCreateUser 函数将处理 create_user 函数的测试。我们的目标是测试如果传递了唯一的电子邮件，该函数是否会创建用户，并且如果非唯一的电子邮件已被用于创建另一个用户，则该函数应该无法创建用户。
首先我们创建测试数据，用于测试这两种情况场景。
test_project
|__cmd
|__api
|__api.go
|__main.go
|__db
|___seed.go
|__internal
|___db
|___db.go
|___services
|___records
|___routes_test.go
|___routes.go
|___store_test.go
|___store.go
|___user
|___routes_test.go
|___routes.go
|___store_test.go
|___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile
我将循环遍历地图执行 create_user 函数，并以测试日期作为参数，并比较返回的值是否与我们期望的结果相同
// main.go
package main
import (
"log"
"finance-crud-app/cmd/api"
"finance-crud-app/internal/db"
"github.com/gorilla/mux"
"github.com/jmoiron/sqlx"
_ "github.com/lib/pq"
)
type Server struct {
db *sqlx.DB
mux *mux.Router
}
func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
return &Server{
db: db,
mux: mux,
}
}
func main() {
connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"
dbconn, err := db.NewPGStorage(connStr)
if err != nil {
log.Fatal(err)
}
defer dbconn.Close()
server := api.NewAPIServer(":8085", dbconn)
if err := server.Run(); err != nil {
log.Fatal(err)
}
}
如果返回的结果与预期结果不一样，那么我们的测试将失败
该函数的最后一部分是使用内置的测试包函数 Cleanup。该函数注册了一个函数，当测试中的所有函数都已执行时将调用该函数。在我们的示例中，我们使用该函数来清除在此测试函数执行期间使用的用户数据。
单元测试
对于我们的单元测试，我们将测试 api 的路由处理程序。在这种情况下，路由与用户实体相关。请观察下面。
// api.go
package api
import (
"finance-crud-app/internal/services/records"
"finance-crud-app/internal/services/user"
"log"
"net/http"
"github.com/gorilla/mux"
"github.com/jmoiron/sqlx"
)
type APIServer struct {
addr string
db *sqlx.DB
}
func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
return &APIServer{
addr: addr,
db: db,
}
}
func (s *APIServer) Run() error {
router := mux.NewRouter()
subrouter := router.PathPrefix("/api/v1").Subrouter()
userStore := user.NewStore(s.db)
userHandler := user.NewHandler(userStore)
userHandler.RegisterRoutes(subrouter)
recordsStore := records.NewStore(s.db)
recordsHandler := records.NewHandler(recordsStore, userStore)
recordsHandler.RegisterRoutes(subrouter)
log.Println("Listening on", s.addr)
return http.ListenAndServe(s.addr, router)
}
我们想要测试 3 个函数
- 处理登录
- 句柄注册
- HandleGetUser
处理获取用户
此处理程序中的handleGetUser 函数根据HTTP 请求URL 中提供的用户ID 检索用户详细信息。它首先使用 mux 路由器从请求路径变量中提取用户 ID。如果 userID 丢失或无效（非整数），则会返回 400 Bad Request 错误。验证后，该函数将调用数据存储上的 GetUserByID 方法来检索用户信息。如果检索期间发生错误，它将返回 500 内部服务器错误。成功后，它会响应 200 OK 状态，并在响应正文中以 JSON 形式发送用户详细信息。
如前所述，为了测试处理程序函数，我们需要创建一个 routes_test.go。请参阅下面我的
test_project
|__cmd
|__api
|__api.go
|__main.go
|__db
|___seed.go
|__internal
|___db
|___db.go
|___services
|___records
|___routes_test.go
|___routes.go
|___store_test.go
|___store.go
|___user
|___routes_test.go
|___routes.go
|___store_test.go
|___store.go
|__test_data
|__docker-compose.yml
|__Dockerfile
|__Makefile
我们的新处理程序函数需要一个用户存储作为参数来创建处理程序结构。
由于我们不需要实际存储，因此我们创建一个模拟结构并创建模拟实际结构函数的接收器函数。我们这样做是因为我们单独处理存储函数测试，因此我们不需要在处理程序测试中测试这部分代码。
测试函数 TestGetUserHandler 测试两种情况，第一种是尝试在不提供用户 ID 的情况下检索用户
// main.go
package main
import (
"log"
"finance-crud-app/cmd/api"
"finance-crud-app/internal/db"
"github.com/gorilla/mux"
"github.com/jmoiron/sqlx"
_ "github.com/lib/pq"
)
type Server struct {
db *sqlx.DB
mux *mux.Router
}
func NewServer(db *sqlx.DB, mux *mux.Router) *Server {
return &Server{
db: db,
mux: mux,
}
}
func main() {
connStr := "postgres://postgres:Password123@localhost:5432/crud_db?sslmode=disable"
dbconn, err := db.NewPGStorage(connStr)
if err != nil {
log.Fatal(err)
}
defer dbconn.Close()
server := api.NewAPIServer(":8085", dbconn)
if err := server.Run(); err != nil {
log.Fatal(err)
}
}
如果 http 请求响应 400 状态代码，则测试预计会通过。
第二个测试用例场景是我们使用包含有效用户 ID 的正确 url 检索用户信息的情况。在此测试用例中，我们期望得到 200 状态代码的响应。如果没有，测试就会失败。
// api.go
package api
import (
"finance-crud-app/internal/services/records"
"finance-crud-app/internal/services/user"
"log"
"net/http"
"github.com/gorilla/mux"
"github.com/jmoiron/sqlx"
)
type APIServer struct {
addr string
db *sqlx.DB
}
func NewAPIServer(addr string, db *sqlx.DB) *APIServer {
return &APIServer{
addr: addr,
db: db,
}
}
func (s *APIServer) Run() error {
router := mux.NewRouter()
subrouter := router.PathPrefix("/api/v1").Subrouter()
userStore := user.NewStore(s.db)
userHandler := user.NewHandler(userStore)
userHandler.RegisterRoutes(subrouter)
recordsStore := records.NewStore(s.db)
recordsHandler := records.NewHandler(recordsStore, userStore)
recordsHandler.RegisterRoutes(subrouter)
log.Println("Listening on", s.addr)
return http.ListenAndServe(s.addr, router)
}
结论
我们已经通过为路由处理程序创建测试来在我们的项目中实现单元测试。我们已经了解了如何使用模拟来仅测试一小部分代码。我们已经能够为与 Postgresql DB 交互的函数开发集成测试。
如果您想亲身体验项目代码，请在此处从 github 克隆存储库
以上是在 Go 中测试 REST API：使用 Go 标准测试库进行单元和集成测试的指南的详细内容。更多信息请关注PHP中文网其他相关文章！
热AI工具
Undresser.AI Undress
人工智能驱动的应用程序，用于创建逼真的裸体照片
AI Clothes Remover
用于从照片中去除衣服的在线人工智能工具。
Undress AI Tool
免费脱衣服图片
Clothoff.io
AI脱衣机
Video Face Swap
使用我们完全免费的人工智能换脸工具轻松在任何视频中换脸！
热门文章
热工具
记事本++7.3.1
好用且免费的代码编辑器
SublimeText3汉化版
中文版，非常好用
禅工作室 13.0.1
功能强大的PHP集成开发环境
Dreamweaver CS6
视觉化网页开发工具
SublimeText3 Mac版
神级代码编辑软件(SublimeText3)
Golang的目的：建立高效且可扩展的系统
Apr 09, 2025 pm 05:17 PM
Go语言在构建高效且可扩展的系统中表现出色，其优势包括：1.高性能：编译成机器码，运行速度快；2.并发编程：通过goroutines和channels简化多任务处理；3.简洁性：语法简洁，降低学习和维护成本；4.跨平台：支持跨平台编译，方便部署。
Golang和C：并发与原始速度
Apr 21, 2025 am 12:16 AM
Golang在并发性上优于C ，而C 在原始速度上优于Golang。1)Golang通过goroutine和channel实现高效并发，适合处理大量并发任务。2)C 通过编译器优化和标准库，提供接近硬件的高性能，适合需要极致优化的应用。
Golang vs. Python：主要差异和相似之处
Apr 17, 2025 am 12:15 AM
Golang和Python各有优势：Golang适合高性能和并发编程，Python适用于数据科学和Web开发。 Golang以其并发模型和高效性能着称，Python则以简洁语法和丰富库生态系统着称。
Golang vs. Python：性能和可伸缩性
Apr 19, 2025 am 12:18 AM
Golang在性能和可扩展性方面优于Python。1)Golang的编译型特性和高效并发模型使其在高并发场景下表现出色。2)Python作为解释型语言，执行速度较慢，但通过工具如Cython可优化性能。
表演竞赛：Golang vs.C
Apr 16, 2025 am 12:07 AM
Golang和C 在性能竞赛中的表现各有优势：1)Golang适合高并发和快速开发，2)C 提供更高性能和细粒度控制。选择应基于项目需求和团队技术栈。
Golang的影响：速度，效率和简单性
Apr 14, 2025 am 12:11 AM
GoimpactsdevelopmentPositationalityThroughSpeed，效率和模拟性。1）速度：gocompilesquicklyandrunseff，ifealforlargeprojects.2）效率：效率：ITScomprehenSevestAndArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdArdEcceSteral Depentencies，增强开发的简单性：3）SimpleflovelmentIcties：3）简单性。
C和Golang：表演至关重要时
Apr 13, 2025 am 12:11 AM
C 更适合需要直接控制硬件资源和高性能优化的场景，而Golang更适合需要快速开发和高并发处理的场景。1.C 的优势在于其接近硬件的特性和高度的优化能力，适合游戏开发等高性能需求。2.Golang的优势在于其简洁的语法和天然的并发支持，适合高并发服务开发。
Golang和C：性能的权衡
Apr 17, 2025 am 12:18 AM
Golang和C 在性能上的差异主要体现在内存管理、编译优化和运行时效率等方面。1)Golang的垃圾回收机制方便但可能影响性能，2)C 的手动内存管理和编译器优化在递归计算中表现更为高效。
