RosterStudentsController.java

package edu.ucsb.cs156.frontiers.controllers;

import com.fasterxml.jackson.core.JsonProcessingException;
import edu.ucsb.cs156.frontiers.entities.Course;
import edu.ucsb.cs156.frontiers.entities.Job;
import edu.ucsb.cs156.frontiers.entities.RosterStudent;
import edu.ucsb.cs156.frontiers.entities.User;
import edu.ucsb.cs156.frontiers.enums.InsertStatus;
import edu.ucsb.cs156.frontiers.enums.OrgStatus;
import edu.ucsb.cs156.frontiers.enums.RosterStatus;
import edu.ucsb.cs156.frontiers.errors.EntityNotFoundException;
import edu.ucsb.cs156.frontiers.errors.NoLinkedOrganizationException;
import edu.ucsb.cs156.frontiers.jobs.RemoveStudentsJob;
import edu.ucsb.cs156.frontiers.jobs.UpdateOrgMembershipJob;
import edu.ucsb.cs156.frontiers.models.LoadResult;
import edu.ucsb.cs156.frontiers.models.RosterStudentDTO;
import edu.ucsb.cs156.frontiers.models.UpsertResponse;
import edu.ucsb.cs156.frontiers.repositories.CourseRepository;
import edu.ucsb.cs156.frontiers.repositories.RosterStudentRepository;
import edu.ucsb.cs156.frontiers.services.CanvasService;
import edu.ucsb.cs156.frontiers.services.CurrentUserService;
import edu.ucsb.cs156.frontiers.services.OrganizationMemberService;
import edu.ucsb.cs156.frontiers.services.UpdateUserService;
import edu.ucsb.cs156.frontiers.services.jobs.JobService;
import edu.ucsb.cs156.frontiers.utilities.CanonicalFormConverter;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

@Tag(name = "RosterStudents")
@RequestMapping("/api/rosterstudents")
@RestController
@Slf4j
public class RosterStudentsController extends ApiController {

  @Autowired private JobService jobService;
  @Autowired private OrganizationMemberService organizationMemberService;

  @Autowired private RosterStudentRepository rosterStudentRepository;

  @Autowired private CourseRepository courseRepository;

  @Autowired private UpdateUserService updateUserService;

  @Autowired private CurrentUserService currentUserService;
  @Autowired private CanvasService canvasService;

