Tests for service layer

service-api/src/main/java/greencity/constant/ErrorMessage.java

@@ -33,6 +33,7 @@ public final class ErrorMessage {
     public static final String ORDER_STATUS_NOT_FOUND = "Order status not found";
     public static final String ORDER_PAYMENT_STATUS_NOT_FOUND = "Order payment status not found";
     public static final String FILE_NOT_SAVED = "File hasn't been saved";
+    public static final String FILE_IS_NULL = "File equals null";
     public static final String EMPLOYEE_NOT_FOUND = "Employee with current id doesn't exist: ";
     public static final String EMPLOYEE_WITH_UUID_NOT_FOUND = "Employee with current uuid doesn't exist: ";
     public static final String CURRENT_PHONE_NUMBER_ALREADY_EXISTS = "Employee with this phone number already exists: ";

service-api/src/main/java/greencity/exceptions/image/FileIsNullException.java

@@ -0,0 +1,12 @@
+package greencity.exceptions.image;
+
+public class FileIsNullException extends RuntimeException {
+    /**
+     * Constructor with message.
+     *
+     * @param message message, that explains cause of the exception.
+     */
+    public FileIsNullException(String message) {
+        super(message);
+    }
+}

service-api/src/test/java/greencity/exceptions/image/FileIsNullExceptionTest.java

@@ -0,0 +1,15 @@
+package greencity.exceptions.image;
+
+import greencity.constant.ErrorMessage;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class FileIsNullExceptionTest {
+    @Test
+    void fileIsNullExceptionTest() {
+        String message = "File equals null";
+        FileIsNullException ex = new FileIsNullException(message);
+        assertEquals(ErrorMessage.FILE_IS_NULL, ex.getMessage());
+    }
+}

service/src/main/java/greencity/service/ubs/AzureCloudStorageService.java

@@ -4,8 +4,10 @@
 import com.azure.storage.blob.BlobContainerClient;
 import com.azure.storage.blob.BlobServiceClient;
 import com.azure.storage.blob.BlobServiceClientBuilder;
+import com.google.common.annotations.VisibleForTesting;
 import greencity.constant.ErrorMessage;
 import greencity.exceptions.BadRequestException;
+import greencity.exceptions.image.FileIsNullException;
 import greencity.exceptions.image.FileNotSavedException;
 import lombok.Data;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -40,6 +42,9 @@ public AzureCloudStorageService(@Autowired PropertyResolver propertyResolver) {
      */
     @Override
     public String upload(MultipartFile multipartFile) {
+        if (multipartFile == null) {
+            throw new FileIsNullException(ErrorMessage.FILE_IS_NULL);
+        }
         final String blob = UUID.randomUUID().toString();
         BlobClient client = containerClient()
             .getBlobClient(blob + multipartFile.getOriginalFilename());
@@ -65,7 +70,8 @@ public void delete(String url) {
         }
     }
 
-    private BlobContainerClient containerClient() {
+    @VisibleForTesting
+    BlobContainerClient containerClient() {
         BlobServiceClient serviceClient = new BlobServiceClientBuilder()
             .connectionString(connectionString).buildClient();
         return serviceClient.getBlobContainerClient(containerName);

service/src/test/java/greencity/service/ubs/AzureCloudStorageServiceTest.java

@@ -0,0 +1,111 @@
+package greencity.service.ubs;
+
+import com.azure.storage.blob.*;
+import greencity.constant.ErrorMessage;
+import greencity.exceptions.BadRequestException;
+import greencity.exceptions.image.FileIsNullException;
+import greencity.exceptions.image.FileNotSavedException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.*;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.core.env.PropertyResolver;
+import org.springframework.mock.env.MockEnvironment;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class AzureCloudStorageServiceTest {
+
+    @BeforeEach
+    void setUp() {
+        MockEnvironment mockEnvironment = new MockEnvironment();
+        mockEnvironment.setProperty("azure.connection.string", " ");
+        mockEnvironment.setProperty("azure.container.name", " ");
+        propertyResolver = mockEnvironment;
+        azureCloudStorageService = spy(new AzureCloudStorageService(propertyResolver));
+    }
+
+    @Mock
+    private PropertyResolver propertyResolver;
+
+    private AzureCloudStorageService azureCloudStorageService;
+
+    @Mock
+    BlobContainerClient containerClient;
+
+    @Mock
+    BlobClient blobClient;
+
+    @Test
+    void checkUpload() {
+        MultipartFile multipartFile = new MockMultipartFile("Image", "Image".getBytes(StandardCharsets.UTF_8));
+        doReturn(containerClient).when(azureCloudStorageService).containerClient();
+        when(containerClient.getBlobClient(anyString())).thenReturn(blobClient);
+        doReturn("blobUrl").when(blobClient).getBlobUrl();
+        azureCloudStorageService.upload(multipartFile);
+        assertNotNull(multipartFile);
+        assertNotNull(azureCloudStorageService.getConnectionString());
+        assertNotNull(azureCloudStorageService.getContainerName());
+        verify(containerClient).getBlobClient(anyString());
+        verify(blobClient).upload(any(InputStream.class), anyLong());
+        verify(blobClient).getBlobUrl();
+    }
+
+    @Test
+    void checkDelete() {
+        doReturn(containerClient).when(azureCloudStorageService).containerClient();
+        when(containerClient.getBlobClient(anyString())).thenReturn(blobClient);
+        when(blobClient.exists()).thenReturn(true);
+        doNothing().when(blobClient).delete();
+        azureCloudStorageService.delete("url/somepath/somefile.txt");
+        assertNotNull(azureCloudStorageService.getConnectionString());
+        assertNotNull(azureCloudStorageService.getContainerName());
+        verify(containerClient).getBlobClient(anyString());
+        assertEquals(true, blobClient.exists());
+        verify(blobClient).delete();
+    }
+
+    @Test
+    void checkUploadThrowsException() {
+        doReturn(containerClient).when(azureCloudStorageService).containerClient();
+        when(containerClient.getBlobClient(anyString())).thenReturn(blobClient);
+        doAnswer(invocation -> {
+            throw new IOException();
+        }).when(blobClient).upload(any(InputStream.class), anyLong());
+        MultipartFile multipartFile = new MockMultipartFile("Image", "Image".getBytes(StandardCharsets.UTF_8));
+        FileNotSavedException ex =
+            assertThrows(FileNotSavedException.class, () -> azureCloudStorageService.upload(multipartFile));
+        assertEquals(ErrorMessage.FILE_NOT_SAVED, ex.getMessage());
+    }
+
+    @Test
+    void checkUploadNullImage() {
+        MultipartFile multipartFile = null;
+        FileIsNullException ex =
+            assertThrows(FileIsNullException.class, () -> azureCloudStorageService.upload(multipartFile));
+        assertEquals(ErrorMessage.FILE_IS_NULL, ex.getMessage());
+    }
+
+    @Test
+    void checkInvalidConnectionString() {
+        azureCloudStorageService = new AzureCloudStorageService(new MockEnvironment());
+        assertThrows(IllegalArgumentException.class, () -> azureCloudStorageService.containerClient());
+    }
+
+    @Test
+    void checkDeleteThrowsException() {
+        String url = "aa#26#1";
+        BadRequestException ex = assertThrows(BadRequestException.class, () -> azureCloudStorageService.delete(url));
+        assertEquals(ErrorMessage.PARSING_URL_FAILED + url, ex.getMessage());
+    }
+}

service/src/test/java/greencity/service/ubs/ValuesForUserTableServiceImplTest.java

@@ -0,0 +1,65 @@
+package greencity.service.ubs;
+
+import greencity.ModelUtils;
+import greencity.entity.order.Order;
+import greencity.entity.user.User;
+import greencity.entity.user.employee.Employee;
+import greencity.enums.SortingOrder;
+import greencity.filters.CustomerPage;
+import greencity.filters.UserFilterCriteria;
+import greencity.repository.EmployeeRepository;
+import greencity.repository.UserRepository;
+import greencity.repository.UserTableRepo;
+import org.glassfish.hk2.utilities.Stub;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.data.domain.*;
+
+import java.util.*;
+
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class ValuesForUserTableServiceImplTest {
+
+    @Mock
+    UserRepository userRepository;
+
+    @Mock
+    UserTableRepo userTableRepo;
+
+    @Mock
+    EmployeeRepository employeeRepository;
+
+    @InjectMocks
+    ValuesForUserTableServiceImpl valuesForUserTableService;
+
+    @Test
+    void getAllFields() {
+        User user = User.builder()
+            .orders(new ArrayList<>())
+            .violations(5)
+            .currentPoints(8)
+            .build();
+        Pageable pageable = PageRequest.of(1, 1);
+        Employee employee = ModelUtils.getEmployee();
+        List<Long> tariffsInfo = List.of(1L, 2L, 3L);
+        when(employeeRepository.findByEmail(anyString())).thenReturn(Optional.of(employee));
+        when(employeeRepository.findTariffsInfoForEmployee(anyLong())).thenReturn(tariffsInfo);
+        when(userRepository.getAllUsersByTariffsInfoId(anyLong())).thenReturn(tariffsInfo);
+        when(userTableRepo.findAll(any(UserFilterCriteria.class), anyString(), any(SortingOrder.class),
+            any(CustomerPage.class), Mockito.<Long>anyList())).thenReturn(new PageImpl<>(List.of(user), pageable, 1L));
+        valuesForUserTableService.getAllFields(new CustomerPage(), "column", SortingOrder.ASC, new UserFilterCriteria(),
+            employee.getEmail());
+
+        verify(userTableRepo).findAll(any(UserFilterCriteria.class), anyString(), any(SortingOrder.class),
+            any(CustomerPage.class), Mockito.<Long>anyList());
+    }
+
+}

service/src/test/java/greencity/service/ubs/ViolationServiceImplTest.java

@@ -2,7 +2,11 @@
 
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
+import greencity.constant.ErrorMessage;
+import greencity.entity.order.TariffsInfo;
+import greencity.entity.user.employee.Employee;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
@@ -33,6 +37,8 @@
 import greencity.repository.ViolationRepository;
 import greencity.service.notification.NotificationServiceImpl;
 
+import javax.persistence.EntityNotFoundException;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.any;
@@ -105,35 +111,37 @@ void deleteViolationFromOrderByOrderId() {
     }
 
     @Test
-    @Disabled
     void checkAddUserViolation() {
+        Employee employee = ModelUtils.getEmployee();
+        List<Long> tariffsInfos = List.of(1L, 2L, 3L);
+        TariffsInfo tariffsInfo = ModelUtils.getTariffsInfo();
         User user = ModelUtils.getTestUser();
         Order order = user.getOrders().get(0);
+        order.setTariffsInfo(tariffsInfo);
         order.setUser(user);
         AddingViolationsToUserDto add = ModelUtils.getAddingViolationsToUserDto();
         add.setOrderID(order.getId());
         when(orderRepository.findById(order.getId())).thenReturn(Optional.ofNullable(order));
-        when(userRepository.findUserByUuid("abc")).thenReturn(Optional.of(user));
         when(userRepository.countTotalUsersViolations(1L)).thenReturn(1);
+        when(employeeRepository.findByEmail(anyString())).thenReturn(Optional.ofNullable(employee));
+        when(employeeRepository.findTariffsInfoForEmployee(anyLong())).thenReturn(tariffsInfos);
         violationService.addUserViolation(add, new MultipartFile[2], "abc");
 
         assertEquals(1, user.getViolations());
     }
 
     @Test
-    @Disabled
     void checkAddUserViolationThrowsException() {
         User user = ModelUtils.getTestUser();
         Order order = user.getOrders().get(0);
         order.setUser(user);
         AddingViolationsToUserDto add = ModelUtils.getAddingViolationsToUserDto();
         add.setOrderID(order.getId());
         when(orderRepository.findById(order.getId())).thenReturn(Optional.ofNullable(order));
-        when(userRepository.findUserByUuid("abc")).thenReturn(Optional.of(user));
-        when(violationRepository.findByOrderId(order.getId())).thenReturn(Optional.of(ModelUtils.getViolation()));
 
-        assertThrows(NotFoundException.class,
+        EntityNotFoundException ex = assertThrows(EntityNotFoundException.class,
             () -> violationService.addUserViolation(add, new MultipartFile[2], "abc"));
+        assertEquals(ErrorMessage.EMPLOYEE_NOT_FOUND, ex.getMessage());
     }
 
     @Test

service/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker

@@ -0,0 +1 @@
+mock-maker-inline