feat: обновления парсеров, тестов и миграций

- Обновлены клиенты парсеров (checko, fns, minpromtorg, proverki, zakupki)
- Добавлены новые миграции для моделей
- Расширено покрытие тестами
- Обновлены конфигурации и настройки проекта
- Добавлены утилиты для тестирования

Co-Authored-By: Warp <agent@warp.dev>

tests/apps/core/test_signals.py

@@ -1,204 +1,91 @@
-"""Tests for core signals utilities"""
+"""Tests for core signal dispatcher utilities."""
 
+from __future__ import annotations
+
+from django.contrib.auth import get_user_model
+from django.db.models.signals import post_save
+from django.test import TestCase
 
 from apps.core.signals import (
     SignalDispatcher,
-    emit_password_changed,
-    emit_user_registered,
-    emit_user_verified,
+    on_post_delete,
     on_post_save,
+    on_pre_delete,
     on_pre_save,
-    password_changed,
-    user_registered,
-    user_verified,
+    signal_dispatcher,
 )
-from django.contrib.auth import get_user_model
-from django.db.models.signals import post_save, pre_save
-from django.test import TestCase
-
-from tests.apps.user.factories import UserFactory
-
-User = get_user_model()
+from tests.utils.fixtures import fake
 
 
 class SignalDispatcherTest(TestCase):
-    """Tests for SignalDispatcher"""
+    def test_register_connect_disconnect(self):
+        dispatcher = SignalDispatcher()
+        events: list[int] = []
 
-    def setUp(self):
-        self.dispatcher = SignalDispatcher()
+        def handler(sender, instance, **_kwargs):
+            events.append(instance.pk)
 
