add infra tests

dmkjfs · dmkjfs · commit 9c38fbb23c98 · 2025-03-09T18:51:56.000+03:00
diff --git a/tests/infrastructure/__init__.py b/tests/infrastructure/__init__.py
diff --git a/tests/infrastructure/api.py b/tests/infrastructure/api.py
@@ -0,0 +1,16 @@
+import pytest
+from fastapi import HTTPException, status
+
+from src.infrastructure.api import ExceptionHandler
+from src.infrastructure.exceptions import Exc
+
+
+class TestExceptionHandler:
+    @pytest.fixture(scope="function")
+    def exceptions(self) -> dict[type[Exc], HTTPException]:
+        return {Exc: HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="detail")}
+
+    async def test_exception_handler(self, exceptions: dict[type[Exc], HTTPException]) -> None:
+        with pytest.raises(HTTPException):
+            async with ExceptionHandler(exceptions=exceptions):
+                raise Exc()
diff --git a/tests/infrastructure/email.py b/tests/infrastructure/email.py
@@ -0,0 +1,25 @@
+import pytest
+
+from src.infrastructure.email import HTMLPage, Templater, TemplateSyntaxError
+
+
+class TestTemplater:
+    @pytest.fixture(scope="function")
+    def html_template(self) -> HTMLPage:
+        return HTMLPage("<html><p>{{param1}}</p><p>{{param2}}</p></html>")
+
+    async def test_templater(self, html_template: HTMLPage):
+        async with Templater() as templater:
+            response = await templater.parse(html_page=html_template, param1="value1", param2="value2")
+
+        assert isinstance(response, HTMLPage)
+        assert response == HTMLPage("<html><p>value1</p><p>value2</p></html>")
+
+        with pytest.raises(TemplateSyntaxError):
+            async with Templater() as templater:
+                await templater.parse(html_page=HTMLPage("<html>{{param1</html"), param1="value1", param2="value2")
+
+
+class TestSMTPSessionMixin:
+    async def test_send_email(self, message: HTMLPage, recipient: str, subject: str) -> None:
+        ...
diff --git a/tests/infrastructure/pages.py b/tests/infrastructure/pages.py
@@ -0,0 +1,48 @@
+import pytest
+
+from src.infrastructure.pages import get_page, get_has_previous, get_has_next
+
+
+class TestPagination:
+    @pytest.fixture(scope="function")
+    def start(self) -> int:
+        return 20
+
+    @pytest.fixture(scope="function")
+    def size(self) -> int:
+        return 10
+
+    @pytest.fixture(scope="function")
+    def total(self) -> int:
+        return 100
+
+    @pytest.mark.parametrize(
+        "size,expected_value",
+        [
+            (10, 3),
+            (3, 7),
+            (30, 2),
+        ]
+    )
+    def test_get_page(self, start: int, size: int, expected_value: int) -> None:
+        assert get_page(start, size) == expected_value
+
+    @pytest.mark.parametrize(
+        "start,expected_value",
+        [
+            (1, False),
+            (2, True),
+        ]
+    )
+    def test_get_has_previous(self, start: int, expected_value: bool) -> None:
+        assert get_has_previous(start) is expected_value
+
+    @pytest.mark.parametrize(
+        "size,expected_value",
+        [
+            (200, False),
+            (4, True),
+        ]
+    )
+    def test_get_has_next(self, total: int, start: int, size: int, expected_value: bool) -> None:
+        assert get_has_next(total, start, size) is expected_value
diff --git a/tests/infrastructure/postgres.py b/tests/infrastructure/postgres.py
@@ -0,0 +1,68 @@
+from types import NoneType
+from typing import Literal
+
+import pytest
+from sqlalchemy import Executable, select
+
+from src.app.social.tags.models import Tag
+from src.infrastructure.postgres import PostgresSessionMixin
+
+
+@pytest.mark.infrastructure
+@pytest.mark.postgres
+class TestPostgresSessionMixin:
+    @pytest.fixture(scope="function")
+    def mixin(self) -> PostgresSessionMixin:
+        return PostgresSessionMixin(table=Tag)
+
+    @pytest.fixture(scope="function")
+    def obj_id(self) -> int:
+        return 1
+
+    @pytest.fixture(scope="function")
+    def statement(self, obj_id: int) -> Executable:
+        return select(Tag).filter(Tag.id == obj_id)
+
+    async def test_create(self, obj: Tag, mixin: PostgresSessionMixin) -> None:
+        async with mixin as session:
+            await session.create(obj)
+
+    @pytest.mark.parametrize(
+        "obj_id,expected_type",
+        [(1, Tag), (100, NoneType)]
+    )
+    async def test_read(
+        self,
+        obj_id: int,
+        mixin: PostgresSessionMixin,
+        expected_type: type,
+    ) -> None:
+        async with mixin as session:
+            response = await session.read(obj_id=obj_id)
+        assert isinstance(response, expected_type)
+
+    async def test_update(self, obj: Tag, mixin: PostgresSessionMixin) -> None:
+        async with mixin as session:
+            await session.update(obj)
+
+    async def test_delete(self, obj_id: int, mixin: PostgresSessionMixin) -> None:
+        async with mixin as session:
+            await session.delete_(obj_id=obj_id)
+
+    @pytest.mark.parametrize(
+        "method,expected_type",
+        [
+            ("scalar", Tag),
+            ("scalars", list[Tag])
+        ]
+    )
+    async def test_run(
+        self,
+        statement: Executable,
+        method: Literal['scalars', 'scalar', 'execute'],
+        mixin: PostgresSessionMixin,
+        expected_type: type,
+    ) -> None:
+        async with mixin as session:
+            response = await session.run(statement, method)
+        assert isinstance(response, expected_type)
diff --git a/tests/infrastructure/s3.py b/tests/infrastructure/s3.py
@@ -0,0 +1,64 @@
+import os
+from io import BytesIO
+from typing import BinaryIO
+
+import pytest
+
+from src.infrastructure.s3 import S3SessionMixin, unique_filename, get_file_stream
+
+
+class TestS3SessionMixin:
+    @pytest.fixture(scope="function")
+    def mixin(self) -> S3SessionMixin:
+        return S3SessionMixin()
+
+    @pytest.fixture(scope="function")
+    def filename(self) -> str:
+        return "filename"
+
+    @pytest.fixture(scope="function")
+    def path(self) -> str:
+        return "/path/"
+
+    @pytest.fixture(scope="function")
+    def file_stream(self) -> BytesIO:
+        return BytesIO()
+
+    async def test_read(self, path: str, filename: str, mixin: S3SessionMixin) -> None:
+        async with mixin as session:
+            response = await session.read(path, filename)
+        assert isinstance(response, str)
+        assert response.startswith("https://storage.yandexcloud.net/")
+        assert response.endswith(os.path.join(path, filename))
+
+    async def test_write(self, path: str, filename: str, file_stream: BytesIO, mixin: S3SessionMixin) -> None:
+        async with mixin as session:
+            response = await session.write(path, filename, file_stream)
+        assert isinstance(response, str)
+
+    async def test_update(self, path: str, filename: str, file_stream: BytesIO, mixin: S3SessionMixin) -> None:
+        async with mixin as session:
+            response = await session.update(path, filename, file_stream)
+        assert isinstance(response, str)
+
+    async def test_remove(self, path: str, filename: str, mixin: S3SessionMixin) -> None:
+        async with mixin as session:
+            await session.remove(path, filename)
+
+
+class TestFileActions:
+    @pytest.fixture(scope="function")
+    def filename(self) -> str:
+        return "filename"
+
+    @pytest.fixture(scope="function")
+    def data(self) -> bytes:
+        return bytes()
+
+    def test_unique_filename(self, filename: str) -> None:
+        response = unique_filename(filename)
+        assert isinstance(response, str)
+
+    def test_get_file_stream(self, data: bytes) -> None:
+        response = get_file_stream(data)
+        assert isinstance(response, BinaryIO)
