Init Service tests

src/test/java/cz/cvut/fit/tjv/seidlpet/semestralka/business/StudentServiceImplTest.java

+package cz.cvut.fit.tjv.seidlpet.semestralka.business;
+
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.StudentRepository;
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.entity.Student;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.BDDMockito;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+
+@SpringBootTest
+class StudentServiceImplTest {
+
+    @Autowired
+    private StudentService studentService;
+
+    @MockBean
+    private StudentRepository studentRepository;
+
+    private final Student student = new Student(1,"Test","Student",1.0);
+    private final List<Integer> ids = Arrays.asList(1,2);
+    private final List<Student> students = Arrays.asList(
+            new Student(1,"Test","Student",1.2),
+            new Student(2,"Test","Student",1.0)
+    );
+
+    @Test
+    void create() {
+        BDDMockito.given(studentRepository.save(student)).willReturn(student);
+        Assertions.assertEquals(student,studentService.create(student));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).save(student);
+    }
+
+    @Test
+    void findByIds() {
+        BDDMockito.given(studentRepository.findAllById(ids)).willReturn(students);
+        Assertions.assertEquals(students,studentService.findByIds(ids));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findAllById(ids);
+    }
+
+    @Test
+    void findById() {
+        BDDMockito.given(studentRepository.findById(student.getId())).willReturn(Optional.of(student));
+        Assertions.assertEquals(Optional.of(student),studentService.findById(student.getId()));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findById(student.getId());
+    }
+
+    @Test
+    void findAll() {
+        BDDMockito.given(studentRepository.findAll()).willReturn(students);
+        Assertions.assertEquals(students,studentService.findAll());
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findAll();
+    }
+
+    @Test
+    void findByGpaGreaterThan() {
+        List<Student> greaterGpaStudents = Arrays.asList(
+                new Student(3,"Test","Student",1.5),
+                new Student(4,"Test","Student",2.6)
+        );
+        BDDMockito.given(studentRepository.findByGpaGreaterThan(1.2)).willReturn(greaterGpaStudents);
+        Assertions.assertEquals(greaterGpaStudents,studentService.findByGpaGreaterThan(1.2));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findByGpaGreaterThan(1.2);
+
+    }
+
+    @Test
+    void findByGpaLessThan() {
+        List<Student> lessGpaStudents = Arrays.asList(
+                new Student(2,"Test","Student",1.0),
+                new Student(3,"Test","Student",1.5),
+                new Student(4,"Test","Student",2.6)
+        );
+        BDDMockito.given(studentRepository.findByGpaGreaterThan(3)).willReturn(lessGpaStudents);
+        Assertions.assertEquals(lessGpaStudents,studentService.findByGpaGreaterThan(3));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findByGpaGreaterThan(3);
+    }
+
+    @Test
+    void findAllByFirstName() {
+        BDDMockito.given(studentRepository.findAllByFirstName("Test")).willReturn(students);
+        Assertions.assertEquals(students,studentService.findAllByFirstName("Test"));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findAllByFirstName("Test");
+    }
+
+    @Test
+    void findAllByLastName() {
+        BDDMockito.given(studentRepository.findAllByFirstName("Student")).willReturn(students);
+        Assertions.assertEquals(students,studentService.findAllByFirstName("Student"));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findAllByFirstName("Student");
+    }
+
+    @Test
+    void update() {
+        Student newStudent = new Student(1,"Test","Student",2.2);
+        BDDMockito.given(studentRepository.findById(student.getId())).willReturn(Optional.of(student));
+        BDDMockito.given(studentRepository.save(newStudent)).willReturn(newStudent);
+        Assertions.assertEquals(newStudent,studentService.update(student.getId(),newStudent));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).save(newStudent);
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findById(student.getId());
+    }
+
+    /*
+    Todo: test delete & deleteById
+
+    @Test
+    void delete() { }
+
+    @Test
+    void deleteById() { }
+     */
+}
\ No newline at end of file

src/test/java/cz/cvut/fit/tjv/seidlpet/semestralka/business/SubjectServiceImplTest.java

