对 Bcrypt 进行单元测试

golang学习网今天将给大家带来《对 Bcrypt 进行单元测试》，感兴趣的朋友请继续看下去吧！以下内容将会涉及到等等知识点，如果你是正在学习Golang或者已经是大佬级别了，都非常欢迎也希望大家都能给我建议评论哈~希望能帮助到大家！

我正在对一项服务执行单元测试，其中使用 go 的 bcrypt 包验证请求 dto 并对用户密码进行哈希处理，然后将其传递到存储库以插入数据库。

我不知道我的模拟函数应该如何返回一个与服务的哈希值匹配的虚拟响应。

func test_should_create_new_account(t *testing.t) {
    // arrange
    teardown := setup(t)
    defer teardown()

    // ** focus here **
    hashedpassword, err := appcrypto.hashandsalt([]byte("securepassword"))

    request := dto.registerrequest{
        email:    "[email protected]",
        password: "securepassword",
        roleid:   1,
    }

    account := realdomain.account{
        email:    request.email,
        password: hashedpassword,
        roleid:   request.roleid,
    }

    accountwithid := account
    accountwithid.accountid = 1

    mockrepo.expect().create(account).return(&accountwithid, nil)
    // act
    res, err := service.registeraccount(request)

    // assert
    if err != nil {
        t.error("failed while creating account")
    }
    if !res.created {
        t.error("failed while creating account")
    }
}

hashandsalt 只是对给定字符串进行哈希处理。

// hashandsalt hashes a given string
func hashandsalt(pwd []byte) (string, *errs.apperror) {

    // use generatefrompassword to hash & salt pwd.
    // mincost is just an integer constant provided by the bcrypt
    // package along with defaultcost & maxcost.
    // the cost can be any value you want provided it isn't lower
    // than the mincost (4)
    hash, err := bcrypt.generatefrompassword(pwd, bcrypt.mincost)
    if err != nil {
        return "", errs.newunexpectederror("an unexpected error ocurred while hashing the password" + err.error())
    } // generatefrompassword returns a byte slice so we need to
    // convert the bytes to a string and return it
    return string(hash), nil
}

这是服务的 registeraccount

func (d defaultaccountservice) registeraccount(request dto.registerrequest) (*dto.registerresponse, *errs.apperror) {
    err := request.validate()
    if err != nil {
        return nil, err
    }
    // hash the request's password
    hashedpassword, err := appcrypto.hashandsalt([]byte(request.password))

    if err != nil {
        return nil, err
    }
    // assign the hashed password to the request obj
    request.password = hashedpassword
    a := request.todomainobject()

    _, err = d.repo.create(a)
    if err != nil {
        return nil, err
    }
    response := dto.registerresponse{
        created: true,
    }
    return &response, nil
}

这是抛出的错误，请注意 got 块，其中模拟请求与给定请求不匹配。

accountService.go:34: Unexpected call to *domain.MockAccountRepository.Create([{0 [email protected] 1 $2a$04$.ORGMDZNk3.ySMpKwJYYcONdpAbgMJh79UDApzwRnzkCe.qeiECUG false}]) at /home/dio/Documents/Code/go-beex-backend/auth-server/mocks/domain/accountRepositoryDB.go:40 because: 
        expected call at /home/dio/Documents/Code/go-beex-backend/auth-server/service/accountService_test.go:52 doesn't match the argument at index 0.
        Got: {0 [email protected] 1 $2a$04$.ORGMDZNk3.ySMpKwJYYcONdpAbgMJh79UDApzwRnzkCe.qeiECUG false}
        Want: is equal to {0 [email protected] 1 $2a$04$Bah8tCOzf7Z9Suw55DfyHOvnsBbXLyJEWV8QZ.owCBUOxxomAuEM2 false}

希望我的解释有意义，我的代码所依据的文章中没有讨论单元测试。

解决方案

我设法模拟了我的加密包，然后在我的测试中进行了模拟，该解决方案相当冗长，但我希望它将来对其他人有帮助。我还在学习 go，所以有些术语可能不正确（呵呵）

