diff --git a/application/module-certificate/src/main/java/org/fuseri/modulecertificate/service/CertificateController.java b/application/module-certificate/src/main/java/org/fuseri/modulecertificate/service/CertificateController.java
index d0643d2529989fed6a1bd9a671d27df285cb2d2b..38853d761e343dbec8e495dea6b7d097c433858d 100644
--- a/application/module-certificate/src/main/java/org/fuseri/modulecertificate/service/CertificateController.java
+++ b/application/module-certificate/src/main/java/org/fuseri/modulecertificate/service/CertificateController.java
@@ -92,7 +92,7 @@ public class CertificateController {
* @return a Result object containing a list of CertificateDto objects and pagination information
*/
@GetMapping("/findAll")
- public Page<CertificateSimpleDto> findAllCertificates(@RequestBody Pageable pageable) {
+ public Page<CertificateSimpleDto> findAllCertificates(Pageable pageable) {
return certificateFacade.findAll(pageable);
}
}
diff --git a/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateControllerTests.java b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateControllerTests.java
index 20a1ec68448a8b0d97f6373a006c25708151a01e..23f381d2fed50ce0999d72f6971195914e8af769 100644
--- a/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateControllerTests.java
+++ b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateControllerTests.java
@@ -2,21 +2,27 @@ package org.fuseri.modulecertificate;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.fuseri.model.dto.certificate.CertificateCreateDto;
-import org.fuseri.model.dto.certificate.CertificateDto;
+import org.fuseri.model.dto.certificate.CertificateSimpleDto;
import org.fuseri.model.dto.course.CourseDto;
import org.fuseri.model.dto.course.LanguageTypeDto;
import org.fuseri.model.dto.course.ProficiencyLevelDto;
import org.fuseri.model.dto.user.AddressDto;
import org.fuseri.model.dto.user.UserDto;
+import org.fuseri.modulecertificate.service.CertificateController;
import org.junit.jupiter.api.Test;
-import org.springdoc.core.converters.models.Pageable;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
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.data.domain.Page;
import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
+import java.time.Instant;
import java.util.List;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
@@ -27,23 +33,42 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
@AutoConfigureMockMvc
class CertificateControllerTests {
- @Autowired
- private ObjectMapper objectMapper;
-
- @Autowired
- private MockMvc mockMvc;
-
private final UserDto USER = new UserDto("novakovat",
"novakova@gamil.com", "Tereza", "Nováková", new AddressDto());
private final CourseDto COURSE = new CourseDto("AJ1", 10,
LanguageTypeDto.ENGLISH, ProficiencyLevelDto.A1);
+ private final CertificateCreateDto certificateCreateDto = new CertificateCreateDto(USER, COURSE);
+ private final CertificateSimpleDto certificateDto = new CertificateSimpleDto(0L, USER.getId(),
+ Instant.now(), COURSE.getId(), "", "");
+ @Autowired
+ private MockMvc mockMvc;
+ @MockBean
+ private CertificateController certificateController;
+
+ private static String asJsonString(final Object obj) {
+ try {
+ return new ObjectMapper().writeValueAsString(obj);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
@Test
void generateCertificate() throws Exception {
+ Mockito.when(certificateController.generate(ArgumentMatchers.any(CertificateCreateDto.class)))
+ .thenReturn(certificateDto);
+
mockMvc.perform(post("/certificates/generate")
- .content(asJsonString(new CertificateCreateDto(USER, COURSE)))
+ .content(asJsonString(certificateCreateDto))
.contentType(MediaType.APPLICATION_JSON))
- .andExpect(status().isOk());
+ .andExpect(status().isOk())
+ .andExpect(jsonPath("$.id").value(certificateDto.getId()))
+ .andExpect(jsonPath("$.userId").value(certificateDto.getUserId()))
+ .andExpect(jsonPath("$.generatedAt").value(certificateDto.getGeneratedAt().toString()))
+ .andExpect(jsonPath("$.courseId").value(certificateDto.getCourseId()))
+ .andExpect(jsonPath("$.certificateFile").value(certificateDto.getCertificateFile()))
+ .andExpect(jsonPath("$.certificateFileName").value(certificateDto.getCertificateFileName()));
+
}
@Test
@@ -71,16 +96,11 @@ class CertificateControllerTests {
@Test
void findCertificate() throws Exception {
- String response = mockMvc.perform(post("/certificates/generate")
- .content(asJsonString(new CertificateCreateDto(USER, COURSE)))
- .contentType(MediaType.APPLICATION_JSON))
- .andExpect(status().isOk()).andReturn().getResponse().getContentAsString();
+ Mockito.when(certificateController.find(ArgumentMatchers.anyLong())).thenReturn(certificateDto);
- Long id = objectMapper.readValue(response, CertificateDto.class).getId();
-
- mockMvc.perform(get("/certificates/find").param("id", id.toString()))
+ mockMvc.perform(get("/certificates/find").param("id", certificateDto.getId().toString()))
.andExpect(status().isOk())
- .andExpect(jsonPath("$.id").value(id));
+ .andExpect(jsonPath("$.id").value(certificateDto.getId()));
}
@Test
@@ -91,6 +111,8 @@ class CertificateControllerTests {
@Test
void findCertificatesForUser() throws Exception {
+ Mockito.when(certificateController.findForUser(ArgumentMatchers.anyLong())).thenReturn(List.of(certificateDto));
+
mockMvc.perform(get("/certificates/findForUser").param("userId", "0"))
.andExpect(status().isOk())
.andExpect(jsonPath("$").isArray())
@@ -105,11 +127,16 @@ class CertificateControllerTests {
@Test
void findCertificateIdForUserAndCourse() throws Exception {
+ Mockito.when(certificateController.findForUserAndCourse(ArgumentMatchers.anyLong(),
+ ArgumentMatchers.anyLong()))
+ .thenReturn(List.of(certificateDto));
+
mockMvc.perform(get("/certificates/findForUserAndCourse")
.param("userId", "0")
.param("courseId", "0"))
.andExpect(status().isOk())
- .andExpect(content().string("[]"));
+ .andExpect(jsonPath("$").isArray())
+ .andExpect(jsonPath("$").isNotEmpty());
}
@Test
@@ -134,8 +161,10 @@ class CertificateControllerTests {
@Test
void deleteCertificate() throws Exception {
+ Mockito.doNothing().when(certificateController).delete(ArgumentMatchers.anyLong());
+
mockMvc.perform(delete("/certificates/delete")
- .param("id", "0"))
+ .param("id", String.valueOf(0L)))
.andExpect(status().isOk());
}
@@ -145,31 +174,27 @@ class CertificateControllerTests {
.andExpect(status().is4xxClientError());
}
-
@Test
void findAllCertificates() throws Exception {
- mockMvc.perform(post("/certificates/generate")
- .content(asJsonString(new CertificateCreateDto(USER, COURSE)))
- .contentType(MediaType.APPLICATION_JSON))
- .andExpect(status().isOk());
+ Mockito.when(certificateController.findAllCertificates(ArgumentMatchers.any(Pageable.class)))
+ .thenReturn(Page.empty(PageRequest.of(0, 1)));
mockMvc.perform(get("/certificates/findAll")
- .content("{ \"page\": 0, \"size\": 1, \"sort\": []}")
- .contentType(MediaType.APPLICATION_JSON))
- .andExpect(status().isOk());
+ .param("page", "0")
+ .param("size", "10"))
+ .andExpect(status().isOk())
+ .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+ .andExpect(jsonPath("$.content").isEmpty());
}
@Test
void findAllCertificatesWithoutParam() throws Exception {
- mockMvc.perform(get("/certificates/findAll"))
- .andExpect(status().is4xxClientError());
- }
+ Mockito.when(certificateController.findAllCertificates(ArgumentMatchers.any(Pageable.class)))
+ .thenReturn(Page.empty(PageRequest.of(0, 1)));
- private static String asJsonString(final Object obj) {
- try {
- return new ObjectMapper().writeValueAsString(obj);
- } catch (Exception e) {
- throw new RuntimeException(e);
- }
+ mockMvc.perform(get("/certificates/findAll"))
+ .andExpect(status().isOk())
+ .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+ .andExpect(jsonPath("$.content").isEmpty());
}
}
diff --git a/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateFacadeTests.java b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateFacadeTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a32b5143717c2b81de648eef5481fa7e7be341e
--- /dev/null
+++ b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateFacadeTests.java
@@ -0,0 +1,122 @@
+package org.fuseri.modulecertificate;
+
+import org.fuseri.model.dto.certificate.CertificateCreateDto;
+import org.fuseri.model.dto.certificate.CertificateSimpleDto;
+import org.fuseri.model.dto.course.CourseDto;
+import org.fuseri.model.dto.course.LanguageTypeDto;
+import org.fuseri.model.dto.course.ProficiencyLevelDto;
+import org.fuseri.model.dto.user.AddressDto;
+import org.fuseri.model.dto.user.UserDto;
+import org.fuseri.modulecertificate.service.CertificateFacade;
+import org.fuseri.modulecertificate.service.CertificateMapper;
+import org.fuseri.modulecertificate.service.CertificateService;
+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.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+final class CertificateFacadeTests {
+ private final UserDto USER = new UserDto("novakovat",
+ "novakova@gamil.com", "Tereza", "Nováková", new AddressDto());
+ private final CourseDto COURSE = new CourseDto("AJ1", 10,
+ LanguageTypeDto.ENGLISH, ProficiencyLevelDto.A1);
+ private final CertificateCreateDto certificateCreateDto = new CertificateCreateDto(USER, COURSE);
+ private final CertificateSimpleDto certificateDto = new CertificateSimpleDto(0L, USER.getId(),
+ Instant.now(), COURSE.getId(), "", "");
+
+ private final Certificate certificate = new Certificate();
+ private final List<Certificate> certificateList = List.of(certificate);
+
+ @Autowired
+ private CertificateFacade certificateFacade;
+
+ @MockBean
+ private CertificateService certificateService;
+
+ @MockBean
+ private CertificateMapper certificateMapper;
+
+ @Test
+ void generateCertificate() {
+ when(certificateMapper.mapToCertificate(certificateCreateDto)).thenReturn(certificate);
+ when(certificateService.save(certificate)).thenReturn(certificate);
+ when(certificateMapper.mapToSimpleDto(certificate)).thenReturn(certificateDto);
+
+ CertificateSimpleDto actualDto = certificateFacade.generate(certificateCreateDto);
+
+ assertEquals(certificateDto, actualDto);
+ }
+
+ @Test
+ public void testFindById() {
+ Long id = 0L;
+ when(certificateService.findById(id)).thenReturn(certificate);
+ when(certificateMapper.mapToSimpleDto(certificate)).thenReturn(certificateDto);
+
+ CertificateSimpleDto actualDto = certificateFacade.findById(id);
+
+ assertNotNull(actualDto);
+ assertEquals(certificateDto, actualDto);
+ }
+
+ @Test
+ public void testFindForUser() {
+ List<CertificateSimpleDto> expectedDtos = List.of(certificateDto);
+
+ when(certificateService.findByUserId(USER.getId())).thenReturn(certificateList);
+ when(certificateMapper.mapToList(certificateList)).thenReturn(expectedDtos);
+
+ List<CertificateSimpleDto> actualDtos = certificateFacade.findByUserId(USER.getId());
+
+ assertEquals(expectedDtos, actualDtos);
+ }
+
+ @Test
+ public void testFindForUserAndCourse() {
+ List<CertificateSimpleDto> expectedDtos = List.of(certificateDto);
+
+ when(certificateService.findByUserIdAndCourseId(USER.getId(), COURSE.getId())).thenReturn(certificateList);
+ when(certificateMapper.mapToList(certificateList)).thenReturn(expectedDtos);
+
+ List<CertificateSimpleDto> actualDtos = certificateFacade.findByUserIdAndCourseId(USER.getId(), COURSE.getId());
+
+ assertEquals(expectedDtos, actualDtos);
+ }
+
+ @Test
+ public void testDelete() {
+ Long certificateId = 1L;
+ certificateFacade.deleteCertificate(certificateId);
+ verify(certificateService).delete(certificateId);
+ }
+
+ @Test
+ public void testFindAll() {
+ Pageable pageable = PageRequest.of(0, 10);
+ Page<Certificate> certificatePage = new PageImpl<>(List.of(certificate), pageable, 0);
+ Page<CertificateSimpleDto> expectedPageDto = new PageImpl<>(List.of(certificateDto), pageable, 0);
+
+ when(certificateService.findAll(pageable)).thenReturn(certificatePage);
+ when(certificateMapper.mapToPageDto(certificatePage)).thenReturn(expectedPageDto);
+
+ Page<CertificateSimpleDto> actualPageDto = certificateFacade.findAll(pageable);
+
+ assertEquals(expectedPageDto, actualPageDto);
+ }
+}
diff --git a/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateMapperTests.java b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateMapperTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc816f6942b335c173d29cea0101e68b490f5ae9
--- /dev/null
+++ b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateMapperTests.java
@@ -0,0 +1,132 @@
+package org.fuseri.modulecertificate;
+
+import org.fuseri.model.dto.certificate.CertificateCreateDto;
+import org.fuseri.model.dto.certificate.CertificateSimpleDto;
+import org.fuseri.model.dto.course.CourseDto;
+import org.fuseri.model.dto.course.LanguageTypeDto;
+import org.fuseri.model.dto.course.ProficiencyLevelDto;
+import org.fuseri.model.dto.user.AddressDto;
+import org.fuseri.model.dto.user.UserDto;
+import org.fuseri.modulecertificate.service.CertificateMapper;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+
+import java.time.Instant;
+import java.util.Collections;
+import java.util.List;
+
+@SpringBootTest
+final class CertificateMapperTests {
+
+ private final UserDto USER = new UserDto("novakovat",
+ "novakova@gamil.com", "Tereza", "Nováková", new AddressDto());
+ private final CourseDto COURSE = new CourseDto("AJ1", 10,
+ LanguageTypeDto.ENGLISH, ProficiencyLevelDto.A1);
+ private final Instant instant = Instant.now();
+ private final String fileName = "fileName";
+ private final String file = "file";
+ private final CertificateSimpleDto certificateDto = new CertificateSimpleDto(0L, USER.getId(),
+ instant, COURSE.getId(), file, fileName);
+ private final Certificate certificate = new Certificate(USER.getId(),
+ instant, COURSE.getId(), file, fileName);
+ private final CertificateCreateDto certificateCreateDto = new CertificateCreateDto(USER, COURSE);
+ @Autowired
+ private CertificateMapper certificateMapper;
+
+ @Test
+ void mapNullToSimpleDto() {
+ var createdSimpleDto = certificateMapper.mapToSimpleDto(null);
+
+ Assertions.assertNull(createdSimpleDto);
+ }
+
+ @Test
+ void mapToSimpleDto() {
+ var createdSimpleDto = certificateMapper.mapToSimpleDto(certificate);
+
+ Assertions.assertEquals(createdSimpleDto.getUserId(), certificateDto.getUserId());
+ Assertions.assertEquals(createdSimpleDto.getGeneratedAt(), certificateDto.getGeneratedAt());
+ Assertions.assertEquals(createdSimpleDto.getCourseId(), certificateDto.getCourseId());
+ Assertions.assertEquals(createdSimpleDto.getCertificateFile(), certificateDto.getCertificateFile());
+ Assertions.assertEquals(createdSimpleDto.getCertificateFileName(), certificateDto.getCertificateFileName());
+ }
+
+ @Test
+ void mapNullToCertificate() {
+ var createdCertificate = certificateMapper.mapToCertificate(null);
+
+ Assertions.assertNull(createdCertificate);
+ }
+
+ @Test
+ void mapToCertificate() {
+ var createdCertificate = certificateMapper.mapToCertificate(certificateCreateDto);
+
+ Assertions.assertEquals(createdCertificate.getUserId(), certificateDto.getUserId());
+ Assertions.assertTrue(createdCertificate.getGeneratedAt().isBefore(Instant.now()));
+ Assertions.assertEquals(createdCertificate.getCourseId(), certificateDto.getCourseId());
+ Assertions.assertNull(createdCertificate.getCertificateFile());
+ Assertions.assertNull(createdCertificate.getCertificateFileName());
+ }
+
+ @Test
+ void mapNullToList() {
+ var certificateSimpleDtos = certificateMapper.mapToList(null);
+
+ Assertions.assertNull(certificateSimpleDtos);
+ }
+
+ @Test
+ void mapToEmptyList() {
+ var certificateSimpleDtos = certificateMapper.mapToList(Collections.emptyList());
+
+ Assertions.assertEquals(certificateSimpleDtos.size(), 0);
+ }
+
+ @Test
+ void mapToList() {
+ var certificateSimpleDtos = certificateMapper.mapToList(Collections.singletonList(certificate));
+
+ Assertions.assertEquals(certificateSimpleDtos.size(), 1);
+ Assertions.assertEquals(certificateSimpleDtos.get(0).getUserId(), certificateDto.getUserId());
+ Assertions.assertEquals(certificateSimpleDtos.get(0).getGeneratedAt(), certificateDto.getGeneratedAt());
+ Assertions.assertEquals(certificateSimpleDtos.get(0).getCourseId(), certificateDto.getCourseId());
+ Assertions.assertEquals(certificateSimpleDtos.get(0).getCertificateFile(), certificateDto.getCertificateFile());
+ Assertions.assertEquals(certificateSimpleDtos.get(0).getCertificateFileName(), certificateDto.getCertificateFileName());
+
+
+ }
+
+ @Test
+ void mapToEmptyPageDto() {
+ Page<CertificateSimpleDto> pageDto = certificateMapper.mapToPageDto(Page.empty());
+
+ Assertions.assertEquals(1, pageDto.getTotalPages());
+ }
+
+ @Test
+ void mapToPageDto() {
+ List<Certificate> certificates = List.of(certificate);
+ Page<Certificate> page = new PageImpl<>(certificates, PageRequest.of(0, 1), certificates.size());
+ Page<CertificateSimpleDto> pageDto = certificateMapper.mapToPageDto(page);
+
+ Assertions.assertEquals(page.getTotalPages(), pageDto.getTotalPages());
+ Assertions.assertEquals(page.getNumber(), pageDto.getNumber());
+ Assertions.assertEquals(page.getNumberOfElements(), pageDto.getNumberOfElements());
+ Assertions.assertEquals(page.getSize(), pageDto.getSize());
+ Assertions.assertEquals(page.getTotalElements(), pageDto.getTotalElements());
+
+ Assertions.assertEquals(certificate.getId(), pageDto.getContent().get(0).getId());
+ Assertions.assertEquals(certificate.getGeneratedAt(), pageDto.getContent().get(0).getGeneratedAt());
+ Assertions.assertEquals(certificate.getUserId(), pageDto.getContent().get(0).getUserId());
+ Assertions.assertEquals(certificate.getCourseId(), pageDto.getContent().get(0).getCourseId());
+ Assertions.assertEquals(certificate.getCertificateFile(), pageDto.getContent().get(0).getCertificateFile());
+ Assertions.assertEquals(certificate.getCertificateFileName(), pageDto.getContent().get(0).getCertificateFileName());
+ }
+
+}
diff --git a/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateRepositoryTests.java b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateRepositoryTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..34ca57badbed1ae6a79c31b20ef4f810e40fc14c
--- /dev/null
+++ b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateRepositoryTests.java
@@ -0,0 +1,101 @@
+package org.fuseri.modulecertificate;
+
+import org.fuseri.modulecertificate.service.CertificateRepository;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+
+import java.util.Arrays;
+import java.util.List;
+
+@DataJpaTest
+class CertificateRepositoryTests {
+
+ @Autowired
+ private TestEntityManager entityManager;
+
+ @Autowired
+ private CertificateRepository certificateRepository;
+
+ @Test
+ void saveCertificate() {
+ Certificate certificate = new Certificate();
+ certificate.setUserId(1L);
+ certificate.setCourseId(2L);
+
+ Certificate saved = certificateRepository.save(certificate);
+
+ Assertions.assertNotNull(saved);
+ Assertions.assertEquals(certificate, saved);
+ }
+
+ @Test
+ void findCertificate() {
+ Certificate certificate = new Certificate();
+ certificate.setUserId(1L);
+ entityManager.persist(certificate);
+ entityManager.flush();
+
+ Certificate found = certificateRepository.findById(certificate.getId()).orElse(null);
+
+ Assertions.assertNotNull(found);
+ Assertions.assertEquals(found, certificate);
+ }
+
+ @Test
+ void findCertificateByUserId() {
+ Certificate certificate = new Certificate();
+ certificate.setUserId(1L);
+ entityManager.persist(certificate);
+ entityManager.flush();
+
+ List<Certificate> found = certificateRepository.findCertificateByUserId(1L);
+
+ Assertions.assertEquals(1, found.size());
+ Assertions.assertEquals(found.get(0), certificate);
+ }
+
+ @Test
+ void findCertificateByUserIdAndCourseId() {
+ Certificate certificate = new Certificate();
+ certificate.setUserId(1L);
+ certificate.setCourseId(2L);
+ entityManager.persist(certificate);
+ entityManager.flush();
+
+ List<Certificate> found = certificateRepository.findCertificateByUserIdAndCourseId(1L, 2L);
+
+ Assertions.assertEquals(1, found.size());
+ Assertions.assertEquals(found.get(0), certificate);
+ }
+
+ @Test
+ public void testFindAllCertificates() {
+ Certificate certificate1 = new Certificate();
+ Certificate certificate2 = new Certificate();
+
+ certificateRepository.save(certificate1);
+ certificateRepository.save(certificate2);
+
+ Page<Certificate> certificatePage = certificateRepository.findAll(PageRequest.of(0, 42));
+
+ Assertions.assertEquals(2, certificatePage.getTotalElements());
+ Assertions.assertEquals(certificatePage.getContent(), Arrays.asList(certificate1, certificate2));
+ }
+
+ @Test
+ public void testDeleteCertificate() {
+ Long certificateId = entityManager.persist(new Certificate()).getId();
+ entityManager.flush();
+
+ certificateRepository.deleteById(certificateId);
+
+ Assertions.assertTrue(certificateRepository.findById(certificateId).isEmpty());
+ }
+
+
+}
diff --git a/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateServiceTests.java b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateServiceTests.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d3302fa62d6c52eb5e0b7e713be40be9d73b1ce
--- /dev/null
+++ b/application/module-certificate/src/test/java/org/fuseri/modulecertificate/CertificateServiceTests.java
@@ -0,0 +1,118 @@
+package org.fuseri.modulecertificate;
+
+import org.fuseri.model.dto.course.CourseDto;
+import org.fuseri.model.dto.course.LanguageTypeDto;
+import org.fuseri.model.dto.course.ProficiencyLevelDto;
+import org.fuseri.model.dto.user.AddressDto;
+import org.fuseri.model.dto.user.UserDto;
+import org.fuseri.modulecertificate.service.CertificateRepository;
+import org.fuseri.modulecertificate.service.CertificateService;
+import org.fuseri.modulecertificate.service.ResourceNotFoundException;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.stubbing.OngoingStubbing;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.time.Instant;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+
+@SpringBootTest
+final class CertificateServiceTests {
+
+ @MockBean
+ private CertificateRepository certificateRepository;
+
+ @Autowired
+ private CertificateService certificateService;
+
+ private final UserDto USER = new UserDto("novakovat",
+ "novakova@gamil.com", "Tereza", "Nováková", new AddressDto());
+ private final CourseDto COURSE = new CourseDto("AJ1", 10,
+ LanguageTypeDto.ENGLISH, ProficiencyLevelDto.A1);
+ private final Certificate certificate = new Certificate(USER.getId(),
+ Instant.now(), COURSE.getId(), "file", "fileName");
+ private final List<Certificate> certificates = List.of(certificate, certificate);
+
+ @Test
+ void save() {
+ when(certificateRepository.save(certificate)).thenReturn(certificate);
+
+ Certificate result = certificateService.save(certificate);
+
+ Assertions.assertEquals(certificate, result);
+ verify(certificateRepository).save(certificate);
+ }
+
+ @Test
+ void notFoundById() {
+ when(certificateRepository.findById(certificate.getId())).thenReturn(Optional.empty());
+
+ Assertions.assertThrows(ResourceNotFoundException.class, () -> certificateService.findById(certificate.getId()));
+
+ }
+
+ @Test
+ void findById() {
+ when(certificateRepository.findById(certificate.getId())).thenReturn(Optional.of(certificate));
+
+ Certificate result = certificateService.findById(certificate.getId());
+
+ Assertions.assertEquals(certificate, result);
+ verify(certificateRepository).findById(certificate.getId());
+ }
+
+
+
+ @Test
+ void findByUserId() {
+ when(certificateRepository.findCertificateByUserId(USER.getId())).thenReturn(certificates);
+
+ List<Certificate> result = certificateService.findByUserId(USER.getId());
+
+ Assertions.assertEquals(certificates, result);
+ verify(certificateRepository).findCertificateByUserId(USER.getId());
+ }
+
+ @Test
+ void findByUserIdAndCourseId() {
+ when(certificateRepository.findCertificateByUserIdAndCourseId(USER.getId(), COURSE.getId())).thenReturn(certificates);
+
+ List<Certificate> result = certificateService.findByUserIdAndCourseId(USER.getId(), COURSE.getId());
+
+ Assertions.assertEquals(certificates, result);
+ verify(certificateRepository).findCertificateByUserIdAndCourseId(USER.getId(), COURSE.getId());
+
+ }
+
+ @Test
+ void delete() {
+ certificateService.delete(certificate.getId());
+
+ verify(certificateRepository).deleteById(certificate.getId());
+ }
+
+ @Test
+ void findAll() {
+ Pageable pageable = PageRequest.of(0, 10);
+ Page<Certificate> page = new PageImpl<>(Collections.emptyList(), pageable, 0);
+
+ when(certificateRepository.findAll(pageable)).thenReturn(page);
+
+ Page<Certificate> result = certificateService.findAll(pageable);
+
+ Assertions.assertEquals(page, result);
+ verify(certificateRepository).findAll(pageable);
+
+ }
+
+}