Add initial implementations for forms and organization apps with serializers, factories, and admin configurations

tests/apps/user/factories.py

@@ -62,6 +62,7 @@ class ProfileFactory(factory.django.DjangoModelFactory):
 
     user = factory.SubFactory(UserFactory)
     first_name = factory.LazyAttribute(lambda _: fake.first_name())
+    mid_name = factory.LazyAttribute(lambda _: fake.first_name())
     last_name = factory.LazyAttribute(lambda _: fake.last_name())
     bio = factory.LazyAttribute(lambda _: fake.text(max_nb_chars=200))
     date_of_birth = factory.LazyAttribute(
@@ -81,6 +82,8 @@ class ProfileFactory(factory.django.DjangoModelFactory):
                 # Заполняем поля faker'ом, если не переданы
                 if "first_name" not in kwargs:
                     profile.first_name = fake.first_name()
+                if "mid_name" not in kwargs:
+                    profile.mid_name = fake.first_name()
                 if "last_name" not in kwargs:
                     profile.last_name = fake.last_name()
                 if "bio" not in kwargs:

tests/apps/user/test_models.py

@@ -65,8 +65,10 @@ class ProfileModelTest(TestCase):
         self.assertEqual(self.profile.user, self.user)
         # Проверяем, что имена заполнены faker'ом
         self.assertIsNotNone(self.profile.first_name)
+        self.assertIsNotNone(self.profile.mid_name)
         self.assertIsNotNone(self.profile.last_name)
         self.assertTrue(len(self.profile.first_name) > 0)
+        self.assertTrue(len(self.profile.mid_name) > 0)
         self.assertTrue(len(self.profile.last_name) > 0)
 
     def test_profile_str_representation(self):
@@ -90,6 +92,12 @@ class ProfileModelTest(TestCase):
         self.assertTrue(field.blank)
         self.assertTrue(field.null)
 
+    def test_profile_mid_name_optional(self):
+        """Test mid_name field is optional"""
+        field = self.profile._meta.get_field("mid_name")
+        self.assertTrue(field.blank)
+        self.assertTrue(field.null)
+
     def test_profile_bio_optional(self):
         """Test bio field is optional"""
         field = self.profile._meta.get_field("bio")
@@ -112,21 +120,35 @@ class ProfileModelTest(TestCase):
         """Test full_name property"""
         # Test with both names
         first_name = fake.first_name()
+        mid_name = fake.first_name()
         last_name = fake.last_name()
         self.profile.first_name = first_name
+        self.profile.mid_name = mid_name
         self.profile.last_name = last_name
-        self.assertEqual(self.profile.full_name, f"{first_name} {last_name}")
+        self.assertEqual(self.profile.full_name, f"{first_name} {mid_name} {last_name}")
+
+        # Test without last name
+        self.profile.last_name = ""
+        self.assertEqual(self.profile.full_name, f"{first_name} {mid_name}")
 
         # Test with only first name
+        self.profile.mid_name = ""
         self.profile.last_name = ""
         self.assertEqual(self.profile.full_name, first_name)
 
+        # Test with only mid name
+        self.profile.first_name = ""
+        self.profile.mid_name = mid_name
+        self.assertEqual(self.profile.full_name, mid_name)
+
         # Test with only last name
         self.profile.first_name = ""
+        self.profile.mid_name = ""
         self.profile.last_name = last_name
         self.assertEqual(self.profile.full_name, last_name)
 
         # Test with no names (fallback to username)
         self.profile.first_name = ""
+        self.profile.mid_name = ""
         self.profile.last_name = ""
         self.assertEqual(self.profile.full_name, self.profile.user.username)

tests/apps/user/test_serializers.py

@@ -163,6 +163,7 @@ class ProfileUpdateSerializerTest(TestCase):
         """Test valid profile update data"""
         update_data = {
             "first_name": fake.first_name(),
+            "mid_name": fake.first_name(),
             "last_name": fake.last_name(),
             "bio": fake.text(max_nb_chars=200),
             "date_of_birth": str(fake.date_of_birth(minimum_age=18, maximum_age=80)),
@@ -175,13 +176,14 @@ class ProfileUpdateSerializerTest(TestCase):
 
         updated_profile = serializer.save()
         self.assertEqual(updated_profile.first_name, update_data["first_name"])
+        self.assertEqual(updated_profile.mid_name, update_data["mid_name"])
         self.assertEqual(updated_profile.last_name, update_data["last_name"])
         self.assertEqual(updated_profile.bio, update_data["bio"])
 
     def test_fields_allowed(self):
         """Test only allowed fields can be updated"""
         serializer = ProfileUpdateSerializer()
-        allowed_fields = ["first_name", "last_name", "bio", "avatar", "date_of_birth"]
+        allowed_fields = ["first_name", "mid_name", "last_name", "bio", "avatar", "date_of_birth"]
 
         self.assertEqual(set(serializer.Meta.fields), set(allowed_fields))
 
@@ -191,7 +193,7 @@ class LoginSerializerTest(TestCase):
 
     def setUp(self):
         self.login_data = {
-            "email": fake.email(),
+            "username": fake.user_name(),
             "password": fake.password(length=12, special_chars=False),
         }
 
@@ -200,16 +202,16 @@ class LoginSerializerTest(TestCase):
         serializer = LoginSerializer(data=self.login_data)
         self.assertTrue(serializer.is_valid())
 
-    def test_missing_email(self):
-        """Test validation fails without email"""
+    def test_missing_username(self):
+        """Test validation fails without username"""
         data = {"password": fake.password(length=12, special_chars=False)}
         serializer = LoginSerializer(data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertIn("email", serializer.errors)
+        self.assertIn("username", serializer.errors)
 
     def test_missing_password(self):
         """Test validation fails without password"""
-        data = {"email": fake.email()}
+        data = {"username": fake.user_name()}
         serializer = LoginSerializer(data=data)
         self.assertFalse(serializer.is_valid())
         self.assertIn("password", serializer.errors)

tests/apps/user/test_services.py

@@ -160,6 +160,7 @@ class ProfileServiceTest(TestCase):
         self.profile = ProfileFactory.create_profile(user=self.user)
         self.profile_data = {
             "first_name": fake.first_name(),
+            "mid_name": fake.first_name(),
             "last_name": fake.last_name(),
             "bio": fake.text(max_nb_chars=200),
             "date_of_birth": str(fake.date_of_birth(minimum_age=18, maximum_age=80)),
@@ -194,6 +195,7 @@ class ProfileServiceTest(TestCase):
 
         self.assertIsNotNone(updated_profile)
         self.assertEqual(updated_profile.first_name, self.profile_data["first_name"])
+        self.assertEqual(updated_profile.mid_name, self.profile_data["mid_name"])
         self.assertEqual(updated_profile.last_name, self.profile_data["last_name"])
         self.assertEqual(updated_profile.bio, self.profile_data["bio"])
 
@@ -212,6 +214,7 @@ class ProfileServiceTest(TestCase):
         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)
         self.assertEqual(profile_data["last_name"], self.profile.last_name)
         self.assertEqual(profile_data["full_name"], self.profile.full_name)
         self.assertEqual(profile_data["bio"], self.profile.bio)

tests/apps/user/test_views.py

@@ -86,7 +86,7 @@ class LoginViewTest(APITestCase):
         self.password = fake.password(length=12, special_chars=False)
         self.user = UserFactory.create_user(password=self.password)
 
-        self.login_data = {"email": self.user.email, "password": self.password}
+        self.login_data = {"username": self.user.username, "password": self.password}
 
     def test_login_success(self):
         """Test successful login"""
@@ -109,7 +109,7 @@ class LoginViewTest(APITestCase):
     def test_login_nonexistent_user(self):
         """Test login fails for nonexistent user"""
         data = {
-            "email": fake.unique.email(),
+            "username": fake.unique.user_name(),
             "password": fake.password(length=12, special_chars=False),
         }
 
@@ -191,6 +191,7 @@ class ProfileDetailViewTest(APITestCase):
 
         self.update_data = {
             "first_name": fake.first_name(),
+            "mid_name": fake.first_name(),
             "last_name": fake.last_name(),
             "bio": fake.text(max_nb_chars=200),
         }
@@ -208,11 +209,13 @@ class ProfileDetailViewTest(APITestCase):
 
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data["first_name"], self.update_data["first_name"])
+        self.assertEqual(response.data["mid_name"], self.update_data["mid_name"])
         self.assertEqual(response.data["last_name"], self.update_data["last_name"])
 
         # Verify in database
         self.profile.refresh_from_db()
         self.assertEqual(self.profile.first_name, self.update_data["first_name"])
+        self.assertEqual(self.profile.mid_name, self.update_data["mid_name"])
 
     def test_profile_created_if_not_exists(self):
         """Test profile is created if it doesn't exist"""