test: cover end-to-end attendance workflow

apps/server/src/attendance/attendance-workflow.integration.spec.ts

@@ -0,0 +1,336 @@
+import type { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import request from 'supertest';
+import type { Repository } from 'typeorm';
+import { AppModule } from '../app.module';
+import type { DingTalkAttendanceResult } from '../integration/dingtalk.service';
+import { DingTalkService } from '../integration/dingtalk.service';
+import {
+  AttendanceRecord,
+  Organization,
+  Role,
+  Student,
+  StudentDingMapping,
+  User,
+} from '../entities';
+import { createStudentImportTemplateWorkbook } from '../students/student-import';
+
+const LESSON_DATE = new Intl.DateTimeFormat('en-CA', {
+  timeZone: 'Asia/Shanghai',
+  year: 'numeric',
+  month: '2-digit',
+  day: '2-digit',
+}).format(new Date());
+const STUDENT_A_DING_ID = 'integration-student-a';
+const STUDENT_B_DING_ID = 'integration-student-b';
+
+const auth = (token: string) => ({ Authorization: `Bearer ${token}` });
+
+function chinaWeekDay(date: string): number {
+  const day = new Date(`${date}T00:00:00+08:00`).getDay();
+  return day === 0 ? 7 : day;
+}
+
+function attendanceResult(
+  userId: string,
+  checkId: string,
+  actualCheckTime: string,
+): DingTalkAttendanceResult {
+  return {
+    userId,
+    userName: '',
+    workDate: LESSON_DATE,
+    timeResult: 'Normal',
+    locationResult: 'Normal',
+    planCheckTime: `${LESSON_DATE}T00:00:00+08:00`,
+    actualCheckTime,
+    checkId,
+    checkType: 'OnDuty',
+    sourceType: 'ATM',
+    deviceName: '集成测试考勤机',
+    deviceId: 'integration-device',
+  };
+}
+
+describe('attendance workflow integration', () => {
+  let app: INestApplication;
+  let adminToken: string;
+  let teacherToken: string;
+  let mockedPunches: DingTalkAttendanceResult[];
+  const originalEnv = {
+    DB_TYPE: process.env.DB_TYPE,
+    DB_DATABASE: process.env.DB_DATABASE,
+    DB_SYNCHRONIZE: process.env.DB_SYNCHRONIZE,
+    SEED_DEV: process.env.SEED_DEV,
+    ADMIN_PASSWORD: process.env.ADMIN_PASSWORD,
+  };
+
+  beforeAll(async () => {
+    process.env.DB_TYPE = 'sqlite';
+    process.env.DB_DATABASE = ':memory:';
+    process.env.DB_SYNCHRONIZE = 'true';
+    process.env.SEED_DEV = 'true';
+    process.env.ADMIN_PASSWORD = 'admin123';
+
+    mockedPunches = [];
+    const dingTalk = {
+      fetchAttendanceResults: jest.fn(async () => mockedPunches),
+    };
+
+    const moduleRef = await Test.createTestingModule({ imports: [AppModule] })
+      .overrideProvider(DingTalkService)
+      .useValue(dingTalk)
+      .compile();
+
+    app = moduleRef.createNestApplication();
+    app.setGlobalPrefix('api');
+    await app.init();
+
+    const login = await request(app.getHttpServer())
+      .post('/api/auth/login')
+      .send({ username: 'admin', password: 'admin123' })
+      .expect(201);
+    adminToken = login.body.access_token;
+  });
+
+  afterAll(async () => {
+    await app?.close();
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  });
+
+  it('imports students, builds a teacher class schedule, refreshes punches, and scopes reads', async () => {
+    let classId: number;
+    let scheduleId: number;
+    let studentA: Student;
+    let studentB: Student;
+
+    const roleRepo = app.get<Repository<Role>>(getRepositoryToken(Role));
+    const userRepo = app.get<Repository<User>>(getRepositoryToken(User));
+    const studentRepo = app.get<Repository<Student>>(getRepositoryToken(Student));
+    const mappingRepo = app.get<Repository<StudentDingMapping>>(
+      getRepositoryToken(StudentDingMapping),
+    );
+    const organizationRepo = app.get<Repository<Organization>>(getRepositoryToken(Organization));
+    const attendanceRepo = app.get<Repository<AttendanceRecord>>(
+      getRepositoryToken(AttendanceRecord),
+    );
+
+    const teacherRole = await roleRepo.findOneByOrFail({ code: 'teacher' });
+    const teacherCreate = await request(app.getHttpServer())
+      .post('/api/rbac/users')
+      .set(auth(adminToken))
+      .send({
+        username: 'integration-teacher',
+        password: 'teacher123',
+        name: '集成测试任课教师',
+        roleIds: [teacherRole.id],
+      })
+      .expect(201);
+    expect(teacherCreate.body.message).toBe('用户创建成功');
+
+    const teacher = await userRepo.findOneByOrFail({ username: 'integration-teacher' });
+    const teacherId = teacher.id;
+    const teacherLogin = await request(app.getHttpServer())
+      .post('/api/auth/login')
+      .send({ username: 'integration-teacher', password: 'teacher123' })
+      .expect(201);
+    teacherToken = teacherLogin.body.access_token;
+
+    const host = await organizationRepo.findOneByOrFail({ isHost: true, status: 'active' });
+    const workbook = createStudentImportTemplateWorkbook();
+    const sheet = workbook.getWorksheet('学生基础+档案+录取')!;
+    sheet.spliceRows(2, 1);
+    sheet.addRow({
+      phone: '13800000001',
+      name: '集成学生甲',
+      studentNo: 'IT001',
+      organization: host.name,
+    });
+    sheet.addRow({
+      phone: '13800000002',
+      name: '集成学生乙',
+      studentNo: 'IT002',
+      organization: host.name,
+    });
+    const workbookBuffer = Buffer.from(await workbook.xlsx.writeBuffer());
+
+    const importResult = await request(app.getHttpServer())
+      .post('/api/students/import')
+      .set(auth(adminToken))
+      .attach('file', workbookBuffer, {
+        filename: 'attendance-workflow-students.xlsx',
+        contentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      })
+      .expect(201);
+    expect(importResult.body).toMatchObject({ imported: 2, skipped: 0 });
+
+    [studentA, studentB] = await Promise.all([
+      studentRepo.findOneByOrFail({ phone: '13800000001' }),
+      studentRepo.findOneByOrFail({ phone: '13800000002' }),
+    ]);
+    await mappingRepo.save([
+      mappingRepo.create({ dingUserId: STUDENT_A_DING_ID, studentId: studentA.id }),
+      mappingRepo.create({ dingUserId: STUDENT_B_DING_ID, studentId: studentB.id }),
+    ]);
+
+    const classResult = await request(app.getHttpServer())
+      .post('/api/classes')
+      .set(auth(adminToken))
+      .send({
+        name: '集成考勤班',
+        code: 'ATTENDANCE-INTEGRATION',
+        classType: 'culture',
+        status: 'active',
+        startDate: LESSON_DATE,
+        endDate: LESSON_DATE,
+      })
+      .expect(201);
+    classId = classResult.body.id;
+
+    await request(app.getHttpServer())
+      .post(`/api/classes/${classId}/students`)
+      .set(auth(adminToken))
+      .send({ studentIds: [studentA.id, studentB.id] })
+      .expect(201)
+      .expect(({ body }) => expect(body).toMatchObject({ added: 2, skipped: 0 }));
+
+    await request(app.getHttpServer())
+      .post(`/api/classes/${classId}/teachers`)
+      .set(auth(adminToken))
+      .send({ userId: teacherId, roleType: 'subject_teacher', subject: '语文' })
+      .expect(201);
+
+    const classroomResult = await request(app.getHttpServer())
+      .post('/api/classrooms')
+      .set(auth(adminToken))
+      .send({ name: '集成测试教室', building: '测试楼', floor: 1, capacity: 30, roomType: '小' })
+      .expect(201);
+
+    const scheduleResult = await request(app.getHttpServer())
+      .post('/api/class-schedules')
+      .set(auth(adminToken))
+      .send({
+        classId,
+        classroomId: classroomResult.body.id,
+        weekDay: chinaWeekDay(LESSON_DATE),
+        startTime: '00:00',
+        endTime: '23:59',
+        attendanceAdvanceMinutes: 0,
+        startDate: LESSON_DATE,
+        endDate: LESSON_DATE,
+        subject: '语文',
+        teacherId,
+        scheduleType: 'INTERNAL',
+      })
+      .expect(201);
+    scheduleId = scheduleResult.body.id;
+
+    const initialPull = await request(app.getHttpServer())
+      .post(`/api/attendance-lessons/schedules/${scheduleId}/pull`)
+      .set(auth(teacherToken))
+      .send({ date: LESSON_DATE })
+      .expect(201);
+    expect(initialPull.body.records).toHaveLength(2);
+    expect(initialPull.body.records.map((record: AttendanceRecord) => record.status)).toEqual([
+      'pending',
+      'pending',
+    ]);
+
+    const studentARecord = initialPull.body.records.find(
+      (record: AttendanceRecord) => record.studentId === studentA.id,
+    );
+    await request(app.getHttpServer())
+      .put(`/api/attendance-records/${studentARecord.id}`)
+      .set(auth(teacherToken))
+      .send({ status: 'absent', remark: '教师本地覆盖' })
+      .expect(200)
+      .expect(({ body }) => expect(body).toMatchObject({ status: 'absent', source: 'manual' }));
+
+    mockedPunches = [
+      attendanceResult(STUDENT_A_DING_ID, 'integration-check-a', `${LESSON_DATE}T01:00:00.000Z`),
+      attendanceResult(STUDENT_B_DING_ID, 'integration-check-b', `${LESSON_DATE}T01:05:00.000Z`),
+    ];
+
+    const refreshed = await request(app.getHttpServer())
+      .post(`/api/attendance-lessons/schedules/${scheduleId}/pull`)
+      .set(auth(teacherToken))
+      .send({ date: LESSON_DATE })
+      .expect(201);
+    expect(refreshed.body.records).toHaveLength(2);
+    expect(
+      refreshed.body.records.find((record: AttendanceRecord) => record.studentId === studentA.id),
+    ).toMatchObject({ status: 'absent', source: 'manual', remark: '教师本地覆盖' });
+    expect(
+      refreshed.body.records.find((record: AttendanceRecord) => record.studentId === studentB.id),
+    ).toMatchObject({ status: 'present', source: 'dingtalk', punchSource: 'ATM' });
+
+    const teacherRecords = await request(app.getHttpServer())
+      .get(
+        `/api/attendance-records?classId=${classId}&dateFrom=${LESSON_DATE}&dateTo=${LESSON_DATE}`,
+      )
+      .set(auth(teacherToken))
+      .expect(200);
+    expect(teacherRecords.body.list).toHaveLength(2);
+    const teacherView: Array<Pick<AttendanceRecord, 'studentId' | 'status' | 'source'>> =
+      teacherRecords.body.list
+        .map((record: AttendanceRecord) => ({
+          studentId: record.studentId,
+          status: record.status,
+          source: record.source,
+        }))
+        .sort((left, right) => left.studentId - right.studentId);
+    expect(teacherView).toEqual([
+      { studentId: studentA.id, status: 'absent', source: 'manual' },
+      { studentId: studentB.id, status: 'present', source: 'dingtalk' },
+    ]);
+
+    const adminRecords = await request(app.getHttpServer())
+      .get(
+        `/api/attendance-records?classId=${classId}&dateFrom=${LESSON_DATE}&dateTo=${LESSON_DATE}`,
+      )
+      .set(auth(adminToken))
+      .expect(200);
+    expect(adminRecords.body.list).toHaveLength(2);
+    expect(
+      adminRecords.body.list
+        .map((record: AttendanceRecord) => ({
+          studentId: record.studentId,
+          status: record.status,
+          source: record.source,
+        }))
+        .sort(
+          (left: Pick<AttendanceRecord, 'studentId'>, right: Pick<AttendanceRecord, 'studentId'>) =>
+            left.studentId - right.studentId,
+        ),
+    ).toEqual(teacherView);
+
+    const unassignedClass = await request(app.getHttpServer())
+      .post('/api/classes')
+      .set(auth(adminToken))
+      .send({
+        name: '未分配教师班级',
+        code: 'UNASSIGNED-INTEGRATION',
+        classType: 'culture',
+        status: 'active',
+      })
+      .expect(201);
+    await request(app.getHttpServer())
+      .get(`/api/attendance-records?classId=${unassignedClass.body.id}`)
+      .set(auth(teacherToken))
+      .expect(400);
+
+    const persisted = await attendanceRepo.find({
+      where: { classId },
+      order: { studentId: 'ASC' },
+    });
+    expect(persisted).toHaveLength(2);
+    expect(persisted).toEqual([
+      expect.objectContaining({ studentId: studentA.id, status: 'absent', source: 'manual' }),
+      expect.objectContaining({ studentId: studentB.id, status: 'present', source: 'dingtalk' }),
+    ]);
+  });
+});