Compare commits
2 Commits
f7023f9c4a
...
environmen
| Author | SHA1 | Date | |
|---|---|---|---|
| a7c8f22658 | |||
| f31885c795 |
@@ -6,6 +6,7 @@ import _11.asktpk.artisanconnectbackend.service.NoticeService;
|
||||
import jakarta.persistence.EntityNotFoundException;
|
||||
import org.springframework.beans.factory.annotation.Value;
|
||||
import org.springframework.core.io.Resource;
|
||||
import org.springframework.data.repository.query.Param;
|
||||
import org.springframework.http.HttpStatus;
|
||||
import org.springframework.http.MediaType;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
@@ -29,7 +30,7 @@ public class ImageController {
|
||||
private String uploadDir;
|
||||
|
||||
@PostMapping("/upload/{id}")
|
||||
public ResponseEntity<RequestResponseDTO> uploadImage(@RequestParam("file") MultipartFile file, @PathVariable("id") Long noticeId) {
|
||||
public ResponseEntity<RequestResponseDTO> uploadImage(@RequestParam("file") MultipartFile file, @PathVariable("id") Long noticeId, @Param("isMainImage") Boolean isMainImage) {
|
||||
try {
|
||||
if(file.isEmpty()) {
|
||||
return ResponseEntity.badRequest().body(new RequestResponseDTO("File is empty"));
|
||||
@@ -44,10 +45,11 @@ public class ImageController {
|
||||
}
|
||||
|
||||
String newImageName = imageService.saveImageToStorage(uploadDir, file);
|
||||
imageService.addImageNameToDB(newImageName, noticeId);
|
||||
imageService.addImageNameToDB(newImageName, noticeId, isMainImage);
|
||||
|
||||
return ResponseEntity.ok(new RequestResponseDTO("Image uploaded successfully with new name: " + newImageName));
|
||||
} catch (Exception e) {
|
||||
System.out.println(e.getMessage());
|
||||
return ResponseEntity.status(HttpStatus.UNSUPPORTED_MEDIA_TYPE).body(new RequestResponseDTO(e.getMessage()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend.dto;
|
||||
|
||||
import org.springframework.core.io.Resource;
|
||||
|
||||
public class ImageRequestDTO {
|
||||
public Resource image;
|
||||
public Long noticeId;
|
||||
public boolean isMainImage;
|
||||
}
|
||||
@@ -40,10 +40,11 @@ public class ImageService {
|
||||
return uniqueFileName;
|
||||
}
|
||||
|
||||
public void addImageNameToDB(String filename, Long noticeId) {
|
||||
public void addImageNameToDB(String filename, Long noticeId, boolean isMainImage) {
|
||||
Image image = new Image();
|
||||
image.setImageName(filename);
|
||||
image.setNoticeId(noticeId);
|
||||
image.setMainImage(isMainImage);
|
||||
imageRepository.save(image);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,39 +1,41 @@
|
||||
spring.application.name=ArtisanConnectBackend
|
||||
|
||||
## PostgreSQL
|
||||
spring.datasource.url=jdbc:postgresql://localhost:5432/postgres
|
||||
spring.datasource.url=${DB_URL:jdbc:postgresql://db:5432/postgres}
|
||||
spring.datasource.username=${DB_USER:postgres}
|
||||
spring.datasource.password=${DB_PASS:postgres}
|
||||
spring.datasource.driver-class-name=org.postgresql.Driver
|
||||
spring.datasource.username=postgres
|
||||
spring.datasource.password=postgres
|
||||
|
||||
#initial data for db injection
|
||||
#Injekcja danych przyk?adowych przy starcie bazy
|
||||
spring.sql.init.data-locations=classpath:sql/data.sql
|
||||
spring.sql.init.mode=always
|
||||
spring.jpa.defer-datasource-initialization=true
|
||||
|
||||
# create and drop table, good for testing, production set to none or comment it
|
||||
#Sposób zachowania JPA
|
||||
spring.jpa.hibernate.ddl-auto=create-drop
|
||||
|
||||
file.upload-dir=/Users/andsol/Desktop/uploads
|
||||
spring.servlet.multipart.max-file-size=10MB
|
||||
spring.servlet.multipart.max-request-size=10MB
|
||||
#Gdzie uploadujemy zdj?cia i maksymalny rozmiar
|
||||
file.upload-dir=${IMAGES_UPLOAD_DIR:/app/images}
|
||||
spring.servlet.multipart.max-file-size=${MAX_FILE_SIZE:10MB}
|
||||
spring.servlet.multipart.max-request-size=${MAX_REQUEST_SIZE:10MB}
|
||||
|
||||
spring.mail.host=smtp.sendgrid.net
|
||||
spring.mail.port=587
|
||||
spring.mail.username=apikey
|
||||
spring.mail.password=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
|
||||
spring.mail.properties.mail.smtp.auth=true
|
||||
spring.mail.properties.mail.smtp.starttls.enable=true
|
||||
#Ustawienia wysy?ania maili
|
||||
spring.mail.host=${MAIL_HOST}
|
||||
spring.mail.port=${MAIL_PORT}
|
||||
spring.mail.username=${MAIL_USER}
|
||||
spring.mail.password=${MAIL_PASSWORD}
|
||||
|
||||
tpay.clientId = 01JQKC048X62ST9V59HNRSXD92-01JQKC2CQHPYXQFSFX8BKC24BX
|
||||
tpay.clientSecret = 44898642be53381cdcc47f3e44bf5a15e592f5d270fc3a6cf6fb81a8b8ebffb9
|
||||
tpay.authUrl = https://openapi.sandbox.tpay.com/oauth/auth
|
||||
tpay.transactionUrl = https://openapi.sandbox.tpay.com/transactions
|
||||
tpay.securityCode = )IY7E)YSM!A)Q6O-GN#U7U_33s9qObk8
|
||||
#Ustawienia TPay
|
||||
tpay.clientId=${TPAY_CLIENT_ID}
|
||||
tpay.clientSecret=${TPAY_SECRET}
|
||||
tpay.authUrl=${TPAY_AUTH_URL}
|
||||
tpay.transactionUrl=${TPAY_TRANSACTION_URL}
|
||||
tpay.securityCode = ${TPAY_SECURITY_CODE}
|
||||
|
||||
#jwt settings
|
||||
jwt.secret=DIXLsOs3FKmCAQwISd0SKsHMXJrPl3IKIRkVlkOvYW7kEcdUTbxh8zFe1B3eZWkY
|
||||
jwt.expiration=300000
|
||||
#Ustawienia JWT
|
||||
jwt.secret=${JWT_SECRET}
|
||||
jwt.expiration=1200000
|
||||
|
||||
#Ustawienia logowania
|
||||
logging.file.name=logs/payment-notifications.log
|
||||
logging.level.TpayLogger=INFO
|
||||
@@ -1,590 +1,33 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.dto.CategoriesDTO;
|
||||
import _11.asktpk.artisanconnectbackend.dto.ClientDTO;
|
||||
import _11.asktpk.artisanconnectbackend.dto.NoticeDTO;
|
||||
import _11.asktpk.artisanconnectbackend.dto.WishlistDTO;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Client;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Notice;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Wishlist;
|
||||
import _11.asktpk.artisanconnectbackend.repository.ClientRepository;
|
||||
import _11.asktpk.artisanconnectbackend.repository.NoticeRepository;
|
||||
import _11.asktpk.artisanconnectbackend.repository.WishlistRepository;
|
||||
import _11.asktpk.artisanconnectbackend.service.ClientService;
|
||||
import _11.asktpk.artisanconnectbackend.service.ImageService;
|
||||
import _11.asktpk.artisanconnectbackend.service.NoticeService;
|
||||
import _11.asktpk.artisanconnectbackend.service.WishlistService;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Enums;
|
||||
import jakarta.persistence.EntityNotFoundException;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.junit.jupiter.api.*;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.boot.test.context.SpringBootTest;
|
||||
import org.springframework.boot.test.web.client.TestRestTemplate;
|
||||
import org.springframework.boot.test.web.server.LocalServerPort;
|
||||
import org.springframework.dao.DataIntegrityViolationException;
|
||||
import org.springframework.http.*;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Image;
|
||||
import _11.asktpk.artisanconnectbackend.repository.ImageRepository;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.Mockito;
|
||||
import org.springframework.core.io.Resource;
|
||||
import org.springframework.core.io.UrlResource;
|
||||
import org.springframework.web.multipart.MultipartFile;
|
||||
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import java.util.UUID;
|
||||
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Testy dla funkcjonalności klienta w backendzie.
|
||||
*/
|
||||
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
|
||||
@SpringBootTest
|
||||
class ArtisanConnectBackendApplicationTests {
|
||||
|
||||
private static final Logger logger = LogManager.getLogger(ArtisanConnectBackendApplicationTests.class);
|
||||
|
||||
@LocalServerPort
|
||||
private final int port;
|
||||
|
||||
private final ClientService clientService;
|
||||
private final TestRestTemplate restTemplate;
|
||||
|
||||
@Autowired
|
||||
public ArtisanConnectBackendApplicationTests(ClientService clientService, @LocalServerPort int port) {
|
||||
this.clientService = clientService;
|
||||
this.port = port;
|
||||
this.restTemplate = new TestRestTemplate();
|
||||
}
|
||||
|
||||
|
||||
@Nested
|
||||
@DisplayName("Testy jednostkowe ClientService")
|
||||
class ClientServiceTest {
|
||||
|
||||
private final ClientRepository clientRepository;
|
||||
private final ClientService clientService;
|
||||
|
||||
ClientServiceTest(ClientRepository clientRepository, ClientService clientService) {
|
||||
logger.info("Inicjalizacja mocków dla ClientService");
|
||||
this.clientRepository = clientRepository;
|
||||
this.clientService = clientService;
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie mapować klientów na ClientDTO")
|
||||
void testClientMappingToDTO() {
|
||||
logger.info("Tworzenie danych klientów...");
|
||||
Client client = createTestClient("Jan", "Kowalski");
|
||||
when(clientRepository.findAll()).thenReturn(List.of(client));
|
||||
|
||||
logger.info("Wywołanie metody getAllClients...");
|
||||
List<ClientDTO> clientDTOList = clientService.getAllClients();
|
||||
|
||||
assertThat(clientDTOList).hasSize(1);
|
||||
assertThat(clientDTOList.get(0).getFirstName()).isEqualTo("Jan");
|
||||
verify(clientRepository, times(1)).findAll();
|
||||
logger.info("Test zakończony poprawnie");
|
||||
}
|
||||
|
||||
private Client createTestClient(String firstName, String lastName) {
|
||||
Client client = new Client();
|
||||
client.setFirstName(firstName);
|
||||
client.setLastName(lastName);
|
||||
client.setEmail(firstName.toLowerCase() + "." + lastName.toLowerCase() + "@example.com");
|
||||
client.setRole(clientService.getUserRole());
|
||||
return client;
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("Testy integracyjne ClientController")
|
||||
class ClientControllerTest {
|
||||
|
||||
private final int port;
|
||||
private final TestRestTemplate restTemplate;
|
||||
private final ClientService clientService;
|
||||
private final NoticeService noticeService;
|
||||
private final NoticeRepository noticeRepository;
|
||||
private final Logger logger = LogManager.getLogger(ClientControllerTest.class);
|
||||
|
||||
@Autowired
|
||||
public ClientControllerTest(
|
||||
@LocalServerPort int port,
|
||||
TestRestTemplate restTemplate,
|
||||
ClientService clientService,
|
||||
NoticeService noticeService,
|
||||
NoticeRepository noticeRepository) {
|
||||
this.port = port;
|
||||
this.restTemplate = restTemplate;
|
||||
this.clientService = clientService;
|
||||
this.noticeService = noticeService;
|
||||
this.noticeRepository = noticeRepository;
|
||||
}
|
||||
|
||||
@BeforeEach
|
||||
void cleanDatabase() {
|
||||
|
||||
noticeRepository.deleteAll();
|
||||
|
||||
clientService.getAllClients().forEach(client -> {
|
||||
try {
|
||||
clientService.deleteClient(client.getId());
|
||||
} catch (Exception e) {
|
||||
logger.error("Błąd podczas usuwania klienta: {}", e.getMessage());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private boolean hasNotices(Long clientId) {
|
||||
return noticeService.getAllNotices().stream()
|
||||
.anyMatch(notice -> notice.getClientId().equals(clientId));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie usunąć klienta z powiązanymi ogłoszeniami")
|
||||
void shouldDeleteClientWithNotices() {
|
||||
ClientDTO client = clientService.addClient(createTestDTO("client@example.com", "Jan", "Kowalski"));
|
||||
|
||||
NoticeDTO notice = new NoticeDTO();
|
||||
notice.setClientId(client.getId());
|
||||
notice.setTitle("Test Notice");
|
||||
Long noticeId = noticeService.addNotice(notice);
|
||||
|
||||
ResponseEntity<Void> deleteNoticeResponse = restTemplate.exchange(
|
||||
createURLWithPort("/api/v1/notices/delete/" + noticeId),
|
||||
HttpMethod.DELETE,
|
||||
null,
|
||||
Void.class
|
||||
);
|
||||
assertThat(deleteNoticeResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
|
||||
ResponseEntity<Void> deleteClientResponse = restTemplate.exchange(
|
||||
createURLWithPort("/api/v1/clients/delete/" + client.getId()),
|
||||
HttpMethod.DELETE,
|
||||
null,
|
||||
Void.class
|
||||
);
|
||||
|
||||
assertThat(deleteClientResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
assertThat(clientService.clientExists(client.getId())).isFalse();
|
||||
assertThat(noticeService.noticeExists(noticeId)).isFalse();
|
||||
}
|
||||
@Autowired
|
||||
private ClientRepository clientRepository;
|
||||
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwracać wszystkich klientów")
|
||||
void shouldReturnAllClients() {
|
||||
ClientDTO client1 = clientService.addClient(createTestDTO("client1@example.com", "Anna", "Nowak"));
|
||||
ClientDTO client2 = clientService.addClient(createTestDTO("client2@example.com", "Adam", "Kowalski"));
|
||||
|
||||
ResponseEntity<ClientDTO[]> response = restTemplate.getForEntity(
|
||||
createURLWithPort("/api/v1/clients/get/all"),
|
||||
ClientDTO[].class
|
||||
);
|
||||
|
||||
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
assertThat(response.getBody()).isNotNull();
|
||||
assertThat(response.getBody()).hasSize(2);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić błąd przy próbie usunięcia klienta z powiązanymi ogłoszeniami bez kaskady")
|
||||
void shouldFailWhenDeletingClientWithNoticesWithoutCascade() {
|
||||
noticeService.getAllNotices().forEach(n -> noticeService.deleteNotice(n.getNoticeId()));
|
||||
clientService.getAllClients().forEach(c -> clientService.deleteClient(c.getId()));
|
||||
|
||||
ClientDTO client = clientService.addClient(createTestDTO("client@example.com", "Jan", "Kowalski"));
|
||||
|
||||
NoticeDTO notice = new NoticeDTO();
|
||||
notice.setClientId(client.getId());
|
||||
notice.setTitle("Test Notice");
|
||||
noticeService.addNotice(notice);
|
||||
|
||||
try {
|
||||
clientService.deleteClient(client.getId());
|
||||
fail("Powinien zostać rzucony wyjątek DataIntegrityViolationException");
|
||||
} catch (DataIntegrityViolationException e) {
|
||||
// Oczekiwany wyjątek
|
||||
assertThat(e.getMessage()).contains("could not execute statement");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie usunąć klienta bez powiązanych ogłoszeń")
|
||||
void shouldDeleteClientWithoutNotices() {
|
||||
ClientDTO client = clientService.addClient(createTestDTO("client@example.com", "Jan", "Kowalski"));
|
||||
|
||||
ResponseEntity<Void> deleteResponse = restTemplate.exchange(
|
||||
createURLWithPort("/api/v1/clients/delete/" + client.getId()),
|
||||
HttpMethod.DELETE,
|
||||
null,
|
||||
Void.class
|
||||
);
|
||||
|
||||
assertThat(deleteResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
assertThat(clientService.clientExists(client.getId())).isFalse();
|
||||
}
|
||||
|
||||
private ClientDTO createTestDTO(String email, String firstName, String lastName) {
|
||||
ClientDTO clientDTO = new ClientDTO();
|
||||
clientDTO.setEmail(email);
|
||||
clientDTO.setFirstName(firstName);
|
||||
clientDTO.setLastName(lastName);
|
||||
clientDTO.setRole("USER");
|
||||
return clientDTO;
|
||||
}
|
||||
|
||||
private String createURLWithPort(String uri) {
|
||||
return "http://localhost:" + port + uri;
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("Testy jednostkowe NoticeService")
|
||||
class NoticeServiceUnitTest {
|
||||
|
||||
private final NoticeRepository noticeRepository;
|
||||
private final ClientRepository clientRepository;
|
||||
private final NoticeService noticeService;
|
||||
|
||||
NoticeServiceUnitTest() {
|
||||
this.noticeRepository = mock(NoticeRepository.class);
|
||||
this.clientRepository = mock(ClientRepository.class);
|
||||
this.noticeService = new NoticeService(
|
||||
noticeRepository,
|
||||
clientRepository,
|
||||
null,
|
||||
null
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie dodać ogłoszenie")
|
||||
void shouldAddNoticeSuccessfully() {
|
||||
Client client = createTestClient("test@example.com", "Anna", "Kowalska");
|
||||
when(clientRepository.findById(1L)).thenReturn(Optional.of(client));
|
||||
|
||||
NoticeDTO noticeDTO = new NoticeDTO();
|
||||
noticeDTO.setClientId(1L);
|
||||
noticeDTO.setTitle("Test Notice");
|
||||
noticeDTO.setDescription("Opis ogłoszenia");
|
||||
noticeDTO.setPrice(100.0);
|
||||
|
||||
Notice notice = new Notice();
|
||||
notice.setIdNotice(1L);
|
||||
|
||||
when(noticeRepository.save(any(Notice.class))).thenReturn(notice);
|
||||
|
||||
Long savedNoticeId = noticeService.addNotice(noticeDTO);
|
||||
|
||||
assertThat(savedNoticeId).isEqualTo(1L);
|
||||
verify(noticeRepository, times(1)).save(any(Notice.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić wyjątek, gdy klient dla ogłoszenia nie istnieje")
|
||||
void shouldThrowExceptionWhenClientNotFound() {
|
||||
NoticeDTO noticeDTO = new NoticeDTO();
|
||||
noticeDTO.setClientId(1L);
|
||||
|
||||
when(clientRepository.findById(1L)).thenReturn(Optional.empty());
|
||||
|
||||
assertThrows(EntityNotFoundException.class, () -> noticeService.addNotice(noticeDTO));
|
||||
}
|
||||
|
||||
private Client createTestClient(String email, String firstName, String lastName) {
|
||||
Client client = new Client();
|
||||
client.setId(1L);
|
||||
client.setEmail(email);
|
||||
client.setFirstName(firstName);
|
||||
client.setLastName(lastName);
|
||||
return client;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@Nested
|
||||
@DisplayName("Testy integracyjne ImageService")
|
||||
class ImageServiceTest {
|
||||
|
||||
private final ImageRepository imageRepository;
|
||||
private final ImageService imageService;
|
||||
|
||||
ImageServiceTest() throws Exception {
|
||||
this.imageRepository = mock(ImageRepository.class);
|
||||
Constructor<ImageService> constructor = ImageService.class.getDeclaredConstructor(ImageRepository.class);
|
||||
constructor.setAccessible(true);
|
||||
this.imageService = constructor.newInstance(imageRepository);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie zapisać obraz w magazynie plików")
|
||||
void shouldSaveImageToStorage() throws IOException {
|
||||
MultipartFile file = mock(MultipartFile.class);
|
||||
when(file.getOriginalFilename()).thenReturn("test.jpg");
|
||||
when(file.getInputStream()).thenReturn(Files.newInputStream(Path.of("src/test/resources/test.jpg")));
|
||||
|
||||
String uploadDirectory = "upload_dir";
|
||||
Path uploadPath = Path.of(uploadDirectory);
|
||||
Files.createDirectories(uploadPath);
|
||||
|
||||
String savedFileName = imageService.saveImageToStorage(uploadDirectory, file);
|
||||
|
||||
assertTrue(savedFileName.contains(".jpg"));
|
||||
assertTrue(Files.exists(uploadPath.resolve(savedFileName)));
|
||||
|
||||
Files.deleteIfExists(uploadPath.resolve(savedFileName));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie zapisać nazwę obrazu do bazy danych")
|
||||
void shouldAddImageNameToDB() {
|
||||
String filename = UUID.randomUUID() + "test.jpg";
|
||||
Long noticeId = 1L;
|
||||
|
||||
imageService.addImageNameToDB(filename, noticeId);
|
||||
|
||||
verify(imageRepository, times(1)).save(Mockito.any(Image.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie pobrać obraz")
|
||||
void shouldGetImage() throws IOException {
|
||||
Path imagePath = Path.of("src/test/resources/test.jpg");
|
||||
Resource resource = imageService.getImage("src/test/resources", "test.jpg");
|
||||
|
||||
assertNotNull(resource);
|
||||
assertTrue(resource instanceof UrlResource);
|
||||
assertTrue(Files.exists(imagePath));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zgłosić błąd, gdy obraz nie zostanie znaleziony")
|
||||
void shouldThrowExceptionWhenImageNotFound() {
|
||||
Exception exception = assertThrows(IOException.class, () -> {
|
||||
imageService.getImage("invalid/path", "missing.jpg");
|
||||
});
|
||||
|
||||
assertThat(exception).hasMessageContaining("File not found");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie usuwać obraz z magazynu plików i bazy danych")
|
||||
void shouldDeleteImage() throws IOException {
|
||||
Path imagePath = Files.createTempFile("temp-dir", "temp-image.jpg");
|
||||
String imageName = imagePath.getFileName().toString();
|
||||
String imageDirectory = imagePath.getParent().toString();
|
||||
|
||||
Image image = new Image();
|
||||
image.setImageName(imageName);
|
||||
when(imageRepository.existsImageByImageNameEqualsIgnoreCase(imageName)).thenReturn(true);
|
||||
|
||||
imageService.deleteImage(imageDirectory, imageName);
|
||||
|
||||
assertFalse(Files.exists(imagePath));
|
||||
verify(imageRepository, times(1)).deleteByImageNameEquals(imageName);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie zwrócić listę nazw obrazów dla podanego ogłoszenia")
|
||||
void shouldGetImagesListForNotice() throws Exception {
|
||||
Long noticeId = 1L;
|
||||
List<Image> images = List.of(
|
||||
createTestImage(1L, noticeId, "image1.jpg"),
|
||||
createTestImage(2L, noticeId, "image2.jpg")
|
||||
);
|
||||
when(imageRepository.findByNoticeId(noticeId)).thenReturn(images);
|
||||
|
||||
List<String> imageNames = imageService.getImagesList(noticeId);
|
||||
|
||||
assertThat(imageNames).hasSize(2);
|
||||
assertThat(imageNames).containsExactly("image1.jpg", "image2.jpg");
|
||||
}
|
||||
|
||||
private Image createTestImage(Long id, Long noticeId, String imageName) {
|
||||
Image image = new Image();
|
||||
image.setId(id);
|
||||
image.setNoticeId(noticeId);
|
||||
image.setImageName(imageName);
|
||||
return image;
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("Testy integracyjne WishlistService")
|
||||
class WishlistServiceTest {
|
||||
|
||||
private final WishlistRepository wishlistRepository;
|
||||
private final NoticeService noticeService;
|
||||
private final WishlistService wishlistService;
|
||||
|
||||
WishlistServiceTest() {
|
||||
this.wishlistRepository = mock(WishlistRepository.class);
|
||||
this.noticeService = mock(NoticeService.class);
|
||||
this.wishlistService = new WishlistService(wishlistRepository, noticeService);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie zwrócić wishlist dla klienta")
|
||||
void shouldGetWishlistForClient() {
|
||||
Long clientId = 1L;
|
||||
Wishlist wishlist1 = createTestWishlist(1L, clientId, 10L);
|
||||
Wishlist wishlist2 = createTestWishlist(2L, clientId, 20L);
|
||||
|
||||
when(wishlistRepository.findAllByClientId(clientId)).thenReturn(List.of(wishlist1, wishlist2));
|
||||
|
||||
List<WishlistDTO> result = wishlistService.getWishlistForClientId(clientId);
|
||||
|
||||
assertThat(result).hasSize(2);
|
||||
assertThat(result.get(0).getNoticeId()).isEqualTo(10L);
|
||||
verify(wishlistRepository, times(1)).findAllByClientId(clientId);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien poprawnie dodać lub usunąć element z wishlist")
|
||||
void shouldToggleWishlist() {
|
||||
Client client = createTestClient(1L, "test@example.com");
|
||||
Notice notice = createTestNotice(10L);
|
||||
|
||||
// Scenariusz 1: Element istnieje i powinien zostać usunięty
|
||||
when(wishlistRepository.findByClientAndNotice(client, notice)).thenReturn(Optional.of(new Wishlist()));
|
||||
|
||||
boolean removed = wishlistService.toggleWishlist(client, notice);
|
||||
|
||||
assertThat(removed).isFalse();
|
||||
verify(wishlistRepository, times(1)).delete(any(Wishlist.class));
|
||||
|
||||
// Scenariusz 2: Element nie istnieje i powinien zostać dodany
|
||||
when(wishlistRepository.findByClientAndNotice(client, notice)).thenReturn(Optional.empty());
|
||||
|
||||
boolean added = wishlistService.toggleWishlist(client, notice);
|
||||
|
||||
assertThat(added).isTrue();
|
||||
verify(wishlistRepository, times(1)).save(any(Wishlist.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić listę ogłoszeń w wishlist klienta")
|
||||
void shouldGetNoticesInWishlist() {
|
||||
Long clientId = 1L;
|
||||
Wishlist wishlist1 = createTestWishlist(1L, clientId, 10L);
|
||||
Wishlist wishlist2 = createTestWishlist(2L, clientId, 20L);
|
||||
|
||||
when(wishlistRepository.findAllByClientId(clientId)).thenReturn(List.of(wishlist1, wishlist2));
|
||||
when(noticeService.getNoticeById(10L)).thenReturn(createNoticeDTO(10L, "Ogłoszenie 1"));
|
||||
when(noticeService.getNoticeById(20L)).thenReturn(createNoticeDTO(20L, "Ogłoszenie 2"));
|
||||
|
||||
List<NoticeDTO> result = wishlistService.getNoticesInWishlist(clientId);
|
||||
|
||||
assertThat(result).hasSize(2);
|
||||
assertThat(result.get(0).getNoticeId()).isEqualTo(10L);
|
||||
assertThat(result.get(1).getNoticeId()).isEqualTo(20L);
|
||||
}
|
||||
|
||||
private Wishlist createTestWishlist(Long id, Long clientId, Long noticeId) {
|
||||
Wishlist wishlist = new Wishlist();
|
||||
wishlist.setId(id);
|
||||
|
||||
Client client = new Client();
|
||||
client.setId(clientId);
|
||||
wishlist.setClient(client);
|
||||
|
||||
Notice notice = new Notice();
|
||||
notice.setIdNotice(noticeId);
|
||||
wishlist.setNotice(notice);
|
||||
|
||||
return wishlist;
|
||||
}
|
||||
|
||||
private Client createTestClient(Long id, String email) {
|
||||
Client client = new Client();
|
||||
client.setId(id);
|
||||
client.setEmail(email);
|
||||
return client;
|
||||
}
|
||||
|
||||
private Notice createTestNotice(Long noticeId) {
|
||||
Notice notice = new Notice();
|
||||
notice.setIdNotice(noticeId);
|
||||
return notice;
|
||||
}
|
||||
|
||||
private NoticeDTO createNoticeDTO(Long noticeId, String title) {
|
||||
NoticeDTO noticeDTO = new NoticeDTO();
|
||||
noticeDTO.setNoticeId(noticeId);
|
||||
noticeDTO.setTitle(title);
|
||||
return noticeDTO;
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@DisplayName("Testy dla VariablesController")
|
||||
class VariablesControllerTest {
|
||||
|
||||
private final int port;
|
||||
private final TestRestTemplate restTemplate;
|
||||
|
||||
@Autowired
|
||||
public VariablesControllerTest(@LocalServerPort int port, TestRestTemplate restTemplate) {
|
||||
this.port = port;
|
||||
this.restTemplate = restTemplate;
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić kategorie")
|
||||
void shouldGetCategories() {
|
||||
String url = createURLWithPort("/api/v1/vars/categories");
|
||||
|
||||
ResponseEntity<CategoriesDTO[]> response = restTemplate.getForEntity(url, CategoriesDTO[].class);
|
||||
|
||||
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
assertThat(response.getBody()).isNotNull().isNotEmpty();
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić statusy")
|
||||
void shouldGetStatuses() {
|
||||
String url = createURLWithPort("/api/v1/vars/statuses");
|
||||
|
||||
ResponseEntity<Enums.Status[]> response = restTemplate.getForEntity(url, Enums.Status[].class);
|
||||
|
||||
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
assertThat(response.getBody()).isNotNull().isNotEmpty();
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić role")
|
||||
void shouldGetRoles() {
|
||||
String url = createURLWithPort("/api/v1/vars/roles");
|
||||
|
||||
ResponseEntity<Enums.Role[]> response = restTemplate.getForEntity(url, Enums.Role[].class);
|
||||
|
||||
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
|
||||
assertThat(response.getBody()).isNotNull().isNotEmpty();
|
||||
}
|
||||
|
||||
private String createURLWithPort(String uri) {
|
||||
return "http://localhost:" + port + uri;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
// @Test
|
||||
// void testPostgresDatabase() {
|
||||
// postgresDatabase.add(new Notice("Test Notice", "Username", "Test Description"));
|
||||
// Boolean isRecordAvailable = postgresDatabase.get().size() > 0;
|
||||
// if(isRecordAvailable) {
|
||||
// logger.info("The record is available in the database");
|
||||
// } else {
|
||||
// logger.error("The record is not available in the database");
|
||||
// }
|
||||
// assert isRecordAvailable;
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// void getAllNotices() throws IOException {
|
||||
// OkHttpClient client = new OkHttpClient().newBuilder()
|
||||
// .build();
|
||||
// MediaType mediaType = MediaType.parse("text/plain");
|
||||
// Request request = new Request.Builder()
|
||||
// .url("http://localhost:8080/api/v1/notices/all")
|
||||
// .build();
|
||||
// Response response = client.newCall(request).execute();
|
||||
// }
|
||||
}
|
||||
|
||||
@@ -1,174 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.controller.ClientController;
|
||||
import _11.asktpk.artisanconnectbackend.dto.ClientDTO;
|
||||
import _11.asktpk.artisanconnectbackend.service.ClientService;
|
||||
import com.fasterxml.jackson.databind.ObjectMapper;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
import org.springframework.http.MediaType;
|
||||
import org.springframework.test.web.servlet.MockMvc;
|
||||
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.anyLong;
|
||||
import static org.mockito.Mockito.*;
|
||||
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
|
||||
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
|
||||
|
||||
class ClientControllerTest {
|
||||
|
||||
private MockMvc mockMvc;
|
||||
private final ObjectMapper objectMapper = new ObjectMapper();
|
||||
|
||||
@Mock
|
||||
private ClientService clientService;
|
||||
|
||||
@InjectMocks
|
||||
private ClientController clientController;
|
||||
|
||||
private ClientDTO sampleClientDTO;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
System.out.println("Inicjalizacja konfiguracji testu...");
|
||||
MockitoAnnotations.openMocks(this);
|
||||
mockMvc = MockMvcBuilders.standaloneSetup(clientController).build();
|
||||
|
||||
sampleClientDTO = new ClientDTO();
|
||||
sampleClientDTO.setId(1L);
|
||||
sampleClientDTO.setEmail("test@example.com");
|
||||
sampleClientDTO.setFirstName("John");
|
||||
sampleClientDTO.setLastName("Doe");
|
||||
sampleClientDTO.setRole("USER");
|
||||
System.out.println("Konfiguracja testu zakończona z przykładowym klientem: " + sampleClientDTO);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić listę klientów")
|
||||
void getAllClients_ShouldReturnListOfClients() throws Exception {
|
||||
System.out.println("Uruchamianie testu: getAllClients_ShouldReturnListOfClients");
|
||||
|
||||
List<ClientDTO> clients = Collections.singletonList(sampleClientDTO);
|
||||
when(clientService.getAllClients()).thenReturn(clients);
|
||||
System.out.println("Konfiguracja mocka: clientService.getAllClients() zwróci " + clients);
|
||||
|
||||
mockMvc.perform(get("/api/v1/clients/get/all"))
|
||||
.andExpect(status().isOk())
|
||||
.andExpect(jsonPath("$[0].id").value(1L))
|
||||
.andExpect(jsonPath("$[0].email").value("test@example.com"));
|
||||
|
||||
verify(clientService, times(1)).getAllClients();
|
||||
System.out.println("Test zaliczony: Pomyślnie pobrano listę klientów");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien utworzyć nowego klienta")
|
||||
void addClient_WhenClientNotExists_ShouldCreateClient() throws Exception {
|
||||
System.out.println("Uruchamianie testu: addClient_WhenClientNotExists_ShouldCreateClient");
|
||||
|
||||
when(clientService.clientExists(anyLong())).thenReturn(false);
|
||||
when(clientService.addClient(any(ClientDTO.class))).thenReturn(sampleClientDTO);
|
||||
System.out.println("Konfiguracja mocka: clientService.addClient() zwróci " + sampleClientDTO);
|
||||
|
||||
mockMvc.perform(post("/api/v1/clients/add")
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(objectMapper.writeValueAsString(sampleClientDTO)))
|
||||
.andExpect(status().isCreated())
|
||||
.andExpect(jsonPath("$.id").value(1L));
|
||||
|
||||
verify(clientService, times(1)).addClient(any(ClientDTO.class));
|
||||
System.out.println("Test zaliczony: Pomyślnie utworzono nowego klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić 409 gdy klient istnieje")
|
||||
void addClient_WhenClientExists_ShouldReturnConflict() throws Exception {
|
||||
System.out.println("Uruchamianie testu: addClient_WhenClientExists_ShouldReturnConflict");
|
||||
|
||||
when(clientService.clientExists(anyLong())).thenReturn(true);
|
||||
System.out.println("Konfiguracja mocka: clientService.clientExists() zwróci true");
|
||||
|
||||
mockMvc.perform(post("/api/v1/clients/add")
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(objectMapper.writeValueAsString(sampleClientDTO)))
|
||||
.andExpect(status().isConflict());
|
||||
|
||||
verify(clientService, times(0)).addClient(any(ClientDTO.class));
|
||||
System.out.println("Test zaliczony: Poprawnie zwrócono 409 dla istniejącego klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zaktualizować istniejącego klienta")
|
||||
void updateClient_WhenClientExists_ShouldUpdateClient() throws Exception {
|
||||
System.out.println("Uruchamianie testu: updateClient_WhenClientExists_ShouldUpdateClient");
|
||||
|
||||
when(clientService.clientExists(1L)).thenReturn(true);
|
||||
when(clientService.updateClient(anyLong(), any(ClientDTO.class))).thenReturn(sampleClientDTO);
|
||||
System.out.println("Konfiguracja mocka: clientService.updateClient() zwróci " + sampleClientDTO);
|
||||
|
||||
mockMvc.perform(put("/api/v1/clients/edit/1")
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(objectMapper.writeValueAsString(sampleClientDTO)))
|
||||
.andExpect(status().isOk())
|
||||
.andExpect(jsonPath("$.id").value(1L));
|
||||
|
||||
verify(clientService, times(1)).updateClient(anyLong(), any(ClientDTO.class));
|
||||
System.out.println("Test zaliczony: Pomyślnie zaktualizowano klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić 404 gdy klient nie istnieje")
|
||||
void updateClient_WhenClientNotExists_ShouldReturnNotFound() throws Exception {
|
||||
System.out.println("Uruchamianie testu: updateClient_WhenClientNotExists_ShouldReturnNotFound");
|
||||
|
||||
when(clientService.clientExists(1L)).thenReturn(false);
|
||||
System.out.println("Konfiguracja mocka: clientService.clientExists(1L) zwróci false");
|
||||
|
||||
mockMvc.perform(put("/api/v1/clients/edit/1")
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(objectMapper.writeValueAsString(sampleClientDTO)))
|
||||
.andExpect(status().isNotFound());
|
||||
|
||||
verify(clientService, times(0)).updateClient(anyLong(), any(ClientDTO.class));
|
||||
System.out.println("Test zaliczony: Poprawnie zwrócono 404 dla nieistniejącego klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien usunąć istniejącego klienta")
|
||||
void deleteClient_WhenClientExists_ShouldDeleteClient() throws Exception {
|
||||
System.out.println("Uruchamianie testu: deleteClient_WhenClientExists_ShouldDeleteClient");
|
||||
|
||||
when(clientService.clientExists(1L)).thenReturn(true);
|
||||
doNothing().when(clientService).deleteClient(1L);
|
||||
System.out.println("Konfiguracja mocka: clientService.deleteClient(1L) nie zrobi nic");
|
||||
|
||||
mockMvc.perform(delete("/api/v1/clients/delete/1"))
|
||||
.andExpect(status().isOk());
|
||||
|
||||
verify(clientService, times(1)).deleteClient(1L);
|
||||
System.out.println("Test zaliczony: Pomyślnie usunięto klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Powinien zwrócić 404 gdy klient nie istnieje")
|
||||
void deleteClient_WhenClientNotExists_ShouldReturnNotFound() throws Exception {
|
||||
System.out.println("Uruchamianie testu: deleteClient_WhenClientNotExists_ShouldReturnNotFound");
|
||||
|
||||
when(clientService.clientExists(1L)).thenReturn(false);
|
||||
System.out.println("Konfiguracja mocka: clientService.clientExists(1L) zwróci false");
|
||||
|
||||
mockMvc.perform(delete("/api/v1/clients/delete/1"))
|
||||
.andExpect(status().isNotFound());
|
||||
|
||||
verify(clientService, times(0)).deleteClient(anyLong());
|
||||
System.out.println("Test zaliczony: Poprawnie zwrócono 404 dla nieistniejącego klienta");
|
||||
}
|
||||
}
|
||||
@@ -1,202 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.Mockito;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.dto.ClientDTO;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Client;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Role;
|
||||
import _11.asktpk.artisanconnectbackend.repository.ClientRepository;
|
||||
import _11.asktpk.artisanconnectbackend.repository.RolesRepository;
|
||||
import _11.asktpk.artisanconnectbackend.service.ClientService;
|
||||
|
||||
import jakarta.persistence.EntityNotFoundException;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
public class ClientServiceTest {
|
||||
|
||||
private final ClientRepository clientRepository = Mockito.mock(ClientRepository.class);
|
||||
private final RolesRepository rolesRepository = Mockito.mock(RolesRepository.class);
|
||||
|
||||
private final ClientService clientService = new ClientService(clientRepository, rolesRepository);
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania wszystkich klientów")
|
||||
public void testGetAllClients() {
|
||||
Client client1 = new Client();
|
||||
client1.setId(1L);
|
||||
client1.setEmail("client1@example.com");
|
||||
client1.setRole(new Role());
|
||||
|
||||
Client client2 = new Client();
|
||||
client2.setId(2L);
|
||||
client2.setEmail("client2@example.com");
|
||||
client2.setRole(new Role());
|
||||
|
||||
when(clientRepository.findAll()).thenReturn(List.of(client1, client2));
|
||||
|
||||
List<ClientDTO> clients = clientService.getAllClients();
|
||||
|
||||
assertEquals(2, clients.size(), "Lista klientów powinna zawierać 2 elementy");
|
||||
assertEquals("client1@example.com", clients.getFirst().getEmail(), "Email pierwszego klienta powinien być poprawny");
|
||||
|
||||
System.out.println("Test pobierania wszystkich klientów przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania klienta po ID - klient istnieje")
|
||||
public void testGetClientByIdExists() {
|
||||
// Przygotowanie danych
|
||||
Long clientId = 1L;
|
||||
Client client = new Client();
|
||||
client.setId(clientId);
|
||||
client.setEmail("client@example.com");
|
||||
client.setRole(new Role());
|
||||
|
||||
when(clientRepository.findById(clientId)).thenReturn(Optional.of(client));
|
||||
|
||||
Client retrievedClient = clientService.getClientById(clientId);
|
||||
|
||||
assertNotNull(retrievedClient, "Pobrany klient nie powinien być null");
|
||||
assertEquals(clientId, retrievedClient.getId(), "ID klienta powinno być zgodne");
|
||||
|
||||
System.out.println("Test pobierania klienta po ID (klient istnieje) przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania klienta po ID - klient nie istnieje")
|
||||
public void testGetClientByIdNotExists() {
|
||||
Long clientId = 1L;
|
||||
when(clientRepository.findById(clientId)).thenReturn(Optional.empty());
|
||||
|
||||
Client retrievedClient = clientService.getClientById(clientId);
|
||||
|
||||
assertNull(retrievedClient, "Pobrany klient powinien być null, gdy nie istnieje");
|
||||
|
||||
System.out.println("Test pobierania klienta po ID (klient nie istnieje) przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania klienta po emailu")
|
||||
public void testGetClientByEmail() {
|
||||
String email = "client@example.com";
|
||||
Client client = new Client();
|
||||
client.setEmail(email);
|
||||
|
||||
when(clientRepository.findByEmail(email)).thenReturn(client);
|
||||
|
||||
Client retrievedClient = clientService.getClientByEmail(email);
|
||||
|
||||
assertNotNull(retrievedClient, "Pobrany klient nie powinien być null");
|
||||
assertEquals(email, retrievedClient.getEmail(), "Email klienta powinien być zgodny");
|
||||
|
||||
System.out.println("Test pobierania klienta po emailu przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test dodawania klienta")
|
||||
public void testAddClient() {
|
||||
// Przygotowanie danych
|
||||
ClientDTO clientDTO = new ClientDTO();
|
||||
clientDTO.setEmail("newclient@example.com");
|
||||
clientDTO.setRole("USER");
|
||||
|
||||
Client client = new Client();
|
||||
client.setEmail("newclient@example.com");
|
||||
client.setRole(new Role());
|
||||
|
||||
when(clientRepository.save(any(Client.class))).thenReturn(client);
|
||||
|
||||
ClientDTO addedClient = clientService.addClient(clientDTO);
|
||||
|
||||
assertNotNull(addedClient, "Dodany klient nie powinien być null");
|
||||
assertEquals("newclient@example.com", addedClient.getEmail(), "Email dodanego klienta powinien być poprawny");
|
||||
|
||||
System.out.println("Test dodawania klienta przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test aktualizacji klienta")
|
||||
public void testUpdateClient() {
|
||||
Long clientId = 1L;
|
||||
Client existingClient = new Client();
|
||||
existingClient.setId(clientId);
|
||||
existingClient.setEmail("old@example.com");
|
||||
|
||||
ClientDTO updatedDTO = new ClientDTO();
|
||||
updatedDTO.setEmail("updated@example.com");
|
||||
updatedDTO.setRole("USER");
|
||||
|
||||
Role role = new Role();
|
||||
role.setRole("USER");
|
||||
|
||||
when(clientRepository.findById(clientId)).thenReturn(Optional.of(existingClient));
|
||||
when(rolesRepository.findRoleByRole("USER")).thenReturn(role);
|
||||
when(clientRepository.save(any(Client.class))).thenReturn(existingClient);
|
||||
|
||||
ClientDTO updatedClient = clientService.updateClient(clientId, updatedDTO);
|
||||
|
||||
assertEquals("updated@example.com", updatedClient.getEmail(), "Email klienta powinien być zaktualizowany");
|
||||
|
||||
System.out.println("Test aktualizacji klienta przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test aktualizacji klienta - klient nie istnieje")
|
||||
public void testUpdateClientNotExists() {
|
||||
long clientId = 1L;
|
||||
ClientDTO updatedDTO = new ClientDTO();
|
||||
updatedDTO.setEmail("updated@example.com");
|
||||
|
||||
when(clientRepository.findById(clientId)).thenReturn(Optional.empty());
|
||||
|
||||
assertThrows(EntityNotFoundException.class, () -> clientService.updateClient(clientId, updatedDTO),
|
||||
"Powinien zostać rzucony EntityNotFoundException");
|
||||
|
||||
System.out.println("Test aktualizacji klienta (klient nie istnieje) przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test usuwania klienta")
|
||||
public void testDeleteClient() {
|
||||
Long clientId = 1L;
|
||||
|
||||
clientService.deleteClient(clientId);
|
||||
|
||||
verify(clientRepository, times(1)).deleteById(clientId);
|
||||
|
||||
System.out.println("Test usuwania klienta przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test konwersji encji do DTO")
|
||||
public void testToDto() {
|
||||
Client client = new Client();
|
||||
client.setId(1L);
|
||||
client.setEmail("client@example.com");
|
||||
client.setFirstName("Jan");
|
||||
client.setLastName("Kowalski");
|
||||
client.setImage("image.jpg");
|
||||
Role role = new Role();
|
||||
role.setRole("USER");
|
||||
client.setRole(role);
|
||||
|
||||
ClientDTO dto = clientService.toDto(client);
|
||||
|
||||
assertEquals(1L, dto.getId(), "ID w DTO powinno być zgodne");
|
||||
assertEquals("client@example.com", dto.getEmail(), "Email w DTO powinien być zgodny");
|
||||
assertEquals("Jan", dto.getFirstName(), "Imię w DTO powinno być zgodne");
|
||||
assertEquals("Kowalski", dto.getLastName(), "Nazwisko w DTO powinno być zgodne");
|
||||
assertEquals("image.jpg", dto.getImage(), "Obraz w DTO powinien być zgodny");
|
||||
assertEquals("USER", dto.getRole(), "Rola w DTO powinna być zgodna");
|
||||
|
||||
System.out.println("Test konwersji encji do DTO przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,76 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.security.JwtUtil;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
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.http.MediaType;
|
||||
import org.springframework.test.web.servlet.MockMvc;
|
||||
import org.springframework.test.web.servlet.MvcResult;
|
||||
|
||||
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
|
||||
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
|
||||
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
|
||||
|
||||
@SpringBootTest
|
||||
@AutoConfigureMockMvc
|
||||
class EmailControllerIntegrationTest {
|
||||
|
||||
@Autowired
|
||||
private MockMvc mockMvc;
|
||||
|
||||
@Autowired
|
||||
private JwtUtil jwtUtil;
|
||||
|
||||
@Test
|
||||
@DisplayName("Wysyłanie Maila z waznym tokenem")
|
||||
void testSendEmailWithValidAuthToken() throws Exception {
|
||||
System.out.println("Startowanie testSendEmailWithValidAuthToken");
|
||||
String jsonPayload = """
|
||||
{
|
||||
"to": "test@example.com",
|
||||
"subject": "Test Subject",
|
||||
"body": "Test Body"
|
||||
}
|
||||
""";
|
||||
System.out.println("Wysyłanie JSON payload: " + jsonPayload);
|
||||
|
||||
String jwtToken = "Bearer " + jwtUtil.generateToken("test@example.com", "USER", 1L);
|
||||
|
||||
MvcResult result = mockMvc.perform(post("/api/v1/email/send")
|
||||
.header("Authorization", jwtToken)
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(jsonPayload))
|
||||
.andExpect(status().isOk())
|
||||
.andExpect(content().string("Email wysłany pomyślnie"))
|
||||
.andReturn();
|
||||
|
||||
System.out.println("Status odpowiedzi: " + result.getResponse().getStatus());
|
||||
System.out.println("Treść odpowiedzi: " + result.getResponse().getContentAsString());
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Wysyłanie Maila bez tokena")
|
||||
void testSendEmailWithoutAuthToken() throws Exception {
|
||||
System.out.println("Startowanie testSendEmailWithoutAuthToken");
|
||||
String jsonPayload = """
|
||||
{
|
||||
"to": "test@example.com",
|
||||
"subject": "Test Subject",
|
||||
"body": "Test Body"
|
||||
}
|
||||
""";
|
||||
System.out.println("Wysyłanie JSON payload: " + jsonPayload);
|
||||
|
||||
MvcResult result = mockMvc.perform(post("/api/v1/email/send")
|
||||
.contentType(MediaType.APPLICATION_JSON)
|
||||
.content(jsonPayload))
|
||||
.andExpect(status().isForbidden())
|
||||
.andReturn();
|
||||
|
||||
System.out.println("Status odpowiedzi: " + result.getResponse().getStatus());
|
||||
System.out.println("Treść odpowiedzi: " + result.getResponse().getContentAsString());
|
||||
}
|
||||
}
|
||||
@@ -1,221 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.controller.NoticeController;
|
||||
import _11.asktpk.artisanconnectbackend.dto.*;
|
||||
import _11.asktpk.artisanconnectbackend.service.ClientService;
|
||||
import _11.asktpk.artisanconnectbackend.service.NoticeService;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Enums;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Tools;
|
||||
import jakarta.servlet.http.HttpServletRequest;
|
||||
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.http.HttpStatus;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.anyLong;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class NoticeControllerTest {
|
||||
|
||||
@Mock
|
||||
private final NoticeService noticeService = mock(NoticeService.class);
|
||||
|
||||
@Mock
|
||||
private final ClientService clientService = mock(ClientService.class);
|
||||
|
||||
@Mock
|
||||
private final Tools tools = mock(Tools.class);
|
||||
|
||||
@Mock
|
||||
private HttpServletRequest request;
|
||||
|
||||
@InjectMocks
|
||||
private NoticeController noticeController;
|
||||
|
||||
private NoticeResponseDTO sampleNotice;
|
||||
private NoticeRequestDTO sampleNoticeRequest;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
System.out.println("Inicjalizacja danych testowych przed każdym testem");
|
||||
|
||||
sampleNotice = new NoticeResponseDTO();
|
||||
sampleNotice.setNoticeId(1L);
|
||||
sampleNotice.setTitle("Testowe ogłoszenie");
|
||||
sampleNotice.setClientId(1L);
|
||||
sampleNotice.setDescription("Opis testowego ogłoszenia");
|
||||
sampleNotice.setPrice(100.0);
|
||||
sampleNotice.setCategory(Enums.Category.Woodworking);
|
||||
sampleNotice.setStatus(Enums.Status.ACTIVE);
|
||||
sampleNotice.setPublishDate(LocalDateTime.now());
|
||||
|
||||
sampleNoticeRequest = new NoticeRequestDTO();
|
||||
sampleNoticeRequest.setTitle("Testowe ogłoszenie");
|
||||
sampleNoticeRequest.setClientId(1L);
|
||||
sampleNoticeRequest.setDescription("Opis testowego ogłoszenia");
|
||||
sampleNoticeRequest.setPrice(100.0);
|
||||
sampleNoticeRequest.setCategory(Enums.Category.Woodworking);
|
||||
sampleNoticeRequest.setStatus(Enums.Status.ACTIVE);
|
||||
}
|
||||
|
||||
@Test
|
||||
void getAllNotices_ShouldReturnListOfNotices() {
|
||||
System.out.println("Test: getAllNotices_ShouldReturnListOfNotices - powinien zwrócić listę ogłoszeń");
|
||||
|
||||
when(noticeService.getAllNotices()).thenReturn(List.of(sampleNotice));
|
||||
|
||||
List<NoticeResponseDTO> result = noticeController.getAllNotices();
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.size());
|
||||
assertEquals(sampleNotice.getNoticeId(), result.getFirst().getNoticeId());
|
||||
|
||||
System.out.println("Pomyślnie zwrócono listę ogłoszeń");
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNoticeById_WhenNoticeExists_ShouldReturnNotice() {
|
||||
System.out.println("Test: getNoticeById_WhenNoticeExists_ShouldReturnNotice - powinien zwrócić ogłoszenie gdy istnieje");
|
||||
|
||||
when(noticeService.noticeExists(1L)).thenReturn(true);
|
||||
when(noticeService.getNoticeById(1L)).thenReturn(sampleNotice);
|
||||
|
||||
ResponseEntity<?> response = noticeController.getNoticeById(1L);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode());
|
||||
assertNotNull(response.getBody());
|
||||
assertEquals(sampleNotice, response.getBody());
|
||||
|
||||
System.out.println("Pomyślnie zwrócono istniejące ogłoszenie");
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNoticeById_WhenNoticeNotExists_ShouldReturnNotFound() {
|
||||
System.out.println("Test: getNoticeById_WhenNoticeNotExists_ShouldReturnNotFound - powinien zwrócić 404 gdy ogłoszenie nie istnieje");
|
||||
|
||||
when(noticeService.noticeExists(1L)).thenReturn(false);
|
||||
|
||||
ResponseEntity<?> response = noticeController.getNoticeById(1L);
|
||||
|
||||
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
|
||||
|
||||
System.out.println("Pomyślnie zwrócono status 404 dla nieistniejącego ogłoszenia");
|
||||
}
|
||||
|
||||
@Test
|
||||
void addNotice_WithValidData_ShouldCreateNotice() {
|
||||
System.out.println("Test: addNotice_WithValidData_ShouldCreateNotice - powinien utworzyć nowe ogłoszenie przy poprawnych danych");
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(1L);
|
||||
when(clientService.clientExists(1L)).thenReturn(true);
|
||||
when(noticeService.addNotice(any(NoticeRequestDTO.class))).thenReturn(1L);
|
||||
|
||||
ResponseEntity<NoticeAdditionDTO> response = noticeController.addNotice(sampleNoticeRequest, request);
|
||||
|
||||
assertEquals(HttpStatus.CREATED, response.getStatusCode());
|
||||
assertNotNull(response.getBody());
|
||||
assertEquals(1L, response.getBody().getNoticeId());
|
||||
assertEquals("Dodano ogłoszenie.", response.getBody().getMessage());
|
||||
|
||||
System.out.println("Pomyślnie utworzono nowe ogłoszenie");
|
||||
}
|
||||
|
||||
@Test
|
||||
void addNotice_WithInvalidCategory_ShouldReturnBadRequest() {
|
||||
System.out.println("Test: addNotice_WithInvalidCategory_ShouldReturnBadRequest - powinien zwrócić błąd dla nieprawidłowej kategorii");
|
||||
|
||||
sampleNoticeRequest.setCategory(null);
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(1L);
|
||||
when(clientService.clientExists(1L)).thenReturn(true);
|
||||
|
||||
ResponseEntity<NoticeAdditionDTO> response = noticeController.addNotice(sampleNoticeRequest, request);
|
||||
|
||||
assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
|
||||
assertNotNull(response.getBody());
|
||||
assertEquals("Nie ma takiej kategorii", response.getBody().getMessage());
|
||||
|
||||
System.out.println("Pomyślnie zwrócono błąd dla nieprawidłowej kategorii");
|
||||
}
|
||||
|
||||
@Test
|
||||
void addNotice_WhenClientNotExists_ShouldReturnBadRequest() {
|
||||
System.out.println("Test: addNotice_WhenClientNotExists_ShouldReturnBadRequest - powinien zwrócić błąd gdy klient nie istnieje");
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(1L);
|
||||
when(clientService.clientExists(1L)).thenReturn(false);
|
||||
|
||||
ResponseEntity<NoticeAdditionDTO> response = noticeController.addNotice(sampleNoticeRequest, request);
|
||||
|
||||
assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
|
||||
assertNotNull(response.getBody());
|
||||
assertTrue(response.getBody().getMessage().contains("Nie znaleziono klienta o ID:"));
|
||||
|
||||
System.out.println("Pomyślnie zwrócono błąd dla nieistniejącego klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
void editNotice_WhenNoticeExistsAndOwnedByClient_ShouldUpdateNotice() {
|
||||
System.out.println("Test: editNotice_WhenNoticeExistsAndOwnedByClient_ShouldUpdateNotice - powinien zaktualizować ogłoszenie gdy istnieje i należy do klienta");
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(1L);
|
||||
when(noticeService.noticeExists(1L)).thenReturn(true);
|
||||
when(noticeService.isNoticeOwnedByClient(1L, 1L)).thenReturn(true);
|
||||
when(noticeService.updateNotice(anyLong(), any(NoticeRequestDTO.class))).thenReturn(sampleNotice);
|
||||
|
||||
ResponseEntity<Object> response = noticeController.editNotice(1L, sampleNoticeRequest, request);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode());
|
||||
assertNotNull(response.getBody());
|
||||
assertEquals(sampleNotice, response.getBody());
|
||||
|
||||
System.out.println("Pomyślnie zaktualizowano ogłoszenie należące do klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
void editNotice_WhenNoticeNotOwnedByClient_ShouldReturnForbidden() {
|
||||
System.out.println("Test: editNotice_WhenNoticeNotOwnedByClient_ShouldReturnForbidden - powinien zwrócić błąd 403 gdy ogłoszenie nie należy do klienta");
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(2L);
|
||||
when(noticeService.noticeExists(1L)).thenReturn(true);
|
||||
when(noticeService.isNoticeOwnedByClient(1L, 2L)).thenReturn(false);
|
||||
|
||||
ResponseEntity<Object> response = noticeController.editNotice(1L, sampleNoticeRequest, request);
|
||||
|
||||
assertEquals(HttpStatus.FORBIDDEN, response.getStatusCode());
|
||||
assertNotNull(response.getBody());
|
||||
assertTrue(((RequestResponseDTO) response.getBody()).getMessage().contains("Nie masz uprawnień"));
|
||||
|
||||
System.out.println("Pomyślnie zwrócono błąd 403 dla próby edycji nie swojego ogłoszenia");
|
||||
}
|
||||
|
||||
@Test
|
||||
void deleteNotice_WhenNoticeExistsAndOwnedByClient_ShouldDeleteNotice() {
|
||||
System.out.println("Test: deleteNotice_WhenNoticeExistsAndOwnedByClient_ShouldDeleteNotice - powinien usunąć ogłoszenie gdy istnieje i należy do klienta");
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(1L);
|
||||
when(noticeService.noticeExists(1L)).thenReturn(true);
|
||||
when(noticeService.isNoticeOwnedByClient(1L, 1L)).thenReturn(true);
|
||||
|
||||
ResponseEntity<RequestResponseDTO> response = noticeController.deleteNotice(1L, request);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode());
|
||||
assertNotNull(response.getBody());
|
||||
assertTrue(response.getBody().getMessage().contains("Pomyślnie usunięto"));
|
||||
|
||||
verify(noticeService, times(1)).deleteNotice(1L);
|
||||
|
||||
System.out.println("Pomyślnie usunięto ogłoszenie należące do klienta");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,200 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.dto.AttributeDto;
|
||||
import _11.asktpk.artisanconnectbackend.dto.NoticeRequestDTO;
|
||||
import _11.asktpk.artisanconnectbackend.dto.NoticeResponseDTO;
|
||||
import _11.asktpk.artisanconnectbackend.entities.*;
|
||||
import _11.asktpk.artisanconnectbackend.repository.*;
|
||||
import _11.asktpk.artisanconnectbackend.service.ImageService;
|
||||
import _11.asktpk.artisanconnectbackend.service.NoticeService;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Enums;
|
||||
import jakarta.persistence.EntityNotFoundException;
|
||||
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.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class NoticeServiceTest {
|
||||
|
||||
@Mock
|
||||
private final NoticeRepository noticeRepository = mock(NoticeRepository.class);
|
||||
|
||||
@Mock
|
||||
private final ClientRepository clientRepository = mock(ClientRepository.class);
|
||||
|
||||
|
||||
@Mock
|
||||
private final AttributesRepository attributesRepository = mock(AttributesRepository.class);
|
||||
|
||||
@Mock
|
||||
private final AttributeValuesRepository attributeValuesRepository = mock(AttributeValuesRepository.class);
|
||||
|
||||
@Mock
|
||||
private final AttributesNoticeRepository attributesNoticeRepository = mock(AttributesNoticeRepository.class);
|
||||
|
||||
@InjectMocks
|
||||
private NoticeService noticeService;
|
||||
|
||||
private Notice sampleNotice;
|
||||
private NoticeRequestDTO sampleNoticeRequest;
|
||||
private Client sampleClient;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
System.out.println("Inicjalizacja danych testowych przed każdym testem");
|
||||
|
||||
sampleClient = new Client();
|
||||
sampleClient.setId(1L);
|
||||
sampleClient.setEmail("test@example.com");
|
||||
|
||||
sampleNotice = new Notice();
|
||||
sampleNotice.setIdNotice(1L);
|
||||
sampleNotice.setTitle("Testowe ogłoszenie");
|
||||
sampleNotice.setClient(sampleClient);
|
||||
sampleNotice.setDescription("Opis testowego ogłoszenia");
|
||||
sampleNotice.setPrice(100.0);
|
||||
sampleNotice.setCategory(Enums.Category.Woodworking);
|
||||
sampleNotice.setStatus(Enums.Status.ACTIVE);
|
||||
sampleNotice.setPublishDate(LocalDateTime.now());
|
||||
|
||||
sampleNoticeRequest = new NoticeRequestDTO();
|
||||
sampleNoticeRequest.setTitle("Testowe ogłoszenie");
|
||||
sampleNoticeRequest.setClientId(1L);
|
||||
sampleNoticeRequest.setDescription("Opis testowego ogłoszenia");
|
||||
sampleNoticeRequest.setPrice(100.0);
|
||||
sampleNoticeRequest.setCategory(Enums.Category.Woodworking);
|
||||
sampleNoticeRequest.setStatus(Enums.Status.ACTIVE);
|
||||
}
|
||||
|
||||
@Test
|
||||
void getAllNotices_ShouldReturnListOfNotices() {
|
||||
System.out.println("Test: getAllNotices_ShouldReturnListOfNotices - powinien zwrócić listę ogłoszeń");
|
||||
|
||||
when(noticeRepository.findAll()).thenReturn(List.of(sampleNotice));
|
||||
|
||||
List<NoticeResponseDTO> result = noticeService.getAllNotices();
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.size());
|
||||
assertEquals(sampleNotice.getIdNotice(), result.getFirst().getNoticeId());
|
||||
|
||||
System.out.println("Pomyślnie zwrócono listę ogłoszeń");
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNoticeById_WhenNoticeExists_ShouldReturnNotice() {
|
||||
System.out.println("Test: getNoticeById_WhenNoticeExists_ShouldReturnNotice - powinien zwrócić ogłoszenie gdy istnieje");
|
||||
|
||||
when(noticeRepository.findById(1L)).thenReturn(Optional.of(sampleNotice));
|
||||
|
||||
NoticeResponseDTO result = noticeService.getNoticeById(1L);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(sampleNotice.getIdNotice(), result.getNoticeId());
|
||||
|
||||
System.out.println("Pomyślnie zwrócono istniejące ogłoszenie");
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNoticeById_WhenNoticeNotExists_ShouldThrowException() {
|
||||
System.out.println("Test: getNoticeById_WhenNoticeNotExists_ShouldThrowException - powinien rzucić wyjątek gdy ogłoszenie nie istnieje");
|
||||
|
||||
when(noticeRepository.findById(1L)).thenReturn(Optional.empty());
|
||||
|
||||
assertThrows(EntityNotFoundException.class, () -> noticeService.getNoticeById(1L));
|
||||
|
||||
System.out.println("Pomyślnie rzucono wyjątek dla nieistniejącego ogłoszenia");
|
||||
}
|
||||
|
||||
@Test
|
||||
void addNotice_WithValidData_ShouldCreateNotice() {
|
||||
System.out.println("Test: addNotice_WithValidData_ShouldCreateNotice - powinien utworzyć nowe ogłoszenie przy poprawnych danych");
|
||||
|
||||
when(clientRepository.findById(1L)).thenReturn(Optional.of(sampleClient));
|
||||
when(noticeRepository.save(any(Notice.class))).thenReturn(sampleNotice);
|
||||
|
||||
Long result = noticeService.addNotice(sampleNoticeRequest);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1L, result);
|
||||
|
||||
verify(noticeRepository, times(1)).save(any(Notice.class));
|
||||
|
||||
System.out.println("Pomyślnie utworzono nowe ogłoszenie");
|
||||
}
|
||||
|
||||
@Test
|
||||
void addNotice_WithAttributes_ShouldSaveAttributes() {
|
||||
System.out.println("Test: addNotice_WithAttributes_ShouldSaveAttributes - powinien zapisać atrybuty ogłoszenia");
|
||||
|
||||
AttributeDto attributeDto = new AttributeDto();
|
||||
attributeDto.setName("Materiał");
|
||||
attributeDto.setValue("Drewno");
|
||||
sampleNoticeRequest.setAttributes(List.of(attributeDto));
|
||||
|
||||
when(clientRepository.findById(1L)).thenReturn(Optional.of(sampleClient));
|
||||
when(noticeRepository.save(any(Notice.class))).thenReturn(sampleNotice);
|
||||
when(attributesRepository.findByName(anyString())).thenReturn(Optional.empty());
|
||||
when(attributeValuesRepository.findByAttributeAndValue(any(), anyString())).thenReturn(Optional.empty());
|
||||
|
||||
Long result = noticeService.addNotice(sampleNoticeRequest);
|
||||
|
||||
assertNotNull(result);
|
||||
verify(attributesNoticeRepository, times(1)).save(any(AttributesNotice.class));
|
||||
|
||||
System.out.println("Pomyślnie zapisano atrybuty ogłoszenia");
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
void deleteNotice_WhenNoticeExists_ShouldDeleteNotice() {
|
||||
System.out.println("Test: deleteNotice_WhenNoticeExists_ShouldDeleteNotice - powinien usunąć istniejące ogłoszenie");
|
||||
|
||||
when(noticeRepository.existsById(1L)).thenReturn(true);
|
||||
|
||||
noticeService.deleteNotice(1L);
|
||||
|
||||
verify(noticeRepository, times(1)).deleteById(1L);
|
||||
|
||||
System.out.println("Pomyślnie usunięto istniejące ogłoszenie");
|
||||
}
|
||||
|
||||
@Test
|
||||
void isNoticeOwnedByClient_WhenOwned_ShouldReturnTrue() {
|
||||
System.out.println("Test: isNoticeOwnedByClient_WhenOwned_ShouldReturnTrue - powinien zwrócić true gdy ogłoszenie należy do klienta");
|
||||
|
||||
when(noticeRepository.existsByIdNoticeAndClientId(1L, 1L)).thenReturn(true);
|
||||
|
||||
boolean result = noticeService.isNoticeOwnedByClient(1L, 1L);
|
||||
|
||||
assertTrue(result);
|
||||
|
||||
System.out.println("Pomyślnie zwrócono true dla ogłoszenia należącego do klienta");
|
||||
}
|
||||
|
||||
@Test
|
||||
void boostNotice_ShouldUpdatePublishDate() {
|
||||
System.out.println("Test: boostNotice_ShouldUpdatePublishDate - powinien zaktualizować datę publikacji");
|
||||
|
||||
when(noticeRepository.findById(1L)).thenReturn(Optional.of(sampleNotice));
|
||||
when(noticeRepository.save(any(Notice.class))).thenReturn(sampleNotice);
|
||||
|
||||
noticeService.boostNotice(1L);
|
||||
|
||||
assertNotNull(sampleNotice.getPublishDate());
|
||||
verify(noticeRepository, times(1)).save(sampleNotice);
|
||||
|
||||
System.out.println("Pomyślnie zaktualizowano datę publikacji ogłoszenia");
|
||||
}
|
||||
}
|
||||
@@ -1,235 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.controller.OrderController;
|
||||
import _11.asktpk.artisanconnectbackend.dto.*;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Client;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Notice;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Order;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Payment;
|
||||
import _11.asktpk.artisanconnectbackend.service.OrderService;
|
||||
import _11.asktpk.artisanconnectbackend.service.PaymentService;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Enums;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Tools;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.Mockito;
|
||||
import org.springframework.http.HttpStatus;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
|
||||
import jakarta.servlet.http.HttpServletRequest;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
public class OrderControllerTest {
|
||||
|
||||
private final OrderService orderService = Mockito.mock(OrderService.class);
|
||||
private final PaymentService paymentService = Mockito.mock(PaymentService.class);
|
||||
private final Tools tools = Mockito.mock(Tools.class);
|
||||
private final HttpServletRequest request = Mockito.mock(HttpServletRequest.class);
|
||||
|
||||
private OrderController orderController;
|
||||
|
||||
@BeforeEach
|
||||
public void setUp() {
|
||||
orderController = new OrderController(orderService, paymentService, tools);
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test dodawania zamówienia")
|
||||
public void testAddOrder() {
|
||||
OrderDTO orderDTO = new OrderDTO();
|
||||
orderDTO.setClientId(1L);
|
||||
orderDTO.setNoticeId(1L);
|
||||
orderDTO.setOrderType(Enums.OrderType.ACTIVATION);
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(1L);
|
||||
when(orderService.addOrder(orderDTO)).thenReturn(1L);
|
||||
|
||||
ResponseEntity<?> response = orderController.addClient(orderDTO, request);
|
||||
|
||||
assertEquals(HttpStatus.CREATED, response.getStatusCode(), "Status odpowiedzi powinien być 201 CREATED");
|
||||
assertEquals(1L, response.getBody(), "Ciało odpowiedzi powinno zawierać ID zamówienia");
|
||||
|
||||
System.out.println("Test dodawania zamówienia przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test zmiany statusu zamówienia")
|
||||
public void testChangeStatus() {
|
||||
OrderStatusDTO orderStatusDTO = new OrderStatusDTO();
|
||||
orderStatusDTO.setId(1L);
|
||||
orderStatusDTO.setStatus(Enums.OrderStatus.COMPLETED);
|
||||
|
||||
when(orderService.changeOrderStatus(1L, Enums.OrderStatus.COMPLETED)).thenReturn(1L);
|
||||
|
||||
ResponseEntity<?> response = orderController.changeStatus(orderStatusDTO);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
|
||||
assertEquals(1L, response.getBody(), "Ciało odpowiedzi powinno zawierać ID zamówienia");
|
||||
|
||||
System.out.println("Test zmiany statusu zamówienia przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania tokena płatności")
|
||||
public void testFetchToken() {
|
||||
Long orderId = 1L;
|
||||
Order order = new Order();
|
||||
order.setId(orderId);
|
||||
order.setAmount(10.00);
|
||||
order.setOrderType(Enums.OrderType.ACTIVATION);
|
||||
|
||||
Client client = new Client();
|
||||
client.setId(1L);
|
||||
client.setEmail("test@example.com");
|
||||
client.setFirstName("Jan");
|
||||
client.setLastName("Kowalski");
|
||||
|
||||
Notice notice = new Notice();
|
||||
notice.setTitle("Test Notice");
|
||||
|
||||
order.setClient(client);
|
||||
order.setNotice(notice);
|
||||
|
||||
OAuthPaymentResponseDTO oAuthResponse = new OAuthPaymentResponseDTO();
|
||||
oAuthResponse.setAccess_token("testAccessToken");
|
||||
|
||||
when(orderService.getOrderById(orderId)).thenReturn(order);
|
||||
when(paymentService.getOAuthToken()).thenReturn(oAuthResponse);
|
||||
when(paymentService.createTransaction(eq(order), eq("testAccessToken"), any(TransactionPaymentRequestDTO.class)))
|
||||
.thenReturn("http://payment.url");
|
||||
|
||||
ResponseEntity<?> response = orderController.fetchToken(orderId);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
|
||||
assertEquals("http://payment.url", response.getBody(), "Ciało odpowiedzi powinno zawierać URL płatności");
|
||||
|
||||
System.out.println("Test pobierania tokena płatności przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania wszystkich zamówień")
|
||||
public void testGetAllOrders() {
|
||||
Long clientId = 1L;
|
||||
Order order1 = new Order();
|
||||
order1.setId(1L);
|
||||
order1.setOrderType(Enums.OrderType.ACTIVATION);
|
||||
order1.setStatus(Enums.OrderStatus.PENDING);
|
||||
order1.setAmount(10.00);
|
||||
order1.setCreatedAt(LocalDateTime.now());
|
||||
|
||||
Order order2 = new Order();
|
||||
order2.setId(2L);
|
||||
order2.setOrderType(Enums.OrderType.BOOST);
|
||||
order2.setStatus(Enums.OrderStatus.COMPLETED);
|
||||
order2.setAmount(8.00);
|
||||
order2.setCreatedAt(LocalDateTime.now());
|
||||
|
||||
List<Order> orders = List.of(order1, order2);
|
||||
|
||||
Payment payment1 = new Payment();
|
||||
payment1.setIdPayment(1L);
|
||||
payment1.setAmount(10.00);
|
||||
payment1.setStatus(Enums.PaymentStatus.PENDING);
|
||||
payment1.setTransactionPaymentUrl("http://payment.url/1");
|
||||
payment1.setTransactionId("trans1");
|
||||
|
||||
Payment payment2 = new Payment();
|
||||
payment2.setIdPayment(2L);
|
||||
payment2.setAmount(8.00);
|
||||
payment2.setStatus(Enums.PaymentStatus.CORRECT);
|
||||
payment2.setTransactionPaymentUrl("http://payment.url/2");
|
||||
payment2.setTransactionId("trans2");
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(clientId);
|
||||
when(orderService.getOrdersByClientId(clientId)).thenReturn(orders);
|
||||
when(paymentService.getPaymentsByOrderId(1L)).thenReturn(List.of(payment1));
|
||||
when(paymentService.getPaymentsByOrderId(2L)).thenReturn(List.of(payment2));
|
||||
|
||||
ResponseEntity<List<OrderWithPaymentsDTO>> response = orderController.getOrders(request);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
|
||||
List<OrderWithPaymentsDTO> dtoList = response.getBody();
|
||||
assertNotNull(dtoList, "Lista DTO nie powinna być null");
|
||||
assertEquals(2, dtoList.size(), "Lista DTO powinna zawierać 2 elementy");
|
||||
|
||||
OrderWithPaymentsDTO dto1 = dtoList.getFirst();
|
||||
assertEquals(1L, dto1.getOrderId(), "ID zamówienia w DTO powinno być 1");
|
||||
assertEquals("ACTIVATION", dto1.getOrderType(), "Typ zamówienia w DTO powinien być ACTIVATION");
|
||||
assertEquals("PENDING", dto1.getStatus(), "Status zamówienia w DTO powinien być PENDING");
|
||||
assertEquals(10.00, dto1.getAmount(), "Kwota zamówienia w DTO powinna być 10.00");
|
||||
assertEquals(1, dto1.getPayments().size(), "Liczba płatności w DTO powinna być 1");
|
||||
|
||||
System.out.println("Test pobierania wszystkich zamówień przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania zamówienia po ID")
|
||||
public void testGetOrderById() {
|
||||
Long clientId = 1L;
|
||||
Long orderId = 1L;
|
||||
|
||||
Order order = new Order();
|
||||
order.setId(orderId);
|
||||
order.setOrderType(Enums.OrderType.ACTIVATION);
|
||||
order.setStatus(Enums.OrderStatus.PENDING);
|
||||
order.setAmount(10.00);
|
||||
order.setCreatedAt(LocalDateTime.now());
|
||||
|
||||
Client client = new Client();
|
||||
client.setId(clientId);
|
||||
order.setClient(client);
|
||||
|
||||
Payment payment = new Payment();
|
||||
payment.setIdPayment(1L);
|
||||
payment.setAmount(10.00);
|
||||
payment.setStatus(Enums.PaymentStatus.PENDING);
|
||||
payment.setTransactionPaymentUrl("http://payment.url/1");
|
||||
payment.setTransactionId("trans1");
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(clientId);
|
||||
when(orderService.getOrderById(orderId)).thenReturn(order);
|
||||
when(paymentService.getPaymentsByOrderId(orderId)).thenReturn(List.of(payment));
|
||||
|
||||
ResponseEntity<OrderWithPaymentsDTO> response = orderController.getOrderById(request, orderId);
|
||||
|
||||
assertEquals(HttpStatus.OK, response.getStatusCode(), "Status odpowiedzi powinien być 200 OK");
|
||||
OrderWithPaymentsDTO dto = response.getBody();
|
||||
assertNotNull(dto, "DTO nie powinno być null");
|
||||
assertEquals(orderId, dto.getOrderId(), "ID zamówienia w DTO powinno być równe podanemu");
|
||||
|
||||
System.out.println("Test pobierania zamówienia po ID przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania zamówienia po ID - brak uprawnień")
|
||||
public void testGetOrderByIdForbidden() {
|
||||
Long clientId = 1L;
|
||||
Long orderId = 1L;
|
||||
|
||||
Order order = new Order();
|
||||
order.setId(orderId);
|
||||
order.setOrderType(Enums.OrderType.ACTIVATION);
|
||||
order.setStatus(Enums.OrderStatus.PENDING);
|
||||
order.setAmount(10.00);
|
||||
order.setCreatedAt(LocalDateTime.now());
|
||||
|
||||
Client client = new Client();
|
||||
client.setId(2L);
|
||||
order.setClient(client);
|
||||
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(clientId);
|
||||
when(orderService.getOrderById(orderId)).thenReturn(order);
|
||||
|
||||
ResponseEntity<OrderWithPaymentsDTO> response = orderController.getOrderById(request, orderId);
|
||||
|
||||
assertEquals(HttpStatus.FORBIDDEN, response.getStatusCode(), "Status odpowiedzi powinien być 403 FORBIDDEN");
|
||||
|
||||
System.out.println("Test pobierania zamówienia po ID - brak uprawnień przeszedł pomyślnie.");
|
||||
}
|
||||
}
|
||||
@@ -1,123 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import org.junit.jupiter.api.DisplayName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.Mockito;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.dto.OrderDTO;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Client;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Notice;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Order;
|
||||
import _11.asktpk.artisanconnectbackend.repository.ClientRepository;
|
||||
import _11.asktpk.artisanconnectbackend.repository.NoticeRepository;
|
||||
import _11.asktpk.artisanconnectbackend.repository.OrderRepository;
|
||||
import _11.asktpk.artisanconnectbackend.service.OrderService;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Enums;
|
||||
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
public class OrderServiceTest {
|
||||
|
||||
private final OrderRepository orderRepository = Mockito.mock(OrderRepository.class);
|
||||
private final ClientRepository clientRepository = Mockito.mock(ClientRepository.class);
|
||||
private final NoticeRepository noticeRepository = Mockito.mock(NoticeRepository.class);
|
||||
private final OrderService orderService = new OrderService(orderRepository, clientRepository, noticeRepository);
|
||||
|
||||
@Test
|
||||
@DisplayName("Test dodawania zamówienia")
|
||||
public void testAddOrder() {
|
||||
OrderDTO orderDTO = new OrderDTO();
|
||||
orderDTO.setClientId(1L);
|
||||
orderDTO.setNoticeId(1L);
|
||||
orderDTO.setOrderType(Enums.OrderType.ACTIVATION);
|
||||
|
||||
Client client = new Client();
|
||||
client.setId(1L);
|
||||
|
||||
Notice notice = new Notice();
|
||||
notice.setIdNotice(1L);
|
||||
|
||||
Order savedOrder = new Order();
|
||||
savedOrder.setId(1L);
|
||||
savedOrder.setClient(client);
|
||||
savedOrder.setNotice(notice);
|
||||
savedOrder.setOrderType(Enums.OrderType.ACTIVATION);
|
||||
savedOrder.setStatus(Enums.OrderStatus.PENDING);
|
||||
savedOrder.setAmount(10.00);
|
||||
savedOrder.setCreatedAt(LocalDateTime.now());
|
||||
savedOrder.setUpdatedAt(LocalDateTime.now());
|
||||
|
||||
when(clientRepository.findById(1L)).thenReturn(Optional.of(client));
|
||||
when(noticeRepository.findById(1L)).thenReturn(Optional.of(notice));
|
||||
when(orderRepository.save(any(Order.class))).thenReturn(savedOrder);
|
||||
|
||||
Long orderId = orderService.addOrder(orderDTO);
|
||||
|
||||
assertNotNull(orderId, "ID zamówienia nie powinno być null");
|
||||
assertEquals(1L, orderId, "ID zamówienia powinno być równe 1");
|
||||
verify(orderRepository, times(1)).save(any(Order.class));
|
||||
|
||||
System.out.println("Test dodawania zamówienia przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test zmiany statusu zamówienia")
|
||||
public void testChangeOrderStatus() {
|
||||
Long orderId = 1L;
|
||||
Enums.OrderStatus newStatus = Enums.OrderStatus.COMPLETED;
|
||||
|
||||
Order existingOrder = new Order();
|
||||
existingOrder.setId(orderId);
|
||||
existingOrder.setStatus(Enums.OrderStatus.PENDING);
|
||||
|
||||
when(orderRepository.findById(orderId)).thenReturn(Optional.of(existingOrder));
|
||||
when(orderRepository.save(any(Order.class))).thenReturn(existingOrder);
|
||||
|
||||
Long updatedOrderId = orderService.changeOrderStatus(orderId, newStatus);
|
||||
|
||||
assertNotNull(updatedOrderId, "ID zaktualizowanego zamówienia nie powinno być null");
|
||||
assertEquals(orderId, updatedOrderId, "ID zaktualizowanego zamówienia powinno być równe podanemu");
|
||||
assertEquals(newStatus, existingOrder.getStatus(), "Status zamówienia powinien zostać zaktualizowany");
|
||||
verify(orderRepository, times(1)).save(existingOrder);
|
||||
|
||||
System.out.println("Test zmiany statusu zamówienia przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania zamówienia po ID")
|
||||
public void testGetOrderById() {
|
||||
Long orderId = 1L;
|
||||
Order order = new Order();
|
||||
order.setId(orderId);
|
||||
|
||||
when(orderRepository.findById(orderId)).thenReturn(Optional.of(order));
|
||||
|
||||
Order retrievedOrder = orderService.getOrderById(orderId);
|
||||
|
||||
assertNotNull(retrievedOrder, "Pobrane zamówienie nie powinno być null");
|
||||
assertEquals(orderId, retrievedOrder.getId(), "ID pobranego zamówienia powinno być równe podanemu");
|
||||
|
||||
System.out.println("Test pobierania zamówienia po ID przeszedł pomyślnie.");
|
||||
}
|
||||
|
||||
@Test
|
||||
@DisplayName("Test pobierania zamówień po ID klienta")
|
||||
public void testGetOrdersByClientId() {
|
||||
Long clientId = 1L;
|
||||
List<Order> orders = List.of(new Order(), new Order());
|
||||
|
||||
when(orderRepository.findByClientId(clientId)).thenReturn(orders);
|
||||
|
||||
List<Order> retrievedOrders = orderService.getOrdersByClientId(clientId);
|
||||
|
||||
assertNotNull(retrievedOrders, "Lista zamówień nie powinna być null");
|
||||
assertEquals(2, retrievedOrders.size(), "Lista zamówień powinna zawierać 2 elementy");
|
||||
|
||||
System.out.println("Test pobierania zamówień po ID klienta przeszedł pomyślnie.");
|
||||
}
|
||||
}
|
||||
@@ -1,40 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.security.JwtUtil;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Tools;
|
||||
import jakarta.servlet.http.HttpServletRequest;
|
||||
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 static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class ToolsTest {
|
||||
|
||||
@Mock
|
||||
private JwtUtil jwtUtil;
|
||||
|
||||
@Mock
|
||||
private HttpServletRequest request;
|
||||
|
||||
@InjectMocks
|
||||
private Tools tools;
|
||||
|
||||
@Test
|
||||
void getClientIdFromRequest_shouldReturnClientIdWhenTokenValid() {
|
||||
String token = "valid.token.here";
|
||||
Long expectedClientId = 1L;
|
||||
|
||||
when(request.getHeader("Authorization")).thenReturn("Bearer " + token);
|
||||
when(jwtUtil.extractUserId(token)).thenReturn(expectedClientId);
|
||||
|
||||
Long result = tools.getClientIdFromRequest(request);
|
||||
|
||||
assertEquals(expectedClientId, result);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -1,107 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.controller.WishlistController;
|
||||
import _11.asktpk.artisanconnectbackend.dto.NoticeResponseDTO;
|
||||
import _11.asktpk.artisanconnectbackend.dto.RequestResponseDTO;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Client;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Notice;
|
||||
import _11.asktpk.artisanconnectbackend.service.ClientService;
|
||||
import _11.asktpk.artisanconnectbackend.service.NoticeService;
|
||||
import _11.asktpk.artisanconnectbackend.service.WishlistService;
|
||||
import _11.asktpk.artisanconnectbackend.utils.Tools;
|
||||
import jakarta.servlet.http.HttpServletRequest;
|
||||
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.http.ResponseEntity;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class WishlistControllerTest {
|
||||
|
||||
@Mock
|
||||
private WishlistService wishlistService;
|
||||
|
||||
@Mock
|
||||
private ClientService clientService;
|
||||
|
||||
@Mock
|
||||
private NoticeService noticeService;
|
||||
|
||||
@Mock
|
||||
private Tools tools;
|
||||
|
||||
@Mock
|
||||
private HttpServletRequest request;
|
||||
|
||||
@InjectMocks
|
||||
private WishlistController wishlistController;
|
||||
|
||||
private final Long testClientId = 1L;
|
||||
private final Long testNoticeId = 1L;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
when(tools.getClientIdFromRequest(request)).thenReturn(testClientId);
|
||||
}
|
||||
|
||||
@Test
|
||||
void toggleWishlist_shouldReturnSuccessWhenNoticeExists() {
|
||||
NoticeResponseDTO noticeResponse = new NoticeResponseDTO();
|
||||
noticeResponse.setNoticeId(testNoticeId);
|
||||
|
||||
when(noticeService.getNoticeById(testNoticeId)).thenReturn(noticeResponse);
|
||||
when(clientService.getClientById(testClientId)).thenReturn(new Client());
|
||||
when(noticeService.getNoticeByIdEntity(testNoticeId)).thenReturn(new Notice());
|
||||
when(wishlistService.toggleWishlist(any(), any())).thenReturn(true);
|
||||
|
||||
ResponseEntity<RequestResponseDTO> response = wishlistController.toggleWishlist(testNoticeId, request);
|
||||
|
||||
assertEquals(200, response.getStatusCodeValue());
|
||||
assertNotNull(response.getBody());
|
||||
assertEquals("Wishlist entry added", response.getBody().getMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void toggleWishlist_shouldReturnBadRequestWhenNoticeNotFound() {
|
||||
when(noticeService.getNoticeById(testNoticeId)).thenReturn(null);
|
||||
|
||||
ResponseEntity<RequestResponseDTO> response = wishlistController.toggleWishlist(testNoticeId, request);
|
||||
|
||||
assertEquals(400, response.getStatusCodeValue());
|
||||
assertNotNull(response.getBody());
|
||||
assertEquals("Notice not found", response.getBody().getMessage());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getWishlistForClient_shouldReturnNoticeList() {
|
||||
NoticeResponseDTO noticeResponse = new NoticeResponseDTO();
|
||||
noticeResponse.setNoticeId(testNoticeId);
|
||||
|
||||
when(wishlistService.getNoticesInWishlist(testClientId)).thenReturn(Collections.singletonList(noticeResponse));
|
||||
|
||||
List<NoticeResponseDTO> result = wishlistController.getWishlistForClient(request);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.size());
|
||||
assertEquals(testNoticeId, result.getFirst().getNoticeId());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getWishlistForClient_shouldReturnEmptyListWhenNoEntries() {
|
||||
when(wishlistService.getNoticesInWishlist(testClientId)).thenReturn(Collections.emptyList());
|
||||
|
||||
List<NoticeResponseDTO> result = wishlistController.getWishlistForClient(request);
|
||||
|
||||
assertNotNull(result);
|
||||
assertTrue(result.isEmpty());
|
||||
}
|
||||
}
|
||||
@@ -1,101 +0,0 @@
|
||||
package _11.asktpk.artisanconnectbackend;
|
||||
|
||||
import _11.asktpk.artisanconnectbackend.dto.NoticeResponseDTO;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Client;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Notice;
|
||||
import _11.asktpk.artisanconnectbackend.entities.Wishlist;
|
||||
import _11.asktpk.artisanconnectbackend.repository.WishlistRepository;
|
||||
import _11.asktpk.artisanconnectbackend.service.NoticeService;
|
||||
import _11.asktpk.artisanconnectbackend.service.WishlistService;
|
||||
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 static org.junit.jupiter.api.Assertions.*;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@ExtendWith(MockitoExtension.class)
|
||||
class WishlistServiceTest {
|
||||
|
||||
@Mock
|
||||
private WishlistRepository wishlistRepository;
|
||||
|
||||
@Mock
|
||||
private NoticeService noticeService;
|
||||
|
||||
@InjectMocks
|
||||
private WishlistService wishlistService;
|
||||
|
||||
private Client testClient;
|
||||
private Notice testNotice;
|
||||
private Wishlist testWishlist;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
testClient = new Client();
|
||||
testClient.setId(1L);
|
||||
testClient.setEmail("test@example.com");
|
||||
|
||||
testNotice = new Notice();
|
||||
testNotice.setIdNotice(1L);
|
||||
testNotice.setTitle("Test Notice");
|
||||
|
||||
testWishlist = new Wishlist();
|
||||
testWishlist.setId(1L);
|
||||
testWishlist.setClient(testClient);
|
||||
testWishlist.setNotice(testNotice);
|
||||
}
|
||||
|
||||
@Test
|
||||
void toggleWishlist_shouldAddWhenNotExists() {
|
||||
when(wishlistRepository.findByClientAndNotice(testClient, testNotice)).thenReturn(Optional.empty());
|
||||
when(wishlistRepository.save(any(Wishlist.class))).thenReturn(testWishlist);
|
||||
|
||||
boolean result = wishlistService.toggleWishlist(testClient, testNotice);
|
||||
|
||||
assertTrue(result);
|
||||
verify(wishlistRepository, times(1)).save(any(Wishlist.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
void toggleWishlist_shouldRemoveWhenExists() {
|
||||
when(wishlistRepository.findByClientAndNotice(testClient, testNotice)).thenReturn(Optional.of(testWishlist));
|
||||
|
||||
boolean result = wishlistService.toggleWishlist(testClient, testNotice);
|
||||
|
||||
assertFalse(result);
|
||||
verify(wishlistRepository, times(1)).delete(testWishlist);
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNoticesInWishlist_shouldReturnNoticeList() {
|
||||
List<Wishlist> wishlistEntries = new ArrayList<>();
|
||||
wishlistEntries.add(testWishlist);
|
||||
|
||||
when(wishlistRepository.findAllByClientId(1L)).thenReturn(wishlistEntries);
|
||||
when(noticeService.getNoticeById(1L)).thenReturn(new NoticeResponseDTO());
|
||||
|
||||
List<NoticeResponseDTO> result = wishlistService.getNoticesInWishlist(1L);
|
||||
|
||||
assertNotNull(result);
|
||||
assertEquals(1, result.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
void getNoticesInWishlist_shouldReturnEmptyListWhenNoEntries() {
|
||||
when(wishlistRepository.findAllByClientId(1L)).thenReturn(new ArrayList<>());
|
||||
|
||||
List<NoticeResponseDTO> result = wishlistService.getNoticesInWishlist(1L);
|
||||
|
||||
assertNotNull(result);
|
||||
assertTrue(result.isEmpty());
|
||||
}
|
||||
}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 108 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 62 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 435 KiB |
Reference in New Issue
Block a user