Merge branch 'develop'v2.0

21 files changed, 1087 insertions, 942 deletions

diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/CreateNewEmployeeApplication.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewEmployeeApplication.java
index e9f4801..e1b3714 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/CreateNewEmployeeApplication.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewEmployeeApplication.java
@@ -1,4 +1,4 @@
-package at.ac.tuwien.sepm.assignment.groupphase.employee;
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.controller;
 
 import at.ac.tuwien.sepm.assignment.groupphase.util.SpringFXMLLoader;
 import java.lang.invoke.MethodHandles;
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/CreateNewEmployeeControllerTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewEmployeeControllerTest.java
index eb1a728..7f95950 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/CreateNewEmployeeControllerTest.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewEmployeeControllerTest.java
@@ -1,4 +1,4 @@
-package at.ac.tuwien.sepm.assignment.groupphase.employee;
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.controller;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/CreateNewVehicleApplication.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewVehicleApplication.java
index dcd88ec..ff46938 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/CreateNewVehicleApplication.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewVehicleApplication.java
@@ -1,4 +1,4 @@
-package at.ac.tuwien.sepm.assignment.groupphase.vehicle;
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.controller;
 
 import at.ac.tuwien.sepm.assignment.groupphase.util.SpringFXMLLoader;
 import java.lang.invoke.MethodHandles;
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/CreateNewVehicleControllerTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewVehicleControllerTest.java
index 866ed74..08e3fde 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/CreateNewVehicleControllerTest.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/controller/CreateNewVehicleControllerTest.java
@@ -1,4 +1,4 @@
-package at.ac.tuwien.sepm.assignment.groupphase.vehicle;
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.controller;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/EmployeeDAOTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/EmployeeDAOTest.java
new file mode 100644
index 0000000..585e5ea
--- /dev/null
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/EmployeeDAOTest.java
@@ -0,0 +1,254 @@
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao;
+
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee.EducationLevel;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.ElementNotFoundException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
+import at.ac.tuwien.sepm.assignment.groupphase.util.Helper;
+import at.ac.tuwien.sepm.assignment.groupphase.util.JdbcTestCase;
+import java.io.InputStream;
+import java.time.LocalDate;
+import java.util.Set;
+import org.dbunit.Assertion;
+import org.dbunit.dataset.DataSetException;
+import org.dbunit.dataset.IDataSet;
+import org.dbunit.dataset.ITable;
+import org.dbunit.dataset.filter.DefaultColumnFilter;
+import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
+import org.dbunit.util.fileloader.FlatXmlDataFileLoader;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EmployeeDAOTest extends JdbcTestCase {
+
+    private EmployeeDAO employeePersistence;
+
+    public EmployeeDAOTest() throws PersistenceException {
+        employeePersistence = new EmployeeDatabaseDAO(getJdbcConnectionManager());
+    }
+
+    @Override
+    protected IDataSet getDataSet() throws DataSetException {
+        InputStream res =
+                getClass()
+                        .getClassLoader()
+                        .getResourceAsStream("EmployeePersistenceTestBaseData.xml");
+        return new FlatXmlDataSetBuilder().build(res);
+    }
+
+    @Test
+    public void testListEmployees() throws PersistenceException {
+        Set<Employee> employees = employeePersistence.list();
+
+        System.out.println(LocalDate.parse("2010-10-10"));
+        Employee empOne =
+                Employee.builder()
+                        .id(1)
+                        .name("Adam")
+                        .birthday(LocalDate.parse("2010-10-10"))
+                        .educationLevel(EducationLevel.RS)
+                        .isDriver(true)
+                        .isPilot(false)
+                        .build();
+
+        Employee empTwo =
+                Employee.builder()
+                        .id(2)
+                        .name("Max")
+                        .birthday(LocalDate.parse("1990-11-11"))
+                        .educationLevel(EducationLevel.NFS)
+                        .isDriver(false)
+                        .isPilot(false)
+                        .build();
+
+        Employee empThree =
+                Employee.builder()
+                        .id(3)
+                        .name("Lisa")
+                        .birthday(LocalDate.parse("1999-10-16"))
+                        .educationLevel(EducationLevel.NKI)
+                        .isDriver(true)
+                        .isPilot(false)
+                        .build();
+
+        Assert.assertTrue(employees.contains(empOne));
+        Assert.assertTrue(employees.contains(empTwo));
+        Assert.assertTrue(employees.contains(empThree));
+        Assert.assertEquals(3, employees.size());
+    }
+
+    @Test
+    public void testEmployeeListNoElement() throws PersistenceException {
+        Set<Employee> employees = employeePersistence.list();
+
+        Employee empOne =
+                Employee.builder()
+                        .id(10)
+                        .name("Adam")
+                        .birthday(LocalDate.parse("2010-10-10"))
+                        .educationLevel(EducationLevel.RS)
+                        .isDriver(true)
+                        .isPilot(false)
+                        .build();
+
+        Assert.assertFalse(employees.contains(empOne));
+    }
+
+    Employee validEmployee =
+            Employee.builder()
+                    .name("Testperson")
+                    .birthday(LocalDate.parse("2010-11-11"))
+                    .educationLevel(EducationLevel.NA)
+                    .isDriver(true)
+                    .isPilot(false)
+                    .build();
+
+    @Test
+    public void testAddValidEmployee_EmployeeVersion() throws Exception {
+
+        employeePersistence.add(validEmployee);
+
+        String[] excludedColumnsEmployeeVersion = new String[] {"ID"};
+        String tableEmployeeVersion = "EMPLOYEEVERSION";
+
+        // load actual and expected data set
+        IDataSet actualDataSet = getConnection().createDataSet();
+        IDataSet expectedDataSet =
+                new FlatXmlDataFileLoader().load("/testAddValidEmployee_expected.xml");
+
+        // extract employeeVersion table
+        ITable actualEmployeeVersionTable = actualDataSet.getTable(tableEmployeeVersion);
+        ITable expectedEmployeeVersionTable = expectedDataSet.getTable(tableEmployeeVersion);
+
+        // exclude 'id' column as it is an autogenerated value
+        ITable actualFilteredTable =
+                DefaultColumnFilter.excludedColumnsTable(
+                        actualEmployeeVersionTable, excludedColumnsEmployeeVersion);
+        ITable expectedFilteredTable =
+                DefaultColumnFilter.excludedColumnsTable(
+                        expectedEmployeeVersionTable, excludedColumnsEmployeeVersion);
+
+        Assertion.assertEquals(expectedFilteredTable, actualFilteredTable);
+    }
+
+    @Test
+    public void testAddValidEmployee_Employee() throws Exception {
+
+        employeePersistence.add(validEmployee);
+
+        String[] excludedColumnsEmployee = new String[] {"VERSION", "ID"};
+        String tableEmployee = "EMPLOYEE";
+
+        // load actual and expected data set
+        IDataSet actualDataSet = getConnection().createDataSet();
+        IDataSet expectedDataSet =
+                new FlatXmlDataFileLoader().load("/testAddValidEmployee_expected.xml");
+
+        // extract employee table
+        ITable actualEmployeeTable = actualDataSet.getTable(tableEmployee);
+        ITable expectedEmployeeTable = expectedDataSet.getTable(tableEmployee);
+
+        // exclude 'version' as it is an autogenerated value
+        ITable actualFilteredEmpTable =
+                DefaultColumnFilter.excludedColumnsTable(
+                        actualEmployeeTable, excludedColumnsEmployee);
+        ITable expectedFilteredEmpTable =
+                DefaultColumnFilter.excludedColumnsTable(
+                        expectedEmployeeTable, excludedColumnsEmployee);
+
+        Assertion.assertEquals(expectedFilteredEmpTable, actualFilteredEmpTable);
+    }
+
+    @Test
+    public void testAddValidEmployee_Join() throws Exception {
+
+        employeePersistence.add(validEmployee);
+
+        String[] excludedColumns = new String[] {"E_VERSION", "V_ID", "E_ID"};
+        String table = "EMP_JOIN";
+        String expectedXmlDataFileName = "testAddValidEmployeeJoin_expected.xml";
+
+        String sqlJoinEmployeeVersion =
+                "SELECT e.id AS E_ID, v.name AS V_NAME, v.birthday AS V_BIRTHDAY, "
+                        + "v.educationLevel as V_EDUCATIONLEVEL, "
+                        + "v.isDriver AS V_ISDRIVER, v.isPilot AS V_ISPILOT "
+                        + "FROM Employee e "
+                        + "JOIN EmployeeVersion v ON e.version = v.id";
+
+        ITable actualFilteredJoinData =
+                Helper.getActualFilteredQueryTableData(
+                        getConnection(), table, sqlJoinEmployeeVersion, excludedColumns);
+
+        ITable expectedFilteredJoinData =
+                Helper.getExpectedFilteredTableData(
+                        table, excludedColumns, expectedXmlDataFileName);
+
+        Assertion.assertEquals(expectedFilteredJoinData, actualFilteredJoinData);
+    }
+
+    Employee validUpdateEmployee =
+            Employee.builder()
+                    .id(3)
+                    .name("Lisa")
+                    .birthday(LocalDate.parse("1999-10-16"))
+                    .educationLevel(EducationLevel.NKA)
+                    .isDriver(true)
+                    .isPilot(true)
+                    .build();
+
+    @Test
+    public void testUpdateValidEmployee_EmployeeVersion() throws Exception {
+
+        employeePersistence.update(validUpdateEmployee);
+
+        String[] excludedColumnsEmployeeVersion = new String[] {"ID"};
+        String tableEmployeeVersion = "EMPLOYEEVERSION";
+
+        ITable actualTableData =
+                Helper.getActualFilteredTableData(
+                        getConnection(), tableEmployeeVersion, excludedColumnsEmployeeVersion);
+        ITable expedtedTableData =
+                Helper.getExpectedFilteredTableData(
+                        tableEmployeeVersion,
+                        excludedColumnsEmployeeVersion,
+                        "testUpdateValidEmployee_expected.xml");
+
+        Assertion.assertEquals(expedtedTableData, actualTableData);
+    }
+
+    @Test
+    public void testUpdateValidEmployee_Employee() throws Exception {
+
+        employeePersistence.update(validUpdateEmployee);
+
+        String[] excludedColumns = new String[] {"VERSION"};
+        String tableName = "EMPLOYEE";
+        String expectedXmlDataFileName = "testUpdateValidEmployee_expected.xml";
+
+        ITable actualTableData =
+                Helper.getActualFilteredTableData(getConnection(), tableName, excludedColumns);
+
+        ITable expectedTableData =
+                Helper.getExpectedFilteredTableData(
+                        tableName, excludedColumns, expectedXmlDataFileName);
+
+        Assertion.assertEquals(expectedTableData, actualTableData);
+    }
+
+    @Test(expected = ElementNotFoundException.class)
+    public void testUpdateNonExistingEmployee()
+            throws PersistenceException, ElementNotFoundException {
+
+        Employee nonExistentEmployee =
+                Employee.builder()
+                        .id(1000)
+                        .name("Lisa")
+                        .birthday(LocalDate.parse("1999-10-16"))
+                        .educationLevel(EducationLevel.NKA)
+                        .isDriver(true)
+                        .isPilot(true)
+                        .build();
+
+        employeePersistence.update(nonExistentEmployee);
+    }
+}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/OperationDAOTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/OperationDAOTest.java
new file mode 100644
index 0000000..f173376
--- /dev/null
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/OperationDAOTest.java
@@ -0,0 +1,157 @@
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao;
+
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation.Severity;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation.Status;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.ConstructionType;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.VehicleType;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.ElementNotFoundException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
+import at.ac.tuwien.sepm.assignment.groupphase.util.JdbcTestCase;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Set;
+import org.dbunit.dataset.DataSetException;
+import org.dbunit.dataset.IDataSet;
+import org.junit.Test;
+
+public class OperationDAOTest extends JdbcTestCase {
+
+    private static final String[] COMPARE_TABLES =
+            new String[] {"VehicleOperation", "Operation", "Vehicle", "VehicleVersion"};
+
+    private final OperationDAO operationDAO;
+
+    private final Operation o;
+
+    public OperationDAOTest() throws PersistenceException {
+        // TODO: fix once everything properly uses dependency injection
+        EmployeeDAO employeeDAO = new EmployeeDatabaseDAO(getJdbcConnectionManager());
+        RegistrationDatabaseDAO registrationDatabaseDAO =
+                new RegistrationDatabaseDAO(getJdbcConnectionManager(), employeeDAO);
+        VehicleDAO vehicleDAO =
+                new VehicleDatabaseDAO(getJdbcConnectionManager(), registrationDatabaseDAO);
+        this.operationDAO = new OperationDatabaseDAO(getJdbcConnectionManager(), vehicleDAO);
+
+        Vehicle v1 =
+                Vehicle.builder()
+                        .id(1)
+                        .name("RTW-1")
+                        .constructionType(Vehicle.ConstructionType.HOCHDACH)
+                        .type(Vehicle.VehicleType.RTW)
+                        .status(Vehicle.Status.FREI_FUNK)
+                        .hasNef(true)
+                        .build();
+
+        Vehicle v2 = v1.toBuilder().id(2).build();
+        Vehicle v3 = v1.toBuilder().id(3).build();
+
+        o =
+                Operation.builder()
+                        .id(1)
+                        .opCode("RD-2B0M")
+                        .severity(Severity.B)
+                        .status(Status.ACTIVE)
+                        .vehicles(Set.of(v1, v2, v3))
+                        .created(Instant.now())
+                        .destination("New description")
+                        .additionalInfo("Test")
+                        .build();
+    }
+
+    @Override
+    protected IDataSet getDataSet() throws DataSetException {
+        return getDataSet("operationDAOUpdateSetup.xml");
+    }
+
+    @Test
+    public void testUpdateNormal() throws Exception {
+        operationDAO.update(o);
+
+        compareWith("operationDAOUpdateNormal.xml", COMPARE_TABLES);
+    }
+
+    @Test(expected = ElementNotFoundException.class)
+    public void testUpdateMissing() throws Exception {
+        Operation op = o.toBuilder().id(73).build();
+
+        operationDAO.update(op);
+    }
+
+    @Test
+    public void testUpdateRemoveVehicles() throws Exception {
+        Operation op = o.toBuilder().vehicles(Collections.emptySet()).build();
+
+        operationDAO.update(op);
+
+        compareWith("operationDAOUpdateRemoveVehicles.xml", COMPARE_TABLES);
+    }
+
+    @Test
+    public void testListOperations() throws Exception {
+        Set<Operation> operationSet = operationDAO.list(EnumSet.allOf(Status.class));
+
+        // TODO: operations.list() currently doesn't set the vehicles set
+        // assertEquals(Set.of(o), operationSet);
+    }
+
+    @Test
+    public void testAddOperation() throws Exception {
+        operationDAO.add(o);
+
+        // TODO: won't work because id won't match
+        // compareWith("operationDAOUpdateNormal.xml", COMPARE_TABLES);
+    }
+
+    @Test(expected = PersistenceException.class)
+    public void testAddFaultyOperation() throws PersistenceException {
+        Vehicle vehicle =
+                Vehicle.builder()
+                        .status(Vehicle.Status.FREI_FUNK)
+                        .constructionType(ConstructionType.HOCHDACH)
+                        .name("BKTW_123")
+                        .hasNef(true)
+                        .type(VehicleType.BKTW)
+                        .build();
+
+        Operation operation =
+                Operation.builder()
+                        .status(Status.ACTIVE)
+                        .opCode(String.valueOf(Arrays.stream(new int[200]).map(i -> 'a')))
+                        .created(Instant.now())
+                        .destination("Wiedner Hauptstraße 35, Wien")
+                        .additionalInfo("HTU Wien")
+                        .severity(Severity.B)
+                        .vehicles(Set.of(vehicle))
+                        .build();
+        operationDAO.add(operation);
+    }
+
+    @Test(expected = PersistenceException.class)
+    public void testAddFaultyOperation2() throws PersistenceException {
+        Vehicle vehicle =
+                Vehicle.builder()
+                        .status(Vehicle.Status.FREI_FUNK)
+                        .constructionType(ConstructionType.HOCHDACH)
+                        .name("BKTW_123")
+                        .hasNef(true)
+                        .type(VehicleType.BKTW)
+                        .build();
+
+        Operation operation =
+                Operation.builder()
+                        .status(Status.ACTIVE)
+                        .opCode("ALP-95E7")
+                        .created(Instant.now())
+                        .destination(
+                                "Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien ")
+                        .additionalInfo("HTU Wien")
+                        .severity(Severity.B)
+                        .vehicles(Set.of(vehicle))
+                        .build();
+        operationDAO.add(operation);
+    }
+}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/RegistrationDatabaseDAOTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/RegistrationDAOTest.java
index 03059ff..e8ea809 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/RegistrationDatabaseDAOTest.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/RegistrationDAOTest.java
@@ -11,8 +11,8 @@ import java.nio.charset.Charset;
 import java.sql.SQLException;
 import java.time.Instant;
 import java.time.LocalDate;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 import org.h2.tools.RunScript;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
