"src/git@gitlab.ruzhoukj.com:wujipeng/integration.git" did not exist on "42f628f311eddbd1ebfd93ec0913d5febdf10440"
Commit b833e12b authored by wujipeng's avatar wujipeng
Browse files

我的课程-接口拆分

parent 03bbec8e
-- 学员端“学习中心-我的课程”查询索引增量脚本(MySQL 5.7+/8.0)。
--
-- 本脚本不新增业务表或字段,只为“学员 -> 班级 -> 日期范围课程 -> 本人出勤”查询链路
-- 补齐前导索引。所有检查都比较索引列而不是固定索引名,因此可重复执行,也不会与
-- 其他模块中名称不同但等价的索引重复。
delimiter $$
drop procedure if exists migrate_student_course$$
create procedure migrate_student_course()
begin
if not exists (
select 1 from information_schema.tables
where table_schema = database() and table_name = 'class_student'
) or not exists (
select 1 from information_schema.tables
where table_schema = database() and table_name = 'class_subject'
) or not exists (
select 1 from information_schema.tables
where table_schema = database() and table_name = 'class_subject_attendance'
) then
signal sqlstate '45000'
set message_text = '缺少班级、课程或出勤基础表,请先执行项目基础数据库脚本';
end if;
-- 登录后首先按user_id反查学员所属班级,class_id同时可直接用于后续课程查询。
if not exists (
select 1
from (
select index_name,
group_concat(column_name order by seq_in_index separator ',') as indexed_columns
from information_schema.statistics
where table_schema = database() and table_name = 'class_student'
group by index_name
) member_indexes
where member_indexes.indexed_columns = 'user_id,class_id'
or member_indexes.indexed_columns like 'user_id,class_id,%'
) then
alter table class_student
add index idx_class_student_user_class (user_id, class_id);
end if;
-- 月历按班级集合和日期范围查询;已有相同前导列的课程管理索引可直接复用。
if not exists (
select 1
from (
select index_name,
group_concat(column_name order by seq_in_index separator ',') as indexed_columns
from information_schema.statistics
where table_schema = database() and table_name = 'class_subject'
group by index_name
) subject_indexes
where subject_indexes.indexed_columns = 'class_id,date'
or subject_indexes.indexed_columns like 'class_id,date,%'
) then
alter table class_subject
add index idx_subject_class_date (class_id, date, id);
end if;
-- 学员课程页面按user_id读取指定日期范围内的出勤;教师端唯一索引以subject_id
-- 为前导列,不能覆盖该访问方向,因此单独补充反向查询索引。
if not exists (
select 1
from (
select index_name,
group_concat(column_name order by seq_in_index separator ',') as indexed_columns
from information_schema.statistics
where table_schema = database() and table_name = 'class_subject_attendance'
group by index_name
) attendance_indexes
where attendance_indexes.indexed_columns = 'user_id,subject_id'
or attendance_indexes.indexed_columns like 'user_id,subject_id,%'
) then
alter table class_subject_attendance
add index idx_attendance_user_subject (user_id, subject_id);
end if;
end$$
call migrate_student_course()$$
drop procedure if exists migrate_student_course$$
delimiter ;
-- 执行后可使用以下只读查询核对最终索引,不会修改任何业务数据。
select table_name, index_name, non_unique, seq_in_index, column_name
from information_schema.statistics
where table_schema = database()
and table_name in ('class_student', 'class_subject', 'class_subject_attendance')
order by table_name, index_name, seq_in_index;
...@@ -19,12 +19,20 @@ begin ...@@ -19,12 +19,20 @@ begin
set message_text = '缺少出勤表,请先执行项目基础出勤模块数据库脚本'; set message_text = '缺少出勤表,请先执行项目基础出勤模块数据库脚本';
end if; end if;
-- 教师日历固定按教师和日期范围查询,课程ID用于稳定排序和回表。 -- 教师日历固定按教师和日期范围查询。按前导列而非索引名判断,避免与
-- home_dashboard.sql或course_management.sql中名称不同但等价的索引重复。
if not exists ( if not exists (
select 1 from information_schema.statistics select 1
where table_schema = database() from (
and table_name = 'class_subject' select index_name,
and index_name = 'idx_subject_teacher_date' group_concat(column_name order by seq_in_index separator ',') as indexed_columns
from information_schema.statistics
where table_schema = database()
and table_name = 'class_subject'
group by index_name
) subject_indexes
where subject_indexes.indexed_columns = 'teacher_id,date'
or subject_indexes.indexed_columns like 'teacher_id,date,%'
) then ) then
alter table class_subject alter table class_subject
add index idx_subject_teacher_date (teacher_id, date, id); add index idx_subject_teacher_date (teacher_id, date, id);
......
package com.platform.business.controller;
import org.junit.jupiter.api.Test;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** 防止后续维护再次把学员、教师“我的课程”接口混回班级管理Controller。 */
class CourseControllerSeparationTest {
@Test
void roleCourseControllersShouldOwnTheirLegacyRoutesIndependently() {
assertEquals("/class", root(StudentCourseController.class));
assertEquals("/class", root(TeacherCourseController.class));
Set<String> studentRoutes = routes(StudentCourseController.class);
assertTrue(studentRoutes.contains("POST /schedule"));
assertTrue(studentRoutes.contains("POST /schedule/detail"));
assertTrue(studentRoutes.contains("GET /today/course/{userId}"));
assertTrue(studentRoutes.contains("POST /student/course/summary"));
assertTrue(studentRoutes.contains("POST /today/course/signIn"));
Set<String> teacherRoutes = routes(TeacherCourseController.class);
assertTrue(teacherRoutes.contains("POST /schedule/teacher"));
assertTrue(teacherRoutes.contains("POST /schedule/teacher/detail"));
assertTrue(teacherRoutes.contains("GET /today/course/teacher"));
assertTrue(teacherRoutes.contains("POST /teacher/course/summary"));
Set<String> classRoutes = routes(ClassController.class);
assertFalse(classRoutes.stream().anyMatch(route -> route.contains("schedule")));
assertFalse(classRoutes.stream().anyMatch(route -> route.contains("course")));
}
private static String root(Class<?> controller) {
return controller.getAnnotation(RequestMapping.class).value()[0];
}
private static Set<String> routes(Class<?> controller) {
Set<String> result = new HashSet<>();
for (Method method : controller.getDeclaredMethods()) {
PostMapping post = method.getAnnotation(PostMapping.class);
if (post != null) {
for (String path : post.value()) result.add("POST " + path);
}
GetMapping get = method.getAnnotation(GetMapping.class);
if (get != null) {
for (String path : get.value()) result.add("GET " + path);
}
}
return result;
}
}
package com.platform.business.controller;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.entity.UserEntity;
import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.StudentCourseService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 学员“我的课程”控制器的角色校验和可信身份传递测试。 */
@ExtendWith(MockitoExtension.class)
class StudentCourseControllerTest {
@Mock
private StudentCourseService studentCourseService;
@Mock
private AuthenticatedUserService authenticatedUserService;
private StudentCourseController controller;
private MockHttpServletRequest request;
private UserEntity student;
@BeforeEach
void setUp() {
controller = new StudentCourseController();
ReflectionTestUtils.setField(controller, "studentCourseService", studentCourseService);
ReflectionTestUtils.setField(controller, "authenticatedUserService", authenticatedUserService);
request = new MockHttpServletRequest();
student = new UserEntity();
student.setId("student-from-jwt");
when(authenticatedUserService.current(request)).thenReturn(student);
}
@Test
void todayShouldIgnoreForgedPathUserIdAndUseJwtStudent() {
when(studentCourseService.today("student-from-jwt")).thenReturn(Collections.emptyList());
controller.today("forged-student", request);
verify(authenticatedUserService).requireStudent(student);
verify(studentCourseService).today("student-from-jwt");
verify(studentCourseService, never()).today("forged-student");
}
@Test
void scheduleShouldStopBeforeServiceWhenUserIsNotStudent() {
doThrow(new BusinessException("只有学员可以访问学员端接口"))
.when(authenticatedUserService).requireStudent(student);
assertThrows(BusinessException.class,
() -> controller.schedule(new CourseRangeQueryDTO(), request));
verify(studentCourseService, never()).schedule(
org.mockito.ArgumentMatchers.any(), org.mockito.ArgumentMatchers.anyString());
}
@Test
void todayShouldRequireValidLoginBeforeCallingService() {
when(authenticatedUserService.current(request))
.thenThrow(new BusinessException("登录凭证无效或已过期"));
assertThrows(BusinessException.class, () -> controller.today("any", request));
verify(studentCourseService, never()).today(org.mockito.ArgumentMatchers.anyString());
}
}
package com.platform.business.controller; package com.platform.business.controller;
import com.platform.business.model.dto.ClassDTO; import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.entity.UserEntity; import com.platform.business.model.entity.UserEntity;
import com.platform.business.service.AuthenticatedUserService; import com.platform.business.service.AuthenticatedUserService;
import com.platform.business.service.ClassService; import com.platform.business.service.TeacherCourseService;
import com.platform.exception.BusinessException; import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
...@@ -25,18 +25,18 @@ import static org.mockito.Mockito.when; ...@@ -25,18 +25,18 @@ import static org.mockito.Mockito.when;
class TeacherCourseControllerTest { class TeacherCourseControllerTest {
@Mock @Mock
private ClassService classService; private TeacherCourseService teacherCourseService;
@Mock @Mock
private AuthenticatedUserService authenticatedUserService; private AuthenticatedUserService authenticatedUserService;
private ClassController controller; private TeacherCourseController controller;
private MockHttpServletRequest request; private MockHttpServletRequest request;
private UserEntity teacher; private UserEntity teacher;
@BeforeEach @BeforeEach
void setUp() { void setUp() {
controller = new ClassController(); controller = new TeacherCourseController();
ReflectionTestUtils.setField(controller, "classService", classService); ReflectionTestUtils.setField(controller, "teacherCourseService", teacherCourseService);
ReflectionTestUtils.setField(controller, "authenticatedUserService", authenticatedUserService); ReflectionTestUtils.setField(controller, "authenticatedUserService", authenticatedUserService);
request = new MockHttpServletRequest(); request = new MockHttpServletRequest();
teacher = new UserEntity(); teacher = new UserEntity();
...@@ -46,15 +46,14 @@ class TeacherCourseControllerTest { ...@@ -46,15 +46,14 @@ class TeacherCourseControllerTest {
@Test @Test
void scheduleShouldUseJwtTeacherInsteadOfForgedBodyUserId() { void scheduleShouldUseJwtTeacherInsteadOfForgedBodyUserId() {
ClassDTO query = new ClassDTO(); CourseRangeQueryDTO query = new CourseRangeQueryDTO();
query.setUserId("forged-teacher"); when(teacherCourseService.schedule(query, "teacher-from-jwt"))
when(classService.scheduleTeacher(query, "teacher-from-jwt"))
.thenReturn(Collections.emptyList()); .thenReturn(Collections.emptyList());
controller.scheduleTeacher(query, request); controller.schedule(query, request);
verify(authenticatedUserService).requireTeacher(teacher); verify(authenticatedUserService).requireTeacher(teacher);
verify(classService).scheduleTeacher(query, "teacher-from-jwt"); verify(teacherCourseService).schedule(query, "teacher-from-jwt");
} }
@Test @Test
...@@ -63,7 +62,7 @@ class TeacherCourseControllerTest { ...@@ -63,7 +62,7 @@ class TeacherCourseControllerTest {
.when(authenticatedUserService).requireTeacher(teacher); .when(authenticatedUserService).requireTeacher(teacher);
assertThrows(BusinessException.class, assertThrows(BusinessException.class,
() -> controller.teacherCourseSummary(new ClassDTO(), request)); () -> controller.summary(new CourseRangeQueryDTO(), request));
} }
@Test @Test
...@@ -71,6 +70,6 @@ class TeacherCourseControllerTest { ...@@ -71,6 +70,6 @@ class TeacherCourseControllerTest {
when(authenticatedUserService.current(request)) when(authenticatedUserService.current(request))
.thenThrow(new BusinessException("登录凭证无效或已过期")); .thenThrow(new BusinessException("登录凭证无效或已过期"));
assertThrows(BusinessException.class, () -> controller.todayTeacherCourse(request)); assertThrows(BusinessException.class, () -> controller.today(request));
} }
} }
...@@ -8,6 +8,10 @@ import org.apache.ibatis.session.Configuration; ...@@ -8,6 +8,10 @@ import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import java.io.InputStream; import java.io.InputStream;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
...@@ -41,6 +45,43 @@ class TeacherCourseMapperXmlTest { ...@@ -41,6 +45,43 @@ class TeacherCourseMapperXmlTest {
assertTrue(upsertSql.contains("else values(status) end")); assertTrue(upsertSql.contains("else values(status) end"));
} }
@Test
void studentQueriesShouldContainTrustedDateAndRangeFilters() throws Exception {
Configuration configuration = new Configuration();
parse(configuration, "com/platform/business/mapper/ClassSubjectMapper.xml");
parse(configuration, "com/platform/business/mapper/ClassSubjectAttendanceMapper.xml");
Map<String, Object> todayParameters = new HashMap<>();
todayParameters.put("classIds", Collections.singletonList(10));
todayParameters.put("date", new Date());
String todaySql = compact(configuration.getMappedStatement(
"com.platform.business.mapper.ClassSubjectMapper.todayCourse")
.getBoundSql(todayParameters).getSql());
assertTrue(todaySql.contains("cs.date = ?"));
assertTrue(todaySql.contains("order by cs.time_frame asc, cs.id asc"));
ClassSubjectDTO detailQuery = new ClassSubjectDTO();
detailQuery.setDate("2026-08-19");
detailQuery.setClassIds(Collections.singletonList(10));
String detailSql = compact(configuration.getMappedStatement(
"com.platform.business.mapper.ClassSubjectMapper.queryListByUserIdAndDate")
.getBoundSql(detailQuery).getSql());
assertTrue(detailSql.contains("cs.id"));
assertTrue(detailSql.contains("cs.date"));
assertTrue(detailSql.contains("u.nick_name as teacherName"));
assertTrue(detailSql.contains("cs.class_id in"));
Map<String, Object> attendanceParameters = new HashMap<>();
attendanceParameters.put("studentId", "student-1");
attendanceParameters.put("startDate", new Date());
attendanceParameters.put("endDate", new Date());
String attendanceSql = compact(configuration.getMappedStatement(
"com.platform.business.mapper.ClassSubjectAttendanceMapper.queryByStudentAndRange")
.getBoundSql(attendanceParameters).getSql());
assertTrue(attendanceSql.contains("a.user_id = ?"));
assertTrue(attendanceSql.contains("s.date between ? and ?"));
}
private static void parse(Configuration configuration, String resource) throws Exception { private static void parse(Configuration configuration, String resource) throws Exception {
try (InputStream input = Resources.getResourceAsStream(resource)) { try (InputStream input = Resources.getResourceAsStream(resource)) {
XMLMapperBuilder builder = new XMLMapperBuilder( XMLMapperBuilder builder = new XMLMapperBuilder(
......
package com.platform.business.service.impl;
import com.platform.business.constant.AttendanceConstants;
import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.entity.ClassSubjectAttendanceEntity;
import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO;
import com.platform.business.service.ClassStudentService;
import com.platform.business.service.ClassSubjectAttendanceService;
import com.platform.business.service.ClassSubjectService;
import com.platform.business.service.ExamStudentService;
import com.platform.exception.BusinessException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyList;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/** 学员课程范围、空班级保护、英文状态和汇总口径测试。 */
@ExtendWith(MockitoExtension.class)
class StudentCourseServiceImplTest {
@Mock
private ClassStudentService classStudentService;
@Mock
private ClassSubjectService classSubjectService;
@Mock
private ClassSubjectAttendanceService attendanceService;
@Mock
private ExamStudentService examStudentService;
private StudentCourseServiceImpl service;
@BeforeEach
void setUp() {
service = new StudentCourseServiceImpl();
ReflectionTestUtils.setField(service, "classStudentService", classStudentService);
ReflectionTestUtils.setField(service, "classSubjectService", classSubjectService);
ReflectionTestUtils.setField(service, "classSubjectAttendanceService", attendanceService);
ReflectionTestUtils.setField(service, "examStudentService", examStudentService);
}
@Test
void noClassShouldReturnNaturalMonthWithoutGeneratingCourseInClause() {
when(classStudentService.queryClassIdByUserId("student-1")).thenReturn(Collections.emptyList());
when(examStudentService.queryOneself("student-1")).thenReturn(Collections.emptyList());
List<ClassVO> result = service.schedule(new CourseRangeQueryDTO(), "student-1");
Calendar calendar = Calendar.getInstance();
assertEquals(calendar.getActualMaximum(Calendar.DAY_OF_MONTH), result.size());
verify(classSubjectService, never()).queryOneself(anyList(), any(), any());
verify(attendanceService, never()).queryByStudentAndRange(any(), any(), any());
}
@Test
void detailShouldRejectInvalidDateBeforeQueryingMembership() {
CourseDateQueryDTO query = new CourseDateQueryDTO();
query.setDate("2026-02-30");
assertThrows(BusinessException.class, () -> service.detail(query, "student-1"));
verify(classStudentService, never()).queryClassIdByUserId(any());
}
@Test
void scheduleShouldUseEnglishAttendanceAndUpcomingStatuses() {
Date today = startOfDay(new Date());
Date tomorrow = addDays(today, 1);
ClassSubjectVO attended = course(1, today, "00:00-23:59");
ClassSubjectVO upcoming = course(2, tomorrow, "08:00-09:00");
ClassSubjectAttendanceEntity record = new ClassSubjectAttendanceEntity();
record.setSubjectId(1);
record.setStatus(AttendanceConstants.STATUS_NORMAL);
when(classStudentService.queryClassIdByUserId("student-1"))
.thenReturn(Collections.singletonList(10));
when(classSubjectService.queryOneself(anyList(), any(), any()))
.thenReturn(Arrays.asList(attended, upcoming));
when(attendanceService.queryByStudentAndRange(eq("student-1"), any(), any()))
.thenReturn(Collections.singletonList(record));
when(examStudentService.queryOneself("student-1")).thenReturn(Collections.emptyList());
List<ClassVO> days = service.schedule(range(today, tomorrow), "student-1");
assertEquals("NORMAL", days.get(0).getClassSubjectList().get(0).getStatus());
assertEquals("UPCOMING", days.get(1).getClassSubjectList().get(0).getStatus());
}
@Test
void summaryShouldCountUpcomingCourseAsPendingAndUseBoundedAttendanceQuery() {
Date today = startOfDay(new Date());
Date tomorrow = addDays(today, 1);
ClassSubjectVO attended = course(1, today, "00:00-23:59");
ClassSubjectVO upcoming = course(2, tomorrow, "08:00-09:00");
ClassSubjectAttendanceEntity record = new ClassSubjectAttendanceEntity();
record.setSubjectId(1);
record.setStatus(AttendanceConstants.STATUS_LATE);
when(classStudentService.queryClassIdByUserId("student-1"))
.thenReturn(Collections.singletonList(10));
when(classSubjectService.queryOneself(anyList(), any(), any()))
.thenReturn(Arrays.asList(attended, upcoming));
when(attendanceService.queryByStudentAndRange(eq("student-1"), any(), any()))
.thenReturn(Collections.singletonList(record));
Map<String, Integer> result = service.summary(range(today, tomorrow), "student-1");
assertEquals(2, result.get("本月课程"));
assertEquals(1, result.get("迟到"));
assertEquals(1, result.get("待签到"));
assertEquals(100, result.get("出勤率"));
verify(attendanceService).queryByStudentAndRange(eq("student-1"), any(), any());
}
private static ClassSubjectVO course(int id, Date date, String timeFrame) {
ClassSubjectVO result = new ClassSubjectVO();
result.setId(id);
result.setDate(date);
result.setTimeFrame(timeFrame);
return result;
}
private static CourseRangeQueryDTO range(Date start, Date end) {
CourseRangeQueryDTO result = new CourseRangeQueryDTO();
result.setStartDate(start);
result.setEndDate(end);
return result;
}
private static Date startOfDay(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.set(Calendar.HOUR_OF_DAY, 0);
calendar.set(Calendar.MINUTE, 0);
calendar.set(Calendar.SECOND, 0);
calendar.set(Calendar.MILLISECOND, 0);
return calendar.getTime();
}
private static Date addDays(Date date, int days) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
calendar.add(Calendar.DAY_OF_MONTH, days);
return calendar.getTime();
}
}
package com.platform.business.service.impl; package com.platform.business.service.impl;
import com.platform.business.model.dto.ClassDTO; import com.platform.business.model.dto.CourseDateQueryDTO;
import com.platform.business.model.dto.ClassSubjectDTO; import com.platform.business.model.dto.CourseRangeQueryDTO;
import com.platform.business.model.vo.ClassSubjectVO; import com.platform.business.model.vo.ClassSubjectVO;
import com.platform.business.model.vo.ClassVO; import com.platform.business.model.vo.ClassVO;
import com.platform.business.service.AttendanceService; import com.platform.business.service.AttendanceService;
...@@ -39,11 +39,11 @@ class TeacherCourseServiceImplTest { ...@@ -39,11 +39,11 @@ class TeacherCourseServiceImplTest {
@Mock @Mock
private AttendanceService attendanceService; private AttendanceService attendanceService;
private ClassServiceImpl service; private TeacherCourseServiceImpl service;
@BeforeEach @BeforeEach
void setUp() { void setUp() {
service = new ClassServiceImpl(); service = new TeacherCourseServiceImpl();
ReflectionTestUtils.setField(service, "classSubjectService", classSubjectService); ReflectionTestUtils.setField(service, "classSubjectService", classSubjectService);
ReflectionTestUtils.setField(service, "attendanceService", attendanceService); ReflectionTestUtils.setField(service, "attendanceService", attendanceService);
} }
...@@ -53,7 +53,7 @@ class TeacherCourseServiceImplTest { ...@@ -53,7 +53,7 @@ class TeacherCourseServiceImplTest {
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(Date.class), any(Date.class))) when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(Date.class), any(Date.class)))
.thenReturn(Collections.emptyList()); .thenReturn(Collections.emptyList());
List<ClassVO> result = service.scheduleTeacher(new ClassDTO(), "teacher-1"); List<ClassVO> result = service.schedule(new CourseRangeQueryDTO(), "teacher-1");
ArgumentCaptor<Date> start = ArgumentCaptor.forClass(Date.class); ArgumentCaptor<Date> start = ArgumentCaptor.forClass(Date.class);
ArgumentCaptor<Date> end = ArgumentCaptor.forClass(Date.class); ArgumentCaptor<Date> end = ArgumentCaptor.forClass(Date.class);
...@@ -72,13 +72,13 @@ class TeacherCourseServiceImplTest { ...@@ -72,13 +72,13 @@ class TeacherCourseServiceImplTest {
void scheduleShouldDistinguishPendingAndUpcomingCourses() { void scheduleShouldDistinguishPendingAndUpcomingCourses() {
Date today = startOfDay(new Date()); Date today = startOfDay(new Date());
Date tomorrow = addDays(today, 1); Date tomorrow = addDays(today, 1);
ClassDTO query = range(today, tomorrow); CourseRangeQueryDTO query = range(today, tomorrow);
ClassSubjectVO pending = course(today, "00:00-23:59", 2, 1, 1, 0); ClassSubjectVO pending = course(today, "00:00-23:59", 2, 1, 1, 0);
ClassSubjectVO upcoming = course(tomorrow, "08:00-09:00", 2, 0, 0, 0); ClassSubjectVO upcoming = course(tomorrow, "08:00-09:00", 2, 0, 0, 0);
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any())) when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any()))
.thenReturn(Arrays.asList(pending, upcoming)); .thenReturn(Arrays.asList(pending, upcoming));
List<ClassVO> days = service.scheduleTeacher(query, "teacher-1"); List<ClassVO> days = service.schedule(query, "teacher-1");
assertEquals("PENDING", days.get(0).getClassSubjectList().get(0).getStatus()); assertEquals("PENDING", days.get(0).getClassSubjectList().get(0).getStatus());
assertEquals("UPCOMING", days.get(1).getClassSubjectList().get(0).getStatus()); assertEquals("UPCOMING", days.get(1).getClassSubjectList().get(0).getStatus());
...@@ -94,7 +94,7 @@ class TeacherCourseServiceImplTest { ...@@ -94,7 +94,7 @@ class TeacherCourseServiceImplTest {
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any())) when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any()))
.thenReturn(Arrays.asList(completed, upcoming)); .thenReturn(Arrays.asList(completed, upcoming));
Map<String, Integer> summary = service.teacherCourseSummary( Map<String, Integer> summary = service.summary(
range(today, tomorrow), "teacher-1"); range(today, tomorrow), "teacher-1");
assertEquals(2, summary.get("本月课程")); assertEquals(2, summary.get("本月课程"));
...@@ -109,28 +109,28 @@ class TeacherCourseServiceImplTest { ...@@ -109,28 +109,28 @@ class TeacherCourseServiceImplTest {
when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any())) when(classSubjectService.queryTeacherCourse(eq("teacher-1"), any(), any()))
.thenReturn(Collections.emptyList()); .thenReturn(Collections.emptyList());
Map<String, Integer> summary = service.teacherCourseSummary(new ClassDTO(), "teacher-1"); Map<String, Integer> summary = service.summary(new CourseRangeQueryDTO(), "teacher-1");
assertEquals(0, summary.get("平均出勤率")); assertEquals(0, summary.get("平均出勤率"));
} }
@Test @Test
void detailShouldRejectInvalidCalendarDateBeforeQueryingMapper() { void detailShouldRejectInvalidCalendarDateBeforeQueryingMapper() {
ClassSubjectDTO query = new ClassSubjectDTO(); CourseDateQueryDTO query = new CourseDateQueryDTO();
query.setDate("2026-02-30"); query.setDate("2026-02-30");
assertThrows(BusinessException.class, assertThrows(BusinessException.class,
() -> service.scheduleTeacherDetail(query, "teacher-1")); () -> service.detail(query, "teacher-1"));
verify(classSubjectService, never()).queryListByUserIdAndDateTeacher(any()); verify(classSubjectService, never()).queryListByUserIdAndDateTeacher(any());
} }
@Test @Test
void rangeLongerThanSixtyTwoDaysShouldBeRejected() { void rangeLongerThanSixtyTwoDaysShouldBeRejected() {
Date start = startOfDay(new Date()); Date start = startOfDay(new Date());
ClassDTO query = range(start, addDays(start, 63)); CourseRangeQueryDTO query = range(start, addDays(start, 63));
assertThrows(BusinessException.class, assertThrows(BusinessException.class,
() -> service.scheduleTeacher(query, "teacher-1")); () -> service.schedule(query, "teacher-1"));
} }
private static ClassSubjectVO course(Date date, String timeFrame, int students, private static ClassSubjectVO course(Date date, String timeFrame, int students,
...@@ -148,8 +148,8 @@ class TeacherCourseServiceImplTest { ...@@ -148,8 +148,8 @@ class TeacherCourseServiceImplTest {
return course; return course;
} }
private static ClassDTO range(Date start, Date end) { private static CourseRangeQueryDTO range(Date start, Date end) {
ClassDTO query = new ClassDTO(); CourseRangeQueryDTO query = new CourseRangeQueryDTO();
query.setStartDate(start); query.setStartDate(start);
query.setEndDate(end); query.setEndDate(end);
return query; return query;
......
package com.platform.business.sql;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import static org.junit.jupiter.api.Assertions.assertTrue;
/** 验证学员课程索引脚本和教师等价索引检测会随应用制品一起发布。 */
class CourseMigrationSqlTest {
@Test
void studentMigrationShouldContainIdempotentLeadingColumnChecks() throws Exception {
String sql = resource("sql/student_course.sql").toLowerCase();
assertTrue(sql.contains("indexed_columns = 'user_id,class_id'"));
assertTrue(sql.contains("idx_class_student_user_class"));
assertTrue(sql.contains("indexed_columns = 'class_id,date'"));
assertTrue(sql.contains("idx_subject_class_date"));
assertTrue(sql.contains("indexed_columns = 'user_id,subject_id'"));
assertTrue(sql.contains("idx_attendance_user_subject"));
}
@Test
void teacherMigrationShouldDetectEquivalentIndexByColumnsInsteadOfNameOnly() throws Exception {
String sql = resource("sql/teacher_course.sql").toLowerCase();
assertTrue(sql.contains("indexed_columns = 'teacher_id,date'"));
assertTrue(sql.contains("indexed_columns like 'teacher_id,date,%'"));
assertTrue(sql.contains("idx_subject_teacher_date"));
}
private static String resource(String path) throws Exception {
try (InputStream input = Thread.currentThread().getContextClassLoader().getResourceAsStream(path)) {
assertTrue(input != null, "迁移SQL资源必须存在:" + path);
ByteArrayOutputStream output = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
int length;
while ((length = input.read(buffer)) >= 0) {
output.write(buffer, 0, length);
}
return new String(output.toByteArray(), StandardCharsets.UTF_8);
}
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment