Рефакт. Добавил слой сервис, подготовил к кэшированию

tests/conftest.py

@@ -1,12 +1,11 @@
 import asyncio
-from typing import AsyncGenerator, Generator
+from typing import AsyncGenerator, Dict, Generator
 
 import pytest
 import pytest_asyncio
 from fastapi import FastAPI
 from httpx import AsyncClient
-from sqlalchemy.ext.asyncio import (AsyncSession, async_sessionmaker,
-                                    create_async_engine)
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
 from fastfood.app import create_app
 from fastfood.config import settings
@@ -31,7 +30,7 @@ def event_loop():
     loop.close()
 
 
-@pytest_asyncio.fixture(scope="function", autouse=True)
+@pytest_asyncio.fixture(scope="session", autouse=True)
 async def db_init(event_loop):
     async with async_engine.begin() as conn:
         await conn.run_sync(Base.metadata.drop_all)
@@ -60,3 +59,8 @@ async def client(app) -> AsyncGenerator[AsyncClient, None]:
         base_url="http://localhost:8000/api/v1/menus",
     ) as async_client:
         yield async_client
+
+
+@pytest.fixture(scope="session")
+def session_data() -> Dict:
+    return {}

tests/repository.py

@@ -0,0 +1,150 @@
+from typing import Tuple
+
+from httpx import AsyncClient, Response
+
+
+class Repository:
+    class Menu:
+        @staticmethod
+        async def read_all(ac: AsyncClient) -> Tuple[int, dict]:
+            """чтение всех меню"""
+
+            response: Response = await ac.get("/")
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def get(ac: AsyncClient, data: dict) -> Tuple[int, dict]:
+            """Получение меню по id"""
+            response: Response = await ac.get(f"/{data.get('id')}")
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def write(ac: AsyncClient, data: dict) -> Tuple[int, dict]:
+            """создания меню"""
+            response: Response = await ac.post("/", json=data)
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def update(ac: AsyncClient, data: dict) -> Tuple[int, dict]:
+            """Обновление меню по id"""
+            response: Response = await ac.patch(
+                f"/{data.get('id')}",
+                json=data,
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def delete(ac: AsyncClient, data: dict) -> int:
+            """Удаление меню по id"""
+            response: Response = await ac.delete(f"/{data.get('id')}")
+            return response.status_code
+
+    class Submenu:
+        @staticmethod
+        async def read_all(ac: AsyncClient, menu: dict) -> Tuple[int, dict]:
+            """чтение всех меню"""
+            response: Response = await ac.get(f"/{menu.get('id')}/submenus/")
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def get(
+            ac: AsyncClient,
+            menu: dict,
+            submenu: dict,
+        ) -> Tuple[int, dict]:
+            """Получение меню по id"""
+            response: Response = await ac.get(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}",
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def write(
+            ac: AsyncClient,
+            menu: dict,
+            submenu: dict,
+        ) -> Tuple[int, dict]:
+            """создания меню"""
+            response: Response = await ac.post(
+                f"/{menu.get('id')}/submenus/",
+                json=submenu,
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def update(
+            ac: AsyncClient, menu: dict, submenu: dict
+        ) -> Tuple[int, dict]:
+            """Обновление меню по id"""
+            response: Response = await ac.patch(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}",
+                json=submenu,
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def delete(ac: AsyncClient, menu: dict, submenu: dict) -> int:
+            """Удаление меню по id"""
+            response: Response = await ac.delete(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
+            )
+            return response.status_code
+
+    class Dish:
+        @staticmethod
+        async def read_all(
+            ac: AsyncClient, menu: dict, submenu: dict
+        ) -> Tuple[int, dict]:
+            """чтение всех блюд"""
+            response: Response = await ac.get(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}/dishes/",
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def get(
+            ac: AsyncClient, menu: dict, submenu: dict, dish: dict
+        ) -> Tuple[int, dict]:
+            """Получение блюда по id"""
+            response: Response = await ac.get(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
+                f"/dishes/{dish.get('id')}",
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def write(
+            ac: AsyncClient, menu: dict, submenu: dict, dish: dict
+        ) -> Tuple[int, dict]:
+            """создания блюда"""
+            response: Response = await ac.post(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}/dishes/",
+                json=dish,
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def update(
+            ac: AsyncClient, menu: dict, submenu: dict, dish: dict
+        ) -> Tuple[int, dict]:
+            """Обновление блюда по id"""
+            response: Response = await ac.patch(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
+                f"/dishes/{dish.get('id')}",
+                json=dish,
+            )
+            return response.status_code, response.json()
+
+        @staticmethod
+        async def delete(
+            ac: AsyncClient,
+            menu: dict,
+            submenu: dict,
+            dish: dict,
+        ) -> int:
+            """Удаление блюда по id"""
+            response: Response = await ac.delete(
+                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
+                f"/dishes/{dish.get('id')}"
+            )
+            return response.status_code

tests/test_api.py

@@ -1,414 +1,360 @@
-from typing import Tuple
-
 import pytest
-from httpx import AsyncClient, Response
+from httpx import AsyncClient
 
-
-class TestBaseCrud:
-    class Menu:
-        @staticmethod
-        async def read_all(ac: AsyncClient) -> Tuple[int, dict]:
-            """чтение всех меню"""
-
-            response: Response = await ac.get("/")
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def get(ac: AsyncClient, data: dict) -> Tuple[int, dict]:
-            """Получение меню по id"""
-            response: Response = await ac.get(f"/{data.get('id')}")
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def write(ac: AsyncClient, data: dict) -> Tuple[int, dict]:
-            """создания меню"""
-            response: Response = await ac.post("/", json=data)
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def update(ac: AsyncClient, data: dict) -> Tuple[int, dict]:
-            """Обновление меню по id"""
-            response: Response = await ac.patch(
-                f"/{data.get('id')}",
-                json=data,
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def delete(ac: AsyncClient, data: dict) -> int:
-            """Удаление меню по id"""
-            response: Response = await ac.delete(f"/{data.get('id')}")
-            return response.status_code
-
-    class Submenu:
-        @staticmethod
-        async def read_all(ac: AsyncClient, menu: dict) -> Tuple[int, dict]:
-            """чтение всех меню"""
-            response: Response = await ac.get(f"/{menu.get('id')}/submenus/")
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def get(
-            ac: AsyncClient,
-            menu: dict,
-            submenu: dict,
-        ) -> Tuple[int, dict]:
-            """Получение меню по id"""
-            response: Response = await ac.get(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}",
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def write(
-            ac: AsyncClient,
-            menu: dict,
-            submenu: dict,
-        ) -> Tuple[int, dict]:
-            """создания меню"""
-            response: Response = await ac.post(
-                f"/{menu.get('id')}/submenus/",
-                json=submenu,
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def update(
-            ac: AsyncClient, menu: dict, submenu: dict
-        ) -> Tuple[int, dict]:
-            """Обновление меню по id"""
-            response: Response = await ac.patch(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}",
-                json=submenu,
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def delete(ac: AsyncClient, menu: dict, submenu: dict) -> int:
-            """Удаление меню по id"""
-            response: Response = await ac.delete(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
-            )
-            return response.status_code
-
-    class Dish:
-        @staticmethod
-        async def read_all(
-            ac: AsyncClient, menu: dict, submenu: dict
-        ) -> Tuple[int, dict]:
-            """чтение всех блюд"""
-            response: Response = await ac.get(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}/dishes/",
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def get(
-            ac: AsyncClient, menu: dict, submenu: dict, dish: dict
-        ) -> Tuple[int, dict]:
-            """Получение блюда по id"""
-            response: Response = await ac.get(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
-                f"/dishes/{dish.get('id')}",
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def write(
-            ac: AsyncClient, menu: dict, submenu: dict, dish: dict
-        ) -> Tuple[int, dict]:
-            """создания блюда"""
-            response: Response = await ac.post(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}/dishes/",
-                json=dish,
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def update(
-            ac: AsyncClient, menu: dict, submenu: dict, dish: dict
-        ) -> Tuple[int, dict]:
-            """Обновление блюда по id"""
-            response: Response = await ac.patch(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
-                f"/dishes/{dish.get('id')}",
-                json=dish,
-            )
-            return response.status_code, response.json()
-
-        @staticmethod
-        async def delete(ac: AsyncClient, menu: dict, submenu: dict, dish: dict) -> int:
-            """Удаление блюда по id"""
-            response: Response = await ac.delete(
-                f"/{menu.get('id')}/submenus/{submenu.get('id')}"
-                f"/dishes/{dish.get('id')}"
-            )
-            return response.status_code
+from .repository import Repository as Repo
 
 
 @pytest.mark.asyncio
-async def test_menu_crud(client) -> None:
+async def test_menu_crud_empty(client: AsyncClient) -> None:
     """Тестирование функций меню"""
-    code, menus = await TestBaseCrud.Menu.read_all(client)
+    code, rspn = await Repo.Menu.read_all(client)
     assert code == 200
-    assert menus == []
+    assert rspn == []
 
+
+@pytest.mark.asyncio
+async def test_menu_crud_add(client: AsyncClient) -> None:
+    """Тестирование функций меню"""
     data = {"title": "Menu", "description": None}
-    code, menu = await TestBaseCrud.Menu.write(client, data)
+    code, rspn = await Repo.Menu.write(client, data)
     assert code == 201
-    assert menu["title"] == "Menu"
-    assert menu["description"] is None
-    code, menus = await TestBaseCrud.Menu.read_all(client)
-    assert len(menus) == 1
+    assert rspn["title"] == "Menu"
+    assert rspn["description"] is None
+    await Repo.Menu.delete(client, rspn)
 
-    code, menu = await TestBaseCrud.Menu.get(client, {"id": menu.get("id")})
+
+@pytest.mark.asyncio
+async def test_menu_crud_get(client: AsyncClient) -> None:
+    """Тестирование функций меню"""
+    data = {"title": "Menu", "description": None}
+    code, rspn = await Repo.Menu.write(client, data)
+    code, menu = await Repo.Menu.get(client, {"id": rspn.get("id")})
     assert code == 200
-    assert menu["title"] == data["title"]
+    assert menu["title"] == rspn["title"]
+    await Repo.Menu.delete(client, menu)
 
-    upd_menu = {
-        "id": menu.get("id"),
+
+@pytest.mark.asyncio
+async def test_menu_crud_update(client: AsyncClient) -> None:
+    """Тестирование функций меню"""
+    data = {"title": "Menu", "description": None}
+    code, rspn = await Repo.Menu.write(client, data)
+
+    upd_data = {
+        "id": rspn.get("id"),
         "title": "upd Menu",
         "description": "",
     }
-    code, menu = await TestBaseCrud.Menu.update(client, upd_menu)
+    code, upd_rspn = await Repo.Menu.update(client, upd_data)
     assert code == 200
-    print(menu)
-    # assert menu["title"] == "upd Menu"
+    assert upd_rspn["title"] == "upd Menu"
+    await Repo.Menu.delete(client, upd_rspn)
 
 
-#         code = await self.Menu.delete(client, rspn)
-#         assert code == 200
-#
-#         code, menu = await self.Menu.get(client, {"id": rspn.get("id")})
-#         assert code == 404
-#
-#     @pytest.mark.asyncio
-#     async def test_submenus(self, client) -> None:
-#         # Создаем меню и проверяем ответ
-#         menu = {"title": "Menu", "description": "main menu"}
-#         code, rspn = await self.Menu.write(client, menu)
-#         assert code == 201
-#         menu.update(rspn)
-#
-#         # Проверяем наличие подменю
-#         code, rspn = await self.Submenu.read_all(client, menu)
-#         assert code == 200
-#         assert rspn == []
-#
-#         # Создаем и проверяем подменю
-#         submenu = {
-#             "title": "Submenu",
-#             "description": "submenu",
-#             "parent_menu": menu["id"],
-#         }
-#         code, rspn = await self.Submenu.write(client, menu, submenu)
-#         assert code == 201
-#         submenu.update(rspn)
-#
-#         # Проверяем меню на наличие подменю
-#         code, rspn = await self.Menu.get(client, menu)
-#         assert code == 200
-#         assert rspn["submenus_count"] == 1
-#
-#         # Обновляем подменю и проверяем
-#         submenu["title"] = "updated_submenu"
-#         code, rspn = await self.Submenu.update(client, menu, submenu)
-#         assert code == 200
-#         assert submenu["title"] == rspn["title"]
-#         submenu.update(rspn)
-#
-#         # Удаляем подменю
-#         code = await self.Submenu.delete(client, menu, submenu)
-#         assert code == 200
-#
-#         # Проверяем меню
-#         code, rspn = await self.Menu.get(client, menu)
-#         assert code == 200
-#         assert rspn["submenus_count"] == 0
-#
-#         # Проверяем удаленное подменю
-#         code, rspn = await self.Submenu.get(client, menu, submenu)
-#         assert code == 404
-#
-#         # удаляем сопутствующее
-#         await self.Menu.delete(client, menu)
-#
-#     @pytest.mark.asyncio
-#     async def test_dishes(self, client: AsyncClient) -> None:
-#         # Создаем меню и проверяем ответ
-#         menu = {
-#             "title": "Menu",
-#             "description": "main menu",
-#         }
-#         code, rspn = await self.Menu.write(client, menu)
-#         assert code == 201
-#         menu.update(rspn)
-#
-#         # Создаем и проверяем подменю
-#         submenu = {
-#             "title": "Submenu",
-#             "description": "submenu",
-#             "parent_menu": menu["id"],
-#         }
-#         code, rspn = await self.Submenu.write(client, menu, submenu)
-#         assert code == 201
-#         submenu.update(rspn)
-#
-#         # Проверяем все блюда в подменю
-#         code, rspn = await self.Dish.read_all(client, menu, submenu)
-#         assert code == 200
-#         assert rspn == []
-#
-#         # Добавляем блюдо
-#         dish = {
-#             "title": "dish",
-#             "description": "some dish",
-#             "price": "12.5",
-#             "parent_submenu": submenu["id"],
-#         }
-#         code, rspn = await self.Dish.write(client, menu, submenu, dish)
-#         assert code == 201
-#         dish.update(rspn)
-#
-#         # Получаем блюдо
-#         code, rspn = await self.Dish.get(client, menu, submenu, dish)
-#         assert code == 200
-#         assert rspn["title"] == dish["title"]
-#
-#         # Проверяем меню на количество блюд
-#         code, rspn = await self.Menu.get(client, menu)
-#         assert code == 200
-#         assert rspn["dishes_count"] == 1
-#
-#         # Проверяем подменю на наличие блюд
-#         code, rspn = await self.Submenu.get(client, menu, submenu)
-#         assert code == 200
-#         assert rspn["dishes_count"] == 1
-#
-#         # Обновляем блюдо и проверяем
-#         dish["title"] = "updated_dish"
-#         code, rspn = await self.Dish.update(client, menu, submenu, dish)
-#         assert code == 200
-#         assert dish["title"] == rspn["title"]
-#         dish.update(rspn)
-#
-#         # Удаляем подменю
-#         code = await self.Dish.delete(client, menu, submenu, dish)
-#         assert code == 200
-#
-#         # Проверяем меню
-#         code, rspn = await self.Menu.get(client, menu)
-#         assert code == 200
-#         assert rspn["dishes_count"] == 0
-#
-#         # Проверяем подменю на наличие блюд
-#         code, rspn = await self.Submenu.get(client, menu, submenu)
-#         assert code == 200
-#         assert rspn["dishes_count"] == 0
-#
-#         # Проверяем удаленное блюдо
-#         code, rspn = await self.Dish.get(client, menu, submenu, dish)
-#         assert code == 404
-#
-#         # удаляем сопутствующее
-#         await self.Submenu.delete(client, menu, submenu)
-#         await self.Menu.delete(client, menu)
-#
-#
-# class TestСontinuity:
-#     @pytest.mark.asyncio
-#     async def test_postman_continuity(self, client):
-#         # Создаем меню
-#         menu = {
-#             "title": "Menu",
-#             "description": "main menu",
-#         }
-#         code, rspn = await TestBaseCrud.Menu.write(client, menu)
-#         assert code == 201
-#         assert "id" in rspn.keys()
-#         menu.update(rspn)
-#
-#         # Создаем подменю
-#         submenu = {
-#             "title": "Submenu",
-#             "description": "submenu",
-#             "parent_menu": menu["id"],
-#         }
-#         code, rspn = await TestBaseCrud.Submenu.write(client, menu, submenu)
-#         assert code == 201
-#         assert "id" in rspn.keys()
-#         submenu.update(rspn)
-#
-#         # Добавляем блюдо1
-#         dish = {
-#             "title": "dish1",
-#             "description": "some dish1",
-#             "price": "13.50",
-#             "parent_submenu": submenu["id"],
-#         }
-#         code, rspn = await TestBaseCrud.Dish.write(client, menu, submenu, dish)
-#         assert code == 201
-#         assert "id" in rspn.keys()
-#         dish.update(rspn)
-#
-#         # Добавляем блюдо2
-#         dish = {
-#             "title": "dish2",
-#             "description": "some dish2",
-#             "price": "12.50",
-#             "parent_submenu": submenu["id"],
-#         }
-#         code, rspn = await TestBaseCrud.Dish.write(client, menu, submenu, dish)
-#         assert code == 201
-#         assert "id" in rspn.keys()
-#         dish.update(rspn)
-#
-#         # Просматриваем конкретное меню
-#         code, rspn = await TestBaseCrud.Menu.get(client, menu)
-#         assert code == 200
-#         assert "id" in rspn.keys()
-#         assert menu["id"] == rspn["id"]
-#         assert "submenus_count" in rspn.keys()
-#         assert rspn["submenus_count"] == 1
-#         assert "dishes_count" in rspn.keys()
-#         assert rspn["dishes_count"] == 2
-#
-#         # Просматриваем конкретное подменю
-#         code, rspn = await TestBaseCrud.Submenu.get(client, menu, submenu)
-#         assert code == 200
-#         assert "id" in rspn.keys()
-#         assert "dishes_count" in rspn.keys()
-#         assert rspn["dishes_count"] == 2
-#
-#         # Удаляем подменю
-#         code = await TestBaseCrud.Submenu.delete(client, menu, submenu)
-#         assert code == 200
-#
-#         # Просматриваем список подменю
-#         code, rspn = await TestBaseCrud.Submenu.read_all(client, menu)
-#         assert code == 200
-#         assert rspn == []
-#
-#         # Просматриваем список блюд
-#         code, rspn = await TestBaseCrud.Dish.read_all(client, menu, submenu)
-#         assert code == 200
-#         assert rspn == []
-#
-#         # Просматриваем конкретное меню
-#         code, rspn = await TestBaseCrud.Menu.get(client, menu)
-#         assert code == 200
-#         assert "id" in rspn.keys()
-#         assert menu["id"] == rspn["id"]
-#         assert "submenus_count" in rspn.keys()
-#         assert rspn["submenus_count"] == 0
-#         assert "dishes_count" in rspn.keys()
-#         assert rspn["dishes_count"] == 0
-#
-#         # Удаляем меню
-#         code = await TestBaseCrud.Menu.delete(client, menu)
-#         assert code == 200
-#
-#         # Просматриваем все меню
-#         code, rspn = await TestBaseCrud.Menu.read_all(client)
-#         assert code == 200
-#         assert rspn == []
+@pytest.mark.asyncio
+async def test_menu_crud_delete(client: AsyncClient) -> None:
+    """Тестирование функций меню"""
+    data = {"title": "Menu", "description": None}
+    code, rspn = await Repo.Menu.write(client, data)
+
+    code = await Repo.Menu.delete(client, rspn)
+    assert code == 200
+
+    code, rspn = await Repo.Menu.get(client, {"id": rspn.get("id")})
+    assert code == 404
+
+
+@pytest.mark.asyncio
+async def test_menu_crud_get_all(client: AsyncClient) -> None:
+    """Тестирование функций меню"""
+    code, rspn = await Repo.Menu.read_all(client)
+    assert code == 200
+    assert rspn == []
+
+    data = {"title": "Menu", "description": None}
+    code, rspn = await Repo.Menu.write(client, data)
+
+    code, upd_rspn = await Repo.Menu.read_all(client)
+    assert code == 200
+    assert upd_rspn == [rspn]
+    await Repo.Menu.delete(client, rspn)
+
+
+@pytest.mark.asyncio
+async def test_submenus_get_all(client) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {"title": "Menu", "description": "main menu"}
+    code, rspn = await Repo.Menu.write(client, menu)
+    assert code == 201
+    menu.update(rspn)
+
+    # Проверяем наличие подменю
+    code, rspn = await Repo.Submenu.read_all(client, menu)
+    assert code == 200
+    assert rspn == []
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    submenu.update(rspn)
+
+    # Проверяем наличие подменю
+    code, upd_rspn = await Repo.Submenu.read_all(client, menu)
+    assert code == 200
+    assert upd_rspn == [rspn]
+
+    # удаляем сопутствующее
+    await Repo.Submenu.delete(client, menu, submenu)
+    await Repo.Menu.delete(client, menu)
+
+
+@pytest.mark.asyncio
+async def test_submenus_add(client) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {"title": "Menu", "description": "main menu"}
+    code, rspn = await Repo.Menu.write(client, menu)
+    menu.update(rspn)
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    assert code == 201
+    submenu.update(rspn)
+
+    # удаляем сопутствующее
+    await Repo.Submenu.delete(client, menu, submenu)
+    await Repo.Menu.delete(client, menu)
+
+
+@pytest.mark.asyncio
+async def test_submenus_update(client) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {"title": "Menu", "description": "main menu"}
+    code, rspn = await Repo.Menu.write(client, menu)
+    menu.update(rspn)
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    submenu.update(rspn)
+
+    # Обновляем подменю и проверяем
+    submenu["title"] = "updated_submenu"
+    code, rspn = await Repo.Submenu.update(client, menu, submenu)
+    assert code == 200
+    assert submenu["title"] == rspn["title"]
+    submenu.update(rspn)
+
+    # удаляем сопутствующее
+    await Repo.Submenu.delete(client, menu, submenu)
+    await Repo.Menu.delete(client, menu)
+
+
+@pytest.mark.asyncio
+async def test_submenus_delete(client) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {"title": "Menu", "description": "main menu"}
+    code, rspn = await Repo.Menu.write(client, menu)
+    menu.update(rspn)
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    submenu.update(rspn)
+
+    # Удаляем подменю
+    code = await Repo.Submenu.delete(client, menu, submenu)
+    assert code == 200
+
+    # Проверяем удаленное подменю
+    code, rspn = await Repo.Submenu.get(client, menu, submenu)
+    assert code == 404
+
+    # удаляем сопутствующее
+    await Repo.Menu.delete(client, menu)
+
+
+@pytest.mark.asyncio
+async def test_dishes_get_all(client: AsyncClient) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {
+        "title": "Menu",
+        "description": "main menu",
+    }
+    code, rspn = await Repo.Menu.write(client, menu)
+    menu.update(rspn)
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    submenu.update(rspn)
+
+    # Проверяем все блюда в подменю
+    code, rspn = await Repo.Dish.read_all(client, menu, submenu)
+    assert code == 200
+    assert rspn == []
+
+    # Добавляем блюдо
+    dish = {
+        "title": "dish",
+        "description": "some dish",
+        "price": "12.5",
+        "parent_submenu": submenu["id"],
+    }
+    code, rspn = await Repo.Dish.write(client, menu, submenu, dish)
+    assert code == 201
+    dish.update(rspn)
+
+    code, upd_rspn = await Repo.Dish.read_all(client, menu, submenu)
+
+    assert code == 200
+
+    # удаляем сопутствующее
+    await Repo.Dish.delete(client, menu, submenu, dish)
+    await Repo.Submenu.delete(client, menu, submenu)
+    await Repo.Menu.delete(client, menu)
+
+
+@pytest.mark.asyncio
+async def test_dishes_add(client: AsyncClient) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {
+        "title": "Menu",
+        "description": "main menu",
+    }
+    code, rspn = await Repo.Menu.write(client, menu)
+    menu.update(rspn)
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    submenu.update(rspn)
+
+    # Добавляем блюдо
+    dish = {
+        "title": "dish",
+        "description": "some dish",
+        "price": "12.5",
+        "parent_submenu": submenu["id"],
+    }
+    code, rspn = await Repo.Dish.write(client, menu, submenu, dish)
+    assert code == 201
+    dish.update(rspn)
+
+    # Получаем блюдо
+    code, rspn = await Repo.Dish.get(client, menu, submenu, dish)
+    assert code == 200
+    assert rspn["title"] == dish["title"]
+
+    # удаляем сопутствующее
+    await Repo.Dish.delete(client, menu, submenu, dish)
+    await Repo.Submenu.delete(client, menu, submenu)
+    await Repo.Menu.delete(client, menu)
+
+
+@pytest.mark.asyncio
+async def test_dishes_update(client: AsyncClient) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {
+        "title": "Menu",
+        "description": "main menu",
+    }
+    code, rspn = await Repo.Menu.write(client, menu)
+    menu.update(rspn)
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    submenu.update(rspn)
+
+    # Добавляем блюдо
+    dish = {
+        "title": "dish",
+        "description": "some dish",
+        "price": "12.5",
+        "parent_submenu": submenu["id"],
+    }
+    code, rspn = await Repo.Dish.write(client, menu, submenu, dish)
+    dish.update(rspn)
+
+    # Обновляем блюдо и проверяем
+    dish["title"] = "updated_dish"
+    code, rspn = await Repo.Dish.update(client, menu, submenu, dish)
+    assert code == 200
+    assert dish["title"] == rspn["title"]
+    dish.update(rspn)
+
+    # удаляем сопутствующее
+    await Repo.Dish.delete(client, menu, submenu, dish)
+    await Repo.Submenu.delete(client, menu, submenu)
+    await Repo.Menu.delete(client, menu)
+
+
+@pytest.mark.asyncio
+async def test_dishes_delete(client: AsyncClient) -> None:
+    # Создаем меню и проверяем ответ
+    menu = {
+        "title": "Menu",
+        "description": "main menu",
+    }
+    code, rspn = await Repo.Menu.write(client, menu)
+    menu.update(rspn)
+
+    # Создаем и проверяем подменю
+    submenu = {
+        "title": "Submenu",
+        "description": "submenu",
+        "parent_menu": menu["id"],
+    }
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+    submenu.update(rspn)
+
+    # Добавляем блюдо
+    dish = {
+        "title": "dish",
+        "description": "some dish",
+        "price": "12.5",
+        "parent_submenu": submenu["id"],
+    }
+    code, rspn = await Repo.Dish.write(client, menu, submenu, dish)
+    dish.update(rspn)
+
+    # Удаляем подменю
+    code = await Repo.Dish.delete(client, menu, submenu, dish)
+    assert code == 200
+
+    # Проверяем удаленное блюдо
+    code, rspn = await Repo.Dish.get(client, menu, submenu, dish)
+    assert code == 404
+
+    # удаляем сопутствующее
+    await Repo.Submenu.delete(client, menu, submenu)
+    await Repo.Menu.delete(client, menu)

tests/test_postman.py

@@ -0,0 +1,235 @@
+from typing import Dict
+
+import pytest
+from httpx import AsyncClient
+
+from .repository import Repository as Repo
+
+
+@pytest.mark.asyncio
+async def test_01(client: AsyncClient, session_data: Dict):
+    """Проверяет создание меню"""
+    menu = {"title": "Menu", "description": "some_menu_desc"}
+    code, rspn = await Repo.Menu.write(client, menu)
+
+    assert code == 201
+    code, rspn = await Repo.Menu.get(client, rspn)
+    session_data["target_menu_id"] = rspn.get("id")
+    session_data["target_menu_title"] = rspn.get("title")
+    session_data["target_menu_description"] = rspn.get("description")
+
+    assert code == 200
+    assert "id" in rspn
+    assert "title" in rspn
+    assert "description" in rspn
+    assert "submenus_count" in rspn
+    assert "dishes_count" in rspn
+    assert rspn["title"] == menu.get("title")
+    assert rspn.get("description") == menu.get("description")
+
+
+@pytest.mark.asyncio
+async def test_02(client: AsyncClient, session_data: Dict):
+    submenu = {"title": "Submenu", "description": "submenu_descr"}
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+
+    code, rspn = await Repo.Submenu.write(client, menu, submenu)
+
+    assert code == 201
+    assert "id" in rspn
+    assert "title" in rspn
+    assert "description" in rspn
+    assert "dishes_count" in rspn
+    assert rspn["title"] == submenu.get("title")
+    assert rspn.get("description") == submenu.get("description")
+
+    session_data["target_submenu_id"] = rspn.get("id")
+    session_data["target_submenu_title"] = rspn.get("title")
+    session_data["target_submenu_description"] = rspn.get("description")
+
+
+@pytest.mark.asyncio
+async def test_03_dish1(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    submenu = {
+        "id": session_data.get("target_submenu_id"),
+        "title": session_data.get("target_submenu_title"),
+        "description": session_data.get("target_submenu_description"),
+    }
+    dish = {"title": "dish_1", "description": "dish 1 descr", "price": "12.5"}
+    code, rspn = await Repo.Dish.write(client, menu, submenu, dish)
+
+    assert code == 201
+    assert "id" in rspn
+    assert "title" in rspn
+    assert "description" in rspn
+    assert "price" in rspn
+    assert rspn["title"] == dish.get("title")
+    assert rspn.get("description") == dish.get("description")
+    assert rspn.get("price") == dish.get("price")
+
+    session_data["target_dish_id"] = rspn.get("id")
+    session_data["target_dish_title"] = rspn.get("title")
+    session_data["target_dish_description"] = rspn.get("description")
+    session_data["target_dish_price"] = rspn.get("price")
+
+
+@pytest.mark.asyncio
+async def test_04_dish2(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    submenu = {
+        "id": session_data.get("target_submenu_id"),
+        "title": session_data.get("target_submenu_title"),
+        "description": session_data.get("target_submenu_description"),
+    }
+    dish = {"title": "dish_2", "description": "dish 2 descr", "price": "13.5"}
+    code, rspn = await Repo.Dish.write(client, menu, submenu, dish)
+
+    assert code == 201
+    assert "id" in rspn
+    assert "title" in rspn
+    assert "description" in rspn
+    assert "price" in rspn
+    assert rspn["title"] == dish.get("title")
+    assert rspn.get("description") == dish.get("description")
+    assert rspn.get("price") == dish.get("price")
+
+    session_data["target_dish1_id"] = rspn.get("id")
+    session_data["target_dish1_title"] = rspn.get("title")
+    session_data["target_dish1_description"] = rspn.get("description")
+    session_data["target_dish1_price"] = rspn.get("price")
+
+
+@pytest.mark.asyncio
+async def test_05_check_menu(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    code, rspn = await Repo.Menu.get(client, menu)
+
+    assert code == 200
+    assert "id" in rspn
+    assert "title" in rspn
+    assert "description" in rspn
+    assert rspn.get("submenus_count") == 1
+    assert rspn.get("dishes_count") == 2
+
+
+@pytest.mark.asyncio
+async def test_06_check_submenu(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    submenu = {
+        "id": session_data.get("target_submenu_id"),
+        "title": session_data.get("target_submenu_title"),
+        "description": session_data.get("target_submenu_description"),
+    }
+    code, rspn = await Repo.Submenu.get(client, menu, submenu)
+
+    assert code == 200
+    assert "id" in rspn
+    assert "title" in rspn
+    assert "description" in rspn
+    assert rspn.get("dishes_count") == 2
+
+
+@pytest.mark.asyncio
+async def test_07_del_submenu(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    submenu = {
+        "id": session_data.get("target_submenu_id"),
+        "title": session_data.get("target_submenu_title"),
+        "description": session_data.get("target_submenu_description"),
+    }
+    code = await Repo.Submenu.delete(client, menu, submenu)
+
+    assert code == 200
+
+
+@pytest.mark.asyncio
+async def test_07_check_submenus(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    code, rspn = await Repo.Submenu.read_all(client, menu)
+
+    assert code == 200
+    assert rspn == []
+
+
+@pytest.mark.asyncio
+async def test_08_check_dishes(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    submenu = {
+        "id": session_data.get("target_submenu_id"),
+        "title": session_data.get("target_submenu_title"),
+        "description": session_data.get("target_submenu_description"),
+    }
+    code, rspn = await Repo.Dish.read_all(client, menu, submenu)
+
+    assert code == 200
+    assert rspn == []
+
+
+@pytest.mark.asyncio
+async def test_09_check_menu(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    code, rspn = await Repo.Menu.get(client, menu)
+
+    assert code == 200
+    assert "id" in rspn
+    assert "title" in rspn
+    assert "description" in rspn
+    assert rspn.get("submenus_count") == 0
+    assert rspn.get("dishes_count") == 0
+
+
+@pytest.mark.asyncio
+async def test_10_del_menu(client: AsyncClient, session_data: Dict):
+    menu = {
+        "id": session_data.get("target_menu_id"),
+        "title": session_data.get("target_menu_title"),
+        "description": session_data.get("target_menu_description"),
+    }
+    code = await Repo.Menu.delete(client, menu)
+
+    assert code == 200
+
+
+@pytest.mark.asyncio
+async def test_11_check_menus(client: AsyncClient, session_data: Dict):
+    code, rspn = await Repo.Menu.read_all(client)
+
+    assert code == 200
+    assert rspn == []