Feature/python testing homework

pyproject.toml

@@ -30,6 +30,8 @@ requests = "^2.28"
 attrs = "^23.1"
 pydantic = "^2.3"
 punq = "^0.6"
+mimesis = "^11.1.0"
+isort = "^5.12.0"
 
 [tool.poetry.group.dev.dependencies]
 django-debug-toolbar = "^4.2"

server/apps/identity/logic/usecases/user_create_new.py

@@ -30,7 +30,7 @@ def __call__(self, user: User) -> None:
         https://sobolevn.me/2019/02/engineering-guide-to-user-stories
         """
         new_ids = self._create_lead(user)
-        return self._update_user_ids(user, new_ids)
+        self._update_user_ids(user, new_ids)
 
     def _create_lead(self, user: User) -> placeholder.UserResponse:
         return placeholder.LeadCreate(
@@ -41,8 +41,8 @@ def _create_lead(self, user: User) -> placeholder.UserResponse:
     def _update_user_ids(
         self,
         user: User,
-        new_ids: placeholder.UserResponse,
+        response: placeholder.UserResponse,
     ) -> None:
         # This can be moved to some other place once this becomes too complex:
-        user.lead_id = new_ids.id
+        user.lead_id = response.id
         user.save(update_fields=['lead_id'])

tests/conftest.py

@@ -8,7 +8,7 @@
 
 pytest_plugins = [
     # Should be the first custom one:
-    'plugins.django_settings',
+    # 'plugins.django_settings',
 
     # TODO: add your own plugins here!
 ]

tests/plugins/identity/user.py

@@ -0,0 +1,41 @@
+import datetime as dt
+from typing import Callable, Protocol, TypeAlias, TypedDict, Unpack, final
+
+
+@final
+class UserData(TypedDict, total=False):
+    """
+    Represent the user data that is required to create a new user.
+
+    Does not include `password`, because it's special field in Django.
+    """
+
+    email: str
+    first_name: str
+    last_name: str
+    date_of_birth: dt.datetime
+    address: str
+    job_title: str
+    phone: str
+    lead_id: int
+    is_staff: bool
+    is_active: bool
+
+
+UserAssertion: TypeAlias = Callable[[str, UserData], None]
+
+
+@final
+class RegistrationData(UserData, total=False):
+    """Represent the user data that is required to create a new user."""
+
+    password_first: str
+    password_second: str
+
+
+@final
+class RegistrationDataFactory(Protocol):
+    """User data factory protocol."""
+
+    def __call__(self, **fields: Unpack[RegistrationData]) -> RegistrationData:
+        """User data factory protocol."""

tests/test_server/test_apps/test_identity/conftest.py

@@ -0,0 +1,90 @@
+from typing import Any, Unpack
+
+import pytest
+from mimesis import Field, Schema
+from mimesis.locales import Locale
+
+from server.apps.identity.models import User
+from tests.plugins.identity.user import (
+    RegistrationData,
+    RegistrationDataFactory,
+    UserAssertion,
+    UserData,
+)
+
+
+@pytest.fixture()
+def registration_data_factory() -> RegistrationDataFactory:
+    """Fxture that generate fake registration data."""
+    def factory(**fields: Unpack[RegistrationData]) -> RegistrationData:
+        field = Field(locale=Locale.RU, seed=fields.pop('seed'))
+        password = field('password')
+        schema = Schema(schema=lambda: {
+            'email': field('person.email'),
+            'first_name': field('person.first_name'),
+            'last_name': field('person.last_name'),
+            'date_of_birth': field('datetime.date'),
+            'address': field('address.city'),
+            'job_title': field('person.occupation'),
+            'phone': field('person.telephone'),
+        })
+        return {
+            **schema.create()[0],
+            **{'password_first': password, 'password_second': password},
+            **fields,
+        }
+
+    return factory
+
+
+@pytest.fixture(scope='session')
+def assert_correct_user() -> UserAssertion:
+    """Fixture that check created user attrs from database."""
+    def factory(email: str, expected: UserData) -> None:
+        user = User.objects.get(email=email)
+        assert user.id
+        assert user.is_active
+        assert not user.is_superuser
+        assert not user.is_staff
+        for field, value_name in expected.items():
+            assert getattr(user, field) == value_name
+
+    return factory
+
+
+@pytest.fixture()
+def reg_data(registration_data_factory) -> RegistrationData:
+    """Fixture that return user reg data."""
+    return registration_data_factory(seed=1)
+
+
+@pytest.fixture()
+def expected_user_data(reg_data: RegistrationData) -> dict[str, Any]:
+    """Fixture that return exeected user data."""
+    return {
+        key: value_name
+        for key, value_name in reg_data.items()
+        if not key.startswith('password')
+    }
+
+
+@pytest.fixture()
+def expected_serialized_user(reg_data: RegistrationData) -> dict[str, Any]:
+    """Serialized user's key-values that expected in test."""
+    return {
+        'name': reg_data['first_name'],
+        'last_name': reg_data['last_name'],
+        'birthday': reg_data['date_of_birth'].strftime('%d.%m.%Y'),
+        'city_of_birth': reg_data['address'],
+        'position': reg_data['job_title'],
+        'email': reg_data['email'],
+        'phone': reg_data['phone'],
+    }
+
+
+@pytest.fixture()
+def user(
+    expected_user_data: RegistrationData,
+) -> User:
+    """Return created user in database."""
+    return User.objects.create(**expected_user_data)

