From e59a7d040d60b7c2b8918a15342520fd764d9eff Mon Sep 17 00:00:00 2001 From: artemdergunov Date: Sun, 26 Jan 2025 16:38:56 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=BB=D0=B5?= =?UTF-8?q?=D0=BD=D1=8B=20=D0=BD=D0=BE=D0=B2=D1=8B=D0=B5=20=D0=B8=D0=B7?= =?UTF-8?q?=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD=D0=B8=D1=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .idea/libraries/junit.xml | 11 + .idea/libraries/junit_jupiter.xml | 17 ++ .idea/misc.xml | 2 +- .idea/vcs.xml | 6 + java-kanban.iml | 3 + src/Main.java | 64 ++++- src/enums/Status.java | 7 + src/manager/HistoryManager.java | 14 + src/manager/InMemoryHistoryManager.java | 76 ++++++ src/manager/InMemoryTaskManager.java | 257 ++++++++++++++++++ src/manager/Managers.java | 12 + src/manager/Node.java | 37 +++ src/manager/TaskManager.java | 51 ++++ src/task/Epic.java | 45 +++ src/task/Subtask.java | 33 +++ src/task/Task.java | 80 ++++++ tests/manager/InMemoryHistoryManagerTest.java | 143 ++++++++++ tests/manager/InMemoryTaskManagerTest.java | 104 +++++++ tests/manager/ManagersTest.java | 23 ++ tests/task/EpicTest.java | 20 ++ tests/task/SubtaskTest.java | 18 ++ tests/task/TaskTest.java | 18 ++ 22 files changed, 1039 insertions(+), 2 deletions(-) create mode 100644 .idea/libraries/junit.xml create mode 100644 .idea/libraries/junit_jupiter.xml create mode 100644 .idea/vcs.xml create mode 100644 src/enums/Status.java create mode 100644 src/manager/HistoryManager.java create mode 100644 src/manager/InMemoryHistoryManager.java create mode 100644 src/manager/InMemoryTaskManager.java create mode 100644 src/manager/Managers.java create mode 100644 src/manager/Node.java create mode 100644 src/manager/TaskManager.java create mode 100644 src/task/Epic.java create mode 100644 src/task/Subtask.java create mode 100644 src/task/Task.java create mode 100644 tests/manager/InMemoryHistoryManagerTest.java create mode 100644 tests/manager/InMemoryTaskManagerTest.java create mode 100644 tests/manager/ManagersTest.java create mode 100644 tests/task/EpicTest.java create mode 100644 tests/task/SubtaskTest.java create mode 100644 tests/task/TaskTest.java diff --git a/.idea/libraries/junit.xml b/.idea/libraries/junit.xml new file mode 100644 index 00000000..e0e3044a --- /dev/null +++ b/.idea/libraries/junit.xml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/libraries/junit_jupiter.xml b/.idea/libraries/junit_jupiter.xml new file mode 100644 index 00000000..75dd2894 --- /dev/null +++ b/.idea/libraries/junit_jupiter.xml @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml index fa5b4362..d5617668 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,6 +1,6 @@ - + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 00000000..35eb1ddf --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/java-kanban.iml b/java-kanban.iml index c90834f2..b5e4a62f 100644 --- a/java-kanban.iml +++ b/java-kanban.iml @@ -4,8 +4,11 @@ + + + \ No newline at end of file diff --git a/src/Main.java b/src/Main.java index adab4c68..bd16a683 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,6 +1,68 @@ +import manager.InMemoryTaskManager; +import manager.Managers; +import enums.Status; +import manager.TaskManager; +import task.Task; +import task.Epic; +import task.Subtask; + public class Main { public static void main(String[] args) { - System.out.println("Поехали!"); + + final TaskManager taskManager = Managers.getDefault(); + + // создаем две задачи + Task task1 = new Task("Сходить в магазин", "Купить молоко обязательно"); + Task task2 = new Task("Покормить кота", "Влажным кормом"); + + + taskManager.addTask(task1); + taskManager.addTask(task2); + + System.out.println(task1); + System.out.println(task2); + + + // Создаем эпик с двумя подзадачами + Epic epic1 = new Epic("Переезд", "В ближайшую неделю"); + taskManager.addEpic(epic1); + + Subtask subtask1 = new Subtask("Собрать вещи", "Сложить все в коробки", epic1.getId()); + Subtask subtask2 = new Subtask("Заказать машину", "Грузовую", epic1.getId()); + taskManager.addSubtask(subtask1); + taskManager.addSubtask(subtask2); + + System.out.println(epic1); + System.out.println(subtask1); + System.out.println(subtask2); + + // Создаем эпик с одной подзадачей + Epic epic2 = new Epic("Ремонт на даче", "В ближайший месяц"); + taskManager.addEpic(epic2); + Subtask subtask3 = new Subtask("Купить материалы", "Отвезти на дачу", epic2.getId()); + + taskManager.addSubtask(subtask3); + + // меняем статусы + subtask2.setStatus(Status.DONE); + subtask1.setStatus(Status.DONE); + taskManager.updateSubtask(subtask1); + taskManager.updateSubtask(subtask2); + task1.setStatus(Status.DONE); + + + System.out.println(task1); + System.out.println(epic1); + } } + + + + + + + + + diff --git a/src/enums/Status.java b/src/enums/Status.java new file mode 100644 index 00000000..a5512f45 --- /dev/null +++ b/src/enums/Status.java @@ -0,0 +1,7 @@ +package enums; + +public enum Status { + NEW, + IN_PROGRESS, + DONE +} \ No newline at end of file diff --git a/src/manager/HistoryManager.java b/src/manager/HistoryManager.java new file mode 100644 index 00000000..fe297013 --- /dev/null +++ b/src/manager/HistoryManager.java @@ -0,0 +1,14 @@ +package manager; + +import task.Task; + +import java.util.List; + +public interface HistoryManager { + void add(Task task); + + List getHistory(); + + void remove(int id); +} + diff --git a/src/manager/InMemoryHistoryManager.java b/src/manager/InMemoryHistoryManager.java new file mode 100644 index 00000000..e31c0ae9 --- /dev/null +++ b/src/manager/InMemoryHistoryManager.java @@ -0,0 +1,76 @@ +package manager; + +import task.Task; + +import java.util.*; + +public class InMemoryHistoryManager implements HistoryManager { + + private final Map> viewedTasksMap = new HashMap<>(); + private Node head; + private Node tail; + + @Override + public void add(Task task) { + if (task != null) { + linkLast(task); + } + } + + @Override + public List getHistory() { + return getTasks(); + } + + @Override + public void remove(int id) { + removeNode(viewedTasksMap.get(id)); + } + + private void linkLast(Task task) { + if (viewedTasksMap.containsKey(task.getId())) { + removeNode(viewedTasksMap.get(task.getId())); + } + final Node oldTail = tail; + final Node newNode = new Node<>(task, tail, null); + tail = newNode; + viewedTasksMap.put(task.getId(), newNode); + if (oldTail == null) { + head = newNode; + } else { + oldTail.setNext(newNode); + } + } + + private List getTasks() { + List tasks = new LinkedList<>(); + Node currentNode = head; + while (currentNode != null) { + tasks.add(currentNode.getData()); + currentNode = currentNode.getNext(); + } + return tasks; + } + + private void removeNode(Node node) { + if (node != null) { + final Node next = node.getNext(); + final Node previous = node.getPrevious(); + node.setData(null); + + if (head == node && tail == node) { + head = null; + tail = null; + } else if (head == node && tail != node) { + head = next; + head.setPrevious(null); + } else if (head != node && tail == node) { + tail = previous; + tail.setNext(null); + } else { + previous.setNext(next); + next.setPrevious(previous); + } + } + } +} diff --git a/src/manager/InMemoryTaskManager.java b/src/manager/InMemoryTaskManager.java new file mode 100644 index 00000000..5bfe9103 --- /dev/null +++ b/src/manager/InMemoryTaskManager.java @@ -0,0 +1,257 @@ +package manager; + +import enums.Status; +import task.Epic; +import task.Subtask; +import task.Task; + +import java.util.ArrayList; +import java.util.List; +import java.util.HashMap; + + +public class InMemoryTaskManager implements TaskManager { + + private final HashMap tasks = new HashMap<>(); + private final HashMap epics = new HashMap<>(); + private final HashMap subtasks = new HashMap<>(); + private final HistoryManager historyManager = Managers.getDefaultHistory(); + + private int curretndId = 1; + + private int generateID() { + return curretndId++; + } + + @Override + public Task addTask(Task task) { + task.setId(generateID()); + tasks.put(task.getId(), task); + return task; + } + + @Override + public Epic addEpic(Epic epic) { + epic.setId(generateID()); + epics.put(epic.getId(), epic); + return epic; + } + + @Override + public Subtask addSubtask(Subtask subtask) { + Epic epic = epics.get(subtask.getEpicID()); + if (epic != null) { + subtask.setId(generateID()); + epic.addSubtask(subtask); + subtasks.put(subtask.getId(), subtask); + updateEpicStatus(epic); + } else { + System.out.println("Такого эпика нет"); + return null; + } + return subtask; + } + + @Override + public Task updateTask(Task task) { + Integer taskID = task.getId(); + if (taskID == 0 || !tasks.containsKey(taskID)) { + return null; + } + tasks.put(taskID, task); + return task; + } + + @Override + public Epic updateEpic(Epic epic) { + Integer epicID = epic.getId(); + if (epicID != 0 && epics.containsKey(epicID)) { + Epic oldEpic = epics.get(epicID); + oldEpic.setName(epic.getName()); + oldEpic.setDescription(epic.getDescription()); + updateEpicStatus(epic); + } + return epic; + } + + @Override + public Subtask updateSubtask(Subtask subtask) { + Integer subtaskID = subtask.getId(); + if (subtaskID == 0 || !subtasks.containsKey(subtaskID)) { + return null; + } + + int epicID = subtask.getEpicID(); + Subtask oldSubtask = subtasks.get(subtaskID); + if (subtask.getEpicID() != oldSubtask.getEpicID()) { + return null; + } + + subtasks.put(subtaskID, subtask); + Epic epic = epics.get(epicID); + epic.removeSubtask(oldSubtask); + epic.addSubtask(subtask); + updateEpicStatus(epic); + return subtask; + } + + @Override + public Task getTaskByID(int id) { + if (tasks.containsKey(id)) { + historyManager.add(tasks.get(id)); + } else { + System.out.println("Задача с ID " + id + " не найдена"); + return null; + } + return tasks.get(id); + + } + + @Override + public Epic getEpicByID(int id) { + if (epics.containsKey(id)) { + historyManager.add(epics.get(id)); + } else { + System.out.println("Эпик с ID " + id + " не найден"); + return null; + } + return epics.get(id); + } + + @Override + public Subtask getSubtaskByID(int id) { + if (subtasks.containsKey(id)) { + historyManager.add(subtasks.get(id)); + } else { + System.out.println("Подзадача с ID " + id + " не найдена"); + return null; + } + return subtasks.get(id); + } + + @Override + public List getTasks() { + return new ArrayList<>(tasks.values()); + } + + @Override + public List getEpics() { + return new ArrayList<>(epics.values()); + } + + @Override + public List getSubtasks() { + return new ArrayList<>(subtasks.values()); + } + + @Override + public List getEpicSubtasks(int epicId) { + if (epics.containsKey(epicId)) { + Epic epic = epics.get(epicId); + return epic.getSubtaskList(); + } else { + return new ArrayList<>(); + } + } + + @Override + public void deleteTasks() { + for (Integer taskId : tasks.keySet()) { + historyManager.remove(taskId); + } + tasks.clear(); + } + + @Override + public void deleteEpics() { + for (Integer epicId : epics.keySet()) { + historyManager.remove(epicId); + } + for (Integer subtaskId : subtasks.keySet()) { + historyManager.remove(subtaskId); + } + epics.clear(); + subtasks.clear(); + } + + @Override + public void deleteSubtasks() { + for (Integer subtaskId : subtasks.keySet()) { + historyManager.remove(subtaskId); + } + subtasks.clear(); + for (Epic epic : epics.values()) { + epic.clearSubtasks(); + updateEpicStatus(epic); + } + } + + @Override + public void deleteTaskByID(int id) { + if (tasks.containsKey(id)) { + tasks.remove(id); + historyManager.remove(id); + } else { + System.out.println("Задача с ID " + " не найдена"); + } + } + + @Override + public void deleteEpicByID(int id) { + if (epics.containsKey(id)) { + ArrayList epicSubtasks = epics.get(id).getSubtaskList(); + for (Subtask subtask : epicSubtasks) { + subtasks.remove(subtask.getId()); + historyManager.remove(subtask.getId()); + } + epics.remove(id); + historyManager.remove(id); + } else { + System.out.println("Эпик с ID " + id + " не найден"); + } + } + + @Override + public void deleteSubtaskByID(int id) { + if (subtasks.containsKey(id)) { + Subtask subtask = subtasks.get(id); + int epicID = subtask.getEpicID(); + subtasks.remove(id); + historyManager.remove(id); + // обновляем список подзадач и статус эпика + Epic epic = epics.get(epicID); + epic.removeSubtask(subtask); + updateEpicStatus(epic); + } else { + System.out.println("Подзадача с ID " + id + " не найдена"); + } + } + + @Override + public List getHistory() { + return historyManager.getHistory(); + } + + + private void updateEpicStatus(Epic epic) { + int allDone = 0; + int allNew = 0; + ArrayList list = epic.getSubtaskList(); + + for (Subtask subtask : list) { + if (subtask.getStatus() == Status.DONE) { + allDone++; + } + if (subtask.getStatus() == Status.NEW) { + allNew++; + } + } + if (allNew == list.size()) { + epic.setStatus(Status.NEW); + } else if (allDone == list.size()) { + epic.setStatus(Status.DONE); + } else { + epic.setStatus(Status.IN_PROGRESS); + } + } +} \ No newline at end of file diff --git a/src/manager/Managers.java b/src/manager/Managers.java new file mode 100644 index 00000000..89bf4822 --- /dev/null +++ b/src/manager/Managers.java @@ -0,0 +1,12 @@ +package manager; + +public final class Managers { + + public static TaskManager getDefault() { + return new InMemoryTaskManager(); + } + + public static HistoryManager getDefaultHistory() { + return new InMemoryHistoryManager(); + } +} diff --git a/src/manager/Node.java b/src/manager/Node.java new file mode 100644 index 00000000..fe1465c5 --- /dev/null +++ b/src/manager/Node.java @@ -0,0 +1,37 @@ +package manager; + +public class Node { + private T data; + private Node previous; + private Node next; + + public Node(T data, Node previous, Node next) { + this.previous = previous; + this.data = data; + this.next = next; + } + + public T getData() { + return data; + } + + public void setData(T data) { + this.data = data; + } + + public Node getPrevious() { + return previous; + } + + public void setPrevious(Node previous) { + this.previous = previous; + } + + public Node getNext() { + return next; + } + + public void setNext(Node next) { + this.next = next; + } +} \ No newline at end of file diff --git a/src/manager/TaskManager.java b/src/manager/TaskManager.java new file mode 100644 index 00000000..212a9871 --- /dev/null +++ b/src/manager/TaskManager.java @@ -0,0 +1,51 @@ +package manager; + +import task.Epic; +import task.Subtask; +import task.Task; + +import java.util.ArrayList; +import java.util.List; + +public interface TaskManager { + + Task addTask(Task task); + + Epic addEpic(Epic epic); + + Subtask addSubtask(Subtask subtask); + + Task updateTask(Task task); + + Epic updateEpic(Epic epic); + + Subtask updateSubtask(Subtask subtask); + + Task getTaskByID(int id); + + Epic getEpicByID(int id); + + Subtask getSubtaskByID(int id); + + List getTasks(); + + List getEpics(); + + List getSubtasks(); + + List getEpicSubtasks(int epicId); + + void deleteTasks(); + + void deleteEpics(); + + void deleteSubtasks(); + + void deleteTaskByID(int id); + + void deleteEpicByID(int id); + + void deleteSubtaskByID(int id); + + List getHistory(); +} diff --git a/src/task/Epic.java b/src/task/Epic.java new file mode 100644 index 00000000..b261f219 --- /dev/null +++ b/src/task/Epic.java @@ -0,0 +1,45 @@ +package task; + +import enums.Status; + +import java.util.ArrayList; + +public class Epic extends Task { + + private ArrayList subtaskList = new ArrayList<>(); + + public Epic(String name, String description) { + super(name, description); + } + + public Epic(int id, String name, String description, Status status) { + super(id, name, description, status); + } + + public void addSubtask(Subtask subtask) { + subtaskList.add(subtask); + } + + public void removeSubtask(Subtask subtask) { + subtaskList.remove(subtask); + } + + public void clearSubtasks() { + subtaskList.clear(); + } + + public ArrayList getSubtaskList() { + return new ArrayList<>(subtaskList); + } + + @Override + public String toString() { + return "tusk.Epic{" + + "name= " + getName() + '\'' + + ", description = " + getDescription() + '\'' + + ", id=" + getId() + + ", subtasks.size = " + subtaskList.size() + + ", status = " + getStatus() + + '}'; + } +} \ No newline at end of file diff --git a/src/task/Subtask.java b/src/task/Subtask.java new file mode 100644 index 00000000..254bc0a4 --- /dev/null +++ b/src/task/Subtask.java @@ -0,0 +1,33 @@ +package task; + +import enums.Status; + +public class Subtask extends Task { + + private final int epicID; + + public Subtask(String name, String description, int epicID) { + super(name, description); + this.epicID = epicID; + } + + public Subtask(int id, String name, String description, Status status, int epicID) { + super(id, name, description, status); + this.epicID = epicID; + } + + public int getEpicID() { + return epicID; + } + + @Override + public String toString() { + return "tusk.Subtask{" + + "name='" + getName() + '\'' + + ", description='" + getDescription() + '\'' + + ", id=" + getId() + + ", epicID=" + epicID + + ", status=" + getStatus() + + '}'; + } +} \ No newline at end of file diff --git a/src/task/Task.java b/src/task/Task.java new file mode 100644 index 00000000..3ba48e0a --- /dev/null +++ b/src/task/Task.java @@ -0,0 +1,80 @@ +package task; + +import enums.Status; + +import java.util.Objects; + +public class Task { + + private String name; + private String description; + private int id; + private Status status; + + public Task(int id, String name, String description, Status status) { + this.id = id; + this.name = name; + this.description = description; + this.status = status; + } + + public Task(String name, String description) { + this.name = name; + this.description = description; + this.status = Status.NEW; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getDescription() { + return description; + } + + public void setDescription(String description) { + this.description = description; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public Status getStatus() { + return status; + } + + public void setStatus(Status status) { + this.status = status; + } + + @Override + public String toString() { + return "tusk.Task{" + + "name='" + name + '\'' + + ", description='" + description + '\'' + + ", id=" + id + + ", status=" + status + + '}'; + } + + @Override + public boolean equals(Object o) { + if (o == null || getClass() != o.getClass()) return false; + Task task = (Task) o; + return id == task.id; + } + + @Override + public int hashCode() { + return Objects.hashCode(id); + } +} \ No newline at end of file diff --git a/tests/manager/InMemoryHistoryManagerTest.java b/tests/manager/InMemoryHistoryManagerTest.java new file mode 100644 index 00000000..7a669943 --- /dev/null +++ b/tests/manager/InMemoryHistoryManagerTest.java @@ -0,0 +1,143 @@ +package manager; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import enums.Status; +import task.Epic; +import task.Subtask; +import task.Task; +import java.util.ArrayList; +import java.util.List; +import static org.junit.jupiter.api.Assertions.*; + +class InMemoryHistoryManagerTest { + + private static TaskManager taskManager; + private static HistoryManager historyManager; + + @BeforeEach + public void beforeEach() { + taskManager = Managers.getDefault(); + historyManager = Managers.getDefaultHistory(); + } + + @Test + public void getHistoryShouldReturnAllTasks() { + for (int i = 0; i < 15; i++) { + Task task = new Task("Задача " + i, "Описание " + i); + taskManager.addTask(task); + taskManager.getTaskByID(task.getId()); + } + + List tasksHistory = taskManager.getHistory(); + assertEquals(15, tasksHistory.size(), "История должна хранить все задачи"); + } + + @Test + public void getHistoryShouldNotContainDuplicates() { + Task task = new Task("Задача", "Описание"); + taskManager.addTask(task); + + for (int i = 0; i < 5; i++) { + taskManager.getTaskByID(task.getId()); + } + + List tasksHistory = taskManager.getHistory(); + assertEquals(1, tasksHistory.size(), "История не должна содержать дубликатов"); + } + + @Test + public void getHistoryShouldReturnOldTaskAfterUpdate() { + Task task1 = new Task("Задача 1", "Описание задачи 1"); + + taskManager.addTask(task1); + taskManager.getTaskByID(task1.getId()); + taskManager.updateTask(new Task("Задача изменилась", + "Описание задачи изменилось")); + + List tasks = taskManager.getHistory(); + Task oldTask = tasks.getFirst(); + + assertEquals(task1.getName(), oldTask.getName(), "В истории не сохранилась старая версия задачи"); + assertEquals(task1.getDescription(), oldTask.getDescription(), + "В истории не сохранилась старая версия задачи"); + } + + @Test + public void removeShouldDeleteTaskFromHistory() { + Task task1 = new Task("Задача 1", "Описание 1"); + Task task2 = new Task("Задача 2", "Описание 2"); + taskManager.addTask(task1); + taskManager.addTask(task2); + + // Добавляем задачи в историю + taskManager.getTaskByID(task1.getId()); + taskManager.getTaskByID(task2.getId()); + + // Удаляем задачу из истории через TaskManager + taskManager.deleteTaskByID(task1.getId()); + + // Получаем историю + List tasksHistory = taskManager.getHistory(); + + // Проверяем, что задача удалена из истории + assertFalse(tasksHistory.contains(task1), "Задача должна быть удалена из истории"); + assertTrue(tasksHistory.contains(task2), "Задача должна остаться в истории"); + } + + @Test + public void subtaskShouldBeRemovedFromEpic() { + Epic epic = new Epic("Эпик", "Описание эпика"); + taskManager.addEpic(epic); + + Subtask subtask = new Subtask("Подзадача", "Описание подзадачи", epic.getId()); + taskManager.addSubtask(subtask); + + taskManager.deleteSubtaskByID(subtask.getId()); + + Epic updatedEpic = taskManager.getEpicByID(epic.getId()); + assertFalse(updatedEpic.getSubtaskList().contains(subtask), "Подзадача должна быть удалена из эпика"); + } + + @Test + void deletedSubtaskShouldNotExist() { + Epic epic = new Epic("Эпик 1", "Описание эпика 1"); + taskManager.addEpic(epic); + + Subtask subtask = new Subtask("Подзадача 1", "Описание подзадачи 1", epic.getId()); + taskManager.addSubtask(subtask); + + int subtaskId = subtask.getId(); + + taskManager.deleteSubtaskByID(subtaskId); + + assertNull(taskManager.getSubtaskByID(subtaskId), "Подзадача должна быть удалена из менеджера."); + + Epic updatedEpic = taskManager.getEpicByID(epic.getId()); + assertFalse(updatedEpic.getSubtaskList().contains(subtask), "Эпик не должен содержать удаленную подзадачу."); + } + + @Test + void epicShouldNotContainOutdatedSubtaskIds() { + Epic epic = new Epic("Эпик 1", "Описание эпика 1"); + taskManager.addEpic(epic); + + Subtask subtask = new Subtask("Подзадача 1", "Описание подзадачи 1", epic.getId()); + taskManager.addSubtask(subtask); + + int subtaskId = subtask.getId(); + + taskManager.deleteSubtaskByID(subtaskId); + + Epic updatedEpic = taskManager.getEpicByID(epic.getId()); + + assertFalse(updatedEpic.getSubtaskList().contains(subtaskId), + "Эпик не должен содержать id удаленной подзадачи."); + } +} + + + + + + diff --git a/tests/manager/InMemoryTaskManagerTest.java b/tests/manager/InMemoryTaskManagerTest.java new file mode 100644 index 00000000..fede5988 --- /dev/null +++ b/tests/manager/InMemoryTaskManagerTest.java @@ -0,0 +1,104 @@ +package manager; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.BeforeEach; +import static org.junit.jupiter.api.Assertions.*; +import java.util.ArrayList; +import java.util.List; +import enums.Status; +import task.Task; +import task.Subtask; +import task.Epic; + +class InMemoryTaskManagerTest { + + private static TaskManager taskManager; + + @BeforeEach + public void beforeEach() { + taskManager = Managers.getDefault(); + } + + @Test + void aNewTaskShouldBeCreated() { + Task task1 = taskManager.addTask(new Task("Задача 1", "Описание задачи 1")); + final Task savedTask = taskManager.getTaskByID(task1.getId()); + + assertNotNull(savedTask, "Задача не найдена."); + assertEquals(task1, savedTask, "Задачи не совпадают."); + + final List tasks = taskManager.getTasks(); + + assertNotNull(tasks, "Задачи не возвращаются."); + assertEquals(1, tasks.size(), "Неверное количество задач."); + assertEquals(task1, tasks.getFirst(), "Задачи не совпадают."); + } + + @Test + void aNewEpicAndSubtaskShouldBeCreated() { + Epic epic1 = taskManager.addEpic(new Epic("Эпик 1", + "Описание эпика 1")); + Subtask epic1Subtask1 = taskManager.addSubtask(new Subtask("Подзадача 1", + "Описание подзадачи 1", epic1.getId())); + Subtask epic1Subtask2 = taskManager.addSubtask(new Subtask("Подзадача 2", + "Описание подзадачи 2", epic1.getId())); + + final Epic savedEpic = taskManager.getEpicByID(epic1.getId()); + final Subtask savedSubtask1 = taskManager.getSubtaskByID(epic1Subtask1.getId()); + final Subtask savedSubtask2 = taskManager.getSubtaskByID(epic1Subtask2.getId()); + + assertNotNull(savedEpic, "Эпик не найден."); + assertNotNull(savedSubtask1, "Подзадача не найдена."); + assertEquals(epic1, savedEpic, "Эпики не совпадают."); + assertEquals(epic1Subtask1, savedSubtask1, "Подзадачи не совпадают."); + + final List epics = taskManager.getEpics(); + + assertNotNull(epics, "Эпики не возвращаются."); + assertEquals(1, epics.size(), "Неверное количество эпиков."); + + final List subtasks = taskManager.getSubtasks(); + + assertNotNull(subtasks, "Подзадачи не возвращаются."); + assertEquals(2, subtasks.size(), "Неверное количество подзадач."); + assertEquals(savedSubtask1, subtasks.getFirst(), "Подзадачи не совпадают."); + } + + @Test + void tasksWithTheSpecifiedIdAndTheGeneratedShouldNotConflict() { + Task task1 = new Task(1, "Задача 1", "Описание задачи 1", Status.NEW); + taskManager.addTask(task1); + + Task task2 = new Task("Задача 2", "Описание задачи 2"); + taskManager.addTask(task2); + + Task savedTask1 = taskManager.getTaskByID(1); + Task savedTask2 = taskManager.getTaskByID(task2.getId()); + + assertNotNull(savedTask1, "Задача с заданным ID не найдена."); + assertNotNull(savedTask2, "Задача с сгенерированным ID не найдена."); + assertNotEquals(savedTask1.getId(), savedTask2.getId(), "ID задач конфликтуют."); + } + + @Test + void createdTaskShouldNotChangeWhenAddedToManager() { + Task expected = new Task(1, "Задача1", "Описание задачи 1", Status.DONE); + taskManager.addTask(expected); + List tasks = taskManager.getTasks(); + Task actual = tasks.getFirst(); + assertEquals(expected.getId(), actual.getId()); + assertEquals(expected.getName(), actual.getName()); + assertEquals(expected.getDescription(), actual.getDescription()); + assertEquals(expected.getStatus(), actual.getStatus()); + } + + @Test + public void testSubtaskCannotBeItsOwnEpicReturnsNull() { + Subtask subtask = new Subtask("Подзадача 1", "Описание", 1); + taskManager.updateSubtask(new Subtask("Подзадача 1","Описание", subtask.getId())); + Subtask result = taskManager.addSubtask(subtask); + + assertNull(result, "Подзадача не должна быть добавлена как свой эпик, метод должен вернуть null."); + } +} + diff --git a/tests/manager/ManagersTest.java b/tests/manager/ManagersTest.java new file mode 100644 index 00000000..06400313 --- /dev/null +++ b/tests/manager/ManagersTest.java @@ -0,0 +1,23 @@ +package manager; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class ManagersTest { + + @Test + void getDefaultShouldInitializeInMemoryTaskManager() { + TaskManager taskManager = Managers.getDefault(); + assertNotNull(taskManager, "TaskManager должен быть инициализирован и не равен null."); + assertInstanceOf(InMemoryTaskManager.class, Managers.getDefault()); + } + + @Test + void getDefaultHistoryShouldInitializeInMemoryHistoryManager() { + HistoryManager historyManager = Managers.getDefaultHistory(); + assertNotNull(historyManager, "HistoryManager должен быть инициализирован и не равен null."); + assertInstanceOf(InMemoryHistoryManager.class, Managers.getDefaultHistory()); + } +} + diff --git a/tests/task/EpicTest.java b/tests/task/EpicTest.java new file mode 100644 index 00000000..7be44529 --- /dev/null +++ b/tests/task/EpicTest.java @@ -0,0 +1,20 @@ +package task; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +import enums.Status; + +class EpicTest { + + @Test + public void EpicsWithEqualIdShouldBeEqual() { + Epic epic1 = new Epic(10, "Прибраться на даче", "Вывызети строительный мусор", Status.NEW); + Epic epic2 = new Epic(10, "Купить стройматериалы", "Для строительства бани", + Status.IN_PROGRESS); + assertEquals(epic1, epic2, + "Ошибка! Наследники класса Task должны быть равны друг другу, если равен их id;"); + } +} + diff --git a/tests/task/SubtaskTest.java b/tests/task/SubtaskTest.java new file mode 100644 index 00000000..8135b16c --- /dev/null +++ b/tests/task/SubtaskTest.java @@ -0,0 +1,18 @@ +package task; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +import enums.Status; + +class SubtaskTest { + + @Test + public void SubtasksWithEqualIdShouldBeEqual() { + Subtask subtask1 = new Subtask(10, "Купить билет на новый фильм", "На сайте, там дешевле", Status.NEW, 5); + Subtask subtask2 = new Subtask(10, "Не забыть попкорн", "Купить в магазине", Status.DONE, 5); + assertEquals(subtask1, subtask2, + "Ошибка! Наследники класса Task должны быть равны друг другу, если равен их id;"); + } +} diff --git a/tests/task/TaskTest.java b/tests/task/TaskTest.java new file mode 100644 index 00000000..c4d2b875 --- /dev/null +++ b/tests/task/TaskTest.java @@ -0,0 +1,18 @@ +package task; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +import enums.Status; + +class TaskTest { + + @Test + public void tasksWithEqualIdShouldBeEqual() { + Task task1 = new Task(10, "Купить продукты для похода", "В супермаркете", Status.NEW); + Task task2 = new Task(10, "Купить молоко", "В Пятерочке", Status.DONE); + assertEquals(task1, task2, + "Ошибка! Экземпляры класса Task должны быть равны друг другу, если равен их id;"); + } +} \ No newline at end of file