Lesson1 updates

docker-compose.yml

@@ -13,6 +13,8 @@ services:
     image: "postgres:15-alpine"
     volumes:
       - pgdata:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
     networks:
       - webnet
       - postgresnet

pyproject.toml

@@ -66,6 +66,7 @@ dennis = "^1.1"
 dump-env = "^1.3"
 ipython = "^8.15"
 import-linter = "^1.11"
+mimesis = "^11.1.0"
 
 [tool.poetry.group.docs]
 optional = true

tests/conftest.py

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

tests/plugins/django_settings.py

@@ -1,7 +1,11 @@
+from random import SystemRandom
+
 import pytest
 from django.conf import LazySettings
 from django.core.cache import BaseCache, caches
 
+MAX_RANDOM_INT = 999999
+
 
 @pytest.fixture(autouse=True)
 def _media_root(
@@ -36,6 +40,12 @@ def _debug(settings: LazySettings) -> None:
         template['OPTIONS']['debug'] = True
 
 
+@pytest.fixture(scope='session', autouse=True)
+def faker_seed() -> int:
+    """Create a random seed for the Faker library."""
+    return SystemRandom().randint(0, MAX_RANDOM_INT)
+
+
 @pytest.fixture(autouse=True)
 def cache(settings: LazySettings) -> BaseCache:
     """Modifies how cache is used in Django tests."""

tests/plugins/identity/user.py

@@ -0,0 +1,101 @@
+"""Identity data related plugins."""
+from datetime import datetime
+from typing import Callable, Protocol, TypeAlias, TypedDict, Unpack, final
+
+import pytest
+from django.contrib.auth import get_user_model
+from django.test import Client
+from django.contrib.auth.models import User
+from mimesis.locales import Locale
+from mimesis.schema import Field, Schema
+
+
+@final
+class ProfileData(TypedDict, total=False):
+    """Represent the simplified profile data."""
+
+    first_name: str
+    last_name: str
+    date_of_birth: datetime
+    address: str
+    job_title: str
+    phone: str
+
+
+ProfileAssertion: TypeAlias = Callable[[str, ProfileData], None]
+
+
+class ProfileDataFactory(Protocol):
+    """Factory for representation of the simplified profile data."""
+
+    def __call__(self, **fields: Unpack[ProfileData]) -> ProfileData:
+        """User data factory protocol."""
+
+
+@pytest.fixture()
+def profile_data_factory(
+    faker_seed: int,
+) -> ProfileDataFactory:
+    """Returns factory for fake random profile data."""
+
+    def factory(**fields: Unpack[ProfileData]) -> ProfileData:
+        mf = Field(locale=Locale.EN, seed=faker_seed)
+        schema = Schema(
+            schema=lambda: {
+                'first_name': mf('person.first_name'),
+                'last_name': mf('person.last_name'),
+                'date_of_birth': mf('datetime.date'),
+                'address': mf('address.city'),
+                'job_title': mf('person.occupation'),
+                'phone': mf('person.telephone'),
+            },
+            iterations=1,
+        )
+        return {
+            **schema.create()[0],  # type: ignore[typeddict-item]
+            **fields,
+        }
+
+    return factory
+
+
+@pytest.fixture(scope='session')
+def assert_correct_profile() -> ProfileAssertion:
+    """All profile fields are equal to reference."""
+
+    def factory(email: str, expected: ProfileData) -> None:
+        user = get_user_model().objects.get(email=email)
+        assert user.id
+        assert user.is_active
+        for field_name, data_value in expected.items():
+            assert getattr(user, field_name) == data_value
+    return factory
+
+
+@pytest.fixture(scope='session')
+def assert_incorrect_profile() -> ProfileAssertion:
+    """At least one field does not match."""
+
+    def factory(email: str, expected: ProfileData) -> None:
+        user = get_user_model().objects.get(email=email)
+        assert user.id
+        assert user.is_active
+        matches = []
+        for field_name, data_value in expected.items():
+            matches.append(getattr(user, field_name) == data_value)
+
+        assert not all(matches)
+
+    return factory
+
+
+@pytest.fixture(scope='function')
+def logged_user_client(client: Client, django_user_model: User):
+    """Client for a logged in user."""
+    password, email = 'password', '[email protected]'
+    user = django_user_model.objects.create_user(
+        email,
+        password,
+    )
+    client.force_login(user)
+    return client

tests/test_server/test_urls.py

@@ -2,6 +2,11 @@
 
 import pytest
 from django.test import Client
+from plugins.identity.user import (
+    ProfileAssertion,
+    ProfileDataFactory,
+    logged_user_client
+)
 
 
 @pytest.mark.django_db()()
@@ -43,6 +48,57 @@ def test_admin_docs_authorized(admin_client: Client) -> None:
     assert b'docutils' not in response.content
 
 
+@pytest.mark.parametrize("url_found", [
+    '/pictures/dashboard',
+    '/pictures/favourites'
+])
+def test_picture_pages_unauthorized(client: Client, url_found: str) -> None:
+    """This test ensures that picture management pages require auth."""
+    response = client.get(url_found)
+    assert response.status_code == HTTPStatus.FOUND
+
+
+@pytest.mark.django_db()
+@pytest.mark.parametrize("url_accessible", [
+    '/pictures/dashboard',
+    '/pictures/favourites'
+])
+def test_picture_pages_authorized(
+    logged_user_client: Client,
+    url_accessible: str
+) -> None:
+    """Ensures picture management pages are accessible for authorized user."""
+
+    response = logged_user_client.get(url_accessible)
+    assert response.status_code == HTTPStatus.OK
+
+
+@pytest.mark.django_db()
+def test_profile_update_authorized(
+    logged_user_client: Client,
+    profile_data_factory: 'ProfileDataFactory',
+    assert_correct_profile: 'ProfileAssertion',
+    assert_incorrect_profile: 'ProfileAssertion',
+) -> None:
+    """This test ensures profile updating for an authorized user."""
+    user_data = profile_data_factory()
+
+    # that is an email for `logged_user_client` fixture
+    # maybe add indirect parametrization?
+    email = '[email protected]'
+
+    # there might be a probability of accidental match, but disregard it for now
+    assert_incorrect_profile(email, user_data)
+
+    response = logged_user_client.post(
+        '/identity/update',
+        data=user_data,
+    )
+    assert response.status_code == HTTPStatus.FOUND
+    assert response.get('Location') == '/identity/update'
+    assert_correct_profile(email, user_data)
+
+
 @pytest.mark.parametrize('page', [
     '/robots.txt',
     '/humans.txt',