我在模型设计方面遇到了一些问题，特别是处理模型特定操作与数据库操作。我的用户模型就是一个很好的例子。

在我的数据库中创建用户时，我想:

1. 验证密码是否符合标准(模型操作)
2. 创建摘要(模型操作)
3. 设置时间戳(模型操作)
4. 将电子邮件、摘要和时间戳保存到数据库(数据库操作)

在测试时，我显然希望对所有 4 个进行一组单元测试，但是 #4 调用了其他 3 个，我不想重新测试，否则如果其中任何一个测试失败，#4 可能会失败3 做。

我想出了为 ModelActions 和 StoreActions 创建一个单独的接口(interface)，并在需要时将 UserAction 接口(interface)发送到存储操作，但是当我写出来时，我已经感觉到一些严重的代码味道。

type User struct {
        ID                   int    `json:"id"`
        Email                string `json:"email"`
        Password             string `json:"password"`
        ConfirmationPassword string `json:"confirmationPassword"`
        passwordDigest       string `json:"-"`
        CreatedAt            time.Time `json:"createdAt,omitempty"`
        ModifiedAt           time.Time `json:"modifiedAt,omitempty"`
}

//UserStore is the interface for all User functions that interact with the database
type UserStore interface {
        GetUserByEmailAndPassword(email, password string) (User, error)
        UpdatePassword(u UserAction, previousPassword, password, confirmationPassword string) error
        UserExists(email string) (bool, error)
        CreateUser(u UserAction) error
}

// I am going against design Principles by having GetID, GetEmail, since JSON unmarshalling needs the struct fields to be capitalized, which is already a warning sign for me

type UserAction interface {
        GetID() int
        GetEmail() string
        Timestamps() (time.Time, time.Time)
        SetID(id int)
        SetTimestamps()
        SetPassword(password, confirmation string)
        SetDigest(digest string)
        CreateDigest() (string, error)
        VerifyPassword() error
        ComparePassword(password string) error
}

// Example of UserActions
func (u *User) CreateDigest() (string, error) {
        var digest string
        if err := u.VerifyPassword(); err != nil {
                return digest, err
        }

        passwordByte, err := bcrypt.GenerateFromPassword([]byte(u.Password), bcrypt.DefaultCost)
        if err != nil {
                return digest, err
        }

        digest = string(passwordByte)
        return digest, nil
}

func (u *User) VerifyPassword() error {
        if len(u.Password) < 6 {
                return &modelError{"Password", "must be at least 6 characters long"}
        }

        if u.Password != u.ConfirmationPassword {
                return &modelError{"ConfirmationPassword", "does not match Password"}
        }

        return nil
}

// Example of DB Action
func (db *DB) CreateUser(ua UserAction) error {
        if exists, err := db.UserExists(ua.GetEmail()); err != nil {
                return err
        } else if exists {
                return &modelError{"Email", "already exists in the system"}
        }

        // set password
        digest, err := ua.CreateDigest()
        if  err != nil {
                return err
        }

        ua.SetDigest(digest)
        ua.SetTimestamps()

        createdAt, modifiedAt := ua.Timestamps()

        rows, err := db.Query(`
                INSERT INTO users (email, password_digest, created_at, modified_at)
                        VALUES ($1, $2, $3, $4)
                        RETURNING id
                `, ua.GetEmail(), digest, createdAt, modifiedAt)

        if err != nil {
                return err
        }

        defer rows.Close()

        var id int
        for rows.Next() {
                if err := rows.Scan(&id); err != nil {
                        return err
                }
        }

        ua.SetID(id)

        return nil
}

有没有更好的方法来模拟这些单独的操作，以便在测试 DB/Store 函数时可以模拟 UserActions？我尝试将 User 结构存储为界面的一部分，例如:

type UserAction {
    SetTimestamps()
    CreateDigest() (string, error)
    VerifyPassword() error
    ComparePassword(password string) error
    User() *User
}

然而，这会在创建模拟时导致循环导入，并且还会打开所有字段，这些字段可以说是可用的，因为模型的字段是可导出的

最佳答案

我认为您的用户应该是具体类型，您应该使用一个界面来模拟您的商店。

例如，像这样的项目结构对我来说很有意义:

cmd/
   server/
      user.go
      user_test.go
      main.go
      store.go
mysql/
   mysql.go
   user.go
   user_test.go
user.go
user_test.go

您的用户模型位于根部，在 user.go 中。该文件将包含您的 User 结构，以及将对其进行操作的函数，例如 CreateDigest。这些函数应该在 user_test.go 中进行测试。

值得一提的是，在你的根目录下，你的包不应该是main，你的包名应该是你项目的名字，我们称它为myapp。

你的mysql、postgres等也应该是具体的实现。您可能在该包中有一个函数，例如:

func (m *MySQL) InsertUser(u *myapp.User) error

这个函数应该在 mysql/user_test.go 中测试。

最后，我们可以将它们放在server 中。这是您实际部署或运行​​的二进制文件。

在cmd/server/store.go 中，您应该创建一个将由mysql 实现的接口(interface)。

在 cmd/server/user_test.go 中很容易模拟它，这样您就不必访问真实的数据库。我相信您的界面应该存在于您的客户端中。在这种情况下，server 是 mysql 的客户端。

在 cmd/server/user.go 中，您可能具有如下所示的函数:

func CreateUser(w http.ResponseWriter, r *http.Request) {
  var u myapp.user
  err := json.NewDecoder(r.Body).Decode(&u)
  if err != nil {
    panic(err) // don't do this for real
  }

  d := myapp.CreateDigest(u.Password)
  u.Digest = d

  // s is the interface, defined in `cmd/server/store.go`, but is implemented by mysql
  err = s.InsertUser(&u)
  if err != nil {
    panic(err)
  }

  // Since we pass a pointer, you can have your store set the ID of the user
  fmt.Println(u.ID)
}

现在您可以更好地分离关注点，一切都应该易于测试，并且更改现有代码也很容易。

关于go - 处理模型特定操作与数据库操作，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50588831/