implemented more unit tests

src/test/java/cz/muni/fi/pv168/project/db/task/TaskDaoTest.java

 package cz.muni.fi.pv168.project.db.task;
 
+import cz.muni.fi.pv168.project.data.category.Category;
 import cz.muni.fi.pv168.project.data.task.Task;
 import cz.muni.fi.pv168.project.data.task.TaskStatus;
+import cz.muni.fi.pv168.project.db.DataAccessException;
 import cz.muni.fi.pv168.project.db.category.CategoryDao;
 import cz.muni.fi.pv168.project.db.category.CategoryManager;
 import cz.muni.fi.pv168.project.db.categorytime.CategoryTimeDao;
 import cz.muni.fi.pv168.project.db.dependency.DependencyDao;
+import cz.muni.fi.pv168.project.db.dependency.DependencyManager;
 import cz.muni.fi.pv168.project.db.subtask.SubTaskDao;
 import cz.muni.fi.pv168.project.db.taskcategory.TaskCategoryDao;
 import cz.muni.fi.pv168.project.db.taskcategory.TaskCategoryManager;
@@ -15,12 +18,14 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
+import java.awt.Color;
 import java.sql.SQLException;
 import java.time.LocalDate;
 import java.util.Arrays;
 import java.util.LinkedList;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.Mockito.mock;
 
 class TaskDaoTest {
@@ -31,6 +36,8 @@ class TaskDaoTest {
     private TaskCategoryDao taskCategoryDao;
     private CategoryManager categoryManager;
     private TaskCategoryManager taskCategoryManager;
+    private DependencyManager dependencyManager;
+    private DependencyDao dependencyDao;
 
     @BeforeAll
     static void initTestDataSource() throws SQLException {
@@ -45,14 +52,17 @@ class TaskDaoTest {
         taskCategoryDao = new TaskCategoryDao(dataSource);
         taskDao = new TaskDao(dataSource, mock(SubTaskDao.class), mock(DependencyDao.class),
                 taskCategoryDao, categoryDao, mock(CategoryTimeDao.class));
+        dependencyDao = new DependencyDao(dataSource);
 
         taskManager = new TaskManager(dataSource);
         categoryManager = new CategoryManager(dataSource);
         taskCategoryManager = new TaskCategoryManager(dataSource);
+        dependencyManager = new DependencyManager(dataSource);
     }
 
     @AfterEach
     void cleanUp() {
+        dependencyManager.dropTable();
         taskCategoryManager.dropTable();
         categoryManager.dropTable();
         taskManager.dropTable();
@@ -71,6 +81,40 @@ class TaskDaoTest {
         assertThat(taskDao.getAll()).isEqualTo(tasks);
     }
 
+    @Test
+    void add_NewTasksWithCategoriesWithoutDependencies_TasksAdded() {
+        var tasks = new LinkedList<Task>(Arrays.asList(
+                Task.builder("A", 10L, LocalDate.EPOCH).build(),
+                Task.builder("B", 10L, LocalDate.EPOCH).build()
+        ));
+        for (var task :
+                tasks) {
+            taskDao.add(task);
+            setupCategories(task.getId());
+        }
+        assertThat(taskDao.getAll()).isEqualTo(tasks);
+    }
+
+    @Test
+    void add_NewTasksWithCategoriesAndDependencies_TasksAdded() {
+        var tasks = new LinkedList<Task>(Arrays.asList(
+                Task.builder("A", 10L, LocalDate.EPOCH).build(),
+                Task.builder("B", 10L, LocalDate.EPOCH).build()
+        ));
+        var dependencyTasks = new LinkedList<Task>();
+        for (var task :
+                tasks) {
+            taskDao.add(task);
+            setupCategories(task.getId());
+            dependencyTasks.addAll(setupDependencies(task.getId()));
+        }
+        var allTasks = new LinkedList<Task>();
+        allTasks.addAll(tasks);
+        allTasks.addAll(dependencyTasks);
+        assertThat(taskDao.getAll()).asList().contains(allTasks.toArray());
+        assertThat(allTasks.size()).isEqualTo(taskDao.getAll().size());
+    }
+
     @Test
     void getAll_ExistingTasksWithoutCategoryAndDependencies_AllTaskReturned() {
         var tasks = setupTasks();
@@ -92,6 +136,22 @@ class TaskDaoTest {
         assertThat(taskDao.getAll()).isEqualTo(tasks);
     }
 
+    @Test
+    void update_ChangedExistingTasksCategory_TaskUpdated() {
+        var tasks = setupTasks();
+        setupCategories(tasks.get(0).getId());
+        taskDao.update(tasks.get(0));
+        assertThat(taskDao.getAll()).isEqualTo(tasks);
+    }
+
+    @Test
+    void update_ChangedExistingTasksDependency_TaskUpdated() {
+        var tasks = setupTasks();
+        dependencyDao.addAssociationFor(tasks.get(0).getId(), tasks.get(1).getId());
+        taskDao.update(tasks.get(0));
+        assertThat(taskDao.getAll()).isEqualTo(tasks);
+    }
+
     @Test
     void delete_ExistingTask_TaskDeleted() {
         var tasks = setupTasks();
@@ -100,12 +160,19 @@ class TaskDaoTest {
         assertThat(taskDao.getAll()).isEqualTo(tasks);
     }
 
+    @Test
+    void delete_ExistingTaskWithDependencyAssociation_ExceptionThrown() {
+        var tasks = setupTasks();
+        dependencyDao.addAssociationFor(tasks.get(1).getId(), tasks.get(0).getId());
+        assertThrows(DataAccessException.class, () -> taskDao.delete(tasks.get(0)));
+    }
+
     private LinkedList<Task> setupTasks() {
         var tasks = new LinkedList<Task>(Arrays.asList(
-                Task.builder("A", 10L, LocalDate.EPOCH).build(),
-                Task.builder("B", 10L, LocalDate.EPOCH).build(),
-                Task.builder("C", 10L, LocalDate.EPOCH).build(),
-                Task.builder("D", 10L, LocalDate.EPOCH).build()
+                Task.builder("A Task", 10L, LocalDate.EPOCH).build(),
+                Task.builder("B Task", 10L, LocalDate.EPOCH).build(),
+                Task.builder("C Task", 10L, LocalDate.EPOCH).build(),
+                Task.builder("D Task", 10L, LocalDate.EPOCH).build()
         ));
         for (var task :
                 tasks) {
@@ -113,4 +180,30 @@ class TaskDaoTest {
         }
         return tasks;
     }
+
+    private void setupCategories(long taskId) {
+        var categories = new LinkedList<Category>(Arrays.asList(
+                new Category("A Category", Color.black),
+                new Category("B Category", Color.blue)
+        ));
+        for (var category :
+                categories) {
+            categoryDao.add(category);
+            taskCategoryDao.addAssociationFor(taskId, category.getId());
+        }
+    }
+
+    private LinkedList<Task> setupDependencies(long taskId) {
+        var tasks = new LinkedList<Task>(Arrays.asList(
+                Task.builder("A Dependency", 10L, LocalDate.EPOCH).build(),
+                Task.builder("B Dependency", 10L, LocalDate.EPOCH).build()
+        ));
+        for (var task :
+                tasks) {
+            taskDao.add(task);
+            dependencyDao.addAssociationFor(task.getId(), taskId);
+        }
+        return tasks;
+    }
+
 }
\ No newline at end of file