  /**
   * This method creates a new RosterStudent. It is important to keep the code in this method
   * consistent with the code for adding multiple roster students from a CSV
   *
   * @return the created RosterStudent
   */
  @Operation(summary = "Create a new roster student")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @PostMapping("/post")
  public ResponseEntity<UpsertResponse> postRosterStudent(
      @Parameter(name = "studentId") @RequestParam String studentId,
      @Parameter(name = "firstName") @RequestParam String firstName,
      @Parameter(name = "lastName") @RequestParam String lastName,
      @Parameter(name = "email") @RequestParam String email,
      @Parameter(name = "courseId") @RequestParam Long courseId,
      @Parameter(name = "section") @RequestParam(required = false) String section)
      throws EntityNotFoundException {

    // Get Course or else throw an error

    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));

    RosterStudent rosterStudent =
        RosterStudent.builder()
            .studentId(studentId)
            .firstName(firstName)
            .lastName(lastName)
            .email(email.strip())
            .section(section != null ? section : "")
            .build();

    UpsertResponse upsertResponse = upsertStudent(rosterStudent, course, RosterStatus.MANUAL);
    if (upsertResponse.getInsertStatus() == InsertStatus.REJECTED) {
      return ResponseEntity.status(HttpStatus.CONFLICT).body(upsertResponse);
    } else {
      rosterStudent = rosterStudentRepository.save(upsertResponse.rosterStudent());
      updateUserService.attachUserToRosterStudent(rosterStudent);
      return ResponseEntity.ok(upsertResponse);
    }
  }

  /**
   * This method returns a list of roster students for a given course.
   *
   * @return a list of all courses.
   */
  @Operation(summary = "List all roster students for a course")
  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @GetMapping("/course/{courseId}")
  public Iterable<RosterStudentDTO> rosterStudentForCourse(
      @Parameter(name = "courseId") @PathVariable Long courseId) throws EntityNotFoundException {
    courseRepository
        .findById(courseId)
        .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));
    Iterable<RosterStudent> rosterStudents =
        rosterStudentRepository.findByCourseIdOrderByFirstNameAscLastNameAscIgnoreCase(courseId);
    Iterable<RosterStudentDTO> rosterStudentDTOs =
        () ->
            java.util.stream.StreamSupport.stream(rosterStudents.spliterator(), false)
                .map(RosterStudentDTO::new)
                .iterator();
    return rosterStudentDTOs;
  }

  public static UpsertResponse upsertStudent(
      RosterStudent student, Course course, RosterStatus rosterStatus) {
    String convertedEmail = CanonicalFormConverter.convertToValidEmail(student.getEmail()).strip();
    Optional<RosterStudent> existingStudent =
        course.getRosterStudents().stream()
            .filter(
                filteringStudent -> student.getStudentId().equals(filteringStudent.getStudentId()))
            .findFirst();
    Optional<RosterStudent> existingStudentByEmail =
        course.getRosterStudents().stream()
            .filter(filteringStudent -> convertedEmail.equals(filteringStudent.getEmail()))
            .findFirst();
    if (existingStudent.isPresent() && existingStudentByEmail.isPresent()) {
      if (existingStudent.get().getId().equals(existingStudentByEmail.get().getId())) {
        RosterStudent existingStudentObj = existingStudent.get();
        existingStudentObj.setRosterStatus(rosterStatus);
        existingStudentObj.setFirstName(student.getFirstName());
        existingStudentObj.setLastName(student.getLastName());
        existingStudentObj.setSection(student.getSection());
        return new UpsertResponse(InsertStatus.UPDATED, existingStudentObj);
      } else {
        return new UpsertResponse(InsertStatus.REJECTED, student);
      }
    } else if (existingStudent.isPresent() || existingStudentByEmail.isPresent()) {
      RosterStudent existingStudentObj =
          existingStudent.isPresent() ? existingStudent.get() : existingStudentByEmail.get();
      existingStudentObj.setRosterStatus(rosterStatus);
      existingStudentObj.setFirstName(student.getFirstName());
      existingStudentObj.setLastName(student.getLastName());
      existingStudentObj.setSection(student.getSection());
      existingStudentObj.setEmail(convertedEmail);
      existingStudentObj.setStudentId(student.getStudentId());
      return new UpsertResponse(InsertStatus.UPDATED, existingStudentObj);
    } else {
      student.setCourse(course);
      student.setEmail(convertedEmail);
      student.setRosterStatus(rosterStatus);
      // if an installationID exists, orgStatus should be set to JOINCOURSE. if it doesn't exist
      // (null), set orgStatus to PENDING.
      if (course.getInstallationId() != null) {
        student.setOrgStatus(OrgStatus.JOINCOURSE);
      } else {
        student.setOrgStatus(OrgStatus.PENDING);
      }
      return new UpsertResponse(InsertStatus.INSERTED, student);
    }
  }

  @PreAuthorize("@CourseSecurity.hasManagePermissions(#root, #courseId)")
  @PostMapping("/updateCourseMembership")
  public Job updateCourseMembership(
      @Parameter(name = "courseId", description = "Course ID") @RequestParam Long courseId)
      throws NoSuchAlgorithmException, InvalidKeySpecException, JsonProcessingException {
    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId));
    if (course.getInstallationId() == null || course.getOrgName() == null) {
      throw new NoLinkedOrganizationException(course.getCourseName());
    } else {
      UpdateOrgMembershipJob job =
          UpdateOrgMembershipJob.builder()
              .rosterStudentRepository(rosterStudentRepository)
              .organizationMemberService(organizationMemberService)
              .course(course)
              .build();

      return jobService.runAsJob(job);
    }
  }

  @Operation(
      summary =
          "Allow roster student to join a course by generating an invitation to the linked Github Org")
  @PreAuthorize("hasRole('ROLE_USER')")
  @PutMapping("/joinCourse")
  public ResponseEntity<String> joinCourseOnGitHub(
      @Parameter(
              name = "rosterStudentId",
              description = "Roster Student joining a course on GitHub")
          @RequestParam
          Long rosterStudentId)
      throws NoSuchAlgorithmException, InvalidKeySpecException, JsonProcessingException {

    User currentUser = currentUserService.getUser();
    RosterStudent rosterStudent =
        rosterStudentRepository
            .findById(rosterStudentId)
            .orElseThrow(() -> new EntityNotFoundException(RosterStudent.class, rosterStudentId));

    if (rosterStudent.getUser() == null || currentUser.getId() != rosterStudent.getUser().getId()) {
      throw new AccessDeniedException("User not authorized join the course as this roster student");
    }

    if (rosterStudent.getRosterStatus() == RosterStatus.DROPPED) {
      throw new AccessDeniedException(
          "You have dropped this course. Please contact your instructor.");
    }

    if (rosterStudent.getGithubId() != null
        && rosterStudent.getGithubLogin() != null
        && (rosterStudent.getOrgStatus() == OrgStatus.MEMBER
            || rosterStudent.getOrgStatus() == OrgStatus.OWNER)) {
      return ResponseEntity.badRequest()
          .body("This user has already linked a Github account to this course.");
    }

    if (rosterStudent.getCourse().getOrgName() == null
        || rosterStudent.getCourse().getInstallationId() == null) {
      return ResponseEntity.badRequest()
          .body("Course has not been set up. Please ask your instructor for help.");
    }
    rosterStudent.setGithubId(currentUser.getGithubId());
    rosterStudent.setGithubLogin(currentUser.getGithubLogin());
    OrgStatus status = organizationMemberService.inviteOrganizationMember(rosterStudent);
    rosterStudent.setOrgStatus(status);
    rosterStudentRepository.save(rosterStudent);
    if (status == OrgStatus.INVITED) {
      return ResponseEntity.accepted().body("Successfully invited student to Organization");
    } else if (status == OrgStatus.MEMBER || status == OrgStatus.OWNER) {
      return ResponseEntity.accepted()
          .body("Already in organization - set status to %s".formatted(status.toString()));
    } else {
      return ResponseEntity.internalServerError().body("Could not invite student to Organization");
    }
  }

  @Operation(summary = "Get Associated Roster Students with a User")
  @PreAuthorize("hasRole('ROLE_USER')")
  @GetMapping("/associatedRosterStudents")
  public Iterable<RosterStudent> getAssociatedRosterStudents() {
    User currentUser = currentUserService.getUser();
    Iterable<RosterStudent> rosterStudents = rosterStudentRepository.findAllByUser((currentUser));
    return rosterStudents;
  }

  @Operation(summary = "Update a roster student")
  @PreAuthorize("@CourseSecurity.hasRosterStudentManagementPermissions(#root, #id)")
  @PutMapping("/update")
  public RosterStudent updateRosterStudent(
      @Parameter(name = "id") @RequestParam Long id,
      @Parameter(name = "firstName") @RequestParam(required = false) String firstName,
      @Parameter(name = "lastName") @RequestParam(required = false) String lastName,
      @Parameter(name = "studentId") @RequestParam(required = false) String studentId,
      @Parameter(name = "section") @RequestParam(required = false) String section)
      throws EntityNotFoundException {

    if (firstName == null
        || lastName == null
        || studentId == null
        || firstName.trim().isEmpty()
        || lastName.trim().isEmpty()
        || studentId.trim().isEmpty()) {
      throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Required fields cannot be empty");
    }

    RosterStudent rosterStudent =
        rosterStudentRepository
            .findById(id)
            .orElseThrow(() -> new EntityNotFoundException(RosterStudent.class, id));

    if (!rosterStudent.getStudentId().trim().equals(studentId.trim())) {
      Optional<RosterStudent> existingStudent =
          rosterStudentRepository.findByCourseIdAndStudentId(
              rosterStudent.getCourse().getId(), studentId.trim());
      if (existingStudent.isPresent()) {
        throw new ResponseStatusException(
            HttpStatus.BAD_REQUEST, "Student ID already exists in this course");
      }
    }

    rosterStudent.setFirstName(firstName.trim());
    rosterStudent.setLastName(lastName.trim());
    rosterStudent.setStudentId(studentId.trim());

    if (section != null) {
      rosterStudent.setSection(section.trim());
    }

    return rosterStudentRepository.save(rosterStudent);
  }

  @Operation(
      summary = "Restore a roster student",
      description = "Makes a student who previously dropped the course able to join and interact")
  @PreAuthorize("@CourseSecurity.hasRosterStudentManagementPermissions(#root, #id)")
  @PutMapping("/restore")
  public RosterStudent restoreRosterStudent(@Parameter(name = "id") @RequestParam Long id)
      throws EntityNotFoundException {
    RosterStudent rosterStudent =
        rosterStudentRepository
            .findById(id)
            .orElseThrow(() -> new EntityNotFoundException(RosterStudent.class, id));
    rosterStudent.setRosterStatus(RosterStatus.MANUAL);
    return rosterStudentRepository.save(rosterStudent);
  }

  @Operation(summary = "Delete a roster student")
  @PreAuthorize("@CourseSecurity.hasRosterStudentManagementPermissions(#root, #id)")
  @DeleteMapping("/delete")
  @Transactional
  public ResponseEntity<String> deleteRosterStudent(
      @Parameter(name = "id") @RequestParam Long id,
      @Parameter(
              name = "removeFromOrg",
              description = "Whether to remove student from GitHub organization")
          @RequestParam(defaultValue = "true")
          boolean removeFromOrg)
      throws EntityNotFoundException {
    RosterStudent rosterStudent =
        rosterStudentRepository
            .findById(id)
            .orElseThrow(() -> new EntityNotFoundException(RosterStudent.class, id));
    Course course = rosterStudent.getCourse();

    boolean orgRemovalAttempted = false;
    boolean orgRemovalSuccessful = false;
    String orgRemovalErrorMessage = null;

    // Try to remove the student from the organization if they have a GitHub login
    // and removeFromOrg parameter is true
    if (removeFromOrg
        && rosterStudent.getGithubLogin() != null
        && course.getOrgName() != null
        && course.getInstallationId() != null) {
      orgRemovalAttempted = true;
      try {
        organizationMemberService.removeOrganizationMember(rosterStudent);
        orgRemovalSuccessful = true;
      } catch (Exception e) {
        log.error("Error removing student from organization: {}", e.getMessage());
        orgRemovalErrorMessage = e.getMessage();
        // Continue with deletion even if organization removal fails
      }
    }

    if (!rosterStudent.getTeamMembers().isEmpty()) {
      rosterStudent
          .getTeamMembers()
          .forEach(
              teamMember -> {
                teamMember.getTeam().getTeamMembers().remove(teamMember);
                teamMember.setTeam(null);
              });
    }

    rosterStudent.getCourse().getRosterStudents().remove(rosterStudent);
    rosterStudent.setCourse(null);
    rosterStudentRepository.delete(rosterStudent);

    if (!orgRemovalAttempted) {
      return ResponseEntity.ok(
          "Successfully deleted roster student and removed him/her from the course list");
    } else if (orgRemovalSuccessful) {
      return ResponseEntity.ok(
          "Successfully deleted roster student and removed him/her from the course list and organization");
    } else {
      return ResponseEntity.ok(
          "Successfully deleted roster student but there was an error removing them from the course organization: "
              + orgRemovalErrorMessage);
    }
  }

  /**
   * Upload Roster students for Course from Canvas. It is important to keep the code in this method
   * consistent with the code in uploadRosterStudentsCSV.
   *
   * @param courseId the internal course ID in Frontiers
   * @return LoadResult with counts of inserted, updated, dropped students and any rejected students
   */
  @Operation(summary = "Upload Roster students for Course from Canvas")
  @PreAuthorize("@CourseSecurity.hasInstructorPermissions(#root, #courseId)")
  @PostMapping("/canvas/sync/students")
  public ResponseEntity<LoadResult> uploadRosterFromCanvas(
      @Parameter(name = "courseId") @RequestParam Long courseId) {

    Course course =
        courseRepository
            .findById(courseId)
            .orElseThrow(() -> new EntityNotFoundException(Course.class, courseId.toString()));

    course.getRosterStudents().stream()
        .filter(filteredStudent -> filteredStudent.getRosterStatus() == RosterStatus.ROSTER)
        .forEach(student -> student.setRosterStatus(RosterStatus.DROPPED));

    int counts[] = {0, 0};
    List<RosterStudent> rejectedStudents = new ArrayList<>();

    List<RosterStudent> canvasStudents = canvasService.getCanvasRoster(course);
    for (RosterStudent rosterStudent : canvasStudents) {
      UpsertResponse upsertResponse = upsertStudent(rosterStudent, course, RosterStatus.ROSTER);
      if (upsertResponse.getInsertStatus() == InsertStatus.REJECTED) {
        rejectedStudents.add(upsertResponse.rosterStudent());
      } else {
        InsertStatus s = upsertResponse.getInsertStatus();
        if (s == InsertStatus.INSERTED) {
          course.getRosterStudents().add(upsertResponse.rosterStudent());
        }
        counts[s.ordinal()]++;
      }
    }

    if (rejectedStudents.isEmpty()) {
      List<RosterStudent> droppedStudents =
          course.getRosterStudents().stream()
              .filter(student -> student.getRosterStatus() == RosterStatus.DROPPED)
              .toList();
      LoadResult successfulResult =
          new LoadResult(
              counts[InsertStatus.INSERTED.ordinal()],
              counts[InsertStatus.UPDATED.ordinal()],
              droppedStudents.size(),
              List.of());
      rosterStudentRepository.saveAll(course.getRosterStudents());
      updateUserService.attachUsersToRosterStudents(course.getRosterStudents());
      RemoveStudentsJob job =
          RemoveStudentsJob.builder()
              .students(droppedStudents)
              .organizationMemberService(organizationMemberService)
              .rosterStudentRepository(rosterStudentRepository)
              .build();
      jobService.runAsJob(job);
      return ResponseEntity.ok(successfulResult);
    } else {
      LoadResult conflictResult = new LoadResult(0, 0, 0, rejectedStudents);
      return ResponseEntity.status(HttpStatus.CONFLICT).body(conflictResult);
    }
  }
}







































































































