dianshang-houduan/src/test/java/com/sztzjy/linkCommerce/controller/stu/UserControllerTeacherAdminTest.java

package com.sztzjy.linkCommerce.controller.stu;

import com.sztzjy.linkCommerce.entity.School;
import com.sztzjy.linkCommerce.entity.SchoolClass;
import com.sztzjy.linkCommerce.entity.SchoolFaculty;
import com.sztzjy.linkCommerce.entity.SchoolMajor;
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.UserinfoMapper;
import com.sztzjy.linkCommerce.service.UserInfoService;
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.Collections;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class UserControllerTeacherAdminTest {

    @Test
    void addTeacherAccountAlwaysCreatesOrdinaryTeacher() {
        UserController controller = controllerWithCommonMocks();
        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);

        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 addSchoolClassStoresCreatorTeacher() {
        UserController controller = controllerWithCommonMocks();
        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");

        ArgumentCaptor<SchoolClass> captor = ArgumentCaptor.forClass(SchoolClass.class);
        verify(controller.schoolClassMapper).insert(captor.capture());
        assertEquals(HttpStatus.OK, result.getStatusCode());
        assertEquals("teacher-1", captor.getValue().getCreatedBy());
    }

    @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 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 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");

        assertEquals(HttpStatus.BAD_REQUEST, result.getStatusCode());
        verify(controller.userinfoMapper, never()).deleteByPrimaryKey("student-1");
    }

    @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());
    }

    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.userinfoMapper = mock(UserinfoMapper.class);
        controller.userInfoService = mock(UserInfoService.class);
        controller.pinyin4jUtil = mock(Pinyin4jUtil.class);

        School school = new School();
        school.setSchoolId("school-1");
        school.setSchoolName("school");
        SchoolFaculty faculty = new SchoolFaculty();
        faculty.setSchoolFacultyId("faculty-1");
        SchoolMajor major = new SchoolMajor();
        major.setSchoolMajorId("major-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);
        return controller;
    }

    private Userinfo teacher(String userId) {
        Userinfo teacher = new Userinfo();
        teacher.setUserId(userId);
        teacher.setRole(3);
        teacher.setSchoolId("school-1");
        return teacher;
    }

    private SchoolClass classCreatedBy(String teacherId) {
        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("class-1");
        schoolClass.setSchoolId("school-1");
        schoolClass.setCreatedBy(teacherId);
        return schoolClass;
    }
}