Merge branch 'esting' into 'main'

feat: some tests

See merge request !104

backend/wedding_app_backend/src/main/java/org/example/wedding_app_backend/weddingGuest/service/WeddingGuestService.java

@@ -41,7 +41,9 @@ public class WeddingGuestService {
         return weddingGuestRepository.findById(id);
     }
 
-    public Optional<List<WeddingGuestEntity>> findAllWeddingGuestsThatFinishedQuiz(UUID id){return weddingGuestRepository.findAllByWeddingIdAndQuizFinishedTrue(id);}
+    public Optional<List<WeddingGuestEntity>> findAllWeddingGuestsThatFinishedQuiz(UUID id){
+        return weddingGuestRepository.findAllByWeddingIdAndQuizFinishedTrue(id);
+    }
 
 
     public void updateQuizPoints(WeddingGuestEntity guest, int score) throws IOException {

backend/wedding_app_backend/src/main/java/org/example/wedding_app_backend/weddingQuiz/controller/WeddingQuizController.java

@@ -41,6 +41,7 @@ public class WeddingQuizController {
                         .map(ResponseEntity::ok)
                         .orElse(ResponseEntity.notFound().build()))
                 .orElse(ResponseEntity.notFound().build());
+
     }
 
     @PatchMapping(path = "{weddingId}/{guestId}/games/quiz")

backend/wedding_app_backend/src/main/java/org/example/wedding_app_backend/weddingQuiz/service/WeddingQuizService.java

@@ -21,8 +21,6 @@ public class WeddingQuizService {
 
     private final WeddingQuizRepository weddingQuizRepository;
 
-    private final WeddingGuestRepository weddingGuestRepository;
-
     public void save(WeddingQuizEntity weddingQuizEntity) {
         weddingQuizRepository.save(weddingQuizEntity);
     }
@@ -32,4 +30,5 @@ public class WeddingQuizService {
         return weddingQuizRepository.findQuestionById(guest.getQuestionIndex(),weddingId,guest.getQuizSeed());
     }
 
+
 }

backend/wedding_app_backend/src/test/java/org/example/wedding_app_backend/api/controller/WeddingQuizControllerTests.java

