feat: expand platform APIs, sources, and test coverage

tests/apps/user/test_serializers.py

@@ -1,8 +1,11 @@
 """Tests for user serializers"""
 
 from apps.user.serializers import (
+    AdminUserCreateSerializer,
+    AdminUserUpdateSerializer,
     LoginSerializer,
     PasswordChangeSerializer,
+    PasswordResetConfirmSerializer,
     ProfileUpdateSerializer,
     TokenSerializer,
     UserRegistrationSerializer,
@@ -110,6 +113,9 @@ class UserSerializerTest(TestCase):
         self.assertEqual(data["email"], self.user.email)
         self.assertEqual(data["username"], self.user.username)
         self.assertEqual(data["phone"], self.user.phone)
+        self.assertEqual(data["role"], "user")
+        self.assertEqual(data["role_label"], "Пользователь")
+        self.assertIn("capabilities", data)
         self.assertEqual(data["is_verified"], self.user.is_verified)
         self.assertIn("profile", data)
         self.assertIn("created_at", data)
@@ -117,7 +123,16 @@ class UserSerializerTest(TestCase):
 
     def test_read_only_fields(self):
         """Test that read-only fields are not writable"""
-        read_only_fields = ["id", "is_verified", "created_at", "updated_at"]
+        read_only_fields = [
+            "id",
+            "is_active",
+            "is_verified",
+            "role",
+            "role_label",
+            "capabilities",
+            "created_at",
+            "updated_at",
+        ]
         serializer = UserSerializer()
 
         for field_name in read_only_fields:
@@ -152,6 +167,45 @@ class UserUpdateSerializerTest(TestCase):
         self.assertEqual(set(serializer.Meta.fields), set(allowed_fields))
 
 
+class AdminUserCreateSerializerTest(TestCase):
+    """Tests for AdminUserCreateSerializer."""
+
+    def test_valid_admin_user_create_data(self):
+        serializer = AdminUserCreateSerializer(
+            data={
+                "email": fake.unique.email(),
+                "username": fake.unique.user_name(),
+                "phone": f"+7{fake.numerify('##########')}",
+                "password": fake.password(length=12, special_chars=False),
+                "role": "user",
+                "is_active": True,
+                "is_verified": False,
+                "first_name": fake.first_name(),
+                "last_name": fake.last_name(),
+            }
+        )
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+
+
+class AdminUserUpdateSerializerTest(TestCase):
+    """Tests for AdminUserUpdateSerializer."""
+
+    def setUp(self):
+        self.user = UserFactory.create_user()
+
+    def test_valid_admin_user_update_data(self):
+        serializer = AdminUserUpdateSerializer(
+            self.user,
+            data={
+                "role": "admin",
+                "is_active": False,
+                "first_name": fake.first_name(),
+            },
+            partial=True,
+        )
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+
+
 class ProfileUpdateSerializerTest(TestCase):
     """Tests for ProfileUpdateSerializer"""
 
@@ -289,3 +343,31 @@ class PasswordChangeSerializerTest(TestCase):
         serializer = PasswordChangeSerializer(data=data)
         self.assertFalse(serializer.is_valid())
         self.assertIn("old_password", serializer.errors)
+
+
+class PasswordResetConfirmSerializerTest(TestCase):
+    """Tests for PasswordResetConfirmSerializer."""
+
+    def test_valid_payload(self):
+        new_password = fake.password(length=12, special_chars=False)
+        serializer = PasswordResetConfirmSerializer(
+            data={
+                "token": fake.sha1(raw_output=False),
+                "new_password": new_password,
+                "new_password_confirm": new_password,
+            }
+        )
+
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+
+    def test_passwords_must_match(self):
+        serializer = PasswordResetConfirmSerializer(
+            data={
+                "token": fake.sha1(raw_output=False),
+                "new_password": fake.password(length=12, special_chars=False),
+                "new_password_confirm": fake.password(length=12, special_chars=False),
+            }
+        )
+
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("non_field_errors", serializer.errors)