如何在golang中测试映射对象

huangapple
go评论114阅读模式
英文:

How to Test mapped Objects in golang

问题

我尝试在我的Go代码中实现一些单元测试，并发现模拟方法的主题相当困难。
我有以下示例，希望你能帮助我 如何在golang中测试映射对象

在第一层中，我有以下代码：

  1. package api
  3. import (
  4. 	"fmt"
  5.     "core"
  6. )
  8. type createUserDTO struct {
  9. 	Id string
  10. }
  12. func ApiMethod() {
  13. 	fmt.Println("some incoming api call wit user")
  14. 	incomingUserData := &createUserDTO{Id: "testId"}
  15. 	mapedUser := incomingUserData.mapUser()
  16. 	mapedUser.Create()
  17. }
  19. func (createUserDTO *createUserDTO) mapUser() core.User {
  20. 	return &core.UserCore{Id: createUserDTO.Id}
  21. }

第二层有以下代码：

  1. package core
  3. import (
  4. 	"fmt"
  5. )
  7. type CoreUser struct{ Id string }
  9. type User interface {
  10. 	Create()
  11. }
  13. func (user CoreUser) Create() {
  14. 	fmt.Println("Do Stuff")
  15. }

我的问题是，如何在不测试核心包的情况下测试api包中的每个公共方法，特别是Create()方法。

英文:

I try to implement some unit testing in my go code and find the topic of mocking method quite difficult.
I have the following example where I hope you can help me 如何在golang中测试映射对象

On the first layer I have the following code:

  1. package api
  3. import (
  4. 	"fmt"
  5.     "core"
  6. )
  8. type createUserDTO struct {
  9. 	Id string
  10. }
  12. func ApiMethod() {
  13. 	fmt.Println("some incoming api call wit user")
  14. 	incomingUserData := &createUserDTO{Id: "testId"}
  15. 	mapedUser := incomingUserData.mapUser()
  16. 	mapedUser.Create()
  17. }
  19. func (createUserDTO *createUserDTO) mapUser() core.User {
  20. 	return &core.UserCore{Id: createUserDTO.Id}
  21. }

The second layer has the following code:

  1. package core
  3. import (
  4. 	"fmt"
  5. )
  7. type CoreUser struct{ Id string }
  9. type User interface {
  10. 	Create()
  11. }
  13. func (user CoreUser) Create() {
  14. 	fmt.Println("Do Stuff")
  15. }

My question now is, how do I test every public method in the api package without testing the core package. Especially the method Create().

答案1

得分: 1

根据评论，我创建了一个简单的GitHub存储库，展示了我通常如何在Go中组织项目结构。该存储库目前不考虑测试部分，但使用这种项目结构应该很容易插入测试。

让我们从一般文件夹布局开始：

  • controllers（控制器）
  • services（服务）
  • db（数据库）
  • dto（数据传输对象）
  • models（模型）

现在，让我们看看相关的文件。

models/user.go
  1. package models
  3. import "gorm.io/gorm"
  5. type User struct {
  6. 	*gorm.Model
  7. 	Id string `gorm:"primaryKey"`
  8. }
  10. func NewUser(id string) *User {
  11. 	return &User{Id: id}
  12. }

这里是简单的结构定义。

dto/user.go
  1. package dto
  3. import "time"
  5. type UserDTO struct {
  6. 	Id      string    `json:"id"`
  7. 	AddedOn time.Time `json:"added_on"`
  8. }
  10. func NewUserDTO(id string) *UserDTO {
  11. 	return &UserDTO{Id: id}
  12. }

我们用一个虚拟的AddedOn字段丰富了模型结构，这只是为了演示而需要。

db/user.go
  1. package db
  3. import (
  4. 	"gorm.io/gorm"
  6. 	"userapp/models"
  7. )
  9. type UserDb struct {
  10. 	Conn *gorm.DB
  11. }
  13. type UserDbInterface interface {
  14. 	SaveUser(user *models.User) error
  15. }
  17. func (u *UserDb) SaveUser(user *models.User) error {
  18. 	if dbTrn := u.Conn.Create(user); dbTrn.Error != nil {
  19. 		return dbTrn.Error
  20. 	}
  21. 	return nil
  22. }

在这里，我们为使用User存储库定义了一个接口。在我们的测试中，我们可以提供一个模拟对象，而不是UserDb结构的实例。

services/user.go
  1. package services
  3. import (
  4. 	"time"
  6. 	"userapp/db"
  7. 	"userapp/dto"
  8. 	"userapp/models"
  9. )
  11. type UserService struct {
  12. 	DB db.UserDbInterface
  13. }
  15. type UserServiceInterface interface {
  16. 	AddUser(inputReq *dto.UserDTO) (*dto.UserDTO, error)
  17. }
  19. func NewUserService(db db.UserDbInterface) *UserService {
  20. 	return &UserService{
  21. 		DB: db,
  22. 	}
  23. }
  25. func (u *UserService) AddUser(inputReq *dto.UserDTO) (*dto.UserDTO, error) {
  26. 	// 这里可以编写复杂的逻辑
  27. 	user := models.NewUser(inputReq.Id)
  29. 	// 调用数据库存储库
  30. 	if err := u.DB.SaveUser(user); err != nil {
  31. 		return nil, err
  32. 	}
  34. 	inputReq.AddedOn = time.Now()
  36. 	return inputReq, nil
  37. }

这是连接表示层和底层存储库之间的桥梁层。