首先创建一个包，其中将创建您的哈希逻辑，more info here，我使用mockgen来创建我的模拟，所以我在界面中添加了注释

//go:generate mockgen -destination=../mocks/crypto/mockcrypto.go -package=crypto auth-server/crypto appcrypto
type appcrypto interface {
    hashandsalt(pwd []byte) (string, *errs.apperror)
    comparepasswords(hashedpwd string, plainpwd []byte) bool
}


type defaultappcrypto struct {
}

// hashandsalt hashes a given string
func (d defaultappcrypto) hashandsalt(pwd []byte) (string, *errs.apperror) {

    hash, err := bcrypt.generatefrompassword(pwd, bcrypt.mincost)
    if err != nil {
        return "", errs.newunexpectederror("an unexpected error ocurred while hashing the password" + err.error())
    }
    return string(hash), nil
}

func (d defaultappcrypto) comparepasswords(hashedpwd string, plainpwd []byte) bool { 
    bytehash := []byte(hashedpwd)
    err := bcrypt.comparehashandpassword(bytehash, plainpwd)
    if err != nil {
        return false
    }

    return true
}

我正在关注您在 udemy 课程 here 中学到的 hexagonal architecture（强烈推荐），因此我正在创建一个用于注册新用户的帐户服务，该服务需要一个用于访问其结构中的数据层的存储库，所以如果我们要注入加密包，然后我们就可以在测试中模拟它的实现。

这里省略一些代码，主要是实现：

type accountservice interface {
    registeraccount(dto.registerrequest) (*dto.registerresponse, *errs.apperror)
}

type defaultaccountservice struct {
    repo   domain.accountrepository
    crypto crypto.appcrypto
}

// more code here

func newaccountservice(repo domain.accountrepository, crypto crypto.appcrypto) defaultaccountservice {
    return defaultaccountservice{repo, crypto}
}

现在我们应该能够模拟这个包，这样类似的东西就可以工作了。

var mockRepo *domain.MockAccountRepository
var mockCrypto *crypto.MockAppCrypto
var ctrl gomock.Controller
var service AccountService

func setup(t *testing.T) func() {
    ctrl := gomock.NewController(t)
    mockRepo = domain.NewMockAccountRepository(ctrl)
    mockCrypto = crypto.NewMockAppCrypto(ctrl)
    service = NewAccountService(mockRepo, mockCrypto)

    return func() {
        service = nil
        defer ctrl.Finish()
    }
}

func Test_should_create_new_account(t *testing.T) {
    // Arrange
    teardown := setup(t)
    defer teardown()

    cryptoService := realCrypto.DefaultAppCrypto{}

    password := "securepassword"
    hashedpassword, err := cryptoService.HashAndSalt([]byte(password))

    request := dto.RegisterRequest{
        Email:    "[email protected]",
        Password: password,
        RoleID:   1,
    }

    account := realDomain.Account{
        Email:    request.Email,
        Password: hashedpassword,
        RoleID:   request.RoleID,
    }

    accountWithID := account
    accountWithID.AccountID = 1

    // ** MOCK THE DATA LAYER IMPLEMENTATION
    mockRepo.EXPECT().Create(account).Return(&accountWithID, nil)
    // ** MOCK THE CRYPTO PACKAGE's HashAndSalt
    mockCrypto.EXPECT().HashAndSalt([]byte(password)).Return(hashedpassword, nil)

    // Act
    res, err := service.RegisterAccount(request)

    // Assert

    if err != nil {
        t.Error("Failed while creating account")
    }

    if !res.Created {
        t.Error("Failed while creating account")
    }

}

最初我的加密包只有哈希所需的函数，但我被迫将它们包含在 struct 中，因此如果有更多经验的人知道一种模拟哈希函数的方法，帐户服务将使用模拟实现会很棒，因为代码会简单得多。

到这里，我们也就讲完了《对 Bcrypt 进行单元测试》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！