feat: characterized the existing use cases as a baseline; every repo fake behaves like the real ones and can be told to fail, every use case is covered; gremlins runs clean on useCases

test/user_test.go

@@ -3,56 +3,137 @@ package test
 import (
 	"RenewCMS/internal/domain/user"
 	"RenewCMS/internal/infrastructure/useCases"
+	"sort"
 	"testing"
+
+	"gorm.io/gorm"
 )
 
 type mockUserRepo struct {
-	users map[uint32]user.User
+	users  map[uint32]user.User
+	nextID uint32
+	fail   failSwitch
+}
+
+func newMockUserRepo() *mockUserRepo {
+	return &mockUserRepo{users: make(map[uint32]user.User)}
+}
+
+func (m *mockUserRepo) sortedIds() []uint32 {
+	ids := make([]uint32, 0, len(m.users))
+	for id := range m.users {
+		ids = append(ids, id)
+	}
+	sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
+	return ids
+}
+
+func (m *mockUserRepo) Get(id uint32) (user.User, error) {
+	if err := m.fail.trigger("Get"); err != nil {
+		return user.User{}, err
+	}
+	u, ok := m.users[id]
+	if !ok {
+		return user.User{}, gorm.ErrRecordNotFound
+	}
+	return u, nil
+}
+
+func (m *mockUserRepo) GetByUsername(username string) (user.User, error) {
+	if err := m.fail.trigger("GetByUsername"); err != nil {
+		return user.User{}, err
+	}
+	for _, id := range m.sortedIds() {
+		u := m.users[id]
+		if u.Username == username {
+			return u, nil
+		}
+	}
+	return user.User{}, gorm.ErrRecordNotFound
+}
+
+func (m *mockUserRepo) GetByEmail(email string) (user.User, error) {
+	if err := m.fail.trigger("GetByEmail"); err != nil {
+		return user.User{}, err
+	}
+	for _, id := range m.sortedIds() {
+		u := m.users[id]
+		if u.Email == email {
+			return u, nil
+		}
+	}
+	return user.User{}, gorm.ErrRecordNotFound
+}
+
+func (m *mockUserRepo) GetAll() []user.User {
+	result := make([]user.User, 0)
+	for _, id := range m.sortedIds() {
+		result = append(result, m.users[id])
+	}
+	return result
 }
 
 func (m *mockUserRepo) Create(u user.User) (user.User, error) {
-	u.ID = uint32(len(m.users) + 1)
+	if err := m.fail.trigger("Create"); err != nil {
+		return user.User{}, err
+	}
+	m.nextID++
+	u.ID = m.nextID
 	m.users[u.ID] = u
 	return u, nil
 }
 
-func (m *mockUserRepo) Get(id uint32) (user.User, error) {
-	u, ok := m.users[id]
+func (m *mockUserRepo) Delete(id uint32) error {
+	if err := m.fail.trigger("Delete"); err != nil {
+		return err
+	}
+	delete(m.users, id)
+	return nil
+}
+
+func (m *mockUserRepo) UpdateVerificationStatus(userId uint32, isVerified bool) (user.User, error) {
+	if err := m.fail.trigger("UpdateVerificationStatus"); err != nil {
+		return user.User{}, err
+	}
+	u, ok := m.users[userId]
 	if !ok {
-		return user.User{}, nil
+		return user.User{}, gorm.ErrRecordNotFound
 	}
+	u.IsVerified = isVerified
+	m.users[userId] = u
 	return u, nil
 }
 
-func (m *mockUserRepo) GetAll() []user.User {
-	var list []user.User
-	for _, u := range m.users {
-		list = append(list, u)
+func (m *mockUserRepo) UpdatePassword(userId uint32, password string) (user.User, error) {
+	if err := m.fail.trigger("UpdatePassword"); err != nil {
+		return user.User{}, err
 	}
-	return list
-}
-
-func (m *mockUserRepo) UpdateVerificationStatus(id uint32, v bool) (user.User, error) {
-	u := m.users[id]
-	u.IsVerified = v
-	m.users[id] = u
+	u, ok := m.users[userId]
+	if !ok {
+		return user.User{}, gorm.ErrRecordNotFound
+	}
+	u.Password = password
+	m.users[userId] = u
 	return u, nil
 }
 
-func (m *mockUserRepo) GetByUsername(n string) (user.User, error) { return user.User{}, nil }
-func (m *mockUserRepo) GetByEmail(e string) (user.User, error)    { return user.User{}, nil }
-func (m *mockUserRepo) Delete(id uint32) error                    { return nil }
-func (m *mockUserRepo) UpdatePassword(id uint32, p string) (user.User, error) {
-	return user.User{}, nil
-}
-func (m *mockUserRepo) UpdatePasswordResetCode(id uint32, c string) (user.User, error) {
-	return user.User{}, nil
+func (m *mockUserRepo) UpdatePasswordResetCode(userId uint32, code string) (user.User, error) {
+	if err := m.fail.trigger("UpdatePasswordResetCode"); err != nil {
+		return user.User{}, err
+	}
+	u, ok := m.users[userId]
+	if !ok {
+		return user.User{}, gorm.ErrRecordNotFound
+	}
+	u.PasswordResetCode = code
+	m.users[userId] = u
+	return u, nil
 }
 
 var _ user.Repository = &mockUserRepo{}
 
 func TestCreateUser(t *testing.T) {
-	repo := &mockUserRepo{users: make(map[uint32]user.User)}
+	repo := newMockUserRepo()
 	uc := useCases.NewCreateUserUseCase(repo)
 
 	cmd := useCases.CreateUserCommand{
@@ -74,9 +155,8 @@ func TestCreateUser(t *testing.T) {
 }
 
 func TestUpdateUserVerification(t *testing.T) {
-	repo := &mockUserRepo{users: map[uint32]user.User{
-		1: {ID: 1, IsVerified: false},
-	}}
+	repo := newMockUserRepo()
+	repo.users[1] = user.User{ID: 1, IsVerified: false}
 	uc := useCases.NewUpdateUserUseCase(repo)
 
 	res, err := uc.UpdateVerificationStatus(1, true)