+package cz.cvut.fit.tjv.seidlpet.semestralka.business;
+
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.StudentRepository;
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.SubjectRepository;
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.TeacherRepository;
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.entity.Student;
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.entity.Subject;
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.entity.Teacher;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.BDDMockito;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+@SpringBootTest
+class SubjectServiceImplTest {
+
+    @Autowired
+    private SubjectService subjectService;
+
+    @MockBean
+    private SubjectRepository subjectRepository;
+
+    @MockBean
+    private StudentRepository studentRepository;
+
+    @MockBean
+    private TeacherRepository teacherRepository;
+
+    private final List<Student> students = Arrays.asList(
+            new Student(1,"Test","Student",1.2),
+            new Student(2,"Test","Student",3.3),
+            new Student(3,"Test","Student",2.5)
+    );
+    private final List<Integer> studentIds = Arrays.asList(1,2,3);
+    private final Teacher teacher = new Teacher(
+            1,"Test","Teacher"
+    );
+    private final Subject subject = new Subject(
+            1,"Test","CZ",teacher,students
+    );
+    private final List<Subject> subjects = Arrays.asList(
+            new Subject(1,"Test","CZ",teacher,students),
+            new Subject(1,"Test 2","SK",teacher,students)
+    );
+
+
+/*
+    Todo: Fix this test | Assertion expected entity but was: <null>
+    @Test
+    void create() {
+        BDDMockito.given(teacherRepository.findById(teacher.getId())).willReturn(Optional.of(teacher));
+        BDDMockito.given(studentRepository.findAllById(studentIds)).willReturn(students);
+        BDDMockito.given(subjectRepository.save(subject)).willReturn(subject);
+        SubjectCreateDTO subjectCreateDTO = new SubjectCreateDTO("Test","CZ",1,studentIds);
+        Assertions.assertSame(subject,subjectService.create(subjectCreateDTO));
+        Mockito.verify(studentRepository,Mockito.atLeastOnce()).findAllById(studentIds);
+        Mockito.verify(teacherRepository,Mockito.atLeastOnce()).findById(teacher.getId());
+        Mockito.verify(subjectRepository,Mockito.atLeastOnce()).save(subject);
+    }
+*/
+
+    @Test
+    void findById() {
+        BDDMockito.given(subjectRepository.findById(subject.getId())).willReturn(Optional.of(subject));
+        Assertions.assertEquals(Optional.of(subject),subjectService.findById(subject.getId()));
+        Mockito.verify(subjectRepository,Mockito.atLeastOnce()).findById(subject.getId());
+    }
+
+    @Test
+    void findAll() {
+        BDDMockito.given(subjectRepository.findAll()).willReturn(subjects);
+        Assertions.assertEquals(subjects,subjectService.findAll());
+        Mockito.verify(subjectRepository,Mockito.atLeastOnce()).findAll();
+    }
+
+    @Test
+    void findAllByTeacherId() {
+        BDDMockito.given(subjectRepository.findAllByTeacherId(teacher.getId())).willReturn(subjects);
+        Assertions.assertEquals(subjects,subjectService.findAllByTeacherId(teacher.getId()));
+        Mockito.verify(subjectRepository,Mockito.atLeastOnce()).findAllByTeacherId(teacher.getId());
+    }
+
+    @Test
+    void update() {
+        Subject newSubject = new Subject(
+                1,"Test","SK",teacher,students
+        );
+        BDDMockito.given(subjectRepository.findById(subject.getId())).willReturn(Optional.of(subject));
+        BDDMockito.given(subjectRepository.save(newSubject)).willReturn(newSubject);
+        Assertions.assertEquals(newSubject,subjectService.update(subject.getId(),newSubject));
+        Mockito.verify(subjectRepository,Mockito.atLeastOnce()).save(newSubject);
+        Mockito.verify(subjectRepository,Mockito.atLeastOnce()).findById(subject.getId());
+    }
+
+    /*
+    Todo: test delete & deleteById
+
+    @Test
+    void delete() { }
+
+    @Test
+    void deleteById() { }
+     */
+}
\ No newline at end of file

src/test/java/cz/cvut/fit/tjv/seidlpet/semestralka/business/TeacherServiceImplTest.java

+package cz.cvut.fit.tjv.seidlpet.semestralka.business;
+
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.TeacherRepository;
+import cz.cvut.fit.tjv.seidlpet.semestralka.data.entity.Teacher;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.BDDMockito;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+@SpringBootTest
+class TeacherServiceImplTest {
+
+    @Autowired
+    private TeacherService teacherService;
+
+    @MockBean
+    private TeacherRepository teacherRepository;
+
+    private final Teacher teacher = new Teacher(1,"Test","Teacher");
+    private final List<Teacher> teachers = Arrays.asList(
+            new Teacher(1,"Test","Teacher"),
+            new Teacher(2,"Test","Teacher")
+    );
+    @Test
+    void create() {
+        BDDMockito.given(teacherRepository.save(teacher)).willReturn(teacher);
+        Assertions.assertEquals(teacher,teacherService.create(teacher));
+        Mockito.verify(teacherRepository,Mockito.atLeastOnce()).save(teacher);
+    }
+
+    @Test
+    void findById() {
+        BDDMockito.given(teacherRepository.findById(teacher.getId())).willReturn(Optional.of(teacher));
+        Assertions.assertEquals(Optional.of(teacher),teacherService.findById(teacher.getId()));
+        Mockito.verify(teacherRepository,Mockito.atLeastOnce()).findById(teacher.getId());
+    }
+
+    @Test
+    void findAll() {
+        BDDMockito.given(teacherRepository.findAll()).willReturn(teachers);
+        Assertions.assertEquals(teachers,teacherService.findAll());
+        Mockito.verify(teacherRepository,Mockito.atLeastOnce()).findAll();
+    }
+
+
+    @Test
+    void findAllByFirstName() {
+        BDDMockito.given(teacherRepository.findAllByFirstName("Test")).willReturn(teachers);
+        Assertions.assertEquals(teachers,teacherService.findAllByFirstName("Test"));
+        Mockito.verify(teacherRepository,Mockito.atLeastOnce()).findAllByFirstName("Test");
+    }
+
+    @Test
+    void findAllByLastName() {
+        BDDMockito.given(teacherRepository.findAllByFirstName("Teacher")).willReturn(teachers);
+        Assertions.assertEquals(teachers,teacherService.findAllByFirstName("Teacher"));
+        Mockito.verify(teacherRepository,Mockito.atLeastOnce()).findAllByFirstName("Teacher");
+    }
+
+    @Test
+    void update() {
+        Teacher newTeacher = new Teacher(1,"Test","Teacher");
+        BDDMockito.given(teacherRepository.findById(teacher.getId())).willReturn(Optional.of(teacher));
+        BDDMockito.given(teacherRepository.save(newTeacher)).willReturn(newTeacher);
+        Assertions.assertEquals(newTeacher,teacherService.update(teacher.getId(),newTeacher));
+        Mockito.verify(teacherRepository,Mockito.atLeastOnce()).save(newTeacher);
+    }
+
+    /* 
+    Todo: test delete & deleteById
+    
+    @Test
+    void delete() { }
+
+    @Test
+    void deleteById() { }
+     */
+}
\ No newline at end of file