Update Unit Tests

Add @BeforeEach
Add Parametarized

buildSrc/src/main/kotlin/studentmanagement.java-common-conventions.gradle.kts

@@ -12,6 +12,7 @@ repositories {
 
 dependencies {
     testImplementation("org.mockito:mockito-core:5.4.0")
+    testImplementation("org.mockito:mockito-junit-jupiter:5.4.0")
     testImplementation("org.junit.jupiter:junit-jupiter:5.9.1")
 }
 

core/src/test/java/studentmanagement/service/administrator/DefaultAdministratorServiceTest.java

 package studentmanagement.service.administrator;
 
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import studentmanagement.model.course.Course;
@@ -36,18 +37,19 @@ class DefaultAdministratorServiceTest {
     private final Teacher teacher = new Teacher(teacherId, teacherName, Degree.PHD);
     private final Course course = new Course(courseId, courseName, totalHours, teacher);
     private final Student student = new Student(studentId, studentName, age);
-    private final TeacherService teacherServiceMock;
-    private final AdministratorService administratorService;
-    private final StudentService studentServiceMock;
-    private final CourseService courseServiceMock;
-
+    private TeacherService teacherServiceMock;
+    private AdministratorService administratorService;
+    private StudentService studentServiceMock;
+    private CourseService courseServiceMock;
     private GradeService gradeServiceMock;
 
-    public DefaultAdministratorServiceTest() {
+    @BeforeEach
+    void setUpTestCase() {
         courseServiceMock = Mockito.mock(CourseService.class);
         teacherServiceMock = Mockito.mock(TeacherService.class);
         studentServiceMock = Mockito.mock(StudentService.class);
         gradeServiceMock = Mockito.mock(GradeService.class);
+
         administratorService = new DefaultAdministratorService(
             studentServiceMock,
             courseServiceMock,

core/src/test/java/studentmanagement/service/course/DefaultCourseServiceTest.java

 package studentmanagement.service.course;
 
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import studentmanagement.data.course.CourseRepository;
@@ -11,11 +12,12 @@ import studentmanagement.service.generic.exception.IDableDoesNotExistException;
 import studentmanagement.service.teacher.TeacherService;
 
 class DefaultCourseServiceTest {
-    CourseRepository mockCourseRepo;
-    CourseService courseService;
-    TeacherService mockTeacherService;
+    private CourseRepository mockCourseRepo;
+    private CourseService courseService;
+    private TeacherService mockTeacherService;
 
-    public DefaultCourseServiceTest() {
+    @BeforeEach
+    void setUpTestCase() {
         mockTeacherService = Mockito.mock(TeacherService.class);
         mockCourseRepo = Mockito.mock(CourseRepository.class);
         courseService = new DefaultCourseService(mockCourseRepo, mockTeacherService);

core/src/test/java/studentmanagement/service/generic/DefaultServiceTest.java

@@ -2,6 +2,7 @@ package studentmanagement.service.generic;
 
 
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import studentmanagement.data.student.StudentRepository;
@@ -16,13 +17,15 @@ class DefaultServiceTest {
     private final IdGenerator generator = IdGeneratorFactory.getInstance();
 
     private final long id = generator.getCurrentId();
+    private final String idString = Long.valueOf(id).toString();
     private final String name = "Filip";
     private final long age = 123;
     private final Student student = new Student(id, name, age);
-    private final StudentRepository mockStudentRepo;
-    private final Service<Student> studentService;
+    private StudentRepository mockStudentRepo;
+    private Service<Student> studentService;
 
-    public DefaultServiceTest() {
+    @BeforeEach
+    void setUpTestCase() {
         mockStudentRepo = Mockito.mock(StudentRepository.class);
         studentService = new DefaultService<>(mockStudentRepo);
     }
@@ -41,7 +44,7 @@ class DefaultServiceTest {
         Optional<Student> optionalStudent = Optional.of(student);
         Mockito.when(mockStudentRepo.get(id)).thenReturn(optionalStudent);
 
-        Student actual = studentService.get(id);
+        Student actual = studentService.get(idString);
 
         Assertions.assertEquals(student, actual, "Student was not found correctly");
     }
@@ -61,7 +64,7 @@ class DefaultServiceTest {
         Optional<Student> optionalStudent = Optional.of(student);
         Mockito.when(mockStudentRepo.remove(id)).thenReturn(optionalStudent);
 
-        Student actual = studentService.remove(id);
+        Student actual = studentService.remove(idString);
 
         Assertions.assertEquals(student, actual, "Student was not removed correctly");
     }

core/src/test/java/studentmanagement/service/grade/DefaultGradeServiceTest.java

 package studentmanagement.service.grade;
 
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 import org.mockito.Mockito;
 import studentmanagement.data.grade.GradeRepository;
 import studentmanagement.model.course.Course;
@@ -43,16 +45,18 @@ class DefaultGradeServiceTest {
     private final Course course = new Course(courseId, courseName, totalHours, teacher);
     private final Student student = new Student(studentId, studentName, age);
 
-    private final GradeRepository gradeRepositoryMock;
-    private final GradeService gradeService;
-    private final StudentService studentServiceMock;
-    private final CourseService courseServiceMock;
+    private GradeRepository gradeRepositoryMock;
+    private GradeService gradeService;
+    private StudentService studentServiceMock;
+    private CourseService courseServiceMock;
 
-    public DefaultGradeServiceTest() {
+    @BeforeEach
+    void setUpTestCase() {
         courseServiceMock = Mockito.mock(CourseService.class);
         studentServiceMock = Mockito.mock(StudentService.class);
         gradeRepositoryMock = Mockito.mock(GradeRepository.class);
         gradeService = new DefaultGradeService(gradeRepositoryMock, studentServiceMock, courseServiceMock);
+
     }
 
     @Test
@@ -331,36 +335,39 @@ class DefaultGradeServiceTest {
             "IDableDoesNotExistException expected");
     }
 
-    @Test
-    void average_GradeTable_Calculates_Correctly() {
-        GradeTable table = setUpTableFor(student, course);
-
-        Grade expected = new Grade("4.0");
-
-        Grade actual = gradeService.average(table);
-
-        Assertions.assertEquals(expected, actual, "Average not Calculated Properly");
-    }
-
-    private GradeTable setUpTableFor(Student student, Course course) {
+    @ParameterizedTest
+    @CsvSource(value =
+        {
+            "2.0, 4.0, 6.0, 4.0",
+        }
+    )
+    void average_GradeTable_Calculates_Correctly(
+        Grade grade1, Grade grade2, Grade grade3,
+        Grade expected
+        ) {
         GradeTable table = new GradeTable(student, course);
-        Grade grade1 = new Grade("2.0");
-        Grade grade2 = new Grade("4.0");
-        Grade grade3 = new Grade("6.0");
 
         table.add(grade1);
         table.add(grade2);
         table.add(grade3);
 
-        return table;
+        Grade actual = gradeService.average(table);
+
+        Assertions.assertEquals(expected, actual, "Average not Calculated Properly");
     }
 
-    @Test
-    void average_GradeTable_Collection_Calculates_Correctly() {
+    @ParameterizedTest
+    @CsvSource(value =
+        {
+            "2.0, 4.0, 6.0, 3.0, 5.0, 4.0, 4.0",
+        }
+    )
+    void average_GradeTable_Collection_Calculates_Correctly(
+        Grade grade1, Grade grade2, Grade grade3,
+        Grade grade4, Grade grade5, Grade grade6,
+        Grade expected
+    ) {
         GradeTable table1 = new GradeTable(student, course);
-        Grade grade1 = new Grade("2.0");
-        Grade grade2 = new Grade("4.0");
-        Grade grade3 = new Grade("6.0");
 
         table1.add(grade1);
         table1.add(grade2);
@@ -368,27 +375,30 @@ class DefaultGradeServiceTest {
 
         Course course2 = new Course(4, "Java2", 150, teacher);
         GradeTable table2 = new GradeTable(student, course2);
-        grade1 = new Grade("3.0");
-        grade2 = new Grade("5.0");
-        grade3 = new Grade("4.0");
 
-        table2.add(grade1);
-        table2.add(grade2);
-        table2.add(grade3);
-
-        Grade expected = new Grade("4.0");
+        table2.add(grade4);
+        table2.add(grade5);
+        table2.add(grade6);
 
         Grade actual = gradeService.average(List.of(table1, table2));
 
         Assertions.assertEquals(expected, actual, "Average not Calculated Properly");
     }
 
-    @Test
-    void getAverageGradeByStudent_Calculates_Correctly() {
+    @ParameterizedTest
+    @CsvSource(value =
+        {
+            "2.0, 4.0, 6.0, 3.0, 5.0, 4.0, 3.0, 4.0, 4.0, 2.0, 4.0, 5.0, 4.0, 3.67"
+        }
+    )
+    void getAverageGradeByStudent_Calculates_Correctly(
+        Grade grade1, Grade grade2, Grade grade3,
+        Grade grade4, Grade grade5, Grade grade6,
+        Grade grade7, Grade grade8, Grade grade9,
+        Grade grade10, Grade grade11, Grade grade12,
+        Grade expected1, Grade expected2
+    ) {
         GradeTable table1 = new GradeTable(student, course);
-        Grade grade1 = new Grade("2.0");
-        Grade grade2 = new Grade("4.0");
-        Grade grade3 = new Grade("6.0");
 
         table1.add(grade1);
         table1.add(grade2);
@@ -396,32 +406,23 @@ class DefaultGradeServiceTest {
 
         Course course2 = new Course(4, "Java2", 150, teacher);
         GradeTable table2 = new GradeTable(student, course2);
-        grade1 = new Grade("3.0");
-        grade2 = new Grade("5.0");
-        grade3 = new Grade("4.0");
 
-        table2.add(grade1);
-        table2.add(grade2);
-        table2.add(grade3);
+        table2.add(grade4);
+        table2.add(grade5);
+        table2.add(grade6);
 
         Student student2 = new Student(5, "Filip2", 21);
         GradeTable table3 = new GradeTable(student2, course);
-        grade1 = new Grade("3.0");
-        grade2 = new Grade("4.0");
-        grade3 = new Grade("4.0");
 
-        table3.add(grade1);
-        table3.add(grade2);
-        table3.add(grade3);
+        table3.add(grade7);
+        table3.add(grade8);
+        table3.add(grade9);
 
         GradeTable table4 = new GradeTable(student2, course2);
-        grade1 = new Grade("2.0");
-        grade2 = new Grade("4.0");
-        grade3 = new Grade("5.0");
 
-        table4.add(grade1);
-        table4.add(grade2);
-        table4.add(grade3);
+        table4.add(grade10);
+        table4.add(grade11);
+        table4.add(grade12);
 
         List<Student> students = List.of(student, student2);
         List<GradeTable> tables1 = List.of(table1, table2);
@@ -432,20 +433,28 @@ class DefaultGradeServiceTest {
         Mockito.when(gradeRepositoryMock.get(student2)).thenReturn(tables2);
 
         Collection<GradeEntry> expected = List.of(
-            new GradeEntry(student, new Grade("4.0")),
-            new GradeEntry(student2, new Grade("3.67"))
+            new GradeEntry(student, expected1),
+            new GradeEntry(student2, expected2)
         );
 
-        Assertions.assertEquals(expected, gradeService.getAverageGradeByStudent(),
+        Assertions.assertIterableEquals(expected, gradeService.getAverageGradeByStudent(),
             "Grades not calculated correctly");
     }
 
-    @Test
-    void getStudentsByCourseSortedByGrade_Calculates_Correctly() throws StudentAlreadyInCourseException {
+
+    @ParameterizedTest
+    @CsvSource(value =
+        {
+            "2.0, 4.0, 6.0, 6.0, 5.3, 5.4, 3.0, 4.0, 4.0, 2.0, 4.0, 5.0"
+        }
+    )
+    void getStudentsByCourseSortedByGrade_Calculates_Correctly(
+        Grade grade1, Grade grade2, Grade grade3,
+        Grade grade4, Grade grade5, Grade grade6,
+        Grade grade7, Grade grade8, Grade grade9,
+        Grade grade10, Grade grade11, Grade grade12
+    ) throws StudentAlreadyInCourseException {
         GradeTable table1 = new GradeTable(student, course);
-        Grade grade1 = new Grade("2.0");
-        Grade grade2 = new Grade("4.0");
-        Grade grade3 = new Grade("6.0");
 
         table1.add(grade1);
         table1.add(grade2);
@@ -453,32 +462,23 @@ class DefaultGradeServiceTest {
 
         Course course2 = new Course(4, "C#", 150, teacher);
         GradeTable table2 = new GradeTable(student, course2);
-        grade1 = new Grade("3.0");
-        grade2 = new Grade("5.0");
-        grade3 = new Grade("4.0");
 
-        table2.add(grade1);
-        table2.add(grade2);
-        table2.add(grade3);
+        table2.add(grade4);
+        table2.add(grade5);
+        table2.add(grade6);
 
         Student student2 = new Student(5, "Filip3", 21);
         GradeTable table3 = new GradeTable(student2, course);
-        grade1 = new Grade("3.0");
-        grade2 = new Grade("4.0");
-        grade3 = new Grade("4.0");
 
-        table3.add(grade1);
-        table3.add(grade2);
-        table3.add(grade3);
+        table3.add(grade7);
+        table3.add(grade8);
+        table3.add(grade9);
 
         GradeTable table4 = new GradeTable(student2, course2);
-        grade1 = new Grade("2.0");
-        grade2 = new Grade("4.0");
-        grade3 = new Grade("5.0");
 
-        table4.add(grade1);
-        table4.add(grade2);
-        table4.add(grade3);
+        table4.add(grade10);
+        table4.add(grade11);
+        table4.add(grade12);
 
         course.enroll(student);
         course.enroll(student2);
@@ -506,13 +506,17 @@ class DefaultGradeServiceTest {
             "Grades not calculated properly");
     }
 
-    @Test
-    void getAverageGradeByStudentForCourse_CalculatesCorrectly()
+    @ParameterizedTest
+    @CsvSource(value =
+        {
+            "2.0, 4.0, 6.0, 3.0, 5.0, 6.0, 4.0, 4.67",
+        }
+    )
+    void getAverageGradeByStudentForCourse_CalculatesCorrectly(Grade grade1, Grade grade2, Grade grade3,
+                                                               Grade grade4, Grade grade5, Grade grade6,
+                                                               Grade average1, Grade average2)
         throws StudentAlreadyInCourseException {
         GradeTable table1 = new GradeTable(student, course);
-        Grade grade1 = new Grade("2.0");
-        Grade grade2 = new Grade("4.0");
-        Grade grade3 = new Grade("6.0");
 
         table1.add(grade1);
         table1.add(grade2);
@@ -520,20 +524,17 @@ class DefaultGradeServiceTest {
 
         Student student2 = new Student(5, "Filip2", 21);
         GradeTable table3 = new GradeTable(student2, course);
-        grade1 = new Grade("3.0");
-        grade2 = new Grade("5.0");
-        grade3 = new Grade("6.0");
 
-        table3.add(grade1);
-        table3.add(grade2);
-        table3.add(grade3);
+        table3.add(grade4);
+        table3.add(grade5);
+        table3.add(grade6);
 
         course.enroll(student);
         course.enroll(student2);
 
         Collection<GradeEntry> expected = List.of(
-            new GradeEntry(student, new Grade("4.0")),
-            new GradeEntry(student2, new Grade("4.67"))
+            new GradeEntry(student, average1),
+            new GradeEntry(student2, average2)
         );
 
         Mockito.when(gradeRepositoryMock.get(student, course)).thenReturn(Optional.of(table1));
@@ -543,12 +544,19 @@ class DefaultGradeServiceTest {
             "Grades not calculated properly");
     }
 
-    @Test
-    void getAverageGradeForCourse_Calculates_Correctly() throws StudentAlreadyInCourseException {
+    @ParameterizedTest
+    @CsvSource(value =
+        {
+            "2.0, 4.0, 6.0, 3.0, 5.0, 6.0, 4.34",
+            "3.0, 3.0, 3.0, 5.0, 5.0, 5.0, 4.0"
+
+        }
+    )
+    void getAverageGradeForCourse_Calculates_Correctly(Grade grade1, Grade grade2, Grade grade3,
+                                                       Grade grade4, Grade grade5, Grade grade6,
+                                                       Grade average)
+        throws StudentAlreadyInCourseException {
         GradeTable table1 = new GradeTable(student, course);
-        Grade grade1 = new Grade("2.0");
-        Grade grade2 = new Grade("4.0");
-        Grade grade3 = new Grade("6.0");
 
         table1.add(grade1);
         table1.add(grade2);
@@ -556,13 +564,10 @@ class DefaultGradeServiceTest {
 
         Student student2 = new Student(5, "Filip2", 21);
         GradeTable table3 = new GradeTable(student2, course);
-        grade1 = new Grade("3.0");
-        grade2 = new Grade("5.0");
-        grade3 = new Grade("6.0");
 
-        table3.add(grade1);
-        table3.add(grade2);
-        table3.add(grade3);
+        table3.add(grade4);
+        table3.add(grade5);
+        table3.add(grade6);
 
         course.enroll(student);
         course.enroll(student2);
@@ -570,9 +575,8 @@ class DefaultGradeServiceTest {
         Mockito.when(gradeRepositoryMock.get(student, course)).thenReturn(Optional.of(table1));
         Mockito.when(gradeRepositoryMock.get(student2, course)).thenReturn(Optional.of(table3));
 
-        Grade expected = new Grade("4.34");
 
-        Assertions.assertEquals(expected, gradeService.getAverageGradeForCourse(course),
+        Assertions.assertEquals(average, gradeService.getAverageGradeForCourse(course),
             "Grade not calculated correctly");
     }
 }
\ No newline at end of file

core/src/test/java/studentmanagement/service/student/DefaultStudentServiceTest.java

 package studentmanagement.service.student;
 
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import studentmanagement.data.student.StudentRepository;
@@ -17,10 +18,11 @@ class DefaultStudentServiceTest {
     private final Student student = new Student(id, name, age);
     private final String ageString = "21";
 
-    private final StudentRepository mockStudentRepo;
-    private final StudentService studentService;
+    private StudentRepository mockStudentRepo;
+    private StudentService studentService;
 
-    public DefaultStudentServiceTest() {
+    @BeforeEach
+    void setUpTestCase() {
         mockStudentRepo = Mockito.mock(StudentRepository.class);
         studentService = new DefaultStudentService(mockStudentRepo);
     }

core/src/test/java/studentmanagement/service/teacher/DefaultTeacherServiceTest.java

 package studentmanagement.service.teacher;
 
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.Mockito;
 import studentmanagement.data.teacher.TeacherRepository;
@@ -11,11 +12,12 @@ import studentmanagement.service.id.generator.IdGenerator;
 import studentmanagement.service.id.generator.IdGeneratorFactory;
 
 class DefaultTeacherServiceTest {
-    IdGenerator generator = IdGeneratorFactory.getInstance();
-    TeacherRepository mockTeacherRepo;
-    TeacherService teacherService;
+    private final IdGenerator generator = IdGeneratorFactory.getInstance();
+    private TeacherRepository mockTeacherRepo;
+    private TeacherService teacherService;
 
-    public DefaultTeacherServiceTest() {
+    @BeforeEach
+    void setUpTestCase() {
         mockTeacherRepo = Mockito.mock(TeacherRepository.class);
         teacherService = new DefaultTeacherService(mockTeacherRepo);
     }