You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1047 lines
56 KiB
Java
1047 lines
56 KiB
Java
package com.sztzjy.linkCommerce.controller.stu;
|
|
|
|
import com.sztzjy.linkCommerce.entity.School;
|
|
import com.sztzjy.linkCommerce.entity.SchoolClass;
|
|
import com.sztzjy.linkCommerce.entity.SchoolClassExample;
|
|
import com.sztzjy.linkCommerce.entity.SchoolFaculty;
|
|
import com.sztzjy.linkCommerce.entity.SchoolMajor;
|
|
import com.sztzjy.linkCommerce.entity.TeachingClassStudent;
|
|
import com.sztzjy.linkCommerce.entity.Userinfo;
|
|
import com.sztzjy.linkCommerce.mapper.SchoolClassMapper;
|
|
import com.sztzjy.linkCommerce.mapper.SchoolFacultyMapper;
|
|
import com.sztzjy.linkCommerce.mapper.SchoolMapper;
|
|
import com.sztzjy.linkCommerce.mapper.SchoolMajorMapper;
|
|
import com.sztzjy.linkCommerce.mapper.TeachingClassStudentMapper;
|
|
import com.sztzjy.linkCommerce.mapper.UserinfoMapper;
|
|
import com.sztzjy.linkCommerce.service.UserInfoService;
|
|
import com.sztzjy.linkCommerce.entity.importDto.SchoolAdminStudentImportDTO;
|
|
import com.sztzjy.linkCommerce.entity.importDto.TeachingClassStudentImportDTO;
|
|
import com.sztzjy.linkCommerce.util.Pinyin4jUtil;
|
|
import com.sztzjy.linkCommerce.util.ResultEntity;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.mockito.ArgumentCaptor;
|
|
import org.springframework.http.HttpStatus;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
import static org.mockito.ArgumentMatchers.any;
|
|
import static org.mockito.ArgumentMatchers.argThat;
|
|
import static org.mockito.Mockito.mock;
|
|
import static org.mockito.Mockito.never;
|
|
import static org.mockito.Mockito.times;
|
|
import static org.mockito.Mockito.verify;
|
|
import static org.mockito.Mockito.when;
|
|
|
|
class UserControllerTeacherAdminTest {
|
|
|
|
@Test
|
|
void addTeacherAccountAlwaysCreatesOrdinaryTeacher() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
|
|
when(controller.userInfoService.existsByUserName("t001")).thenReturn(false);
|
|
when(controller.userinfoMapper.insert(any(Userinfo.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.addTeacherAccount("school-1", "school", "faculty-1", "major-1",
|
|
"major", "张老师", "t001", null, null, "teacher-admin");
|
|
|
|
ArgumentCaptor<Userinfo> captor = ArgumentCaptor.forClass(Userinfo.class);
|
|
verify(controller.userinfoMapper).insert(captor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals(3, captor.getValue().getRole());
|
|
assertFalse(captor.getValue().getTeacherAdmin());
|
|
}
|
|
|
|
@Test
|
|
void ordinaryTeacherCannotAddFaculty() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));
|
|
|
|
ResultEntity result = controller.addSchoolFaculty("school-1", "faculty", null, null, null, "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolFacultyMapper, never()).insert(any(SchoolFaculty.class));
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCanAddFaculty() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
|
|
when(controller.schoolFacultyMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolFacultyMapper.insert(any(SchoolFaculty.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.addSchoolFaculty("school-1", "faculty", null, null, null, "teacher-admin");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolFacultyMapper).insert(any(SchoolFaculty.class));
|
|
}
|
|
|
|
@Test
|
|
void ordinaryTeacherCannotAddMajor() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));
|
|
|
|
ResultEntity result = controller.addSchoolMajor("school-1", "faculty-1", "major", null, null, "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolMajorMapper, never()).insert(any(SchoolMajor.class));
|
|
}
|
|
|
|
@Test
|
|
void ordinaryTeacherCannotUpdateTeacherAccount() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo update = teacher("teacher-2", false);
|
|
update.setName("updated");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));
|
|
|
|
ResultEntity result = controller.updateTeacher(update, "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.userinfoMapper, never()).updateByPrimaryKey(any(Userinfo.class));
|
|
}
|
|
|
|
@Test
|
|
void addSchoolClassStoresCreatorTeacher() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "class-1",
|
|
"teacher-1", null, null);
|
|
|
|
ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
|
|
verify(controller.schoolClassMapper).insert(captor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("teacher-1", captor.getValue().getCreatedBy());
|
|
assertEquals("TEACHING", captor.getValue().getClassType());
|
|
assertEquals("LOCAL", captor.getValue().getDataSource());
|
|
}
|
|
|
|
@Test
|
|
void ordinaryTeacherCanAddAdminClassWithinOwnSchool() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", false));
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "admin-class",
|
|
"teacher-1", "ADMIN", null);
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).insert(argThat(schoolClass -> "ADMIN".equals(schoolClass.getClassType())));
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCanAddAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "admin-class",
|
|
"teacher-admin", "ADMIN", null);
|
|
|
|
ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
|
|
verify(controller.schoolClassMapper).insert(captor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("teacher-admin", captor.getValue().getCreatedBy());
|
|
assertEquals("ADMIN", captor.getValue().getClassType());
|
|
}
|
|
|
|
@Test
|
|
void addSchoolClassRejectsDuplicateNameInSameSchool() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.schoolClassMapper.selectByExample(argThat(example -> hasCondition(example, "school_id ="))))
|
|
.thenReturn(Collections.singletonList(new SchoolClass()));
|
|
|
|
ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "class-1",
|
|
"teacher-1", null, null);
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolClassMapper, never()).insert(any(SchoolClass.class));
|
|
}
|
|
|
|
@Test
|
|
void addTeachingClassFromAdminClassesCreatesMembershipRows() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo studentOne = new Userinfo();
|
|
studentOne.setUserId("student-1");
|
|
studentOne.setRole(4);
|
|
studentOne.setSchoolClassId("admin-1");
|
|
Userinfo studentTwo = new Userinfo();
|
|
studentTwo.setUserId("student-2");
|
|
studentTwo.setRole(4);
|
|
studentTwo.setSchoolClassId("admin-2");
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Arrays.asList(studentOne, studentTwo));
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "teaching-class",
|
|
"teacher-1", "TEACHING", "admin-1,admin-2");
|
|
|
|
ArgumentCaptor<SchoolClass> classCaptor = ArgumentCaptor.forClass(SchoolClass.class);
|
|
ArgumentCaptor<TeachingClassStudent> memberCaptor = ArgumentCaptor.forClass(TeachingClassStudent.class);
|
|
verify(controller.schoolClassMapper).insert(classCaptor.capture());
|
|
verify(controller.teachingClassStudentMapper, times(2)).insertSelective(memberCaptor.capture());
|
|
List<TeachingClassStudent> members = memberCaptor.getAllValues();
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals(classCaptor.getValue().getSchoolClassId(), members.get(0).getTeachingClassId());
|
|
assertEquals("student-1", members.get(0).getStudentUserId());
|
|
assertEquals("admin-1", members.get(0).getAdminClassId());
|
|
assertEquals("IN_PROGRESS", members.get(0).getStatus());
|
|
assertEquals("student-2", members.get(1).getStudentUserId());
|
|
assertEquals("admin-2", members.get(1).getAdminClassId());
|
|
}
|
|
|
|
@Test
|
|
void addTeachingClassFromAdminClassesRequiresConfirmationWhenStudentAlreadyInOtherTeachingClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", ""))
|
|
.thenReturn(1L);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "teaching-class",
|
|
"teacher-1", "TEACHING", "admin-1");
|
|
|
|
assertEquals(HttpStatus.CONFLICT, result.getStatusCode());
|
|
verify(controller.schoolClassMapper, never()).insert(any(SchoolClass.class));
|
|
verify(controller.teachingClassStudentMapper, never()).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void addTeachingClassFromAdminClassesCanContinueAfterMultiClassConfirmation() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", ""))
|
|
.thenReturn(1L);
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.addSchoolClass("school-1", "faculty-1", "major-1", "teaching-class",
|
|
"teacher-1", "TEACHING", "admin-1", true);
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).insert(any(SchoolClass.class));
|
|
verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void deleteFacultyRejectsWhenMajorExists() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
SchoolFaculty faculty = new SchoolFaculty();
|
|
faculty.setSchoolFacultyId("faculty-1");
|
|
faculty.setSchoolId("school-1");
|
|
when(controller.schoolFacultyMapper.selectByPrimaryKey("faculty-1")).thenReturn(faculty);
|
|
when(controller.schoolMajorMapper.selectByExample(any())).thenReturn(Collections.singletonList(new SchoolMajor()));
|
|
|
|
ResultEntity result = controller.deleteSchoolFaculty("faculty-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolFacultyMapper, never()).deleteByPrimaryKey("faculty-1");
|
|
}
|
|
|
|
@Test
|
|
void deleteMajorRejectsWhenClassExists() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.singletonList(new SchoolClass()));
|
|
|
|
ResultEntity result = controller.deleteSchoolMajor("major-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolMajorMapper, never()).deleteByPrimaryKey("major-1");
|
|
}
|
|
|
|
@Test
|
|
void deleteClassRejectsWhenStudentsExist() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass adminClass = classCreatedBy("teacher-1");
|
|
adminClass.setClassType("ADMIN");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(adminClass);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(new Userinfo()));
|
|
|
|
ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherCannotDeleteClassCreatedByAnotherTeacher() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacher = teacher("teacher-1");
|
|
SchoolClass schoolClass = classCreatedBy("teacher-2");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(schoolClass);
|
|
|
|
ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCanDeleteOwnLocalAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacherAdmin = teacher("teacher-1", true);
|
|
SchoolClass existing = classCreatedBy("teacher-1");
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("LOCAL");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.deleteByPrimaryKey("class-1")).thenReturn(1);
|
|
|
|
ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).deleteByPrimaryKey("class-1");
|
|
}
|
|
|
|
@Test
|
|
void ordinaryTeacherCanDeleteOwnLocalAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacher = teacher("teacher-1", false);
|
|
SchoolClass existing = classCreatedBy("teacher-1");
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("LOCAL");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.deleteByPrimaryKey("class-1")).thenReturn(1);
|
|
|
|
ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).deleteByPrimaryKey("class-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCanDeleteLocalAdminClassWithoutOwnerInSameSchool() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacherAdmin = teacher("teacher-1", true);
|
|
SchoolClass existing = classCreatedBy(null);
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("LOCAL");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.deleteByPrimaryKey("class-1")).thenReturn(1);
|
|
|
|
ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).deleteByPrimaryKey("class-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCannotDeleteZhiyunAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacherAdmin = teacher("teacher-1", true);
|
|
SchoolClass existing = classCreatedBy(null);
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("ZHIYUN");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
|
|
ResultEntity result = controller.deleteSchoolClass("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherUpdatesOnlyOwnedClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacher = teacher("teacher-1");
|
|
SchoolClass existing = classCreatedBy("teacher-1");
|
|
SchoolClass update = new SchoolClass();
|
|
update.setSchoolClassId("class-1");
|
|
update.setClassName("new-class");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.updateSchoolClass(update, "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).updateByPrimaryKeySelective(update);
|
|
verify(controller.schoolClassMapper, never()).deleteByPrimaryKey("class-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCanUpdateOwnLocalAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacherAdmin = teacher("teacher-1", true);
|
|
SchoolClass existing = classCreatedBy("teacher-1");
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("LOCAL");
|
|
SchoolClass update = new SchoolClass();
|
|
update.setSchoolClassId("class-1");
|
|
update.setClassName("new-admin-class");
|
|
update.setCreatedBy("teacher-1");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.updateSchoolClass(update, "teacher-1");
|
|
|
|
ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).updateByPrimaryKeySelective(captor.capture());
|
|
assertEquals("teacher-1", captor.getValue().getCreatedBy());
|
|
}
|
|
|
|
@Test
|
|
void ordinaryTeacherCanUpdateOwnLocalAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacher = teacher("teacher-1", false);
|
|
SchoolClass existing = classCreatedBy("teacher-1");
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("LOCAL");
|
|
SchoolClass update = new SchoolClass();
|
|
update.setSchoolClassId("class-1");
|
|
update.setClassName("new-admin-class");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.updateSchoolClass(update, "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).updateByPrimaryKeySelective(update);
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCanUpdateLocalAdminClassWithoutOwnerInSameSchool() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacherAdmin = teacher("teacher-1", true);
|
|
SchoolClass existing = classCreatedBy(null);
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("LOCAL");
|
|
SchoolClass update = new SchoolClass();
|
|
update.setSchoolClassId("class-1");
|
|
update.setClassName("new-admin-class");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
when(controller.schoolClassMapper.updateByPrimaryKeySelective(any(SchoolClass.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.updateSchoolClass(update, "teacher-1");
|
|
|
|
ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).updateByPrimaryKeySelective(captor.capture());
|
|
assertNull(captor.getValue().getCreatedBy());
|
|
}
|
|
|
|
@Test
|
|
void teacherAdminCannotUpdateZhiyunAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacherAdmin = teacher("teacher-1", true);
|
|
SchoolClass existing = classCreatedBy(null);
|
|
existing.setClassType("ADMIN");
|
|
existing.setDataSource("ZHIYUN");
|
|
SchoolClass update = new SchoolClass();
|
|
update.setSchoolClassId("class-1");
|
|
update.setClassName("new-admin-class");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacherAdmin);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(existing);
|
|
|
|
ResultEntity result = controller.updateSchoolClass(update, "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolClassMapper, never()).updateByPrimaryKeySelective(any(SchoolClass.class));
|
|
}
|
|
|
|
@Test
|
|
void teacherCannotDeleteStudentFromClassCreatedByAnotherTeacher() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo teacher = teacher("teacher-1");
|
|
Userinfo student = new Userinfo();
|
|
student.setUserId("student-1");
|
|
student.setRole(4);
|
|
student.setSchoolClassId("class-1");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher);
|
|
when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(student);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-2"));
|
|
|
|
ResultEntity result = controller.deleteStudent("student-1", "teacher-1", null);
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.userinfoMapper, never()).deleteByPrimaryKey("student-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherCanDeleteStudentInOwnedTeachingClassEvenWhenAdminClassIsDifferent() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo student = new Userinfo();
|
|
student.setUserId("student-1");
|
|
student.setRole(4);
|
|
student.setSchoolClassId("admin-1");
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSchoolClassId("teaching-1");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(student);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
|
|
.thenReturn(1L);
|
|
when(controller.teachingClassStudentMapper.deleteByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
|
|
.thenReturn(1);
|
|
|
|
ResultEntity result = controller.deleteStudent("student-1", "teacher-1", "teaching-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.teachingClassStudentMapper).deleteByStudentUserIdAndTeachingClassId("student-1", "teaching-1");
|
|
verify(controller.userinfoMapper, never()).deleteByPrimaryKey("student-1");
|
|
}
|
|
|
|
@Test
|
|
void teacherCanInitializePasswordForStudentInOwnedTeachingClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo student = new Userinfo();
|
|
student.setUserId("student-1");
|
|
student.setRole(4);
|
|
student.setSchoolClassId("admin-1");
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSchoolClassId("teaching-1");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(student);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
|
|
.thenReturn(1L);
|
|
when(controller.userinfoMapper.updateByPrimaryKey(student)).thenReturn(1);
|
|
|
|
ResultEntity result = controller.updateStudentPassword("student-1", "teacher-1", "teaching-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("123qwe", student.getPassword());
|
|
verify(controller.userinfoMapper).updateByPrimaryKey(student);
|
|
}
|
|
|
|
@Test
|
|
void teacherCanUpdateStudentInOwnedTeachingClassEvenWhenAdminClassIsDifferent() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo existingStudent = new Userinfo();
|
|
existingStudent.setUserId("student-1");
|
|
existingStudent.setRole(4);
|
|
existingStudent.setSchoolClassId("admin-1");
|
|
Userinfo update = new Userinfo();
|
|
update.setUserId("student-1");
|
|
update.setRole(4);
|
|
update.setSchoolClassId("admin-1");
|
|
update.setName("updated");
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSchoolClassId("teaching-1");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.userinfoMapper.selectByPrimaryKey("student-1")).thenReturn(existingStudent);
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
|
|
.thenReturn(1L);
|
|
when(controller.userinfoMapper.updateByPrimaryKey(update)).thenReturn(1);
|
|
|
|
ResultEntity result = controller.updateStudent(update, "teacher-1", "teaching-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.userinfoMapper).updateByPrimaryKey(update);
|
|
}
|
|
|
|
@Test
|
|
void teacherCanAddStudentOnlyToOwnedClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-1"));
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.userInfoService.existsByUserName("s001")).thenReturn(false);
|
|
when(controller.userinfoMapper.insert(any(Userinfo.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.addStudentAccount("school-1", "school", "faculty-1", "major-1",
|
|
"major", "class-1", "class-1", "学生", "s001", null, null, "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
}
|
|
|
|
@Test
|
|
void addStudentToTeachingClassCreatesMembershipInsteadOfChangingAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSourceClassIds("admin-1");
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.userInfoService.existsByUserName("s001")).thenReturn(false);
|
|
when(controller.userinfoMapper.insert(any(Userinfo.class))).thenReturn(1);
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.addStudentAccount("school-1", "school", "faculty-1", "major-1",
|
|
"major", "teaching", "teaching-1", "瀛︾敓", "s001", null, null, "teacher-1");
|
|
|
|
ArgumentCaptor<Userinfo> userCaptor = ArgumentCaptor.forClass(Userinfo.class);
|
|
ArgumentCaptor<TeachingClassStudent> memberCaptor = ArgumentCaptor.forClass(TeachingClassStudent.class);
|
|
verify(controller.userinfoMapper).insert(userCaptor.capture());
|
|
verify(controller.teachingClassStudentMapper).insertSelective(memberCaptor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("admin-1", userCaptor.getValue().getSchoolClassId());
|
|
assertEquals("teaching-1", memberCaptor.getValue().getTeachingClassId());
|
|
assertEquals(userCaptor.getValue().getUserId(), memberCaptor.getValue().getStudentUserId());
|
|
}
|
|
|
|
@Test
|
|
void teacherCannotInitializeTeachingClassCreatedByAnotherTeacher() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-2"));
|
|
|
|
ResultEntity result = controller.initializeTeachingClassTrainingData("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
}
|
|
|
|
@Test
|
|
void teacherCanInitializeOwnedTeachingClassResetsAllMembers() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-1"));
|
|
TeachingClassStudent memberOne = new TeachingClassStudent();
|
|
memberOne.setStudentUserId("student-1");
|
|
TeachingClassStudent memberTwo = new TeachingClassStudent();
|
|
memberTwo.setStudentUserId("student-2");
|
|
when(controller.teachingClassStudentMapper.selectByTeachingClassId("class-1"))
|
|
.thenReturn(Arrays.asList(memberOne, memberTwo));
|
|
|
|
ResultEntity result = controller.initializeTeachingClassTrainingData("class-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.cptfController).restartByUserId("student-1");
|
|
verify(controller.cptfController).restartByUserId("student-2");
|
|
}
|
|
|
|
@Test
|
|
void teacherCanInitializeSingleStudentOnlyInOwnedTeachingClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(classCreatedBy("teacher-1"));
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "class-1"))
|
|
.thenReturn(1L);
|
|
|
|
ResultEntity result = controller.initializeTeachingClassStudentTrainingData("class-1", "student-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.cptfController).restartByUserId("student-1");
|
|
}
|
|
|
|
@Test
|
|
void selectStudentByTeachingClassUsesMembershipRows() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
TeachingClassStudent member = new TeachingClassStudent();
|
|
member.setStudentUserId("student-1");
|
|
when(controller.teachingClassStudentMapper.selectByTeachingClassId("teaching-1"))
|
|
.thenReturn(Collections.singletonList(member));
|
|
Userinfo student = new Userinfo();
|
|
student.setUserId("student-1");
|
|
student.setRole(4);
|
|
student.setSchoolId("school-1");
|
|
student.setSchoolClassId("admin-1");
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
|
|
|
|
ResultEntity result = controller.selectStudent("school-1", "teaching-1", null, null, 1, 10);
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.teachingClassStudentMapper).selectByTeachingClassId("teaching-1");
|
|
}
|
|
|
|
@Test
|
|
void importTeachingClassStudentRowsCreatesMembershipForMatchedAdminStudents() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSchoolClassId("teaching-1");
|
|
teachingClass.setSchoolId("school-1");
|
|
teachingClass.setSourceClassIds("admin-1");
|
|
Userinfo student = new Userinfo();
|
|
student.setUserId("student-1");
|
|
student.setRole(4);
|
|
student.setName("student");
|
|
student.setUsername("2024001");
|
|
student.setSchoolId("school-1");
|
|
student.setSchoolClassId("admin-1");
|
|
TeachingClassStudentImportDTO row = teachingClassStudentRow("student", "2024001");
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
|
|
.thenReturn(0L);
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1");
|
|
|
|
ArgumentCaptor<TeachingClassStudent> captor = ArgumentCaptor.forClass(TeachingClassStudent.class);
|
|
verify(controller.teachingClassStudentMapper).insertSelective(captor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("teaching-1", captor.getValue().getTeachingClassId());
|
|
assertEquals("student-1", captor.getValue().getStudentUserId());
|
|
assertEquals("admin-1", captor.getValue().getAdminClassId());
|
|
assertEquals("IN_PROGRESS", captor.getValue().getStatus());
|
|
}
|
|
|
|
@Test
|
|
void importTeachingClassStudentRowsTransfersStudentFromOtherTeachingClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSchoolClassId("teaching-1");
|
|
teachingClass.setSchoolId("school-1");
|
|
teachingClass.setSourceClassIds("admin-1");
|
|
Userinfo student = student("student-1", "student", "2024001", "admin-1");
|
|
TeachingClassStudentImportDTO row = teachingClassStudentRow("student", "2024001");
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.teachingClassStudentMapper).exitActiveByStudentUserIdExceptClass("student-1", "teaching-1");
|
|
verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void importTeachingClassStudentRowsCanContinueAfterMultiClassConfirmation() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSchoolClassId("teaching-1");
|
|
teachingClass.setSchoolId("school-1");
|
|
teachingClass.setSourceClassIds("admin-1");
|
|
Userinfo student = student("student-1", "student", "2024001", "admin-1");
|
|
TeachingClassStudentImportDTO row = teachingClassStudentRow("student", "2024001");
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", "teaching-1"))
|
|
.thenReturn(1L);
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdAndTeachingClassId("student-1", "teaching-1"))
|
|
.thenReturn(0L);
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1", true);
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void importTeachingClassStudentRowsRejectsWholeBatchWhenStudentDoesNotMatchAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass teachingClass = classCreatedBy("teacher-1");
|
|
teachingClass.setSchoolClassId("teaching-1");
|
|
teachingClass.setSchoolId("school-1");
|
|
teachingClass.setSourceClassIds("admin-1");
|
|
TeachingClassStudentImportDTO row = teachingClassStudentRow("missing", "2024999");
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("teaching-1")).thenReturn(teachingClass);
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
|
|
ResultEntity result = controller.importTeachingClassStudentRows(Collections.singletonList(row), "teaching-1", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.teachingClassStudentMapper, never()).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void createTeachingClassByImportRowsCreatesClassAndOnlyImportedMembers() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo studentOne = student("student-1", "student-a", "2024001", "admin-1");
|
|
Userinfo studentTwo = student("student-2", "student-b", "2024002", "admin-2");
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.userinfoMapper.selectByExample(any()))
|
|
.thenReturn(Collections.singletonList(studentOne))
|
|
.thenReturn(Collections.singletonList(studentTwo))
|
|
.thenReturn(Collections.singletonList(studentOne))
|
|
.thenReturn(Collections.singletonList(studentTwo));
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.createTeachingClassByImportRows(
|
|
Arrays.asList(teachingClassStudentRow("student-a", "2024001"), teachingClassStudentRow("student-b", "2024002")),
|
|
"school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1");
|
|
|
|
ArgumentCaptor<SchoolClass> classCaptor = ArgumentCaptor.forClass(SchoolClass.class);
|
|
ArgumentCaptor<TeachingClassStudent> memberCaptor = ArgumentCaptor.forClass(TeachingClassStudent.class);
|
|
verify(controller.schoolClassMapper).insert(classCaptor.capture());
|
|
verify(controller.teachingClassStudentMapper, times(2)).insertSelective(memberCaptor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("TEACHING", classCaptor.getValue().getClassType());
|
|
assertEquals("teacher-1", classCaptor.getValue().getCreatedBy());
|
|
assertEquals("admin-1,admin-2", classCaptor.getValue().getSourceClassIds());
|
|
assertEquals(classCaptor.getValue().getSchoolClassId(), memberCaptor.getAllValues().get(0).getTeachingClassId());
|
|
assertEquals("student-1", memberCaptor.getAllValues().get(0).getStudentUserId());
|
|
assertEquals("student-2", memberCaptor.getAllValues().get(1).getStudentUserId());
|
|
}
|
|
|
|
@Test
|
|
void createTeachingClassByImportRowsTransfersStudentFromOtherTeachingClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.userinfoMapper.selectByExample(any()))
|
|
.thenReturn(Collections.singletonList(student))
|
|
.thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.createTeachingClassByImportRows(
|
|
Collections.singletonList(teachingClassStudentRow("student-a", "2024001")),
|
|
"school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).insert(any(SchoolClass.class));
|
|
verify(controller.teachingClassStudentMapper).exitActiveByStudentUserIdExceptClass(argThat(id -> "student-1".equals(id)), any());
|
|
verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void createTeachingClassByImportRowsCanContinueAfterMultiClassConfirmation() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.userinfoMapper.selectByExample(any()))
|
|
.thenReturn(Collections.singletonList(student))
|
|
.thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.countByStudentUserIdExcludingTeachingClass("student-1", ""))
|
|
.thenReturn(1L);
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.createTeachingClassByImportRows(
|
|
Collections.singletonList(teachingClassStudentRow("student-a", "2024001")),
|
|
"school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1", true);
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.schoolClassMapper).insert(any(SchoolClass.class));
|
|
verify(controller.teachingClassStudentMapper).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void createTeachingClassByImportRowsRejectsWholeBatchBeforeCreatingClassWhenAnyRowDoesNotMatch() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.userinfoMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
|
|
ResultEntity result = controller.createTeachingClassByImportRows(
|
|
Collections.singletonList(teachingClassStudentRow("missing", "2024999")),
|
|
"school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1");
|
|
|
|
assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
|
|
verify(controller.schoolClassMapper, never()).insert(any(SchoolClass.class));
|
|
verify(controller.teachingClassStudentMapper, never()).insertSelective(any(TeachingClassStudent.class));
|
|
}
|
|
|
|
@Test
|
|
void createTeachingClassByImportRowsUsesSelectedSourceAdminClasses() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
Userinfo student = student("student-1", "student-a", "2024001", "admin-1");
|
|
SchoolClass adminClass = new SchoolClass();
|
|
adminClass.setSchoolClassId("admin-1");
|
|
adminClass.setSchoolId("school-1");
|
|
adminClass.setSchoolMajorId("major-1");
|
|
adminClass.setClassType("ADMIN");
|
|
when(controller.schoolClassMapper.selectByPrimaryKey("admin-1")).thenReturn(adminClass);
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.emptyList());
|
|
when(controller.schoolClassMapper.insert(any(SchoolClass.class))).thenReturn(1);
|
|
when(controller.userinfoMapper.selectByExample(any()))
|
|
.thenReturn(Collections.singletonList(student))
|
|
.thenReturn(Collections.singletonList(student));
|
|
when(controller.teachingClassStudentMapper.insertSelective(any(TeachingClassStudent.class))).thenReturn(1);
|
|
when(controller.pinyin4jUtil.convertToPinyin(any())).thenReturn("py");
|
|
|
|
ResultEntity result = controller.createTeachingClassByImportRows(
|
|
Collections.singletonList(teachingClassStudentRow("student-a", "2024001")),
|
|
"school-1", "faculty-1", "major-1", "import-teaching-class", "teacher-1", "admin-1", false);
|
|
|
|
ArgumentCaptor<SchoolClass> classCaptor = ArgumentCaptor.forClass(SchoolClass.class);
|
|
verify(controller.schoolClassMapper).insert(classCaptor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("admin-1", classCaptor.getValue().getSourceClassIds());
|
|
}
|
|
|
|
@Test
|
|
void importTeacherStudentRowsCreatesStudentsForOwnedAdminClass() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass adminClass = new SchoolClass();
|
|
adminClass.setSchoolClassId("admin-1");
|
|
adminClass.setSchoolId("school-1");
|
|
adminClass.setSchoolMajorId("major-1");
|
|
adminClass.setClassName("行政一班");
|
|
adminClass.setClassType("ADMIN");
|
|
adminClass.setCreatedBy("teacher-1");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", true));
|
|
when(controller.schoolFacultyMapper.selectByExample(any())).thenReturn(Collections.singletonList(faculty("faculty-1", "院系")));
|
|
when(controller.schoolMajorMapper.selectByExample(any())).thenReturn(Collections.singletonList(major("major-1", "faculty-1", "专业")));
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.singletonList(adminClass));
|
|
when(controller.userInfoService.existsByUserName("20260001")).thenReturn(false);
|
|
when(controller.userinfoMapper.insertSelective(any(Userinfo.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.importTeacherStudentRows(
|
|
Collections.singletonList(studentAccountRow("张三", "20260001", "男", "院系", "专业", "行政一班")),
|
|
"teacher-1");
|
|
|
|
ArgumentCaptor<Userinfo> captor = ArgumentCaptor.forClass(Userinfo.class);
|
|
verify(controller.userinfoMapper).insertSelective(captor.capture());
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
assertEquals("张三", captor.getValue().getName());
|
|
assertEquals("20260001", captor.getValue().getUsername());
|
|
assertEquals("admin-1", captor.getValue().getSchoolClassId());
|
|
assertEquals(4, captor.getValue().getRole());
|
|
assertEquals("Excel导入", captor.getValue().getCodeFrom());
|
|
}
|
|
|
|
@Test
|
|
void importTeacherStudentRowsAllowsAdminClassFromSameSchool() {
|
|
UserController controller = controllerWithCommonMocks();
|
|
SchoolClass adminClass = new SchoolClass();
|
|
adminClass.setSchoolClassId("admin-1");
|
|
adminClass.setSchoolId("school-1");
|
|
adminClass.setSchoolMajorId("major-1");
|
|
adminClass.setClassName("行政一班");
|
|
adminClass.setClassType("ADMIN");
|
|
adminClass.setCreatedBy("teacher-2");
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1", true));
|
|
when(controller.schoolFacultyMapper.selectByExample(any())).thenReturn(Collections.singletonList(faculty("faculty-1", "院系")));
|
|
when(controller.schoolMajorMapper.selectByExample(any())).thenReturn(Collections.singletonList(major("major-1", "faculty-1", "专业")));
|
|
when(controller.schoolClassMapper.selectByExample(any())).thenReturn(Collections.singletonList(adminClass));
|
|
when(controller.userInfoService.existsByUserName("20260001")).thenReturn(false);
|
|
when(controller.userinfoMapper.insertSelective(any(Userinfo.class))).thenReturn(1);
|
|
|
|
ResultEntity result = controller.importTeacherStudentRows(
|
|
Collections.singletonList(studentAccountRow("张三", "20260001", "男", "院系", "专业", "行政一班")),
|
|
"teacher-1");
|
|
|
|
assertEquals(HttpStatus.OK, result.getStatusCode());
|
|
verify(controller.userinfoMapper).insertSelective(argThat(student -> "admin-1".equals(student.getSchoolClassId())));
|
|
}
|
|
|
|
private UserController controllerWithCommonMocks() {
|
|
UserController controller = new UserController();
|
|
controller.schoolMapper = mock(SchoolMapper.class);
|
|
controller.schoolFacultyMapper = mock(SchoolFacultyMapper.class);
|
|
controller.schoolMajorMapper = mock(SchoolMajorMapper.class);
|
|
controller.schoolClassMapper = mock(SchoolClassMapper.class);
|
|
controller.teachingClassStudentMapper = mock(TeachingClassStudentMapper.class);
|
|
controller.userinfoMapper = mock(UserinfoMapper.class);
|
|
controller.userInfoService = mock(UserInfoService.class);
|
|
controller.pinyin4jUtil = mock(Pinyin4jUtil.class);
|
|
controller.cptfController = mock(CptfController.class);
|
|
|
|
School school = new School();
|
|
school.setSchoolId("school-1");
|
|
school.setSchoolName("school");
|
|
SchoolFaculty faculty = new SchoolFaculty();
|
|
faculty.setSchoolFacultyId("faculty-1");
|
|
faculty.setSchoolId("school-1");
|
|
SchoolMajor major = new SchoolMajor();
|
|
major.setSchoolMajorId("major-1");
|
|
major.setSchoolFacultyId("faculty-1");
|
|
|
|
when(controller.schoolMapper.selectByPrimaryKey("school-1")).thenReturn(school);
|
|
when(controller.schoolFacultyMapper.selectByPrimaryKey("faculty-1")).thenReturn(faculty);
|
|
when(controller.schoolMajorMapper.selectByPrimaryKey("major-1")).thenReturn(major);
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-1")).thenReturn(teacher("teacher-1"));
|
|
when(controller.userinfoMapper.selectByPrimaryKey("teacher-admin")).thenReturn(teacher("teacher-admin", true));
|
|
return controller;
|
|
}
|
|
|
|
private Userinfo teacher(String userId) {
|
|
return teacher(userId, false);
|
|
}
|
|
|
|
private Userinfo teacher(String userId, boolean teacherAdmin) {
|
|
Userinfo teacher = new Userinfo();
|
|
teacher.setUserId(userId);
|
|
teacher.setRole(3);
|
|
teacher.setSchoolId("school-1");
|
|
teacher.setTeacherAdmin(teacherAdmin);
|
|
return teacher;
|
|
}
|
|
|
|
private SchoolFaculty faculty(String facultyId, String facultyName) {
|
|
SchoolFaculty faculty = new SchoolFaculty();
|
|
faculty.setSchoolFacultyId(facultyId);
|
|
faculty.setSchoolId("school-1");
|
|
faculty.setSchoolFacultyName(facultyName);
|
|
return faculty;
|
|
}
|
|
|
|
private SchoolMajor major(String majorId, String facultyId, String majorName) {
|
|
SchoolMajor major = new SchoolMajor();
|
|
major.setSchoolMajorId(majorId);
|
|
major.setSchoolFacultyId(facultyId);
|
|
major.setSchoolMajorName(majorName);
|
|
return major;
|
|
}
|
|
|
|
private SchoolClass classCreatedBy(String teacherId) {
|
|
SchoolClass schoolClass = new SchoolClass();
|
|
schoolClass.setSchoolClassId("class-1");
|
|
schoolClass.setSchoolId("school-1");
|
|
schoolClass.setCreatedBy(teacherId);
|
|
schoolClass.setClassType("TEACHING");
|
|
return schoolClass;
|
|
}
|
|
|
|
private boolean hasCondition(SchoolClassExample example, String condition) {
|
|
return example.getOredCriteria().stream()
|
|
.flatMap(criteria -> criteria.getAllCriteria().stream())
|
|
.anyMatch(criterion -> condition.equals(criterion.getCondition()));
|
|
}
|
|
|
|
private TeachingClassStudentImportDTO teachingClassStudentRow(String studentName, String userName) {
|
|
TeachingClassStudentImportDTO row = new TeachingClassStudentImportDTO();
|
|
row.setStudentName(studentName);
|
|
row.setUserName(userName);
|
|
return row;
|
|
}
|
|
|
|
private Userinfo student(String userId, String name, String userName, String adminClassId) {
|
|
Userinfo student = new Userinfo();
|
|
student.setUserId(userId);
|
|
student.setRole(4);
|
|
student.setName(name);
|
|
student.setUsername(userName);
|
|
student.setSchoolId("school-1");
|
|
student.setSchoolFacultyId("faculty-1");
|
|
student.setSchoolMajorId("major-1");
|
|
student.setSchoolClassId(adminClassId);
|
|
return student;
|
|
}
|
|
|
|
private SchoolAdminStudentImportDTO studentAccountRow(String name,
|
|
String username,
|
|
String sex,
|
|
String facultyName,
|
|
String majorName,
|
|
String className) {
|
|
SchoolAdminStudentImportDTO row = new SchoolAdminStudentImportDTO();
|
|
row.setName(name);
|
|
row.setUsername(username);
|
|
row.setSex(sex);
|
|
row.setSchoolFacultyName(facultyName);
|
|
row.setSchoolMajorName(majorName);
|
|
row.setSchoolClassName(className);
|
|
row.setPhone("13800000000");
|
|
row.setEmail("student@example.com");
|
|
return row;
|
|
}
|
|
}
|