Добавлены документация и тесты для модуля users

Author: Toksi86

docs/modules/users.md

@@ -92,6 +92,13 @@ def __prepare_user_data(self, user: CustomUser) -> dict[str, Any]:
 
     def __get_user_queryset(self) -> QuerySet[CustomUser]:
         user_content_type = ContentType.objects.get_for_model(CustomUser)
+        program_profiles_count_subquery = (
+            PartnerProgramUserProfile.objects
+            .filter(user_id=OuterRef("id"))
+            .values("user_id")
+            .annotate(total=Count("id"))
+            .values("total")
+        )
         projects_in_program_subquery = (
             PartnerProgramUserProfile.objects
             .filter(user_id=OuterRef("id"))
@@ -114,13 +121,6 @@ def __get_user_queryset(self) -> QuerySet[CustomUser]:
             .values("total_likes")
         )
 
-        projects_in_program_subquery = (
-            CustomUser.objects
-            .filter(partner_program_profiles__user_id=OuterRef("id"))
-            .annotate(total_proj=Count("id"))
-            .values("total_proj")
-        )
-
         users: QuerySet[CustomUser] = (
             CustomUser.objects
             .prefetch_related(
@@ -140,7 +140,7 @@ def __get_user_queryset(self) -> QuerySet[CustomUser]:
                     output_field=IntegerField(),
                 ),
                 program_profiles_count=Coalesce(
-                    Subquery(projects_in_program_subquery, output_field=IntegerField()),
+                    Subquery(program_profiles_count_subquery, output_field=IntegerField()),
                     Value(0),
                     output_field=IntegerField(),
                 ),

users/services/users_activity.py

@@ -0,0 +1,118 @@
+from datetime import date, timedelta
+
+from django.contrib.contenttypes.models import ContentType
+from django.utils import timezone
+
+from core.models import Skill, SkillCategory, SkillToObject, Specialization, SpecializationCategory
+from files.models import UserFile
+from partner_programs.models import PartnerProgram, PartnerProgramUserProfile
+from projects.models import Project
+from users.models import CustomUser
+
+
+def build_user(
+    email: str = "user@example.com",
+    *,
+    password: str = "very_strong_password",
+    first_name: str = "Иван",
+    last_name: str = "Иванов",
+    user_type: int = CustomUser.MEMBER,
+    is_active: bool = True,
+    **extra_fields,
+) -> CustomUser:
+    defaults = {
+        "email": email,
+        "password": password,
+        "first_name": first_name,
+        "last_name": last_name,
+        "birthday": date(2000, 1, 1),
+        "user_type": user_type,
+        "is_active": is_active,
+    }
+    defaults.update(extra_fields)
+    return CustomUser.objects.create_user(**defaults)
+
+
+def build_superuser(email: str = "admin@example.com") -> CustomUser:
+    return CustomUser.objects.create_superuser(
+        email=email,
+        password="very_strong_password",
+        first_name="Админ",
+        last_name="Админов",
+    )
+
+
+def build_skill(name: str = "Python") -> Skill:
+    category, _ = SkillCategory.objects.get_or_create(name="Backend")
+    return Skill.objects.create(name=name, category=category)
+
+
+def attach_skill(user: CustomUser, skill: Skill) -> SkillToObject:
+    return SkillToObject.objects.create(
+        skill=skill,
+        content_type=ContentType.objects.get_for_model(CustomUser),
+        object_id=user.id,
+    )
+
+
+def build_specialization(name: str = "Backend developer") -> Specialization:
+    category, _ = SpecializationCategory.objects.get_or_create(name="IT")
+    return Specialization.objects.create(name=name, category=category)
+
+
+def build_user_file(
+    user: CustomUser,
+    *,
+    link: str = "https://cdn.example.com/file.pdf",
+    extension: str = "pdf",
+    size: int = 1024,
+) -> UserFile:
+    return UserFile.objects.create(
+        user=user,
+        link=link,
+        name="file",
+        extension=extension,
+        mime_type="application/pdf",
+        size=size,
+    )
+
+
+def build_project(
+    leader: CustomUser,
+    *,
+    name: str = "Проект",
+    draft: bool = False,
+) -> Project:
+    return Project.objects.create(name=name, leader=leader, draft=draft)
+
+
+def build_partner_program(
+    *,
+    name: str = "Программа",
+    tag: str = "program",
+    draft: bool = False,
+) -> PartnerProgram:
+    now = timezone.now()
+    return PartnerProgram.objects.create(
+        name=name,
+        tag=tag,
+        city="Екатеринбург",
+        draft=draft,
+        datetime_started=now - timedelta(days=1),
+        datetime_registration_ends=now + timedelta(days=10),
+        datetime_finished=now + timedelta(days=20),
+    )
+
+
+def add_user_to_program(
+    user: CustomUser,
+    program: PartnerProgram,
+    *,
+    project: Project | None = None,
+) -> PartnerProgramUserProfile:
+    return PartnerProgramUserProfile.objects.create(
+        user=user,
+        project=project,
+        partner_program=program,
+        partner_program_data={},
+    )

users/tests.py

@@ -0,0 +1,114 @@
+from django.test import TestCase
+from rest_framework.test import APIClient
+
+from users.models import UserAchievement
+
+from .helpers import build_user, build_user_file
+
+
+class UserAchievementAPITests(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        self.user = build_user(email="achievements@example.com")
+        self.client.force_authenticate(user=self.user)
+
+    def test_user_can_create_achievement_with_owned_file(self):
+        user_file = build_user_file(self.user)
+
+        response = self.client.post(
+            "/auth/users/achievements/",
+            {
+                "title": "Победа",
+                "status": "Первое место",
+                "year": 2024,
+                "file_links": [user_file.link],
+            },
+            format="json",
+        )
+
+        self.assertEqual(response.status_code, 201)
+        achievement = UserAchievement.objects.get(user=self.user)
+        self.assertEqual(achievement.files.get(), user_file)
+
+    def test_user_cannot_create_achievement_for_another_user(self):
+        other_user = build_user(email="achievement-owner@example.com")
+
+        response = self.client.post(
+            "/auth/users/achievements/",
+            {
+                "user": other_user.id,
+                "title": "Победа",
+                "status": "Первое место",
+                "year": 2024,
+            },
+            format="json",
+        )
+
+        self.assertEqual(response.status_code, 403)
+        self.assertFalse(UserAchievement.objects.filter(user=other_user).exists())
+
+    def test_user_cannot_attach_foreign_file_to_achievement(self):
+        other_user = build_user(email="file-owner@example.com")
+        foreign_file = build_user_file(
+            other_user,
+            link="https://cdn.example.com/foreign.pdf",
+        )
+
+        response = self.client.post(
+            "/auth/users/achievements/",
+            {
+                "title": "Победа",
+                "status": "Первое место",
+                "year": 2024,
+                "file_links": [foreign_file.link],
+            },
+            format="json",
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertFalse(UserAchievement.objects.filter(user=self.user).exists())
+
+    def test_profile_update_replaces_achievements_and_validates_owned_files(self):
+        old_achievement = UserAchievement.objects.create(
+            user=self.user,
+            title="Старое достижение",
+            status="Участник",
+            year=2023,
+        )
+        user_file = build_user_file(self.user)
+
+        response = self.client.patch(
+            f"/auth/users/{self.user.id}/",
+            {
+                "achievements": [
+                    {
+                        "title": "Новое достижение",
+                        "status": "Победитель",
+                        "year": 2024,
+                        "file_links": [user_file.link],
+                    }
+                ]
+            },
+            format="json",
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(UserAchievement.objects.filter(id=old_achievement.id).exists())
+        achievement = UserAchievement.objects.get(user=self.user)
+        self.assertEqual(achievement.title, "Новое достижение")
+        self.assertEqual(achievement.files.get(), user_file)
+
+    def test_profile_update_rejects_duplicate_achievements(self):
+        response = self.client.patch(
+            f"/auth/users/{self.user.id}/",
+            {
+                "achievements": [
+                    {"title": "Победа", "status": "Первое место", "year": 2024},
+                    {"title": "Победа", "status": "Первое место", "year": 2024},
+                ]
+            },
+            format="json",
+        )
+
+        self.assertEqual(response.status_code, 400)
+        self.assertFalse(UserAchievement.objects.filter(user=self.user).exists())