🗑️ test(user-module-mt): 删除重复的服务层测试，只保留路由API测试

- 删除 user.integration.test.ts (服务层集成测试)
- 删除 user.service.test.ts (用户服务单元测试)
- 删除 role.service.test.ts (角色服务单元测试)
- 保留 user.routes.integration.test.ts (用户路由API集成测试)
- 保留 role.integration.test.ts (角色API集成测试)
- 路由API测试已完整覆盖所有业务逻辑和租户隔离功能

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

packages/user-module-mt/tests/integration/user.integration.test.ts

@@ -1,224 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, beforeAll } from 'vitest';
-import { DataSource } from 'typeorm';
-import { UserServiceMt } from '../../src/services/user.service.mt';
-import { RoleServiceMt } from '../../src/services/role.service.mt';
-import { UserEntityMt } from '../../src/entities/user.entity';
-import { RoleMt } from '../../src/entities/role.entity';
-import { AppDataSource, initializeDataSource } from '@d8d/shared-utils';
-import { FileMt } from '@d8d/file-module-mt';
-
-// 确保测试环境变量被设置
-process.env.NODE_ENV = 'test';
-
-describe('User Integration Tests', () => {
-  let dataSource: DataSource;
-  let userService: UserServiceMt;
-  let roleService: RoleServiceMt;
-
-  beforeAll(() => {
-    // 使用预先配置的数据源
-    initializeDataSource([UserEntityMt, RoleMt, FileMt])
-    dataSource = AppDataSource;
-  })
-
-  beforeEach(async () => {
-    if (!dataSource.isInitialized) {
-      await dataSource.initialize();
-    }
-    userService = new UserServiceMt(dataSource);
-    roleService = new RoleServiceMt(dataSource);
-  });
-
-  afterEach(async () => {
-    if (dataSource.isInitialized) {
-      await dataSource.destroy();
-    }
-  });
-
-
-
-  describe('用户CRUD操作', () => {
-    it('应该创建并检索用户', async () => {
-      // Create user
-      const userData = {
-        username: 'integrationuser',
-        password: 'password123',
-        email: 'integration@example.com',
-        nickname: 'Integration User',
-        tenantId: 1
-      };
-      const originalUserData = {
-        ...userData
-      }
-
-      const createdUser = await userService.createUser(userData, 1);
-      
-      expect(createdUser.id).toBeDefined();
-      expect(createdUser.username).toBe(userData.username);
-      expect(createdUser.email).toBe(userData.email);
-      expect(createdUser.nickname).toBe(userData.nickname);
-      expect(createdUser.password).not.toBe(originalUserData.password); // Password should be hashed
-
-      // Retrieve user
-      const retrievedUser = await userService.getUserById(createdUser.id);
-      expect(retrievedUser).toBeDefined();
-      expect(retrievedUser?.username).toBe(userData.username);
-    });
-
-    it('应该更新用户信息', async () => {
-      // Create user first
-      const userData = {
-        username: 'updateuser',
-        password: 'password123',
-        email: 'update@example.com'
-      };
-
-      const createdUser = await userService.createUser(userData, 1);
-
-      // Update user
-      const updateData = {
-        email: 'updated@example.com',
-        nickname: 'Updated User'
-      };
-
-      const updatedUser = await userService.updateUser(createdUser.id, updateData);
-
-      expect(updatedUser).toBeDefined();
-      expect(updatedUser?.email).toBe(updateData.email);
-      expect(updatedUser?.nickname).toBe(updateData.nickname);
-    });
-
-    it('应该删除用户', async () => {
-      // Create user first
-      const userData = {
-        username: 'deleteuser',
-        password: 'password123'
-      };
-
-      const createdUser = await userService.createUser(userData, 1);
-
-      // Delete user
-      const deleteResult = await userService.deleteUser(createdUser.id);
-      expect(deleteResult).toBe(true);
-
-      // Verify user is deleted
-      const retrievedUser = await userService.getUserById(createdUser.id);
-      expect(retrievedUser).toBeNull();
-    });
-
-    it('应该根据用户名获取用户', async () => {
-      const userData = {
-        username: 'usernameuser',
-        password: 'password123'
-      };
-
-      await userService.createUser(userData, 1);
-
-      const foundUser = await userService.getUserByUsername('usernameuser');
-      expect(foundUser).toBeDefined();
-      expect(foundUser?.username).toBe('usernameuser');
-    });
-
-    it('应该根据账号（用户名或邮箱）获取用户', async () => {
-      const userData = {
-        username: 'accountuser',
-        password: 'password123',
-        email: 'account@example.com'
-      };
-
-      await userService.createUser(userData, 1);
-
-      // Find by username
-      const byUsername = await userService.getUserByAccount('accountuser');
-      expect(byUsername).toBeDefined();
-      expect(byUsername?.username).toBe('accountuser');
-
-      // Find by email
-      const byEmail = await userService.getUserByAccount('account@example.com');
-      expect(byEmail).toBeDefined();
-      expect(byEmail?.email).toBe('account@example.com');
-    });
-  });
-
-  describe('用户角色关系', () => {
-    it('应该为用户分配角色', async () => {
-      // Create user
-      const userData = {
-        username: 'roleuser',
-        password: 'password123'
-      };
-      const user = await userService.createUser(userData, 1);
-
-      // Create roles
-      const adminRole = await roleService.create({
-        name: 'admin',
-        description: 'Administrator role',
-        permissions: ['user:create', 'user:delete'],
-        tenantId: 1
-      });
-
-      const userRole = await roleService.create({
-        name: 'user',
-        description: 'Regular user role',
-        permissions: ['user:read'],
-        tenantId: 1
-      });
-
-      // Assign roles to user
-      const updatedUser = await userService.assignRoles(user.id, [adminRole.id, userRole.id], 1);
-
-      expect(updatedUser).toBeDefined();
-      expect(updatedUser?.roles).toHaveLength(2);
-      expect(updatedUser?.roles.map(r => r.name)).toContain('admin');
-      expect(updatedUser?.roles.map(r => r.name)).toContain('user');
-    });
-  });
-
-  describe('用户列表操作', () => {
-    it('应该获取所有用户', async () => {
-      // Create multiple users
-      const usersData = [
-        { username: 'user1', password: 'password123' },
-        { username: 'user2', password: 'password123' },
-        { username: 'user3', password: 'password123' }
-      ];
-
-      for (const userData of usersData) {
-        await userService.createUser(userData, 1);
-      }
-
-      const allUsers = await userService.getUsers();
-
-      expect(allUsers).toHaveLength(3);
-      expect(allUsers.map(u => u.username)).toEqual(
-        expect.arrayContaining(['user1', 'user2', 'user3'])
-      );
-    });
-  });
-
-  describe('密码验证', () => {
-    it('应该验证正确密码', async () => {
-      const userData = {
-        username: 'verifyuser',
-        password: 'correctpassword'
-      };
-
-      const user = await userService.createUser(userData, 1);
-
-      const isCorrect = await userService.verifyPassword(user, 'correctpassword');
-      expect(isCorrect).toBe(true);
-    });
-
-    it('应该拒绝错误密码', async () => {
-      const userData = {
-        username: 'verifyuser2',
-        password: 'correctpassword'
-      };
-
-      const user = await userService.createUser(userData, 1);
-
-      const isCorrect = await userService.verifyPassword(user, 'wrongpassword');
-      expect(isCorrect).toBe(false);
-    });
-  });
-});

