diff --git a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/IssueReport.java b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/IssueReport.java
index d931de087eed87095ed9ffc3417621bfc9e4309d..45308826fd5d490fa162abbed5509f2bc13f0a0e 100644
--- a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/IssueReport.java
+++ b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/IssueReport.java
@@ -12,6 +12,7 @@ import java.util.UUID;
 public class IssueReport {
 
     private UUID id;
+    private UUID planeId;
     private UUID flightEncountered;
     private String description;
 
diff --git a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRealizationRequest.java b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRealizationRequest.java
index 73877d78439eec668181405f577b4fd8a9e19986..095b01d69fe5600a5628f20a723ee553a68049c6 100644
--- a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRealizationRequest.java
+++ b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRealizationRequest.java
@@ -12,7 +12,7 @@ import java.util.UUID;
 @AllArgsConstructor
 public class FlightRealizationRequest {
 
-    private Long flightId;
+    private UUID flightId;
     private String report;
     private Duration duration;
     private LocalDateTime departureTime;
diff --git a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRequest.java b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRequest.java
index 15919b2dda9e98f165f3e77217e2a21765bb0710..4a89842190768c2d94c6b0f55295ae3b55ca73c9 100644
--- a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRequest.java
+++ b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/FlightRequest.java
@@ -3,15 +3,13 @@ package cz.muni.fi.pa165.api.flight.requests;
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
-
-import java.util.List;
 import java.util.UUID;
 
 @Data
 @AllArgsConstructor
 public class FlightRequest {
 
-    private String origin;
-    private String destination;
+    private UUID origin;
+    private UUID destination;
     private UUID planeId;
 }
diff --git a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/IssueReportRequest.java b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/IssueReportRequest.java
index 189f8f0596c8da730becedb1b94e496c23ed5730..0eea9ee5bde19613d9318ebd21eb6c7eea5354af 100644
--- a/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/IssueReportRequest.java
+++ b/airport-manager-api/src/main/java/cz/muni/fi/pa165/api/flight/requests/IssueReportRequest.java
@@ -10,6 +10,7 @@ import java.util.UUID;
 @AllArgsConstructor
 public class IssueReportRequest {
 
-    private Long flightEncountered;
+    private UUID flightEncountered;
     private String description;
+    private  UUID planeId;
 }
diff --git a/airports-flight-service/pom.xml b/airports-flight-service/pom.xml
index 02dbe0b9636f13615b215594cff29709f4bfa2ff..31dcf37d58e2c2d499183195daa25a113bddb4bf 100644
--- a/airports-flight-service/pom.xml
+++ b/airports-flight-service/pom.xml
@@ -93,6 +93,11 @@
             <artifactId>spring-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>jakarta.validation</groupId>
+            <artifactId>jakarta.validation-api</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <plugins>
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/Application.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/Application.java
index c92d74c37391e5b871920a7411914f1c22ba8297..92759612d154935f626bf49a1ca30fdf880c52df 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/Application.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/Application.java
@@ -14,31 +14,4 @@ public class Application {
     public static void main(String[] args) {
         SpringApplication.run(Application.class, args);
     }
-
-    @Bean
-    CommandLineRunner commandLineRunner(IssueReportRepository issueReportRepository) {
-        return  args -> {
-
-//            IssueReport issueReport = new IssueReport(
-//                    9,
-//                    "MOJALOSSW"
-//            );
-//
-//            IssueReport issueReport2 = new IssueReport(
-//                    81,
-//                    "MOJALOSSW2"
-//            );
-
-            //  issueReportRepository.save(issueReport);
-
-           // issueReportRepository.saveAll(List.of(issueReport, issueReport2));
-
-           // System.out.println(issueReportRepository.count());
-
-          // List<IssueReport> issueReports  = issueReportRepository.findAll();
-
-          //  issueReports.forEach(System.out::println);
-        };
-    }
-
 }
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/Flight.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/Flight.java
index 3174fe45443448b02903ffd17b3fbcaa85cce522..0524c1c70e984cf3b1dc740558fe526b29dcffc9 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/Flight.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/Flight.java
@@ -5,10 +5,9 @@ import lombok.Data;
 
 import javax.persistence.*;
 import java.io.Serializable;
-import java.time.LocalDateTime;
-import java.util.List;
 import java.util.UUID;
 
+
 @Data
 @Entity
 @Table(name = "flight", schema = Constants.FLIGHT_SCHEMA)
@@ -17,14 +16,7 @@ public class Flight implements Serializable {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     private UUID id;
-    private String origin;
-    private String destination;
-
+    private UUID origin;
+    private UUID destination;
     private UUID planeId;
-
-
-//    @ElementCollection
-//    private List<Long> pilotIds;
-//    @ElementCollection
-//    private List<Long> stewardIds;
 }
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/IssueReport.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/IssueReport.java
index 01aeb02dad3eadcb99e910e25ce5fe6ed556e136..55952fa666b5bd2e24aa997ce203ae9b5b8b9ce7 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/IssueReport.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/dao/IssueReport.java
@@ -16,16 +16,8 @@ public class IssueReport implements Serializable {
 
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
-    private Long id;
-    private Long flightEncountered;
+    private UUID id;
+    private UUID flightEncountered;
     private String description;
-
-    public IssueReport( Long flightEncountered, String description ) {
-        this.flightEncountered = flightEncountered;
-        this.description = description;
-    }
-
-    public IssueReport() {
-
-    }
+    private UUID planeId;
 }
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/exception/FlightNotFoundException.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/exception/FlightNotFoundException.java
index 9dfbd4f3d9d50a7f86de9a5f2934daaa51303daf..15bae95e57feea9aefff822f831e7334174971cd 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/exception/FlightNotFoundException.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/exception/FlightNotFoundException.java
@@ -3,6 +3,7 @@ package cz.muni.fi.pa165.exception;
 public class FlightNotFoundException extends RuntimeException {
 
     public FlightNotFoundException() {
+        super();
     }
 
     public FlightNotFoundException(String message) {
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightFacade.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightFacade.java
index 0674a3a99b747014784d44f61bb3a18f698cb1c4..27218c81a56054994cb30c2e9165677bbcf9f11a 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightFacade.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightFacade.java
@@ -1,9 +1,9 @@
 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.dao.Flight;
-import cz.muni.fi.pa165.dao.IssueReport;
+import cz.muni.fi.pa165.repository.FlightRepository;
 import cz.muni.fi.pa165.service.FlightService;
 import lombok.RequiredArgsConstructor;
 import org.modelmapper.ModelMapper;
@@ -19,9 +19,9 @@ public class FlightFacade {
     private final FlightService flightService;
     private final ModelMapper modelMapper = new ModelMapper();
 
-    public List<Flight> getFlights(){
-        var result = flightService.getAllFlights();
-        return result.stream().map(p -> modelMapper.map(p, Flight.class)).toList();
+    public List<Flight> getFlights( int page, int size ){
+        var result = flightService.getAllFlights(page, size);
+        return result.stream().map(p -> modelMapper.map(p, cz.muni.fi.pa165.api.flight.Flight.class)).toList();
     }
 
     public Flight getFlight(UUID id){
@@ -30,14 +30,13 @@ public class FlightFacade {
     }
 
     public Flight createFlight(FlightRequest flightRequest){
-//        return flightService.createFlight(flightRequest);
-        var result = flightService.createFlight( modelMapper.map(flightRequest, Flight.class) );
-        return modelMapper.map(result, Flight.class);
-
+      var result = flightService.createFlight( modelMapper.map(flightRequest, cz.muni.fi.pa165.dao.Flight.class));
+        return modelMapper.map(result,Flight.class);
     }
 
     public Flight updateFlight(UUID id, FlightRequest flightRequest){
-        var result = flightService.updateFlight(id, modelMapper.map(flightRequest, Flight.class));
+        var result = flightService.updateFlight(id, modelMapper.map(flightRequest, cz.muni.fi.pa165.dao.Flight.class));
+
         return modelMapper.map(result, Flight.class);
     }
 
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightRealizationFacade.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightRealizationFacade.java
index 99ce7048a1fa64fee249ad8cfb0ec9abbed15c41..897887556e6bd394c04ae4beac2c23c05a274e4c 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightRealizationFacade.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/FlightRealizationFacade.java
@@ -1,8 +1,7 @@
 package cz.muni.fi.pa165.facade;
 
 import cz.muni.fi.pa165.api.flight.requests.FlightRealizationRequest;
-import cz.muni.fi.pa165.dao.Flight;
-import cz.muni.fi.pa165.dao.FlightRealization;
+import cz.muni.fi.pa165.api.flight.FlightRealization;
 import cz.muni.fi.pa165.service.FlightRealizationService;
 import lombok.RequiredArgsConstructor;
 import org.modelmapper.ModelMapper;
@@ -30,13 +29,13 @@ public class FlightRealizationFacade {
     }
 
     public FlightRealization createFlightRealization(FlightRealizationRequest flightRealizationRequest){
-        var result = flightRealizationService.createFlightRealization(modelMapper.map(flightRealizationRequest, FlightRealization.class));
+        var result = flightRealizationService.createFlightRealization(modelMapper.map(flightRealizationRequest, cz.muni.fi.pa165.dao.FlightRealization.class));
         return modelMapper.map(result, FlightRealization.class);
     }
 
 
     public FlightRealization updateFlightRealization(UUID id, FlightRealizationRequest flightRealizationRequest){
-        var result = flightRealizationService.updateFlightRealization(id, modelMapper.map(flightRealizationRequest, FlightRealization.class));
+        var result = flightRealizationService.updateFlightRealization(id, modelMapper.map(flightRealizationRequest, cz.muni.fi.pa165.dao.FlightRealization.class));
         return modelMapper.map(result, FlightRealization.class);
     }
 
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/IssueReportFacade.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/IssueReportFacade.java
index 0bd35dcad1dcb221fb8f11f30131114e09448044..f06a9e0142cbb20455e5726888c7eb8811059a22 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/IssueReportFacade.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/facade/IssueReportFacade.java
@@ -1,7 +1,7 @@
 package cz.muni.fi.pa165.facade;
 
 import cz.muni.fi.pa165.api.flight.requests.IssueReportRequest;
-import cz.muni.fi.pa165.dao.IssueReport;
+import cz.muni.fi.pa165.api.flight.IssueReport;
 import cz.muni.fi.pa165.service.IssueReportService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -22,13 +22,13 @@ public class IssueReportFacade {
 //        return issueReportService.getAllIssueReports();
     }
     public IssueReport getIssueReport(UUID id) {
-        var result = issueReportService.getIssueReportById(id);
+        cz.muni.fi.pa165.dao.IssueReport result = issueReportService.get(id);
         return modelMapper.map(result, IssueReport.class);
 //        return  issueReportService.getIssueReportById(id);
     }
 
     public IssueReport createIssueReport(IssueReportRequest issueReportRequest){
-        var result = issueReportService.createIssueReport( modelMapper.map(issueReportRequest, IssueReport.class) );
+        var result = issueReportService.createIssueReport( modelMapper.map(issueReportRequest, cz.muni.fi.pa165.dao.IssueReport.class) );
         return modelMapper.map(result, IssueReport.class);
 
         // return issueReportService.createIssueReport(issueReport);
@@ -36,7 +36,8 @@ public class IssueReportFacade {
 
 
     public IssueReport updateIssueReport(UUID id, IssueReportRequest issueReportRequest){
-        return issueReportService.updateIssueReport(id, modelMapper.map( issueReportRequest, IssueReport.class ) );
+        var result =  issueReportService.updateIssueReport(id, modelMapper.map( issueReportRequest, cz.muni.fi.pa165.dao.IssueReport.class ) );
+        return  modelMapper.map(result, IssueReport.class);
     }
 
 
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/repository/FlightRepository.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/repository/FlightRepository.java
index 9a92868cd8b35e565704f09791594f05ab4e32cf..9c8f80ffd4e03616823674d42f420ad3940c7c5e 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/repository/FlightRepository.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/repository/FlightRepository.java
@@ -1,6 +1,8 @@
 package cz.muni.fi.pa165.repository;
 
 import cz.muni.fi.pa165.dao.Flight;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.stereotype.Repository;
@@ -9,4 +11,5 @@ import java.util.UUID;
 
 @Repository
 public interface FlightRepository extends JpaRepository<Flight, UUID> {
+    Page<Flight> findAll(Pageable pageable);
 }
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightController.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightController.java
index f2cf66aa57b4b426091b0d3a6cf3cd3359e2bf22..606ec5a0c6b3e4d6cd0f767d18e60930be6a8f83 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightController.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightController.java
@@ -1,8 +1,8 @@
 package cz.muni.fi.pa165.rest;
 
+import cz.muni.fi.pa165.api.flight.Flight;
 import cz.muni.fi.pa165.api.flight.requests.FlightRequest;
-import cz.muni.fi.pa165.dao.Flight;
-import cz.muni.fi.pa165.dao.IssueReport;
+//import cz.muni.fi.pa165.dao.Flight;
 import cz.muni.fi.pa165.facade.FlightFacade;
 import cz.muni.fi.pa165.repository.FlightRepository;
 import lombok.RequiredArgsConstructor;
@@ -12,7 +12,6 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
-import java.util.Optional;
 import java.util.UUID;
 
 @RestController
@@ -21,37 +20,40 @@ import java.util.UUID;
 public class FlightController {
 
     @Autowired
-    private final FlightRepository flightRepository;
-
     private final FlightFacade flightFacade;
 
     @GetMapping
-    public ResponseEntity<List<Flight>> getAllFlights() {
-        List<Flight> flights = flightFacade.getFlights();
+    public ResponseEntity<List<Flight>> getAllFlights(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "10") int size
+    ) {
+        List<Flight> flights = flightFacade.getFlights(page, size);
+
+        if( flights.isEmpty() ) {
+            return new ResponseEntity<>(flights, HttpStatus.NO_CONTENT);
+        }
+
         return new ResponseEntity<>(flights, HttpStatus.OK);
     }
 
     @GetMapping("/{id}")
     public Flight getFlight(@PathVariable UUID id) {
         return flightFacade.getFlight(id);
-
     }
-
-    // Create a new flight
     @PostMapping
     public Flight createFlight(@RequestBody FlightRequest flightRequest) {
         return flightFacade.createFlight(flightRequest);
     }
 
-    @PutMapping("/{id}")
-    public ResponseEntity<Flight> update(@PathVariable UUID id, @RequestBody FlightRequest flightRequest){
-        Flight updatedFlight = flightFacade.updateFlight(id, flightRequest);
-        return new ResponseEntity<>(updatedFlight, HttpStatus.CREATED);
+    @PostMapping("/{id}")
+    public Flight update(@PathVariable UUID id, @RequestBody FlightRequest flightRequest){
+        return flightFacade.updateFlight(id, flightRequest);
     }
 
+
     @DeleteMapping("/{id}")
     public ResponseEntity<String> deleteFlight(@PathVariable(value = "id") UUID id) {
-        flightRepository.deleteById(id);
+        flightFacade.deleteFlight(id);
         return new ResponseEntity<>("Flight deleted sucessfully", HttpStatus.OK);
     }
 }
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightRealizationController.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightRealizationController.java
index cc7d3947bd75d3253597acf8801b352c515436db..4306e94ad6de2045eda16d60900371c662f842ad 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightRealizationController.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/FlightRealizationController.java
@@ -1,8 +1,7 @@
 package cz.muni.fi.pa165.rest;
 
+import cz.muni.fi.pa165.api.flight.FlightRealization;
 import cz.muni.fi.pa165.api.flight.requests.FlightRealizationRequest;
-import cz.muni.fi.pa165.dao.Flight;
-import cz.muni.fi.pa165.dao.FlightRealization;
 import cz.muni.fi.pa165.facade.FlightRealizationFacade;
 import cz.muni.fi.pa165.repository.FlightRealizationRepository;
 import lombok.RequiredArgsConstructor;
@@ -21,16 +20,14 @@ import java.util.UUID;
 public class FlightRealizationController {
 
     @Autowired
-    private final FlightRealizationRepository flightRealizationRepository;
-
     private final FlightRealizationFacade flightRealizationFacade;
 
     @GetMapping
-    public ResponseEntity<List<FlightRealization>> getAllFlightRealizations() {
-        List<FlightRealization> flightRealizations = flightRealizationFacade.getAllFlightRealizations();
-        return new ResponseEntity<>(flightRealizations, HttpStatus.OK);
+    public List<FlightRealization> getAllFlightRealizations() {
+        return flightRealizationFacade.getAllFlightRealizations();
     }
 
+
     @GetMapping("/{id}")
     public FlightRealization getFlightRealizationById(@PathVariable UUID id) {
         return flightRealizationFacade.getFlightRealization(id);
@@ -38,21 +35,18 @@ public class FlightRealizationController {
 
     @PostMapping
     public FlightRealization createFlightRealization(@RequestBody FlightRealizationRequest flightRealizationRequest) {
-        System.out.println("flight reli");
-        System.out.println(flightRealizationRequest);
         return flightRealizationFacade.createFlightRealization(flightRealizationRequest);
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<FlightRealization> updateFlightRealization(@PathVariable UUID id, @RequestBody FlightRealizationRequest flightRealizationRequest) {
-        FlightRealization updatedFlightRealization = flightRealizationFacade.updateFlightRealization(id, flightRealizationRequest);
-        return new ResponseEntity<>(updatedFlightRealization, HttpStatus.CREATED);
+    public FlightRealization updateFlightRealization(@PathVariable UUID id, @RequestBody FlightRealizationRequest flightRealizationRequest) {
+        return flightRealizationFacade.updateFlightRealization(id, flightRealizationRequest);
     }
 
+
     @DeleteMapping("/{id}")
     public ResponseEntity<String> deleteFlightRealization(@PathVariable UUID id) {
-        flightRealizationRepository.deleteById(id);
-
+        flightRealizationFacade.deleteFlightRealization(id);
         return new ResponseEntity<>("Flight Realization deleted sucessfully", HttpStatus.OK);
     }
 }
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/IssueReportController.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/IssueReportController.java
index 997247fe278579fa54ae815fdf74b6740d32182f..11e58b0b422eaf2f8021417db5576de51ebe9af9 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/IssueReportController.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/rest/IssueReportController.java
@@ -1,10 +1,9 @@
 package cz.muni.fi.pa165.rest;
 
 
+import cz.muni.fi.pa165.api.flight.IssueReport;
 import cz.muni.fi.pa165.api.flight.requests.IssueReportRequest;
-import cz.muni.fi.pa165.dao.IssueReport;
 import cz.muni.fi.pa165.facade.IssueReportFacade;
-import cz.muni.fi.pa165.service.IssueReportService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
@@ -12,7 +11,6 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
-import java.util.Optional;
 import java.util.UUID;
 
 @RestController
@@ -21,41 +19,31 @@ import java.util.UUID;
 public class IssueReportController {
 
     @Autowired
-    private IssueReportService issueReportService;
-
     private final IssueReportFacade issueReportFacade;
 
     @GetMapping
-    public ResponseEntity<List<IssueReport>> getAllIssueReports() {
-//        List<IssueReport> issueReports =  issueReportService.getAllIssueReports();
-        List<IssueReport> issueReports = issueReportFacade.getAllIssueReports();
-        return new ResponseEntity<>(issueReports, HttpStatus.OK);
+    public List<IssueReport> getAllIssueReports() {
+        return issueReportFacade.getAllIssueReports();
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<IssueReport> getIssueReportById(@PathVariable("id") UUID id) {
-//        IssueReport issueReport = issueReportService.getIssueReportById(id);
-        IssueReport issueReport = issueReportFacade.getIssueReport(id);
-        return new ResponseEntity<>(issueReport, HttpStatus.OK);
+    public IssueReport getIssueReportById(@PathVariable("id") UUID id) {
+        return issueReportFacade.getIssueReport(id);
     }
 
     @PostMapping
-    public ResponseEntity<IssueReport> createIssueReport(@RequestBody IssueReportRequest issueReportRequest) {
-//        IssueReport savedIssueReport = issueReportService.createIssueReport(issueReport);
-        IssueReport savedIssueReport = issueReportFacade.createIssueReport(issueReportRequest);
-        return new ResponseEntity<>(savedIssueReport, HttpStatus.CREATED);
+    public IssueReport createIssueReport(@RequestBody IssueReportRequest issueReportRequest) {
+        return issueReportFacade.createIssueReport(issueReportRequest);
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<IssueReport> updateIssueReport(@PathVariable("id") UUID id, @RequestBody IssueReportRequest issueReportRequest) {
-//        IssueReport updatedIssueReport = issueReportService.updateIssueReport(id, issueReport);
-        IssueReport updatedIssueReport = issueReportFacade.updateIssueReport(id, issueReportRequest);
-        return new ResponseEntity<>(updatedIssueReport, HttpStatus.CREATED);
+    public IssueReport updateIssueReport(@PathVariable("id") UUID id, @RequestBody IssueReportRequest issueReportRequest) {
+        return issueReportFacade.updateIssueReport(id, issueReportRequest);
     }
 
     @DeleteMapping("/{id}")
     public ResponseEntity<String> deleteIssueReport(@PathVariable(value = "id") UUID id) {
-        issueReportService.deleteIssueReport(id);
+        issueReportFacade.deleteIssueReport(id);
         return new ResponseEntity<>("Issue deleted sucessfully", HttpStatus.OK);
     }
 }
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/FlightService.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/FlightService.java
index 90be0f6e01d539f6b822e05a9786f8a610484973..e204a8b31d6c52f20948d293ec9d634c44832029 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/FlightService.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/FlightService.java
@@ -1,19 +1,18 @@
 package cz.muni.fi.pa165.service;
 
 import cz.muni.fi.pa165.dao.Flight;
-import cz.muni.fi.pa165.dao.IssueReport;
 import cz.muni.fi.pa165.exception.FlightNotFoundException;
-import cz.muni.fi.pa165.exception.IssueReportNotFoundException;
 import cz.muni.fi.pa165.repository.FlightRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestBody;
 
 import java.util.List;
-import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 @Service
 @RequiredArgsConstructor
@@ -22,8 +21,10 @@ public class FlightService {
     @Autowired
     private FlightRepository flightRepository;
 
-    public List<Flight> getAllFlights() {
-        return flightRepository.findAll();
+    public List<Flight> getAllFlights(int page, int size) {
+        Pageable pageable = PageRequest.of(page, size);
+        Page<Flight> flightPage = flightRepository.findAll(pageable);
+        return flightPage.getContent().stream().collect(Collectors.toList());
     }
 
     public Flight getFlight(UUID id) {
diff --git a/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/IssueReportService.java b/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/IssueReportService.java
index 3862dbdea6814527ca97c199b870efe2b06f56fe..a621546ca0e635efae3d617381dbfc1ab5fbb7a7 100644
--- a/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/IssueReportService.java
+++ b/airports-flight-service/src/main/java/cz/muni/fi/pa165/service/IssueReportService.java
@@ -27,18 +27,12 @@ public class IssueReportService {
         return issueReportRepository.findById(id).orElseThrow(IssueReportNotFoundException::new);
     }
 
-    public IssueReport getIssueReportById(UUID id) {
-        Optional<IssueReport> issueReport = issueReportRepository.findById(id);
-        return issueReport.get();
-    }
-
     public IssueReport createIssueReport(IssueReport issueReport) {
         return issueReportRepository.save(issueReport);
     }
 
     public IssueReport updateIssueReport(UUID id, IssueReport issueReport) {
-        IssueReport existingIssueReport = issueReportRepository.findById(id).get();
-        System.out.println(existingIssueReport);
+        IssueReport existingIssueReport = issueReportRepository.findById(id).orElseThrow(IssueReportNotFoundException::new);
         existingIssueReport.setDescription(issueReport.getDescription());
         existingIssueReport.setFlightEncountered(issueReport.getFlightEncountered());
 
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightControllerTest.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightControllerTest.java
index 042f5675af3d1d18fa52c7aef7dd209d01185e19..b02a29dd76c2eb20a6fed510d5ddc44aee66d980 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightControllerTest.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightControllerTest.java
@@ -1,20 +1,40 @@
 package cz.muni.fi.pa165.rest;
 
+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.facade.FlightFacade;
+import cz.muni.fi.pa165.utils.ObjectConverter;
+import cz.muni.fi.pa165.utils.TestApiFactory;
+
+
+import org.springframework.test.web.servlet.RequestBuilder;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
+
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.context.ApplicationContext;
+import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
-@WebMvcTest
-public class FlightControllerTest {
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
 
-    @Autowired
-    private ApplicationContext applicationContext;
+
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+
+@WebMvcTest(controllers = FlightController.class)
+public class FlightControllerTest {
 
     @Autowired
     private MockMvc mockMvc;
@@ -23,27 +43,121 @@ public class FlightControllerTest {
     private FlightFacade flightFacade;
 
     @Test
-    public void testGetsFlight() {
-        assertTrue( true );
+    void findById_flightFound_returnflight() throws Exception {
+         UUID id = new UUID(0x1, 0xf);
+         UUID planeId = new UUID(0x1, 0xf);
+         UUID destination = new UUID(0x2, 0xf);
+         UUID origin = new UUID(0x3, 0xf);
+//        UUID id = UUID.fromString("00000000-0000-0001-0000-00000000000f");
+        Mockito.when(flightFacade.getFlight(id)).thenReturn(TestApiFactory.getFlightEntity());
+
+        RequestBuilder request = MockMvcRequestBuilders.get("/flights/{id}", id).accept(MediaType.APPLICATION_JSON_VALUE);
+        String responseJson = mockMvc.perform(request)
+                .andExpect(status().isOk())
+                .andReturn()
+                .getResponse()
+                .getContentAsString(StandardCharsets.UTF_8);
+         Flight response = ObjectConverter.convertJsonToObject(responseJson, Flight.class);
+         assertThat(responseJson).isEqualTo("{" +
+                 "\"id\":\""+ id +"\"," +
+                 "\"planeId\":\"" + planeId + "\"," +
+                 "\"pilotIds\":null," +
+                 "\"stewardIds\":null," +
+                 "\"origin\":\"" +origin+ "\"," +
+                 "\"destination\":\"" + destination + "\"" +
+                 "}"
+         );
+         assertThat(response).isEqualTo(TestApiFactory.getFlightEntity());
+    }
+
+
+    @Test
+    void findById_flightNotFound_throws404() throws Exception {
+        UUID id = UUID.randomUUID();
+        Mockito.when(flightFacade.getFlight(id)).thenThrow(new FlightNotFoundException());
+        RequestBuilder request = MockMvcRequestBuilders.get("/flights/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isNotFound());
+        Mockito.verify(flightFacade, Mockito.times(1)).getFlight(id);
     }
 
+
     @Test
-    public void testGetFlight() {
-        assertTrue( true );
+    void updateflight_flightFound_returnsflight() throws Exception {
+        UUID id = new UUID(0x1, 0xf);
+        UUID planeId = new UUID(0x1, 0xf);
+        UUID destination = new UUID(0x2, 0xf);
+        UUID origin = new UUID(0x3, 0xf);
+         cz.muni.fi.pa165.api.flight.Flight updatedFlight = TestApiFactory.getFlightEntity();
+         Mockito.when(flightFacade.updateFlight( Mockito.eq(id), Mockito.any(FlightRequest.class))).thenReturn(updatedFlight);
+
+         String requestJson =
+                 "{" +
+                         "\"planeId\":\"" + planeId + "\"," +
+                         "\"pilotIds\":null," +
+                         "\"stewardIds\":null," +
+                         "\"origin\":\"" +origin+ "\"," +
+                         "\"destination\":\"" + destination + "\"" +
+                         "}";
+
+
+        String responseJson = mockMvc.perform(put("/flights/{id}", id)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(requestJson))
+                .andExpect(status().isOk())
+                .andReturn()
+                .getResponse()
+                .getContentAsString(StandardCharsets.UTF_8);
+
+        Flight response = ObjectConverter.convertJsonToObject(responseJson, Flight.class);
+        assertThat(response).isEqualTo(updatedFlight);
+        Mockito.verify(flightFacade, Mockito.times(1)).updateFlight(Mockito.eq(id), Mockito.any(FlightRequest.class));
     }
 
+
     @Test
-    public void testCreateFlight() throws Exception {
-        assertTrue( true );
+    public void updateflight_flightNotFound_throws404() throws Exception {
+        UUID id = UUID.randomUUID();
+        UUID planeId = new UUID(0x1, 0xf);
+        UUID destination = new UUID(0x2, 0xf);
+        UUID origin = new UUID(0x3, 0xf);
+
+        Mockito.when(flightFacade.updateFlight(Mockito.eq(id), Mockito.any())).thenThrow(new FlightNotFoundException());
+        RequestBuilder request = MockMvcRequestBuilders.delete("/flights/{id}", id).accept(MediaType.APPLICATION_JSON);
+        String requestJson =
+                "{" +
+                        "\"planeId\":\"" + planeId + "\"," +
+                        "\"pilotIds\":null," +
+                        "\"stewardIds\":null," +
+                        "\"origin\":\"" +origin+ "\"," +
+                        "\"destination\":\"" + destination + "\"" +
+                        "}";
+
+        mockMvc.perform(put("/flights/{id}", id)
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(requestJson))
+                .andExpect(status().isNotFound());
+
+        Mockito.verify(flightFacade, Mockito.times(1)).updateFlight(Mockito.eq(id), Mockito.any(FlightRequest.class));
     }
 
     @Test
-    public void testupdateFlight() throws Exception {
-        assertTrue( true );
+    public void deleteflight_flightFound() throws Exception {
+        UUID id = UUID.randomUUID();
+        Flight flight = TestApiFactory.getFlightEntity();
+        Mockito.doNothing().when(flightFacade).deleteFlight(id);
+        RequestBuilder request = MockMvcRequestBuilders.delete("/flights/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isOk());
+        Mockito.verify(flightFacade, Mockito.times(1)).deleteFlight(id);
     }
 
+
     @Test
-    public void testdeleteFlight() throws Exception {
-        assertTrue( true );
+    public void Deleteflight_flightNotFound_404() throws Exception {
+        UUID id = UUID.randomUUID();
+//        Mockito.when(flightFacade.deleteFlight(id)).thenThrow(new FlightNotFoundException());
+        RequestBuilder request = MockMvcRequestBuilders.delete("/flights/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isNotFound());
+
+        Mockito.verify(flightFacade, Mockito.times(1)).deleteFlight(id);
     }
  }
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightRealizationControllerTest.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightRealizationControllerTest.java
index 805930894470e3361d15a1c540235d102088ab50..b0b83aa44c99b05a660028446af767d3860d42be 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightRealizationControllerTest.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/FlightRealizationControllerTest.java
@@ -1,50 +1,159 @@
 package cz.muni.fi.pa165.rest;
 
+import cz.muni.fi.pa165.api.flight.IssueReport;
+import cz.muni.fi.pa165.api.flight.requests.FlightRealizationRequest;
+import cz.muni.fi.pa165.api.flight.requests.FlightRequest;
+import cz.muni.fi.pa165.api.flight.requests.IssueReportRequest;
+import cz.muni.fi.pa165.dao.FlightRealization;
+import cz.muni.fi.pa165.exception.FlightRealizationNotFoundException;
+import cz.muni.fi.pa165.exception.IssueReportNotFoundException;
 import cz.muni.fi.pa165.facade.FlightFacade;
+import cz.muni.fi.pa165.facade.FlightRealizationFacade;
+import cz.muni.fi.pa165.utils.ObjectConverter;
+import cz.muni.fi.pa165.utils.TestApiFactory;
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.context.ApplicationContext;
+import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.RequestBuilder;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
 
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
 
 
-@WebMvcTest
-public class FlightRealizationControllerTest {
 
-    @Autowired
-    private ApplicationContext applicationContext;
+@WebMvcTest(controllers = FlightRealization.class)
+public class FlightRealizationControllerTest {
 
     @Autowired
     private MockMvc mockMvc;
 
     @MockBean
-    private FlightFacade flightFacade;
+    private FlightRealizationFacade flightRealizationFacade;
 
     @Test
-    public void testGetAllFlightRealizations() throws Exception {
-        assertTrue( true );
+    void findById_flightRelizationFound_returnsflightRelization() throws Exception {
+        UUID id = new UUID(0x1, 0xf);
+        Mockito.when(flightRealizationFacade.getFlightRealization(id)).thenReturn(TestApiFactory.getFlightRealizationEntity());
+
+        RequestBuilder request = MockMvcRequestBuilders.get("/flightrelization/{id}", id).accept(MediaType.APPLICATION_JSON);
+        String responseJson = mockMvc.perform(request)
+                .andExpect(status().isOk())
+                .andReturn()
+                .getResponse()
+                .getContentAsString(StandardCharsets.UTF_8);
+
+        FlightRealization response = ObjectConverter.convertJsonToObject(responseJson, FlightRealization.class);
+
+        assertThat(responseJson).isEqualTo("{" +
+                "\"id\":\""+ id +"\"," +
+                "\"flightId\":\"" + id + "\"," +
+                "\"report\":\"report\"," +
+                "\"duration\":\""+ Duration.ofHours(1) +"\"," +
+                "\"departureTime\":\"" + LocalDateTime.now() + "\"," +
+                "\"arrivalTime\":\"" + LocalDateTime.now() + "\"," +
+                "\"kilometersFlown\":\""+ 850 +"\"" +
+                "}"
+        );
+
+
+        assertThat(response).isEqualTo(TestApiFactory.getFlightRealizationEntity());
+    }
+
+
+
+    @Test
+    void findById_flightRealizationNotFound_throws404() throws Exception {
+        UUID id = UUID.randomUUID();
+        Mockito.when(flightRealizationFacade.getFlightRealization(id)).thenThrow(new FlightRealizationNotFoundException());
+
+        mockMvc.perform(get("/flightrelization/{id}", id)
+                        .accept(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNotFound());
+
+        Mockito.verify(flightRealizationFacade, Mockito.times(1)).getFlightRealization(id);
     }
 
     @Test
-    public void testGetFlightRealizationById() throws Exception {
-        assertTrue( true );
+    void updateflightRealization_flightRealizationFound_returnsIssueReport() throws Exception {
+        UUID id = new UUID(0x1, 0xf);
+         cz.muni.fi.pa165.api.flight.FlightRealization updatedFlightRealization = TestApiFactory.getFlightRealizationEntity();
+         Mockito.when(flightRealizationFacade.updateFlightRealization(Mockito.eq(id), Mockito.any(FlightRealizationRequest.class))).thenReturn(updatedFlightRealization);
+
+             String requestJson = "{" +
+                     "\"id\":\""+ id +"\"," +
+                     "\"flightId\":\"" + id + "\"," +
+                     "\"report\":\"report\"," +
+                     "\"duration\":\""+ Duration.ofHours(1) +"\"," +
+                     "\"departureTime\":\"" + LocalDateTime.now() + "\"," +
+                     "\"arrivalTime\":\"" + LocalDateTime.now() + "\"," +
+                     "\"kilometersFlown\":\""+ 850 +"\"" +
+                     "}";
+             String responseJson = mockMvc.perform(put("/flightrelization/{id}", id)
+                        .contentType(MediaType.APPLICATION_JSON)
+                       .content(requestJson)
+                   )
+                .andExpect(status().isOk())
+                .andReturn()
+                .getResponse()
+                .getContentAsString(StandardCharsets.UTF_8);
+
+            FlightRealization response = ObjectConverter.convertJsonToObject(responseJson, FlightRealization.class);
+            assertThat(response).isEqualTo(updatedFlightRealization);
+            Mockito.verify(flightRealizationFacade, Mockito.times(1))
+                .updateFlightRealization(Mockito.eq(id), Mockito.any(FlightRealizationRequest.class));
     }
 
+
+
     @Test
-    public void testCreateFlightRealization() throws Exception {
-        assertTrue( true );
+    public void updateflightRealization_flightRealizationNotFound_throws404() throws Exception {
+        UUID id = UUID.randomUUID();
+        Mockito.when(flightRealizationFacade.updateFlightRealization(Mockito.eq(id), Mockito.any(FlightRealizationRequest.class))).thenThrow(new FlightRealizationNotFoundException());
+
+        RequestBuilder request = MockMvcRequestBuilders.put("/flightrelization/{id}", id).accept(MediaType.APPLICATION_JSON);
+
+        mockMvc.perform(request).andExpect(status().isOk());
+
+        Mockito.verify(flightRealizationFacade, Mockito.times(1)).updateFlightRealization(Mockito.eq(id),Mockito.any());
     }
 
+
+
+
     @Test
-    public void testUpdateFlightRealization() throws Exception {
-        assertTrue( true );
+    public void deleteflightRealization_flightRealizationFound() throws Exception {
+        UUID id = UUID.randomUUID();
+        cz.muni.fi.pa165.api.flight.FlightRealization mockIssueReport = TestApiFactory.getFlightRealizationEntity();
+//         Mockito.when(flightRealizationFacade.deleteFlightRealization(id)).thenReturn("");
+
+        RequestBuilder request = MockMvcRequestBuilders.delete("/flightrelization/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isOk());
+
+        Mockito.verify(flightRealizationFacade, Mockito.times(1)).deleteFlightRealization(id);
     }
 
+
     @Test
-    public void testDeleteFlightRealization() throws Exception {
-        assertTrue( true );
+    public void DeleteflightRealization_flightRealizationNotFound_404() throws Exception {
+        UUID id = UUID.randomUUID();
+//        Mockito.when(flightRealizationFacade.deleteFlightRealization(id)).thenThrow(new IssueReportNotFoundException());
+        RequestBuilder request = MockMvcRequestBuilders.delete("/flightrelization/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isNotFound());
+
+        Mockito.verify(flightRealizationFacade, Mockito.times(1)).deleteFlightRealization(id);
     }
 }
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/IssueReportControllerTest.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/IssueReportControllerTest.java
index fb2ac4c2025a84dd94051a586874be99d186b408..99a4e0cf51f26511f6fc96ff3f2f22310ada12db 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/IssueReportControllerTest.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/rest/IssueReportControllerTest.java
@@ -1,50 +1,133 @@
 package cz.muni.fi.pa165.rest;
 
-import cz.muni.fi.pa165.facade.FlightFacade;
+import cz.muni.fi.pa165.api.flight.IssueReport;
+import cz.muni.fi.pa165.api.flight.requests.IssueReportRequest;
+import cz.muni.fi.pa165.exception.IssueReportNotFoundException;
+import cz.muni.fi.pa165.facade.IssueReportFacade;
+import cz.muni.fi.pa165.utils.ObjectConverter;
+import cz.muni.fi.pa165.utils.TestApiFactory;
+
 import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.context.ApplicationContext;
+import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.RequestBuilder;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.nio.charset.StandardCharsets;
+import java.util.UUID;
 
 
-@WebMvcTest
-public class IssueReportControllerTest {
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
-    @Autowired
-    private ApplicationContext applicationContext;
+
+@WebMvcTest( controllers = IssueReportControllerTest.class)
+public class IssueReportControllerTest {
 
     @Autowired
     private MockMvc mockMvc;
 
     @MockBean
-    private FlightFacade flightFacade;
+    private IssueReportFacade issueReportFacade;
+
+    @Test
+    void findById_issueReportFound_returnsissueReport() throws Exception {
+        UUID id = new UUID(0x1, 0xf);
+        Mockito.when(issueReportFacade.getIssueReport(id)).thenReturn(TestApiFactory.getIssueReport());
+
+        RequestBuilder request = MockMvcRequestBuilders.get("/issuereports/{id}", id).accept(MediaType.APPLICATION_JSON);
+
+        String responseJson = mockMvc.perform(request)
+                .andExpect(status().isOk())
+                .andReturn()
+                .getResponse()
+                .getContentAsString(StandardCharsets.UTF_8);
+
+        IssueReport response = ObjectConverter.convertJsonToObject(responseJson, IssueReport.class);
+
+        assertThat(responseJson).isEqualTo("{" +
+                "\"id\":\""+ id +"\"," +
+                "\"flightId\":\"" + id + "\"," +
+                "\"flightEncountered\":\"" +id+ "\"," +
+                "\"description\":\"description\"" +
+                "}"
+        );
+
+        assertThat(response).isEqualTo(TestApiFactory.getIssueReport());
+    }
+
 
     @Test
-    public void testGetAllIssueReports() throws Exception {
-        assertTrue( true );
+    void findById_employeeNotFound_throws404() throws Exception {
+        UUID id = UUID.randomUUID();
+        Mockito.when(issueReportFacade.getIssueReport(id)).thenThrow(new IssueReportNotFoundException());
+        RequestBuilder request = MockMvcRequestBuilders.get("/issuereports/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isNotFound());
+        Mockito.verify(issueReportFacade, Mockito.times(1)).getIssueReport(id);
     }
 
     @Test
-    public void testGetIssueReportById() throws Exception {
-        assertTrue( true );
+    void updateIssueReport_IssueReportFound_returnsIssueReport() throws Exception {
+        UUID id = new UUID(0x1, 0xf);
+        IssueReport updatedIssueReport = TestApiFactory.getIssueReport();
+        Mockito.when(issueReportFacade.updateIssueReport(Mockito.eq(id), Mockito.any(IssueReportRequest.class))).thenReturn(updatedIssueReport);
+
+        String requestJson =
+                "{" +
+                    "\"id\":\""+ id +"\"," +
+                    "\"planeId\":\"" + id + "\"," +
+                    "\"flightEncountered\":\"" +id+ "\"," +
+                    "\"description\":\"description\"" +
+                "}";
+        String responseJson = mockMvc.perform(put("/issuereports/{id}", id)
+                        .contentType(MediaType.APPLICATION_JSON)
+                       .content(requestJson)
+                   )
+                .andExpect(status().isOk())
+                .andReturn()
+                .getResponse()
+                .getContentAsString(StandardCharsets.UTF_8);
+
+        IssueReport response = ObjectConverter.convertJsonToObject(responseJson, IssueReport.class);
+        assertThat(response).isEqualTo(updatedIssueReport);
+        Mockito.verify(issueReportFacade, Mockito.times(1)).updateIssueReport(Mockito.eq(id), Mockito.any(IssueReportRequest.class));
     }
 
+
     @Test
-    public void testCreateIssueReport() throws Exception {
-        assertTrue( true );
+    public void updateIssueReport_IssueReportNotFound_throws404() throws Exception {
+        UUID id = UUID.randomUUID();
+        Mockito.when(issueReportFacade.updateIssueReport(Mockito.eq(id), Mockito.any(IssueReportRequest.class))).thenThrow(new IssueReportNotFoundException());
+        RequestBuilder request = MockMvcRequestBuilders.put("/issuereports/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isNotFound());
+        Mockito.verify(issueReportFacade, Mockito.times(1)).updateIssueReport(Mockito.eq(id), Mockito.any(IssueReportRequest.class));
     }
 
+
+
     @Test
-    public void testUpdateIssueReport() throws Exception {
-        assertTrue( true );
+    public void deleteIssueReport_IssueReportFound() throws Exception {
+        UUID id = UUID.randomUUID();
+        IssueReport mockIssueReport = TestApiFactory.getIssueReport();
+        Mockito.doNothing().when(issueReportFacade).deleteIssueReport(id);
+        RequestBuilder request = MockMvcRequestBuilders.delete("/issuereports/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isOk());
+        Mockito.verify(issueReportFacade, Mockito.times(1)).deleteIssueReport(id);
     }
 
+
     @Test
-    public void testDeleteIssueReport() throws Exception {
-        assertTrue( true );
+    public void DeleteIssueReport_IssueReportNotFound_404() throws Exception {
+        UUID id = UUID.randomUUID();
+        Mockito.doNothing().when(issueReportFacade).deleteIssueReport(id);
+        RequestBuilder request = MockMvcRequestBuilders.delete("/issuereports/{id}", id).accept(MediaType.APPLICATION_JSON);
+        mockMvc.perform(request).andExpect(status().isNotFound());
+        Mockito.verify(issueReportFacade, Mockito.times(1)).deleteIssueReport(id);
     }
 }
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightRealizationServiceTest.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightRealizationServiceTest.java
index 472c44ec700c8a0d069defa4d342875fcd7272aa..805810936a48b31347bab4e958536bc1ab48e112 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightRealizationServiceTest.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightRealizationServiceTest.java
@@ -3,14 +3,22 @@ package cz.muni.fi.pa165.service;
 import cz.muni.fi.pa165.dao.FlightRealization;
 import cz.muni.fi.pa165.exception.FlightRealizationNotFoundException;
 import cz.muni.fi.pa165.repository.FlightRealizationRepository;
-import cz.muni.fi.pa165.repository.FlightRepository;
+import cz.muni.fi.pa165.utils.TestDaoFactory;
+import org.junit.jupiter.api.Assertions;
 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 java.util.List;
+import java.time.Duration;
+import java.util.Optional;
+import java.util.UUID;
+
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @ExtendWith(MockitoExtension.class)
 public class FlightRealizationServiceTest {
@@ -21,27 +29,87 @@ public class FlightRealizationServiceTest {
     private FlightRealizationService flightRealizationService;
 
     @Test
-    public void getAllFlightRealizations() {
+    public void getFlightRealization_flightRealizationFound_returnsFlight() {
+        // Prepare a sample flight ID
+        UUID id = UUID.randomUUID();
+
+        // Create a sample flight object
+        FlightRealization flight = TestDaoFactory.getflightRealizationEntity();
+
+        // Mocking the behavior of the flightRepository.findById() method
+        Mockito.when(flightRealizationRepository.findById(id)).thenReturn(Optional.of(flight));
+
+        // Calling the method to be tested
+        FlightRealization foundFlight = flightRealizationService.getFlightRealizationById(id);
 
+        // Assertions
+        Assertions.assertEquals(foundFlight, flight); // Check if the returned flight matches the one we created
     }
 
     @Test
-    public void getFlightRealizationById() {
+    void getById_flightRealizationNotFound_throwsResourceNotFoundException() {
+        // Prepare a random non-existent flight ID
+        UUID id = UUID.randomUUID();
 
+        // Mock the behavior of the flightRepository.findById() method to return an empty Optional
+        Mockito.when(flightRealizationRepository.findById(id)).thenReturn(Optional.empty());
+
+        // Assert that calling flightService.getFlight(id) should throw FlightNotFoundException
+        assertThrows(FlightRealizationNotFoundException.class, () -> flightRealizationService.getFlightRealizationById(id));
     }
 
+
     @Test
-    public void createFlightRealization() {
+    void createFlightRealization() {
+        // Create a sample flight object
+        FlightRealization flight = TestDaoFactory.getflightRealizationEntity();
+
+        // Mocking the behavior of the flightRepository.save() method
+        Mockito.when(flightRealizationRepository.save(flight)).thenReturn(flight);
+
+        // Calling the method to be tested
+        FlightRealization createdFlight = flightRealizationService.createFlightRealization(flight);
 
+        // Assertions
+        assertEquals(flight, createdFlight); // Check if returned flight matches the one we created
+        Mockito.verify(flightRealizationRepository, Mockito.times(1)).save(flight); // Verify that save method was called exactly once with the correct parameter
     }
 
     @Test
-    public void updateFlightRealization() {
+    void updateFlightRealization_flightRealizationNotFound_throwsFlightRealizationNotFoundException() {
+        UUID id = UUID.randomUUID(); // Generate a random flight ID
+        FlightRealization update = new FlightRealization(); // Prepare an update object
 
+        // Assert that calling flightService.updateFlight(id, update) should throw FlightNotFoundException
+        assertThrows(FlightRealizationNotFoundException.class, () -> flightRealizationService.updateFlightRealization(id, update));
+
+        // Verify that stewardRepository.save() was not called
+        Mockito.verify(flightRealizationRepository, Mockito.times(0)).save(Mockito.any());
     }
 
+
     @Test
-    public void deleteFlightRealization() {
+    void updateFlightRealization_flighrealizationtFound() {
+        UUID id = UUID.randomUUID();
+
+        FlightRealization existingFlightRealization = TestDaoFactory.getflightRealizationEntity();
+        existingFlightRealization.setId(id);
+
+        FlightRealization update = new FlightRealization();
+        update.setDuration(Duration.ofHours(2));
+
+        FlightRealization updatedFlightRealization = TestDaoFactory.getflightRealizationEntity();
+
+        updatedFlightRealization.setId(id);
+        updatedFlightRealization.setDuration(Duration.ofHours(2));
+
+        Mockito.when(flightRealizationRepository.findById(id)).thenReturn(Optional.of(existingFlightRealization));
+
+        Mockito.when(flightRealizationRepository.save(Mockito.any(FlightRealization.class))).thenReturn(updatedFlightRealization);
+
+        FlightRealization returnedFlightRealization = flightRealizationService.updateFlightRealization(id, update);
 
+        assertEquals(updatedFlightRealization, returnedFlightRealization);
+        Mockito.verify(flightRealizationRepository, Mockito.times(1)).save(updatedFlightRealization);
     }
 }
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightServiceTest.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightServiceTest.java
index ca76b51f61c0fa08fbcf9ac6052da49a1fc1eb05..c49a29db9a5dbda8f01e39aaf8b8b440da285257 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightServiceTest.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/FlightServiceTest.java
@@ -97,12 +97,14 @@ public class FlightServiceTest {
         existingFlight.setId(id);
 
         Flight update = new Flight();
-        update.setDestination(destId.toString());
+//        update.setDestination(destId.toString());
+        update.setDestination(destId);
 
         Flight updatedFlight = TestDaoFactory.getFlightEntity();
 
         updatedFlight.setId(id);
-        updatedFlight.setDestination(destId.toString());
+//        updatedFlight.setDestination(destId.toString());
+        updatedFlight.setDestination(destId);
 
         Mockito.when(flightRepository.findById(id)).thenReturn(Optional.of(existingFlight));
 
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/IssueReportTest.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/IssueReportTest.java
index 2665ab98ba3ac3527267ae41e17dcebfe24310ff..3fb8456642b54ebb33eab5b68e749e6aeecbd05a 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/IssueReportTest.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/service/IssueReportTest.java
@@ -1,12 +1,26 @@
 package cz.muni.fi.pa165.service;
 
+import cz.muni.fi.pa165.dao.FlightRealization;
+import cz.muni.fi.pa165.dao.IssueReport;
+import cz.muni.fi.pa165.exception.FlightRealizationNotFoundException;
+import cz.muni.fi.pa165.exception.IssueReportNotFoundException;
 import cz.muni.fi.pa165.repository.IssueReportRepository;
+import cz.muni.fi.pa165.utils.TestDaoFactory;
+import org.junit.jupiter.api.Assertions;
 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 java.time.Duration;
+import java.util.Optional;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 @ExtendWith(MockitoExtension.class)
 public class IssueReportTest {
 
@@ -18,22 +32,59 @@ public class IssueReportTest {
 
 
     @Test
-    public void getAllIssueReports() {
-
+    public void getIssueReport_issueReportFound_returnsIssueReport() {
+        UUID id = UUID.randomUUID();
+        IssueReport issueReport = TestDaoFactory.getIssueReport();
+        Mockito.when(issueReportRepository.findById(id)).thenReturn(Optional.of(issueReport));
+        IssueReport foundIssueReport = issueReportService.get(id);
+        Assertions.assertEquals(foundIssueReport, issueReport);
     }
 
     @Test
-    public void get() {}
+    void getById_issueReportNotFound_throwsResourceNotFoundException() {
+        UUID id = UUID.randomUUID();
+        Mockito.when(issueReportRepository.findById(id)).thenReturn(Optional.empty());
+        assertThrows(IssueReportNotFoundException.class, () -> issueReportService.get(id));
+    }
 
-    @Test
-    public void getIssueReportById() {}
 
     @Test
-    public void createIssueReport() {}
+    void createIssueReport() {
+        IssueReport issueReport = TestDaoFactory.getIssueReport();
+        Mockito.when(issueReportRepository.save(issueReport)).thenReturn(issueReport);
+        IssueReport createdIssueReport = issueReportService.createIssueReport(issueReport);
+        assertEquals(issueReport, createdIssueReport);
+        Mockito.verify(issueReportRepository, Mockito.times(1)).save(issueReport);
+    }
 
     @Test
-    public void updateIssueReport() {}
+    void updateIssueReport_issueReportNotFound_throwsIssueReportNotFoundException() {
+        UUID id = UUID.randomUUID();
+        IssueReport update = new IssueReport();
+        assertThrows(IssueReportNotFoundException.class, () -> issueReportService.updateIssueReport(id, update));
+        Mockito.verify(issueReportRepository, Mockito.times(0)).save(Mockito.any());
+    }
+
 
     @Test
-    public void deleteIssueReport() {}
+    void updateIssueReport_issueReportFound() {
+        UUID id = UUID.randomUUID();
+        UUID planeId = UUID.randomUUID();
+        IssueReport issueReport = TestDaoFactory.getIssueReport();
+        issueReport.setId(id);
+        IssueReport update = new IssueReport();
+        update.setDescription("description");
+        update.setPlaneId(planeId);
+        IssueReport updatedIssueReport = TestDaoFactory.getIssueReport();
+        updatedIssueReport.setId(id);
+        updatedIssueReport.setDescription("description");
+        updatedIssueReport.setPlaneId(planeId);
+
+        Mockito.when(issueReportRepository.findById(id)).thenReturn(Optional.of(issueReport));
+        Mockito.when(issueReportRepository.save(Mockito.any(IssueReport.class))).thenReturn(updatedIssueReport);
+
+        IssueReport returnedIssueReport = issueReportService.updateIssueReport(id, update);
+        assertEquals(updatedIssueReport, returnedIssueReport);
+        Mockito.verify(issueReportRepository, Mockito.times(1)).save(updatedIssueReport);
+    }
 }
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/ObjectConverter.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/ObjectConverter.java
new file mode 100644
index 0000000000000000000000000000000000000000..f27966fb46ea6ba151c3b19646b63860a21f1d83
--- /dev/null
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/ObjectConverter.java
@@ -0,0 +1,30 @@
+package cz.muni.fi.pa165.utils;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+
+import java.io.IOException;
+
+public class ObjectConverter {
+
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper()
+            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
+            .registerModule(new JavaTimeModule())
+            .setSerializationInclusion(JsonInclude.Include.NON_NULL);
+
+    public static <T> T convertJsonToObject(String serializedObject, Class<T> objectClass) throws JsonProcessingException {
+        return OBJECT_MAPPER.readValue(serializedObject, objectClass);
+    }
+
+    public static String convertObjectToJson(Object object) throws JsonProcessingException {
+        return OBJECT_MAPPER.writeValueAsString(object);
+    }
+
+    public static <T> T convertJsonToObject(String object, TypeReference<T> typeReference) throws IOException {
+        return OBJECT_MAPPER.readValue(object, typeReference);
+    }
+}
\ No newline at end of file
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestApiFactory.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestApiFactory.java
index a478f64ba714b9c64b07ef6a48ca9dbb37d1a2ec..670dbd2a0eed6e4bd193fec1bc39ab02b1a4a977 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestApiFactory.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestApiFactory.java
@@ -3,28 +3,34 @@ package cz.muni.fi.pa165.utils;
 import cz.muni.fi.pa165.api.flight.Flight;
 import cz.muni.fi.pa165.api.flight.FlightRealization;
 import cz.muni.fi.pa165.api.flight.IssueReport;
+import cz.muni.fi.pa165.api.flight.requests.FlightRealizationRequest;
 import cz.muni.fi.pa165.api.flight.requests.FlightRequest;
+import cz.muni.fi.pa165.api.flight.requests.IssueReportRequest;
 import org.springframework.stereotype.Component;
 
 import java.time.Duration;
 import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.UUID;
 
 @Component
 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.setOrigin(new UUID(0x3, 0xf));
+        flight.setId(id);
 
         return flight;
     }
 
 
-    public static FlightRealization getflightRealizationEntity() {
+    public static FlightRealization getFlightRealizationEntity() {
         UUID id = new UUID(0x1, 0xf);
         FlightRealization flightRealization = new FlightRealization();
         flightRealization.setDepartureTime(LocalDateTime.now());
@@ -33,21 +39,52 @@ public class TestApiFactory {
         flightRealization.setReport("report");
         flightRealization.setDuration(Duration.ofHours(1));
         flightRealization.setKilometersFlown(850);
+        flightRealization.setId(id);
 
         return flightRealization;
     }
 
     public static IssueReport getIssueReport() {
+        UUID id = new UUID(0x1, 0xf);
         IssueReport issueReport = new IssueReport();
         issueReport.setFlightEncountered(new UUID(0x1, 0xf));
         issueReport.setDescription("description");
+        issueReport.setPlaneId(new UUID(0x1, 0xf));
+        issueReport.setId(id);
 
         return issueReport;
     }
 
     public static FlightRequest getFlightRequest() {
-        FlightRequest flightRequest = new FlightRequest("origin", "Destination", new UUID(0x1, 0xf));
-
+        FlightRequest flightRequest = new FlightRequest(
+                new UUID(0x1, 0xf),
+                new UUID(0x1, 0xf),
+                new UUID(0x1, 0xf)
+        );
         return flightRequest;
     }
+
+    public static FlightRealizationRequest getFlightRelizationRequest() {
+        UUID flightId = new UUID(0x1, 0xf);
+
+        FlightRealizationRequest flightRealizationRequest = new FlightRealizationRequest(
+                flightId,
+                "report",
+                Duration.ofHours(1),
+                LocalDateTime.now(),
+                LocalDateTime.now(),
+                2.5
+        );
+
+        return flightRealizationRequest;
+    }
+
+    public static IssueReportRequest getIssueReportRequest() {
+        IssueReportRequest issueReportRequest = new IssueReportRequest(
+                new UUID(0x1, 0xf),
+                "there is issue happen in flight",
+                new UUID(0x1, 0xf)
+        );
+        return issueReportRequest;
+    }
 }
diff --git a/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestDaoFactory.java b/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestDaoFactory.java
index c41b41b0f60535c6e085afaeece99dbc1514d61e..817570cb972be10dbe832f81bcd6b62ca7baf363 100644
--- a/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestDaoFactory.java
+++ b/airports-flight-service/src/test/java/cz/muni/fi/pa165/utils/TestDaoFactory.java
@@ -16,8 +16,10 @@ public class TestDaoFactory {
         UUID id = new UUID(0x1, 0xf);
         Flight flight = new Flight();
         flight.setPlaneId(id);
-        flight.setDestination("Destination");
-        flight.setOrigin("Origin");
+        flight.setOrigin(new UUID(0x1, 0xf));
+        flight.setDestination(new UUID(0x1, 0xf));
+//        flight.setDestination("Destination");
+//        flight.setOrigin("Origin");
 
         return flight;
     }
@@ -38,7 +40,8 @@ public class TestDaoFactory {
 
     public static IssueReport getIssueReport() {
         IssueReport issueReport = new IssueReport();
-        issueReport.setFlightEncountered(1L);
+        issueReport.setPlaneId(new UUID(0x1, 0xf));
+        issueReport.setFlightEncountered(new UUID(0x1, 0xf));
         issueReport.setDescription("description");
 
         return issueReport;