diff --git a/src/ru/practicum/task_tracker/CSVFormatter.java b/src/ru/practicum/task_tracker/CSVFormatter.java
index 9a74842..1e21712 100644
--- a/src/ru/practicum/task_tracker/CSVFormatter.java
+++ b/src/ru/practicum/task_tracker/CSVFormatter.java
@@ -28,7 +28,7 @@ public static String toString(Task task) {
     public static Task taskFromString(String csvRow) {
         String[] columns = csvRow.split(",");
         return new Task(Integer.parseInt(columns[1]), columns[2], columns[3], getStatus(columns[4]),
-                Long.parseLong(columns[5]), LocalDateTime.parse(columns[6]));
+                Integer.parseInt(columns[5]), LocalDateTime.parse(columns[6]));
     }
 
     public static Epic epicFromString(String csvRow) {
@@ -39,7 +39,7 @@ public static Epic epicFromString(String csvRow) {
     public static Subtask subtaskFromString(String csvRow) {
         String[] columns = csvRow.split(",");
         return new Subtask(Integer.parseInt(columns[7]), Integer.parseInt(columns[1]), columns[2],
-                columns[3], getStatus(columns[4]), Long.parseLong(columns[5]), LocalDateTime.parse(columns[6]));
+                columns[3], getStatus(columns[4]), Integer.parseInt(columns[5]), LocalDateTime.parse(columns[6]));
     }
 
     private static Status getStatus(String str) {
diff --git a/src/ru/practicum/task_tracker/http/Exception/BadRequestException.java b/src/ru/practicum/task_tracker/http/Exception/BadRequestException.java
new file mode 100644
index 0000000..6592178
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/Exception/BadRequestException.java
@@ -0,0 +1,8 @@
+package ru.practicum.task_tracker.http.Exception;
+
+public class BadRequestException extends RuntimeException {
+
+    public BadRequestException(String msg) {
+        super(msg);
+    }
+}
diff --git a/src/ru/practicum/task_tracker/http/Exception/NotAcceptableException.java b/src/ru/practicum/task_tracker/http/Exception/NotAcceptableException.java
new file mode 100644
index 0000000..1ae73bf
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/Exception/NotAcceptableException.java
@@ -0,0 +1,9 @@
+package ru.practicum.task_tracker.http.Exception;
+
+public class NotAcceptableException extends RuntimeException {
+
+    public NotAcceptableException(String msg) {
+        super(msg);
+    }
+
+}
diff --git a/src/ru/practicum/task_tracker/http/Exception/NotFoundException.java b/src/ru/practicum/task_tracker/http/Exception/NotFoundException.java
new file mode 100644
index 0000000..55add31
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/Exception/NotFoundException.java
@@ -0,0 +1,8 @@
+package ru.practicum.task_tracker.http.Exception;
+
+public class NotFoundException extends RuntimeException {
+
+    public NotFoundException(String msg) {
+        super(msg);
+    }
+}
diff --git a/src/ru/practicum/task_tracker/http/HttpTaskServer.java b/src/ru/practicum/task_tracker/http/HttpTaskServer.java
new file mode 100644
index 0000000..b3a707e
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/HttpTaskServer.java
@@ -0,0 +1,54 @@
+package ru.practicum.task_tracker.http;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.sun.net.httpserver.HttpServer;
+import ru.practicum.task_tracker.Managers;
+import ru.practicum.task_tracker.http.adapter.DurationAdapter;
+import ru.practicum.task_tracker.http.adapter.LocalDateTimeAdapter;
+import ru.practicum.task_tracker.http.handler.*;
+import ru.practicum.task_tracker.manager.TaskManager;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.time.Duration;
+import java.time.LocalDateTime;
+
+public class HttpTaskServer {
+    public static final int PORT = 8080;
+
+    private final HttpServer httpServer;
+    private final TaskManager taskManager;
+
+    public HttpTaskServer(TaskManager taskManager) throws IOException {
+        this.taskManager = taskManager;
+        this.httpServer = HttpServer.create(new InetSocketAddress("localHost", PORT), 0);
+        this.httpServer.createContext("/tasks", new TaskHandler(taskManager));
+        this.httpServer.createContext("/subtasks", new SubtaskHandler(taskManager));
+        this.httpServer.createContext("/epics", new EpicHandler(taskManager));
+        this.httpServer.createContext("/history", new HistoryHandler(taskManager));
+        this.httpServer.createContext("/prioritized", new PrioritizedHandler(taskManager));
+    }
+
+    public void start() {
+        httpServer.start();
+    }
+
+    public void stop() {
+        httpServer.stop(0);
+    }
+
+    public static void main(String[] args) throws IOException {
+        TaskManager taskManager = Managers.getDefault();
+        HttpTaskServer httpTaskServer = new HttpTaskServer(taskManager);
+        httpTaskServer.start();
+    }
+
+    public static Gson getGson() {
+        GsonBuilder gsonBuilder = new GsonBuilder();
+        gsonBuilder.registerTypeAdapter(LocalDateTime.class, new LocalDateTimeAdapter());
+        gsonBuilder.registerTypeAdapter(Duration.class, new DurationAdapter());
+        return gsonBuilder.create();
+    }
+
+}
diff --git a/src/ru/practicum/task_tracker/http/adapter/DurationAdapter.java b/src/ru/practicum/task_tracker/http/adapter/DurationAdapter.java
new file mode 100644
index 0000000..959c9d0
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/adapter/DurationAdapter.java
@@ -0,0 +1,24 @@
+package ru.practicum.task_tracker.http.adapter;
+
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+import java.time.Duration;
+
+public class DurationAdapter extends TypeAdapter<Duration> {
+    @Override
+    public void write(JsonWriter jsonWriter, Duration duration) throws IOException {
+        if (duration == null) {
+            jsonWriter.value("null");
+        } else {
+            jsonWriter.value(duration.toMinutes());
+        }
+    }
+
+    @Override
+    public Duration read(JsonReader jsonReader) throws IOException {
+        return Duration.ofMinutes(jsonReader.nextInt());
+    }
+}
diff --git a/src/ru/practicum/task_tracker/http/adapter/LocalDateTimeAdapter.java b/src/ru/practicum/task_tracker/http/adapter/LocalDateTimeAdapter.java
new file mode 100644
index 0000000..7b36665
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/adapter/LocalDateTimeAdapter.java
@@ -0,0 +1,29 @@
+package ru.practicum.task_tracker.http.adapter;
+
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+public class LocalDateTimeAdapter extends TypeAdapter<LocalDateTime> {
+    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
+
+    @Override
+    public void write(JsonWriter jsonWriter, LocalDateTime localDateTime) throws IOException {
+        if (localDateTime == null) {
+            String str = "null";
+            jsonWriter.value(str);
+        } else {
+            jsonWriter.value(localDateTime.format(FORMATTER));
+        }
+    }
+
+    @Override
+    public LocalDateTime read(JsonReader jsonReader) throws IOException {
+        String str = jsonReader.nextString();
+        return LocalDateTime.parse(str, FORMATTER);
+    }
+}
diff --git a/src/ru/practicum/task_tracker/http/handler/BaseHttpHandler.java b/src/ru/practicum/task_tracker/http/handler/BaseHttpHandler.java
new file mode 100644
index 0000000..515b617
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/handler/BaseHttpHandler.java
@@ -0,0 +1,51 @@
+package ru.practicum.task_tracker.http.handler;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.sun.net.httpserver.HttpExchange;
+import ru.practicum.task_tracker.task.Status;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+public abstract class BaseHttpHandler {
+
+    protected void sendText(HttpExchange h, String text, int statusCode) throws IOException {
+        byte[] resp = text.getBytes(StandardCharsets.UTF_8);
+        h.getResponseHeaders().add("Content-Type", "application/json;charset=utf-8");
+        h.sendResponseHeaders(statusCode, resp.length);
+        h.getResponseBody().write(resp);
+        h.close();
+    }
+
+    protected static void sendException(HttpExchange h, String text, int statusCode) throws IOException {
+        byte[] resp = text.getBytes(StandardCharsets.UTF_8);
+        h.sendResponseHeaders(statusCode, resp.length);
+        h.getResponseHeaders().add("Content-Type", "application/json;charset=utf-8");
+        h.getResponseBody().write(resp);
+        h.close();
+    }
+
+
+    protected Integer jsonObjectGetId(String body) {
+        JsonObject jsonObject = JsonParser.parseString(body).getAsJsonObject();
+        return jsonObject.get("id") != null ? jsonObject.get("id").getAsInt() : null;
+    }
+
+    protected Status getStatus(String str) {
+        return switch (str) {
+            case "IN_PROGRESS" -> Status.IN_PROGRESS;
+            case "DONE" -> Status.DONE;
+            default -> Status.NEW;
+        };
+    }
+
+    protected Integer getIdFromPath(String path) {
+        String[] parts = path.split("/");
+        if (parts.length >= 3) {
+            return Integer.parseInt(parts[2]);
+        }
+        return null;
+    }
+
+}
diff --git a/src/ru/practicum/task_tracker/http/handler/EpicHandler.java b/src/ru/practicum/task_tracker/http/handler/EpicHandler.java
new file mode 100644
index 0000000..5c65cc3
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/handler/EpicHandler.java
@@ -0,0 +1,108 @@
+package ru.practicum.task_tracker.http.handler;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import ru.practicum.task_tracker.http.Exception.BadRequestException;
+import ru.practicum.task_tracker.http.Exception.NotAcceptableException;
+import ru.practicum.task_tracker.http.HttpTaskServer;
+import ru.practicum.task_tracker.manager.TaskManager;
+import ru.practicum.task_tracker.task.Epic;
+import ru.practicum.task_tracker.task.Subtask;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+public class EpicHandler extends BaseHttpHandler implements HttpHandler {
+
+    private final TaskManager taskManager;
+
+    public EpicHandler(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
+    @Override
+    public void handle(HttpExchange exchange) throws IOException {
+        try {
+            InputStream inputStream = exchange.getRequestBody();
+            String body = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
+            String path = exchange.getRequestURI().getPath();
+            Integer id = getIdFromPath(path);
+
+            switch (exchange.getRequestMethod()) {
+                case "GET":
+                    if (id == null) {
+                        List<Epic> epics = taskManager.getEpics();
+                        String response = HttpTaskServer.getGson().toJson(epics);
+                        sendText(exchange, response, 200);
+                    } else {
+                        Epic epic = taskManager.getByEpicId(id);
+                        System.out.println(epic.getDuration());
+
+                        if (booleanSubtasksPath(path)) {
+                            List<Subtask> subtasks = epic.getSubtasks();
+                            String response = HttpTaskServer.getGson().toJson(subtasks);
+                            sendText(exchange, response, 200);
+                        }
+                        String response = HttpTaskServer.getGson().toJson(epic);
+                        sendText(exchange, response, 200);
+                    }
+                    break;
+                case "POST":
+                    Epic createdEpic = taskManager.createEpic(getNewEpic(body));
+                    String responsePost = HttpTaskServer.getGson().toJson("Задача создана. id = " + createdEpic.getId());
+                    sendText(exchange, responsePost, 201);
+                    break;
+                case "DELETE":
+                    if (id == null) {
+                        throw new NotAcceptableException("Не передан id.");
+                    }
+                    taskManager.deleteEpic(id);
+                    String response = HttpTaskServer.getGson().toJson("Задача удалена.");
+                    sendText(exchange, response, 200);
+                    break;
+                default:
+                    throw new NotAcceptableException("Нет обработки текущей команды.");
+            }
+        } catch (Exception e) {
+            ErrorHandler.handleException(exchange, e);
+        } finally {
+            exchange.close();
+        }
+    }
+
+    private Epic getNewEpic(String body) {
+        JsonElement jsonElement = JsonParser.parseString(body);
+
+        if (jsonElement.isJsonNull()) {
+            throw new BadRequestException("Нет входных параметров");
+        }
+
+        JsonObject jsonObject = jsonElement.getAsJsonObject();
+
+        String name = jsonObject.get("name") != null ? jsonObject.get("name").getAsString() : null;
+        String description = jsonObject.get("description") != null ?
+                jsonObject.get("description").getAsString() : null;
+
+        if (name == null || description == null) {
+            throw new BadRequestException("От пользователя некорректно передана задача");
+        } else {
+            return new Epic(name, description);
+        }
+
+    }
+
+    protected Boolean booleanSubtasksPath(String path) {
+        String[] parts = path.split("/");
+        if (parts.length >= 4) {
+            return parts[3].equals("subtasks");
+        }
+        return false;
+
+    }
+
+}
diff --git a/src/ru/practicum/task_tracker/http/handler/ErrorHandler.java b/src/ru/practicum/task_tracker/http/handler/ErrorHandler.java
new file mode 100644
index 0000000..db4656c
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/handler/ErrorHandler.java
@@ -0,0 +1,29 @@
+package ru.practicum.task_tracker.http.handler;
+
+import com.sun.net.httpserver.HttpExchange;
+import ru.practicum.task_tracker.http.Exception.BadRequestException;
+import ru.practicum.task_tracker.http.Exception.NotAcceptableException;
+import ru.practicum.task_tracker.http.Exception.NotFoundException;
+
+import java.io.IOException;
+
+
+public class ErrorHandler extends BaseHttpHandler {
+
+    public static void handleException(HttpExchange h, Exception e) throws IOException {
+        int status;
+
+        try {
+            status = switch (e) {
+                case BadRequestException badRequestException -> 400;
+                case NotFoundException notFoundException -> 404;
+                case NotAcceptableException notAcceptableException -> 406;
+                case null, default -> throw e;
+            };
+            sendException(h, e.getMessage(), status);
+        } catch (Exception ex) {
+            System.out.println(ex.getMessage());
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/ru/practicum/task_tracker/http/handler/HistoryHandler.java b/src/ru/practicum/task_tracker/http/handler/HistoryHandler.java
new file mode 100644
index 0000000..45faac6
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/handler/HistoryHandler.java
@@ -0,0 +1,37 @@
+package ru.practicum.task_tracker.http.handler;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import ru.practicum.task_tracker.http.Exception.NotAcceptableException;
+import ru.practicum.task_tracker.http.HttpTaskServer;
+import ru.practicum.task_tracker.manager.TaskManager;
+import ru.practicum.task_tracker.task.Task;
+
+import java.io.IOException;
+import java.util.List;
+
+public class HistoryHandler extends BaseHttpHandler implements HttpHandler {
+    private final TaskManager taskManager;
+
+    public HistoryHandler(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
+    @Override
+    public void handle(HttpExchange exchange) throws IOException {
+
+        try {
+            if (exchange.getRequestMethod().equals("GET")) {
+                List<Task> history = taskManager.getHistory();
+                String response = HttpTaskServer.getGson().toJson(history);
+                sendText(exchange, response, 200);
+            } else {
+                throw new NotAcceptableException("Нет обработки текущей команды.");
+            }
+        } catch (Exception e) {
+            ErrorHandler.handleException(exchange, e);
+        } finally {
+            exchange.close();
+        }
+    }
+}
diff --git a/src/ru/practicum/task_tracker/http/handler/PrioritizedHandler.java b/src/ru/practicum/task_tracker/http/handler/PrioritizedHandler.java
new file mode 100644
index 0000000..13868ea
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/handler/PrioritizedHandler.java
@@ -0,0 +1,37 @@
+package ru.practicum.task_tracker.http.handler;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import ru.practicum.task_tracker.http.Exception.NotAcceptableException;
+import ru.practicum.task_tracker.http.HttpTaskServer;
+import ru.practicum.task_tracker.manager.TaskManager;
+import ru.practicum.task_tracker.task.Task;
+
+import java.io.IOException;
+import java.util.Set;
+
+public class PrioritizedHandler extends BaseHttpHandler implements HttpHandler {
+    private final TaskManager taskManager;
+
+    public PrioritizedHandler(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
+    @Override
+    public void handle(HttpExchange exchange) throws IOException {
+
+        try {
+            if (exchange.getRequestMethod().equals("GET")) {
+                Set<Task> prioritizedTasks = taskManager.getPrioritizedTasks();
+                String response = HttpTaskServer.getGson().toJson(prioritizedTasks);
+                sendText(exchange, response, 200);
+            } else {
+                throw new NotAcceptableException("Нет обработки текущей команды.");
+            }
+        } catch (Exception e) {
+            ErrorHandler.handleException(exchange, e);
+        } finally {
+            exchange.close();
+        }
+    }
+}
diff --git a/src/ru/practicum/task_tracker/http/handler/SubtaskHandler.java b/src/ru/practicum/task_tracker/http/handler/SubtaskHandler.java
new file mode 100644
index 0000000..793924a
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/handler/SubtaskHandler.java
@@ -0,0 +1,108 @@
+package ru.practicum.task_tracker.http.handler;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import ru.practicum.task_tracker.http.Exception.BadRequestException;
+import ru.practicum.task_tracker.http.Exception.NotAcceptableException;
+import ru.practicum.task_tracker.http.HttpTaskServer;
+import ru.practicum.task_tracker.manager.TaskManager;
+import ru.practicum.task_tracker.task.Status;
+import ru.practicum.task_tracker.task.Subtask;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.util.List;
+
+public class SubtaskHandler extends BaseHttpHandler implements HttpHandler {
+
+    private final TaskManager taskManager;
+
+    public SubtaskHandler(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
+    @Override
+    public void handle(HttpExchange exchange) throws IOException {
+        try {
+            InputStream inputStream = exchange.getRequestBody();
+            String body = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
+            Integer id = getIdFromPath(exchange.getRequestURI().getPath());
+
+            switch (exchange.getRequestMethod()) {
+                case "GET":
+                    if (id == null) {
+                        List<Subtask> subtasks = taskManager.getSubtasks();
+                        String response = HttpTaskServer.getGson().toJson(subtasks);
+                        sendText(exchange, response, 200);
+                    } else {
+                        Subtask subtask = taskManager.getBySubtaskId(id);
+                        String response = HttpTaskServer.getGson().toJson(subtask);
+                        sendText(exchange, response, 200);
+                    }
+                    break;
+                case "POST":
+                    Integer subtaskId = jsonObjectGetId(body);
+                    if (subtaskId == null) {
+                        Subtask createdSubtask = taskManager.createSubtask(getNewSubtask(body));
+                        String response = HttpTaskServer.getGson().toJson("Задача создана.  id = " + createdSubtask.getId());
+                        sendText(exchange, response, 201);
+                    } else {
+                        Subtask subtask = getNewSubtask(body);
+                        subtask.setId(subtaskId);
+                        taskManager.updateSubtask(subtask);
+                        String response = HttpTaskServer.getGson().toJson("Задача обновлена.");
+                        sendText(exchange, response, 200);
+                    }
+                    break;
+                case "DELETE":
+                    if (id == null) {
+                        throw new NotAcceptableException("Не передан id.");
+                    }
+                    taskManager.deleteSubtask(id);
+                    String response = HttpTaskServer.getGson().toJson("Задача удалена.");
+                    sendText(exchange, response, 200);
+                    break;
+                default:
+                    throw new NotAcceptableException("Нет обработки текущей команды.");
+            }
+        } catch (Exception e) {
+            ErrorHandler.handleException(exchange, e);
+        } finally {
+            exchange.close();
+        }
+    }
+
+    private Subtask getNewSubtask(String body) {
+        JsonElement jsonElement = JsonParser.parseString(body);
+
+        if (jsonElement.isJsonNull()) {
+            throw new BadRequestException("Нет входных параметров");
+        }
+        JsonObject jsonObject = jsonElement.getAsJsonObject();
+
+        Integer epicId = jsonObject.get("epicId") != null ? jsonObject.get("epicId").getAsInt() : null;
+        String name = jsonObject.get("name") != null ? jsonObject.get("name").getAsString() : null;
+        String description = jsonObject.get("description") != null ?
+                jsonObject.get("description").getAsString() : null;
+        Status status = getStatus(jsonObject.get("status") != null ?
+                jsonObject.get("status").getAsString() : "null");
+        Integer duration = jsonObject.get("duration") != null ? jsonObject.get("duration").getAsInt() : null;
+        String startTimeString = jsonObject.get("startTime") != null ?
+                jsonObject.get("startTime").getAsString() : "null";
+        LocalDateTime startTime = LocalDateTime.parse(startTimeString);
+
+        if (epicId == null || name == null || duration == null) {
+            throw new BadRequestException("От пользователя некорректно передана задача");
+        } else {
+            return new Subtask(epicId, name, description, status, duration, startTime);
+        }
+
+    }
+
+
+}
diff --git a/src/ru/practicum/task_tracker/http/handler/TaskHandler.java b/src/ru/practicum/task_tracker/http/handler/TaskHandler.java
new file mode 100644
index 0000000..ee3af68
--- /dev/null
+++ b/src/ru/practicum/task_tracker/http/handler/TaskHandler.java
@@ -0,0 +1,110 @@
+package ru.practicum.task_tracker.http.handler;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import ru.practicum.task_tracker.http.Exception.BadRequestException;
+import ru.practicum.task_tracker.http.Exception.NotAcceptableException;
+import ru.practicum.task_tracker.http.HttpTaskServer;
+import ru.practicum.task_tracker.manager.TaskManager;
+import ru.practicum.task_tracker.task.Status;
+import ru.practicum.task_tracker.task.Task;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.time.LocalDateTime;
+import java.util.List;
+
+public class TaskHandler extends BaseHttpHandler implements HttpHandler {
+
+    private final TaskManager taskManager;
+
+    public TaskHandler(TaskManager taskManager) {
+        this.taskManager = taskManager;
+    }
+
+    @Override
+    public void handle(HttpExchange exchange) throws IOException {
+        try {
+            InputStream inputStream = exchange.getRequestBody();
+            String body = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
+            Integer id = getIdFromPath(exchange.getRequestURI().getPath());
+
+            switch (exchange.getRequestMethod()) {
+                case "GET":
+                    if (id == null) {
+                        List<Task> tasks = taskManager.getTasks();
+                        String response = HttpTaskServer.getGson().toJson(tasks);
+                        sendText(exchange, response, 200);
+                    } else {
+                        Task task = taskManager.getByTaskId(id);
+                        String response = HttpTaskServer.getGson().toJson(task);
+                        sendText(exchange, response, 200);
+                    }
+                    break;
+                case "POST":
+                    Integer taskId = jsonObjectGetId(body);
+                    if (taskId == null) {
+                        Task createdTask = taskManager.createTask(getNewTask(body));
+                        String response = HttpTaskServer.getGson().toJson("Задача создана.  id = " + createdTask.getId());
+                        sendText(exchange, response, 201);
+                    } else {
+                        Task task = getNewTask(body);
+                        task.setId(taskId);
+                        taskManager.updateTask(task);
+                        String response = HttpTaskServer.getGson().toJson("Задача обновлена.");
+                        sendText(exchange, response, 200);
+                    }
+                    break;
+                case "DELETE":
+                    if (id == null) {
+                        throw new NotAcceptableException("Не передан id.");
+                    }
+                    taskManager.deleteTask(id);
+                    String response = HttpTaskServer.getGson().toJson("Задача удалена.");
+                    sendText(exchange, response, 200);
+                    break;
+                default:
+                    throw new NotAcceptableException("Нет обработки текущей команды.");
+            }
+        } catch (Exception e) {
+            ErrorHandler.handleException(exchange, e);
+        } finally {
+            exchange.close();
+        }
+    }
+
+    private Task getNewTask(String body) {
+        JsonElement jsonElement = JsonParser.parseString(body);
+
+        if (jsonElement.isJsonNull()) {
+            throw new BadRequestException("Нет входных параметров");
+        }
+        JsonObject jsonObject = jsonElement.getAsJsonObject();
+
+        String name = jsonObject.get("name") != null ? jsonObject.get("name").getAsString() : null;
+        String description = jsonObject.get("description") != null ?
+                jsonObject.get("description").getAsString() : null;
+        Status status = getStatus(jsonObject.get("status") != null ?
+                jsonObject.get("status").getAsString() : "null");
+        Integer duration = jsonObject.get("duration") != null ? jsonObject.get("duration").getAsInt() : null;
+        String startTimeString = jsonObject.get("startTime") != null ?
+                jsonObject.get("startTime").getAsString() : "null";
+        LocalDateTime startTime = LocalDateTime.parse(startTimeString);
+//        Gson gson = new GsonBuilder().create();
+//        LocalDateTime startTime = HttpTaskServer.getGson().fromJson(startTimeString, LocalDateTime.class);
+//        LocalDateTime startTime = gson.fromJson(startTimeString, new LocalDateTimeToken().getType());
+
+        if (name == null || duration == null) {
+            throw new BadRequestException("От пользователя некорректно передана задача");
+        } else {
+            return new Task(name, description, status, duration, startTime);
+        }
+    }
+
+
+}
+
diff --git a/src/ru/practicum/task_tracker/manager/FileBackedTaskManager.java b/src/ru/practicum/task_tracker/manager/FileBackedTaskManager.java
index 73ce071..0727b90 100644
--- a/src/ru/practicum/task_tracker/manager/FileBackedTaskManager.java
+++ b/src/ru/practicum/task_tracker/manager/FileBackedTaskManager.java
@@ -135,7 +135,7 @@ public Epic updateEpic(Epic epic) {
     }
 
     @Override
-    public boolean deleteEpic(int epicId) {
+    public boolean deleteEpic(Integer epicId) {
         boolean deleteEpic = super.deleteEpic(epicId);
         save();
         return deleteEpic;
@@ -156,7 +156,7 @@ public Subtask updateSubtask(Subtask subtask) {
     }
 
     @Override
-    public boolean deleteSubtask(int subtaskId) {
+    public boolean deleteSubtask(Integer subtaskId) {
         boolean deleteSubtask = super.deleteSubtask(subtaskId);
         save();
         return deleteSubtask;
diff --git a/src/ru/practicum/task_tracker/manager/InMemoryTaskManager.java b/src/ru/practicum/task_tracker/manager/InMemoryTaskManager.java
index 0b4efa1..3048f9f 100644
--- a/src/ru/practicum/task_tracker/manager/InMemoryTaskManager.java
+++ b/src/ru/practicum/task_tracker/manager/InMemoryTaskManager.java
@@ -1,7 +1,8 @@
 package ru.practicum.task_tracker.manager;
 
-import ru.practicum.task_tracker.ManagerSaveException;
 import ru.practicum.task_tracker.Managers;
+import ru.practicum.task_tracker.http.Exception.NotAcceptableException;
+import ru.practicum.task_tracker.http.Exception.NotFoundException;
 import ru.practicum.task_tracker.task.Epic;
 import ru.practicum.task_tracker.task.Status;
 import ru.practicum.task_tracker.task.Subtask;
@@ -62,7 +63,7 @@ public List<Task> getTasks() {
 
     public Task getByTaskId(Integer taskId) {
         if (!tasks.containsKey(taskId) || taskId == null) {
-            return null;
+            throw new NotFoundException("Таска не найдена.");
         }
         Task task = tasks.get(taskId);
         historyManager.add(task);
@@ -72,7 +73,7 @@ public Task getByTaskId(Integer taskId) {
     @Override
     public Task createTask(Task task) {
         if (checkPeriodCrossing(task)) {
-            throw new ManagerSaveException("Период задачи пересекается с текущими");
+            throw new NotAcceptableException("Время сохраняемой таски пересекается с текущими задачами.");
         }
         task.setId(getNextId());
         int id = task.getId();
@@ -85,15 +86,15 @@ public Task createTask(Task task) {
     @Override
     public Task updateTask(Task task) {
         Integer taskId = task.getId();
+        if (taskId == null || !tasks.containsKey(taskId)) {
+            throw new NotFoundException("Обновляемая таска не найдена");
+        }
         Task oldTask = tasks.get(taskId);
-        if (oldTask.getStartTime() != task.getStartTime() || oldTask.getDuration() != task.getDuration()) {
+        if (!oldTask.getStartTime().equals(task.getStartTime()) || oldTask.getDuration() != task.getDuration()) {
             if (checkPeriodCrossing(task)) {
-                throw new RuntimeException("Период задачи пересекается с текущими");
+                throw new NotAcceptableException("Время обновленной таски пересекается с текущими задачами.");
             }
         }
-        if (taskId == null || !tasks.containsKey(taskId)) {
-            return null;
-        }
         tasks.put(taskId, task);
         sortedEntity.remove(oldTask);
         sortedEntity.add(task);
@@ -118,7 +119,7 @@ public List<Epic> getEpics() {
 
     public Epic getByEpicId(Integer epicId) {
         if (epicId == null || !epics.containsKey(epicId)) {
-            return null;
+            throw new NotFoundException("Эпик не найден");
         }
         Epic epic = epics.get(epicId);
         historyManager.add(epic);
@@ -138,7 +139,7 @@ public Epic createEpic(Epic epic) {
     public Epic updateEpic(Epic epic) {
         Integer epicId = epic.getId();
         if (epicId == null || !epics.containsKey(epicId)) {
-            return null;
+            throw new NotFoundException("Обновляемый эпик не найден");
         }
         epics.put(epicId, epic);
         updateStatusEpic(epic);
@@ -146,7 +147,10 @@ public Epic updateEpic(Epic epic) {
     }
 
     @Override
-    public boolean deleteEpic(int epicId) {
+    public boolean deleteEpic(Integer epicId) {
+        if (epicId == null || !epics.containsKey(epicId)) {
+            return true;
+        }
         Epic oldEpic = epics.get(epicId);
         for (Subtask subtask : oldEpic.getSubtasks()) {
             subtasks.remove(subtask.getId());
@@ -198,7 +202,7 @@ public List<Subtask> getSubtasks() {
 
     public Subtask getBySubtaskId(Integer subtaskId) {
         if (subtaskId == null || !subtasks.containsKey(subtaskId)) {
-            return null;
+            throw new NotFoundException("Сабтаск не найден.");
         }
         Subtask subtask = subtasks.get(subtaskId);
         historyManager.add(subtask);
@@ -208,11 +212,11 @@ public Subtask getBySubtaskId(Integer subtaskId) {
     @Override
     public Subtask createSubtask(Subtask subtask) {
         if (checkPeriodCrossing(subtask)) {
-            throw new ManagerSaveException("Период задачи пересекается с текущими");
+            throw new NotAcceptableException("Время сохраняемой сабтаски пересекается с текущими задачами.");
         }
         int epicId = subtask.getEpicId();
         if (!epics.containsKey(epicId)) {
-            return null;
+            throw new NotFoundException("У сохраняемой сабтаски не найден эпик.");
         }
         subtask.setId(getNextId());
         Epic epic = epics.get(epicId);
@@ -227,16 +231,16 @@ public Subtask createSubtask(Subtask subtask) {
     @Override
     public Subtask updateSubtask(Subtask subtask) {
         Integer subtaskId = subtask.getId();
+        if (subtaskId == null || !subtasks.containsKey(subtaskId)) {
+            throw new NotFoundException("Обновляемая сабтаска не найдена.");
+        }
         Subtask oldSubtask = subtasks.get(subtaskId);
-        if (oldSubtask.getStartTime() != subtask.getStartTime() || oldSubtask.getDuration() != subtask.getDuration()) {
+        if (!(oldSubtask.getStartTime().equals(subtask.getStartTime())) || oldSubtask.getDuration() != subtask.getDuration()) {
             if (checkPeriodCrossing(subtask)) {
-                throw new ManagerSaveException("Период задачи пересекается с текущими");
+                throw new NotAcceptableException("Время обновленной сабтаски пересекается с текущими задачами.");
             }
         }
         Epic epic = epics.get(subtask.getEpicId());
-        if (subtaskId == null || !subtasks.containsKey(subtaskId)) {
-            return null;
-        }
         sortedEntity.remove(oldSubtask);
         sortedEntity.add(subtask);
         subtasks.put(subtaskId, subtask);
@@ -245,13 +249,16 @@ public Subtask updateSubtask(Subtask subtask) {
     }
 
     @Override
-    public boolean deleteSubtask(int subtaskId) {
+    public boolean deleteSubtask(Integer subtaskId) {
+        if (subtaskId == null || !subtasks.containsKey(subtaskId)) {
+            return true;
+        }
         Subtask subtask = subtasks.get(subtaskId);
         boolean removeSubtask = subtasks.remove(subtask.getId()) != null;
         historyManager.remove(subtaskId);
 
         Epic epic = epics.get(subtask.getEpicId());
-        epic.removesubtaskById(subtask);
+        epic.removeSubtaskById(subtask);
 
         updateStatusEpic(epic);
         sortedEntity.remove(subtask);
diff --git a/src/ru/practicum/task_tracker/manager/TaskManager.java b/src/ru/practicum/task_tracker/manager/TaskManager.java
index 4d94334..698bea4 100644
--- a/src/ru/practicum/task_tracker/manager/TaskManager.java
+++ b/src/ru/practicum/task_tracker/manager/TaskManager.java
@@ -31,7 +31,7 @@ public interface TaskManager {
 
     Epic updateEpic(Epic epic);
 
-    boolean deleteEpic(int epicId);
+    boolean deleteEpic(Integer epicId);
 
     void updateStatusEpic(Epic epic);
 
@@ -43,7 +43,7 @@ public interface TaskManager {
 
     Subtask updateSubtask(Subtask subtask);
 
-    boolean deleteSubtask(int subtaskId);
+    boolean deleteSubtask(Integer subtaskId);
 
     void deleteAllTasks();
 
diff --git a/src/ru/practicum/task_tracker/task/Epic.java b/src/ru/practicum/task_tracker/task/Epic.java
index 7fae105..48f3e73 100644
--- a/src/ru/practicum/task_tracker/task/Epic.java
+++ b/src/ru/practicum/task_tracker/task/Epic.java
@@ -19,7 +19,7 @@ public Epic(Integer id, String name, String description, Status status) {
     }
 
 
-    public Epic(Integer id, String name, String description, Status status, long duration, LocalDateTime startTime) {
+    public Epic(Integer id, String name, String description, Status status, Integer duration, LocalDateTime startTime) {
         super(id, name, description, status, duration, startTime);
     }
 
@@ -47,7 +47,6 @@ private void setDurationAndLocalDateTime() {
                 .map(Task::getDuration)
                 .reduce((long) 0, Long::sum)
         );
-
     }
 
     public LocalDateTime getEndTime() {
@@ -61,7 +60,7 @@ public void clearsubtaskIds() {
         subtasks.clear();
     }
 
-    public void removesubtaskById(Subtask subtask) {
+    public void removeSubtaskById(Subtask subtask) {
         subtasks.remove(subtask);
     }
 
diff --git a/src/ru/practicum/task_tracker/task/Subtask.java b/src/ru/practicum/task_tracker/task/Subtask.java
index c6c6342..03029a6 100644
--- a/src/ru/practicum/task_tracker/task/Subtask.java
+++ b/src/ru/practicum/task_tracker/task/Subtask.java
@@ -6,12 +6,12 @@ public class Subtask extends Task {
 
     private int epicId;
 
-    public Subtask(int epicId, String name, String description, Status status, long duration, LocalDateTime startTime) {
+    public Subtask(int epicId, String name, String description, Status status, Integer duration, LocalDateTime startTime) {
         super(name, description, status, duration, startTime);
         this.epicId = epicId;
     }
 
-    public Subtask(int epicId, Integer id, String name, String description, Status status, long duration, LocalDateTime startTime) {
+    public Subtask(int epicId, Integer id, String name, String description, Status status, Integer duration, LocalDateTime startTime) {
         super(id, name, description, status, duration, startTime);
         this.epicId = epicId;
     }
diff --git a/src/ru/practicum/task_tracker/task/Task.java b/src/ru/practicum/task_tracker/task/Task.java
index 4ba9af2..92272b2 100644
--- a/src/ru/practicum/task_tracker/task/Task.java
+++ b/src/ru/practicum/task_tracker/task/Task.java
@@ -26,7 +26,7 @@ public Task(Integer id, String name, String description, Status status) {
         this.status = status;
     }
 
-    public Task(String name, String description, Status status, long duration, LocalDateTime startTime) {
+    public Task(String name, String description, Status status, Integer duration, LocalDateTime startTime) {
         this.name = name;
         this.description = description;
         this.status = status;
@@ -35,7 +35,7 @@ public Task(String name, String description, Status status, long duration, Local
     }
 
     // Конструктор для сохранения из файла
-    public Task(Integer id, String name, String description, Status status, long duration, LocalDateTime startTime) {
+    public Task(Integer id, String name, String description, Status status, Integer duration, LocalDateTime startTime) {
         this.id = id;
         this.name = name;
         this.description = description;
diff --git a/test/ru/practicum/task_tracker/http/HttpTaskServerTest.java b/test/ru/practicum/task_tracker/http/HttpTaskServerTest.java
new file mode 100644
index 0000000..e366248
--- /dev/null
+++ b/test/ru/practicum/task_tracker/http/HttpTaskServerTest.java
@@ -0,0 +1,416 @@
+package ru.practicum.task_tracker.http;
+
+import com.google.gson.Gson;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import ru.practicum.task_tracker.manager.InMemoryTaskManager;
+import ru.practicum.task_tracker.manager.TaskManager;
+import ru.practicum.task_tracker.task.Epic;
+import ru.practicum.task_tracker.task.Status;
+import ru.practicum.task_tracker.task.Subtask;
+import ru.practicum.task_tracker.task.Task;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+class HttpTaskServerTest {
+    LocalDateTime time1 = LocalDateTime.of(2020, 1, 1, 13, 0);
+    Task task1NotId = new Task("таск1.Имя", "таск1.Описание", Status.NEW, 23, time1);
+    Task task1ThrowName = new Task(null, "таск1.Описание", Status.NEW, 23, time1);
+    Task task1ThrowStartTime = new Task("таск1.Имя", "таск1.Описание", Status.NEW, 23,
+            time1.plusMinutes(5));
+    Task task2 = new Task(1, "таск2.Имя", "таск2.Описание",
+            Status.NEW, 23, time1.plusDays(1));
+    Task task1Id = new Task(0, "таск1.Имя", "таск1.Описание", Status.DONE, 23, time1);
+    Epic epic1 = new Epic("Поход в горы", "обязательно с друзьями");
+    Epic epic1ThrowName = new Epic(null, "обязательно с друзьями");
+    Subtask subtask1ForEpic1 = new Subtask(0, "Купить: ",
+            "пластик. посуду ", Status.NEW, 12, time1.plusDays(2));
+    Subtask subtask1ForEpic1ThrowName = new Subtask(0, null,
+            "пластик. посуду ", Status.NEW, 12, time1.plusDays(2));
+    Subtask subtask1ForEpic1ThrowStartTime = new Subtask(0, "Купить: ", "пластик. посуду ",
+            Status.NEW, 12, time1.plusDays(2).plusMinutes(5));
+    Subtask subtask2ForEpic1 = new Subtask(0, 3, "Купить: ",
+            "пластик. посуду ", Status.NEW, 12, time1.plusDays(2));
+
+    // создаём экземпляр InMemoryTaskManager
+    TaskManager manager = new InMemoryTaskManager();
+    // передаём его в качестве аргумента в конструктор HttpTaskServer
+    HttpTaskServer taskServer = new HttpTaskServer(manager);
+    Gson gson = HttpTaskServer.getGson();
+
+    HttpTaskServerTest() throws IOException {
+    }
+
+    @BeforeEach
+    public void setUp() {
+        manager.deleteAllTasks();
+        taskServer.start();
+    }
+
+    @AfterEach
+    public void shutDown() {
+        taskServer.stop();
+    }
+
+    private HttpResponse<String> getResponsePost(String json, String path) throws IOException, InterruptedException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI url = URI.create(path);
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(url)
+                .POST(HttpRequest.BodyPublishers.ofString(json))
+                .build();
+
+        return client.send(request, HttpResponse.BodyHandlers.ofString());
+    }
+
+    private HttpResponse<String> getResponseGet(String path) throws IOException, InterruptedException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI url = URI.create(path);
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(url)
+                .GET()
+                .build();
+
+        return client.send(request, HttpResponse.BodyHandlers.ofString());
+    }
+
+    private HttpResponse<String> getResponseDelete(String path) throws IOException, InterruptedException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI url = URI.create(path);
+        HttpRequest request = HttpRequest.newBuilder()
+                .uri(url)
+                .DELETE()
+                .build();
+
+        return client.send(request, HttpResponse.BodyHandlers.ofString());
+    }
+
+    @Test
+    public void testAddTask() throws IOException, InterruptedException {
+        // конвертируем её в JSON
+        String taskJson = gson.toJson(task1NotId);
+        String path = "http://localhost:8080/tasks";
+        HttpResponse<String> response = getResponsePost(taskJson, path);
+        assertEquals(201, response.statusCode());
+
+        List<Task> tasksFromManager = manager.getTasks();
+        assertNotNull(tasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, tasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("таск1.Имя", tasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+//        400 Bad Request
+        String taskThrowJson = gson.toJson(task1ThrowName);
+        HttpResponse<String> responseThrows = getResponsePost(taskThrowJson, path);
+        assertEquals(400, responseThrows.statusCode());
+
+//        406 Not Acceptable
+        HttpResponse<String> responseTh = getResponsePost(taskJson, path);
+        assertEquals(406, responseTh.statusCode());
+    }
+
+    @Test
+    public void testUpdateTask() throws IOException, InterruptedException {
+        testAddTask();
+        String taskJson = gson.toJson(task1Id);
+        String path = "http://localhost:8080/tasks";
+        HttpResponse<String> response = getResponsePost(taskJson, path);
+        assertEquals(200, response.statusCode());
+        List<Task> tasksFromManager = manager.getTasks();
+        assertNotNull(tasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, tasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("таск1.Имя", tasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+//          400 Bad Request
+        String taskThrowJson1 = gson.toJson(task1ThrowName);
+        HttpResponse<String> responseThrows1 = getResponsePost(taskThrowJson1, path);
+        assertEquals(400, responseThrows1.statusCode());
+
+//        404 Not Found
+        String taskThrowJson2 = gson.toJson(task2);
+        HttpResponse<String> responseThrows2 = getResponsePost(taskThrowJson2, path);
+        assertEquals(404, responseThrows2.statusCode());
+
+//        406 Not Acceptable
+        String taskThrowJson3 = gson.toJson(task1ThrowStartTime);
+        HttpResponse<String> responseThrows3 = getResponsePost(taskThrowJson3, path);
+        assertEquals(406, responseThrows3.statusCode());
+    }
+
+    @Test
+    public void getTasks() throws IOException, InterruptedException {
+        testAddTask();
+        String path = "http://localhost:8080/tasks";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+        List<Task> tasksFromManager = manager.getTasks();
+
+        assertNotNull(tasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, tasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("таск1.Имя", tasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+    }
+
+    @Test
+    public void getTaskById() throws IOException, InterruptedException {
+        testAddTask();
+        String path = "http://localhost:8080/tasks/0";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+        List<Task> tasksFromManager = manager.getTasks();
+
+        assertNotNull(tasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, tasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("таск1.Имя", tasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+        //        404 Not Found
+        String pathThrow = "http://localhost:8080/tasks/1";
+        HttpResponse<String> responseThrow = getResponseGet(pathThrow);
+        assertEquals(404, responseThrow.statusCode());
+    }
+
+    @Test
+    public void deleteTaskById() throws IOException, InterruptedException {
+        testAddTask();
+        String path = "http://localhost:8080/tasks/0";
+        HttpResponse<String> response = getResponseDelete(path);
+        assertEquals(200, response.statusCode());
+
+        List<Task> tasksFromManager = manager.getTasks();
+        assertNotNull(tasksFromManager, "Задачи не возвращаются");
+        assertEquals(0, tasksFromManager.size(), "Некорректное количество задач");
+
+        //        404 Not Found
+        String pathThrow = "http://localhost:8080/tasks/1";
+        HttpResponse<String> responseThrow = getResponseGet(pathThrow);
+        assertEquals(404, responseThrow.statusCode());
+    }
+
+    @Test
+    public void testAddEpic() throws IOException, InterruptedException {
+        String epicJson = gson.toJson(epic1);
+        String path = "http://localhost:8080/epics";
+        HttpResponse<String> response = getResponsePost(epicJson, path);
+        assertEquals(201, response.statusCode());
+        List<Epic> epicsFromManager = manager.getEpics();
+
+        assertNotNull(epicsFromManager, "Задачи не возвращаются");
+        assertEquals(1, epicsFromManager.size(), "Некорректное количество задач");
+        assertEquals("Поход в горы", epicsFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+        //        400 Bad Request
+        String epicThrowJson = gson.toJson(epic1ThrowName);
+        HttpResponse<String> responseThrows = getResponsePost(epicThrowJson, path);
+        assertEquals(400, responseThrows.statusCode());
+    }
+
+    @Test
+    public void testGetEpic() throws IOException, InterruptedException {
+        testAddEpic();
+        String path = "http://localhost:8080/epics";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+
+        List<Epic> epicsFromManager = manager.getEpics();
+
+        assertNotNull(epicsFromManager, "Задачи не возвращаются");
+        assertEquals(1, epicsFromManager.size(), "Некорректное количество задач");
+        assertEquals("Поход в горы", epicsFromManager.getFirst().getName(), "Некорректное имя задачи");
+    }
+
+    @Test
+    public void testGetByIdEpic() throws IOException, InterruptedException {
+        testAddEpic();
+        String path = "http://localhost:8080/epics/0";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+        List<Epic> epicsFromManager = manager.getEpics();
+
+        assertNotNull(epicsFromManager, "Задачи не возвращаются");
+        assertEquals(1, epicsFromManager.size(), "Некорректное количество задач");
+        assertEquals("Поход в горы", epicsFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+
+        //        404 Not Found
+        String pathThrow = "http://localhost:8080/epics/1";
+        HttpResponse<String> responseThrow = getResponseGet(pathThrow);
+        assertEquals(404, responseThrow.statusCode());
+    }
+
+    @Test
+    public void testGetByIdEpicAllSubtasks() throws IOException, InterruptedException {
+        testAddSubtask();
+        String path = "http://localhost:8080/epics/0/subtasks";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+        List<Subtask> epicsFromManager = manager.getSubtasks();
+
+        assertNotNull(epicsFromManager, "Задачи не возвращаются");
+        assertEquals(1, epicsFromManager.size(), "Некорректное количество задач");
+        assertEquals("Купить: ", epicsFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+        //        404 Not Found
+        String pathThrow = "http://localhost:8080/epics/1/subtasks";
+        HttpResponse<String> responseThrow = getResponseGet(pathThrow);
+        assertEquals(404, responseThrow.statusCode());
+    }
+
+    @Test
+    public void testDeleteByIdEpic() throws IOException, InterruptedException {
+        testAddEpic();
+        String path = "http://localhost:8080/epics/0";
+        HttpResponse<String> response = getResponseDelete(path);
+        assertEquals(200, response.statusCode());
+        List<Epic> epicsFromManager = manager.getEpics();
+
+        assertNotNull(epicsFromManager, "Задачи не возвращаются");
+        assertEquals(0, epicsFromManager.size(), "Некорректное количество задач");
+
+        //        404 Not Found
+        String pathThrow = "http://localhost:8080/epics/1";
+        HttpResponse<String> responseThrow = getResponseGet(pathThrow);
+        assertEquals(404, responseThrow.statusCode());
+    }
+
+    @Test
+    public void testAddSubtask() throws IOException, InterruptedException {
+        testAddEpic();
+
+        String subtaskJson = gson.toJson(subtask1ForEpic1);
+        String path = "http://localhost:8080/subtasks";
+        HttpResponse<String> response = getResponsePost(subtaskJson, path);
+        assertEquals(201, response.statusCode());
+        List<Subtask> tasksFromManager = manager.getSubtasks();
+
+        assertNotNull(tasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, tasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("Купить: ", tasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+//        400 Bad Request
+        String taskThrowJson1 = gson.toJson(subtask1ForEpic1ThrowName);
+        HttpResponse<String> responseThrows1 = getResponsePost(taskThrowJson1, path);
+        assertEquals(400, responseThrows1.statusCode());
+
+//        406 Not Acceptable  StartTime
+        String taskThrowJson2 = gson.toJson(subtask1ForEpic1ThrowStartTime);
+        HttpResponse<String> responseThrows2 = getResponsePost(taskThrowJson2, path);
+        assertEquals(406, responseThrows2.statusCode());
+    }
+
+    @Test
+    public void testUpdateSubtask() throws IOException, InterruptedException {
+        testAddSubtask();
+        Subtask subtask = manager.getBySubtaskId(1);
+        String subtaskJson = gson.toJson(subtask);
+        String path = "http://localhost:8080/subtasks";
+        HttpResponse<String> response = getResponsePost(subtaskJson, path);
+        assertEquals(200, response.statusCode());
+        List<Subtask> subtasksFromManager = manager.getSubtasks();
+
+        assertNotNull(subtasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, subtasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("Купить: ", subtasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+        //        400 Bad Request
+        String taskThrowJson1 = gson.toJson(subtask1ForEpic1ThrowName);
+        HttpResponse<String> responseThrows1 = getResponsePost(taskThrowJson1, path);
+        assertEquals(400, responseThrows1.statusCode());
+
+        //        404 Not Found
+        String taskThrowJson2 = gson.toJson(subtask2ForEpic1);
+        HttpResponse<String> responseThrows2 = getResponsePost(taskThrowJson2, path);
+        assertEquals(404, responseThrows2.statusCode());
+
+//        406 Not Acceptable  StartTime
+        String taskThrowJson3 = gson.toJson(subtask1ForEpic1ThrowStartTime);
+        HttpResponse<String> responseThrows3 = getResponsePost(taskThrowJson3, path);
+        assertEquals(406, responseThrows3.statusCode());
+    }
+
+    @Test
+    public void testGeSubtask() throws IOException, InterruptedException {
+        testAddSubtask();
+        String path = "http://localhost:8080/subtasks";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+        List<Subtask> subtasksFromManager = manager.getSubtasks();
+
+        assertNotNull(subtasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, subtasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("Купить: ", subtasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+    }
+
+    @Test
+    public void testGetByIdSubtask() throws IOException, InterruptedException {
+        testAddSubtask();
+        String path = "http://localhost:8080/subtasks/1";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+        List<Subtask> subtasksFromManager = manager.getSubtasks();
+
+        assertNotNull(subtasksFromManager, "Задачи не возвращаются");
+        assertEquals(1, subtasksFromManager.size(), "Некорректное количество задач");
+        assertEquals("Купить: ", subtasksFromManager.getFirst().getName(), "Некорректное имя задачи");
+
+
+        //        404 Not Found
+        String taskThrowJson2 = gson.toJson(subtask2ForEpic1);
+        HttpResponse<String> responseThrows2 = getResponsePost(taskThrowJson2, path);
+        assertEquals(404, responseThrows2.statusCode());
+    }
+
+    @Test
+    public void testDeleteSubtaskById() throws IOException, InterruptedException {
+        testAddSubtask();
+        String path = "http://localhost:8080/subtasks/1";
+        HttpResponse<String> response = getResponseDelete(path);
+        assertEquals(200, response.statusCode());
+        List<Subtask> subtasksFromManager = manager.getSubtasks();
+
+        assertNotNull(subtasksFromManager, "Задачи не возвращаются");
+        assertEquals(0, subtasksFromManager.size(), "Некорректное количество задач");
+
+        //        404 Not Found
+        String taskThrowJson2 = gson.toJson(subtask2ForEpic1);
+        HttpResponse<String> responseThrows2 = getResponsePost(taskThrowJson2, path);
+        assertEquals(404, responseThrows2.statusCode());
+    }
+
+    @Test
+    public void testGeHistory() throws IOException, InterruptedException {
+        testAddSubtask();
+        testAddTask();
+        String path = "http://localhost:8080/history";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+        List<Task> subtasksFromManager = manager.getHistory();
+
+        assertNotNull(subtasksFromManager, "Задачи не возвращаются");
+        assertEquals(3, subtasksFromManager.size(), "Некорректное количество задач");
+    }
+
+    @Test
+    public void testGePrioritized() throws IOException, InterruptedException {
+        testAddSubtask();
+        testAddTask();
+        String path = "http://localhost:8080/prioritized";
+        HttpResponse<String> response = getResponseGet(path);
+        assertEquals(200, response.statusCode());
+
+        List<Task> subtasksFromManager = new ArrayList<>(manager.getPrioritizedTasks());
+        assertNotNull(subtasksFromManager, "Задачи не возвращаются");
+        assertEquals(2, subtasksFromManager.size(), "Некорректное количество задач");
+        assertEquals(subtasksFromManager.getFirst().getName(), task1Id.getName());
+        assertEquals(subtasksFromManager.getLast().getName(), "Купить: ");
+    }
+
+}
\ No newline at end of file
diff --git a/test/ru/practicum/task_tracker/manager/InMemoryTaskManagerTest.java b/test/ru/practicum/task_tracker/manager/InMemoryTaskManagerTest.java
index f2d7a7a..06f753a 100644
--- a/test/ru/practicum/task_tracker/manager/InMemoryTaskManagerTest.java
+++ b/test/ru/practicum/task_tracker/manager/InMemoryTaskManagerTest.java
@@ -1,8 +1,10 @@
 package ru.practicum.task_tracker.manager;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import ru.practicum.task_tracker.Managers;
+import ru.practicum.task_tracker.http.Exception.NotFoundException;
 import ru.practicum.task_tracker.task.Epic;
 import ru.practicum.task_tracker.task.Status;
 import ru.practicum.task_tracker.task.Subtask;
@@ -12,8 +14,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.*;
 
 class InMemoryTaskManagerTest extends TaskManagerTest<InMemoryTaskManager> {
 
@@ -88,7 +89,7 @@ void objectEpicCanNotMakePersonalSubtask() {
         // // проверьте, что объект Subtask нельзя сделать своим же эпиком
         Subtask subtask1 = new Subtask(9, "Купить: ",
                 "пластик. посуду ", Status.NEW, 22, time1.plusDays(6));
-        assertNull(taskManager.createSubtask(subtask1));
+        Assertions.assertThrows(NotFoundException.class, () -> taskManager.createSubtask(subtask1));
     }
 
     @Test
@@ -171,12 +172,9 @@ void checkDeleteIdSubtask() {
                 "пластик. посуду ", Status.NEW, 31, time1.plusDays(16));
         Subtask saveSubtask1 = taskManager.createSubtask(subtask1ForEpic1);
 
-        taskManager.deleteSubtask(saveSubtask1.getId());
-        Subtask getDeleteId = taskManager.getBySubtaskId(saveSubtask1.getId());
-        Integer deleteEpicIdInSubtask = saveSubtask1.getEpicId();
-
-        assertNull(getDeleteId);
-        assertEquals(deleteEpicIdInSubtask, 0);
+        assertTrue(taskManager.deleteSubtask(saveSubtask1.getId()));
+        Assertions.assertThrows(NotFoundException.class, () -> taskManager.getBySubtaskId(saveSubtask1.getId()));
+        assertEquals(saveSubtask1.getEpicId(), 0);
     }
 
     @Test
@@ -189,17 +187,16 @@ void checkDeleteSubtaskForEpic() {
                 "пластик. посуду ", Status.NEW, 32, time1.plusDays(18));
         Subtask saveSubtask1 = taskManager.createSubtask(subtask1ForEpic1);
 
-        taskManager.deleteSubtask(saveSubtask1.getId());
+        assertTrue(taskManager.deleteSubtask(saveSubtask1.getId()));
 
-        Subtask getDeleteId = taskManager.getBySubtaskId(saveSubtask1.getId());
+        Assertions.assertThrows(NotFoundException.class, () -> taskManager.getBySubtaskId(saveSubtask1.getId()));
         List<Subtask> subtaskInEpic = savedEpic.getSubtasks();
 
         Integer subtask = 0;
         if (subtaskInEpic.isEmpty()) {
             subtask = null;
         }
-        assertNull(getDeleteId);
-        assertEquals(getDeleteId, subtask);
+        assertNull(subtask);
     }
 
     @Test
diff --git a/test/ru/practicum/task_tracker/manager/TaskManagerTest.java b/test/ru/practicum/task_tracker/manager/TaskManagerTest.java
index 1c81d8f..30a8890 100644
--- a/test/ru/practicum/task_tracker/manager/TaskManagerTest.java
+++ b/test/ru/practicum/task_tracker/manager/TaskManagerTest.java
@@ -12,7 +12,8 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 
 abstract class TaskManagerTest<T extends TaskManager> {
@@ -138,7 +139,6 @@ void getEpics() {
     void getByEpicId() {
         Epic createdEpic1 = taskManager.createEpic(epic1);
         assertEquals(taskManager.getByEpicId(createdEpic1.getId()), createdEpic1);
-        assertNull(taskManager.getByEpicId(epic2.getId()));
     }