Examples with ExerciseGroup de.tum.in.www1.artemis.domain.exam.ExerciseGroup used on opensource projects

Example 81 with ExerciseGroup

use of de.tum.in.www1.artemis.domain.exam.ExerciseGroup in project ArTEMiS by ls1intum.

the class ExerciseGroupIntegrationTest method testUpdateExerciseGroup_asEditor.

@Test
@WithMockUser(username = "editor1", roles = "EDITOR")
public void testUpdateExerciseGroup_asEditor() throws Exception {
    ExerciseGroup exerciseGroup = ModelFactory.generateExerciseGroup(true, exam1);
    exerciseGroup.setExam(null);
    request.put("/api/courses/" + course1.getId() + "/exams/" + exam1.getId() + "/exerciseGroups", exerciseGroup, HttpStatus.CONFLICT);
    request.put("/api/courses/" + course1.getId() + "/exams/" + exam1.getId() + "/exerciseGroups", exerciseGroup1, HttpStatus.OK);
    verify(examAccessService, times(1)).checkCourseAndExamAndExerciseGroupAccessElseThrow(Role.EDITOR, course1.getId(), exam1.getId(), exerciseGroup1);
}

Example 82 with ExerciseGroup

use of de.tum.in.www1.artemis.domain.exam.ExerciseGroup in project ArTEMiS by ls1intum.

the class ExerciseGroupIntegrationTest method testGetExerciseGroup_asEditor.

@Test
@WithMockUser(username = "editor1", roles = "EDITOR")
public void testGetExerciseGroup_asEditor() throws Exception {
    ExerciseGroup result = request.get("/api/courses/" + course1.getId() + "/exams/" + exam1.getId() + "/exerciseGroups/" + exerciseGroup1.getId(), HttpStatus.OK, ExerciseGroup.class);
    verify(examAccessService, times(1)).checkCourseAndExamAndExerciseGroupAccessElseThrow(Role.EDITOR, course1.getId(), exam1.getId(), exerciseGroup1);
    assertThat(result.getExam()).isEqualTo(exam1);
}

Example 83 with ExerciseGroup

use of de.tum.in.www1.artemis.domain.exam.ExerciseGroup in project ArTEMiS by ls1intum.

the class ModelingSubmissionIntegrationTest method getModelingResult_BeforeExamPublishDate_Forbidden.

@Test
@WithMockUser(username = "student1", roles = "USER")
public void getModelingResult_BeforeExamPublishDate_Forbidden() throws Exception {
    // create exam
    Exam exam = database.addExamWithExerciseGroup(course, true);
    exam.setStartDate(now().minusHours(2));
    exam.setEndDate(now().minusHours(1));
    exam.setVisibleDate(now().minusHours(3));
    exam.setPublishResultsDate(now().plusHours(3));
    // creating exercise
    ExerciseGroup exerciseGroup = exam.getExerciseGroups().get(0);
    ModelingExercise modelingExercise = ModelFactory.generateModelingExerciseForExam(DiagramType.ActivityDiagram, exerciseGroup);
    exerciseGroup.addExercise(modelingExercise);
    exerciseGroupRepository.save(exerciseGroup);
    modelingExercise = exerciseRepo.save(modelingExercise);
    examRepository.save(exam);
    ModelingSubmission modelingSubmission = ModelFactory.generateModelingSubmission("Some text", true);
    modelingSubmission = database.addModelingSubmissionWithResultAndAssessor(modelingExercise, modelingSubmission, "student1", "tutor1");
    request.get("/api/participations/" + modelingSubmission.getParticipation().getId() + "/latest-modeling-submission", HttpStatus.FORBIDDEN, ModelingSubmission.class);
}

Example 84 with ExerciseGroup

use of de.tum.in.www1.artemis.domain.exam.ExerciseGroup in project ArTEMiS by ls1intum.

the class TextAssessmentIntegrationTest method multipleCorrectionRoundsForExam.