-    def test_register_handler(self):
-        """Test handler registration"""
-
-        def my_handler(sender, **kwargs):
-            pass
-
-        self.dispatcher.register(
+        dispatcher.register(
             signal=post_save,
             sender="user.User",
-            handler=my_handler,
-            description="Test handler",
+            handler=handler,
+            description="track user create",
+        )
+        dispatcher.connect_all()
+
+        user = get_user_model().objects.create_user(
+            email=fake.email(), username=fake.user_name(), password="pass"
         )
 
-        self.assertEqual(len(self.dispatcher._handlers), 1)
-        self.assertEqual(self.dispatcher._handlers[0]["handler"], my_handler)
+        self.assertIn(user.pk, events)
+        self.assertTrue(dispatcher.list_handlers())
 
-    def test_list_handlers(self):
-        """Test listing registered handlers"""
+        dispatcher.disconnect_all()
+        self.assertFalse(dispatcher._connected)
 
-        def handler1(sender, **kwargs):
-            pass
-
-        def handler2(sender, **kwargs):
-            pass
-
-        self.dispatcher.register(
+    def test_connect_all_idempotent(self):
+        dispatcher = SignalDispatcher()
+        dispatcher.register(
             signal=post_save,
             sender="user.User",
-            handler=handler1,
-            description="Handler 1",
-        )
-        self.dispatcher.register(
-            signal=pre_save,
-            sender="user.User",
-            handler=handler2,
-            description="Handler 2",
+            handler=lambda *_args, **_kwargs: None,
         )
+        dispatcher.connect_all()
+        dispatcher.connect_all()
+        self.assertTrue(dispatcher._connected)
 
-        handlers = self.dispatcher.list_handlers()
-
-        self.assertEqual(len(handlers), 2)
-        self.assertEqual(handlers[0]["description"], "Handler 1")
-        self.assertEqual(handlers[1]["description"], "Handler 2")
-
-    def test_connect_all(self):
-        """Test connecting all handlers"""
-        handler_called = {"value": False}
-
-        def test_handler(sender, instance, created, **kwargs):
-            handler_called["value"] = True
-
-        self.dispatcher.register(
-            signal=post_save,
-            sender=User,
-            handler=test_handler,
-            description="Test",
-        )
-
-        self.dispatcher.connect_all()
-
-        # Create user to trigger signal
-        UserFactory.create_user()
-
-        self.assertTrue(handler_called["value"])
-
-        # Cleanup
-        self.dispatcher.disconnect_all()
-
-    def test_disconnect_all(self):
-        """Test disconnecting all handlers"""
-        handler_called = {"value": False}
-
-        def test_handler(sender, instance, created, **kwargs):
-            handler_called["value"] = True
-
-        self.dispatcher.register(
-            signal=post_save,
-            sender=User,
-            handler=test_handler,
-            description="Test",
-        )
-
-        self.dispatcher.connect_all()
-        self.dispatcher.disconnect_all()
-
-        # Create user - handler should not be called
-        handler_called["value"] = False
-        UserFactory.create_user()
-
-        self.assertFalse(handler_called["value"])
-
-
-class SignalDecoratorsTest(TestCase):
-    """Tests for signal decorators"""
-
-    def test_on_post_save_registers_handler(self):
-        """Test @on_post_save registers handler"""
-        from apps.core.signals import signal_dispatcher
-
-        initial_count = len(signal_dispatcher._handlers)
-
-        @on_post_save("user.User", description="Test decorator")
-        def my_handler(sender, **kwargs):
-            pass
-
-        new_count = len(signal_dispatcher._handlers)
-        self.assertEqual(new_count, initial_count + 1)
-
-    def test_on_pre_save_registers_handler(self):
-        """Test @on_pre_save registers handler"""
-        from apps.core.signals import signal_dispatcher
-
-        initial_count = len(signal_dispatcher._handlers)
-
-        @on_pre_save("user.User", description="Test pre_save")
-        def my_pre_handler(sender, **kwargs):
-            pass
-
-        new_count = len(signal_dispatcher._handlers)
-        self.assertEqual(new_count, initial_count + 1)
-
-
-class CustomSignalsTest(TestCase):
-    """Tests for custom signals"""
-
-    def setUp(self):
-        self.user = UserFactory.create_user()
-
-    def test_emit_user_registered(self):
-        """Test user_registered signal emission"""
-        handler_called = {"value": False, "user": None}
-
-        def handler(sender, user, **kwargs):
-            handler_called["value"] = True
-            handler_called["user"] = user
-
-        user_registered.connect(handler)
+    def test_decorator_registers_handler(self):
+        original_handlers = list(signal_dispatcher._handlers)
+        original_connected = signal_dispatcher._connected
+        events: list[int] = []
 
         try:
-            emit_user_registered(self.user)
+            signal_dispatcher._handlers = []
+            signal_dispatcher._connected = False
 
-            self.assertTrue(handler_called["value"])
-            self.assertEqual(handler_called["user"], self.user)
+            @on_post_save("user.User", description="decorator")
+            def _handler(sender, instance, **_kwargs):
+                events.append(instance.pk)
+
+            @on_pre_save("user.User")
+            def _pre_save(sender, instance, **_kwargs):
+                return None
+
+            @on_post_delete("user.User")
+            def _post_delete(sender, instance, **_kwargs):
+                return None
+
+            @on_pre_delete("user.User")
+            def _pre_delete(sender, instance, **_kwargs):
+                return None
+
+            signal_dispatcher.connect_all()
+            user = get_user_model().objects.create_user(
+                email=fake.email(), username=fake.user_name(), password="pass"
+            )
+            self.assertIn(user.pk, events)
+            self.assertTrue(signal_dispatcher.list_handlers())
         finally:
-            user_registered.disconnect(handler)
-
-    def test_emit_user_verified(self):
-        """Test user_verified signal emission"""
-        handler_called = {"value": False}
-
-        def handler(sender, user, **kwargs):
-            handler_called["value"] = True
-
-        user_verified.connect(handler)
-
-        try:
-            emit_user_verified(self.user)
-            self.assertTrue(handler_called["value"])
-        finally:
-            user_verified.disconnect(handler)
-
-    def test_emit_password_changed(self):
-        """Test password_changed signal emission"""
-        handler_called = {"value": False}
-
-        def handler(sender, user, **kwargs):
-            handler_called["value"] = True
-
-        password_changed.connect(handler)
-
-        try:
-            emit_password_changed(self.user)
-            self.assertTrue(handler_called["value"])
-        finally:
-            password_changed.disconnect(handler)
+            signal_dispatcher.disconnect_all()
+            signal_dispatcher._handlers = original_handlers
+            signal_dispatcher._connected = original_connected