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

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);
    });
  });
});