tests/test_server/test_apps/test_identity/test_infrastructure/test_services/test_placeholder.py

@@ -0,0 +1,86 @@
+# isort: skip_file
+# flake8: noqa
+from typing import Any
+
+import pytest
+from pydantic import ValidationError
+
+from server.apps.identity.intrastructure.services.placeholder import (
+    LeadCreate,
+    LeadUpdate,
+    UserResponse,
+    _serialize_user,
+)
+from server.apps.identity.models import User
+from server.common.django.types import Settings
+from tests.plugins.identity.user import RegistrationData, UserAssertion
+
+
+@pytest.mark.django_db()
+def test_success_lead_create(
+    user: User,
+    reg_data: RegistrationData,
+    expected_user_data: dict[str, Any],
+    assert_correct_user: UserAssertion,
+    settings: Settings,
+) -> None:
+    """Testing service that create lead user."""
+    assert_correct_user(reg_data['email'], expected_user_data)
+    actual_id = 11
+    actual_response = UserResponse(id=actual_id)
+    expected_id = LeadCreate(
+        api_timeout=settings.PLACEHOLDER_API_TIMEOUT,
+        api_url=settings.PLACEHOLDER_API_URL,
+    )(user=user)
+    assert actual_response.id == expected_id
+
+
+def test_success_url_path(settings: Settings) -> None:
+    """Testing method that create URL path for the request."""
+    expected_url_path = 'https://jsonplaceholder.typicode.com/users'
+    fetcher = LeadCreate(
+        api_timeout=settings.PLACEHOLDER_API_TIMEOUT,
+        api_url=settings.PLACEHOLDER_API_URL,
+    )
+    actual_url_path = fetcher.url_path()
+    assert actual_url_path == expected_url_path
+
+
+@pytest.mark.django_db()
+def test_success_lead_update(
+    user: User,
+    reg_data: RegistrationData,
+    expected_user_data: dict[str, Any],
+    assert_correct_user: UserAssertion,
+    settings: Settings,
+) -> None:
+    """Testing service that update lead user."""
+    assert_correct_user(reg_data['email'], expected_user_data)
+    LeadUpdate(
+        api_timeout=settings.PLACEHOLDER_API_TIMEOUT,
+        api_url=settings.PLACEHOLDER_API_URL,
+    )(user=user)
+
+
+def test_success_validate_user_response() -> None:
+    """Testing UserResponse model, success case."""
+    expected_id = 1
+    actual_id = UserResponse.model_validate({'id': 1}).id
+    assert actual_id == expected_id
+
+
+def test_failed_validate_user_response() -> None:
+    """Testing UserResponse model, failed case."""
+    with pytest.raises(ValidationError) as exc:
+        UserResponse.model_validate({'TEST': 1}).id  # noqa: WPS428
+    assert 'ValidationError' in exc.typename  # noqa: WPS441
+
+
+@pytest.mark.django_db()
+def test_success_serialize_user(
+    user: User,
+    expected_serialized_user: dict[str, Any],
+) -> None:
+    """Testing _serialize_user function."""
+    actial_serialization = _serialize_user(user=user)
+    assert actial_serialization == expected_serialized_user

tests/test_server/test_apps/test_identity/test_logic/test_usecases/test_user_create_new.py

@@ -0,0 +1,48 @@
+from typing import Any
+
+import pytest
+
+from server.apps.identity.intrastructure.services.placeholder import (
+    UserResponse,
+)
+from server.apps.identity.logic.usecases.user_create_new import UserCreateNew
+from server.apps.identity.models import User
+from server.common.django.types import Settings
+from tests.plugins.identity.user import RegistrationData, UserAssertion
+
+
+@pytest.mark.django_db()
+def test_success_create_new_user(
+    user: User,
+    settings: Settings,
+    assert_correct_user: UserAssertion,
+    reg_data: RegistrationData,
+    expected_user_data: dict[str, Any],
+) -> None:
+    """Testing usecase that create new user."""
+    not_lead_user = User.objects.get(email=reg_data['email'])
+    assert not_lead_user.lead_id is None
+    assert_correct_user(reg_data['email'], expected_user_data)
+
+    UserCreateNew(settings=settings)(user=user)
+    lead_user = User.objects.get(email=reg_data['email'])
+    expected_lead_id = 11
+    assert lead_user.lead_id == expected_lead_id
+
+
+@pytest.mark.django_db()
+def test_success_update_user_ids(
+    user: User,
+    settings: Settings,
+    assert_correct_user: UserAssertion,
+    reg_data: RegistrationData,
+    expected_user_data: dict[str, Any],
+) -> None:
+    """Testing usecase that update user id."""
+    assert_correct_user(reg_data['email'], expected_user_data)
+    response = UserResponse(id=100)
+    UserCreateNew(settings=settings)._update_user_ids(  # noqa: WPS437
+        user=user, response=response,
+    )
+    actual_user = User.objects.get(email=reg_data['email'])
+    assert actual_user.lead_id == response.id