+package org.example.wedding_app_backend.api.controller;
+
+import jakarta.transaction.Transactional;
+import org.assertj.db.api.Assertions;
+import org.assertj.db.type.Column;
+import org.assertj.db.type.Table;
+import org.example.wedding_app_backend.WeddingAppBackendApplication;
+import org.example.wedding_app_backend.initializer.DataInitializer;
+import org.example.wedding_app_backend.wedding.entity.WeddingEntity;
+import org.example.wedding_app_backend.wedding.repository.WeddingRepository;
+import org.example.wedding_app_backend.weddingGuest.entity.WeddingGuestEntity;
+import org.example.wedding_app_backend.weddingGuest.repository.WeddingGuestRepository;
+import org.example.wedding_app_backend.weddingImage.entity.WeddingImageEntity;
+import org.example.wedding_app_backend.weddingImage.repository.WeddingImageRepository;
+import org.example.wedding_app_backend.weddingQuiz.entity.WeddingQuizEntity;
+import org.example.wedding_app_backend.weddingQuiz.repository.WeddingQuizRepository;
+import org.intellij.lang.annotations.Language;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.security.test.context.support.WithMockUser;
+import org.springframework.test.web.servlet.MockMvc;
+
+import javax.sql.DataSource;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.assertj.db.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+@SpringBootTest(
+        webEnvironment = SpringBootTest.WebEnvironment.MOCK,
+        classes = WeddingAppBackendApplication.class
+)
+@AutoConfigureMockMvc
+public class WeddingQuizControllerTests {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+
+    @Autowired
+    private WeddingRepository weddingRepository;
+
+    @Autowired
+    private WeddingQuizRepository weddingQuizRepository;
+
+    @Autowired
+    private WeddingGuestRepository weddingGuestRepository;
+
+    @MockBean
+    private DataInitializer dataInitializer;//Disable data initialization
+
+    @Autowired
+    DataSource dataSource;
+
+    @AfterEach
+    void clean() {
+        weddingQuizRepository.deleteAll();
+        weddingGuestRepository.deleteAll();
+        weddingRepository.deleteAll();
+    }
+
+    @Test
+    void getWeddingQuestion_ShouldReturnQuestions_WhenExists() throws Exception {
+        WeddingEntity wedding_1 = WeddingEntity.builder()
+                .id(UUID.nameUUIDFromBytes("wedding_1".getBytes()))
+                .name("Wedding 1")
+                .eventStartDateTime(LocalDateTime.parse("2024-11-21T14:41"))
+                .build();
+        weddingRepository.save(wedding_1);
+
+        WeddingGuestEntity guest_1 = WeddingGuestEntity.builder()
+                .id(UUID.nameUUIDFromBytes("wedding_guest_1".getBytes()))
+                .questionIndex(0)
+                .quizSeed(1)
+                .wedding(wedding_1)
+                .build();
+        weddingGuestRepository.save(guest_1);
+
+        weddingQuizRepository.save(WeddingQuizEntity.builder()
+                .id(UUID.nameUUIDFromBytes("wedding_quiz_question_1".getBytes()))
+                .question("Test")
+                .answer1("Yes")
+                .answer2("No")
+                .answer3("Maybe")
+                .answer4("Never")
+                .wedding(wedding_1)
+                .build());
+
+        @Language("JSON")
+        String expected = """
+                  {
+                    "question": "Test",
+                    "answer1": "Yes",
+                    "answer2": "No",
+                    "answer3": "Maybe",
+                    "answer4": "Never"
+                  }
+                """;
+
+        mockMvc.perform(get("/api/weddings/{weddingId}/{guestId}/games/quiz",
+                        UUID.nameUUIDFromBytes("wedding_1".getBytes()),
+                        UUID.nameUUIDFromBytes("wedding_guest_1".getBytes()))
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+                .andExpect(content().json(expected, true));
+    }
+
+    @Test
+    void getWeddingGallery_ShouldReturnNotFound_WhenDoesNotExist() throws Exception {
+        mockMvc.perform(get("/api/weddings/{weddingId}/{guestId}/games/quiz",
+                        UUID.nameUUIDFromBytes("wedding_not_existing".getBytes()),
+                        UUID.nameUUIDFromBytes("wedding_guest_not_existing".getBytes()))
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNotFound())
+                .andExpect(content().string(""));
+    }
+
+    @Test
+    void updateWeddingGuestPoints_ShouldIncreasePointsAndIndex() throws Exception {
+        WeddingEntity wedding_1 = WeddingEntity.builder()
+                .id(UUID.nameUUIDFromBytes("wedding_1".getBytes()))
+                .name("Wedding 1")
+                .eventStartDateTime(LocalDateTime.parse("2024-11-21T14:41"))
+                .build();
+        weddingRepository.save(wedding_1);
+
+        WeddingGuestEntity guest_1 = WeddingGuestEntity.builder()
+                .id(UUID.nameUUIDFromBytes("wedding_guest_1".getBytes()))
+                .questionIndex(0)
+                .quizSeed(1)
+                .quizPoints(0)
+                .wedding(wedding_1)
+                .build();
+        weddingGuestRepository.save(guest_1);
+
+        mockMvc.perform(patch("/api/weddings/{weddingId}/{guestId}/games/quiz",
+                        UUID.nameUUIDFromBytes("wedding_1".getBytes()),
+                        UUID.nameUUIDFromBytes("wedding_guest_1".getBytes()))
+                        .content("{\"score\": 1}")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(content().string(""));
+
+        assertThat(new Table(dataSource, "wedding_guests"))
+                .row()
+                .column("quiz_Points").value().isEqualTo(1);
+
+        assertThat(new Table(dataSource, "wedding_guests"))
+                .row()
+                .column("question_Index").value().isEqualTo(1);
+
+        // Usuniecie relacji @ManyToMany żeby nie było błędu bazy
+        weddingGuestRepository.save(guest_1);
+    }
+
+
+}
+

backend/wedding_app_backend/src/test/java/org/example/wedding_app_backend/api/repository/WeddingQuizRepositoryTests.java

+package org.example.wedding_app_backend.api.repository;
+
+import org.example.wedding_app_backend.wedding.entity.WeddingEntity;
+import org.example.wedding_app_backend.wedding.repository.WeddingRepository;
+import org.example.wedding_app_backend.weddingGuest.entity.WeddingGuestEntity;
+import org.example.wedding_app_backend.weddingGuest.repository.WeddingGuestRepository;
+import org.example.wedding_app_backend.weddingImage.entity.WeddingImageEntity;
+import org.example.wedding_app_backend.weddingImage.repository.WeddingImageRepository;
+import org.example.wedding_app_backend.weddingQuiz.entity.WeddingQuizEntity;
+import org.example.wedding_app_backend.weddingQuiz.repository.WeddingQuizRepository;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.jdbc.EmbeddedDatabaseConnection;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.data.domain.Sort;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+@DataJpaTest
+@AutoConfigureTestDatabase(connection = EmbeddedDatabaseConnection.H2)
+public class WeddingQuizRepositoryTests {
+
+    @Autowired
+    private WeddingRepository weddingRepository;
+
+    @Autowired
+    private WeddingQuizRepository weddingQuizRepository;
+
+    @Autowired
+    private WeddingGuestRepository weddingGuestRepository;
+
+    @Test
+    public void findQuestionById_ReturnsWeddingQuestion() {
+
+        WeddingEntity weddingEntity = WeddingEntity.builder()
+                .id(UUID.randomUUID())
+                .name("test name")
+                .build();
+        weddingRepository.save(weddingEntity);
+
+        WeddingQuizEntity quizEntity = WeddingQuizEntity.builder()
+                .id(UUID.randomUUID())
+                .wedding(weddingEntity)
+                .build();
+        weddingQuizRepository.save(quizEntity);
+
+        WeddingGuestEntity guestEntity = WeddingGuestEntity.builder()
+                .id(UUID.randomUUID())
+                .questionIndex(0)
+                .quizSeed(1)
+                .wedding(weddingEntity)
+                .build();
+        weddingGuestRepository.save(guestEntity);
+
+        Optional<WeddingQuizEntity> weddingQuizReturn = weddingQuizRepository.findQuestionById(guestEntity.getQuestionIndex(),weddingEntity.getId(),guestEntity.getQuizSeed());
+
+        Assertions.assertNotNull(weddingQuizReturn);
+    }
+
+}
+

backend/wedding_app_backend/src/test/java/org/example/wedding_app_backend/api/service/WeddingPresentServiceTests.java

+package org.example.wedding_app_backend.api.service;
+
+import org.example.wedding_app_backend.wedding.entity.WeddingEntity;
+import org.example.wedding_app_backend.weddingGuest.entity.WeddingGuestEntity;
+import org.example.wedding_app_backend.weddingGuest.repository.WeddingGuestRepository;
+import org.example.wedding_app_backend.weddingPresent.dto.GetWeddingPresentResponse;
+import org.example.wedding_app_backend.weddingPresent.entity.WeddingPresentEntity;
+import org.example.wedding_app_backend.weddingPresent.repository.WeddingPresentRepository;
+import org.example.wedding_app_backend.weddingPresent.service.WeddingPresentService;
+import org.example.wedding_app_backend.weddingQuiz.entity.WeddingQuizEntity;
+import org.example.wedding_app_backend.weddingQuiz.repository.WeddingQuizRepository;
+import org.example.wedding_app_backend.weddingQuiz.service.WeddingQuizService;
+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.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.aot.generate.AccessControl;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class WeddingPresentServiceTests {
+
+    @Mock
+    private WeddingPresentRepository weddingPresentRepository;
+
+    @Mock
+    private WeddingGuestRepository weddingGuestRepository;
+
+    @InjectMocks
+    private WeddingPresentService weddingPresentService;
+
+    private WeddingEntity weddingEntity;
+
+    private WeddingPresentEntity weddingPresentEntity;
+
+    private WeddingGuestEntity weddingGuestEntity;
+
+    @BeforeEach
+    public void setUp() {
+        weddingEntity = WeddingEntity.builder().id(UUID.randomUUID()).build();
+        weddingGuestEntity = WeddingGuestEntity.builder().id(UUID.randomUUID()).wedding(weddingEntity).build();
+        weddingPresentEntity = WeddingPresentEntity.builder()
+                .id(UUID.randomUUID())
+                .name("Gift Name")
+                .description("Gift Description")
+                .linkToPresent("http://example.com")
+                .wedding(weddingEntity)
+                .build();
+
+    }
+
+    @Test
+    void updatePresentReservedBy_ShouldUpdateReservedBy() throws IOException {
+        GetWeddingPresentResponse response = new GetWeddingPresentResponse();
+        response.setReservedBy((UUID.randomUUID()));
+
+        weddingPresentService.updatePresentReservedBy(weddingPresentEntity, response);
+
+        Assertions.assertEquals(response.getReservedBy(), weddingPresentEntity.getReservedBy());
+    }
+
+    @Test
+    void updatePresentParametersModifiableByUser_ShouldUpdateFields() throws IOException {
+        GetWeddingPresentResponse request = new GetWeddingPresentResponse();
+        request.setName("New Name");
+        request.setDescription("New Description");
+        request.setLinkToPresent("http://new-link.com");
+
+        weddingPresentService.updatePresentParametersModifiableByUser(weddingPresentEntity, request);
+
+        Assertions.assertEquals(request.getName(), weddingPresentEntity.getName());
+        Assertions.assertEquals(request.getDescription(), weddingPresentEntity.getDescription());
+        Assertions.assertEquals(request.getLinkToPresent(), weddingPresentEntity.getLinkToPresent());
+    }
+
+    @Test
+    void createWeddingPresent_ShouldCreateAndSavePresent() throws IOException {
+        GetWeddingPresentResponse request = new GetWeddingPresentResponse();
+        request.setName("Gift 1");
+        request.setDescription("A wonderful gift");
+        request.setLinkToPresent("http://gift.com");
+
+        when(weddingPresentRepository.save(any(WeddingPresentEntity.class))).thenAnswer(invocation -> {
+            WeddingPresentEntity savedPresent = invocation.getArgument(0);
+            savedPresent.setId(UUID.randomUUID());
+            return savedPresent;
+        });
+
+        weddingPresentService.createWeddingPresent(request, weddingEntity);
+
+        verify(weddingPresentRepository, times(1)).save(argThat(present ->
+                present.getName().equals(request.getName()) &&
+                        present.getDescription().equals(request.getDescription()) &&
+                        present.getLinkToPresent().equals(request.getLinkToPresent()) &&
+                        present.getWedding().equals(weddingEntity)
+        ));
+    }
+
+    @Test
+    void deletePresent_ShouldDeletePresent() throws IOException {
+        doNothing().when(weddingPresentRepository).delete(weddingPresentEntity);
+
+        weddingPresentService.deletePresent(weddingPresentEntity);
+
+        verify(weddingPresentRepository, times(1)).delete(weddingPresentEntity);
+    }
+
+}

backend/wedding_app_backend/src/test/java/org/example/wedding_app_backend/api/service/WeddingQuizServiceTests.java

+package org.example.wedding_app_backend.api.service;
+
+import org.example.wedding_app_backend.wedding.entity.WeddingEntity;
+import org.example.wedding_app_backend.weddingGuest.entity.WeddingGuestEntity;
+import org.example.wedding_app_backend.weddingGuest.repository.WeddingGuestRepository;
+import org.example.wedding_app_backend.weddingQuiz.entity.WeddingQuizEntity;
+import org.example.wedding_app_backend.weddingQuiz.repository.WeddingQuizRepository;
+import org.example.wedding_app_backend.weddingQuiz.service.WeddingQuizService;
+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.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class WeddingQuizServiceTests {
+
+    @Mock
+    private WeddingQuizRepository weddingQuizRepository;
+
+    @Mock
+    private WeddingGuestRepository weddingGuestRepository;
+
+    @InjectMocks
+    private WeddingQuizService weddingQuizService;
+
+    private WeddingEntity weddingEntity;
+
+    private WeddingQuizEntity weddingQuizEntity;
+
+    private WeddingGuestEntity weddingGuestEntity;
+
+    @BeforeEach
+    public void setUp() {
+        weddingEntity = WeddingEntity.builder().id(UUID.randomUUID()).build();
+        weddingGuestEntity = WeddingGuestEntity.builder().id(UUID.randomUUID()).wedding(weddingEntity).build();
+        weddingQuizEntity = WeddingQuizEntity.builder().id(UUID.randomUUID()).wedding(weddingEntity).build();
+
+    }
+
+    @Test
+    public void findQuestionByGuestId_ShouldReturnNextQuestion_WhenIndexIsLowerThanNumberOfQuestions() {
+        when(weddingQuizRepository.findQuestionById(weddingGuestEntity.getQuestionIndex(), weddingEntity.getId(), weddingGuestEntity.getQuizSeed()))
+                .thenReturn(Optional.of(weddingQuizEntity));
+
+        Optional<WeddingQuizEntity> result=weddingQuizService.findQuestionByGuestId(weddingGuestEntity, weddingEntity.getId());
+
+        Assertions.assertTrue(result.isPresent());
+        Assertions.assertEquals(weddingQuizEntity, result.get());
+    }
+
+    @Test
+    public void findQuestionByGuestId_ShouldReturnEmpty_WhenIndexIsHigherThanNumberOfQuestions() {
+        when(weddingQuizRepository.findQuestionById(weddingGuestEntity.getQuestionIndex(), weddingEntity.getId(), weddingGuestEntity.getQuizSeed()))
+                .thenReturn(Optional.empty());
+
+        Optional<WeddingQuizEntity> result=weddingQuizService.findQuestionByGuestId(weddingGuestEntity, weddingEntity.getId());
+
+        Assertions.assertFalse(result.isPresent());
+    }
+
+}