@Test
@WithMockUser(username = "tutor1", roles = "TA")
public void multipleCorrectionRoundsForExam() throws Exception {
    // Setup exam with 2 correction rounds and a programming exercise
    ExerciseGroup exerciseGroup1 = new ExerciseGroup();
    Exam exam = database.addExam(textExercise.getCourseViaExerciseGroupOrCourseMember());
    exam.setNumberOfCorrectionRoundsInExam(2);
    exam.addExerciseGroup(exerciseGroup1);
    exam.setVisibleDate(ZonedDateTime.now().minusHours(3));
    exam.setStartDate(ZonedDateTime.now().minusHours(2));
    exam.setEndDate(ZonedDateTime.now().minusHours(1));
    exam = examRepository.save(exam);
    Exam examWithExerciseGroups = examRepository.findWithExerciseGroupsAndExercisesById(exam.getId()).get();
    exerciseGroup1 = examWithExerciseGroups.getExerciseGroups().get(0);
    TextExercise exercise = ModelFactory.generateTextExerciseForExam(exerciseGroup1);
    exercise = exerciseRepo.save(exercise);
    exerciseGroup1.addExercise(exercise);
    // add student submission
    var studentParticipation = new StudentParticipation();
    studentParticipation.setExercise(exercise);
    studentParticipation.setParticipant(database.getUserByLogin("student1"));
    studentParticipation = studentParticipationRepository.save(studentParticipation);
    var submission = ModelFactory.generateTextSubmission("Text", Language.ENGLISH, true);
    submission.setParticipation(studentParticipation);
    submission = textSubmissionRepository.save(submission);
    // verify setup
    assertThat(exam.getNumberOfCorrectionRoundsInExam()).isEqualTo(2);
    assertThat(exam.getEndDate()).isBefore(ZonedDateTime.now());
    var optionalFetchedExercise = exerciseRepo.findWithEagerStudentParticipationsStudentAndSubmissionsById(exercise.getId());
    assertThat(optionalFetchedExercise).isPresent();
    final var exerciseWithParticipation = optionalFetchedExercise.get();
    studentParticipation = exerciseWithParticipation.getStudentParticipations().stream().iterator().next();
    database.changeUser("instructor1");
    // check properties set
    LinkedMultiValueMap<String, String> params = new LinkedMultiValueMap<>();
    params.add("withExerciseGroups", "true");
    Exam examReturned = request.get("/api/courses/" + exam.getCourse().getId() + "/exams/" + exam.getId(), HttpStatus.OK, Exam.class, params);
    examReturned.getExerciseGroups().get(0).getExercises().forEach(exerciseExamReturned -> {
        assertThat(exerciseExamReturned.getNumberOfParticipations()).isNotNull();
        assertThat(exerciseExamReturned.getNumberOfParticipations()).isEqualTo(1);
    });
    database.changeUser("tutor1");
    // request to manually assess latest submission (correction round: 0)
    params = new LinkedMultiValueMap<>();
    params.add("lock", "true");
    params.add("correction-round", "0");
    TextSubmission submissionWithoutFirstAssessment = request.get("/api/exercises/" + exerciseWithParticipation.getId() + "/text-submission-without-assessment", HttpStatus.OK, TextSubmission.class, params);
    // verify that no new submission was created
    assertThat(submissionWithoutFirstAssessment).isEqualTo(submission);
    // verify that the lock has been set
    assertThat(submissionWithoutFirstAssessment.getLatestResult()).isNotNull();
    assertThat(submissionWithoutFirstAssessment.getLatestResult().getAssessor().getLogin()).isEqualTo("tutor1");
    assertThat(submissionWithoutFirstAssessment.getLatestResult().getAssessmentType()).isEqualTo(AssessmentType.MANUAL);
    // make sure that new result correctly appears inside the continue box
    LinkedMultiValueMap<String, String> paramsGetAssessedCR1Tutor1 = new LinkedMultiValueMap<>();
    paramsGetAssessedCR1Tutor1.add("assessedByTutor", "true");
    paramsGetAssessedCR1Tutor1.add("correction-round", "0");
    var assessedSubmissionList = request.getList("/api/exercises/" + exerciseWithParticipation.getId() + "/text-submissions", HttpStatus.OK, TextSubmission.class, paramsGetAssessedCR1Tutor1);
    assertThat(assessedSubmissionList).hasSize(1);
    assertThat(assessedSubmissionList.get(0).getId()).isEqualTo(submissionWithoutFirstAssessment.getId());
    assertThat(assessedSubmissionList.get(0).getResultForCorrectionRound(0)).isEqualTo(submissionWithoutFirstAssessment.getLatestResult());
    // assess submission and submit
    List<Feedback> feedbacks = ModelFactory.generateFeedback().stream().peek(feedback -> {
        feedback.setDetailText("Good work here");
    }).collect(Collectors.toList());
    TextAssessmentDTO textAssessmentDTO = new TextAssessmentDTO();
    textAssessmentDTO.setFeedbacks(feedbacks);
    Result firstSubmittedManualResult = request.postWithResponseBody("/api/participations/" + submissionWithoutFirstAssessment.getParticipation().getId() + "/results/" + submissionWithoutFirstAssessment.getLatestResult().getId() + "/submit-text-assessment", textAssessmentDTO, Result.class, HttpStatus.OK);
    // make sure that new result correctly appears after the assessment for first correction round
    assessedSubmissionList = request.getList("/api/exercises/" + exerciseWithParticipation.getId() + "/text-submissions", HttpStatus.OK, TextSubmission.class, paramsGetAssessedCR1Tutor1);
    assertThat(assessedSubmissionList).hasSize(1);
    assertThat(assessedSubmissionList.get(0).getId()).isEqualTo(submissionWithoutFirstAssessment.getId());
    assertThat(assessedSubmissionList.get(0).getResultForCorrectionRound(0)).isNotNull();
    assertThat(firstSubmittedManualResult.getAssessor().getLogin()).isEqualTo("tutor1");
    // verify that the result contains the relationship
    assertThat(firstSubmittedManualResult).isNotNull();
    assertThat(firstSubmittedManualResult.getParticipation()).isEqualTo(studentParticipation);
    // verify that the relationship between student participation,
    var databaseRelationshipStateOfResultsOverParticipation = studentParticipationRepository.findWithEagerLegalSubmissionsAndResultsAssessorsById(studentParticipation.getId());
    assertThat(databaseRelationshipStateOfResultsOverParticipation).isPresent();
    var fetchedParticipation = databaseRelationshipStateOfResultsOverParticipation.get();
    assertThat(fetchedParticipation.getSubmissions()).hasSize(1);
    assertThat(fetchedParticipation.findLatestSubmission()).contains(submissionWithoutFirstAssessment);
    assertThat(fetchedParticipation.findLatestLegalResult()).isEqualTo(firstSubmittedManualResult);
    var databaseRelationshipStateOfResultsOverSubmission = studentParticipationRepository.findAllWithEagerSubmissionsAndEagerResultsAndEagerAssessorByExerciseId(exercise.getId());
    assertThat(databaseRelationshipStateOfResultsOverSubmission).hasSize(1);
    fetchedParticipation = databaseRelationshipStateOfResultsOverSubmission.get(0);
    assertThat(fetchedParticipation.getSubmissions()).hasSize(1);
    assertThat(fetchedParticipation.findLatestSubmission()).isPresent();
    // it should contain the lock for the manual result
    assertThat(fetchedParticipation.findLatestSubmission().get().getResults()).hasSize(1);
    assertThat(fetchedParticipation.findLatestSubmission().get().getLatestResult()).isEqualTo(firstSubmittedManualResult);
    // SECOND ROUND OF CORRECTION
    database.changeUser("tutor2");
    LinkedMultiValueMap<String, String> paramsSecondCorrection = new LinkedMultiValueMap<>();
    paramsSecondCorrection.add("lock", "true");
    paramsSecondCorrection.add("correction-round", "1");
    final var submissionWithoutSecondAssessment = request.get("/api/exercises/" + exerciseWithParticipation.getId() + "/text-submission-without-assessment", HttpStatus.OK, TextSubmission.class, paramsSecondCorrection);
    // verify that the submission is not new
    assertThat(submissionWithoutSecondAssessment).isEqualTo(submission);
    // verify that the lock has been set
    assertThat(submissionWithoutSecondAssessment.getLatestResult()).isNotNull();
    assertThat(submissionWithoutSecondAssessment.getLatestResult().getAssessor().getLogin()).isEqualTo("tutor2");
    assertThat(submissionWithoutSecondAssessment.getLatestResult().getAssessmentType()).isEqualTo(AssessmentType.MANUAL);
    assertThat(submissionWithoutSecondAssessment.getLatestResult().getFeedbacks()).isNotEmpty();
    // verify that the relationship between student participation,
    databaseRelationshipStateOfResultsOverParticipation = studentParticipationRepository.findWithEagerLegalSubmissionsAndResultsAssessorsById(studentParticipation.getId());
    assertThat(databaseRelationshipStateOfResultsOverParticipation).isPresent();
    fetchedParticipation = databaseRelationshipStateOfResultsOverParticipation.get();
    assertThat(fetchedParticipation.getSubmissions()).hasSize(1);
    assertThat(fetchedParticipation.findLatestSubmission()).contains(submissionWithoutSecondAssessment);
    assertThat(fetchedParticipation.getResults().stream().filter(x -> x.getCompletionDate() == null).findFirst()).contains(submissionWithoutSecondAssessment.getLatestResult());
    databaseRelationshipStateOfResultsOverSubmission = studentParticipationRepository.findAllWithEagerSubmissionsAndEagerResultsAndEagerAssessorByExerciseId(exercise.getId());
    assertThat(databaseRelationshipStateOfResultsOverSubmission).hasSize(1);
    fetchedParticipation = databaseRelationshipStateOfResultsOverSubmission.get(0);
    assertThat(fetchedParticipation.getSubmissions()).hasSize(1);
    assertThat(fetchedParticipation.findLatestSubmission()).isPresent();
    assertThat(fetchedParticipation.findLatestSubmission().get().getResults()).hasSize(2);
    assertThat(fetchedParticipation.findLatestSubmission().get().getLatestResult()).isEqualTo(submissionWithoutSecondAssessment.getLatestResult());
    Feedback secondCorrectionFeedback = new Feedback();
    secondCorrectionFeedback.setDetailText("asfd");
    secondCorrectionFeedback.setCredits(10.0);
    secondCorrectionFeedback.setPositive(true);
    submissionWithoutSecondAssessment.getLatestResult().getFeedbacks().add(secondCorrectionFeedback);
    textAssessmentDTO.setFeedbacks(submissionWithoutSecondAssessment.getLatestResult().getFeedbacks());
    // assess submission and submit
    Result secondSubmittedManualResult = request.postWithResponseBody("/api/participations/" + submissionWithoutFirstAssessment.getParticipation().getId() + "/results/" + submissionWithoutSecondAssessment.getLatestResult().getId() + "/submit-text-assessment", textAssessmentDTO, Result.class, HttpStatus.OK);
    assertThat(secondSubmittedManualResult).isNotNull();
    // check if feedback copy was set correctly
    assertThat(secondSubmittedManualResult.getFeedbacks()).isNotEmpty();
    // make sure that new result correctly appears after the assessment for second correction round
    LinkedMultiValueMap<String, String> paramsGetAssessedCR2 = new LinkedMultiValueMap<>();
    paramsGetAssessedCR2.add("assessedByTutor", "true");
    paramsGetAssessedCR2.add("correction-round", "1");
    assessedSubmissionList = request.getList("/api/exercises/" + exerciseWithParticipation.getId() + "/text-submissions", HttpStatus.OK, TextSubmission.class, paramsGetAssessedCR2);
    assertThat(assessedSubmissionList).hasSize(1);
    assertThat(assessedSubmissionList.get(0).getId()).isEqualTo(submissionWithoutSecondAssessment.getId());
    assertThat(assessedSubmissionList.get(0).getResultForCorrectionRound(1)).isEqualTo(secondSubmittedManualResult);
    // make sure that they do not appear for the first correction round as the tutor only assessed the second correction round
    LinkedMultiValueMap<String, String> paramsGetAssessedCR1 = new LinkedMultiValueMap<>();
    paramsGetAssessedCR1.add("assessedByTutor", "true");
    paramsGetAssessedCR1.add("correction-round", "0");
    assessedSubmissionList = request.getList("/api/exercises/" + exerciseWithParticipation.getId() + "/text-submissions", HttpStatus.OK, TextSubmission.class, paramsGetAssessedCR1);
    assertThat(assessedSubmissionList).isEmpty();
    // Student should not have received a result over WebSocket as manual correction is ongoing
    verify(messagingTemplate, never()).convertAndSendToUser(notNull(), eq(Constants.NEW_RESULT_TOPIC), isA(Result.class));
}

