diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..e4e8d93 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,3 @@ +# Верхний регистр для констант +[*.{java,scala,js,py}] +upper_case_constants = true diff --git a/src/ru/alexgur/kanban/exceptions/ManagerAddTaskException.java b/src/ru/alexgur/kanban/exceptions/ManagerAddTaskException.java new file mode 100644 index 0000000..a7b9e90 --- /dev/null +++ b/src/ru/alexgur/kanban/exceptions/ManagerAddTaskException.java @@ -0,0 +1,7 @@ +package ru.alexgur.kanban.exceptions; + +public class ManagerAddTaskException extends RuntimeException { + public ManagerAddTaskException(final String message) { + super(message); + } +} diff --git a/src/ru/alexgur/kanban/model/Epic.java b/src/ru/alexgur/kanban/model/Epic.java index 4882d9b..e9eaa1f 100644 --- a/src/ru/alexgur/kanban/model/Epic.java +++ b/src/ru/alexgur/kanban/model/Epic.java @@ -4,10 +4,12 @@ import ru.alexgur.kanban.service.TaskType; +import java.time.LocalDateTime; import java.util.ArrayList; public class Epic extends Task { private List subTasksIds = new ArrayList<>(); + private LocalDateTime endTime; // дата и время завершения всех задач public Epic() { super(); @@ -21,6 +23,14 @@ public List getSubTasksIds() { return subTasksIds; } + public LocalDateTime getEndTime() { + return endTime; + } + + public void setEndTime(LocalDateTime endTime) { + this.endTime = endTime; + } + public void setSubTasksIds(List subTasksIds) { List subTasksIdsFiltered = new ArrayList<>(); for (Integer id : subTasksIds) { @@ -46,8 +56,24 @@ public TaskType getType() { @Override public String toString() { - return "Task [id=" + id + ", name=" + getName() + ", text=" + getText() + ", status=" + getStatus() - + ", subTasksIds=" + subTasksIds + "]"; - } + String start = ""; + if (getStartTime() != null) { + start = getStartTime().format(dateTimeFormatter); + } + + long durationStr = 0; + if (getDuration().isZero()) { + durationStr = getDuration().toMinutes(); + } + return "Task [id=" + id + + ", type=" + getType() + + ", name=" + getName() + + ", text=" + getText() + + ", status=" + getStatus() + + ", startTime=" + start + + ", duration=" + durationStr + + ", subTasksIds=" + subTasksIds + + "]"; + } } diff --git a/src/ru/alexgur/kanban/model/SubTask.java b/src/ru/alexgur/kanban/model/SubTask.java index 5daf029..4ad1536 100644 --- a/src/ru/alexgur/kanban/model/SubTask.java +++ b/src/ru/alexgur/kanban/model/SubTask.java @@ -31,7 +31,24 @@ public TaskType getType() { @Override public String toString() { - return "Task [id=" + id + ", name=" + getName() + ", text=" + getText() + ", status=" + getStatus() - + ", epycId=" + epicId + "]"; + String start = ""; + if (getStartTime() != null) { + start = getStartTime().format(dateTimeFormatter); + } + + long durationStr = 0; + if (getDuration().isZero()) { + durationStr = getDuration().toMinutes(); + } + + return "Task [id=" + id + + ", type=" + getType() + + ", name=" + getName() + + ", text=" + getText() + + ", status=" + getStatus() + + ", startTime=" + start + + ", duration=" + durationStr + + ", epycId=" + epicId + + "]"; } } \ No newline at end of file diff --git a/src/ru/alexgur/kanban/model/Task.java b/src/ru/alexgur/kanban/model/Task.java index e9ce22b..f6bfe2d 100644 --- a/src/ru/alexgur/kanban/model/Task.java +++ b/src/ru/alexgur/kanban/model/Task.java @@ -1,5 +1,9 @@ package ru.alexgur.kanban.model; +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; + import ru.alexgur.kanban.service.Status; import ru.alexgur.kanban.service.TaskType; @@ -9,6 +13,34 @@ public class Task { private String name; // название задачи private String text; // текст задачи private Status status; // статус задачи + private Duration duration = Duration.ZERO; // продолжительность задачи в минутах + private LocalDateTime startTime; // дата и время старта выполнения задачи + public static DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + public LocalDateTime getStartTime() { + return startTime; + } + + public Task setStartTime(LocalDateTime startTime) { + this.startTime = startTime; + return this; + } + + public Duration getDuration() { + return duration; + } + + public LocalDateTime getEndTime() { + if (getStartTime() == null) { + return null; + } + return startTime.plus(duration); + } + + public Task setDuration(Duration duration) { + this.duration = duration; + return this; + } public Task() { this.status = Status.NEW; @@ -53,6 +85,10 @@ public String getText() { return text; } + public static int compareToStartTimeAsc(T a, T b) { + return a.getStartTime().isBefore(b.getStartTime()) ? -1 : 1; + } + public Task setText(String text) { this.text = text; return this; @@ -98,6 +134,23 @@ public boolean equals(Object obj) { @Override public String toString() { - return "Task [id=" + id + ", name=" + getName() + ", text=" + getText() + ", status=" + getStatus() + "]"; + String start = ""; + if (getStartTime() != null) { + start = getStartTime().format(dateTimeFormatter); + } + + long durationStr = 0; + if (getDuration().isZero()) { + durationStr = getDuration().toMinutes(); + } + + return "Task [id=" + id + + ", type=" + getType() + + ", name=" + getName() + + ", text=" + getText() + + ", status=" + getStatus() + + ", startTime=" + start + + ", duration=" + durationStr + + "]"; } } diff --git a/src/ru/alexgur/kanban/service/FileBackedTaskManager.java b/src/ru/alexgur/kanban/service/FileBackedTaskManager.java index a6610bb..c75469c 100644 --- a/src/ru/alexgur/kanban/service/FileBackedTaskManager.java +++ b/src/ru/alexgur/kanban/service/FileBackedTaskManager.java @@ -12,9 +12,13 @@ import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; +import java.time.Duration; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; public class FileBackedTaskManager extends InMemoryTaskManager { private File fileToSave; + private DateTimeFormatter dateTimeFormatter = Task.dateTimeFormatter; private String eol = "\n"; private String csvSplitter = ";"; @@ -142,6 +146,7 @@ public static FileBackedTaskManager loadFromFile(File file) { } taskManager.updateEpicsSubTasksIds(); + taskManager.updateEpicsDurationStartEndTime(); taskManager.setFile(file); return taskManager; } @@ -152,7 +157,7 @@ private void save() { } try (FileWriter fileWriter = new FileWriter(fileToSave)) { - String csvHeader = "id,type,name,status,description,epic"; + String csvHeader = "id,type,name,description,status,start,duration,epic"; fileWriter.write(csvHeader + eol); for (List target : List.of(getTasks(), getSubTasks(), getEpics())) { @@ -170,15 +175,30 @@ private String toString(T task) { if (task instanceof SubTask) { epicId = String.valueOf(((SubTask) task).getEpicId()); } + + String start = ""; + if (task.getStartTime() != null) { + start = task.getStartTime().format(dateTimeFormatter); + } + + long duration = 0; + if (task.getDuration().isZero()) { + duration = task.getDuration().toMinutes(); + } + return task.id + csvSplitter + task.getType() + csvSplitter + task.getName() + csvSplitter + + task.getText() + + csvSplitter + task.getStatus() + csvSplitter - + task.getText() + + start + + csvSplitter + + duration + csvSplitter + epicId + csvSplitter @@ -190,25 +210,36 @@ private Object fromString(String line) { int id = Integer.valueOf(args[0]); TaskType type = TaskType.valueOf(args[1]); - Status status = Status.valueOf(args[3]); String name = args[2]; - String text = args[4]; + String text = args[3]; + Status status = Status.valueOf(args[4]); + LocalDateTime startTime = LocalDateTime.parse(args[5], dateTimeFormatter); + int durationMinutes = Integer.valueOf(args[6]); switch (type) { case TASK: Task task = new Task(id); - task.setName(name).setText(text).setStatus(status); + task.setName(name) + .setText(text) + .setStatus(status) + .setStartTime(startTime) + .setDuration(Duration.ofMinutes(durationMinutes)); return task; case SUBTASK: - int epicId = Integer.valueOf(args[5]); + int epicId = Integer.valueOf(args[7]); SubTask subTask = new SubTask(id); - subTask.setName(name).setText(text).setStatus(status); - subTask.setEpicId(epicId); + subTask.setEpicId(epicId) + .setName(name) + .setText(text) + .setStatus(status) + .setStartTime(startTime) + .setDuration(Duration.ofMinutes(durationMinutes)); return subTask; case EPIC: Epic epic = new Epic(id); - epic.setName(name).setText(text); + epic.setName(name) + .setText(text); return epic; } return null; diff --git a/src/ru/alexgur/kanban/service/InMemoryHistoryManager.java b/src/ru/alexgur/kanban/service/InMemoryHistoryManager.java index 2f125cd..523ddb1 100644 --- a/src/ru/alexgur/kanban/service/InMemoryHistoryManager.java +++ b/src/ru/alexgur/kanban/service/InMemoryHistoryManager.java @@ -28,10 +28,8 @@ public void add(Task task) { @Override public List getHistory() { - List listTasks = new ArrayList<>(); - for (Node node : getTasks()) { - listTasks.add(node.getTask()); - } + List listTasks = getTasks().stream() + .map(x -> x.getTask()).toList(); return listTasks; } diff --git a/src/ru/alexgur/kanban/service/InMemoryTaskManager.java b/src/ru/alexgur/kanban/service/InMemoryTaskManager.java index 7366aa6..8d9b7bd 100644 --- a/src/ru/alexgur/kanban/service/InMemoryTaskManager.java +++ b/src/ru/alexgur/kanban/service/InMemoryTaskManager.java @@ -1,11 +1,16 @@ package ru.alexgur.kanban.service; import java.util.List; +import java.util.Objects; +import java.util.TreeSet; +import ru.alexgur.kanban.exceptions.ManagerAddTaskException; import ru.alexgur.kanban.model.Epic; import ru.alexgur.kanban.model.SubTask; import ru.alexgur.kanban.model.Task; +import java.time.Duration; +import java.time.LocalDateTime; import java.util.ArrayList; import java.util.HashMap; @@ -14,6 +19,7 @@ public class InMemoryTaskManager implements TaskManager { private HashMap subTasks = new HashMap<>(); private HashMap epics = new HashMap<>(); private HistoryManager history; + private TreeSet treeOfTasksAndSubTasks = new TreeSet<>(Task::compareToStartTimeAsc); public void setHistoryManager(HistoryManager manager) { history = manager; @@ -25,30 +31,47 @@ public HistoryManager getHistoryManager() { @Override public int addTask(Task task) { + if (isTaskCrossesSavedTasks(task)) { + throw new ManagerAddTaskException("Задача пересекается с другими по времени!"); + } tasks.put(task.id, task); + addTreeOfTasksAndSubTasks(task); return task.id; } @Override public int addSubTask(SubTask subtask) { + if (isTaskCrossesSavedTasks(subtask)) { + throw new ManagerAddTaskException("Подзадача пересекается с другими по времени!"); + } subTasks.put(subtask.id, subtask); updateEpicStatus(subtask.getEpicId()); + addTreeOfTasksAndSubTasks(subtask); return subtask.id; } @Override public int addEpic(Epic epic) { epics.put(epic.id, epic); + updateEpicStatus(epic.id); return epic.id; } @Override public void updateTask(Task task) { + if (isTaskCrossesSavedTasks(task)) { + throw new ManagerAddTaskException("Задача пересекается с другими по времени!"); + } + updateTreeOfTasksAndSubTasks(task); tasks.put(task.id, task); } @Override public void updateSubTask(SubTask subtask) { + if (isTaskCrossesSavedTasks(subtask)) { + throw new ManagerAddTaskException("Подзадача пересекается с другими по времени!"); + } + updateTreeOfTasksAndSubTasks(subtask); subTasks.put(subtask.id, subtask); updateEpicStatus(subtask.getEpicId()); } @@ -60,25 +83,29 @@ public void updateEpic(Epic epic) { @Override public void deleteTask(int id) { + removeTreeOfTasksAndSubTasks(getTaskImpl(id)); clearTask(id); } @Override public void deleteTasks() { + deleteTypeFromTreeOfTasksAndSubTasks(TaskType.TASK); tasks.clear(); } @Override public void deleteSubTask(int id) { + removeTreeOfTasksAndSubTasks(getSubTaskImpl(id)); clearSubTask(id); } @Override public void deleteSubTasks() { - for (Epic epic : epics.values()) { + epics.values().forEach(epic -> { epic.deleteSubTasks(); updateEpicStatus(epic.getId()); - } + }); + deleteTypeFromTreeOfTasksAndSubTasks(TaskType.SUBTASK); subTasks.clear(); } @@ -89,7 +116,7 @@ public List getEpicSubTasks(int epicId) { @Override public Task getTask(int id) { - Task task = tasks.get(id); + Task task = getTaskImpl(id); addToHistoryImpl(task); return task; } @@ -113,7 +140,7 @@ public List getSubTasks() { @Override public Epic getEpic(int id) { - Epic epic = epics.get(id); + Epic epic = getEpicImpl(id); addToHistoryImpl(epic); return epic; } @@ -132,16 +159,25 @@ public void deleteEpic(int id) { public void deleteEpics() { epics.clear(); subTasks.clear(); + deleteTypeFromTreeOfTasksAndSubTasks(TaskType.SUBTASK); + } + + @Override + public List getPrioritizedTasks() { + return new ArrayList<>(treeOfTasksAndSubTasks); } public void updateEpicsSubTasksIds() { - for (Epic epic : epics.values()) { - List subTasksIds = new ArrayList<>(); - for (SubTask subTask : getEpicSubTasksImpl(epic.getId())) { - subTasksIds.add(subTask.getId()); - } - epic.setSubTasksIds(subTasksIds); - } + epics.values().forEach(epic -> { + epic.setSubTasksIds( + getEpicSubTasksImpl(epic.getId()).stream() + .map(x -> x.getId()).toList()); + setEpicDurationStartEndTime(epic); + }); + } + + public void updateEpicsDurationStartEndTime() { + epics.values().forEach(x -> setEpicDurationStartEndTime(x)); } private List getEpicsImpl() { @@ -149,13 +185,9 @@ private List getEpicsImpl() { } private List getEpicSubTasksImpl(int epicId) { - List epicSubTasks = new ArrayList<>(); - - for (SubTask subtask : subTasks.values()) { - if (subtask.getEpicId() == epicId) { - epicSubTasks.add(subtask); - } - } + List epicSubTasks = subTasks.values().stream() + .filter(x -> x.getEpicId() == epicId) + .toList(); return epicSubTasks; } @@ -166,29 +198,59 @@ private void addToHistoryImpl(T task) { } } + private void setEpicDurationStartEndTime(Epic epic) { + if (epic == null) { + return; + } + + List subtasks = getEpicSubTasksImpl(epic.getId()); + Duration duration = subtasks.stream() + .map(x -> x.getDuration()) + .reduce(Duration.ZERO, (x, y) -> x.plus(y)); + + LocalDateTime startTime = subtasks.stream() + .map(x -> x.getStartTime()) + .filter(Objects::nonNull) + .min(LocalDateTime::compareTo) + .orElse(null); + + LocalDateTime endTime = subtasks.stream() + .map(x -> x.getEndTime()) + .filter(Objects::nonNull) + .max(LocalDateTime::compareTo) + .orElse(null); + + if (!duration.isZero()) { + epic.setDuration(duration); + } + if (startTime != null) { + epic.setStartTime(startTime); + epic.setEndTime(endTime); + } + } + + private Epic getEpicImpl(int id) { + return epics.get(id); + } + private void updateEpicStatus(int epicId) { - Epic epic = getEpic(epicId); + Epic epic = getEpicImpl(epicId); if (epic == null) { return; } - updateEpicStatus(epic, getEpicSubTasks(epicId)); + updateEpicStatus(epic, getEpicSubTasksImpl(epicId)); updateEpic(epic); + setEpicDurationStartEndTime(epic); } private void updateEpicStatus(Epic epic, List subTasks) { - boolean isNew = true; - boolean isDone = true; + boolean isNew = subTasks.stream().allMatch( + task -> task.getStatus() == Status.NEW); - for (SubTask t : subTasks) { - if (t.getStatus() != Status.NEW) { - isNew = false; - } - if (t.getStatus() != Status.DONE) { - isDone = false; - } - } + boolean isDone = subTasks.stream().allMatch( + task -> task.getStatus() == Status.DONE); Status newStatus; if (isNew) { @@ -206,13 +268,15 @@ private void updateEpicStatus(Epic epic, List subTasks) { private void clearTask(int id) { if (tasks.containsKey(id)) { - tasks.remove(id); + Task removedTask = tasks.remove(id); + removeTreeOfTasksAndSubTasks(removedTask); } } private void clearSubTask(int id) { if (subTasks.containsKey(id)) { SubTask sub = subTasks.remove(id); + removeTreeOfTasksAndSubTasks(sub); int epicId = sub.getEpicId(); if (epics.containsKey(epicId)) { @@ -225,9 +289,67 @@ private void clearSubTask(int id) { private void clearEpic(int id) { Epic epic = epics.remove(id); - for (Integer sid : epic.getSubTasksIds()) { - clearSubTask(sid); + epic.getSubTasksIds().forEach(sid -> clearSubTask(sid)); + } + + private Task getTaskImpl(int id) { + Task task = tasks.get(id); + return task; + } + + private SubTask getSubTaskImpl(int id) { + SubTask subTask = subTasks.get(id); + return subTask; + } + + private void addTreeOfTasksAndSubTasks(Task task) { + if (task != null && + !task.getDuration().isZero() && + task.getStartTime() != null && + task.getEndTime() != null) { + treeOfTasksAndSubTasks.add(task); } } + private void removeTreeOfTasksAndSubTasks(T task) { + treeOfTasksAndSubTasks.remove(task); + } + + private void updateTreeOfTasksAndSubTasks(T task) { + if (task == null) { + return; + } + Task el = (task.getType() == TaskType.TASK ? tasks : subTasks).get(task.id); + removeTreeOfTasksAndSubTasks(el); + addTreeOfTasksAndSubTasks(task); + } + + private List deleteTypeFromTreeOfTasksAndSubTasks(TaskType type) { + return treeOfTasksAndSubTasks.stream().filter(x -> x.getType() != type).toList(); + } + + public boolean isTaskCrossesSavedTasks(T task) { + final LocalDateTime end = task.getEndTime(); + final LocalDateTime start = task.getStartTime(); + + if (end == null || start == null) { + return false; + } + + return treeOfTasksAndSubTasks.stream() + .anyMatch(x -> { + LocalDateTime thisStart = x.getStartTime(); + LocalDateTime thisEnd = x.getEndTime(); + + if (thisEnd.isAfter(start) && thisEnd.isBefore(end)) { + return true; + } + + if ((thisStart.isAfter(start) || thisStart.isEqual(start)) + && !thisStart.isAfter(end)) { + return true; + } + return false; + }); + } } diff --git a/src/ru/alexgur/kanban/service/TaskManager.java b/src/ru/alexgur/kanban/service/TaskManager.java index 2ec4831..affc5ce 100644 --- a/src/ru/alexgur/kanban/service/TaskManager.java +++ b/src/ru/alexgur/kanban/service/TaskManager.java @@ -50,4 +50,5 @@ public interface TaskManager { void deleteEpics(); + List getPrioritizedTasks(); } \ No newline at end of file diff --git a/test/ru/alexgur/kanban/model/EpicTest.java b/test/ru/alexgur/kanban/model/EpicTest.java index d5b88a7..994a43d 100644 --- a/test/ru/alexgur/kanban/model/EpicTest.java +++ b/test/ru/alexgur/kanban/model/EpicTest.java @@ -7,24 +7,9 @@ import ru.alexgur.kanban.model.Epic; import ru.alexgur.kanban.model.SubTask; -import ru.alexgur.kanban.service.HistoryManager; -import ru.alexgur.kanban.service.Managers; -import ru.alexgur.kanban.service.TaskManager; - import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeAll; public class EpicTest { - private static TaskManager tm; - private static HistoryManager hm; - - @BeforeAll - public static void createTaskManagerAndHistoryManagerVarsSetHistoryManager() { - tm = Managers.getDefault(); - hm = Managers.getDefaultHistory(); - tm.setHistoryManager(hm); - } - @Test public void shouldCreateEpicAndAddSubTaskAndSetProperies() { Epic epic = new Epic(); diff --git a/test/ru/alexgur/kanban/model/SubTaskTest.java b/test/ru/alexgur/kanban/model/SubTaskTest.java index a177847..9f97224 100644 --- a/test/ru/alexgur/kanban/model/SubTaskTest.java +++ b/test/ru/alexgur/kanban/model/SubTaskTest.java @@ -3,24 +3,9 @@ import org.junit.jupiter.api.Test; import ru.alexgur.kanban.model.SubTask; -import ru.alexgur.kanban.service.HistoryManager; -import ru.alexgur.kanban.service.Managers; -import ru.alexgur.kanban.service.TaskManager; - import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeAll; public class SubTaskTest { - private static TaskManager tm; - private static HistoryManager hm; - - @BeforeAll - public static void createTaskManagerAndHistoryManagerVarsSetHistoryManager() { - tm = Managers.getDefault(); - hm = Managers.getDefaultHistory(); - tm.setHistoryManager(hm); - } - @Test public void shouldCreateSubTaskAndSetProperies() { SubTask subTask = new SubTask(); @@ -41,4 +26,16 @@ public void shouldNotBePossibleToSetSubTaskAsItsOwnEpic() { Assertions.assertNotEquals(subTask.id, subTask.getEpicId()); } + + // проверьте, что наследники класса SubTask равны друг другу; + @Test + public void shouldBeEqualTwoSubTasks() { + SubTask subTask1 = new SubTask(); + SubTask subTask2 = new SubTask(); + + subTask1.setName("Название SubTask").setText("Описание SubTask"); + subTask2.setName("Название SubTask").setText("Описание SubTask"); + + Assertions.assertEquals(subTask1, subTask2); + } } \ No newline at end of file diff --git a/test/ru/alexgur/kanban/model/TaskTest.java b/test/ru/alexgur/kanban/model/TaskTest.java index ceed66a..f51615e 100644 --- a/test/ru/alexgur/kanban/model/TaskTest.java +++ b/test/ru/alexgur/kanban/model/TaskTest.java @@ -2,31 +2,10 @@ import org.junit.jupiter.api.Test; -import ru.alexgur.kanban.model.SubTask; import ru.alexgur.kanban.model.Task; -import ru.alexgur.kanban.service.HistoryManager; -import ru.alexgur.kanban.service.Managers; -import ru.alexgur.kanban.service.TaskManager; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; - -import java.util.List; - import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeAll; public class TaskTest { - private static TaskManager tm; - private static HistoryManager hm; - - @BeforeAll - public static void createTaskManagerAndHistoryManagerVarsSetHistoryManager() { - tm = Managers.getDefault(); - hm = Managers.getDefaultHistory(); - tm.setHistoryManager(hm); - } - @Test public void shouldIncrementCountByOneAfterTaskCreate() { Task task1 = new Task(); @@ -57,34 +36,4 @@ public void shouldBeEqualTwoTasks() { Assertions.assertEquals(task1, task2); } - - @Test - void addNewTask() { - Task task = new Task(); - - task.setName("Название").setText("Описание"); - final int taskSizeInit = tm.getTasks().size(); - final int taskId = tm.addTask(task); - final Task savedTask = tm.getTask(taskId); - final List tasks = tm.getTasks(); - - assertNotNull(savedTask, "Задача не найдена."); - assertEquals(task, savedTask, "Задачи не совпадают."); - assertNotNull(tasks, "Задачи не возвращаются."); - assertEquals(taskSizeInit + 1, tasks.size(), "Неверное количество задач."); - assertEquals(task, tasks.get(tasks.size() - 1), "Задачи не совпадают."); - } - - // проверьте, что наследники класса Task равны друг другу; - @Test - public void shouldBeEqualTwoSubTasks() { - SubTask subTask1 = new SubTask(); - SubTask subTask2 = new SubTask(); - - subTask1.setName("Название SubTask").setText("Описание SubTask"); - subTask2.setName("Название SubTask").setText("Описание SubTask"); - - Assertions.assertEquals(subTask1, subTask2); - } - } \ No newline at end of file diff --git a/test/ru/alexgur/kanban/service/FileBackedTaskManagerTest.java b/test/ru/alexgur/kanban/service/FileBackedTaskManagerTest.java index a493e0d..375c151 100644 --- a/test/ru/alexgur/kanban/service/FileBackedTaskManagerTest.java +++ b/test/ru/alexgur/kanban/service/FileBackedTaskManagerTest.java @@ -9,7 +9,6 @@ import ru.alexgur.kanban.exceptions.ManageLoadException; import ru.alexgur.kanban.model.Epic; import ru.alexgur.kanban.model.Task; -import ru.alexgur.kanban.service.HistoryManager; import ru.alexgur.kanban.service.FileBackedTaskManager; import java.io.File; @@ -19,35 +18,146 @@ import java.io.BufferedReader; import java.io.FileReader; import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; -public class FileBackedTaskManagerTest { - public static FileBackedTaskManager tm; - public static HistoryManager hm; +public class FileBackedTaskManagerTest extends TaskManagerTest { + + @BeforeEach + public void setUp() { + taskManager = new FileBackedTaskManager(); + } + + // Методы родителя + @Test + public void testAddNewTask() { + addNewTask(); + } + + @Test + public void testAddNewSubTask() { + addNewSubTask(); + } + + @Test + public void testAddNewEpic() { + addNewEpic(); + } + + @Test + public void testUpdateTask() { + updateTask(); + } + + @Test + public void testUpdateSubTask() { + updateTask(); + } + + @Test + public void testUpdateEpic() { + updateTask(); + } + + @Test + public void testDeleteTask() { + deleteTask(); + } + + @Test + public void testDeleteTasks() { + deleteTasks(); + } + + @Test + public void testDeleteSubTask() { + deleteSubTask(); + } + + @Test + public void testDeleteSubTasks() { + deleteSubTasks(); + } + + @Test + public void testDeleteEpic() { + deleteEpic(); + } + + @Test + public void testDeleteEpics() { + deleteEpics(); + } + + @Test + public void testGetEpicSubTasks() { + getEpicSubTasks(); + } + + @Test + public void testGetTask() { + getTask(); + } + + @Test + public void testGetTasks() { + getTasks(); + } + + @Test + public void testGetSubTask() { + getSubTask(); + } + + @Test + public void testGetSubTasks() { + getSubTasks(); + } + + @Test + public void testGetEpic() { + getEpic(); + } + + @Test + public void testGetEpics() { + getEpics(); + } + + @Test + public void testGetPrioritizedTasks() { + getPrioritizedTasks(); + } + + @Test + public void testSetEpicDurationStartEndTime() { + setEpicDurationStartEndTime(); + } + + // Уникальные методы этого класса @Test public void shouldSaveAndLoadFromEmptyCSVFile() { // сохранение и загрузку пустого файла; try { File tempFile = writeCsvWithoutContent(); - tm = FileBackedTaskManager.loadFromFile(tempFile); + taskManager = FileBackedTaskManager.loadFromFile(tempFile); } catch (ManageLoadException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } - Assertions.assertEquals(tm.getTasks().size(), 0); - Assertions.assertEquals(tm.getSubTasks().size(), 0); - Assertions.assertEquals(tm.getEpics().size(), 0); + Assertions.assertEquals(taskManager.getTasks().size(), 0); + Assertions.assertEquals(taskManager.getSubTasks().size(), 0); + Assertions.assertEquals(taskManager.getEpics().size(), 0); } @Test public void shouldSaveFewTasksToCSVFile() { // сохранение нескольких задач; - tm = new FileBackedTaskManager(); try { - tm.setFile(File.createTempFile("kanban_to_save", ".csv")); + taskManager.setFile(File.createTempFile("kanban_to_save", ".csv")); } catch (IOException e) { // } @@ -62,19 +172,19 @@ public void shouldSaveFewTasksToCSVFile() { epic1.setName("epic Name 1").setText("epic Text 1"); subTask1.setName("subTask Name 1").setText("subTask Text 1"); - tm.addTask(task1); - tm.addEpic(epic1); - tm.addSubTask(subTask1); + taskManager.addTask(task1); + taskManager.addEpic(epic1); + taskManager.addSubTask(subTask1); List sbTasksIds = new ArrayList<>(); sbTasksIds.add(subTask1.id); epic1.setSubTasksIds(sbTasksIds); subTask1.setEpicId(epic1.id); - tm.addTask(task2); + taskManager.addTask(task2); List lines = new ArrayList<>(); - try (BufferedReader reader = new BufferedReader(new FileReader(tm.getFile()))) { + try (BufferedReader reader = new BufferedReader(new FileReader(taskManager.getFile()))) { String line; while ((line = reader.readLine()) != null) { line = line.trim(); @@ -87,14 +197,14 @@ public void shouldSaveFewTasksToCSVFile() { // } - Assertions.assertEquals("1;TASK;task Name 1;NEW;task Text 1;;", lines.get(0)); - Assertions.assertEquals("2;TASK;task Name 2;NEW;task Text 2;;", lines.get(1)); - Assertions.assertEquals("4;SUBTASK;subTask Name 1;NEW;subTask Text 1;3;", lines.get(2)); - Assertions.assertEquals("3;EPIC;epic Name 1;NEW;epic Text 1;;", lines.get(3)); + Assertions.assertEquals("1;TASK;task Name 1;task Text 1;NEW;;0;;", lines.get(0)); + Assertions.assertEquals("2;TASK;task Name 2;task Text 2;NEW;;0;;", lines.get(1)); + Assertions.assertEquals("4;SUBTASK;subTask Name 1;subTask Text 1;NEW;;0;3;", lines.get(2)); + Assertions.assertEquals("3;EPIC;epic Name 1;epic Text 1;NEW;;0;;", lines.get(3)); - Assertions.assertEquals(2, tm.getTasks().size()); - Assertions.assertEquals(1, tm.getSubTasks().size()); - Assertions.assertEquals(1, tm.getEpics().size()); + Assertions.assertEquals(2, taskManager.getTasks().size()); + Assertions.assertEquals(1, taskManager.getSubTasks().size()); + Assertions.assertEquals(1, taskManager.getEpics().size()); } @Test @@ -102,20 +212,20 @@ public void shouldLoadFewTasksFromCSVFile() { // загрузку нескольких задач. try { File tempFile = writeCsvWithContent(); - tm = FileBackedTaskManager.loadFromFile(tempFile); + taskManager = FileBackedTaskManager.loadFromFile(tempFile); } catch (ManageLoadException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } - Assertions.assertEquals(1, tm.getTasks().size()); - Assertions.assertEquals(1, tm.getSubTasks().size()); - Assertions.assertEquals(1, tm.getEpics().size()); + Assertions.assertEquals(1, taskManager.getTasks().size()); + Assertions.assertEquals(1, taskManager.getSubTasks().size()); + Assertions.assertEquals(1, taskManager.getEpics().size()); - Assertions.assertEquals(List.of(3), (List) tm.getEpics().get(0).getSubTasksIds()); - Assertions.assertEquals(2, tm.getSubTasks().get(0).getEpicId()); - Assertions.assertEquals(1, tm.getTasks().get(0).getId()); + Assertions.assertEquals(List.of(3), (List) taskManager.getEpics().get(0).getSubTasksIds()); + Assertions.assertEquals(2, taskManager.getSubTasks().get(0).getEpicId()); + Assertions.assertEquals(1, taskManager.getTasks().get(0).getId()); } private static File writeCsvWithoutContent() throws IOException { @@ -135,13 +245,17 @@ private static File writeCsvWithContent() throws IOException { Writer fileWriter = new FileWriter(tempFile); fileWriter.write( - "id" + SPL + "type" + SPL + "name" + SPL + "status" + SPL + "description" + SPL + "epic" + EOL); + "id" + SPL + "type" + SPL + "name" + SPL + "description" + SPL + "status" + SPL + "start" + SPL + + "duration" + SPL + "epic" + EOL); + fileWriter.write( + "1" + SPL + "TASK" + SPL + "Task1" + SPL + "Description task1" + SPL + "NEW" + SPL + + "2024-12-19 04:12:41" + SPL + "20" + SPL + SPL + EOL); fileWriter.write( - "1" + SPL + "TASK" + SPL + "Task1" + SPL + "NEW" + SPL + "Description task1" + SPL + SPL + EOL); + "2" + SPL + "EPIC" + SPL + "Epic2" + SPL + "Description epic2" + SPL + "DONE" + SPL + + "2024-12-20 07:23:17" + SPL + "30" + SPL + SPL + EOL); fileWriter.write( - "2" + SPL + "EPIC" + SPL + "Epic2" + SPL + "DONE" + SPL + "Description epic2" + SPL + SPL + EOL); - fileWriter.write("3" + SPL + "SUBTASK" + SPL + "Sub Task2" + SPL + "DONE" + SPL + "Description sub task3" - + SPL + "2" + EOL); + "3" + SPL + "SUBTASK" + SPL + "Sub Task2" + SPL + "Description sub task3" + SPL + "DONE" + SPL + + "2024-12-21 10:27:58" + SPL + "40" + SPL + "2" + EOL); fileWriter.close(); diff --git a/test/ru/alexgur/kanban/service/InMemoryTaskManagerTest.java b/test/ru/alexgur/kanban/service/InMemoryTaskManagerTest.java index 9d83053..e5f3f1d 100644 --- a/test/ru/alexgur/kanban/service/InMemoryTaskManagerTest.java +++ b/test/ru/alexgur/kanban/service/InMemoryTaskManagerTest.java @@ -2,56 +2,283 @@ import org.junit.jupiter.api.Test; +import ru.alexgur.kanban.exceptions.ManagerAddTaskException; import ru.alexgur.kanban.model.Epic; import ru.alexgur.kanban.model.SubTask; import ru.alexgur.kanban.model.Task; -import ru.alexgur.kanban.service.HistoryManager; +import ru.alexgur.kanban.service.InMemoryTaskManager; import ru.alexgur.kanban.service.Managers; -import ru.alexgur.kanban.service.TaskManager; +import ru.alexgur.kanban.service.Status; + +import java.time.Duration; +import java.time.LocalDateTime; +import java.util.List; import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; + +public class InMemoryTaskManagerTest extends TaskManagerTest { + + @BeforeEach + public void setUp() { + taskManager = new InMemoryTaskManager(); + historyManager = Managers.getDefaultHistory(); + taskManager.setHistoryManager(historyManager); + } + + // Методы родителя + @Test + public void testAddNewTask() { + addNewTask(); + } + + @Test + public void testAddNewSubTask() { + addNewSubTask(); + } + + @Test + public void testAddNewEpic() { + addNewEpic(); + } + + @Test + public void testUpdateTask() { + updateTask(); + } + + @Test + public void testUpdateSubTask() { + updateTask(); + } + + @Test + public void testUpdateEpic() { + updateTask(); + } + + @Test + public void testDeleteTask() { + deleteTask(); + } + + @Test + public void testDeleteTasks() { + deleteTasks(); + } + + @Test + public void testDeleteSubTask() { + deleteSubTask(); + } + + @Test + public void testDeleteSubTasks() { + deleteSubTasks(); + } + + @Test + public void testDeleteEpic() { + deleteEpic(); + } + + @Test + public void testDeleteEpics() { + deleteEpics(); + } + + @Test + public void testGetEpicSubTasks() { + getEpicSubTasks(); + } + + @Test + public void testGetTask() { + getTask(); + } + + @Test + public void testGetTasks() { + getTasks(); + } + + @Test + public void testGetSubTask() { + getSubTask(); + } -public class InMemoryTaskManagerTest { - private static TaskManager tm; - private static HistoryManager hm; + @Test + public void testGetSubTasks() { + getSubTasks(); + } - @BeforeAll - public static void createTaskManagerAndHistoryManagerVarsSetHistoryManager() { - tm = Managers.getDefault(); - hm = Managers.getDefaultHistory(); - tm.setHistoryManager(hm); + @Test + public void testGetEpic() { + getEpic(); } - // создайте тест, в котором проверяется неизменность задачи (по всем полям) при + @Test + public void testGetEpics() { + getEpics(); + } + + @Test + public void testGetPrioritizedTasks() { + getPrioritizedTasks(); + } + + @Test + public void testSetEpicDurationStartEndTime() { + setEpicDurationStartEndTime(); + } + + // Уникальные методы этого класса + + // тест, в котором проверяется неизменность задачи (по всем полям) при // добавлении задачи в менеджер @Test public void shouldPersistTaskAfterSave() { Task task = new Task(); - int taskId = tm.addTask(task); + int taskId = taskManager.addTask(task); - Assertions.assertEquals(task, tm.getTask(taskId)); + Assertions.assertEquals(task, taskManager.getTask(taskId)); } - // проверьте, что InMemoryTaskManager действительно добавляет задачи разного + // проверьте, что Manager действительно добавляет задачи разного // типа и может найти их по id; @Test - public void shouldSaveAllTypesToInMemoryTaskManager() { + public void shouldSaveAllTaskTypes() { Task task = new Task(); SubTask subTask = new SubTask(); Epic epic = new Epic(); - int taskId = tm.addTask(task); - int subTaskId = tm.addSubTask(subTask); - int epicId = tm.addEpic(epic); + int taskId = taskManager.addTask(task); + int subTaskId = taskManager.addSubTask(subTask); + int epicId = taskManager.addEpic(epic); + + Assertions.assertEquals(task, taskManager.getTask(taskId)); + Assertions.assertEquals(subTask, taskManager.getSubTask(subTaskId)); + Assertions.assertEquals(epic, taskManager.getEpic(epicId)); + } + + // Для расчёта статуса Epic. Граничные условия: + @Test + public void shouldSetEpicNewIfAllSubtasksNew() { + // a. Все подзадачи со статусом NEW. + Epic epic = new Epic(); + SubTask subTask1 = new SubTask(); + SubTask subTask2 = new SubTask(); + + subTask1.setStatus(Status.NEW); + subTask2.setStatus(Status.NEW); + epic.setSubTasksIds(List.of(subTask1.id, subTask2.id)); + + taskManager.addSubTask(subTask1); + taskManager.addSubTask(subTask2); + int epicId = taskManager.addEpic(epic); + + Assertions.assertEquals(Status.NEW, taskManager.getEpic(epicId).getStatus()); + } + + @Test + public void shouldSetEpicDoneIfAllSubtasksDone() { + // b. Все подзадачи со статусом DONE. + Epic epic = new Epic(); + SubTask subTask1 = new SubTask(); + SubTask subTask2 = new SubTask(); + + subTask1.setStatus(Status.DONE); + subTask2.setStatus(Status.DONE); + epic.setSubTasksIds(List.of(subTask1.id, subTask2.id)); + + taskManager.addSubTask(subTask1); + taskManager.addSubTask(subTask2); + subTask1.setEpicId(epic.id); + subTask2.setEpicId(epic.id); + int epicId = taskManager.addEpic(epic); - Assertions.assertEquals(task, tm.getTask(taskId)); - Assertions.assertEquals(subTask, tm.getSubTask(subTaskId)); - Assertions.assertEquals(epic, tm.getEpic(epicId)); + Assertions.assertEquals(Status.DONE, taskManager.getEpic(epicId).getStatus()); } - // проверьте, что задачи с заданным id и сгенерированным id не конфликтуют - // внутри менеджера; ?????? Это вообще как? + @Test + public void shouldSetEpicInProgressIfAllSubtasksNewAndDone() { + // c. Подзадачи со статусами NEW и DONE. + Epic epic = new Epic(); + SubTask subTask1 = new SubTask(); + SubTask subTask2 = new SubTask(); + + subTask1.setStatus(Status.DONE); + subTask2.setStatus(Status.NEW); + epic.setSubTasksIds(List.of(subTask1.id, subTask2.id)); + + taskManager.addSubTask(subTask1); + taskManager.addSubTask(subTask2); + subTask1.setEpicId(epic.id); + subTask2.setEpicId(epic.id); + int epicId = taskManager.addEpic(epic); + + Assertions.assertEquals(Status.IN_PROGRESS, taskManager.getEpic(epicId).getStatus()); + } + + @Test + public void shouldSetEpicInProgressIfAllSubtasksInProgress() { + // d. Подзадачи со статусом IN_PROGRESS. + Epic epic = new Epic(); + SubTask subTask1 = new SubTask(); + SubTask subTask2 = new SubTask(); + subTask1.setStatus(Status.IN_PROGRESS); + subTask2.setStatus(Status.IN_PROGRESS); + epic.setSubTasksIds(List.of(subTask1.id, subTask2.id)); + + taskManager.addSubTask(subTask1); + taskManager.addSubTask(subTask2); + subTask1.setEpicId(epic.id); + subTask2.setEpicId(epic.id); + int epicId = taskManager.addEpic(epic); + + Assertions.assertEquals(Status.IN_PROGRESS, taskManager.getEpic(epicId).getStatus()); + } + + @Test + public void shouldThrowExceptionIfCrossInterval() { + // c. Добавить тест на корректность расчёта пересечения интервалов. + Task task1 = new Task(); + SubTask task2 = new SubTask(); + Task task3 = new Task(); + Task task4 = new Task(); + SubTask task5 = new SubTask(); + Task task6 = new Task(); + + task1.setStartTime(LocalDateTime.parse("2024-12-10 09:18:32", Task.dateTimeFormatter)); + task2.setStartTime(LocalDateTime.parse("2024-12-10 09:18:32", Task.dateTimeFormatter)); + task3.setStartTime(LocalDateTime.parse("2024-12-10 09:18:41", Task.dateTimeFormatter)); + task4.setStartTime(LocalDateTime.parse("2024-12-10 09:19:42", Task.dateTimeFormatter)); + task5.setStartTime(LocalDateTime.parse("2024-12-10 02:02:42", Task.dateTimeFormatter)); + task6.setStartTime(LocalDateTime.parse("2024-12-10 02:02:42", Task.dateTimeFormatter)); + + task1.setDuration(Duration.ofSeconds(10)); + task2.setDuration(Duration.ofSeconds(10)); + task3.setDuration(Duration.ofSeconds(10)); + task4.setDuration(Duration.ofSeconds(10)); + task5.setDuration(Duration.ofSeconds(10)); + task6.setDuration(Duration.ofSeconds(10)); + + Assertions.assertDoesNotThrow(() -> taskManager.addTask(task1)); + Assertions.assertThrows(ManagerAddTaskException.class, () -> taskManager.addSubTask(task2)); + Assertions.assertThrows(ManagerAddTaskException.class, () -> taskManager.addTask(task3)); + Assertions.assertDoesNotThrow(() -> taskManager.addTask(task4)); + + Assertions.assertThrows(ManagerAddTaskException.class, () -> { + task1.setStartTime(LocalDateTime.parse("2024-12-10 09:19:42", Task.dateTimeFormatter)); + taskManager.updateTask(task1); + }); + + Assertions.assertThrows(ManagerAddTaskException.class, () -> { + task1.setStartTime(LocalDateTime.parse("2024-12-10 13:56:12", Task.dateTimeFormatter)); + taskManager.updateTask(task1); + }); + + } } \ No newline at end of file diff --git a/test/ru/alexgur/kanban/service/TaskManagerTest.java b/test/ru/alexgur/kanban/service/TaskManagerTest.java new file mode 100644 index 0000000..fbd1cb6 --- /dev/null +++ b/test/ru/alexgur/kanban/service/TaskManagerTest.java @@ -0,0 +1,398 @@ +package test.ru.alexgur.kanban.service; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.util.List; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import ru.alexgur.kanban.model.Epic; +import ru.alexgur.kanban.model.SubTask; +import ru.alexgur.kanban.model.Task; +import ru.alexgur.kanban.service.HistoryManager; +import ru.alexgur.kanban.service.TaskManager; +import java.time.Duration; +import java.time.LocalDateTime; + +public abstract class TaskManagerTest { + protected T taskManager; + protected HistoryManager historyManager; + + // int addTask(Task task); + @Test + public void addNewTask() { + Task task = new Task(); + + task.setName("Название").setText("Описание"); + final int taskSizeInit = taskManager.getTasks().size(); + final int taskId = taskManager.addTask(task); + final Task savedTask = taskManager.getTask(taskId); + final List tasks = taskManager.getTasks(); + + assertNotNull(savedTask, "Задача не найдена."); + assertEquals(task, savedTask, "Задачи не совпадают."); + assertNotNull(tasks, "Задачи не возвращаются."); + assertEquals(taskSizeInit + 1, tasks.size(), "Неверное количество задач."); + assertEquals(task, tasks.get(tasks.size() - 1), "Задачи не совпадают."); + } + + // int addSubTask(SubTask subtask); + @Test + public void addNewSubTask() { + SubTask task = new SubTask(); + + task.setName("Название").setText("Описание"); + final int taskSizeInit = taskManager.getSubTasks().size(); + final int taskId = taskManager.addSubTask(task); + final SubTask savedSubTask = taskManager.getSubTask(taskId); + final List tasks = taskManager.getSubTasks(); + + assertNotNull(savedSubTask, "Задача не найдена."); + assertEquals(task, savedSubTask, "Задачи не совпадают."); + assertNotNull(tasks, "Задачи не возвращаются."); + assertEquals(taskSizeInit + 1, tasks.size(), "Неверное количество задач."); + assertEquals(task, tasks.get(tasks.size() - 1), "Задачи не совпадают."); + } + + // int addEpic(Epic epic); + @Test + public void addNewEpic() { + Epic task = new Epic(); + + task.setName("Название").setText("Описание"); + final int taskSizeInit = taskManager.getEpics().size(); + final int taskId = taskManager.addEpic(task); + final Epic savedEpic = taskManager.getEpic(taskId); + final List tasks = taskManager.getEpics(); + + assertNotNull(savedEpic, "Задача не найдена."); + assertEquals(task, savedEpic, "Задачи не совпадают."); + assertNotNull(tasks, "Задачи не возвращаются."); + assertEquals(taskSizeInit + 1, tasks.size(), "Неверное количество задач."); + assertEquals(task, tasks.get(tasks.size() - 1), "Задачи не совпадают."); + } + + // void updateTask(Task task); + @Test + public void updateTask() { + Task task = new Task(); + + int taskId = taskManager.addTask(task); + + task.setName("Название") + .setText("Описание"); + + Task savedTask = taskManager.getTask(taskId); + + assertEquals(task, savedTask, "Задачи Task не совпадают."); + } + + // void updateSubTask(SubTask subtask); + @Test + public void updateSubTask() { + SubTask task = new SubTask(); + + int taskId = taskManager.addSubTask(task); + + task.setName("Название") + .setText("Описание"); + + Task savedTask = taskManager.getSubTask(taskId); + + assertEquals(task, savedTask, "Задачи SubTask не совпадают."); + } + + // void updateEpic(Epic epic); + @Test + public void updateEpic() { + Epic task = new Epic(); + + int taskId = taskManager.addEpic(task); + + task.setName("Название") + .setText("Описание"); + + Epic savedEpic = taskManager.getEpic(taskId); + + assertEquals(task, savedEpic, "Задачи Epic не совпадают."); + } + + // void deleteTask(int id); + @Test + public void deleteTask() { + Task task = new Task(); + + task.setName("Название") + .setText("Описание"); + + int taskId = taskManager.addTask(task); + + taskManager.deleteTask(taskId); + Task saved = taskManager.getTask(taskId); + + assertEquals(saved, null, "Задачи Task не удаляются"); + } + + // void deleteTasks(); + @Test + public void deleteTasks() { + Task task1 = new Task(); + Task task2 = new Task(); + + taskManager.addTask(task1); + taskManager.addTask(task2); + + int size1 = taskManager.getTasks().size(); + taskManager.deleteTasks(); + int size2 = taskManager.getTasks().size(); + + assertEquals(size1, 2, "Список Task задач не дополняется"); + assertEquals(size2, 0, "Список Task задач не очищается"); + } + + // void deleteSubTask(int id); + @Test + public void deleteSubTask() { + SubTask task = new SubTask(); + + task.setName("Название") + .setText("Описание"); + + int taskId = taskManager.addSubTask(task); + taskManager.deleteSubTask(taskId); + SubTask saved = taskManager.getSubTask(taskId); + + assertEquals(saved, null, "Задачи SubTask не удаляются"); + } + + // void deleteSubTasks(); + @Test + public void deleteSubTasks() { + SubTask task1 = new SubTask(); + SubTask task2 = new SubTask(); + + taskManager.addSubTask(task1); + taskManager.addSubTask(task2); + + int size1 = taskManager.getSubTasks().size(); + taskManager.deleteSubTasks(); + int size2 = taskManager.getSubTasks().size(); + + assertEquals(size1, 2, "Список подзадач не дополняется"); + assertEquals(size2, 0, "Список подзадач не очищается"); + } + + // void deleteEpic(int id); + @Test + public void deleteEpic() { + Epic task = new Epic(); + + task.setName("Название") + .setText("Описание"); + + int taskId = taskManager.addEpic(task); + taskManager.deleteEpic(taskId); + Epic saved = taskManager.getEpic(taskId); + + assertEquals(saved, null, "Задачи Epic не удаляются"); + } + + // void deleteEpics(); + @Test + public void deleteEpics() { + Epic task1 = new Epic(); + Epic task2 = new Epic(); + + taskManager.addEpic(task1); + taskManager.addEpic(task2); + + int size1 = taskManager.getEpics().size(); + taskManager.deleteEpics(); + int size2 = taskManager.getEpics().size(); + + assertEquals(size1, 2, "Список Epic задач не дополняется"); + assertEquals(size2, 0, "Список Epic задач не очищается"); + } + + // List getEpicSubTasks(int epicId); + @Test + public void getEpicSubTasks() { + Epic epic = new Epic(); + SubTask subTask1 = new SubTask(); + SubTask subTask2 = new SubTask(); + + epic.setSubTasksIds(List.of(subTask1.id, subTask2.id)); + + subTask1.setEpicId(epic.id); + subTask2.setEpicId(epic.id); + + int subTaskId1 = taskManager.addSubTask(subTask1); + int subTaskId2 = taskManager.addSubTask(subTask2); + int epicId = taskManager.addEpic(epic); + + List saved = taskManager.getEpic(epicId).getSubTasksIds(); + + Assertions.assertEquals(subTaskId1, saved.get(0)); + Assertions.assertEquals(subTaskId2, saved.get(1)); + } + + // Task getTask(int id); + @Test + public void getTask() { + Task task1 = new Task(); + + int taskId = taskManager.addTask(task1); + + int size = taskManager.getTasks().size(); + Task savedTask1 = taskManager.getTask(taskId); + + assertEquals(size, 1, "Список Task задач не дополняется"); + assertEquals(task1, savedTask1, "Задача Task1 не совпадает с сохранённой"); + } + + // List getTasks(); + @Test + public void getTasks() { + Task task1 = new Task(); + Task task2 = new Task(); + + taskManager.addTask(task1); + taskManager.addTask(task2); + + int size = taskManager.getTasks().size(); + Task savedTask1 = taskManager.getTasks().get(0); + Task savedTask2 = taskManager.getTasks().get(1); + + assertEquals(size, 2, "Список Task задач не дополняется"); + assertEquals(task1, savedTask1, "Задача Task1 не совпадает с сохранённой"); + assertEquals(task2, savedTask2, "Задача Task2 не совпадает с сохранённой"); + } + + // SubTask getSubTask(int id); + @Test + public void getSubTask() { + SubTask task1 = new SubTask(); + + int taskId = taskManager.addSubTask(task1); + + int size = taskManager.getSubTasks().size(); + SubTask savedSubTask1 = taskManager.getSubTask(taskId); + + assertEquals(size, 1, "Список SubTask задач не дополняется"); + assertEquals(task1, savedSubTask1, "Задача SubTask1 не совпадает с сохранённой"); + } + + // List getSubTasks(); + @Test + public void getSubTasks() { + SubTask task1 = new SubTask(); + SubTask task2 = new SubTask(); + + taskManager.addSubTask(task1); + taskManager.addSubTask(task2); + + int size = taskManager.getSubTasks().size(); + SubTask savedSubTask1 = taskManager.getSubTasks().get(0); + SubTask savedSubTask2 = taskManager.getSubTasks().get(1); + + assertEquals(size, 2, "Список SubTask задач не дополняется"); + assertEquals(task1, savedSubTask1, "Задача SubTask1 не совпадает с сохранённой"); + assertEquals(task2, savedSubTask2, "Задача SubTask2 не совпадает с сохранённой"); + } + + // Epic getEpic(int id); + @Test + public void getEpic() { + Epic task1 = new Epic(); + + int taskId = taskManager.addEpic(task1); + + int size = taskManager.getEpics().size(); + Epic savedEpic1 = taskManager.getEpic(taskId); + + assertEquals(size, 1, "Список Epic задач не дополняется"); + assertEquals(task1, savedEpic1, "Задача Epic1 не совпадает с сохранённой"); + } + + // List getEpics(); + @Test + public void getEpics() { + Epic task1 = new Epic(); + Epic task2 = new Epic(); + + taskManager.addEpic(task1); + taskManager.addEpic(task2); + + int size = taskManager.getEpics().size(); + Epic savedEpic1 = taskManager.getEpics().get(0); + Epic savedEpic2 = taskManager.getEpics().get(1); + + assertEquals(size, 2, "Список Epic задач не дополняется"); + assertEquals(task1, savedEpic1, "Задача Epic1 не совпадает с сохранённой"); + assertEquals(task2, savedEpic2, "Задача Epic2 не совпадает с сохранённой"); + } + + // List getPrioritizedTasks(); + @Test + public void getPrioritizedTasks() { + Task task1 = new Task(); + Task task2 = new Task(); + SubTask task3 = new SubTask(); + + task1.setDuration(Duration.ofSeconds(60)) + .setStartTime(LocalDateTime.parse("2024-08-17 01:32:21", + Task.dateTimeFormatter)); + task2.setDuration(Duration.ofSeconds(60)) + .setStartTime(LocalDateTime.parse("2024-08-17 03:32:21", + Task.dateTimeFormatter)); + task3.setDuration(Duration.ofSeconds(60)) + .setStartTime(LocalDateTime.parse("2024-08-17 02:32:21", + Task.dateTimeFormatter)); + + taskManager.addTask(task1); + taskManager.addTask(task2); + taskManager.addTask(task3); + + List tasks = taskManager.getPrioritizedTasks(); + int size = tasks.size(); + assertEquals(size, 3, "Приоритетные задачи не добавляются"); + assertEquals(task1, tasks.get(0), "Приоритетные задачи не сортируются по времени"); + assertEquals(task3, tasks.get(1), "Приоритетные задачи не сортируются по времени"); + assertEquals(task2, tasks.get(2), "Приоритетные задачи не сортируются по времени"); + } + + @Test + public void setEpicDurationStartEndTime() { + Epic epic = new Epic(); + SubTask subTask1 = new SubTask(); + SubTask subTask2 = new SubTask(); + + subTask1.setStartTime(LocalDateTime.parse("2024-12-10 09:00:00", Task.dateTimeFormatter)); + subTask2.setStartTime(LocalDateTime.parse("2024-12-10 09:00:30", Task.dateTimeFormatter)); + + subTask1.setDuration(Duration.ofSeconds(10)); + subTask2.setDuration(Duration.ofSeconds(10)); + + epic.setSubTasksIds(List.of(subTask1.id, subTask2.id)); + + subTask1.setEpicId(epic.id); + subTask2.setEpicId(epic.id); + + taskManager.addSubTask(subTask1); + taskManager.addSubTask(subTask2); + int epicId = taskManager.addEpic(epic); + + Epic savedEpic = taskManager.getEpic(epicId); + + // Продолжительность эпика — сумма продолжительностей всех его подзадач. + Assertions.assertEquals(savedEpic.getDuration(), subTask1.getDuration().plus(subTask2.getDuration())); + + // Время начала — дата старта самой ранней подзадачи, + Assertions.assertEquals(savedEpic.getStartTime(), subTask1.getStartTime()); + + // а время завершения — время окончания самой поздней из задач. + Assertions.assertEquals(savedEpic.getEndTime(), subTask2.getEndTime()); + } +}