RenewCMS/test/user_test.go

package test

import (
	"RenewCMS/internal/domain/user"
	"RenewCMS/internal/infrastructure/useCases"
	"sort"
	"testing"

	"gorm.io/gorm"
)

type mockUserRepo struct {
	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) {
	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) 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{}, gorm.ErrRecordNotFound
	}
	u.IsVerified = isVerified
	m.users[userId] = u
	return u, nil
}

func (m *mockUserRepo) UpdatePassword(userId uint32, password string) (user.User, error) {
	if err := m.fail.trigger("UpdatePassword"); err != nil {
		return user.User{}, err
	}
	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) 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 := newMockUserRepo()
	uc := useCases.NewCreateUserUseCase(repo)

	cmd := useCases.CreateUserCommand{
		Username: "testuser",
		Password: "password123",
		Email:    "test@example.com",
	}

	res, err := uc.CreateUser(cmd)
	if err != nil {
		t.Fatalf("User creation failed: %v", err)
	}
	if res.Username != cmd.Username {
		t.Errorf("Username mismatch")
	}
	if res.VerificationCode == "" {
		t.Errorf("Verification code was not generated")
	}
}

func TestUpdateUserVerification(t *testing.T) {
	repo := newMockUserRepo()
	repo.users[1] = user.User{ID: 1, IsVerified: false}
	uc := useCases.NewUpdateUserUseCase(repo)

	res, err := uc.UpdateVerificationStatus(1, true)
	if err != nil {
		t.Fatalf("Update failed: %v", err)
	}
	if !res.IsVerified {
		t.Errorf("User should be verified")
	}
}