Example 85 with ExerciseGroup

use of de.tum.in.www1.artemis.domain.exam.ExerciseGroup in project ArTEMiS by ls1intum.

the class TextAssessmentIntegrationTest method getDataForTextEditor_BeforeExamPublishDate_Forbidden.

@Test
@WithMockUser(username = "student1", roles = "USER")
public void getDataForTextEditor_BeforeExamPublishDate_Forbidden() throws Exception {
    // create exam
    Exam exam = database.addExamWithExerciseGroup(course, true);
    exam.setStartDate(now().minusHours(2));
    exam.setEndDate(now().minusHours(1));
    exam.setVisibleDate(now().minusHours(3));
    exam.setPublishResultsDate(now().plusHours(3));
    // creating exercise
    ExerciseGroup exerciseGroup = exam.getExerciseGroups().get(0);
    TextExercise textExercise = ModelFactory.generateTextExerciseForExam(exerciseGroup);
    exerciseGroup.addExercise(textExercise);
    exerciseGroupRepository.save(exerciseGroup);
    textExercise = exerciseRepo.save(textExercise);
    examRepository.save(exam);
    TextSubmission textSubmission = ModelFactory.generateTextSubmission("Some text", Language.ENGLISH, true);
    textSubmission = database.saveTextSubmissionWithResultAndAssessor(textExercise, textSubmission, "student1", "tutor1");
    request.get("/api/text-editor/" + textSubmission.getParticipation().getId(), HttpStatus.FORBIDDEN, Participation.class);
}