Active mutators

CONDITIONALS_BOUNDARY
EMPTY_RETURNS
FALSE_RETURNS
INCREMENTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NULL_RETURNS
PRIMITIVE_RETURNS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:no_fire_on_no_installation_id()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:test_already_part_is_member()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:test_fires_invite()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:cant_invite()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:test_already_part_is_owner()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_updatesExistingStudents()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests]/[method:students_with_non_matching_student_id_and_email_are_rejected()] (12 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests]/[method:updates_in_upsert_correctly()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests]/[method:instructor_can_upload_students_for_an_existing_course_chico()] (25 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testRestoreRosterStudent_notFound()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testPostRosterStudentWithInstallationId()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_setsJOINCOURSEStatusWhenInstallationIdPresent()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_nullFields()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_nullStudentId()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_emptyLastName()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_nullLastName()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_emptyFields()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_emptyFirstName()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_emptyStudentId()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_nullFirstName()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_notFound()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_duplicateStudentId()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_sameStudentIdWithWhitespace()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_success()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_updatesSectionWhenProvided()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_doesNotChangeSectionWhenNotProvided()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpdateRosterStudent_newStudentIdNotExists()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_setsPENDINGStatusWhenNoInstallationId()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_insertsNewStudents()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_manualStudentStaysManual()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_handlesDroppedStudents()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpsertStudentUpdatingTheEmail()] (7 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUpsertStudentWithDuplicateEmail()] (45 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_withGithubLogin_orgRemovalFails()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_withRemoveFromOrgTrue_success()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_withGithubLogin_success()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:test_post_fails_on_matching()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testPostRosterStudent_withSection()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testPostRosterStudentWithNoInstallationId()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_handlesRejectedStudents()] (8 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testPostRosterStudent_emailSanitized()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testPostRosterStudent_withUmail()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testPostRosterStudent()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsCSVControllerTests]/[method:drops_handled_correctly()] (10 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testJoinCourseOnGitHub_nullUser()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testJoinCourseOnGitHub_unauthorized()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:access_denied_on_dropped()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testJoinCourseOnGitHub_alreadyJoined_Owner()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testJoinCourseOnGitHub_alreadyJoined()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:no_fire_on_no_org_name()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:not_registered_org()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:job_actually_fires()] (8 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:just_no_org_name()] (15 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_withGithubLogin_noOrgName_success()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_withGithubLogin_noInstallationId_success()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testRosterStudentsByCourse()] (7 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testRestoreRosterStudent_success()] (11 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_notFound()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_success()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_withRemoveFromOrgFalse_noGithubLogin_success()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testDeleteRosterStudent_withRemoveFromOrgFalse_success()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testLinkGitHub_notFound()] (4 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:getting_roster_students_for_a_non_existing_course_returns_appropriate_error()] (8 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testGetAssociatedRosterStudents_noStudentsFound()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testGetAssociatedRosterStudents()] (6 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:notFound()] (5 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:test_InstructorCannotPostRosterStudentForCourseThatDoesNotExist()] (3 ms)
edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests.[engine:junit-jupiter]/[class:edu.ucsb.cs156.frontiers.controllers.RosterStudentsControllerTests]/[method:testUploadRosterFromCanvas_courseNotFound()] (5 ms)

