Фиксируем модели, UserStory и тесты

net/xeaf/rack/tests/models/account_model_tests.py

@@ -9,64 +9,48 @@
 """
 
 from django.db.utils import IntegrityError
-from django.test import TestCase
 
+from net.xeaf.rack.core import CoreTestCase
+from net.xeaf.rack.management.userstory import AccountTestData
 from net.xeaf.rack.models import AccountModel
 
 
-class AccountModelTests(TestCase):
+class AccountModelTests(CoreTestCase):
     """
     Тесты для класса AccountModel
     """
 
-    def test_create_account_with_defaults(self):
+    def test_user_story_accounts_exist(self):
         """
-        Проверяет корректное создание аккаунта с дефолтными полями
+        Проверяет, что эталонные пользователи успешно созданы в User Story
         """
 
-        email = "test_user@example.com"
+        # Ищем Ивана Иванова по фиксированному UUID
+        ivanov = AccountModel.objects.get(id=AccountTestData.I_IVANOV_ID)
 
-        # Создаем через чистый ORM, как ты любишь, построчно
-        account = AccountModel()
-        account.username = email
-        account.save()
+        self.assertEqual(ivanov.username, "i.ivanov@xeaf.net")
+        self.assertEqual(ivanov.full_name, "Иван И. Иванов")
+        self.assertEqual(ivanov.get_short_name(), "Иван")
 
-        # Проверяем контракт полей
-        self.assertEqual(account.username, email)
-        self.assertIsNone(account.full_name)
-        self.assertIsNone(account.nick_name)
+        # Проверяем, что наше исправление JSONField (default=dict) работает:
+        # Поле extra должно быть пустым словарем, а не None, готовым к .update()
+        self.assertEqual(ivanov.extra, {})
 
-        # Если ты исправил дефолт на dict, тест гарантирует безопасность:
-        self.assertEqual(account.extra, {})
+    def test_password_hashing_works(self):
+        """Проверяет, что пароли пользователей в User Story захешированы, а не лежат строкой"""
+        ivanov = AccountModel.objects.get(id=AccountTestData.I_IVANOV_ID)
 
-    def test_compatibility_methods(self):
-        """
-        Проверяет методы совместимости get_full_name и get_short_name
-        """
-
-        account = AccountModel()
-        account.username = "names@example.com"
-        account.full_name = "Иван Иванов"
-        account.nick_name = "vanya"
-        account.save()
-
-        self.assertEqual(account.get_full_name(), "Иван Иванов")
-        self.assertEqual(account.get_short_name(), "vanya")
+        # Проверяем, что стандартный джанговский механизм проверки пароля работает
+        self.assertTrue(ivanov.check_password(AccountTestData.DEFAULT_PASSWORD))
+        # Гарантируем, что в базе лежит хэш, а не сырая строка
+        self.assertNotEqual(ivanov.password, AccountTestData.DEFAULT_PASSWORD)
 
     def test_username_uniqueness_constraint(self):
-        """
-        Проверяет жесткое ограничение уникальности на уровне UniqueConstraint
-        """
-
-        duplicate_email = "duplicate@example.com"
-
-        # Создаем первого
-        account1 = AccountModel(username=duplicate_email)
-        account1.save()
-
-        # Попытка создать второго с тем же username должна намертво упасть в БД
-        account2 = AccountModel(username=duplicate_email)
+        """Проверяет жесткое ограничение уникальности email-username"""
+        # Попытка создать пользователя с дублирующим email Ивана должна намертво упасть
+        duplicate_account = AccountModel()
+        duplicate_account.username = "i.ivanov@xeaf.net"
 
         with self.assertRaises(IntegrityError):
-            account2.save()
+            duplicate_account.save()
 

net/xeaf/rack/tests/models/session_model_tests.py

@@ -9,75 +9,56 @@
 """
 
 from django.db.utils import IntegrityError
