finished flight facade tests

airports-flight-service/src/test/java/cz/muni/fi/pa165/facade/FlightFacadeTest.java

 package cz.muni.fi.pa165.facade;
 
+import cz.muni.fi.pa165.api.flight.Flight;
 import cz.muni.fi.pa165.api.flight.requests.FlightRequest;
 import cz.muni.fi.pa165.exception.FlightNotFoundException;
 import cz.muni.fi.pa165.service.FlightService;
 import cz.muni.fi.pa165.utils.TestApiFactory;
 import cz.muni.fi.pa165.utils.TestDaoFactory;
-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.List;
 import java.util.UUID;
 
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
 @ExtendWith(MockitoExtension.class)
@@ -27,30 +27,81 @@ public class FlightFacadeTest {
     @InjectMocks
     private FlightFacade flightFacade;
 
-    @BeforeEach
-    public void simulate_post_construct() {
+    @Test
+    public void getFlights() {
+        List<cz.muni.fi.pa165.dao.Flight> daoFlights = List.of(TestDaoFactory.getFlightEntity());
+        List<Flight> apiFlights = List.of(TestApiFactory.getFlightEntity());
+
+        when(flightService.getAllFlights(anyInt(), anyInt())).thenReturn(daoFlights);
 
+        List<Flight> result = flightFacade.getFlights(0, 10);
+
+        assertEquals(apiFlights, result);
+        verify(flightService, times(1)).getAllFlights(0, 10);
     }
 
     @Test
     public void getFlight_flightFound() {
-        var id = new UUID(0x1, 0xf);
-        cz.muni.fi.pa165.api.flight.Flight apiPlane = TestApiFactory.getFlightEntity();
-        cz.muni.fi.pa165.dao.Flight daoPlane = TestDaoFactory.getFlightEntity();
-        FlightRequest request = TestApiFactory.getFlightRequest();
-        when(flightService.getFlight(id)).thenReturn(daoPlane);
+        UUID id = UUID.randomUUID();
+        cz.muni.fi.pa165.dao.Flight daoFlight = TestDaoFactory.getFlightEntity();
+        Flight apiFlight = TestApiFactory.getFlightEntity();
 
-        var result = flightFacade.getFlight(id);
+        when(flightService.getFlight(id)).thenReturn(daoFlight);
+
+        Flight result = flightFacade.getFlight(id);
         assertNotNull(result);
+        assertEquals(apiFlight, result);
 
         verify(flightService, times(1)).getFlight(id);
     }
 
     @Test
-    void getById_flightNotFound_throwsFlightNotFoundException() {
+    public void getFlight_flightNotFound_throwsFlightNotFoundException() {
         UUID id = UUID.randomUUID();
         when(flightService.getFlight(id)).thenThrow(new FlightNotFoundException());
+
         assertThrows(FlightNotFoundException.class, () -> flightFacade.getFlight(id));
+
+        verify(flightService, times(1)).getFlight(id);
+    }
+
+    @Test
+    public void createFlight() {
+        FlightRequest flightRequest = TestApiFactory.getFlightRequest();
+        cz.muni.fi.pa165.dao.Flight daoFlight = TestDaoFactory.getFlightEntity();
+        Flight apiFlight = TestApiFactory.getFlightEntity();
+
+        when(flightService.createFlight(any(cz.muni.fi.pa165.dao.Flight.class))).thenReturn(daoFlight);
+
+        Flight result = flightFacade.createFlight(flightRequest);
+        assertEquals(apiFlight, result);
+
+        verify(flightService, times(1)).createFlight(any(cz.muni.fi.pa165.dao.Flight.class));
+    }
+
+    @Test
+    public void updateFlight() {
+        UUID id = UUID.randomUUID();
+        FlightRequest flightRequest = TestApiFactory.getFlightRequest();
+        cz.muni.fi.pa165.dao.Flight daoFlight = TestDaoFactory.getFlightEntity();
+        Flight apiFlight = TestApiFactory.getFlightEntity();
+
+        when(flightService.updateFlight(eq(id), any(cz.muni.fi.pa165.dao.Flight.class))).thenReturn(daoFlight);
+
+        Flight result = flightFacade.updateFlight(id, flightRequest);
+        assertEquals(apiFlight, result);
+
+        verify(flightService, times(1)).updateFlight(eq(id), any(cz.muni.fi.pa165.dao.Flight.class));
+    }
+
+    @Test
+    public void deleteFlight() {
+        UUID id = UUID.randomUUID();
+        doNothing().when(flightService).deleteFlight(id);
+
+        flightFacade.deleteFlight(id);
+
+        verify(flightService, times(1)).deleteFlight(id);
     }
 
 }

airports-flight-service/src/test/java/cz/muni/fi/pa165/facade/FlightRealizationFacadeTest.java

 package cz.muni.fi.pa165.facade;
 
+import cz.muni.fi.pa165.api.flight.requests.FlightRealizationRequest;
+import cz.muni.fi.pa165.dao.FlightRealization;
+import cz.muni.fi.pa165.exception.FlightRealizationNotFoundException;
+import cz.muni.fi.pa165.service.FlightRealizationService;
 import cz.muni.fi.pa165.service.FlightService;
+import cz.muni.fi.pa165.utils.TestApiFactory;
+import cz.muni.fi.pa165.utils.TestDaoFactory;
+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.List;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
 @ExtendWith(MockitoExtension.class)
 public class FlightRealizationFacadeTest {
 
     @Mock
-    private FlightService flightService;
+    private FlightRealizationService flightRealizationService;
 
     @InjectMocks
-    private FlightFacade flightFacade;
+    private FlightRealizationFacade flightRealizationFacade;
+
+    @Test
+    public void getAllFlightRealizations() {
+        List<FlightRealization> daoFlightRealizations = List.of(TestDaoFactory.getflightRealizationEntity());
+        List<cz.muni.fi.pa165.api.flight.FlightRealization> apiFlightRealizations = List.of(TestApiFactory.getFlightRealizationEntity());
+
+        when(flightRealizationService.getAllFlightRealizations()).thenReturn(daoFlightRealizations);
+
+        List<cz.muni.fi.pa165.api.flight.FlightRealization> result = flightRealizationFacade.getAllFlightRealizations();
+
+        assertEquals(apiFlightRealizations, result);
+        verify(flightRealizationService, times(1)).getAllFlightRealizations();
+    }
+
+    @Test
+    public void getFlightRealization_flightFound() {
+        UUID id = new UUID(0x1, 0xf);
+        FlightRealization daoFlightRealization = TestDaoFactory.getflightRealizationEntity();
+        cz.muni.fi.pa165.api.flight.FlightRealization apiFlightRealization = TestApiFactory.getFlightRealizationEntity();
+
+        when(flightRealizationService.getFlightRealizationById(id)).thenReturn(daoFlightRealization);
+
+        cz.muni.fi.pa165.api.flight.FlightRealization result = flightRealizationFacade.getFlightRealization(id);
+        assertNotNull(result);
+        assertEquals(apiFlightRealization, result);
+
+        verify(flightRealizationService, times(1)).getFlightRealizationById(id);
+    }
+
+    @Test
+    public void getFlightRealization_flightNotFound_throwsFlightRealizationNotFoundException() {
+        UUID id = UUID.randomUUID();
+        when(flightRealizationService.getFlightRealizationById(id)).thenThrow(new FlightRealizationNotFoundException());
+
+        assertThrows(FlightRealizationNotFoundException.class, () -> flightRealizationFacade.getFlightRealization(id));
+
+        verify(flightRealizationService, times(1)).getFlightRealizationById(id);
+    }
+
+    @Test
+    public void createFlightRealization() {
+        FlightRealizationRequest flightRealizationRequest = TestApiFactory.getFlightRelizationRequest();
+        FlightRealization daoFlightRealization = TestDaoFactory.getflightRealizationEntity();
+        cz.muni.fi.pa165.api.flight.FlightRealization apiFlightRealization = TestApiFactory.getFlightRealizationEntity();
+
+        when(flightRealizationService.createFlightRealization(any(cz.muni.fi.pa165.dao.FlightRealization.class))).thenReturn(daoFlightRealization);
+
+        cz.muni.fi.pa165.api.flight.FlightRealization result = flightRealizationFacade.createFlightRealization(flightRealizationRequest);
+        assertEquals(apiFlightRealization, result);
+
+        verify(flightRealizationService, times(1)).createFlightRealization(any(cz.muni.fi.pa165.dao.FlightRealization.class));
+    }
+
+    @Test
+    public void updateFlightRealization() {
+        UUID id = new UUID(0x1, 0xf);
+        FlightRealizationRequest flightRealizationRequest = TestApiFactory.getFlightRelizationRequest();
+        FlightRealization daoFlightRealization = TestDaoFactory.getflightRealizationEntity();
+        cz.muni.fi.pa165.api.flight.FlightRealization apiFlightRealization = TestApiFactory.getFlightRealizationEntity();
+
+        when(flightRealizationService.updateFlightRealization(eq(id), any(cz.muni.fi.pa165.dao.FlightRealization.class))).thenReturn(daoFlightRealization);
+
+        cz.muni.fi.pa165.api.flight.FlightRealization result = flightRealizationFacade.updateFlightRealization(id, flightRealizationRequest);
+        assertEquals(apiFlightRealization, result);
+
+        verify(flightRealizationService, times(1)).updateFlightRealization(eq(id), any(cz.muni.fi.pa165.dao.FlightRealization.class));
+    }
+
+    @Test
+    public void deleteFlightRealization() {
+        UUID id = new UUID(0x1, 0xf);
+        doNothing().when(flightRealizationService).deleteFlightRealization(id);
+
+        flightRealizationFacade.deleteFlightRealization(id);
 
+        verify(flightRealizationService, times(1)).deleteFlightRealization(id);
+    }
 }

airports-flight-service/src/test/java/cz/muni/fi/pa165/facade/IssueReportFacadeTest.java

@@ -14,6 +14,8 @@ import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import java.util.UUID;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @ExtendWith(MockitoExtension.class)
@@ -34,14 +36,58 @@ public class IssueReportFacadeTest {
     @Test
     public void createIssueReport() {
         cz.muni.fi.pa165.api.flight.IssueReport issueReport = TestApiFactory.getIssueReport();
-        System.out.println(issueReport);
         IssueReport daoIssueReport = TestDaoFactory.getIssueReport();
-        System.out.println(daoIssueReport);
         IssueReportRequest issueReportRequest = TestApiFactory.getIssueReportRequest();
-        System.out.println(issueReportRequest);
 
-        Mockito.when(issueReportService.createIssueReport(daoIssueReport)).thenReturn(daoIssueReport);
-        assertEquals(issueReport, issueReportFacade.createIssueReport(issueReportRequest));
-        Mockito.verify(issueReportService, Mockito.times(1)).createIssueReport(daoIssueReport);
+        // Use argument matchers to handle dynamic UUID
+        Mockito.when(issueReportService.createIssueReport(Mockito.any(IssueReport.class)))
+                .thenReturn(daoIssueReport);
+
+        cz.muni.fi.pa165.api.flight.IssueReport returnedIssueReport = issueReportFacade.createIssueReport(issueReportRequest);
+
+        assertEquals(issueReport, returnedIssueReport);
+        Mockito.verify(issueReportService, Mockito.times(1)).createIssueReport(Mockito.any(IssueReport.class));
+    }
+
+    @Test
+    public void getIssueReport() {
+        UUID id = UUID.randomUUID();
+        cz.muni.fi.pa165.dao.IssueReport daoIssueReport = TestDaoFactory.getIssueReport();
+        cz.muni.fi.pa165.api.flight.IssueReport apiIssueReport = TestApiFactory.getIssueReport();
+
+        Mockito.when(issueReportService.get(id)).thenReturn(daoIssueReport);
+
+        cz.muni.fi.pa165.api.flight.IssueReport returnedIssueReport = issueReportFacade.getIssueReport(id);
+
+        assertEquals(apiIssueReport, returnedIssueReport);
+        Mockito.verify(issueReportService, Mockito.times(1)).get(id);
+    }
+
+    @Test
+    public void updateIssueReport() {
+        UUID id = UUID.randomUUID();
+        cz.muni.fi.pa165.dao.IssueReport daoIssueReport = TestDaoFactory.getIssueReport();
+        cz.muni.fi.pa165.api.flight.IssueReport apiIssueReport = TestApiFactory.getIssueReport();
+        IssueReportRequest issueReportRequest = TestApiFactory.getIssueReportRequest();
+
+        Mockito.when(issueReportService.updateIssueReport(Mockito.eq(id), Mockito.any(IssueReport.class)))
+                .thenReturn(daoIssueReport);
+
+        cz.muni.fi.pa165.api.flight.IssueReport returnedIssueReport = issueReportFacade.updateIssueReport(id, issueReportRequest);
+
+        assertEquals(apiIssueReport, returnedIssueReport);
+        Mockito.verify(issueReportService, Mockito.times(1))
+                .updateIssueReport(Mockito.eq(id), Mockito.any(IssueReport.class));
+    }
+
+    @Test
+    public void deleteIssueReport() {
+        UUID id = UUID.randomUUID();
+
+        Mockito.doNothing().when(issueReportService).deleteIssueReport(id);
+
+        issueReportFacade.deleteIssueReport(id);
+
+        Mockito.verify(issueReportService, Mockito.times(1)).deleteIssueReport(id);
     }
 }

airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestApiFactory.java

@@ -21,18 +21,18 @@ public class TestApiFactory {
     public static Flight getFlightEntity() {
         UUID id = new UUID(0x1, 0xf);
         Flight flight = new Flight();
-        flight.setPlaneId(id);
-        flight.setDestination(new UUID(0x2, 0xf));
+        flight.setPlaneId(new UUID(0x2, 0xf));
+        flight.setDestination(new UUID(0x4, 0xf));
         flight.setOrigin(new UUID(0x3, 0xf));
         flight.setId(id);
         Set<UUID> pilots = new HashSet<>();
-        pilots.add(UUID.randomUUID());
-        pilots.add(UUID.randomUUID());
+        pilots.add(new UUID(0x5, 0xf));
+        pilots.add(new UUID(0x6, 0xf));
         flight.setPilotIds(pilots);
 
         Set<UUID> stewards = new HashSet<>();
-        stewards.add(UUID.randomUUID());
-        stewards.add(UUID.randomUUID());
+        stewards.add(new UUID(0x7, 0xf));
+        stewards.add(new UUID(0x8, 0xf));
         flight.setStewardIds(stewards);
 
         return flight;

airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestDaoFactory.java

@@ -38,12 +38,13 @@ public class TestDaoFactory {
     public static FlightRealization getflightRealizationEntity() {
         UUID id = new UUID(0x1, 0xf);
         FlightRealization flightRealization = new FlightRealization();
-        flightRealization.setDepartureTime(LocalDateTime.now());
-        flightRealization.setArrivalTime(LocalDateTime.now());
-        flightRealization.setFlightId(id);
+        flightRealization.setDepartureTime(LocalDateTime.of(2002, 2, 2, 2, 2, 2));
+        flightRealization.setArrivalTime(LocalDateTime.of(2002, 2, 2, 2, 2, 2));
+        flightRealization.setFlightId(new UUID(0x2, 0xf));
         flightRealization.setReport("report");
         flightRealization.setDuration(Duration.ofHours(1));
-        flightRealization.setKilometersFlown(850);
+        flightRealization.setKilometersFlown(850.0);
+        flightRealization.setId(id);
 
         return flightRealization;
     }