controllers/user.go
  1. package controllers
  3. import (
  4. 	"encoding/json"
  5. 	"io"
  6. 	"net/http"
  8. 	"userapp/dto"
  9. 	"userapp/services"
  10. )
  12. type UserController struct {
  13. 	US services.UserServiceInterface
  14. }
  16. func NewUserController(userService services.UserServiceInterface) *UserController {
  17. 	return &UserController{
  18. 		US: userService,
  19. 	}
  20. }
  22. func (u *UserController) Save(w http.ResponseWriter, r *http.Request) {
  23. 	reqBody, err := io.ReadAll(r.Body)
  24. 	if err != nil {
  25. 		panic(err)
  26. 	}
  27. 	r.Body.Close()
  29. 	var userReq dto.UserDTO
  31. 	json.Unmarshal(reqBody, &userReq)
  33. 	userRes, err := u.US.AddUser(&userReq)
  34. 	if err != nil {
  35. 		w.WriteHeader(http.StatusInternalServerError)
  36. 		json.NewEncoder(w).Encode(err)
  37. 		return
  38. 	}
  40. 	w.WriteHeader(http.StatusCreated)
  41. 	json.NewEncoder(w).Encode(userRes)
  42. }

在这里，我们定义了控制器（通过依赖注入）使用UserService结构。

你可以在我的GitHub存储库中找到所有内容：GitHub。如果有任何疑问，请告诉我。

英文:

Based on the comments, I put together a trivial GitHub repository to show how I usually deal with structuring projects in Go. The repository doesn't take into consideration the test part for now but it should be pretty easy to insert them with this project structure.
Let's start with the general folders' layout:

  • controllers
  • services
  • db
  • dto
  • models

Now, let's see the relevant files.

models/user.go
  1. package models
  3. import "gorm.io/gorm"
  5. type User struct {
  6. 	*gorm.Model
  7. 	Id string `gorm:"primaryKey"`
  8. }
  10. func NewUser(id string) *User {
  11. 	return &User{Id: id}
  12. }

Simple struct definition here.

dto/user.go
  1. package dto
  3. import "time"
  5. type UserDTO struct {
  6. 	Id      string    `json:"id"`
  7. 	AddedOn time.Time `json:"added_on"`
  8. }
  10. func NewUserDTO(id string) *UserDTO {
  11. 	return &UserDTO{Id: id}
  12. }

We enrich the model struct with a dummy AddedOn field which needs only for the sake of the demo.

db/user.go
  1. package db
  3. import (
  4. 	"gorm.io/gorm"
  6. 	"userapp/models"
  7. )
  9. type UserDb struct {
  10. 	Conn *gorm.DB
  11. }
  13. type UserDbInterface interface {
  14. 	SaveUser(user *models.User) error
  15. }
  17. func (u *UserDb) SaveUser(user *models.User) error {
  18. 	if dbTrn := u.Conn.Create(user); dbTrn.Error != nil {
  19. 		return dbTrn.Error
  20. 	}
  21. 	return nil
  22. }

Here, we define an interface for using the User repository. In our tests, we can provide a mock instead of an instance of the UserDb struct.

services/user.go
  1. package services
  3. import (
  4. 	"time"
  6. 	"userapp/db"
  7. 	"userapp/dto"
  8. 	"userapp/models"
  9. )
  11. type UserService struct {
  12. 	DB db.UserDbInterface
  13. }
  15. type UserServiceInterface interface {
  16. 	AddUser(inputReq *dto.UserDTO) (*dto.UserDTO, error)
  17. }
  19. func NewUserService(db db.UserDbInterface) *UserService {
  20. 	return &UserService{
  21. 		DB: db,
  22. 	}
  23. }
  25. func (u *UserService) AddUser(inputReq *dto.UserDTO) (*dto.UserDTO, error) {
  26. 	// here you can write complex logic
  27. 	user := models.NewUser(inputReq.Id)
  29. 	// invoke db repo
  30. 	if err := u.DB.SaveUser(user); err != nil {
  31. 		return nil, err
  32. 	}
  34. 	inputReq.AddedOn = time.Now()
  36. 	return inputReq, nil
  37. }

This is the layer that bridges connections between the presentation layer and the underlying repositories.

controllers/user.go
  1. package controllers
  3. import (
  4. 	"encoding/json"
  5. 	"io"
  6. 	"net/http"
  8. 	"userapp/dto"
  9. 	"userapp/services"
  10. )
  12. type UserController struct {
  13. 	US services.UserServiceInterface
  14. }
  16. func NewUserController(userService services.UserServiceInterface) *UserController {
  17. 	return &UserController{
  18. 		US: userService,
  19. 	}
  20. }
  22. func (u *UserController) Save(w http.ResponseWriter, r *http.Request) {
  23. 	reqBody, err := io.ReadAll(r.Body)
  24. 	if err != nil {
  25. 		panic(err)
  26. 	}
  27. 	r.Body.Close()
  29. 	var userReq dto.UserDTO
  31. 	json.Unmarshal(reqBody, &userReq)
  33. 	userRes, err := u.US.AddUser(&userReq)
  34. 	if err != nil {
  35. 		w.WriteHeader(http.StatusInternalServerError)
  36. 		json.NewEncoder(w).Encode(err)
  37. 		return
  38. 	}
  40. 	w.WriteHeader(http.StatusCreated)
  41. 	json.NewEncoder(w).Encode(userRes)
  42. }

Here, we defined the controller that (through Dependency Injection) uses the UserService struct.

You can find everything in my repository on GitHub
Let me know if it clarifies a little bit.

huangapple
  • 本文由 发表于 2022年11月14日 06:10:04
  • 转载请务必保留本文链接：https://go.coder-hub.com/74425152.html
  • go
  • mocking
  • testing
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定