From e61f92200df3cb5384488d3cf86e2f97976f149e Mon Sep 17 00:00:00 2001 From: Aleksandr Meshchryakov Date: Thu, 1 Oct 2026 10:20:01 +0200 Subject: [PATCH] fix(user): remove email from accounts --- .gitea/workflows/ci-cd.yml | 3 +- .gitea/workflows/deploy-customer-main.yml | 4 +- README.md | 6 +- docs/implementation/contract-drafts.md | 1 - src/apps/core/permissions.py | 6 +- src/apps/core/services.py | 4 +- src/apps/core/signals.py | 4 +- src/apps/user/admin.py | 6 +- src/apps/user/managers.py | 34 ++++++++ .../user/migrations/0012_remove_user_email.py | 32 ++++++++ src/apps/user/models.py | 19 ++--- src/apps/user/serializers.py | 31 +------- src/apps/user/services.py | 39 +--------- src/apps/user/sso_services.py | 63 ++------------- tests/apps/core/test_services.py | 14 ++-- tests/apps/exchange/test_api.py | 1 - tests/apps/registers/test_backup_import.py | 1 - tests/apps/user/factories.py | 1 - tests/apps/user/test_models.py | 7 +- tests/apps/user/test_serializers.py | 49 ++++-------- tests/apps/user/test_services.py | 35 ++------- tests/apps/user/test_sso.py | 72 +++++++---------- tests/apps/user/test_views.py | 25 +----- tests/apps/user/test_without_email.py | 77 +++++++++++++++++++ 24 files changed, 239 insertions(+), 295 deletions(-) create mode 100644 src/apps/user/managers.py create mode 100644 src/apps/user/migrations/0012_remove_user_email.py create mode 100644 tests/apps/user/test_without_email.py diff --git a/.gitea/workflows/ci-cd.yml b/.gitea/workflows/ci-cd.yml index b611f67..d44c9e0 100644 --- a/.gitea/workflows/ci-cd.yml +++ b/.gitea/workflows/ci-cd.yml @@ -187,7 +187,8 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 5 needs: [build_push] - if: needs.build_push.result == 'success' + # Schema removal requires a coordinated operator release with a database backup. + if: ${{ false }} steps: - name: Checkout code diff --git a/.gitea/workflows/deploy-customer-main.yml b/.gitea/workflows/deploy-customer-main.yml index cdf4e3b..13e90e6 100644 --- a/.gitea/workflows/deploy-customer-main.yml +++ b/.gitea/workflows/deploy-customer-main.yml @@ -1,9 +1,7 @@ name: Deploy Customer Main +# Customer releases are manual; internal hotfix merges must not deploy there. on: - push: - branches: - - main workflow_dispatch: concurrency: diff --git a/README.md b/README.md index c6b77a7..72706c7 100644 --- a/README.md +++ b/README.md @@ -261,9 +261,9 @@ make pre-commit `SSO_CLOCK_SKEW_SECONDS` задаёт допустимое расхождение часов в секундах: по умолчанию 5, разрешено от 0 до 60. Увеличивайте его только при измеренном расхождении с ИАС: допуск применяется к `iat`, `nbf` и `exp`, поэтому продлевает окно принятия просроченного токена на указанное число секунд. Ограничение `exp - iat <= 60` и защита от повторного использования сохраняются. Для stage-портала ИАС используйте маршрут `/sso-redirect` без завершающего слеша; вариант со слешем может перенаправить на главную страницу вместо SSO. -Email в SSO-токене необязателен: отсутствующее поле, `null` и пустая строка означают отсутствие почты. Новый SSO-пользователь создаётся с `email=NULL` и `is_verified=false`; фиктивный адрес не генерируется. Переданный непустой email проверяется на формат, длину и конфликты. Если при следующем входе email отсутствует, сохранённый адрес и его признак подтверждения остаются прежними. Обычная регистрация по-прежнему требует email. +Поле email удалено из модели пользователя, регистрации, административного API, профилей и поиска. Вход использует логин и пароль. Email из подписанного SSO-токена игнорируется: он не проверяется, не сохраняется и не используется для связывания аккаунтов. Признак `is_verified` остаётся отдельным признаком проверки учётной записи и больше не меняется по email из SSO. -Повторный вход использует неизменяемую пару `(iss, user_id)`. Автоматическая первичная привязка к локальному аккаунту по-прежнему требует совпадения логина и непустой почты. При совпадении только логина вход отклоняется. Администратор может явно привязать существующий аккаунт после проверки принадлежности внешнего `user_id` пользователю: +Повторный вход использует неизменяемую пару `(iss, user_id)`. Новый внешний пользователь получает отдельную локальную запись без пароля. Совпадение логина с несвязанным локальным аккаунтом отклоняется; автоматической привязки по логину нет. Администратор может явно привязать существующий аккаунт после проверки принадлежности внешнего `user_id` пользователю: ```bash python src/manage.py link_sso_identity --user-id --expected-username --subject --dry-run @@ -272,7 +272,7 @@ python src/manage.py link_sso_identity --user-id --expected-username Команда использует настроенный `SSO_ISSUER`, не переносит уже занятую identity и не меняет локальные права. До первого успешного входа `last_authenticated_at` равен `NULL`. Сам по себе одинаковый логин не является подтверждением принадлежности аккаунта. -Миграция `0010_sso_optional_email` разрешает NULL в email и времени последнего SSO-входа; данные пользователей сохраняются. При откате приложения оставьте эту совместимую схему: обратная миграция к NOT NULL требует предварительно обработать пользователей без почты и ещё не использованные привязки. +Миграция `0012_remove_user_email` удаляет колонку `users.email` вместе с её данными. Перед применением остановите запись в StateCorp и сделайте проверенную резервную копию БД. Сохраняются ID пользователей, профили, роли и связи SSO. Старые backend-образы несовместимы с новой схемой: откат требует восстановления предрелизной БД и старых образов; обратная миграция сама адреса не восстановит. Старые клиентские поля email принимаются как неизвестные и игнорируются стандартным сериализатором DRF, в ответах их больше нет. После успешной проверки одноразового ES256 JWT backend устанавливает Django session cookie и CSRF cookie и отвечает `303 Location: `. GET callback возвращает 405; токен в URL не принимается. Пустая форма при включённом SSO возвращает 400, при выключенном — 503. diff --git a/docs/implementation/contract-drafts.md b/docs/implementation/contract-drafts.md index cbe490f..8da6b3b 100644 --- a/docs/implementation/contract-drafts.md +++ b/docs/implementation/contract-drafts.md @@ -60,7 +60,6 @@ { "id": 1, "username": "admin", - "email": "admin@example.com", "phone": "+79990000000", "is_active": true, "role": "admin", diff --git a/src/apps/core/permissions.py b/src/apps/core/permissions.py index daaf397..3e26be3 100644 --- a/src/apps/core/permissions.py +++ b/src/apps/core/permissions.py @@ -91,15 +91,15 @@ class IsSuperuser(permissions.BasePermission): class IsVerified(permissions.BasePermission): """ - Разрешает доступ только пользователям с подтверждённым email. + Разрешает доступ только пользователям с подтверждённой учётной записью. Требует наличие поля `is_verified` у модели пользователя. """ - message = "Email не подтверждён" + message = "Учётная запись не подтверждена" def has_permission(self, request: Request, view: APIView) -> bool: - """Проверяет, подтверждён ли email пользователя.""" + """Проверяет, подтверждена ли учётная запись пользователя.""" return ( request.user and request.user.is_authenticated diff --git a/src/apps/core/services.py b/src/apps/core/services.py index 1eb45b0..0c23019 100644 --- a/src/apps/core/services.py +++ b/src/apps/core/services.py @@ -27,9 +27,9 @@ class BaseService(Generic[M]): model = User @classmethod - def create_user(cls, *, email: str, password: str) -> User: + def create_user(cls, *, username: str, password: str) -> User: # Business logic here - user = cls.model.objects.create_user(email=email, password=password) + user = cls.model.objects.create_user(username=username, password=password) return user """ diff --git a/src/apps/core/signals.py b/src/apps/core/signals.py index 5d831d4..a2bc0c4 100644 --- a/src/apps/core/signals.py +++ b/src/apps/core/signals.py @@ -261,7 +261,7 @@ def on_pre_delete( # Пользовательские сигналы для бизнес-событий user_registered = Signal() # Отправляется при регистрации пользователя -user_verified = Signal() # Отправляется при верификации email +user_verified = Signal() # Отправляется при верификации учётной записи password_changed = Signal() # Отправляется при смене пароля @@ -284,7 +284,7 @@ def emit_user_registered(user: Any) -> None: def emit_user_verified(user: Any) -> None: - """Отправляет сигнал о верификации email пользователя.""" + """Отправляет сигнал о верификации учётной записи пользователя.""" user_verified.send(sender=user.__class__, user=user) logger.info(f"Отправлен сигнал user_verified для user_id={user.id}") diff --git a/src/apps/user/admin.py b/src/apps/user/admin.py index 6c389b3..7a707e4 100644 --- a/src/apps/user/admin.py +++ b/src/apps/user/admin.py @@ -66,7 +66,6 @@ class UserAdmin(BaseUserAdmin): inlines = [ProfileInline] list_display = [ "username", - "email", "phone", "is_verified_badge", "is_active_badge", @@ -74,14 +73,14 @@ class UserAdmin(BaseUserAdmin): "created_at", ] list_filter = ["is_staff", "is_superuser", "is_active", "is_verified", "created_at"] - search_fields = ["username", "email", "phone"] + search_fields = ["username", "phone"] ordering = ["-created_at"] list_per_page = 50 date_hierarchy = "created_at" fieldsets = ( (None, {"fields": ("username", "password")}), - (_("Personal info"), {"fields": ("email", "phone")}), + (_("Personal info"), {"fields": ("phone",)}), ( _("Permissions"), { @@ -108,7 +107,6 @@ class UserAdmin(BaseUserAdmin): "classes": ("wide",), "fields": ( "username", - "email", "password1", "password2", "is_staff", diff --git a/src/apps/user/managers.py b/src/apps/user/managers.py new file mode 100644 index 0000000..d672374 --- /dev/null +++ b/src/apps/user/managers.py @@ -0,0 +1,34 @@ +"""Создание пользователей по логину, без электронной почты.""" + +from django.contrib.auth.base_user import AbstractBaseUser +from django.contrib.auth.models import UserManager as DjangoUserManager + + +class UserManager(DjangoUserManager): + """Менеджер локальных пользователей и суперпользователей.""" + + use_in_migrations = True + + def _create_user(self, username, password, **extra_fields): + if not username: + raise ValueError("Логин обязателен") + user = self.model( + username=AbstractBaseUser.normalize_username(username), **extra_fields + ) + user.set_password(password) + user.save(using=self._db) + return user + + def create_user(self, username, password=None, **extra_fields): + extra_fields.setdefault("is_staff", False) + extra_fields.setdefault("is_superuser", False) + return self._create_user(username, password, **extra_fields) + + def create_superuser(self, username, password=None, **extra_fields): + extra_fields.setdefault("is_staff", True) + extra_fields.setdefault("is_superuser", True) + if extra_fields.get("is_staff") is not True: + raise ValueError("Суперпользователь должен иметь is_staff=True") + if extra_fields.get("is_superuser") is not True: + raise ValueError("Суперпользователь должен иметь is_superuser=True") + return self._create_user(username, password, **extra_fields) diff --git a/src/apps/user/migrations/0012_remove_user_email.py b/src/apps/user/migrations/0012_remove_user_email.py new file mode 100644 index 0000000..e2e4a3e --- /dev/null +++ b/src/apps/user/migrations/0012_remove_user_email.py @@ -0,0 +1,32 @@ +# Generated by Django 3.2.25 on 2026-10-01 07:54 + +import apps.user.managers +from django.db import migrations, models + + +class Migration(migrations.Migration): + dependencies = [ + ("user", "0010_sso_optional_email"), + ] + + operations = [ + migrations.AlterModelManagers( + name="user", + managers=[ + ("objects", apps.user.managers.UserManager()), + ], + ), + migrations.RemoveField( + model_name="user", + name="email", + ), + migrations.AlterField( + model_name="user", + name="is_verified", + field=models.BooleanField( + default=False, + help_text="Designates whether the account has been verified.", + verbose_name="account verified", + ), + ), + ] diff --git a/src/apps/user/models.py b/src/apps/user/models.py index f68f9c5..7bd73d1 100644 --- a/src/apps/user/models.py +++ b/src/apps/user/models.py @@ -2,6 +2,8 @@ from django.contrib.auth.models import AbstractUser from django.db import models from django.utils.translation import gettext_lazy as _ +from .managers import UserManager + class User(AbstractUser): """Расширенная модель пользователя""" @@ -28,13 +30,8 @@ class User(AbstractUser): related_query_name="custom_user", ) - email = models.EmailField( - _("email address"), - unique=True, - blank=True, - null=True, - help_text=_("Optional for SSO users. Must be unique when provided."), - ) + email = None + objects = UserManager() phone = models.CharField( _("phone number"), @@ -45,9 +42,9 @@ class User(AbstractUser): ) is_verified = models.BooleanField( - _("email verified"), + _("account verified"), default=False, - help_text=_("Designates whether the user has verified their email."), + help_text=_("Designates whether the account has been verified."), ) created_at = models.DateTimeField(_("created at"), auto_now_add=True) @@ -55,7 +52,7 @@ class User(AbstractUser): updated_at = models.DateTimeField(_("updated at"), auto_now=True) USERNAME_FIELD = "username" - REQUIRED_FIELDS = ["email"] + REQUIRED_FIELDS = [] class Meta: db_table = "users" @@ -64,7 +61,7 @@ class User(AbstractUser): ordering = ["-created_at"] def __str__(self): - return f"{self.username} ({self.email})" + return self.username class Profile(models.Model): diff --git a/src/apps/user/serializers.py b/src/apps/user/serializers.py index 794bf7a..ff1710b 100644 --- a/src/apps/user/serializers.py +++ b/src/apps/user/serializers.py @@ -15,10 +15,6 @@ User = get_user_model() class UserRegistrationSerializer(serializers.ModelSerializer): """Сериализатор для регистрации пользователя""" - email = serializers.EmailField( - validators=[UniqueValidator(queryset=User.objects.all())], - help_text="Email пользователя (уникальный)", - ) password = serializers.CharField( write_only=True, min_length=8, help_text="Пароль (минимум 8 символов)" ) @@ -28,7 +24,7 @@ class UserRegistrationSerializer(serializers.ModelSerializer): class Meta: model = User - fields = ("email", "username", "password", "password_confirm", "phone") + fields = ("username", "password", "password_confirm", "phone") extra_kwargs = { "username": { "validators": [UniqueValidator(queryset=User.objects.all())], @@ -80,7 +76,6 @@ class UserSerializer(serializers.ModelSerializer): model = User fields = ( "id", - "email", "username", "phone", "is_verified", @@ -89,9 +84,6 @@ class UserSerializer(serializers.ModelSerializer): "updated_at", ) read_only_fields = ("id", "is_verified", "created_at", "updated_at") - extra_kwargs = { - "email": {"required": True, "allow_null": False, "allow_blank": False}, - } class CurrentUserProfileSerializer(serializers.ModelSerializer): @@ -144,7 +136,6 @@ class CurrentUserSerializer(serializers.ModelSerializer): fields = ( "id", "username", - "email", "phone", "is_active", "role", @@ -159,7 +150,6 @@ class UserManagementSerializer(serializers.Serializer): id = serializers.IntegerField(read_only=True) username = serializers.CharField(read_only=True) - email = serializers.EmailField(read_only=True, allow_null=True) phone = serializers.CharField(read_only=True, allow_null=True) is_active = serializers.BooleanField(read_only=True) is_verified = serializers.BooleanField(read_only=True) @@ -272,7 +262,6 @@ class ManagedUserSerializer(serializers.ModelSerializer): fields = ( "id", "username", - "email", "phone", "role", "role_label", @@ -312,7 +301,6 @@ class AdminUserCreateSerializer(serializers.ModelSerializer): class Meta: model = User fields = ( - "email", "username", "phone", "password", @@ -324,12 +312,6 @@ class AdminUserCreateSerializer(serializers.ModelSerializer): "last_name", ) extra_kwargs = { - "email": { - "required": True, - "allow_null": False, - "allow_blank": False, - "validators": [UniqueValidator(queryset=User.objects.all())], - }, "username": { "validators": [UniqueValidator(queryset=User.objects.all())], }, @@ -369,7 +351,6 @@ class AdminUserUpdateSerializer(serializers.ModelSerializer): class Meta: model = User fields = ( - "email", "username", "phone", "password", @@ -381,10 +362,6 @@ class AdminUserUpdateSerializer(serializers.ModelSerializer): "last_name", ) - extra_kwargs = { - "email": {"required": True, "allow_null": False, "allow_blank": False}, - } - def validate(self, attrs): profile_fields = {"first_name", "middle_name", "last_name"} if not any(field in attrs for field in profile_fields): @@ -464,12 +441,6 @@ class PasswordChangeSerializer(serializers.Serializer): return attrs -class PasswordResetRequestSerializer(serializers.Serializer): - """Сериализатор для запроса сброса пароля""" - - email = serializers.EmailField(help_text="Email пользователя") - - class PasswordResetConfirmSerializer(serializers.Serializer): """Сериализатор для подтверждения сброса пароля""" diff --git a/src/apps/user/services.py b/src/apps/user/services.py index 7474116..9e05751 100644 --- a/src/apps/user/services.py +++ b/src/apps/user/services.py @@ -24,14 +24,11 @@ class UserService: ROLE_LABELS = dict(ROLE_CHOICES) @classmethod - def create_user( - cls, *, email: str, username: str, password: str, **extra_fields - ) -> User: + def create_user(cls, *, username: str, password: str, **extra_fields) -> User: """ Создает нового пользователя Args: - email: Email пользователя username: Username пользователя password: Пароль **extra_fields: Дополнительные поля @@ -44,33 +41,10 @@ class UserService: """ with transaction.atomic(): user = User.objects.create_user( - email=email, username=username, password=password, **extra_fields + username=username, password=password, **extra_fields ) return user - @classmethod - def get_user_by_email(cls, email: str) -> User: - """Получает пользователя по email - - Raises: - NotFoundError: Если пользователь не найден - """ - try: - return User.objects.get(email=email) - except User.DoesNotExist as e: - raise NotFoundError( - message=f"User with email={email} not found", - details={"email": email}, - ) from e - - @classmethod - def get_user_by_email_or_none(cls, email: str) -> User | None: - """Получает пользователя по email или None""" - try: - return User.objects.get(email=email) - except User.DoesNotExist: - return None - @classmethod def get_user_by_id(cls, user_id: int) -> User: """Получает пользователя по ID @@ -118,7 +92,6 @@ class UserService: if search_term: queryset = queryset.filter( Q(username__icontains=search_term) - | Q(email__icontains=search_term) | Q(phone__icontains=search_term) | Q(profile__first_name__icontains=search_term) | Q(profile__mid_name__icontains=search_term) @@ -128,7 +101,6 @@ class UserService: ordering_fields = [] ordering_map = { "id": ("id", False), - "email": ("email", False), "username": ("username", False), "phone": ("phone", False), "is_active": ("is_active", False), @@ -190,7 +162,6 @@ class UserService: def create_managed_user( cls, *, - email: str, username: str, password: str, role: str, @@ -201,7 +172,6 @@ class UserService: ) -> User: """Создаёт пользователя администратором и назначает ему роль.""" user = User.objects.create_user( - email=email, username=username, password=password, **extra_fields, @@ -358,9 +328,9 @@ class UserService: return profile @classmethod - def verify_email(cls, user_id: int) -> User: + def verify_user(cls, user_id: int) -> User: """ - Подтверждает email пользователя + Подтверждает учётную запись пользователя Args: user_id: ID пользователя @@ -444,7 +414,6 @@ class ProfileService: user = profile.user return { "id": user.id, - "email": user.email, "username": user.username, "is_verified": user.is_verified, "phone": user.phone, diff --git a/src/apps/user/sso_services.py b/src/apps/user/sso_services.py index f9d5a90..9133df5 100644 --- a/src/apps/user/sso_services.py +++ b/src/apps/user/sso_services.py @@ -10,9 +10,7 @@ from django.conf import settings from django.contrib.auth import get_user_model from django.core.cache import cache from django.core.exceptions import ValidationError as DjangoValidationError -from django.core.validators import validate_email from django.db import transaction -from django.db.models import Q from django.utils import timezone from jwt import InvalidTokenError @@ -30,7 +28,6 @@ class SsoClaims: issuer: str subject: str username: str - email: str | None first_name: str middle_name: str last_name: str @@ -101,23 +98,6 @@ def _validate_token_lifetime(payload: dict) -> tuple[int, int]: return issued_at, expires_at -def _optional_email(payload: dict) -> str | None: - email = payload.get("email") - if email is None: - return None - if not isinstance(email, str): - raise SsoAuthenticationError("Некорректный email SSO-пользователя.") - email = email.strip() - if not email: - return None - try: - validate_email(email) - User._meta.get_field("email").run_validators(email) - except DjangoValidationError as exc: - raise SsoAuthenticationError("Некорректный email SSO-пользователя.") from exc - return email - - def verify_sso_token(encoded_token: str) -> SsoClaims: """Проверяет ES256 SSO JWT и возвращает только нужные локальному сервису claims.""" payload = _decode_sso_payload(encoded_token) @@ -130,7 +110,6 @@ def verify_sso_token(encoded_token: str) -> SsoClaims: _, expires_at = _validate_token_lifetime(payload) username = payload.get("username") - email = _optional_email(payload) jti = payload.get("jti") subject = payload.get("user_id") if not isinstance(username, str) or not username.strip(): @@ -153,7 +132,6 @@ def verify_sso_token(encoded_token: str) -> SsoClaims: issuer=str(payload["iss"]), subject=str(subject), username=username, - email=email, first_name=str(payload.get("first_name") or ""), middle_name=str(payload.get("surname") or ""), last_name=str(payload.get("last_name") or ""), @@ -173,10 +151,7 @@ def reserve_sso_token(claims: SsoClaims) -> None: def _ensure_user_claims_available(claims: SsoClaims, *, exclude_user_id=None) -> None: - query = Q(username=claims.username) - if claims.email is not None: - query |= Q(email__iexact=claims.email) - conflicts = User.objects.filter(query) + conflicts = User.objects.filter(username=claims.username) if exclude_user_id is not None: conflicts = conflicts.exclude(id=exclude_user_id) if conflicts.exists(): @@ -199,32 +174,13 @@ def provision_sso_user(claims: SsoClaims): raise SsoAuthenticationError("Локальная учётная запись отключена.") _ensure_user_claims_available(claims, exclude_user_id=user.id) else: - username_user = User.objects.filter(username=claims.username).first() - email_users = ( - list(User.objects.filter(email__iexact=claims.email)[:2]) - if claims.email is not None - else [] - ) - if username_user is not None or email_users: - if ( - username_user is None - or len(email_users) != 1 - or email_users[0].id != username_user.id - ): - raise SsoAuthenticationError( - "Неоднозначное совпадение локальной учётной записи." - ) - user = username_user - if not user.is_active: - raise SsoAuthenticationError("Локальная учётная запись отключена.") - else: - user = User( - username=claims.username, - email=claims.email, - is_verified=claims.email is not None, + if User.objects.filter(username=claims.username).exists(): + raise SsoAuthenticationError( + "Логин уже занят. Требуется явная привязка учётной записи SSO." ) - user.set_unusable_password() - user.save() + user = User(username=claims.username) + user.set_unusable_password() + user.save() identity = SsoIdentity.objects.create( user=user, @@ -234,10 +190,7 @@ def provision_sso_user(claims: SsoClaims): ) user.username = claims.username - if claims.email is not None: - user.email = claims.email - user.is_verified = True - user.save(update_fields=["username", "email", "is_verified", "updated_at"]) + user.save(update_fields=["username", "updated_at"]) profile = user.profile profile.first_name = claims.first_name profile.mid_name = claims.middle_name diff --git a/tests/apps/core/test_services.py b/tests/apps/core/test_services.py index e7b2c2e..cc690b3 100644 --- a/tests/apps/core/test_services.py +++ b/tests/apps/core/test_services.py @@ -20,7 +20,6 @@ class BaseServiceTest(TestCase): def setUp(self): self.user = User.objects.create_user( username="testuser", - email="test@example.com", password="testpass123", # noqa: S106 ) @@ -28,7 +27,6 @@ class BaseServiceTest(TestCase): """Test get_by_id returns entity""" result = UserTestService.get_by_id(self.user.pk) self.assertEqual(result.pk, self.user.pk) - self.assertEqual(result.email, self.user.email) def test_get_by_id_not_found(self): """Test get_by_id raises NotFoundError for non-existent ID""" @@ -52,7 +50,6 @@ class BaseServiceTest(TestCase): """Test get_all returns queryset""" User.objects.create_user( username="testuser2", - email="test2@example.com", password="testpass123", # noqa: S106 ) @@ -61,18 +58,17 @@ class BaseServiceTest(TestCase): def test_filter(self): """Test filter returns filtered queryset""" - result = UserTestService.filter(email="test@example.com") + result = UserTestService.filter(username="testuser") self.assertEqual(result.count(), 1) - self.assertEqual(result.first().email, "test@example.com") def test_exists_true(self): """Test exists returns True when entity exists""" - result = UserTestService.exists(email="test@example.com") + result = UserTestService.exists(username="testuser") self.assertTrue(result) def test_exists_false(self): """Test exists returns False when entity does not exist""" - result = UserTestService.exists(email="nonexistent@example.com") + result = UserTestService.exists(username="nonexistent") self.assertFalse(result) def test_count_all(self): @@ -82,10 +78,10 @@ class BaseServiceTest(TestCase): def test_count_filtered(self): """Test count with filter""" - result = UserTestService.count(email="test@example.com") + result = UserTestService.count(username="testuser") self.assertEqual(result, 1) - result = UserTestService.count(email="nonexistent@example.com") + result = UserTestService.count(username="nonexistent") self.assertEqual(result, 0) def test_update(self): diff --git a/tests/apps/exchange/test_api.py b/tests/apps/exchange/test_api.py index d8676a3..cdb35b7 100644 --- a/tests/apps/exchange/test_api.py +++ b/tests/apps/exchange/test_api.py @@ -381,7 +381,6 @@ class ExchangePackageApiTest(APITestCase): password = get_random_string(16) self.user = User.objects.create_user( username="exchange-admin", - email="exchange@example.com", password=password, ) diff --git a/tests/apps/registers/test_backup_import.py b/tests/apps/registers/test_backup_import.py index 9f8ea8a..337ffae 100644 --- a/tests/apps/registers/test_backup_import.py +++ b/tests/apps/registers/test_backup_import.py @@ -103,7 +103,6 @@ class RegisterBackupImportServiceTest(TestCase): password = f"test-{get_random_string(12)}" self.user = User.objects.create_user( username="admin", - email="admin@example.com", password=password, ) diff --git a/tests/apps/user/factories.py b/tests/apps/user/factories.py index cd768d7..0c6ce76 100644 --- a/tests/apps/user/factories.py +++ b/tests/apps/user/factories.py @@ -14,7 +14,6 @@ class UserFactory(factory.django.DjangoModelFactory): model = User skip_postgeneration_save = True - email = factory.LazyAttribute(lambda _: fake.unique.email()) username = factory.LazyAttribute(lambda _: fake.unique.user_name()) phone = factory.LazyAttribute(lambda _: f"+7{fake.numerify('##########')}") is_verified = False diff --git a/tests/apps/user/test_models.py b/tests/apps/user/test_models.py index 33d1ac7..b1b0bbd 100644 --- a/tests/apps/user/test_models.py +++ b/tests/apps/user/test_models.py @@ -17,12 +17,11 @@ class UserModelTest(TestCase): def test_user_creation(self): """Test user creation""" - self.assertTrue(self.user.email) self.assertTrue(self.user.username) def test_user_str_representation(self): """Test user string representation""" - expected = f"{self.user.username} ({self.user.email})" + expected = self.user.username self.assertEqual(str(self.user), expected) def test_superuser_creation(self): @@ -30,10 +29,6 @@ class UserModelTest(TestCase): self.assertTrue(self.superuser.is_staff) self.assertTrue(self.superuser.is_superuser) - def test_user_email_unique(self): - """Test email field is unique""" - self.assertTrue(self.user._meta.get_field("email").unique) - def test_user_username_required(self): """Test username is required field""" self.assertFalse(self.user._meta.get_field("username").blank) diff --git a/tests/apps/user/test_serializers.py b/tests/apps/user/test_serializers.py index 6aa7525..fb67a47 100644 --- a/tests/apps/user/test_serializers.py +++ b/tests/apps/user/test_serializers.py @@ -32,7 +32,6 @@ class UserRegistrationSerializerTest(TestCase): def setUp(self): self.password = fake.password(length=12, special_chars=False) self.user_data = { - "email": fake.unique.email(), "username": fake.unique.user_name(), "password": self.password, "password_confirm": self.password, @@ -44,29 +43,24 @@ class UserRegistrationSerializerTest(TestCase): serializer = UserRegistrationSerializer(data=self.user_data) self.assertTrue(serializer.is_valid()) - def test_local_registration_still_requires_email(self): - for value in (None, "", "missing"): - data = self.user_data.copy() - if value == "missing": - data.pop("email") - else: - data["email"] = value - serializer = UserRegistrationSerializer(data=data) - self.assertFalse(serializer.is_valid()) - self.assertIn("email", serializer.errors) + def test_local_registration_without_email(self): + serializer = UserRegistrationSerializer(data=self.user_data) + self.assertTrue(serializer.is_valid(), serializer.errors) + self.assertNotIn("email", serializer.fields) - def test_admin_creation_still_requires_email(self): + def test_admin_creation_without_email(self): from apps.user.serializers import AdminUserCreateSerializer - data = { - "username": "local", - "password": self.password, - "first_name": "Test", - "last_name": "User", - } - serializer = AdminUserCreateSerializer(data=data) - self.assertFalse(serializer.is_valid()) - self.assertIn("email", serializer.errors) + serializer = AdminUserCreateSerializer( + data={ + "username": "local", + "password": self.password, + "first_name": "Test", + "last_name": "User", + } + ) + self.assertTrue(serializer.is_valid(), serializer.errors) + self.assertNotIn("email", serializer.fields) def test_passwords_do_not_match(self): """Test validation fails when passwords don't match""" @@ -90,17 +84,6 @@ class UserRegistrationSerializerTest(TestCase): self.assertFalse(serializer.is_valid()) self.assertIn("password", serializer.errors) - def test_duplicate_email(self): - """Test validation fails with duplicate email""" - existing_user = UserFactory.create_user() - data = self.user_data.copy() - data["email"] = existing_user.email - - serializer = UserRegistrationSerializer(data=data) - - self.assertFalse(serializer.is_valid()) - self.assertIn("email", serializer.errors) - def test_duplicate_username(self): """Test validation fails with duplicate username""" existing_user = UserFactory.create_user() @@ -120,7 +103,6 @@ class UserRegistrationSerializerTest(TestCase): user = serializer.save() self.assertIsInstance(user, User) - self.assertEqual(user.email, self.user_data["email"]) self.assertEqual(user.username, self.user_data["username"]) self.assertTrue(user.check_password(self.user_data["password"])) @@ -138,7 +120,6 @@ class UserSerializerTest(TestCase): data = serializer.data self.assertEqual(data["id"], self.user.id) - self.assertEqual(data["email"], self.user.email) self.assertEqual(data["username"], self.user.username) self.assertEqual(data["phone"], self.user.phone) self.assertEqual(data["is_verified"], self.user.is_verified) diff --git a/tests/apps/user/test_services.py b/tests/apps/user/test_services.py index a836541..92ec6a9 100644 --- a/tests/apps/user/test_services.py +++ b/tests/apps/user/test_services.py @@ -19,7 +19,6 @@ class UserServiceTest(TestCase): def setUp(self): self.user = UserFactory.create_user() self.user_data = { - "email": fake.unique.email(), "username": fake.unique.user_name(), "password": fake.password(length=12, special_chars=False), } @@ -29,7 +28,6 @@ class UserServiceTest(TestCase): user = UserService.create_user(**self.user_data) self.assertIsInstance(user, User) - self.assertEqual(user.email, self.user_data["email"]) self.assertEqual(user.username, self.user_data["username"]) self.assertTrue(user.check_password(self.user_data["password"])) self.assertFalse(user.is_verified) # Default value @@ -37,7 +35,6 @@ class UserServiceTest(TestCase): def test_create_user_with_extra_fields(self): """Test user creation with extra fields""" extra_data = self.user_data.copy() - extra_data["email"] = fake.unique.email() extra_data["username"] = fake.unique.user_name() extra_data["phone"] = f"+7{fake.numerify('##########')}" extra_data["is_verified"] = True @@ -47,25 +44,6 @@ class UserServiceTest(TestCase): self.assertEqual(user.phone, extra_data["phone"]) self.assertTrue(user.is_verified) - def test_get_user_by_email_found(self): - """Test getting user by existing email""" - found_user = UserService.get_user_by_email(self.user.email) - self.assertEqual(found_user, self.user) - - def test_get_user_by_email_not_found(self): - """Test getting user by non-existing email raises NotFoundError""" - nonexistent_email = fake.unique.email() - with self.assertRaises(NotFoundError) as context: - UserService.get_user_by_email(nonexistent_email) - - self.assertEqual(context.exception.code, "not_found") - self.assertIn("email", context.exception.message) - - def test_get_user_by_email_or_none_not_found(self): - """Test getting user by non-existing email returns None""" - found_user = UserService.get_user_by_email_or_none(fake.unique.email()) - self.assertIsNone(found_user) - def test_get_user_by_id_found(self): """Test getting user by existing ID""" found_user = UserService.get_user_by_id(self.user.id) @@ -134,22 +112,22 @@ class UserServiceTest(TestCase): refresh = RefreshToken(tokens["refresh"]) self.assertEqual(refresh["user_id"], self.user.id) - def test_verify_email_success(self): - """Test successful email verification""" + def test_verify_user_success(self): + """Test successful account verification""" self.user.is_verified = False self.user.save() - user = UserService.verify_email(self.user.id) + user = UserService.verify_user(self.user.id) self.assertEqual(user.id, self.user.id) self.user.refresh_from_db() self.assertTrue(self.user.is_verified) - def test_verify_email_not_found(self): - """Test email verification for non-existing user raises NotFoundError""" + def test_verify_user_not_found(self): + """Test account verification for non-existing user raises NotFoundError""" nonexistent_id = fake.pyint(min_value=900000, max_value=999999) with self.assertRaises(NotFoundError): - UserService.verify_email(nonexistent_id) + UserService.verify_user(nonexistent_id) class ProfileServiceTest(TestCase): @@ -211,7 +189,6 @@ class ProfileServiceTest(TestCase): self.assertIsNotNone(profile_data) self.assertEqual(profile_data["id"], self.user.id) - self.assertEqual(profile_data["email"], self.user.email) self.assertEqual(profile_data["username"], self.user.username) self.assertEqual(profile_data["first_name"], self.profile.first_name) self.assertEqual(profile_data["mid_name"], self.profile.mid_name) diff --git a/tests/apps/user/test_sso.py b/tests/apps/user/test_sso.py index 2f3075a..6c5b86c 100644 --- a/tests/apps/user/test_sso.py +++ b/tests/apps/user/test_sso.py @@ -195,7 +195,7 @@ class SsoCallbackViewTest(APITestCase): self.assertEqual(response["Location"], "/open-data") user = User.objects.get(username="test30") self.assertFalse(user.has_usable_password()) - self.assertTrue(user.is_verified) + self.assertFalse(user.is_verified) self.assertFalse(user.is_staff) self.assertEqual(user.profile.first_name, "Иван") self.assertEqual(user.profile.mid_name, "Иванович") @@ -231,26 +231,17 @@ class SsoCallbackViewTest(APITestCase): self.assertEqual(first_response.status_code, 303) self.assertEqual(replay_response.status_code, 403) - def test_links_existing_user_only_when_username_and_email_both_match(self): - existing_user = UserFactory.create_user( - username="test30", - email="TEST30@example.com", - is_staff=True, + def test_username_match_cannot_claim_unlinked_local_admin(self): + existing = UserFactory.create_user(username="test30", is_staff=True) + self.assertEqual(self._post_callback(self._token()).status_code, 403) + self.assertFalse( + apps.get_model("user", "SsoIdentity").objects.filter(user=existing).exists() ) - - response = self._post_callback(self._token()) - - self.assertEqual(response.status_code, 303) self.assertEqual(User.objects.count(), 1) - existing_user.refresh_from_db() - self.assertTrue(existing_user.is_staff) - identity_model = apps.get_model("user", "SsoIdentity") - self.assertTrue(identity_model.objects.filter(user=existing_user).exists()) def test_rejects_partial_local_account_collision(self): UserFactory.create_user( username="test30", - email="another@example.com", ) response = self._post_callback(self._token()) @@ -331,40 +322,31 @@ class SsoCallbackViewTest(APITestCase): response = self._post_callback(self._encode_claims(claims)) self.assertEqual(response.status_code, 303) user = User.objects.get(username=f"noemail{index}") - self.assertIsNone(user.email) self.assertFalse(user.is_verified) self.assertFalse(user.has_usable_password()) self.assertEqual(self.client.get("/api/v1/users/me/").status_code, 200) - self.assertEqual(User.objects.filter(email__isnull=True).count(), 4) + self.assertEqual(User.objects.count(), 4) - def test_email_less_identity_reuses_account_and_preserves_existing_email(self): + def test_identity_reuses_account_when_ignored_email_changes(self): self.assertEqual(self._post_callback(self._token()).status_code, 303) user = User.objects.get(username="test30") response = self._post_callback(self._token(email=None, jti="without-email")) self.assertEqual(response.status_code, 303) - user.refresh_from_db() - self.assertEqual(user.email, "test30@example.com") - self.assertTrue(user.is_verified) - self.assertEqual(User.objects.count(), 1) - self.assertEqual(self.client.session["_auth_user_id"], str(user.pk)) + self.assertEqual(User.objects.get(username="test30").pk, user.pk) - def test_email_less_account_can_receive_email_on_later_login(self): + def test_email_claim_is_not_persisted(self): self.assertEqual(self._post_callback(self._token(email=None)).status_code, 303) - response = self._post_callback(self._token(jti="email-added")) - self.assertEqual(response.status_code, 303) - user = User.objects.get(username="test30") - self.assertEqual(user.email, "test30@example.com") - self.assertTrue(user.is_verified) - self.assertEqual(User.objects.count(), 1) + self.assertEqual( + self._post_callback(self._token(jti="email-added")).status_code, 303 + ) + self.assertNotIn("email", self.client.get("/api/v1/users/me/").data) def test_email_less_token_cannot_claim_existing_local_admin(self): user = UserFactory.create_user(username="test30", is_staff=True) - original_email = user.email response = self._post_callback(self._token(email=None)) self.assertEqual(response.status_code, 403) self.assertNotIn("_auth_user_id", self.client.session) user.refresh_from_db() - self.assertEqual(user.email, original_email) self.assertTrue(user.is_staff) self.assertFalse(apps.get_model("user", "SsoIdentity").objects.exists()) @@ -387,11 +369,15 @@ class SsoCallbackViewTest(APITestCase): self.assertEqual(self._post_callback(token).status_code, 303) self.assertEqual(self._post_callback(token).status_code, 403) - def test_invalid_provided_email_is_rejected(self): - for email in (123, [], "not-an-email", "x" * 250 + "@example.com"): - response = self._post_callback(self._token(email=email)) - self.assertEqual(response.status_code, 403) - self.assertFalse(User.objects.exists()) + def test_email_claim_is_ignored_regardless_of_format(self): + for index, email in enumerate( + (123, [], "not-an-email", "x" * 250 + "@example.com") + ): + response = self._post_callback( + self._token(email=email, jti=f"ignored-{index}") + ) + self.assertEqual(response.status_code, 303) + self.assertEqual(User.objects.count(), 1) def _link(self, user, subject="2564", **options): call_command( @@ -407,7 +393,6 @@ class SsoCallbackViewTest(APITestCase): user = UserFactory.create_user( username="test30", is_staff=True, is_verified=False ) - original_email = user.email self._link(user, dry_run=True) identity_model = apps.get_model("user", "SsoIdentity") self.assertFalse(identity_model.objects.exists()) @@ -417,7 +402,6 @@ class SsoCallbackViewTest(APITestCase): response = self._post_callback(self._token(email=None)) self.assertEqual(response.status_code, 303) user.refresh_from_db() - self.assertEqual(user.email, original_email) self.assertFalse(user.is_verified) self.assertTrue(user.is_staff) self.assertIsNotNone( @@ -459,13 +443,15 @@ class SsoCallbackViewTest(APITestCase): self.assertEqual(User.objects.get(username="renamed").pk, original.pk) self.assertEqual(User.objects.count(), 1) - def test_later_email_collision_does_not_modify_identity(self): + def test_email_claim_cannot_change_identity(self): self.assertEqual(self._post_callback(self._token(email=None)).status_code, 303) - UserFactory.create_user(username="other", email="test30@example.com") + user = User.objects.get(username="test30") + other = UserFactory.create_user(username="other") self.assertEqual( - self._post_callback(self._token(jti="email-conflict")).status_code, 403 + self._post_callback(self._token(jti="ignored-email")).status_code, 303 ) - self.assertIsNone(User.objects.get(username="test30").email) + self.assertEqual(self.client.session["_auth_user_id"], str(user.pk)) + self.assertNotEqual(user.pk, other.pk) def test_email_less_login_rejects_missing_security_claims(self): for claim in ( diff --git a/tests/apps/user/test_views.py b/tests/apps/user/test_views.py index c20656d..26513fb 100644 --- a/tests/apps/user/test_views.py +++ b/tests/apps/user/test_views.py @@ -25,7 +25,6 @@ class RegisterViewTest(APITestCase): self.register_url = reverse("api_v1:user:register") self.password = fake.password(length=12, special_chars=False) self.user_data = { - "email": fake.unique.email(), "username": fake.unique.user_name(), "password": self.password, "password_confirm": self.password, @@ -43,7 +42,9 @@ class RegisterViewTest(APITestCase): self.assertIn("access", response.data["tokens"]) # Verify user was created - self.assertTrue(User.objects.filter(email=self.user_data["email"]).exists()) + self.assertTrue( + User.objects.filter(username=self.user_data["username"]).exists() + ) def test_register_passwords_do_not_match(self): """Test registration fails when passwords don't match""" @@ -55,20 +56,6 @@ class RegisterViewTest(APITestCase): self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertIn("non_field_errors", response.data) - def test_register_duplicate_email(self): - """Test registration fails with duplicate email""" - # Create existing user - existing_user = UserFactory.create_user() - - # Use the same email as existing user - data = self.user_data.copy() - data["email"] = existing_user.email - - response = self.client.post(self.register_url, data, format="json") - - self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) - self.assertIn("email", response.data) - def test_register_short_password(self): """Test registration fails with short password""" short_password = fake.pystr(min_chars=3, max_chars=5) @@ -138,7 +125,6 @@ class CurrentUserViewTest(APITestCase): self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data["id"], self.user.id) - self.assertEqual(response.data["email"], self.user.email) self.assertEqual(response.data["is_active"], self.user.is_active) self.assertIn("profile", response.data) self.assertEqual(response.data["profile"]["middle_name"], "") @@ -283,7 +269,6 @@ class AdminUserCrudViewTest(APITestCase): def test_admin_can_create_user_with_role_and_profile(self): password = fake.password(length=12, special_chars=False) payload = { - "email": fake.unique.email(), "username": fake.unique.user_name(), "phone": f"+7{fake.numerify('##########')}", "password": password, @@ -311,8 +296,7 @@ class AdminUserCrudViewTest(APITestCase): duplicate_response = self.client.post( self.list_url, { - "email": self.regular_user.email, - "username": fake.unique.user_name(), + "username": self.regular_user.username, "password": "valid-pass", "first_name": "Иван", "last_name": "Иванов", @@ -322,7 +306,6 @@ class AdminUserCrudViewTest(APITestCase): password_response = self.client.post( self.list_url, { - "email": fake.unique.email(), "username": fake.unique.user_name(), "password": "short", "first_name": "Иван", diff --git a/tests/apps/user/test_without_email.py b/tests/apps/user/test_without_email.py new file mode 100644 index 0000000..5a5b45e --- /dev/null +++ b/tests/apps/user/test_without_email.py @@ -0,0 +1,77 @@ +"""Регрессии управления сотрудниками без поля электронной почты.""" + +import pytest +from apps.user.models import User +from django.core.exceptions import FieldDoesNotExist +from rest_framework.test import APIClient + + +@pytest.mark.django_db +def test_create_multiple_employees_without_email_and_login(): + password = "test-password" # noqa: S105 - synthetic test credential + admin = User.objects.create_superuser(username="owner", password=password) + client = APIClient() + client.force_authenticate(admin) + for index in range(2): + response = client.post( + "/api/v1/users/admin/users/", + { + "username": f"employee-{index}", + "password": "test-password", + "first_name": "Иван", + "last_name": "Иванов", + "role": "user", + }, + format="json", + ) + assert response.status_code == 201, response.data + assert "email" not in response.data + client.force_authenticate(None) + response = client.post( + "/api/v1/users/login/", + { + "username": "employee-0", + "password": "test-password", + }, + format="json", + ) + assert response.status_code == 200, response.data + + +def test_email_is_not_a_model_field(): + with pytest.raises(FieldDoesNotExist): + User._meta.get_field("email") + + +@pytest.mark.django_db +def test_legacy_email_payload_is_ignored(): + from django.urls import reverse + + admin = User.objects.create_superuser(username="legacy-owner") + client = APIClient() + client.force_authenticate(admin) + response = client.post( + reverse("api_v1:user:admin_users"), + { + "username": "legacy-client", + "password": "test-password", + "first_name": "Test", + "last_name": "User", + "email": "", + }, + format="json", + ) + assert response.status_code == 201 + user = User.objects.get(username="legacy-client") + response = client.patch( + reverse("api_v1:user:admin-user-detail", args=[user.pk]), + { + "phone": "+70000000000", + "email": "obsolete@example.test", + }, + format="json", + ) + assert response.status_code == 200 + assert "email" not in response.data + user.refresh_from_db() + assert user.phone == "+70000000000"