create-dp-koa 1.0.1 → 1.1.0

package/template/test/service/ytUser.service.test.ts

@@ -1,566 +0,0 @@
-import { TestDatabaseHelper, TestUtils } from '../utils/testHelpers';
-import { YtUserService } from '../../src/service/ytUser.service';
-import { Provider } from 'dp-ioc2';
-import { CreateUserDto, UpdateUserDto, QueryUserDto, LoginUserDto, ChangePasswordDto } from '../../src/dto/user.dto';
-import { YtUserTypeEnum, YtUserStatusEnum } from '../../src/entity/ytUser.entity';
-import { CommonServiceResultCode } from '../../src/framework/types/ServiceResult';
-
-describe('YtUserService 测试', () => {
-    let userService: YtUserService;
-
-    beforeAll(async () => {
-        await TestDatabaseHelper.initTestDatabase();
-    });
-
-    afterAll(async () => {
-        await TestDatabaseHelper.cleanupTestDatabase();
-    });
-
-    beforeEach(async () => {
-        await TestDatabaseHelper.resetTestData();
-        userService = Provider(YtUserService);
-    });
-
-    describe('createUser - 创建用户', () => {
-        test('应该能够成功创建用户', async () => {
-            const createUserDto: CreateUserDto = {
-                nickName: '新测试用户',
-                email: 'newuser@example.com',
-                telnumber: '13900139000',
-                password: 'Password123!',
-                userType: YtUserTypeEnum.CUSTOMER,
-                status: YtUserStatusEnum.NORMAL
-            };
-
-            const result = await userService.createUser(createUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBeDefined();
-            expect(result.data?.email).toBe(createUserDto.email);
-            expect(result.data?.telnumber).toBe(createUserDto.telnumber);
-            expect(result.data?.nickName).toBe(createUserDto.nickName);
-            expect(result.data?.password).not.toBe(createUserDto.password); // 密码应该被加密
-        });
-
-        test('应该拒绝重复的邮箱', async () => {
-            const createUserDto: CreateUserDto = {
-                nickName: '重复邮箱用户',
-                email: 'test1@example.com', // 使用已有的邮箱
-                telnumber: '13900139001',
-                password: 'Password123!'
-            };
-
-            const result = await userService.createUser(createUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.CONFLICT);
-            expect(result.message).toContain('邮箱已被使用');
-        });
-
-        test('应该拒绝重复的手机号', async () => {
-            const createUserDto: CreateUserDto = {
-                nickName: '重复手机用户',
-                email: 'unique@example.com',
-                telnumber: '13800138001', // 使用已有的手机号
-                password: 'Password123!'
-            };
-
-            const result = await userService.createUser(createUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.CONFLICT);
-            expect(result.message).toContain('手机号已被使用');
-        });
-
-        test('应该拒绝无效的邮箱格式', async () => {
-            const createUserDto: CreateUserDto = {
-                nickName: '无效邮箱用户',
-                email: 'invalid-email', // 无效的邮箱格式
-                telnumber: '13900139002',
-                password: 'Password123!'
-            };
-
-            const result = await userService.createUser(createUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.VALIDATION_ERROR);
-            expect(result.message).toContain('邮箱格式不正确');
-        });
-
-        test('应该拒绝过短的密码', async () => {
-            const createUserDto: CreateUserDto = {
-                nickName: '短密码用户',
-                email: 'shortpass@example.com',
-                telnumber: '13900139003',
-                password: '12345!' // 少于8个字符，不符合强度要求
-            };
-
-            const result = await userService.createUser(createUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.VALIDATION_ERROR);
-            expect(result.message).toContain('密码强度不足');
-        });
-
-        test('应该为密码使用默认的用户类型和状态', async () => {
-            const createUserDto: CreateUserDto = {
-                nickName: '默认类型用户',
-                email: TestUtils.generateRandomEmail(),
-                telnumber: TestUtils.generateRandomPhone(),
-                password: 'Password123!'
-            };
-
-            const result = await userService.createUser(createUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data?.userType).toBe(YtUserTypeEnum.CUSTOMER);
-            expect(result.data?.status).toBe(YtUserStatusEnum.NORMAL);
-        });
-    });
-
-    describe('updateUser - 更新用户', () => {
-        test('应该能够成功更新用户信息', async () => {
-            // 先获取一个测试用户
-            const existingUser = await userService.findByEmail('test1@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-            const updateUserDto: UpdateUserDto = {
-                nickName: '更新后的昵称',
-                age: 30
-            };
-
-            const result = await userService.updateUser(userId, updateUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data?.nickName).toBe(updateUserDto.nickName);
-            expect(result.data?.age).toBe(updateUserDto.age);
-        });
-
-        test('应该拒绝更新不存在的用户', async () => {
-            const updateUserDto: UpdateUserDto = {
-                nickName: '不存在的用户'
-            };
-
-            const result = await userService.updateUser(999999, updateUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.NOT_FOUND);
-            expect(result.message).toContain('用户不存在');
-        });
-
-        test('应该拒绝使用已存在的邮箱更新用户', async () => {
-            // 获取第二个测试用户
-            const existingUser = await userService.findByEmail('test2@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-            const updateUserDto: UpdateUserDto = {
-                email: 'test1@example.com' // 使用第一个用户的邮箱
-            };
-
-            const result = await userService.updateUser(userId, updateUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.ERROR);
-            expect(result.message).toContain('邮箱已被其他用户使用');
-        });
-
-        test('应该拒绝使用已存在的手机号更新用户', async () => {
-            // 获取第二个测试用户
-            const existingUser = await userService.findByEmail('test2@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-            const updateUserDto: UpdateUserDto = {
-                telnumber: '13800138001' // 使用第一个用户的手机号
-            };
-
-            const result = await userService.updateUser(userId, updateUserDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.ERROR);
-            expect(result.message).toContain('手机号已被其他用户使用');
-        });
-    });
-
-    describe('getUserById - 获取用户', () => {
-        test('应该能够成功获取用户', async () => {
-            // 先获取一个测试用户
-            const existingUser = await userService.findByEmail('test1@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-
-            const result = await userService.getUserById(userId);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBeDefined();
-            expect(result.data?.id).toBe(userId);
-        });
-
-        test('应该返回NOT_FOUND当用户不存在', async () => {
-            const result = await userService.getUserById(999999);
-
-            expect(result.code).toBe(CommonServiceResultCode.NOT_FOUND);
-            expect(result.message).toContain('用户不存在');
-        });
-    });
-
-    describe('login - 用户登录', () => {
-        test('应该能够使用邮箱成功登录', async () => {
-            const loginDto: LoginUserDto = {
-                credential: 'test1@example.com',
-                password: 'Password123!'
-            };
-
-            const result = await userService.login(loginDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBeDefined();
-            expect(result.message).toContain('登录成功');
-        });
-
-        test('应该能够使用手机号成功登录', async () => {
-            const loginDto: LoginUserDto = {
-                credential: '13800138001',
-                password: 'Password123!'
-            };
-
-            const result = await userService.login(loginDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBeDefined();
-        });
-
-        test('应该拒绝不存在的用户登录', async () => {
-            const loginDto: LoginUserDto = {
-                credential: 'nonexistent@example.com',
-                password: 'Password123!'
-            };
-
-            const result = await userService.login(loginDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.NOT_FOUND);
-            expect(result.message).toContain('用户不存在');
-        });
-
-        test('应该拒绝错误密码的登录', async () => {
-            const loginDto: LoginUserDto = {
-                credential: 'test1@example.com',
-                password: 'WrongPassword123!'
-            };
-
-            const result = await userService.login(loginDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.UNAUTHORIZED);
-            expect(result.message).toContain('密码错误');
-        });
-
-        test('应该拒绝被禁用用户的登录', async () => {
-            // 先获取一个用户并禁用
-            const existingUser = await userService.findByEmail('test1@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-            await userService.toggleUserStatus(userId, false);
-
-            const loginDto: LoginUserDto = {
-                credential: 'test1@example.com',
-                password: 'Password123!'
-            };
-
-            const result = await userService.login(loginDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.FORBIDDEN);
-            expect(result.message).toContain('用户已被禁用');
-
-            // 恢复用户状态
-            await userService.toggleUserStatus(userId, true);
-        });
-    });
-
-    describe('changePassword - 修改密码', () => {
-        test('应该能够成功修改密码', async () => {
-            // 先获取一个用户
-            const existingUser = await userService.findByEmail('test2@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-            const changePasswordDto: ChangePasswordDto = {
-                currentPassword: 'Password123!',
-                newPassword: 'NewPassword123!',
-                confirmPassword: 'NewPassword123!'
-            };
-
-            const result = await userService.changePassword(userId, changePasswordDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBe(true);
-            expect(result.message).toContain('密码修改成功');
-
-            // 验证新密码可以登录
-            const loginDto: LoginUserDto = {
-                credential: 'test2@example.com',
-                password: 'NewPassword123!'
-            };
-            const loginResult = await userService.login(loginDto);
-            expect(loginResult.code).toBe(CommonServiceResultCode.SUCCESS);
-        });
-
-        test('应该拒绝错误的当前密码', async () => {
-            // 先获取一个用户
-            const existingUser = await userService.findByEmail('test2@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-            const changePasswordDto: ChangePasswordDto = {
-                currentPassword: 'WrongPassword123!',
-                newPassword: 'newpassword123',
-                confirmPassword: 'newpassword123'
-            };
-
-            const result = await userService.changePassword(userId, changePasswordDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.ERROR);
-            expect(result.message).toContain('当前密码错误');
-        });
-
-        test('应该拒绝新密码和确认密码不一致', async () => {
-            const userId = 1;
-            const changePasswordDto: ChangePasswordDto = {
-                currentPassword: 'Password123!',
-                newPassword: 'NewPassword123!',
-                confirmPassword: 'DifferentPassword123!'
-            };
-
-            const result = await userService.changePassword(userId, changePasswordDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.VALIDATION_ERROR);
-            expect(result.message).toContain('新密码和确认密码不一致');
-        });
-
-        test('应该拒绝修改不存在的用户的密码', async () => {
-            const changePasswordDto: ChangePasswordDto = {
-                currentPassword: 'Password123!',
-                newPassword: 'NewPassword123!',
-                confirmPassword: 'NewPassword123!'
-            };
-
-            const result = await userService.changePassword(999999, changePasswordDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.ERROR);
-            expect(result.message).toContain('用户不存在');
-        });
-    });
-
-    describe('getUsers - 查询用户列表', () => {
-        test('应该能够获取用户列表', async () => {
-            const queryDto: QueryUserDto = {
-                page: 1,
-                pageSize: 10
-            };
-
-            const result = await userService.getUsers(queryDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBeDefined();
-            if (result.data) {
-                expect(Array.isArray(result.data[0])).toBe(true);
-                expect(typeof result.data[1]).toBe('number');
-            }
-        });
-
-        test('应该能够按用户类型筛选', async () => {
-            const queryDto: QueryUserDto = {
-                userType: YtUserTypeEnum.CUSTOMER,
-                page: 1,
-                pageSize: 10
-            };
-
-            const result = await userService.getUsers(queryDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            if (result.data && result.data[0].length > 0) {
-                expect(result.data[0][0].userType).toBe(YtUserTypeEnum.CUSTOMER);
-            }
-        });
-
-        test('应该能够按状态筛选', async () => {
-            const queryDto: QueryUserDto = {
-                status: YtUserStatusEnum.NORMAL,
-                page: 1,
-                pageSize: 10
-            };
-
-            const result = await userService.getUsers(queryDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            if (result.data && result.data[0].length > 0) {
-                expect(result.data[0][0].status).toBe(YtUserStatusEnum.NORMAL);
-            }
-        });
-
-        test('应该能够分页查询', async () => {
-            const queryDto: QueryUserDto = {
-                page: 1,
-                pageSize: 2
-            };
-
-            const result = await userService.getUsers(queryDto);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            if (result.data) {
-                expect(result.data[0].length).toBeLessThanOrEqual(2);
-            }
-        });
-    });
-
-    describe('deleteUser - 删除用户', () => {
-        test('应该能够成功删除用户', async () => {
-            // 先创建一个用户用于删除
-            const createUserDto: CreateUserDto = {
-                nickName: '待删除用户',
-                email: TestUtils.generateRandomEmail(),
-                telnumber: TestUtils.generateRandomPhone(),
-                password: 'Password123!'
-            };
-
-            const createResult = await userService.createUser(createUserDto);
-            const userId = createResult.data?.id;
-
-            if (!userId) {
-                throw new Error('创建用户失败');
-            }
-
-            // 删除用户
-            const deleteResult = await userService.deleteUser(userId);
-
-            expect(deleteResult.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(deleteResult.data).toBe(true);
-
-            // 验证用户已被删除
-            const getUserResult = await userService.getUserById(userId);
-            expect(getUserResult.code).toBe(CommonServiceResultCode.NOT_FOUND);
-        });
-
-        test('应该拒绝删除不存在的用户', async () => {
-            const result = await userService.deleteUser(999999);
-
-            expect(result.code).toBe(CommonServiceResultCode.NOT_FOUND);
-            expect(result.message).toContain('用户不存在');
-        });
-    });
-
-    describe('toggleUserStatus - 切换用户状态', () => {
-        test('应该能够禁用用户', async () => {
-            // 先获取一个用户
-            const existingUser = await userService.findByEmail('test2@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-
-            const result = await userService.toggleUserStatus(userId, false);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBe(true);
-            expect(result.message).toContain('禁用');
-
-            // 验证用户已被禁用
-            const userResult = await userService.getUserById(userId);
-            expect(userResult.data?.status).toBe(YtUserStatusEnum.FORBIDDEN);
-
-            // 恢复用户状态
-            await userService.toggleUserStatus(userId, true);
-        });
-
-        test('应该能够激活用户', async () => {
-            // 先获取一个用户
-            const existingUser = await userService.findByEmail('test2@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-
-            // 先禁用用户
-            await userService.toggleUserStatus(userId, false);
-
-            // 再激活用户
-            const result = await userService.toggleUserStatus(userId, true);
-
-            expect(result.code).toBe(CommonServiceResultCode.SUCCESS);
-            expect(result.data).toBe(true);
-            expect(result.message).toContain('激活');
-
-            // 验证用户已被激活
-            const userResult = await userService.getUserById(userId);
-            expect(userResult.data?.status).toBe(YtUserStatusEnum.NORMAL);
-        });
-
-        test('应该拒绝切换不存在用户的状态', async () => {
-            const result = await userService.toggleUserStatus(999999, false);
-
-            expect(result.code).toBe(CommonServiceResultCode.NOT_FOUND);
-            expect(result.message).toContain('用户不存在');
-        });
-    });
-
-    describe('findByEmail - 根据邮箱查找用户', () => {
-        test('应该能够找到存在的用户', async () => {
-            const user = await userService.findByEmail('test1@example.com');
-
-            expect(user).toBeDefined();
-            expect(user?.email).toBe('test1@example.com');
-        });
-
-        test('应该返回null当用户不存在', async () => {
-            const user = await userService.findByEmail('nonexistent@example.com');
-
-            expect(user).toBeNull();
-        });
-    });
-
-    describe('addUser - 添加用户（兼容接口）', () => {
-        test('应该能够添加用户', async () => {
-            const newUser: any = {
-                nickName: '兼容接口用户',
-                email: TestUtils.generateRandomEmail(),
-                telnumber: TestUtils.generateRandomPhone(),
-                password: 'Password123!',
-                userType: YtUserTypeEnum.CUSTOMER,
-                status: YtUserStatusEnum.NORMAL,
-                gender: 0,
-                age: 0,
-                constellation: '',
-                avatar: ''
-            };
-
-            const result = await userService.addUser(newUser);
-
-            expect(result).toBeDefined();
-            expect(result.email).toBe(newUser.email);
-        });
-    });
-
-    describe('getUserByIdLegacy - 获取用户（兼容接口）', () => {
-        test('应该能够获取用户', async () => {
-            // 先获取一个用户
-            const existingUser = await userService.findByEmail('test1@example.com');
-            if (!existingUser) {
-                throw new Error('测试用户不存在');
-            }
-            const userId = existingUser.id;
-            const user = await userService.getUserByIdLegacy(null as any, userId);
-
-            expect(user).toBeDefined();
-            expect(user?.id).toBe(userId);
-        });
-
-        test('应该返回null当用户不存在', async () => {
-            const user = await userService.getUserByIdLegacy(null as any, 999999);
-
-            expect(user).toBeNull();
-        });
-    });
-});