Ai written student tests

src/test/java/com/example/demo/project/ProjectRepositoryTest.java

@@ -7,13 +7,15 @@
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 
-@ExtendWith(MockitoExtension.class)
+@DataJpaTest
 class ProjectRepositoryTest {
 
-    @Mock
+    @Autowired
     private ProjectRepository projectRepository;
 
     @AfterEach
@@ -23,12 +25,18 @@ void tearDown() {
 
     @Test
     void itShouldCheckWhenProjectTitleExists() {
-        //TODO implement test
+        Project project = new Project();
+        String title = "title";
+        project.setTitle(title);
+        assertThat(projectRepository.selectExistsProject(title)).isFalse();
+        projectRepository.save(project);
+        assertThat(projectRepository.selectExistsProject(title)).isTrue();
     }
 
     @Test
     void itShouldCheckWhenProjectTitleDoesNotExists() {
-        //TODO implement test
+        String title = "title";
+        assertThat(projectRepository.selectExistsProject(title)).isFalse();
     }
 
 }

src/test/java/com/example/demo/project/ProjectServiceTest.java

@@ -1,29 +1,27 @@
 package com.example.demo.project;
 
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
 import com.example.demo.project.exception.BadRequestException;
-import com.example.demo.student.Gender;
 import com.example.demo.student.Student;
 import com.example.demo.student.StudentRepository;
-
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.*;
-
 
 @ExtendWith(MockitoExtension.class)
 class ProjectServiceTest {
@@ -41,22 +39,44 @@ void setUp() {
 
     @Test
     public void canGetAllProjects() {
-        //TODO implement test
+        List<Project> projects = new ArrayList<>();
+        projects.add(new Project());
+        projects.add(new Project());
+        projects.add(new Project());
+        when(projectRepository.findAll()).thenReturn(projects);
+        assertEquals(projects, projectService.getAllProjects());
     }
 
     @Test
     public void testAddProject() {
-        //TODO implement test
+        Project project = new Project();
+        when(projectRepository.save(any())).thenReturn(project);
+        projectService.addProject(project);
+        verify(projectRepository, times(1)).save(project);
     }
 
     @Test
     void willThrowWhenTitleIsTaken() {
-        //TODO implement test
+        String title = "title";
+        Project project = new Project();
+        project.setTitle(title);
+        when(projectRepository.selectExistsProject(title)).thenReturn(Boolean.TRUE);
+        assertThatThrownBy(() -> projectService.addProject(project)).isInstanceOf(BadRequestException.class);
+        verify(projectRepository, never()).save(project);
     }
 
     @Test
     void canAddStudentToProject() {
-        //TODO implement test
+        Long projectId = 1L;
+        Long studentId = 2L;
+        Project project = new Project();
+        Student student = new Student();
+        student.setId(studentId);
+        when(projectRepository.findById(eq(projectId))).thenReturn(Optional.of(project));
+        when(studentRepository.findById(eq(studentId))).thenReturn(Optional.of(student));
+        projectService.addStudentToProject(projectId, studentId);
+        verify(projectRepository, times(1)).save(project);
+        assertThat(project.getStudent()).isEqualTo(student);
     }
 
 

src/test/java/com/example/demo/student/StudentRepositoryTest.java

@@ -1,14 +1,12 @@
 package com.example.demo.student;
 
-import com.example.demo.project.Project;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
 
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-import static org.mockito.Mockito.verify;
-
 @DataJpaTest
 class StudentRepositoryTest {
 
@@ -22,22 +20,20 @@ void tearDown() {
 
     @Test
     void itShouldCheckWhenStudentEmailExists() {
-        //TODO fix test
         String email = "mail@test.com";
         Student student = new Student();
-        student.setEmail(EMAIL);
-        studentRepository.save(new Student());
+        student.setEmail(email);
+        student.setName("TEST");
+        student.setGender(Gender.OTHER);
         assertThat(studentRepository.selectExistsEmail(email)).isFalse();
+        studentRepository.save(student);
+        assertThat(studentRepository.selectExistsEmail(email)).isTrue();
     }
 
     @Test
     void itShouldCheckWhenStudentEmailDoesNotExists() {
-        //TODO fix test
         String email = "mail@test.com";
-        Student student = new Student();
-        student.setEmail(EMAIL);
         assertThat(studentRepository.selectExistsEmail(email)).isFalse();
-        verify(studentRepository).selectExistsEmail(email);
     }
 
 }

src/test/java/com/example/demo/student/StudentServiceTest.java

@@ -16,6 +16,7 @@
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.BDDMockito.given;
@@ -25,7 +26,8 @@
 @ExtendWith(MockitoExtension.class)
 class StudentServiceTest {
 
-    @Mock private StudentRepository repository;
+    @Mock
+    private StudentRepository repository;
     private StudentService studentService;
 
     @BeforeEach
@@ -39,18 +41,19 @@ void canGetAllStudents() {
         List<Student> students = new ArrayList<>();
         students.add(new Student());
         when(repository.findAll()).thenReturn(students);
-        assertEquals(students, service.getAllStudent());
+        assertEquals(students, studentService.getAllStudents());
     }
 
     @Test
     public void testAddStudent() {
         //TODO fix test
         Student student = new Student();
-        student.setEmail(EMAIL);
-        when(repository.selectExistsStudent(EMAIL)).thenReturn(Boolean.TRUE);
+        String email = "mail@test.com";
+        student.setEmail(email);
+        when(repository.selectExistsEmail(email)).thenReturn(Boolean.FALSE);
         studentService.addStudent(student);
         ArgumentCaptor<Student> studentArgumentCaptor = ArgumentCaptor.forClass(Student.class);
-        verify(repository).save(studentArgumentCaptor.capture());
+        verify(repository, times(1)).save(studentArgumentCaptor.capture());
         Student capturedStudent = studentArgumentCaptor.getValue();
         assertThat(capturedStudent).isEqualTo(student);
     }
@@ -59,9 +62,10 @@ public void testAddStudent() {
     void willThrowWhenTitleIsTaken() {
         //TODO fix test
         Student student = new Student();
-        student.setEmail(EMAIL);
-        given(repository.selectExistsStudent(anyString())).willReturn(Boolean.TRUE);
-        assertThatThrownBy(() -> studentService.addStudent(new Student())).isInstanceOf(BadRequestException.class);
+        String email = "mail@test.com";
+        student.setEmail(email);
+        when(repository.selectExistsEmail(anyString())).thenReturn(Boolean.TRUE);
+        assertThatThrownBy(() -> studentService.addStudent(student)).isInstanceOf(BadRequestException.class);
         verify(repository, never()).save(any());
     }
 
@@ -70,7 +74,7 @@ void willThrowWhenDeleteStudentNotFound() {
         //TODO fix test
         long id = 10;
         given(repository.existsById(id)).willReturn(false);
-        assertThatThrownBy(() -> studentService.deleteStudent(10L)).isInstanceOf(StudentNotFoundException.class);
+        assertThatThrownBy(() -> studentService.deleteStudent(id)).isInstanceOf(StudentNotFoundException.class);
         verify(repository, never()).deleteById(any());
     }
 
@@ -79,8 +83,8 @@ void canDeleteStudent() {
         //TODO fix test
         long id = 10;
         given(repository.existsById(id)).willReturn(true);
-        service.deleteStudent(1L);
-        verify(repository).deleteById(id);
+        studentService.deleteStudent(id);
+        verify(repository, times(1)).deleteById(id);
     }