register_test.go

package userbiz

import (
	"context"
	"errors"
	"fmt"
	usermodel "nhaancs/modules/user/model"
	"testing"
)

type mockRegisterStore struct {
	users []usermodel.User
}

func NewMockRegisterStore(users []usermodel.User) *mockRegisterStore {
	return &mockRegisterStore{users: users}
}

func (m *mockRegisterStore) FindUser(ctx context.Context, conditions map[string]interface{}, moreInfo ...string) (*usermodel.User, error) {
	for _, user := range m.users {
		for k, v := range conditions {
			if k == "email" && user.Email == v {
				return &user, nil
			}
		}
	}
	return nil, errors.New("user not found")
}
func (m *mockRegisterStore) CreateUser(ctx context.Context, data *usermodel.UserRegister) error {
	user := usermodel.User{
		Name:     data.Name,
		Email:    data.Email,
		Password: data.Password,
		Salt:     data.Salt,
	}
	m.users = append(m.users, user)
	return nil
}

type mockHasher struct {
}

func NewMockHasher() *mockHasher {
	return &mockHasher{}
}

func (m *mockHasher) Hash(data string) string {
	fmt.Println("hash data: ", data)
	return "hashed" + data
}

func TestRegister(t *testing.T) {
	t.Run("should return error if email existed", func(t *testing.T) {
		mockStore := NewMockRegisterStore([]usermodel.User{
			{Email: "[email protected]"},
		})
		biz := NewRegisterBiz(mockStore, nil)
		want := ErrEmailExisted
		got := biz.Register(
			context.Background(), 
			newRegisterUser("Nhan", "[email protected]", "123456"),
		)
		if got != want {
			t.Errorf("got %q, want %q", got, want)
		}
	})

	t.Run("should gen salt for a user", func(t *testing.T) {
		mockHasher := NewMockHasher()
		mockStore := NewMockRegisterStore(nil)
		biz := NewRegisterBiz(mockStore, mockHasher)
		err := biz.Register(
			context.Background(), 
			newRegisterUser("Nhan", "[email protected]", "123456"),
		)
		if err != nil {
			t.Fatalf("expect no error, but got %q", err)
		}

		createdUser := mockStore.users[0]
		if len(createdUser.Salt) == 0 {
			t.Error("expect salt created but no created")
		}
	})

	t.Run("should gen a different salt for each user", func(t *testing.T) {
		mockHasher := NewMockHasher()
		mockStore := NewMockRegisterStore(nil)
		biz := NewRegisterBiz(mockStore, mockHasher)

		err := biz.Register(
			context.Background(), 
			newRegisterUser("Nhan", "[email protected]", "123456"),
		)
		if err != nil {
			t.Fatalf("expect no error, but got %q", err)
		}

		err = biz.Register(
			context.Background(), 
			newRegisterUser("Nhan2", "[email protected]", "123456"),
		)
		if err != nil {
			t.Fatalf("expect no error, but got %q", err)
		}

		createdUser1 := mockStore.users[0]
		createdUser2 := mockStore.users[1]
		if createdUser1.Salt == createdUser2.Salt {
			t.Error("expect different salts created but created the same salts")
		}
	})

	t.Run("should hash password", func(t *testing.T) {
		mockHasher := NewMockHasher()
		mockStore := NewMockRegisterStore(nil)
		biz := NewRegisterBiz(mockStore, mockHasher)
		rawPassword := "123456"
		registerData := newRegisterUser("Nhan", "[email protected]", rawPassword)
		err := biz.Register(context.Background(), registerData)
		if err != nil {
			t.Fatalf("expect no error, but got %q", err)
		}
		createdUser := mockStore.users[0]
		want := "hashed" + rawPassword + createdUser.Salt
		if createdUser.Password != want {
			t.Errorf("got %q, but want %q", createdUser.Password, want)
		}
	})
}

func newRegisterUser(name, email, password string) *usermodel.UserRegister {
	return &usermodel.UserRegister{
		Name:     name,
		Email:    email,
		Password: password,
	}
}