refactor: remove User-based import and RBAC UserDingMapping endpoints

apps/server/src/sync/sync.service.spec.ts

@@ -1,467 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { getRepositoryToken } from '@nestjs/typeorm';
-import { DataSource, Repository } from 'typeorm';
-import { SyncService, ImportUserDto } from './sync.service';
-import { SyncLog, SyncState, StudentDingMapping, ClassStudent, ClassTeacher } from '../entities';
-import { Class as ClassEntity } from '../entities/class.entity';
-import { User } from '../entities/user.entity';
-import { Student } from '../entities/student.entity';
-import { Role } from '../entities/role.entity';
-import { DingTalkService } from '../integration/dingtalk.service';
-import { WeComService } from '../integration/wecom.service';
-import { AttendanceImportService } from '../attendance/attendance-import.service';
-import { ScheduleSyncService } from './schedule-sync.service';
-import { BadRequestException } from '@nestjs/common';
-
-// ── EntityManager mock helpers ──
-
-interface ManagerMock {
-  create: jest.Mock;
-  save: jest.Mock;
-  findOne: jest.Mock;
-  count: jest.Mock;
-}
-
-function mockManager(overrides: Partial<ManagerMock> = {}): ManagerMock {
-  return {
-    create: jest.fn(),
-    save: jest.fn(),
-    findOne: jest.fn(),
-    count: jest.fn(),
-    ...overrides,
-  };
-}
-
-describe('SyncService — importDingTalkUsers (transactional)', () => {
-  let service: SyncService;
-
-  let mappingRepo: jest.Mocked<
-    Pick<Repository<StudentDingMapping>, 'findOne' | 'create' | 'save' | 'find'>
-  >;
-  let userRepo: jest.Mocked<Pick<Repository<User>, 'create' | 'save'>>;
-  let studentRepo: jest.Mocked<Pick<Repository<Student>, 'create' | 'save'>>;
-  let roleRepo: jest.Mocked<Pick<Repository<Role>, 'findOne'>>;
-  let classRepo: jest.Mocked<Pick<Repository<ClassEntity>, 'find'>>;
-  let dataSourceMock: jest.Mocked<Pick<DataSource, 'transaction'>>;
-
-  let dingTalkService: jest.Mocked<Pick<DingTalkService, 'fetchOrgTreeWithUsers' | 'syncAll' | 'fetchOrgTree'>>;
-
-  let mgr: ManagerMock;
-  beforeEach(async () => {
-    mgr = mockManager();
-
-    // Smart defaults: create returns data with id, save passes through
-    let nextId = 1;
-    mgr.create.mockImplementation((_entityClass: unknown, data: Record<string, unknown>) => ({
-      id: nextId++,
-      ...data,
-    }));
-    mgr.save.mockImplementation((entityOrClass: unknown, data?: Record<string, unknown>) => {
-      if (data !== undefined) {
-        return Promise.resolve({ id: nextId++, ...data });
-      }
-      return Promise.resolve(entityOrClass);
-    });
-    mgr.count.mockResolvedValue(0);
-
-    classRepo = {
-      find: jest.fn().mockResolvedValue([]),
-    };
-
-    mappingRepo = {
-      findOne: jest.fn(),
-      create: jest.fn(),
-      save: jest.fn(),
-      find: jest.fn().mockResolvedValue([]),
-    };
-
-    userRepo = {
-      create: jest.fn(),
-      save: jest.fn(),
-    };
-
-    studentRepo = {
-      create: jest.fn(),
-      save: jest.fn(),
-    };
-
-    roleRepo = {
-      findOne: jest.fn(),
-    };
-
-    dataSourceMock = {
-      transaction: jest.fn().mockImplementation(
-        async (cb: (manager: ManagerMock) => Promise<void>) => cb(mgr),
-      ),
-    };
-    dingTalkService = {
-      fetchOrgTreeWithUsers: jest.fn(),
-      syncAll: jest.fn(),
-      fetchOrgTree: jest.fn(),
-    };
-
-    const mockWeComService = { syncAll: jest.fn() };
-    const mockAttendanceImportService = { importFromDingTalk: jest.fn() };
-    const mockScheduleSyncService = { syncAll: jest.fn(), getStatus: jest.fn() };
-
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        SyncService,
-        { provide: getRepositoryToken(SyncLog), useValue: { create: jest.fn(), save: jest.fn(), find: jest.fn(), findOne: jest.fn() } },
-        { provide: getRepositoryToken(SyncState), useValue: { findOne: jest.fn(), upsert: jest.fn() } },
-        { provide: getRepositoryToken(StudentDingMapping), useValue: mappingRepo },
-        { provide: getRepositoryToken(User), useValue: userRepo },
-        { provide: getRepositoryToken(Student), useValue: studentRepo },
-        { provide: getRepositoryToken(Role), useValue: roleRepo },
-        { provide: getRepositoryToken(ClassEntity), useValue: classRepo },
-        { provide: DataSource, useValue: dataSourceMock },
-        { provide: DingTalkService, useValue: dingTalkService },
-        { provide: WeComService, useValue: mockWeComService },
-        { provide: AttendanceImportService, useValue: mockAttendanceImportService },
-        { provide: ScheduleSyncService, useValue: mockScheduleSyncService },
-      ],
-    }).compile();
-
-    service = module.get<SyncService>(SyncService);
-  });
-
-  // ── getDingTalkOrgTreeWithUsers ──
-
-  it('getDingTalkOrgTreeWithUsers delegates to dingTalkService.fetchOrgTreeWithUsers', async () => {
-    const mockTree = [{ id: 1, name: 'root', parentId: 0, children: [], users: [] }];
-    dingTalkService.fetchOrgTreeWithUsers.mockResolvedValue(mockTree);
-
-    const result = await service.getDingTalkOrgTreeWithUsers(1);
-
-    expect(dingTalkService.fetchOrgTreeWithUsers).toHaveBeenCalledWith(1);
-    expect(result).toBe(mockTree);
-  });
-
-  // ── importDingTalkUsers ──
-
-  it('imports teacher when roleId is a number (role found)', async () => {
-    const mockRole = { id: 5, name: 'Teacher' } as Role;
-    mgr.findOne.mockImplementation(async (entityClass: unknown) => {
-      if (entityClass === StudentDingMapping) return null;
-      if (entityClass === Role) return mockRole;
-      return null;
-    });
-
-    const mockUser = { id: 10 } as User;
-    mgr.create.mockReturnValue(mockUser);
-    mgr.save.mockResolvedValue(mockUser);
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 'user1', name: 'Zhang San', mobile: '13800001111', roleId: 5 },
-    ];
-
-    const result = await service.importDingTalkUsers(users);
-
-    expect(result.teacherCount).toBe(1);
-    expect(result.studentCount).toBe(0);
-    expect(result.skipped).toBe(0);
-    expect(result.warnings).toEqual([]);
-
-    expect(dataSourceMock.transaction).toHaveBeenCalledTimes(1);
-    expect(mgr.findOne).toHaveBeenCalledWith(Role, { where: { id: 5 } });
-    expect(mgr.save).toHaveBeenCalledWith(
-      expect.objectContaining({ roles: [mockRole] }),
-    );
-  });
-
-  it('throws when role not found', async () => {
-    // StudentDingMapping lookup → null (not skipped), Role lookup → null → throws
-    mgr.findOne.mockResolvedValue(null);
-
-    const mockUser = { id: 11 } as User;
-    mgr.create.mockReturnValue(mockUser);
-    mgr.save.mockResolvedValue(mockUser);
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 'user2', name: 'Li Si', mobile: '13800002222', roleId: 999 },
-    ];
-
-    await expect(service.importDingTalkUsers(users)).rejects.toThrow(BadRequestException);
-    expect(dataSourceMock.transaction).toHaveBeenCalledTimes(1);
-  });
-  it('imports student when roleId is null', async () => {
-    const mockUser = { id: 20 } as User;
-    mgr.create.mockReturnValueOnce(mockUser);
-    mgr.save.mockResolvedValueOnce(mockUser);
-
-    const mockStudent = { id: 30 } as Student;
-    mgr.create.mockReturnValueOnce(mockStudent);
-    mgr.save.mockResolvedValueOnce(mockStudent);
-
-    // mapping create+save also calls create/save
-    mgr.create.mockReturnValueOnce({} as StudentDingMapping);
-    mgr.save.mockResolvedValueOnce({} as StudentDingMapping);
-
-    mappingRepo.findOne.mockResolvedValue(null);
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 'user3', name: 'Wang Wu', mobile: '', roleId: null },
-    ];
-
-    const result = await service.importDingTalkUsers(users);
-
-    expect(result.studentCount).toBe(1);
-    expect(result.teacherCount).toBe(0);
-    expect(result.skipped).toBe(0);
-    expect(result.warnings).toEqual([]);
-
-    // Verify Student was created via manager
-    const studentCreateCalls = mgr.create.mock.calls.filter(
-      ([entity]) => entity === Student,
-    );
-    expect(studentCreateCalls.length).toBe(1);
-    expect(studentCreateCalls[0][1]).toEqual(
-      expect.objectContaining({
-        name: 'Wang Wu',
-        userId: 20,
-        status: 'active',
-      }),
-    );
-
-  });
-  it('skips user when mapping already exists', async () => {
-    // mgr.findOne(StudentDingMapping, ...) returns truthy → skip inside transaction
-    mgr.findOne.mockResolvedValue({ id: 1 });
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 'existing', name: 'Zhao Liu', mobile: '13800003333', roleId: null },
-    ];
-
-    const result = await service.importDingTalkUsers(users);
-
-    expect(result.skipped).toBe(1);
-    expect(result.teacherCount).toBe(0);
-    expect(result.studentCount).toBe(0);
-    expect(result.warnings).toEqual([]);
-    expect(dataSourceMock.transaction).toHaveBeenCalledTimes(1);
-  });
-
-  it('transaction error propagates to caller', async () => {
-    dataSourceMock.transaction.mockImplementationOnce(async () => {
-      throw new Error('DB error');
-    });
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 'fail', name: 'Fail User', mobile: '', roleId: null },
-    ];
-
-    await expect(service.importDingTalkUsers(users)).rejects.toThrow('DB error');
-    expect(dataSourceMock.transaction).toHaveBeenCalledTimes(1);
-  });
-
-  it('counts mixed teacher/student/skipped correctly', async () => {
-    const mockRole = { id: 1, name: 'Teacher Role' } as Role;
-
-    // Single transaction: User 1→skip, User 2→teacher, User 3→student
-    mgr.findOne
-      .mockResolvedValueOnce({ id: 99 })  // User 1: StudentDingMapping → skip
-      .mockResolvedValueOnce(null)         // User 2: StudentDingMapping → not skipped
-      .mockResolvedValueOnce(mockRole)     // User 2: Role lookup
-      .mockResolvedValueOnce(null);        // User 3: StudentDingMapping → not skipped
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 'skip', name: 'Skip', mobile: '138', roleId: null, dingDeptIds: [] },
-      { dingUserId: 'teacher', name: 'Teacher', mobile: '139', roleId: 1, dingDeptIds: [] },
-      { dingUserId: 'student', name: 'Student', mobile: '', roleId: null, dingDeptIds: [] },
-    ];
-
-    const result = await service.importDingTalkUsers(users);
-
-    expect(result.teacherCount).toBe(1);
-    expect(result.studentCount).toBe(1);
-    expect(result.skipped).toBe(1);
-    expect(result.warnings).toEqual([]);
-    expect(dataSourceMock.transaction).toHaveBeenCalledTimes(1);
-  });
-
-  // ── class-marking import ──
-
-  it('creates Class, ClassTeacher(roleType=teacher), and ClassStudent for single mixed dept', async () => {
-    mgr.findOne.mockImplementation(async (entityClass: unknown, opts?: { where?: Record<string, unknown> }) => {
-      if (entityClass === Role) return { id: 5 };
-      if (entityClass === Student && opts?.where) return { id: 100, userId: opts.where.userId };
-      return null;
-    });
-    mgr.count.mockImplementation(async (entityClass: unknown) =>
-      entityClass === ClassTeacher || entityClass === ClassStudent ? 1 : 0,
-    );
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 't1', name: 'Teacher', mobile: '1381', roleId: 5, dingDeptIds: [1] },
-      { dingUserId: 's1', name: 'Student', mobile: '1382', roleId: null, dingDeptIds: [1] },
-    ];
-    const classes = [{ deptId: 1, name: 'Class A', code: 'A01', classType: 'culture' }];
-
-    const result = await service.importDingTalkUsers(users, classes);
-
-    expect(result.teacherCount).toBe(1);
-    expect(result.studentCount).toBe(1);
-    expect(result.classCount).toBe(1);
-    expect(result.skipped).toBe(0);
-    expect(result.warnings).toEqual([]);
-
-    // ClassTeacher: roleType='teacher'
-    const ctCalls = mgr.create.mock.calls.filter(([ec]) => ec === ClassTeacher);
-    expect(ctCalls.length).toBe(1);
-    expect(ctCalls[0][1]).toEqual(expect.objectContaining({ roleType: 'teacher' }));
-
-    // ClassStudent: status='active'
-    const csCalls = mgr.create.mock.calls.filter(([ec]) => ec === ClassStudent);
-    expect(csCalls.length).toBe(1);
-    expect(csCalls[0][1]).toEqual(expect.objectContaining({ status: 'active' }));
-
-    // Class saved via manager.save(ClassEntity, data)
-    expect(mgr.save).toHaveBeenCalledWith(ClassEntity, expect.objectContaining({
-      name: 'Class A',
-      code: 'A01',
-    }));
-  });
-
-  it('creates ClassTeacher entries for all teachers in a dept', async () => {
-    mgr.findOne.mockImplementation(async (entityClass: unknown) => {
-      if (entityClass === Role) return { id: 5 };
-      return null;
-    });
-    mgr.count.mockImplementation(async (entityClass: unknown) =>
-      entityClass === ClassTeacher ? 2 : 0,
-    );
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 't1', name: 'T1', mobile: '1381', roleId: 5, dingDeptIds: [1] },
-      { dingUserId: 't2', name: 'T2', mobile: '1382', roleId: 5, dingDeptIds: [1] },
-    ];
-    const classes = [{ deptId: 1, name: 'Class A', code: 'A02', classType: 'culture' }];
-
-    const result = await service.importDingTalkUsers(users, classes);
-
-    expect(result.teacherCount).toBe(2);
-    expect(result.studentCount).toBe(0);
-    expect(result.classCount).toBe(1);
-
-    const ctCalls = mgr.create.mock.calls.filter(([ec]) => ec === ClassTeacher);
-    expect(ctCalls.length).toBe(2);
-    ctCalls.forEach(([, data]) => {
-      expect(data).toEqual(expect.objectContaining({ roleType: 'teacher' }));
-    });
-  });
-
-  it('joins user to all matching classes when in multiple marked depts', async () => {
-    mgr.findOne.mockImplementation(async (entityClass: unknown) => {
-      if (entityClass === Role) return { id: 5 };
-      return null;
-    });
-    mgr.count.mockImplementation(async (entityClass: unknown) =>
-      entityClass === ClassTeacher ? 2 : 0,
-    );
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 't1', name: 'T1', mobile: '1381', roleId: 5, dingDeptIds: [1, 2] },
-    ];
-    const classes = [
-      { deptId: 1, name: 'Class A', code: 'A03', classType: 'culture' },
-      { deptId: 2, name: 'Class B', code: 'B01', classType: 'professional' },
-    ];
-
-    const result = await service.importDingTalkUsers(users, classes);
-
-    expect(result.teacherCount).toBe(1);
-    expect(result.classCount).toBe(2);
-
-    const ctCalls = mgr.create.mock.calls.filter(([ec]) => ec === ClassTeacher);
-    expect(ctCalls.length).toBe(2);
-  });
-
-  it('throws BadRequestException when class code already exists', async () => {
-    classRepo.find.mockResolvedValue([{ id: 1, code: 'DUP', name: 'Existing' } as ClassEntity]);
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 't1', name: 'T1', mobile: '1381', roleId: 5, dingDeptIds: [1] },
-    ];
-    const classes = [{ deptId: 1, name: 'New Class', code: 'DUP', classType: 'culture' }];
-
-    await expect(service.importDingTalkUsers(users, classes)).rejects.toThrow(BadRequestException);
-    expect(dataSourceMock.transaction).not.toHaveBeenCalled();
-  });
-
-  it('returns warning for empty dept with no users', async () => {
-    mgr.findOne.mockImplementation(async (entityClass: unknown) => {
-      if (entityClass === Role) return { id: 5 };
-      return null;
-    });
-    mgr.count.mockResolvedValue(0);
-    // save(ClassEntity, data) returns a class — but the smart mock already handles this
-    mgr.findOne.mockResolvedValueOnce(null); // first findOne: StudentDingMapping for teacher
-    mgr.findOne.mockResolvedValueOnce({ id: 5 }); // Role lookup
-    mgr.findOne.mockResolvedValueOnce({ name: 'Empty Class' }); // Class lookup in empty check
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 't1', name: 'T1', mobile: '1381', roleId: 5, dingDeptIds: [99] },
-    ];
-    const classes = [{ deptId: 1, name: 'Empty Class', code: 'E01', classType: 'culture' }];
-
-    const result = await service.importDingTalkUsers(users, classes);
-
-    expect(result.classCount).toBe(1);
-    expect(result.warnings).toContainEqual(
-      expect.stringContaining('无任何师生'),
-    );
-    expect(result.warnings[0]).toContain('Empty Class');
-  });
-
-  it('creates ClassStudent correctly for student-only dept', async () => {
-    mgr.findOne.mockImplementation(async (entityClass: unknown, opts?: { where?: Record<string, unknown> }) => {
-      if (entityClass === Student && opts?.where) return { id: 100, userId: opts.where.userId };
-      return null;
-    });
-    mgr.count.mockImplementation(async (entityClass: unknown) =>
-      entityClass === ClassStudent ? 1 : 0,
-    );
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 's1', name: 'Student', mobile: '1382', roleId: null, dingDeptIds: [1] },
-    ];
-    const classes = [{ deptId: 1, name: 'Class A', code: 'S01', classType: 'culture' }];
-
-    const result = await service.importDingTalkUsers(users, classes);
-
-    expect(result.teacherCount).toBe(0);
-    expect(result.studentCount).toBe(1);
-    expect(result.classCount).toBe(1);
-    expect(result.warnings).toEqual([]);
-
-    const csCalls = mgr.create.mock.calls.filter(([ec]) => ec === ClassStudent);
-    expect(csCalls.length).toBe(1);
-    expect(csCalls[0][1]).toEqual(expect.objectContaining({ status: 'active' }));
-  });
-
-  it('returns classCount=0 and preserves backward compat when no classes param', async () => {
-    mgr.findOne.mockImplementation(async (entityClass: unknown) => {
-      if (entityClass === Role) return { id: 5 };
-      return null;
-    });
-
-    const users: ImportUserDto[] = [
-      { dingUserId: 't1', name: 'Teacher', mobile: '1381', roleId: 5, dingDeptIds: [1] },
-    ];
-
-    const result = await service.importDingTalkUsers(users);
-
-    expect(result.teacherCount).toBe(1);
-    expect(result.studentCount).toBe(0);
-    expect(result.classCount).toBe(0);
-    expect(result.skipped).toBe(0);
-    expect(result.warnings).toEqual([]);
-
-    // No class-related operations
-    const ctCalls = mgr.create.mock.calls.filter(([ec]) => ec === ClassTeacher);
-    expect(ctCalls.length).toBe(0);
-    const csCalls = mgr.create.mock.calls.filter(([ec]) => ec === ClassStudent);
-    expect(csCalls.length).toBe(0);
-    expect(classRepo.find).not.toHaveBeenCalled();
-  });
-});