-from django.test import TestCase
+from django.utils import timezone
 
-from net.xeaf.rack.managers import CryptoManager
-from net.xeaf.rack.models import AccountModel
+from net.xeaf.rack.core import CoreTestCase
+from net.xeaf.rack.management.userstory import AccountTestData
+from net.xeaf.rack.management.userstory import SessionTestData
 from net.xeaf.rack.models import SessionModel
 
 
-class SessionModelTests(TestCase):
+class SessionModelTests(CoreTestCase):
     """
     Тесты для класса SessionModel
     """
 
-    def setUp(self):
+    def test_user_story_sessions_exist_and_linked(self):
         """
-        Атомарно создаем тестовых пользователей для связей
+        Проверяет, что сессии из User Story созданы и правильно связаны с аккаунтами
         """
 
-        self.primary_user = AccountModel.objects.create_user(
-            username="primary@example.com",
-            password="secure_password_123"
-        )
-        self.actual_user = AccountModel.objects.create_user(
-            username="actual@example.com",
-            password="secure_password_456"
-        )
+        # Ищем сессию Ивана по фиксированному токену
+        session = SessionModel.objects.get(token=SessionTestData.I_IVANOV_SESSION_TOKEN)
 
-    def test_create_session_with_defaults_and_relations(self):
-        """
-        Проверяет успешное создание сессии, заполнение дефолтных полей и внешних ключей
-        """
+        # Проверяем связи (включая твой крутой механизм имперсонации)
+        self.assertEqual(session.account_id, AccountTestData.I_IVANOV_ID)
+        self.assertEqual(session.actual_account_id, AccountTestData.I_IVANOV_ID)
 
-        token_str = CryptoManager.gen_token()
-
-        session = SessionModel()
-        session.token = token_str
-        session.account = self.primary_user
-        session.actual_account = self.actual_user
-        session.renew(3600)
-        session.save()
-
-        # Проверяем контракт полей и связей
-        self.assertEqual(session.token, token_str)
-        self.assertEqual(session.account.id, self.primary_user.id)
-        self.assertEqual(session.actual_account.id, self.actual_user.id)
+        # Проверяем дефолты текстовых полей, которые мы закладывали в модель
         self.assertEqual(session.device_id, "WEB")
+        self.assertIsNone(session.fcm_token)
+
+    def test_session_expiration_logic(self):
+        """
+        Проверяет, что метод renew() правильно выставил expires_at в будущем
+        """
+
+        session = SessionModel.objects.get(token=SessionTestData.I_IVANOV_SESSION_TOKEN)
+
+        # Сессия должна быть активной прямо сейчас
+        self.assertGreater(session.expires_at, timezone.now())
 
     def test_token_uniqueness_constraint(self):
         """
-        Проверяет жесткое ограничение уникальности токена сессии в базе данных
+        Проверяет жесткое ограничение уникальности токенов сессий
         """
 
-        duplicate_token = "same_token_xyz"
-
-        # Создаем первую валидную сессию
-        session1 = SessionModel(
-            token=duplicate_token,
-            account=self.primary_user,
-            actual_account=self.actual_user
-        )
-        session1.renew(3600)
-        session1.save()
-
-        # Попытка создать вторую сессию с тем же токеном должна намертво упасть в БД
-        session2 = SessionModel(
-            token=duplicate_token,
-            account=self.primary_user,
-            actual_account=self.actual_user
-        )
+        # Попытка создать новую сессию с токеном Петра должна упасть
+        duplicate_session = SessionModel()
+        duplicate_session.token = SessionTestData.P_PETROV_SESSION_TOKEN
+        duplicate_session.account_id = AccountTestData.I_IVANOV_ID
+        duplicate_session.actual_account_id = AccountTestData.I_IVANOV_ID
+        duplicate_session.expire()
 
         with self.assertRaises(IntegrityError):
-            session2.renew(3600)
-            session2.save()
+            duplicate_session.save()