291 lines
9.8 KiB
TypeScript
291 lines
9.8 KiB
TypeScript
/**
|
||
* AdminService 单元测试
|
||
*
|
||
* 功能描述：
|
||
* - 测试管理员业务服务的所有方法
|
||
* - 验证业务逻辑的正确性
|
||
* - 测试异常处理和边界情况
|
||
*
|
||
* 职责分离：
|
||
* - 业务逻辑测试，不涉及HTTP层
|
||
* - Mock核心服务，专注业务服务逻辑
|
||
* - 验证数据处理和格式化的正确性
|
||
*
|
||
* 最近修改：
|
||
* - 2026-01-08: 注释规范优化 - 添加文件头注释，完善测试文档说明 (修改者: moyin)
|
||
*
|
||
* @author moyin
|
||
* @version 1.0.1
|
||
* @since 2025-12-19
|
||
* @lastModified 2026-01-08
|
||
*/
|
||
|
||
import { NotFoundException, BadRequestException } from '@nestjs/common';
|
||
import { AdminService } from './admin.service';
|
||
import { AdminCoreService } from '../../core/admin_core/admin_core.service';
|
||
import { LogManagementService } from '../../core/utils/logger/log_management.service';
|
||
import { Users } from '../../core/db/users/users.entity';
|
||
import { UserStatus } from '../user_mgmt/user_status.enum';
|
||
|
||
describe('AdminService', () => {
|
||
let service: AdminService;
|
||
|
||
const adminCoreServiceMock: Pick<AdminCoreService, 'login' | 'resetUserPassword'> = {
|
||
login: jest.fn(),
|
||
resetUserPassword: jest.fn(),
|
||
};
|
||
|
||
const usersServiceMock = {
|
||
findAll: jest.fn(),
|
||
findOne: jest.fn(),
|
||
update: jest.fn(),
|
||
};
|
||
|
||
const logManagementServiceMock: Pick<LogManagementService, 'getRuntimeLogTail' | 'getLogDirAbsolutePath'> = {
|
||
getRuntimeLogTail: jest.fn(),
|
||
getLogDirAbsolutePath: jest.fn(),
|
||
};
|
||
|
||
beforeEach(() => {
|
||
jest.resetAllMocks();
|
||
service = new AdminService(
|
||
adminCoreServiceMock as unknown as AdminCoreService,
|
||
usersServiceMock as any,
|
||
logManagementServiceMock as unknown as LogManagementService,
|
||
);
|
||
});
|
||
|
||
it('should login admin successfully', async () => {
|
||
(adminCoreServiceMock.login as jest.Mock).mockResolvedValue({
|
||
admin: { id: '1', username: 'admin', nickname: '管理员', role: 9 },
|
||
access_token: 'token',
|
||
expires_at: 123,
|
||
});
|
||
|
||
const res = await service.login('admin', 'Admin123456');
|
||
|
||
expect(adminCoreServiceMock.login).toHaveBeenCalledWith({ identifier: 'admin', password: 'Admin123456' });
|
||
expect(res.success).toBe(true);
|
||
expect(res.data?.admin?.role).toBe(9);
|
||
expect(res.message).toBe('管理员登录成功');
|
||
});
|
||
|
||
it('should handle login failure', async () => {
|
||
(adminCoreServiceMock.login as jest.Mock).mockRejectedValue(new Error('密码错误'));
|
||
|
||
const res = await service.login('admin', 'bad');
|
||
|
||
expect(res.success).toBe(false);
|
||
expect(res.error_code).toBe('ADMIN_LOGIN_FAILED');
|
||
expect(res.message).toBe('密码错误');
|
||
});
|
||
|
||
it('should handle non-Error login failure', async () => {
|
||
(adminCoreServiceMock.login as jest.Mock).mockRejectedValue('boom');
|
||
|
||
const res = await service.login('admin', 'bad');
|
||
|
||
expect(res.success).toBe(false);
|
||
expect(res.error_code).toBe('ADMIN_LOGIN_FAILED');
|
||
expect(res.message).toBe('管理员登录失败');
|
||
});
|
||
|
||
it('should list users with pagination', async () => {
|
||
const user = {
|
||
id: BigInt(1),
|
||
username: 'u1',
|
||
nickname: 'U1',
|
||
email: 'u1@test.com',
|
||
email_verified: true,
|
||
phone: null,
|
||
avatar_url: null,
|
||
role: 1,
|
||
created_at: new Date('2025-01-01T00:00:00Z'),
|
||
updated_at: new Date('2025-01-02T00:00:00Z'),
|
||
} as unknown as Users;
|
||
|
||
usersServiceMock.findAll.mockResolvedValue([user]);
|
||
|
||
const res = await service.listUsers(100, 0);
|
||
|
||
expect(usersServiceMock.findAll).toHaveBeenCalledWith(100, 0);
|
||
expect(res.success).toBe(true);
|
||
expect(res.data?.users).toHaveLength(1);
|
||
expect(res.data?.users[0]).toMatchObject({
|
||
id: '1',
|
||
username: 'u1',
|
||
nickname: 'U1',
|
||
role: 1,
|
||
});
|
||
});
|
||
|
||
it('should get user by id', async () => {
|
||
const user = {
|
||
id: BigInt(3),
|
||
username: 'u3',
|
||
nickname: 'U3',
|
||
email: null,
|
||
email_verified: false,
|
||
phone: '123',
|
||
avatar_url: null,
|
||
role: 1,
|
||
created_at: new Date('2025-01-01T00:00:00Z'),
|
||
updated_at: new Date('2025-01-02T00:00:00Z'),
|
||
} as unknown as Users;
|
||
|
||
usersServiceMock.findOne.mockResolvedValue(user);
|
||
|
||
const res = await service.getUser(BigInt(3));
|
||
|
||
expect(usersServiceMock.findOne).toHaveBeenCalledWith(BigInt(3));
|
||
expect(res.success).toBe(true);
|
||
expect(res.data?.user).toMatchObject({ id: '3', username: 'u3', nickname: 'U3' });
|
||
});
|
||
|
||
it('should reset user password', async () => {
|
||
usersServiceMock.findOne.mockResolvedValue({ id: BigInt(2) } as unknown as Users);
|
||
(adminCoreServiceMock.resetUserPassword as jest.Mock).mockResolvedValue(undefined);
|
||
|
||
const res = await service.resetPassword(BigInt(2), 'NewPass1234');
|
||
|
||
expect(usersServiceMock.findOne).toHaveBeenCalledWith(BigInt(2));
|
||
expect(adminCoreServiceMock.resetUserPassword).toHaveBeenCalledWith(BigInt(2), 'NewPass1234');
|
||
expect(res).toEqual({ success: true, message: '密码重置成功' });
|
||
});
|
||
|
||
it('should throw NotFoundException when resetting password for missing user', async () => {
|
||
usersServiceMock.findOne.mockRejectedValue(new Error('not found'));
|
||
|
||
await expect(service.resetPassword(BigInt(999), 'NewPass1234')).rejects.toBeInstanceOf(NotFoundException);
|
||
});
|
||
|
||
it('should get runtime logs', async () => {
|
||
(logManagementServiceMock.getRuntimeLogTail as jest.Mock).mockResolvedValue({
|
||
file: 'dev.log',
|
||
updated_at: '2025-01-01T00:00:00.000Z',
|
||
lines: ['a', 'b'],
|
||
});
|
||
|
||
const res = await service.getRuntimeLogs(2);
|
||
|
||
expect(logManagementServiceMock.getRuntimeLogTail).toHaveBeenCalledWith({ lines: 2 });
|
||
expect(res.success).toBe(true);
|
||
expect(res.data?.file).toBe('dev.log');
|
||
expect(res.data?.lines).toEqual(['a', 'b']);
|
||
});
|
||
|
||
it('should expose log dir absolute path', () => {
|
||
(logManagementServiceMock.getLogDirAbsolutePath as jest.Mock).mockReturnValue('/abs/logs');
|
||
|
||
expect(service.getLogDirAbsolutePath()).toBe('/abs/logs');
|
||
expect(logManagementServiceMock.getLogDirAbsolutePath).toHaveBeenCalled();
|
||
});
|
||
|
||
// 测试新增的用户状态管理方法
|
||
describe('updateUserStatus', () => {
|
||
const mockUser = {
|
||
id: BigInt(1),
|
||
username: 'testuser',
|
||
status: UserStatus.ACTIVE
|
||
} as unknown as Users;
|
||
|
||
it('should update user status successfully', async () => {
|
||
usersServiceMock.findOne.mockResolvedValue(mockUser);
|
||
usersServiceMock.update.mockResolvedValue({ ...mockUser, status: UserStatus.INACTIVE });
|
||
|
||
const result = await service.updateUserStatus(BigInt(1), { status: UserStatus.INACTIVE, reason: 'test' });
|
||
|
||
expect(result.success).toBe(true);
|
||
expect(result.message).toBe('用户状态修改成功');
|
||
});
|
||
|
||
it('should throw NotFoundException when user not found', async () => {
|
||
usersServiceMock.findOne.mockResolvedValue(null);
|
||
|
||
await expect(service.updateUserStatus(BigInt(999), { status: UserStatus.INACTIVE, reason: 'test' }))
|
||
.rejects.toThrow(NotFoundException);
|
||
});
|
||
|
||
it('should return error when status unchanged', async () => {
|
||
usersServiceMock.findOne.mockResolvedValue({ ...mockUser, status: UserStatus.INACTIVE });
|
||
|
||
await expect(service.updateUserStatus(BigInt(1), { status: UserStatus.INACTIVE, reason: 'test' }))
|
||
.rejects.toThrow(BadRequestException);
|
||
});
|
||
});
|
||
|
||
describe('batchUpdateUserStatus', () => {
|
||
it('should batch update user status successfully', async () => {
|
||
const mockUsers = [
|
||
{ id: BigInt(1), username: 'user1', status: UserStatus.ACTIVE },
|
||
{ id: BigInt(2), username: 'user2', status: UserStatus.ACTIVE }
|
||
] as unknown as Users[];
|
||
|
||
usersServiceMock.findOne
|
||
.mockResolvedValueOnce(mockUsers[0])
|
||
.mockResolvedValueOnce(mockUsers[1]);
|
||
|
||
usersServiceMock.update
|
||
.mockResolvedValueOnce({ ...mockUsers[0], status: UserStatus.INACTIVE })
|
||
.mockResolvedValueOnce({ ...mockUsers[1], status: UserStatus.INACTIVE });
|
||
|
||
const result = await service.batchUpdateUserStatus({
|
||
userIds: ['1', '2'],
|
||
status: UserStatus.INACTIVE,
|
||
reason: 'batch test'
|
||
});
|
||
|
||
expect(result.success).toBe(true);
|
||
expect(result.data?.result.success_count).toBe(2);
|
||
expect(result.data?.result.failed_count).toBe(0);
|
||
});
|
||
|
||
it('should handle mixed success and failure', async () => {
|
||
usersServiceMock.findOne
|
||
.mockResolvedValueOnce({ id: BigInt(1), status: UserStatus.ACTIVE })
|
||
.mockResolvedValueOnce(null); // User not found
|
||
|
||
usersServiceMock.update.mockResolvedValueOnce({ id: BigInt(1), status: UserStatus.INACTIVE });
|
||
|
||
const result = await service.batchUpdateUserStatus({
|
||
userIds: ['1', '999'],
|
||
status: UserStatus.INACTIVE,
|
||
reason: 'mixed test'
|
||
});
|
||
|
||
expect(result.success).toBe(true);
|
||
expect(result.data?.result.success_count).toBe(1);
|
||
expect(result.data?.result.failed_count).toBe(1);
|
||
});
|
||
});
|
||
|
||
describe('getUserStatusStats', () => {
|
||
it('should return user status statistics', async () => {
|
||
const mockUsers = [
|
||
{ status: UserStatus.ACTIVE },
|
||
{ status: UserStatus.ACTIVE },
|
||
{ status: UserStatus.INACTIVE },
|
||
{ status: null } // Should default to active
|
||
] as unknown as Users[];
|
||
|
||
usersServiceMock.findAll.mockResolvedValue(mockUsers);
|
||
|
||
const result = await service.getUserStatusStats();
|
||
|
||
expect(result.success).toBe(true);
|
||
expect(result.data?.stats.active).toBe(3); // 2 active + 1 null (defaults to active)
|
||
expect(result.data?.stats.inactive).toBe(1);
|
||
expect(result.data?.stats.total).toBe(4);
|
||
});
|
||
|
||
it('should handle error when getting stats', async () => {
|
||
usersServiceMock.findAll.mockRejectedValue(new Error('Database error'));
|
||
|
||
const result = await service.getUserStatusStats();
|
||
|
||
expect(result.success).toBe(false);
|
||
expect(result.error_code).toBe('USER_STATUS_STATS_FAILED');
|
||
});
|
||
});
|
||
});
|