Report generated by PIT 1.17.0

1		package edu.ucsb.cs156.frontiers.controllers;
2
3		import com.fasterxml.jackson.core.JsonProcessingException;
4		import edu.ucsb.cs156.frontiers.entities.Course;
5		import edu.ucsb.cs156.frontiers.entities.Job;
6		import edu.ucsb.cs156.frontiers.entities.RosterStudent;
7		import edu.ucsb.cs156.frontiers.entities.User;
8		import edu.ucsb.cs156.frontiers.enums.InsertStatus;
9		import edu.ucsb.cs156.frontiers.enums.OrgStatus;
10		import edu.ucsb.cs156.frontiers.enums.RosterStatus;
11		import edu.ucsb.cs156.frontiers.errors.EntityNotFoundException;
12		import edu.ucsb.cs156.frontiers.errors.NoLinkedOrganizationException;
13		import edu.ucsb.cs156.frontiers.jobs.RemoveStudentsJob;
14		import edu.ucsb.cs156.frontiers.jobs.UpdateOrgMembershipJob;
15		import edu.ucsb.cs156.frontiers.models.LoadResult;
16		import edu.ucsb.cs156.frontiers.models.RosterStudentDTO;
17		import edu.ucsb.cs156.frontiers.models.UpsertResponse;
18		import edu.ucsb.cs156.frontiers.repositories.CourseRepository;
19		import edu.ucsb.cs156.frontiers.repositories.RosterStudentRepository;
20		import edu.ucsb.cs156.frontiers.services.CanvasService;
21		import edu.ucsb.cs156.frontiers.services.CurrentUserService;
22		import edu.ucsb.cs156.frontiers.services.OrganizationMemberService;
23		import edu.ucsb.cs156.frontiers.services.UpdateUserService;
24		import edu.ucsb.cs156.frontiers.services.jobs.JobService;
25		import edu.ucsb.cs156.frontiers.utilities.CanonicalFormConverter;
26		import io.swagger.v3.oas.annotations.Operation;
27		import io.swagger.v3.oas.annotations.Parameter;
28		import io.swagger.v3.oas.annotations.tags.Tag;
29		import java.security.NoSuchAlgorithmException;
30		import java.security.spec.InvalidKeySpecException;
31		import java.util.ArrayList;
32		import java.util.List;
33		import java.util.Optional;
34		import lombok.extern.slf4j.Slf4j;
35		import org.springframework.beans.factory.annotation.Autowired;
36		import org.springframework.http.HttpStatus;
37		import org.springframework.http.ResponseEntity;
38		import org.springframework.security.access.AccessDeniedException;
39		import org.springframework.security.access.prepost.PreAuthorize;
40		import org.springframework.transaction.annotation.Transactional;

RosterStudentsController.java

Mutations

Active mutators

Tests examined