@@ -20,9 +20,9 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 
-public class RegistrationDatabaseDAOTest {
+public class RegistrationDAOTest {
 
-    // Base taken from EmployeePersistenceTest
+    // Base taken from EmployeeDAOTest
 
     private static final String JDBC_DRIVER = org.h2.Driver.class.getName();
     private static final String JDBC_URL = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1";
@@ -31,8 +31,12 @@ public class RegistrationDatabaseDAOTest {
 
     private RegistrationDAO registrationDAO;
 
-    public RegistrationDatabaseDAOTest() throws PersistenceException {
-        this.registrationDAO = new RegistrationDatabaseDAO(new JDBCConnectionManager(JDBC_URL));
+    public RegistrationDAOTest() throws PersistenceException {
+        JDBCConnectionManager jdbcConnectionManager = new JDBCConnectionManager(JDBC_URL);
+        this.registrationDAO =
+                new RegistrationDatabaseDAO(
+                        jdbcConnectionManager, new EmployeeDatabaseDAO(jdbcConnectionManager));
+        // TODO: Use Spring Dependency Injection here!
     }
 
     @BeforeClass
@@ -79,7 +83,7 @@ public class RegistrationDatabaseDAOTest {
 
     @Test
     public void addRegistrationsShouldSucceed() throws PersistenceException {
-        List<Registration> registrations = new LinkedList<>();
+        Set<Registration> registrations = new HashSet<>();
         /*
         Vehicle vehicle = Vehicle.builder()
                 .id(1)
@@ -139,14 +143,14 @@ public class RegistrationDatabaseDAOTest {
         registrations.add(registration2);
         registrations.add(registration3);
 
-        List<Long> returnvalues = registrationDAO.add(1, registrations);
+        Set<Long> returnvalues = registrationDAO.add(1, registrations);
         assertFalse(returnvalues.isEmpty()); // can be improved...
     }
 
     @Test
     public void addRegistrationToInexistentVehicleShouldFail() throws PersistenceException {
         thrown.expect(PersistenceException.class);
-        List<Registration> registrations = new LinkedList<>();
+        Set<Registration> registrations = new HashSet<>();
         Employee employee =
                 Employee.builder()
                         .id(1)
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/VehicleDAOTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/VehicleDAOTest.java
new file mode 100644
index 0000000..1862214
--- /dev/null
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/dao/VehicleDAOTest.java
@@ -0,0 +1,161 @@
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao;
+
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.ConstructionType;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.Status;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.VehicleType;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.ElementNotFoundException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
+import at.ac.tuwien.sepm.assignment.groupphase.util.Helper;
+import at.ac.tuwien.sepm.assignment.groupphase.util.JdbcTestCase;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Set;
+import org.dbunit.Assertion;
+import org.dbunit.dataset.IDataSet;
+import org.dbunit.dataset.ITable;
+import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class VehicleDAOTest extends JdbcTestCase {
+
+    private VehicleDAO vehicleDAO;
+
+    private Vehicle validUpdateVehicle =
+            Vehicle.builder()
+                    .hasNef(true)
+                    .constructionType(ConstructionType.HOCHDACH)
+                    .type(VehicleType.RTW)
+                    .id(2)
+                    .name("RTW-2")
+                    .status(Status.ABGEMELDET)
+                    .build();
+
+    public VehicleDAOTest() throws PersistenceException {
+        vehicleDAO =
+                new VehicleDatabaseDAO(
+                        getJdbcConnectionManager(),
+                        new RegistrationDatabaseDAO(
+                                getJdbcConnectionManager(),
+                                new EmployeeDatabaseDAO(getJdbcConnectionManager())));
+        // TODO: use Spring Dependency Injection!
+    }
+
+    @Override
+    protected IDataSet getDataSet() throws Exception {
+        InputStream res = getClass().getClassLoader().getResourceAsStream("vehicleTestData.xml");
+        return new FlatXmlDataSetBuilder().build(res);
+    }
+
+    @Test
+    public void testListVehicle() throws PersistenceException {
+        Set<Vehicle> vehicles = vehicleDAO.list();
+
+        Vehicle v1 =
+                Vehicle.builder()
+                        .id(1)
+                        .constructionType(ConstructionType.HOCHDACH)
+                        .name("RTW-1")
+                        .hasNef(true)
+                        .status(Status.ABGEMELDET)
+                        .type(VehicleType.RTW)
+                        .registrations(new ArrayList<>())
+                        .build();
+        Vehicle v2 =
+                Vehicle.builder()
+                        .id(2)
+                        .constructionType(ConstructionType.MITTELHOCHDACH)
+                        .name("KTW-2")
+                        .hasNef(false)
+                        .status(Status.FREI_WACHE)
+                        .type(VehicleType.KTW)
+                        .registrations(new ArrayList<>())
+                        .build();
+        Vehicle v3 =
+                Vehicle.builder()
+                        .id(3)
+                        .constructionType(ConstructionType.NORMAL)
+                        .name("NEF-3")
+                        .hasNef(false)
+                        .status(Status.FREI_FUNK)
+                        .type(VehicleType.NEF)
+                        .registrations(new ArrayList<>())
+                        .build();
+
+        Assert.assertTrue(vehicles.contains(v1));
+        Assert.assertTrue(vehicles.contains(v2));
+        Assert.assertTrue(vehicles.contains(v3));
+        Assert.assertEquals(3, vehicles.size());
+    }
+
+    @Test
+    public void testVehicleListNoElement() throws PersistenceException {
+        Set<Vehicle> vehicles = vehicleDAO.list();
+
+        Vehicle v1 =
+                Vehicle.builder()
+                        .id(30)
+                        .constructionType(ConstructionType.NORMAL)
+                        .name("NEF-3")
+                        .hasNef(false)
+                        .status(Status.FREI_FUNK)
+                        .type(VehicleType.NEF)
+                        .build();
+
+        Assert.assertFalse(vehicles.contains(v1));
+    }
+
+    @Test
+    public void testUpdateValid_VehicleVersion() throws Exception {
+        vehicleDAO.update(validUpdateVehicle);
+
+        String[] excludedColumnsVehicleVersion = new String[] {"ID", "NAME"};
+        String tableVehicleVersion = "VEHICLEVERSION";
+
+        ITable actualTableData =
+                Helper.getActualFilteredTableData(
+                        getConnection(), tableVehicleVersion, excludedColumnsVehicleVersion);
+
+        ITable expectedTableData =
+                Helper.getExpectedFilteredTableData(
+                        tableVehicleVersion,
+                        excludedColumnsVehicleVersion,
+                        "vehicleTestUpdateExpectedData.xml");
+        Assertion.assertEquals(expectedTableData, actualTableData);
+    }
+
+    @Test
+    public void testUpdateValid_Vehicle() throws Exception {
+        vehicleDAO.update(validUpdateVehicle);
+
+        String[] excludedColumnsVehicleVersion = new String[] {"VERSION", "STATUS"};
+        String tableVehicleVersion = "VEHICLE";
+
+        ITable actualTableData =
+                Helper.getActualFilteredTableData(
+                        getConnection(), tableVehicleVersion, excludedColumnsVehicleVersion);
+
+        ITable expectedTableData =
+                Helper.getExpectedFilteredTableData(
+                        tableVehicleVersion,
+                        excludedColumnsVehicleVersion,
+                        "vehicleTestUpdateExpectedData.xml");
+        Assertion.assertEquals(expectedTableData, actualTableData);
+    }
+
+    @Test(expected = ElementNotFoundException.class)
+    public void testUpdateNonExistingVehicle()
+            throws PersistenceException, ElementNotFoundException {
+        Vehicle nonExistentVehicle =
+                Vehicle.builder()
+                        .id(35)
+                        .constructionType(ConstructionType.NORMAL)
+                        .name("NEF-3")
+                        .hasNef(false)
+                        .status(Status.FREI_FUNK)
+                        .type(VehicleType.NEF)
+                        .build();
+        vehicleDAO.update(nonExistentVehicle);
+    }
+}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/EmployeeServiceTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/EmployeeServiceTest.java
new file mode 100644
index 0000000..90f0a44
--- /dev/null
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/EmployeeServiceTest.java
@@ -0,0 +1,67 @@
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.EmployeeDAO;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.EmployeeDatabaseDAO;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee.EducationLevel;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.ElementNotFoundException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidEmployeeException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.ServiceException;
+import java.time.LocalDate;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EmployeeServiceTest {
+
+    private final EmployeeDAO employeePersistence = mock(EmployeeDatabaseDAO.class);
+    private final EmployeeService employeeService = new EmployeeServiceImpl(employeePersistence);
+
+    private final Employee.Builder employeeBuilder =
+            Employee.builder()
+                    .name("Testperson")
+                    .birthday(LocalDate.parse("1996-10-10"))
+                    .educationLevel(EducationLevel.NKA)
+                    .isDriver(true)
+                    .isPilot(false);
+
+    public EmployeeServiceTest() throws PersistenceException {
+        when(employeePersistence.add(any())).thenReturn(1L);
+    }
+
+    @Test
+    public void testAddValidEmployee() throws ServiceException, InvalidEmployeeException {
+
+        Employee employee = employeeBuilder.build();
+        Assert.assertThat(employeeService.add(employee), is(1L));
+    }
+
+    @Test(expected = InvalidEmployeeException.class)
+    public void testAddInvalidEmployee() throws InvalidEmployeeException, ServiceException {
+
+        Employee employee = employeeBuilder.name("").build();
+        employeeService.add(employee);
+    }
+
+    @Test
+    public void testUpdateValidEmployee() throws ElementNotFoundException, PersistenceException {
+
+        Employee employee = employeeBuilder.build();
+        employeePersistence.update(employee);
+    }
+
+    @Test(expected = ElementNotFoundException.class)
+    public void testUpdateNonExistentEmployee()
+            throws ElementNotFoundException, PersistenceException {
+
+        doThrow(ElementNotFoundException.class).when(employeePersistence).update(any());
+        Employee employee = employeeBuilder.id(1000).build();
+        employeePersistence.update(employee);
+    }
+}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeeServiceTestConfiguration.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/EmployeeServiceTestConfiguration.java
index 3668ef4..6bf2275 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeeServiceTestConfiguration.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/EmployeeServiceTestConfiguration.java
@@ -1,9 +1,7 @@
-package at.ac.tuwien.sepm.assignment.groupphase.employee;
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service;
 
 import static org.mockito.Mockito.mock;
 
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.EmployeeService;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.EmployeeServiceImpl;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/OperationServiceTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/OperationServiceTest.java
new file mode 100644
index 0000000..67fb77d
--- /dev/null
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/OperationServiceTest.java
@@ -0,0 +1,205 @@
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.OperationDAO;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.VehicleDAO;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation.Severity;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation.Status;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.ConstructionType;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.ElementNotFoundException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidOperationException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidVehicleException;
+import java.time.Instant;
+import java.util.Collections;
+import java.util.Set;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class OperationServiceTest {
+
+    @Mock private OperationDAO operationDAO;
+
+    @Mock private VehicleDAO vehicleDAO;
+
+    @InjectMocks private OperationServiceImpl operationService;
+
+    private Set<Vehicle> vehicles;
+    private Vehicle v1, v2, v3, v4, v5;
+    private Operation baseOp, o1, o2;
+
+    @Before
+    public void setUp() throws Exception {
+        v1 =
+                Vehicle.builder()
+                        .id(1)
+                        .name("RTW-1")
+                        .constructionType(ConstructionType.HOCHDACH)
+                        .type(Vehicle.VehicleType.RTW)
+                        .status(Vehicle.Status.FREI_FUNK)
+                        .hasNef(true)
+                        .build();
+
+        v2 =
+                Vehicle.builder()
+                        .id(2)
+                        .name("KTW-1")
+                        .constructionType(ConstructionType.HOCHDACH)
+                        .type(Vehicle.VehicleType.KTW)
+                        .status(Vehicle.Status.FREI_WACHE)
+                        .hasNef(true)
+                        .build();
+
+        v3 =
+                Vehicle.builder()
+                        .id(3)
+                        .name("KTW-2")
+                        .constructionType(ConstructionType.MITTELHOCHDACH)
+                        .type(Vehicle.VehicleType.KTW_B)
+                        .status(Vehicle.Status.FREI_FUNK)
+                        .hasNef(false)
+                        .build();
+
+        v4 =
+                Vehicle.builder()
+                        .id(4)
+                        .name("BKTW-2")
+                        .constructionType(ConstructionType.HOCHDACH)
+                        .type(Vehicle.VehicleType.BKTW)
+                        .status(Vehicle.Status.FREI_FUNK)
+                        .hasNef(false)
+                        .build();
+
+        v5 =
+                Vehicle.builder()
+                        .id(5)
+                        .name("NEF-1")
+                        .constructionType(ConstructionType.NORMAL)
+                        .type(Vehicle.VehicleType.NEF)
+                        .status(Vehicle.Status.FREI_WACHE)
+                        .hasNef(true)
+                        .build();
+
+        Vehicle v6 =
+                Vehicle.builder()
+                        .id(6)
+                        .name("NAH-1")
+                        .constructionType(ConstructionType.MITTELHOCHDACH)
+                        .type(Vehicle.VehicleType.NAH)
+                        .status(Vehicle.Status.ABGEMELDET)
+                        .hasNef(true)
+                        .build();
+
+        vehicles = Set.of(v1, v2, v3, v4, v5, v6);
+
+        baseOp =
+                Operation.builder()
+                        .opCode("ALP-95E7")
+                        .severity(Severity.E)
+                        .status(Status.ACTIVE)
+                        .vehicles(Collections.singleton(v1))
+                        .destination("Wiedner Hauptstraße 35, Wien")
+                        .build();
+
+        o1 = baseOp.toBuilder().id(1).created(Instant.now()).build();
+        o2 = o1.toBuilder().id(5).status(Status.CANCELLED).build();
+
+        when(operationDAO.get(anyLong()))
+                .thenAnswer(
+                        ans -> {
+                            long arg = ans.getArgument(0);
+                            if (arg == 1L) return o1;
+                            else if (arg == 5L) return o2;
+                            else throw new ElementNotFoundException("");
+                        });
+
+        when(vehicleDAO.get(anyLong()))
+                .thenAnswer(
+                        ans -> {
+                            int arg = ((Long) ans.getArgument(0)).intValue();
+                            return vehicles.stream()
+                                    .filter(v -> v.id() == arg)
+                                    .findFirst()
+                                    .orElseThrow(() -> new ElementNotFoundException(""));
+                        });
+    }
+
+    @Test
+    public void requestNormal() throws Exception {
+        Set<Long> vehicleIds = Set.of(2L, 3L, 4L, 5L);
+        operationService.requestVehicles(1, vehicleIds);
+
+        Operation result =
+                operationDAO.get(1).toBuilder().vehicles(Set.of(v1, v2, v3, v4, v5)).build();
+        verify(operationDAO, times(1)).update(result);
+        verify(operationDAO, times(0)).get(6L);
+    }
+
+    @Test
+    public void requestExistingVehicle() throws Exception {
+        operationService.requestVehicles(1, Set.of(1L));
+
+        Operation result = operationDAO.get(1);
+        verify(operationDAO, times(0)).update(result);
+    }
+
+    @Test(expected = InvalidVehicleException.class)
+    public void requestInvalidVehicle() throws Exception {
+        operationService.requestVehicles(1, Set.of(5L, 6L));
+    }
+
+    @Test(expected = InvalidOperationException.class)
+    public void requestInvalidOperation() throws Exception {
+        operationService.requestVehicles(2, Set.of(1L));
+    }
+
+    @Test(expected = InvalidVehicleException.class)
+    public void requestInactiveVehicle() throws Exception {
+        operationService.requestVehicles(1, Set.of(6L));
+    }
+
+    @Test(expected = InvalidOperationException.class)
+    public void requestInactiveOperation() throws Exception {
+        operationService.requestVehicles(5, Set.of(1L));
+    }
+
+    @Test
+    public void addOperation() throws Exception {
+        operationService.add(baseOp.toBuilder().severity(null).build());
+
+        verify(operationDAO, times(1))
+                .add(baseOp.toBuilder().created(any()).status(Status.ACTIVE).build());
+        verify(vehicleDAO, times(1)).get(v1.id());
+    }
+
+    @Test(expected = InvalidOperationException.class)
+    public void addWithSeverity() throws Exception {
+        operationService.add(baseOp.toBuilder().severity(Severity.E).build());
+    }
+
+    @Test(expected = InvalidOperationException.class)
+    public void addWithoutVehicles() throws Exception {
+        operationService.add(baseOp.toBuilder().vehicles(Set.of()).build());
+    }
+
+    @Test(expected = InvalidOperationException.class)
+    public void addInvalidOpcode() throws Exception {
+        operationService.add(baseOp.toBuilder().opCode("ABC").build());
+    }
+
+    @Test(expected = InvalidOperationException.class)
+    public void addWithSetCreated() throws Exception {
+        operationService.add(baseOp.toBuilder().created(Instant.now()).build());
+    }
+}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/RegistrationServiceImplTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/RegistrationServiceTest.java
index f3efbef..4d3a251 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/RegistrationServiceImplTest.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/RegistrationServiceTest.java
@@ -1,25 +1,28 @@
 package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service;
 
-import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.when;
 
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.RegistrationDAO;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.VehicleDAO;
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee;
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee.EducationLevel;
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Registration;
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle;
+import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.Builder;
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.ConstructionType;
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.Status;
 import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.VehicleType;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.ElementNotFoundException;
 import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidRegistrationException;
 import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidVehicleException;
+import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
 import at.ac.tuwien.sepm.assignment.groupphase.exception.ServiceException;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.temporal.ChronoUnit;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -29,38 +32,35 @@ import org.mockito.MockitoAnnotations;
 import org.mockito.junit.MockitoJUnit;
 import org.mockito.junit.MockitoRule;
 
-public class RegistrationServiceImplTest {
+public class RegistrationServiceTest {
 
-    @Mock RegistrationDAO daoMock;
+    @Mock private RegistrationDAO registrationDAO;
 
-    @Mock VehicleService vehicleService;
+    @Mock private VehicleDAO vehicleDAO;
 
     @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
 
     @Rule public ExpectedException thrown = ExpectedException.none();
 
     @Before
-    public void setUp() throws ServiceException {
+    public void setUp() throws ElementNotFoundException, PersistenceException {
         MockitoAnnotations.initMocks(this);
-        when(vehicleService.list(any()))
-                .thenReturn(
-                        Arrays.asList(
-                                Vehicle.builder()
-                                        .id(1)
-                                        .name("RTW-1")
-                                        .constructionType(ConstructionType.HOCHDACH)
-                                        .status(Status.ABGEMELDET)
-                                        .type(VehicleType.RTW)
-                                        .hasNef(true)
-                                        .build()));
+        Builder b =
+                Vehicle.builder()
+                        .name("RTW-1")
+                        .constructionType(ConstructionType.HOCHDACH)
+                        .status(Status.ABGEMELDET)
+                        .type(VehicleType.RTW)
+                        .hasNef(true);
+        when(vehicleDAO.get(anyLong())).thenAnswer(ans -> b.id(ans.getArgument(0)).build());
     }
 
     @Test
     public void addValidRegistrationsShouldSucceed()
             throws InvalidRegistrationException, ServiceException, InvalidVehicleException {
         RegistrationService registrationService =
-                new RegistrationServiceImpl(daoMock, vehicleService);
-        List<Registration> registrations = new LinkedList<>();
+                new RegistrationServiceImpl(registrationDAO, vehicleDAO);
+        Set<Registration> registrations = new HashSet<>();
         Vehicle vehicle =
                 Vehicle.builder()
                         .id(1)
@@ -116,8 +116,8 @@ public class RegistrationServiceImplTest {
             throws InvalidRegistrationException, ServiceException, InvalidVehicleException {
         thrown.expect(InvalidRegistrationException.class);
         RegistrationService registrationService =
-                new RegistrationServiceImpl(daoMock, vehicleService);
-        List<Registration> registrations = new LinkedList<>();
+                new RegistrationServiceImpl(registrationDAO, vehicleDAO);
+        Set<Registration> registrations = new HashSet<>();
         Vehicle vehicle =
                 Vehicle.builder()
                         .id(1)
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/VehicleServiceTestConfiguration.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/VehicleServiceTestConfiguration.java
index ccd1e5d..895973a 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/VehicleServiceTestConfiguration.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/einsatzverwaltung/service/VehicleServiceTestConfiguration.java
@@ -1,9 +1,7 @@
-package at.ac.tuwien.sepm.assignment.groupphase.vehicle;
+package at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service;
 
 import static org.mockito.Mockito.mock;
 
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.VehicleService;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.VehicleServiceImpl;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeePersistenceTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeePersistenceTest.java
deleted file mode 100644
index f8fe0f3..0000000
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeePersistenceTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-package at.ac.tuwien.sepm.assignment.groupphase.employee;
-
-import static junit.framework.TestCase.fail;
-
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.EmployeeDAO;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.EmployeeDatabaseDao;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee.EducationLevel;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
-import at.ac.tuwien.sepm.assignment.groupphase.util.JDBCConnectionManager;
-import java.nio.charset.Charset;
-import java.sql.SQLException;
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.util.List;
-import org.dbunit.IDatabaseTester;
-import org.dbunit.JdbcDatabaseTester;
-import org.dbunit.dataset.DataSetException;
-import org.dbunit.dataset.IDataSet;
-import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
-import org.dbunit.operation.DatabaseOperation;
-import org.h2.tools.RunScript;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-public class EmployeePersistenceTest {
-
-    private static final String JDBC_DRIVER = org.h2.Driver.class.getName();
-    private static final String JDBC_URL = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1";
-    private static final String USER = "";
-    private static final String PASSWORD = "";
-
-    private EmployeeDAO employeePersistence;
-
-    public EmployeePersistenceTest() throws PersistenceException {
-        employeePersistence = new EmployeeDatabaseDao(new JDBCConnectionManager(JDBC_URL));
-    }
-
-    @BeforeClass
-    public static void createSchema() throws SQLException {
-        RunScript.execute(
-                JDBC_URL,
-                USER,
-                PASSWORD,
-                "classpath:sql/database.sql",
-                Charset.forName("UTF8"),
-                false);
-    }
-
-    @Before
-    public void importDataSet() throws Exception {
-        IDataSet dataSet = readDataSet();
-        cleanlyInsert(dataSet);
-    }
-
-    private IDataSet readDataSet() throws DataSetException {
-        return new FlatXmlDataSetBuilder()
-                .build(
-                        getClass()
-                                .getClassLoader()
-                                .getResourceAsStream("employeeServiceTestData.xml"));
-    }
-
-    private void cleanlyInsert(IDataSet dataSet) throws Exception {
-        IDatabaseTester databaseTester =
-                new JdbcDatabaseTester(JDBC_DRIVER, JDBC_URL, USER, PASSWORD);
-
-        databaseTester.setSetUpOperation(DatabaseOperation.CLEAN_INSERT);
-        databaseTester.setDataSet(dataSet);
-        databaseTester.onSetup();
-    }
-
-    @Test
-    public void testListEmployees() {
-
-        try {
-            List<Employee> employees = employeePersistence.list();
-
-            Employee empOne =
-                    Employee.builder()
-                            .id(1)
-                            .name("Adam")
-                            .birthday(
-                                    LocalDate.parse(
-                                            "10.10.2010",
-                                            DateTimeFormatter.ofPattern("dd.MM.yyyy")))
-                            .educationLevel(EducationLevel.RS)
-                            .isDriver(true)
-                            .isPilot(false)
-                            .build();
-
-            Employee empTwo =
-                    Employee.builder()
-                            .id(2)
-                            .name("Max")
-                            .birthday(
-                                    LocalDate.parse(
-                                            "11.11.1990",
-                                            DateTimeFormatter.ofPattern("dd.MM.yyyy")))
-                            .educationLevel(EducationLevel.NFS)
-                            .isDriver(false)
-                            .isPilot(false)
-                            .build();
-
-            Employee empThree =
-                    Employee.builder()
-                            .id(3)
-                            .name("Lisa")
-                            .birthday(
-                                    LocalDate.parse(
-                                            "16.10.1999",
-                                            DateTimeFormatter.ofPattern("dd.MM.yyyy")))
-                            .educationLevel(EducationLevel.NKI)
-                            .isDriver(true)
-                            .isPilot(false)
-                            .build();
-
-            Assert.assertTrue(employees.contains(empOne));
-            Assert.assertTrue(employees.contains(empTwo));
-            Assert.assertTrue(employees.contains(empThree));
-            Assert.assertEquals(3, employees.size());
-
-        } catch (PersistenceException e) {
-            fail();
-        }
-    }
-
-    @Test
-    public void testEmployeeListNoElement() {
-
-        try {
-            List<Employee> employees = employeePersistence.list();
-
-            Employee empOne =
-                    Employee.builder()
-                            .id(10)
-                            .name("Adam")
-                            .birthday(
-                                    LocalDate.parse(
-                                            "10.10.2010",
-                                            DateTimeFormatter.ofPattern("dd.MM.yyyy")))
-                            .educationLevel(EducationLevel.RS)
-                            .isDriver(true)
-                            .isPilot(false)
-                            .build();
-
-            Assert.assertFalse(employees.contains(empOne));
-
-        } catch (PersistenceException e) {
-            fail();
-        }
-    }
-}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeeServiceTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeeServiceTest.java
deleted file mode 100644
index 47328b3..0000000
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/employee/EmployeeServiceTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package at.ac.tuwien.sepm.assignment.groupphase.employee;
-
-import static junit.framework.TestCase.fail;
-import static org.hamcrest.CoreMatchers.is;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.EmployeeDAO;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.EmployeeDatabaseDao;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Employee.EducationLevel;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.EmployeeService;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.EmployeeServiceImpl;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidEmployeeException;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.ServiceException;
-import java.time.LocalDate;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class EmployeeServiceTest {
-
-    private final EmployeeDAO employeePersistence = mock(EmployeeDatabaseDao.class);
-    private final EmployeeService employeeService = new EmployeeServiceImpl(employeePersistence);
-
-    public EmployeeServiceTest() throws PersistenceException {
-        when(employeePersistence.add(any())).thenReturn(1L);
-    }
-
-    @Test
-    public void testAddValidEmployee() {
-
-        Employee employee =
-                Employee.builder()
-                        .name("Testperson")
-                        .birthday(LocalDate.MIN)
-                        .educationLevel(EducationLevel.NA)
-                        .isDriver(true)
-                        .isPilot(false)
-                        .build();
-
-        try {
-            Assert.assertThat(employeeService.add(employee), is(1L));
-        } catch (InvalidEmployeeException | ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidEmployeeException.class)
-    public void testAddInvalidEmployee() throws InvalidEmployeeException {
-
-        Employee employee =
-                Employee.builder()
-                        .name("")
-                        .birthday(LocalDate.MIN)
-                        .educationLevel(EducationLevel.NA)
-                        .isDriver(true)
-                        .isPilot(false)
-                        .build();
-
-        try {
-            employeeService.add(employee);
-        } catch (ServiceException e) {
-            fail();
-        }
-    }
-}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationPersistenceTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationPersistenceTest.java
deleted file mode 100644
index be612d0..0000000
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationPersistenceTest.java
+++ /dev/null
@@ -1,109 +0,0 @@
-package at.ac.tuwien.sepm.assignment.groupphase.operation;
-
-public class OperationPersistenceTest {
-
-    /*private final OperationDAO operationDAO =
-            new DBOperationDAO(new JDBCConnectionManager("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1"));
-
-    @BeforeClass
-    public static void createSchema() throws SQLException {
-        RunScript.execute(
-                "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
-                "",
-                "",
-                "classpath:sql/database.sql",
-                Charset.forName("UTF8"),
-                false);
-    }
-
-    @Test
-    public void addOperationTest() {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .status(Vehicle.Status.FREI_FUNK)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of(vehicle))
-                        .build();
-        try {
-            operationDAO.add(operation);
-        } catch (PersistenceException e) {
-            fail();
-        }
-    }
-
-    /*@Test(expected = PersistenceException.class)
-    public void addFaultyOperationTest() throws PersistenceException {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .status(Vehicle.Status.FREI_FUNK)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of(vehicle))
-                        .build();
-        operationDAO.add(operation);
-    }*/
-    /*
-
-    @Test(expected = PersistenceException.class)
-    public void addFaultyOperation1Test() throws PersistenceException {
-        operationDAO.add(null);
-    }
-
-    @Test(expected = PersistenceException.class)
-    public void addFaultyOperation2Test() throws PersistenceException {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .status(Vehicle.Status.FREI_FUNK)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination(
-                                "Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien Wiednerstraße 888, 1010 Wien ")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of(vehicle))
-                        .build();
-        operationDAO.add(operation);
-    }
-
-    @Test(expected = PersistenceException.class)
-    public void addConnectionTest() throws PersistenceException {
-        operationDAO.connectVehicleToOperation(-1, 0);
-    }
-
-    // TODO: ADD CONNECTION TESTS
-    // KOMMT ID ZURÜCK?*/
-}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationServiceComponentTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationServiceComponentTest.java
deleted file mode 100644
index 286ee07..0000000
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationServiceComponentTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package at.ac.tuwien.sepm.assignment.groupphase.operation;
-
-public class OperationServiceComponentTest {
-
-    /*private final OperationDAO operationDAO =
-            new DBOperationDAO(new JDBCConnectionManager("jdbc:h2:mem:test;DB_CLOSE_DELAY=-1"));
-    private final OperationService operationService = new OperationServiceImpl(operationDAO);
-
-    @Test
-    public void addOperationTest() {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .status(Vehicle.Status.FREI_FUNK)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of(vehicle))
-                        .build();
-        try {
-            // TODO: OPERATION DOES NOT WORK
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (InvalidOperationException | ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperationTest() throws InvalidOperationException {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .status(Vehicle.Status.FREI_FUNK)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-        Vehicle vehicle1 =
-                Vehicle.builder()
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of(vehicle, vehicle1))
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperation2Test() throws InvalidOperationException {
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of())
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperation3Test() throws InvalidOperationException {
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of())
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperation4Test() throws InvalidOperationException {
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("")
-                        .created(Instant.now())
-                        .destination("Römergasse 7, 2500 Baden")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of())
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            e.printStackTrace();
-        }
-    }*/
-}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationServiceUnitTest.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationServiceUnitTest.java
deleted file mode 100644
index fc10553..0000000
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/operation/OperationServiceUnitTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-package at.ac.tuwien.sepm.assignment.groupphase.operation;
-
-import static junit.framework.TestCase.fail;
-import static org.hamcrest.CoreMatchers.is;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.OperationDAO;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation.Severity;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Operation.Status;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.ConstructionType;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle.VehicleType;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.OperationService;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.OperationServiceImpl;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidOperationException;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.ServiceException;
-import java.time.Instant;
-import java.util.List;
-import org.junit.Assert;
-import org.junit.Test;
-
-public class OperationServiceUnitTest {
-    private final OperationDAO operationDAO = mock(OperationDAO.class);
-    private final OperationService operationService = new OperationServiceImpl(operationDAO);
-
-    @Test
-    public void addOperationTest() {
-        try {
-            when(operationDAO.add(any())).thenReturn(1L);
-        } catch (PersistenceException e) {
-            fail();
-        }
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .status(Vehicle.Status.FREI_FUNK)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of(vehicle))
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (InvalidOperationException | ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperationTest() throws InvalidOperationException {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .status(Vehicle.Status.FREI_FUNK)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-        Vehicle vehicle1 =
-                Vehicle.builder()
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .constructionType(ConstructionType.HOCHDACH)
-                        .name("BKTW_123")
-                        .hasNef(true)
-                        .type(VehicleType.BKTW)
-                        .build();
-
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of(vehicle, vehicle1))
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperation2Test() throws InvalidOperationException {
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("Wiedner Hauptstraße 35, Wien")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of())
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperation3Test() throws InvalidOperationException {
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("ALP-95E7")
-                        .created(Instant.now())
-                        .destination("")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of())
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Test(expected = InvalidOperationException.class)
-    public void addFaultyOperation4Test() throws InvalidOperationException {
-        Operation operation =
-                Operation.builder()
-                        .status(Status.ACTIVE)
-                        .opCode("")
-                        .created(Instant.now())
-                        .destination("Römergasse 7, 2500 Baden")
-                        .additionalInfo("HTU Wien")
-                        .severity(Severity.B)
-                        .vehicles(List.of())
-                        .build();
-        try {
-            Assert.assertThat(operationService.add(operation), is(1L));
-        } catch (ServiceException e) {
-            e.printStackTrace();
-        }
-    }
-}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/util/Helper.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/util/Helper.java
index b808206..618b06f 100644
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/util/Helper.java
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/util/Helper.java
@@ -6,6 +6,12 @@ import java.util.List;
 import javafx.stage.Modality;
 import javafx.stage.Stage;
 import javafx.stage.Window;
+import org.dbunit.database.IDatabaseConnection;
+import org.dbunit.dataset.DataSetException;
+import org.dbunit.dataset.IDataSet;
+import org.dbunit.dataset.ITable;
+import org.dbunit.dataset.filter.DefaultColumnFilter;
+import org.dbunit.util.fileloader.FlatXmlDataFileLoader;
 import org.testfx.api.FxRobotContext;
 
 public class Helper {
@@ -25,4 +31,39 @@ public class Helper {
                         .findFirst()
                         .orElse(null);
     }
+
+    public static ITable getActualFilteredTableData(
+            IDatabaseConnection connection, String tableName, String[] excludedColumns)
+            throws Exception {
+        IDataSet actualDataSet = connection.createDataSet();
+        ITable actualTable = actualDataSet.getTable(tableName);
+        return getFilteredTableData(actualTable, excludedColumns);
+    }
+
+    public static ITable getExpectedFilteredTableData(
+            String tableName, String[] excludedColumns, String expectedXmlDataFileName)
+            throws Exception {
+        IDataSet dataSet = loadDataSet(expectedXmlDataFileName);
+        ITable table = dataSet.getTable(tableName);
+        return getFilteredTableData(table, excludedColumns);
+    }
+
+    public static ITable getActualFilteredQueryTableData(
+            IDatabaseConnection connection,
+            String resultTableName,
+            String sql,
+            String[] excludedColumns)
+            throws Exception {
+        ITable queryData = connection.createQueryTable(resultTableName, sql);
+        return getFilteredTableData(queryData, excludedColumns);
+    }
+
+    private static ITable getFilteredTableData(ITable tableData, String[] excludedColumns)
+            throws DataSetException {
+        return DefaultColumnFilter.excludedColumnsTable(tableData, excludedColumns);
+    }
+
+    private static IDataSet loadDataSet(String fileName) {
+        return new FlatXmlDataFileLoader().load("/" + fileName);
+    }
 }
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/util/JdbcTestCase.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/util/JdbcTestCase.java
new file mode 100644
index 0000000..c509a1f
--- /dev/null
+++ b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/util/JdbcTestCase.java
@@ -0,0 +1,160 @@
+package at.ac.tuwien.sepm.assignment.groupphase.util;
+
+import static org.dbunit.Assertion.assertEquals;
+
+import java.io.InputStream;
+import java.lang.invoke.MethodHandles;
+import java.sql.SQLException;
+import java.sql.Types;
+import java.util.Collection;
+import java.util.Collections;
+import org.dbunit.DefaultDatabaseTester;
+import org.dbunit.IDatabaseTester;
+import org.dbunit.IOperationListener;
+import org.dbunit.database.DatabaseConfig;
+import org.dbunit.database.DatabaseConnection;
+import org.dbunit.database.IDatabaseConnection;
+import org.dbunit.dataset.DataSetException;
+import org.dbunit.dataset.IDataSet;
+import org.dbunit.dataset.datatype.DataType;
+import org.dbunit.dataset.datatype.DataTypeException;
+import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
+import org.dbunit.ext.postgresql.PostgresqlDataTypeFactory;
+import org.dbunit.operation.DatabaseOperation;
+import org.junit.After;
+import org.junit.Before;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+@Component
+public abstract class JdbcTestCase {
+
+    private static final Logger LOG = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+    private static final String JDBC_URL =
+            "jdbc:h2:mem:test;INIT=RUNSCRIPT FROM 'classpath:sql/database.sql'";
+
+    private IDatabaseTester dbTester;
+    private IDatabaseConnection connection;
+    private IOperationListener operationListener;
+    private JDBCConnectionManager jdbcConnectionManager;
+
+    protected JdbcTestCase() {
+        jdbcConnectionManager = new JDBCConnectionManager(JDBC_URL);
+    }
+
+    protected abstract IDataSet getDataSet() throws Exception;
+
+    protected IDataSet getDataSet(String xmlname) throws DataSetException {
+        InputStream res = getClass().getClassLoader().getResourceAsStream(xmlname);
+        FlatXmlDataSetBuilder builder = new FlatXmlDataSetBuilder();
+        builder.setColumnSensing(true);
+        return builder.build(res);
+    }
+
+    protected JDBCConnectionManager getJdbcConnectionManager() {
+        return jdbcConnectionManager;
+    }
+
+    protected IDatabaseConnection getConnection() throws Exception {
+        if (connection == null)
+            connection = new DatabaseConnection(jdbcConnectionManager.getConnection(), null, true);
+
+        return connection;
+    }
+
+    private IOperationListener getOperationListener() {
+        if (operationListener == null) {
+            operationListener =
+                    new IOperationListener() {
+                        @Override
+                        public void connectionRetrieved(IDatabaseConnection connection) {
+                            setUpDatabaseConfig(connection.getConfig());
+                        }
+
+                        @Override
+                        public void operationSetUpFinished(IDatabaseConnection connection) {
+                            LOG.debug("operationSetUpFinished(connection={}) - start", connection);
+                        }
+
+                        @Override
+                        public void operationTearDownFinished(IDatabaseConnection connection) {
+                            LOG.debug(
+                                    "operationTearDownFinished(connection={}) - start", connection);
+                            try {
+                                connection.close();
+                            } catch (SQLException e) {
+                                LOG.error("Failed to close connection:" + e);
+                                e.printStackTrace();
+                            }
+                        }
+                    };
+        }
+
+        return operationListener;
+    }
+
+    // override DBUnit's enum handling
+    private void setUpDatabaseConfig(DatabaseConfig config) {
+        PostgresqlDataTypeFactory factory =
+                new PostgresqlDataTypeFactory() {
+                    @Override
+                    public boolean isEnumType(String sqlTypeName) {
+                        if (sqlTypeName.equalsIgnoreCase("enum")) return true;
+
+                        return super.isEnumType(sqlTypeName);
+                    }
+
+                    @Override
+                    public DataType createDataType(int sqlType, String sqlTypeName)
+                            throws DataTypeException {
+                        if (isEnumType(sqlTypeName)) {
+                            sqlType = Types.VARCHAR;
+                        }
+
+                        return super.createDataType(sqlType, sqlTypeName);
+                    }
+
+                    @Override
+                    public Collection getValidDbProducts() {
+                        return Collections.singletonList("H2");
+                    }
+                };
+
+        config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, factory);
+    }
+
+    protected void compareWith(String xmlname, String[] tables) throws Exception {
+        InputStream res = getClass().getClassLoader().getResourceAsStream(xmlname);
+        IDataSet actual = getConnection().createDataSet();
+        IDataSet expected = new FlatXmlDataSetBuilder().build(res);
+
+        for (String table : tables) {
+            assertEquals(actual.getTable(table), expected.getTable(table));
+        }
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        IDataSet dataSet = getDataSet();
+
+        dbTester = new DefaultDatabaseTester(getConnection());
+        getOperationListener().connectionRetrieved(getConnection());
+
+        dbTester.setSetUpOperation(DatabaseOperation.CLEAN_INSERT);
+        dbTester.setTearDownOperation(DatabaseOperation.REFRESH);
+        dbTester.setDataSet(dataSet);
+        dbTester.setOperationListener(getOperationListener());
+        dbTester.onSetup();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        try {
+            dbTester.onTearDown();
+            getConnection().close();
+        } finally {
+            dbTester = null;
+        }
+    }
+}
diff --git a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/CarAddTestService.java b/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/CarAddTestService.java
deleted file mode 100644
index de7a26a..0000000
--- a/src/test/java/at/ac/tuwien/sepm/assignment/groupphase/vehicle/CarAddTestService.java
+++ /dev/null
@@ -1,283 +0,0 @@
-package at.ac.tuwien.sepm.assignment.groupphase.vehicle;
-
-import static junit.framework.TestCase.fail;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.VehicleDAO;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dao.VehicleDatabaseDao;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.dto.Vehicle;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.VehicleService;
-import at.ac.tuwien.sepm.assignment.groupphase.einsatzverwaltung.service.VehicleServiceImpl;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.InvalidVehicleException;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.PersistenceException;
-import at.ac.tuwien.sepm.assignment.groupphase.exception.ServiceException;
-import org.junit.Test;
-
-public class CarAddTestService {
-    private final VehicleDAO vehicleP = mock(VehicleDatabaseDao.class);
-    private final VehicleService vehicleService = new VehicleServiceImpl(vehicleP);
-
-    public CarAddTestService() throws PersistenceException {
-        when(vehicleP.add(any())).thenReturn(1L);
-    }
-
-    @Test
-    public void testValidVehicleH() {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.HOCHDACH)
-                        .type(Vehicle.VehicleType.RTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.HOCHDACH)
-                        .type(Vehicle.VehicleType.KTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.HOCHDACH)
-                        .type(Vehicle.VehicleType.KTW_B)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.HOCHDACH)
-                        .type(Vehicle.VehicleType.BKTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test
-    public void testValidVehicleM() {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.MITTELHOCHDACH)
-                        .type(Vehicle.VehicleType.KTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.MITTELHOCHDACH)
-                        .type(Vehicle.VehicleType.KTW_B)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.MITTELHOCHDACH)
-                        .type(Vehicle.VehicleType.BKTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test
-    public void testValidVehicleN() {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.NORMAL)
-                        .type(Vehicle.VehicleType.BKTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.NORMAL)
-                        .type(Vehicle.VehicleType.NEF)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.NORMAL)
-                        .type(Vehicle.VehicleType.NAH)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (InvalidVehicleException | ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidVehicleException.class)
-    public void testInvalidVehicleH() throws InvalidVehicleException {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.HOCHDACH)
-                        .type(Vehicle.VehicleType.NEF)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.HOCHDACH)
-                        .type(Vehicle.VehicleType.NAH)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidVehicleException.class)
-    public void testInvalidVehicleM() throws InvalidVehicleException {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.MITTELHOCHDACH)
-                        .type(Vehicle.VehicleType.NEF)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.MITTELHOCHDACH)
-                        .type(Vehicle.VehicleType.NAH)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.MITTELHOCHDACH)
-                        .type(Vehicle.VehicleType.RTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-    }
-
-    @Test(expected = InvalidVehicleException.class)
-    public void testInvalidVehicleN() throws InvalidVehicleException {
-        Vehicle vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.NORMAL)
-                        .type(Vehicle.VehicleType.RTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.NORMAL)
-                        .type(Vehicle.VehicleType.KTW_B)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-        vehicle =
-                Vehicle.builder()
-                        .constructionType(Vehicle.ConstructionType.NORMAL)
-                        .type(Vehicle.VehicleType.KTW)
-                        .hasNef(true)
-                        .status(Vehicle.Status.ABGEMELDET)
-                        .name("")
-                        .build();
-        try {
-            vehicleService.add(vehicle);
-        } catch (ServiceException e) {
-            fail();
-        }
-    }
-}