furniture-3d-system-Wu/tests/api/users.test.ts

/**
 * 用户管理 API 集成测试
 * 
 * 测试范围：
 * - 用户列表查询
 * - 用户创建
 * - 用户更新
 * - 用户删除
 * - 用户角色管理
 */

import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
import { PrismaClient } from '@prisma/client';
import { setupTestEnvironment, cleanDatabase } from '../helpers/test-utils';

const prisma = new PrismaClient();

describe('用户管理 API 测试', () => {
  let testEnv: any;

  beforeAll(async () => {
    await cleanDatabase();
    testEnv = await setupTestEnvironment();
  });

  afterAll(async () => {
    await cleanDatabase();
    await prisma.$disconnect();
  });

  describe('用户列表查询', () => {
    it('超级管理员应该能查看所有用户', async () => {
      const users = await prisma.user.findMany({
        select: {
          id: true,
          email: true,
          name: true,
          role: true,
          departmentId: true,
          teamId: true
        }
      });

      expect(users.length).toBeGreaterThan(0);
    });

    it('部门管理员应该能查看本部门用户', async () => {
      const users = await prisma.user.findMany({
        where: {
          departmentId: testEnv.department.id
        },
        select: {
          id: true,
          email: true,
          name: true,
          role: true
        }
      });

      expect(users.length).toBeGreaterThan(0);
      users.forEach(user => {
        expect(user).toHaveProperty('email');
        expect(user).toHaveProperty('name');
      });
    });

    it('应该支持按角色筛选', async () => {
      const designers = await prisma.user.findMany({
        where: {
          role: 'DESIGNER'
        }
      });

      designers.forEach(user => {
        expect(user.role).toBe('DESIGNER');
      });
    });

    it('应该支持搜索功能', async () => {
      const users = await prisma.user.findMany({
        where: {
          name: {
            contains: '设计师'
          }
        }
      });

      users.forEach(user => {
        expect(user.name).toContain('设计师');
      });
    });
  });

  describe('用户创建', () => {
    it('管理员应该能创建新用户', async () => {
      const userData = {
        email: 'newuser@test.com',
        name: '新用户',
        password: await require('@/lib/password').hashPassword('Test123456!'),
        role: 'DESIGNER' as any,
        departmentId: testEnv.department.id,
        isFirstLogin: true
      };

      const user = await prisma.user.create({
        data: userData
      });

      expect(user).toBeDefined();
      expect(user.email).toBe(userData.email);
      expect(user.name).toBe(userData.name);
      expect(user.isFirstLogin).toBe(true);
    });

    it('应该拒绝重复的邮箱', async () => {
      const password = await require('@/lib/password').hashPassword('Test123456!');

      await expect(
        prisma.user.create({
          data: {
            email: testEnv.users.designer.email,
            name: '重复邮箱测试',
            password,
            role: 'DESIGNER'
          }
        })
      ).rejects.toThrow();
    });

    it('应该拒绝重复的姓名', async () => {
      const password = await require('@/lib/password').hashPassword('Test123456!');

      await expect(
        prisma.user.create({
          data: {
            email: 'unique@test.com',
            name: testEnv.users.designer.name,
            password,
            role: 'DESIGNER'
          }
        })
      ).rejects.toThrow();
    });
  });

  describe('用户更新', () => {
    it('应该能更新用户信息', async () => {
      const updatedUser = await prisma.user.update({
        where: { id: testEnv.users.designer.id },
        data: {
          name: '更新后的设计师'
        }
      });

      expect(updatedUser.name).toBe('更新后的设计师');
    });

    it('应该能更新用户角色', async () => {
      const user = await prisma.user.create({
        data: {
          email: 'roletest@test.com',
          name: '角色测试用户',
          password: await require('@/lib/password').hashPassword('Test123456!'),
          role: 'DESIGNER'
        }
      });

      const updatedUser = await prisma.user.update({
        where: { id: user.id },
        data: { role: 'TEAM_LEADER' }
      });

      expect(updatedUser.role).toBe('TEAM_LEADER');
    });

    it('应该能分配用户到部门', async () => {
      const user = await prisma.user.create({
        data: {
          email: 'depttest@test.com',
          name: '部门测试用户',
          password: await require('@/lib/password').hashPassword('Test123456!'),
          role: 'DESIGNER'
        }
      });

      const updatedUser = await prisma.user.update({
        where: { id: user.id },
        data: { departmentId: testEnv.department.id }
      });

      expect(updatedUser.departmentId).toBe(testEnv.department.id);
    });
  });

  describe('用户删除', () => {
    it('应该能删除用户', async () => {
      const user = await prisma.user.create({
        data: {
          email: 'deletetest@test.com',
          name: '待删除用户',
          password: await require('@/lib/password').hashPassword('Test123456!'),
          role: 'DESIGNER'
        }
      });

      await prisma.user.delete({
        where: { id: user.id }
      });

      const deletedUser = await prisma.user.findUnique({
        where: { id: user.id }
      });

      expect(deletedUser).toBeNull();
    });

    it('删除用户前应该检查关联数据', async () => {
      // 检查用户是否有创建的产品
      const products = await prisma.product.findMany({
        where: {
          createdBy: testEnv.users.designer.id,
          deletedAt: null
        }
      });

      // 如果有产品，应该先处理产品
      if (products.length > 0) {
        expect(products.length).toBeGreaterThan(0);
      }
    });
  });

  describe('用户角色管理', () => {
    it('应该正确设置用户角色', async () => {
      const roles = ['SUPER_ADMIN', 'ADMIN', 'DEPARTMENT_MANAGER', 'TEAM_LEADER', 'DESIGNER', 'VIEWER'];

      for (const role of roles) {
        const user = await prisma.user.create({
          data: {
            email: `${role.toLowerCase()}@test.com`,
            name: `${role}用户`,
            password: await require('@/lib/password').hashPassword('Test123456!'),
            role: role as any
          }
        });

        expect(user.role).toBe(role);
      }
    });

    it('应该拒绝无效的角色', async () => {
      await expect(
        prisma.user.create({
          data: {
            email: 'invalidrole@test.com',
            name: '无效角色',
            password: await require('@/lib/password').hashPassword('Test123456!'),
            role: 'INVALID_ROLE' as any
          }
        })
      ).rejects.toThrow();
    });
  });
});