Exam mode: Generate student exam on demand if student is registered for the exam

src/main/java/de/tum/in/www1/artemis/service/exam/ExamAccessService.java

@@ -84,17 +84,19 @@ public StudentExam getExamInCourseElseThrow(Long courseId, Long examId) {
             studentExam = optionalStudentExam.get();
         }
         else {
-            // Only Test Exams can be self-created by the user.
             Exam examWithExerciseGroupsAndExercises = examRepository.findWithExerciseGroupsAndExercisesByIdOrElseThrow(examId);
+            // Generate a student exam if exam is a test exam or of student is registered for a normal exam
+            if (examWithExerciseGroupsAndExercises.isTestExam() || examRegistrationService.isUserRegisteredForExam(examId, currentUser.getId())) {
+                studentExam = studentExamService.generateIndividualStudentExam(examWithExerciseGroupsAndExercises, currentUser);
+                // For the start of the exam, the exercises are not needed. They are later loaded via StudentExamResource
+                studentExam.setExercises(null);
 
-            if (!examWithExerciseGroupsAndExercises.isTestExam()) {
+            }
+            else {
                 // We skip the alert since this can happen when a tutor sees the exam card or the user did not participate yet is registered for the exam
-                throw new BadRequestAlertException("The requested Exam is no test exam and thus no student exam can be created", ENTITY_NAME,
-                        "StudentExamGenerationOnlyForTestExams", true);
+                throw new BadRequestAlertException("Cannot generate student exam. Student is not registered for the exam", ENTITY_NAME,
+                        "StudentExamGenerationOnlyForRegisteredStudents", true);
             }
-            studentExam = studentExamService.generateTestExam(examWithExerciseGroupsAndExercises, currentUser);
-            // For the start of the exam, the exercises are not needed. They are later loaded via StudentExamResource
-            studentExam.setExercises(null);
         }
 
         Exam exam = studentExam.getExam();

src/main/java/de/tum/in/www1/artemis/service/exam/StudentExamService.java

@@ -797,16 +797,18 @@ public void setUpExerciseParticipationsAndSubmissions(StudentExam studentExam, L
     }
 
     /**
-     * Generates a new test exam for the student and stores it in the database
+     * Generates a new individual StudentExam for the student and stores it in the database
      *
-     * @param exam    the exam with loaded exercise groups and exercises for which the StudentExam should be created
-     * @param student the corresponding student
-     * @return a StudentExam for the student and exam
+     * @param exam    with eagerly loaded users, exerciseGroups and exercises loaded
+     * @param student the student for which the StudentExam should be created
+     * @return the generated StudentExam
      */
-    public StudentExam generateTestExam(Exam exam, User student) {
+    public StudentExam generateIndividualStudentExam(Exam exam, User student) {
         // To create a new StudentExam, the Exam with loaded ExerciseGroups and Exercises is needed
         long start = System.nanoTime();
-        StudentExam studentExam = generateIndividualStudentExam(exam, student);
+        HashSet<User> userHashSet = new HashSet<>();
+        userHashSet.add(student);
+        StudentExam studentExam = studentExamRepository.createRandomStudentExams(exam, userHashSet, examQuizQuestionsGenerator).getFirst();
         // we need to break a cycle for the serialization
         studentExam.getExam().setExerciseGroups(null);
         studentExam.getExam().setStudentExams(null);
@@ -816,20 +818,6 @@ public StudentExam generateTestExam(Exam exam, User student) {
         return studentExam;
     }
 
-    /**
-     * Generates an individual StudentExam
-     *
-     * @param exam    with eagerly loaded users, exerciseGroups and exercises loaded
-     * @param student the student for which the StudentExam should be created
-     * @return the generated StudentExam
-     */
-    private StudentExam generateIndividualStudentExam(Exam exam, User student) {
-        // StudentExams are saved in the called method
-        HashSet<User> userHashSet = new HashSet<>();
-        userHashSet.add(student);
-        return studentExamRepository.createRandomStudentExams(exam, userHashSet, examQuizQuestionsGenerator).getFirst();
-    }
-
     /**
      * Generates the student exams randomly based on the exam configuration and the exercise groups
      * Important: the passed exams needs to include the registered users, exercise groups and exercises (eagerly loaded)

src/test/java/de/tum/in/www1/artemis/service/exam/ExamAccessServiceTest.java

@@ -1,6 +1,7 @@
 package de.tum.in.www1.artemis.service.exam;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.InstanceOfAssertFactories.type;
 
@@ -9,6 +10,7 @@
 import java.util.Set;
 
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -22,9 +24,12 @@
 import de.tum.in.www1.artemis.domain.exam.ExamUser;
 import de.tum.in.www1.artemis.domain.exam.ExerciseGroup;
 import de.tum.in.www1.artemis.domain.exam.StudentExam;
+import de.tum.in.www1.artemis.domain.quiz.QuizExercise;
 import de.tum.in.www1.artemis.exam.ExamUtilService;
+import de.tum.in.www1.artemis.exercise.quiz.QuizExerciseFactory;
 import de.tum.in.www1.artemis.repository.ExamRepository;
 import de.tum.in.www1.artemis.repository.ExamUserRepository;
+import de.tum.in.www1.artemis.repository.ExerciseRepository;
 import de.tum.in.www1.artemis.repository.StudentExamRepository;
 import de.tum.in.www1.artemis.repository.UserRepository;
 import de.tum.in.www1.artemis.security.Role;
@@ -60,6 +65,9 @@ class ExamAccessServiceTest extends AbstractSpringIntegrationIndependentTest {
     @Autowired
     private ExamUtilService examUtilService;
 
+    @Autowired
+    private ExerciseRepository exerciseRepository;
+
     private Course course1;
 
     private Course course2;
@@ -123,11 +131,20 @@ void init() {
         examUser1 = examUserRepository.save(examUser1);
         testExam2.setExamUsers(Set.of(examUser1));
         exerciseGroup1 = exam1.getExerciseGroups().getFirst();
+        QuizExercise quiz = QuizExerciseFactory.generateQuizExerciseForExam(exerciseGroup1);
+        exerciseGroup1.addExercise(quiz);
+        exerciseRepository.save(quiz);
         exerciseGroup2 = exam2.getExerciseGroups().getFirst();
-        studentExam1 = examUtilService.addStudentExam(exam1);
+        studentExam1 = examUtilService.addStudentExamWithUser(exam1, student1);
         studentExam2 = examUtilService.addStudentExam(exam2);
         studentExamForTestExam1 = examUtilService.addStudentExamForTestExam(testExam1, student1);
         studentExamForTestExam2 = examUtilService.addStudentExamForTestExam(testExam2, student1);
+        ExamUser examUser2 = new ExamUser();
+        examUser2.setExam(exam1);
+        examUser2.setUser(student1);
+        examUser2 = examUserRepository.save(examUser2);
+        exam1.setExamUsers(Set.of(examUser2));
+        exam1 = examRepository.save(exam1);
     }
 
     @Test
@@ -332,10 +349,24 @@ void testCheckAndGetCourseAndExamAccessForConduction_examBelongsToCourse() {
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "student1", roles = "USER")
-    void testCheckAndGetCourseAndExamAccessForConduction_registeredUser() {
-        exam1.setExamUsers(Set.of());
+    void testCheckAndGetCourseAndExamAccessForConduction_notRegisteredUser() {
+        assertThatThrownBy(() -> examAccessService.getExamInCourseElseThrow(course1.getId(), exam2.getId())).isInstanceOf(BadRequestAlertException.class);
+    }
+
+    @Test
+    @WithMockUser(username = TEST_PREFIX + "student1", roles = "USER")
+    void testCheckAndGetCourseAndExamAccessForConduction_registeredUser_noStudentExamPresent() {
+        exam1.setStudentExams(Set.of());
         examRepository.save(exam1);
-        assertThatThrownBy(() -> examAccessService.getExamInCourseElseThrow(course1.getId(), exam1.getId())).isInstanceOf(BadRequestAlertException.class);
+        studentExamRepository.delete(studentExam1);
+        assertThatNoException().isThrownBy(() -> examAccessService.getExamInCourseElseThrow(course1.getId(), exam1.getId()));
+    }
+
+    @Test
+    @WithMockUser(username = TEST_PREFIX + "student1", roles = "USER")
+    void testCheckAndGetCourseAndExamAccessForConduction_registeredUser_studentExamPresent() {
+        StudentExam studentExam = examAccessService.getExamInCourseElseThrow(course1.getId(), exam1.getId());
+        Assertions.assertEquals(studentExam, studentExam1);
     }
 
     @Test
@@ -355,14 +386,6 @@ void testGetExamInCourseElseThrow_noCourseAccess() {
         assertThatThrownBy(() -> examAccessService.getExamInCourseElseThrow(course1.getId(), testExam1.getId())).isInstanceOf(AccessForbiddenException.class);
     }
 
-    @Test
-    @WithMockUser(username = TEST_PREFIX + "student1", roles = "USER")
-    void testGetExamInCourseElseThrow_realExam() {
-        assertThatThrownBy(() -> examAccessService.getExamInCourseElseThrow(course1.getId(), exam1.getId())).asInstanceOf(type(BadRequestAlertException.class))
-                .satisfies(error -> assertThat(error.getParameters().get("skipAlert")).isEqualTo(Boolean.TRUE));
-
-    }
-
     @Test
     @WithMockUser(username = TEST_PREFIX + "student1", roles = "USER")
     void testGetExamInCourseElseThrow_notVisible() {