packages/user-module-mt/tests/unit/role.service.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { RoleService } from '../../src/services/role.service';
-import { Role } from '../../src/entities/role.entity';
-import { DataSource, Repository } from 'typeorm';
-
-// Mock DataSource
-const mockDataSource = {
-  getRepository: vi.fn()
-} as unknown as DataSource;
-
-// Mock repository
-const mockRepository = {
-  findOneBy: vi.fn(),
-  findOne: vi.fn()
-} as unknown as Repository<Role>;
-
-describe('RoleService', () => {
-  let roleService: RoleService;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Setup mock repository
-    vi.mocked(mockDataSource.getRepository).mockReturnValue(mockRepository);
-
-    roleService = new RoleService(mockDataSource);
-  });
-
-  describe('getRoleByName', () => {
-    it('should return role by name', async () => {
-      const mockRole = {
-        id: 1,
-        name: 'admin',
-        description: 'Administrator role',
-        permissions: ['user:create', 'user:delete']
-      } as Role;
-
-      vi.mocked(mockRepository.findOneBy).mockResolvedValue(mockRole);
-
-      const result = await roleService.getRoleByName('admin');
-
-      expect(mockRepository.findOneBy).toHaveBeenCalledWith({ name: 'admin' });
-      expect(result).toEqual(mockRole);
-    });
-
-    it('should return null when role not found', async () => {
-      vi.mocked(mockRepository.findOneBy).mockResolvedValue(null);
-
-      const result = await roleService.getRoleByName('nonexistent');
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('hasPermission', () => {
-    it('should return true when role has permission', async () => {
-      const mockRole = {
-        id: 1,
-        name: 'admin',
-        permissions: ['user:create', 'user:delete']
-      } as Role;
-
-      vi.mocked(mockRepository.findOne).mockResolvedValue(mockRole);
-
-      const result = await roleService.hasPermission(1, 'user:create');
-
-      expect(result).toBe(true);
-    });
-
-    it('should return false when role does not have permission', async () => {
-      const mockRole = {
-        id: 1,
-        name: 'admin',
-        permissions: ['user:create', 'user:delete']
-      } as Role;
-
-      vi.mocked(mockRepository.findOne).mockResolvedValue(mockRole);
-
-      const result = await roleService.hasPermission(1, 'user:update');
-
-      expect(result).toBe(false);
-    });
-
-    it('should return false when role not found', async () => {
-      vi.mocked(mockRepository.findOne).mockResolvedValue(null);
-
-      const result = await roleService.hasPermission(999, 'user:create');
-
-      expect(result).toBe(false);
-    });
-  });
-
-  // Test inherited methods from GenericCrudService
-  describe('inherited methods', () => {
-    it('should have getById method', () => {
-      expect(roleService.getById).toBeDefined();
-    });
-
-    it('should have getList method', () => {
-      expect(roleService.getList).toBeDefined();
-    });
-
-    it('should have create method', () => {
-      expect(roleService.create).toBeDefined();
-    });
-
-    it('should have update method', () => {
-      expect(roleService.update).toBeDefined();
-    });
-
-    it('should have delete method', () => {
-      expect(roleService.delete).toBeDefined();
-    });
-  });
-});

packages/user-module-mt/tests/unit/user.service.test.ts

@@ -1,293 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { UserService } from '../../src/services/user.service';
-import { UserEntity } from '../../src/entities/user.entity';
-import { Role } from '../../src/entities/role.entity';
-import { DataSource, Repository } from 'typeorm';
-
-// Mock DataSource
-const mockDataSource = {
-  getRepository: vi.fn()
-} as unknown as DataSource;
-
-// Mock repositories
-const mockUserRepository = {
-  create: vi.fn(),
-  save: vi.fn(),
-  findOne: vi.fn(),
-  update: vi.fn(),
-  delete: vi.fn(),
-  find: vi.fn(),
-  findByIds: vi.fn()
-} as unknown as Repository<UserEntity>;
-
-const mockRoleRepository = {
-  findByIds: vi.fn()
-} as unknown as Repository<Role>;
-
-describe('UserService', () => {
-  let userService: UserService;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Setup mock repositories
-    vi.mocked(mockDataSource.getRepository)
-      .mockReturnValueOnce(mockUserRepository)
-      .mockReturnValueOnce(mockRoleRepository);
-
-    userService = new UserService(mockDataSource);
-  });
-
-  describe('createUser', () => {
-    it('should create a user with hashed password', async () => {
-      const userData = {
-        username: 'testuser',
-        password: 'password123',
-        email: 'test@example.com'
-      };
-
-      const mockUser = {
-        id: 1,
-        ...userData,
-        password: 'hashed_password',
-        phone: null,
-        nickname: null,
-        name: null,
-        avatarFileId: null,
-        disabledStatus: 'enabled',
-        deleteStatus: 'active',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        roles: []
-      } as unknown as UserEntity;
-
-      vi.mocked(mockUserRepository.create).mockReturnValue(mockUser);
-      vi.mocked(mockUserRepository.save).mockResolvedValue(mockUser);
-
-      const result = await userService.createUser(userData);
-
-      expect(mockUserRepository.create).toHaveBeenCalledWith({
-        ...userData,
-        password: expect.not.stringMatching('password123') // Password should be hashed
-      });
-      expect(mockUserRepository.save).toHaveBeenCalledWith(mockUser);
-      expect(result).toEqual(mockUser);
-    });
-
-    it('should throw error when creation fails', async () => {
-      const userData = {
-        username: 'testuser',
-        password: 'password123'
-      };
-
-      vi.mocked(mockUserRepository.create).mockImplementation(() => {
-        throw new Error('Database error');
-      });
-
-      await expect(userService.createUser(userData)).rejects.toThrow('Failed to create user');
-    });
-  });
-
-  describe('getUserById', () => {
-    it('should return user by id', async () => {
-      const mockUser = {
-        id: 1,
-        username: 'testuser',
-        password: 'hashedpassword',
-        phone: null,
-        email: 'test@example.com',
-        nickname: null,
-        name: null,
-        avatarFileId: null,
-        disabledStatus: 'enabled',
-        deleteStatus: 'active',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        roles: []
-      } as unknown as UserEntity;
-
-      vi.mocked(mockUserRepository.findOne).mockResolvedValue(mockUser);
-
-      const result = await userService.getUserById(1);
-
-      expect(mockUserRepository.findOne).toHaveBeenCalledWith({
-        where: { id: 1 },
-        relations: ['roles', 'avatarFile']
-      });
-      expect(result).toEqual(mockUser);
-    });
-
-    it('should return null when user not found', async () => {
-      vi.mocked(mockUserRepository.findOne).mockResolvedValue(null);
-
-      const result = await userService.getUserById(999);
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('getUserByUsername', () => {
-    it('should return user by username', async () => {
-      const mockUser = {
-        id: 1,
-        username: 'testuser',
-        password: 'hashedpassword',
-        phone: null,
-        email: 'test@example.com',
-        nickname: null,
-        name: null,
-        avatarFileId: null,
-        disabledStatus: 'enabled',
-        deleteStatus: 'active',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        roles: []
-      } as unknown as UserEntity;
-
-      vi.mocked(mockUserRepository.findOne).mockResolvedValue(mockUser);
-
-      const result = await userService.getUserByUsername('testuser');
-
-      expect(mockUserRepository.findOne).toHaveBeenCalledWith({
-        where: { username: 'testuser' },
-        relations: ['roles', 'avatarFile']
-      });
-      expect(result).toEqual(mockUser);
-    });
-  });
-
-  describe('updateUser', () => {
-    it('should update user with hashed password', async () => {
-      const updateData = {
-        password: 'newpassword',
-        email: 'new@example.com'
-      };
-
-      const updatedUser = {
-        id: 1,
-        username: 'testuser',
-        password: 'hashed_newpassword',
-        email: 'new@example.com',
-        roles: []
-      } as unknown as UserEntity;
-
-      vi.mocked(mockUserRepository.update).mockResolvedValue({ affected: 1 } as any);
-      vi.mocked(mockUserRepository.findOne).mockResolvedValue(updatedUser);
-
-      const result = await userService.updateUser(1, updateData);
-
-      expect(mockUserRepository.update).toHaveBeenCalledWith(1, {
-        ...updateData,
-        password: expect.not.stringMatching('newpassword') // Password should be hashed
-      });
-      expect(result).toEqual(updatedUser);
-    });
-  });
-
-  describe('deleteUser', () => {
-    it('should delete user successfully', async () => {
-      vi.mocked(mockUserRepository.delete).mockResolvedValue({ affected: 1 } as any);
-
-      const result = await userService.deleteUser(1);
-
-      expect(mockUserRepository.delete).toHaveBeenCalledWith(1);
-      expect(result).toBe(true);
-    });
-
-    it('should return false when user not found', async () => {
-      vi.mocked(mockUserRepository.delete).mockResolvedValue({ affected: 0 } as any);
-
-      const result = await userService.deleteUser(999);
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('assignRoles', () => {
-    it('should assign roles to user', async () => {
-      const mockUser = {
-        id: 1,
-        username: 'testuser',
-        password: 'hashedpassword',
-        phone: null,
-        email: 'test@example.com',
-        nickname: null,
-        name: null,
-        avatarFileId: null,
-        disabledStatus: 'enabled',
-        deleteStatus: 'active',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        roles: []
-      } as unknown as UserEntity;
-
-      const mockRoles = [
-        { id: 1, name: 'admin' } as Role,
-        { id: 2, name: 'user' } as Role
-      ];
-
-      vi.mocked(mockUserRepository.findOne).mockResolvedValue(mockUser);
-      vi.mocked(mockRoleRepository.findByIds).mockResolvedValue(mockRoles);
-      vi.mocked(mockUserRepository.save).mockResolvedValue({
-        ...mockUser,
-        roles: mockRoles
-      } as UserEntity);
-
-      const result = await userService.assignRoles(1, [1, 2]);
-
-      expect(mockRoleRepository.findByIds).toHaveBeenCalledWith([1, 2]);
-      expect(mockUserRepository.save).toHaveBeenCalledWith({
-        ...mockUser,
-        roles: mockRoles
-      });
-      expect(result?.roles).toEqual(mockRoles);
-    });
-
-    it('should return null when user not found', async () => {
-      vi.mocked(mockUserRepository.findOne).mockResolvedValue(null);
-
-      const result = await userService.assignRoles(999, [1, 2]);
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('getUsers', () => {
-    it('should return all users', async () => {
-      const mockUsers = [
-        { id: 1, username: 'user1', roles: [] },
-        { id: 2, username: 'user2', roles: [] }
-      ] as unknown as UserEntity[];
-
-      vi.mocked(mockUserRepository.find).mockResolvedValue(mockUsers);
-
-      const result = await userService.getUsers();
-
-      expect(mockUserRepository.find).toHaveBeenCalledWith({
-        relations: ['roles', 'avatarFile']
-      });
-      expect(result).toEqual(mockUsers);
-    });
-  });
-
-  describe('getUserByAccount', () => {
-    it('should return user by username or email', async () => {
-      const mockUser = {
-        id: 1,
-        username: 'testuser',
-        email: 'test@example.com',
-        roles: []
-      } as unknown as UserEntity;
-
-      vi.mocked(mockUserRepository.findOne).mockResolvedValue(mockUser);
-
-      const result = await userService.getUserByAccount('testuser');
-
-      expect(mockUserRepository.findOne).toHaveBeenCalledWith({
-        where: [{ username: 'testuser' }, { email: 'testuser' }],
-        relations: ['roles', 'avatarFile']
-      });
-      expect(result).toEqual(mockUser);
-    });
-  });
-});