Fix ExerciseFacadeTest

application/model/src/main/java/org/fuseri/model/dto/exercise/QuestionDto.java

@@ -3,7 +3,9 @@ package org.fuseri.model.dto.exercise;
 import jakarta.validation.Valid;
 import jakarta.validation.constraints.NotBlank;
 import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 import lombok.Setter;
 import org.fuseri.model.dto.common.DomainObjectDto;
 
@@ -12,6 +14,8 @@ import java.util.Objects;
 
 @Getter
 @Setter
+@AllArgsConstructor
+@NoArgsConstructor
 public class QuestionDto extends DomainObjectDto {
 
     @NotBlank

application/module-exercise/src/test/java/org/fuseri/moduleexercise/question/QuestionFacadeTest.java

 package org.fuseri.moduleexercise.question;
 
 
+import org.fuseri.model.dto.exercise.AnswerDto;
+import org.fuseri.model.dto.exercise.AnswerInQuestionCreateDto;
 import org.fuseri.model.dto.exercise.QuestionCreateDto;
 import org.fuseri.model.dto.exercise.QuestionDto;
 import org.fuseri.model.dto.exercise.QuestionUpdateDto;
+import org.fuseri.moduleexercise.answer.Answer;
+import org.fuseri.moduleexercise.answer.AnswerMapper;
 import org.fuseri.moduleexercise.answer.AnswerService;
 import org.fuseri.moduleexercise.exercise.Exercise;
-import org.fuseri.moduleexercise.exercise.ExerciseService;
 import org.junit.jupiter.api.Test;
 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.ArrayList;
-import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -22,91 +26,100 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 @SpringBootTest
-public class QuestionFacadeTest {
-    private final QuestionDto questionDto = new QuestionDto();
-
-    private final QuestionCreateDto questionCreateDto = new QuestionCreateDto("name",1L,new ArrayList<>());
-
-    private final QuestionUpdateDto questionUpdateDto = QuestionUpdateDto.builder().build();
+class QuestionFacadeTest {
 
-    private final Exercise exercise = new Exercise();
-    private final Question question = new Question("text",new HashSet<>(),exercise);
-
-    @MockBean
-    QuestionRepository repository;
     @Autowired
-    QuestionFacade facade;
+    QuestionFacade questionFacade;
 
     @MockBean
-    QuestionService service;
+    QuestionService questionService;
 
     @MockBean
     AnswerService answerService;
 
     @MockBean
-    QuestionMapper mapper;
-
+    QuestionMapper questionMapper;
 
     @MockBean
-    ExerciseService exerciseService;
-//
-//    @MockBean
-//    QuestionMapper mapper;
+    AnswerMapper answerMapper;
+
+    private final QuestionDto questionDto = new QuestionDto();
+
+    private final QuestionCreateDto questionCreateDto = new QuestionCreateDto("name", 1L, new ArrayList<>());
+
+    private final QuestionUpdateDto questionUpdateDto = QuestionUpdateDto.builder().build();
+
+    private final Exercise exercise = new Exercise();
+
+    private final Question question = new Question("text", new HashSet<>(), exercise);
+    Set<Answer> answers = new HashSet<>(List.of(new Answer("BA", true, question)));
 
     @Test
     void create() {
-        long id = 1;
-        when(exerciseService.find(id)).thenReturn(exercise);
-        when(mapper.fromCreateDto(questionCreateDto)).thenReturn(question);
-        when(service.create(question)).thenReturn(question);
-        when(mapper.toDto(question)).thenReturn(questionDto);
+        when(questionMapper.fromCreateDto(questionCreateDto)).thenReturn(question);
+        when(questionService.create(question)).thenReturn(question);
+        when(questionMapper.toDto(question)).thenReturn(questionDto);
 
-        QuestionDto actualDto = facade.create(questionCreateDto);
+        QuestionDto actualDto = questionFacade.create(questionCreateDto);
 
         assertEquals(questionDto, actualDto);
-
     }
 
     @Test
-    void testFindById() {
-        Long id = 0L;
+    void find() {
+        long id = 1L;
 
-        when(service.find(id)).thenReturn(question);
-        when(mapper.toDto(question)).thenReturn(questionDto);
+        when(questionService.find(id)).thenReturn(question);
+        when(questionMapper.toDto(question)).thenReturn(questionDto);
 
-        QuestionDto actualDto = facade.find(id);
+        QuestionDto actualDto = questionFacade.find(id);
 
         assertNotNull(actualDto);
         assertEquals(questionDto, actualDto);
     }
 
-
-
-
     @Test
-    void update() {
-        Long id = 1L;
-        when(repository.existsById(id)).thenReturn(true);
-//        when(repository.find)
-        when(service.find(id)).thenReturn(question);
-        when(mapper.fromCreateDto(questionCreateDto)).thenReturn(question);
-        when(service.update(question)).thenReturn(question);
-        when(mapper.toDto(question)).thenReturn(questionDto);
-        when(mapper.fromUpdateDto(questionUpdateDto)).thenReturn(question);
-        when(answerService.findAllByQuestionId(id)).thenReturn(Collections.emptyList());
-        QuestionDto actualDto = facade.update(id,questionUpdateDto);
-
+    void patchUpdate() {
+        long id = 1L;
+        when(questionMapper.fromUpdateDto(questionUpdateDto)).thenReturn(question);
+        when(questionService.patchUpdateWithoutAnswers(id, question)).thenReturn(question);
+        when(questionMapper.toDto(question)).thenReturn(questionDto);
+        QuestionDto actualDto = questionFacade.patchUpdate(id, questionUpdateDto);
 
         assertEquals(questionDto, actualDto);
     }
 
     @Test
     void testDelete() {
-        Long id = 1L;
-        when(service.find(id)).thenReturn(question);
+        long id = 1L;
+        when(questionService.find(id)).thenReturn(question);
+
+        questionFacade.delete(id);
+        verify(questionService).delete(id);
+    }
 
-        facade.delete(id);
-        verify(service).delete(id);
+    @Test
+    void getQuestionAnswers() {
+        long id = 1L;
+        List<Answer> answers = List.of(new Answer("BA", true, question));
+        List<AnswerDto> answerDtos = List.of(new AnswerDto("BA", true));
+        when(answerMapper.toDtoList(answers)).thenReturn(answerDtos);
+        when(answerService.findAllByQuestionId(id)).thenReturn(answers);
+        var actualAnswers = questionFacade.getQuestionAnswers(id);
+        assertEquals(answerDtos, actualAnswers);
     }
 
+    @Test
+    void addAnswers() {
+        long id = 1L;
+        question.setAnswers(answers);
+        List<AnswerInQuestionCreateDto> answerDtos = List.of(new AnswerInQuestionCreateDto("BA", true));
+        QuestionDto questionDtoAnswers = new QuestionDto(question.getText(), question.getExercise().getId(), List.of(new AnswerDto("BA", true)));
+
+        when(answerMapper.fromCreateDtoList(answerDtos)).thenReturn(answers);
+        when(questionService.addAnswers(id, answers)).thenReturn(question);
+        when(questionMapper.toDto(question)).thenReturn(questionDtoAnswers);
+        QuestionDto actualQuestionDto = questionFacade.addAnswers(id, answerDtos);
+        assertEquals(questionDtoAnswers, actualQuestionDto);
+    }
 }