fix(user): remove email from accounts
All checks were successful
State Corp Backend CI/CD / Quality gate (push) Successful in 2m45s
State Corp Backend CI/CD / Build linux/amd64 images once (push) Successful in 4m32s
State Corp Backend CI/CD / Release dev (push) Has been skipped
State Corp Backend CI/CD / Refresh and release internal main (push) Has been skipped
State Corp Backend CI/CD / Release customer main (push) Has been skipped

This commit is contained in:
Aleksandr Meshchryakov
2026-10-01 10:20:01 +02:00
parent 7484b3c2b6
commit 2bfbb133bc
24 changed files with 248 additions and 307 deletions

View File

@@ -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):

View File

@@ -432,7 +432,6 @@ class ExchangePackageApiTest(APITestCase):
password = get_random_string(16)
self.user = User.objects.create_user(
username="exchange-admin",
email="exchange@example.com",
password=password,
)

View File

@@ -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,
)

View File

@@ -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

View File

@@ -99,9 +99,7 @@ class UserDeletionTest(APITestCase):
reverse("api_v1:user:admin_users"), {"search": self.user.username}
)
self.assertEqual(response.data["count"], 0)
replacement = UserFactory.create_user(
username=self.user.username, email=self.user.email
)
replacement = UserFactory.create_user(username=self.user.username)
self.assertNotEqual(replacement.pk, self.user_id)
def test_deletion_revokes_access_and_refresh_even_without_outstanding_row(self):

View File

@@ -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)

View File

@@ -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)

View File

@@ -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)
@@ -136,22 +114,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):
@@ -213,7 +191,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)

View File

@@ -196,7 +196,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, "Иванович")
@@ -244,9 +244,8 @@ class SsoCallbackViewTest(APITestCase):
@override_settings(SSO_GROUP_ROLE_MAP_JSON='{"GK-admin":"admin"}')
def test_linked_local_admin_keeps_manual_role_by_default(self):
user = UserFactory.create_user(
username="test30", email="test30@example.com", is_staff=True
)
user = UserFactory.create_user(username="test30", is_staff=True)
self._link(user)
response = self._post_callback(self._token(groups=[], jti="linked-admin"))
user.refresh_from_db()
self.assertEqual(response.status_code, 303)
@@ -258,9 +257,8 @@ class SsoCallbackViewTest(APITestCase):
SSO_MANAGE_LINKED_USER_ROLES=True,
)
def test_linked_local_admin_is_downgraded_when_explicitly_managed(self):
user = UserFactory.create_user(
username="test30", email="test30@example.com", is_staff=True
)
user = UserFactory.create_user(username="test30", is_staff=True)
self._link(user)
response = self._post_callback(self._token(groups=[], jti="managed-admin"))
user.refresh_from_db()
self.assertEqual(response.status_code, 303)
@@ -306,26 +304,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())
@@ -406,40 +395,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())
@@ -462,11 +442,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(
@@ -482,7 +466,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())
@@ -492,7 +475,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(
@@ -534,13 +516,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 (

View File

@@ -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": "Иван",

View File

@@ -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"