Add tests for registration

docker-compose.override.yml

@@ -12,6 +12,10 @@
 version: "3.8"
 services:
 
+  db:
+    ports:
+      - "5432:5432"
+
   web:
     ports:
       # We only bind ports directly in development:

pyproject.toml

@@ -53,6 +53,9 @@ pytest-randomly = "^3.15"
 pytest-timeout = "^2.1"
 hypothesis = "^6.84"
 django-test-migrations = "^1.3"
+httpretty = "^1.1.4"
+mimesis = "^11.1"
+factory-boy = "^3.3"
 
 django-stubs = { version = "^4.2", extras = ["compatible-mypy"] }
 types-requests = "^2.31"

server/apps/pictures/models.py

@@ -22,5 +22,5 @@ class FavouritePicture(TimedMixin, models.Model):
     url = models.URLField()
 
     def __str__(self) -> str:
-        """Beatuful representation."""
+        """Beautiful representation."""
         return '<Picture {0} by {1}>'.format(self.foreign_id, self.user_id)

tests/conftest.py

@@ -11,4 +11,5 @@
     'plugins.django_settings',
 
     # TODO: add your own plugins here!
+    'plugins.identity.user',
 ]

tests/plugins/identity/user.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from typing import Callable, Protocol, TypeAlias, TypedDict, Unpack, final
+
+import pytest
+from mimesis.locales import Locale
+from mimesis.schema import Field, Schema
+
+from server.apps.identity.models import User
+
+
+class UserData(TypedDict, total=False):
+    email: str
+    first_name: str
+    last_name: str
+    date_of_birth: datetime
+    address: str
+    job_title: str
+    phone: str
+    phone_type: int
+
+
+UserAssertion: TypeAlias = Callable[[str, UserData], None]
+
+
+@final
+class RegistrationData(UserData, total=False):
+    password1: str
+    password2: str
+
+
+@final
+class RegistrationDataFactory(Protocol):  # type: ignore[misc]
+    def __call__(self, **fields: Unpack[RegistrationData]) -> RegistrationData:
+        """User registration data factory."""
+
+
+@pytest.fixture(scope="session")
+def assert_correct_user() -> UserAssertion:
+    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_name, data_value in expected.items():
+            assert getattr(user, field_name) == data_value
+
+    return factory
+
+
+@pytest.fixture(scope='function')
+def registration_data_factory(faker_seed: int) -> RegistrationDataFactory:
+    def factory(**fields: Unpack[RegistrationData]) -> RegistrationData:
+        mf = Field(locale=Locale.RU, seed=faker_seed)
+        password = mf('password')
+        schema = Schema(schema=lambda: {
+            'email': mf('person.email'),
+            'first_name': mf('person.first_name'),
+            'last_name': mf('person.last_name'),
+            'date_of_birth': mf('datetime.date'),
+            'job_title': mf('person.occupation'),
+            'phone': mf('person.telephone'),
+            'phone_type': mf('choice', items=[1, 2, 3]),
+        }, iterations=1)
+        return {
+            **next(schema),  # type: ignore[typeddict-item]
+            **{'password1': password, 'password2': password},
+            **fields
+        }
+
+    return factory

tests/test_apps/test_identity/conftest.py

@@ -0,0 +1,26 @@
+from typing import TYPE_CHECKING
+
+import pytest
+
+if TYPE_CHECKING:
+    from tests.plugins.identity.user import (
+        RegistrationData,
+        RegistrationDataFactory,
+        UserData,
+    )
+
+
+@pytest.fixture
+def valid_registration_data(
+    registration_data_factory: 'RegistrationDataFactory'
+) -> 'RegistrationData':
+    return registration_data_factory()
+
+
+@pytest.fixture()
+def valid_user_data(valid_registration_data: 'RegistrationData') -> 'UserData':
+    return {  # type: ignore[return-value]
+        key_name: value_part
+        for key_name, value_part in valid_registration_data.items()
+        if not key_name.startswith('password')
+    }

tests/test_apps/test_identity/test_registration.py

@@ -0,0 +1,57 @@
+from http import HTTPStatus
+from typing import TYPE_CHECKING
+
+import pytest
+from django.test import Client
+from django.urls import reverse
+
+from server.apps.identity.models import User
+
+if TYPE_CHECKING:
+    from tests.plugins.identity.user import (
+        RegistrationData,
+        RegistrationDataFactory,
+        UserAssertion,
+        UserData,
+    )
+
+
+def test_registration_page_exists(client: Client) -> None:
+    response = client.get(reverse('identity:registration'))
+    assert response.status_code == HTTPStatus.OK
+
+
+@pytest.mark.django_db()
+def test_registration_success(
+    client: Client,
+    valid_registration_data: 'RegistrationData',
+    valid_user_data: 'UserData',
+    assert_correct_user: 'UserAssertion',
+) -> None:
+    """Test that registration is successfully with valid registration data."""
+    response = client.post(
+        reverse('identity:registration'),
+        data=valid_registration_data
+    )
+
+    assert response.status_code == HTTPStatus.OK
+    assert_correct_user(valid_registration_data['email'], valid_user_data)
+
+
+@pytest.mark.django_db()
+@pytest.mark.parametrize('field', User.REQUIRED_FIELDS + [User.USERNAME_FIELD])
+def test_registration_missing_required_field(
+    client: Client,
+    registration_data_factory: 'RegistrationDataFactory',
+    field: str,
+) -> None:
+    post_data = registration_data_factory(
+        **{field: ''},  # type: ignore[arg-type]
+    )
+
+    response = client.post(
+        reverse('identity:registration'),
+        data=post_data,
+    )
+    assert response.status_code == HTTPStatus.OK
+    assert not User.objects.filter(email=post_data['email'])

tests/test_server/test_urls.py

@@ -4,7 +4,7 @@
 from django.test import Client
 
 
-@pytest.mark.django_db()()
+@pytest.mark.django_db()
 def test_health_check(client: Client) -> None:
     """This test ensures that health check is accessible."""
     response = client.get('/health/')