Increase code coverage

.github/workflows/sonar.yml

@@ -45,4 +45,4 @@ jobs:
           -Dsonar.projectKey=Mastercard_petstore-application-java
           -Dsonar.organization=mastercard -Dsonar.host.url=https://sonarcloud.io
           -Dsonar.login=$SONAR_TOKEN -Dsonar.cpd.exclusions=**/OkHttp*.java
-          -Dsonar.exclusions=**/*.xml -Dgpg.signature.skip=true
+          -Dsonar.exclusions=**/*.xml,**/configuration/**,**/PetstoreApplication.java,**/utils/** -Dgpg.signature.skip=true

src/main/java/com/mastercard/app/petstore/utils/MockDataBuilders.java

@@ -124,7 +124,7 @@ public static NewEmployee buildNewEmployee(){
 
     public static Employee buildEmployee(){
         String firstName = generateRandomName();
-        Employee employee = new Employee();
+        Employee employee = new Employee(UUID.randomUUID(), new Date(), new Date());
         employee.setFirstName(firstName);
         employee.setLastName(generateRandomName());
         employee.setPhoneNumber("+6573437115596");
@@ -133,6 +133,22 @@ public static Employee buildEmployee(){
         return employee;
     }
 
+    public static EmployeeWrapper buildEmployeeWrapper(){
+        String firstName = generateRandomName();
+        return new EmployeeWrapper()
+                .firstName(generateRandomName())
+                .lastName(generateRandomName())
+                .phoneNumber("+6573437115596")
+                .ssn(generateRandomSsn())
+                .username(firstName + "123");
+    }
+
+    public static EmployeeSearch buildEmployeeSearch(){
+        EmployeeSearch employeeSearch = new EmployeeSearch();
+        employeeSearch.setSsn(generateRandomSsn());
+        return employeeSearch;
+    }
+
     public static Payment buildPayment(){
         Payment payment = new Payment();
         payment.setAmount(new BigDecimal(50));

src/test/java/com/mastercard/app/petstore/examples/AdoptionFlowExampleTest.java

@@ -0,0 +1,72 @@
+package com.mastercard.app.petstore.examples;
+
+import com.mastercard.app.petstore.services.AdoptionsService;
+import com.mastercard.app.petstore.services.CatService;
+import com.mastercard.app.petstore.utils.MockDataBuilders;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.MockitoAnnotations;
+import org.openapitools.client.ApiException;
+import org.openapitools.client.model.Adoption;
+import org.openapitools.client.model.Cat;
+import org.openapitools.client.model.NewAdoption;
+import org.openapitools.client.model.NewCat;
+
+import java.util.UUID;
+
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class AdoptionFlowExampleTest {
+
+    @InjectMocks
+    private AdoptionFlowExample adoptionFlowExample;
+
+    @Mock
+    private AdoptionsService adoptionsService;
+
+    @Mock
+    private CatService catService;
+
+    @BeforeEach
+    void setup() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testAdoptionUseCase() throws ApiException {
+        UUID catId = UUID.randomUUID();
+        UUID adoptionId = UUID.randomUUID();
+
+        NewCat newCat = mock(NewCat.class);
+        Cat cat = mock(Cat.class);
+        when(cat.getId()).thenReturn(catId);
+
+        NewAdoption newAdoption = mock(NewAdoption.class);
+        Adoption adoption = mock(Adoption.class);
+        when(adoption.getId()).thenReturn(adoptionId);
+
+        when(catService.addCat(any(NewCat.class))).thenReturn(cat);
+        when(adoptionsService.adoptPet(any(NewAdoption.class))).thenReturn("/adoptions/" + adoptionId);
+        when(adoptionsService.getAdoption(adoptionId.toString())).thenReturn(adoption);
+
+        try (MockedStatic<MockDataBuilders> mockBuilders = mockStatic(MockDataBuilders.class)) {
+            mockBuilders.when(MockDataBuilders::buildNewCat).thenReturn(newCat);
+            mockBuilders.when(() -> MockDataBuilders.buildNewAdoptionObject(catId)).thenReturn(newAdoption);
+
+            adoptionFlowExample.adoptionUseCase();
+
+            verify(catService).addCat(newCat);
+            verify(adoptionsService).adoptPet(newAdoption);
+            verify(adoptionsService).getAdoption(adoptionId.toString());
+            verify(adoptionsService).updateAdoption("0", adoption);
+            verify(adoptionsService).deleteAdoption(adoptionId.toString());
+        }
+    }
+}

src/test/java/com/mastercard/app/petstore/examples/EmployeeFlowExampleTest.java

@@ -0,0 +1,64 @@
+package com.mastercard.app.petstore.examples;
+
+import com.mastercard.app.petstore.services.EmployeeService;
+import com.mastercard.app.petstore.utils.MockDataBuilders;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.*;
+import org.openapitools.client.ApiException;
+import org.openapitools.client.model.*;
+
+import static org.mockito.Mockito.*;
+
+class EmployeeFlowExampleTest {
+
+    @InjectMocks
+    private EmployeeFlowExample employeeFlowExample;
+
+    @Mock
+    private EmployeeService employeeService;
+
+    @BeforeEach
+    void setup() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testEmployeeUseCase() throws ApiException {
+        NewEmployee newEmployee = new NewEmployee().ssn("123-45-6789");
+        Employee employee = new Employee().ssn("123-45-6789");
+        EmployeeWrapper employeeWrapper = new EmployeeWrapper().username("jdoe");
+
+        NewEmployeeData newEmployeeData = new NewEmployeeData().addNewEmployeesItem(newEmployee);
+
+        EmployeeListData employeeData = new EmployeeListData().addEmployeesItem(employee);
+
+        when(employeeService.createEmployee(any(NewEmployeeData.class))).thenReturn(employeeData);
+        when(employeeService.searchEmployee(any(EmployeeSearch.class))).thenReturn(employeeWrapper);
+
+        try (MockedStatic<MockDataBuilders> mockBuilders = mockStatic(MockDataBuilders.class)) {
+            mockBuilders.when(MockDataBuilders::buildNewEmployee).thenReturn(newEmployee);
+
+            employeeFlowExample.employeeUseCase();
+
+            verify(employeeService).createEmployee(newEmployeeData);
+            verify(employeeService).searchEmployee(argThat(search -> "123-45-6789".equals(search.getSsn())));
+            verify(employeeService).deleteEmployee("jdoe");
+        }
+    }
+
+    @Test
+    void testEmployeeUseCaseThrowsApiException() throws ApiException {
+        NewEmployee newEmployee = new NewEmployee().ssn("123-45-6789");
+
+        when(employeeService.createEmployee(any(NewEmployeeData.class))).thenThrow(new ApiException("API error"));
+
+        try (MockedStatic<MockDataBuilders> mockBuilders = mockStatic(MockDataBuilders.class)) {
+            mockBuilders.when(MockDataBuilders::buildNewEmployee).thenReturn(newEmployee);
+
+            org.junit.jupiter.api.Assertions.assertThrows(ApiException.class, () -> {
+                employeeFlowExample.employeeUseCase();
+            });
+        }
+    }
+}

src/test/java/com/mastercard/app/petstore/examples/PetFlowExampleTest.java

@@ -0,0 +1,77 @@
+package com.mastercard.app.petstore.examples;
+
+import com.mastercard.app.petstore.services.CatService;
+import com.mastercard.app.petstore.services.PetService;
+import com.mastercard.app.petstore.utils.MockDataBuilders;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.MockitoAnnotations;
+import org.openapitools.client.ApiException;
+import org.openapitools.client.model.Cat;
+import org.openapitools.client.model.NewCat;
+import org.openapitools.client.model.PetStatus;
+
+import java.util.Date;
+import java.util.UUID;
+
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.argThat;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class PetFlowExampleTest {
+
+    @InjectMocks
+    private PetFlowExample petFlowExample;
+
+    @Mock
+    private CatService catService;
+
+    @Mock
+    private PetService petService;
+
+    @BeforeEach
+    void setup() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void testPetUseCaseFlow() throws ApiException {
+        NewCat newCat = new NewCat();
+        UUID catId = UUID.randomUUID();
+        Cat cat = new Cat(catId, new Date(), new Date()).name("Whiskers");
+        PetStatus status = new PetStatus().value("RESERVED");
+
+        when(catService.addCat(any(NewCat.class))).thenReturn(cat);
+        when(catService.getCat(catId.toString())).thenReturn(cat);
+
+        try (MockedStatic<MockDataBuilders> mockBuilders = mockStatic(MockDataBuilders.class)) {
+            mockBuilders.when(MockDataBuilders::buildNewCat).thenReturn(newCat);
+
+            petFlowExample.petUseCaseFlow();
+
+            verify(catService).addCat(newCat);
+            verify(catService).getCat(catId.toString());
+            verify(catService).updateCat(argThat(updatedCat -> "Catso".equals(updatedCat.getName())), eq("0"));
+            verify(petService).updatePetStatus(eq(catId), eq(status), eq("1"));
+            verify(petService).removePet(catId);
+        }
+    }
+
+    @Test
+    void testPetUseCaseFlowThrowsApiException() throws ApiException {
+        NewCat newCat = new NewCat();
+        when(catService.addCat(any(NewCat.class))).thenThrow(new ApiException("API error"));
+
+        try (MockedStatic<MockDataBuilders> mockBuilders = mockStatic(MockDataBuilders.class)) {
+            mockBuilders.when(MockDataBuilders::buildNewCat).thenReturn(newCat);
+
+            org.junit.jupiter.api.Assertions.assertThrows(ApiException.class, () -> petFlowExample.petUseCaseFlow());
+        }
+    }
+}