ok

src/users/users.service.spec.ts

@@ -0,0 +1,91 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { ConflictException, NotFoundException } from '@nestjs/common';
+import { UsersService } from './users.service';
+import { User, UserRole } from './entities/user.entity';
+
+const mockUser: Partial<User> = {
+  id: 'uuid-1',
+  email: 'test@test.com',
+  name: 'Test User',
+  role: UserRole.MEMBER,
+  isActive: true,
+  passwordHash: 'hash',
+};
+
+const mockRepo = {
+  findAndCount: jest.fn(),
+  findOne: jest.fn(),
+  create: jest.fn(),
+  save: jest.fn(),
+  update: jest.fn(),
+};
+
+describe('UsersService', () => {
+  let service: UsersService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        UsersService,
+        { provide: getRepositoryToken(User), useValue: mockRepo },
+      ],
+    }).compile();
+
+    service = module.get<UsersService>(UsersService);
+    jest.clearAllMocks();
+  });
+
+  describe('findAll', () => {
+    it('should return paginated users', async () => {
+      mockRepo.findAndCount.mockResolvedValue([[mockUser], 1]);
+      const result = await service.findAll(1, 20);
+      expect(result.users).toHaveLength(1);
+      expect(result.total).toBe(1);
+      expect(result.totalPages).toBe(1);
+    });
+  });
+
+  describe('findById', () => {
+    it('should return user by id', async () => {
+      mockRepo.findOne.mockResolvedValue(mockUser);
+      const user = await service.findById('uuid-1');
+      expect(user.id).toBe('uuid-1');
+    });
+
+    it('should throw NotFoundException for unknown id', async () => {
+      mockRepo.findOne.mockResolvedValue(null);
+      await expect(service.findById('unknown')).rejects.toThrow(NotFoundException);
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new user', async () => {
+      mockRepo.findOne.mockResolvedValue(null); // no existing user
+      mockRepo.create.mockReturnValue({ ...mockUser });
+      mockRepo.save.mockResolvedValue({ ...mockUser });
+
+      const result = await service.create({ email: 'new@test.com', password: 'password123' });
+      expect(mockRepo.save).toHaveBeenCalled();
+    });
+
+    it('should throw ConflictException for duplicate email', async () => {
+      mockRepo.findOne.mockResolvedValue(mockUser); // existing user
+      await expect(
+        service.create({ email: mockUser.email, password: 'password123' }),
+      ).rejects.toThrow(ConflictException);
+    });
+  });
+
+  describe('updateRole', () => {
+    it('should update user role', async () => {
+      mockRepo.findOne.mockResolvedValue({ ...mockUser });
+      mockRepo.update.mockResolvedValue({});
+      mockRepo.findOne.mockResolvedValueOnce({ ...mockUser })
+                      .mockResolvedValueOnce({ ...mockUser, role: UserRole.MANAGER });
+
+      const result = await service.updateRole('uuid-1', { role: UserRole.MANAGER });
+      expect(mockRepo.update).toHaveBeenCalledWith('uuid-1', { role: UserRole.MANAGER });
+    });
+  });
+});