feat: expand platform APIs, sources, and test coverage

tests/apps/parsers/test_source_cards_service.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+from apps.parsers.source_cards import (
+    RefreshParamDefinition,
+    SourceCardDefinition,
+    SourceCardService,
+    SourceItemDefinition,
+)
+from django.http import Http404
+from django.test import SimpleTestCase
+from rest_framework.exceptions import ValidationError
+
+
+class SourceCardServiceUnitTest(SimpleTestCase):
+    def test_get_definition_raises_for_unknown_slug(self):
+        with self.assertRaises(Http404):
+            SourceCardService.get_definition("missing-card")
+
+    def test_validate_refresh_params_rejects_unknown_param(self):
+        definition = SourceCardService.get_definition("public-procurements")
+
+        with self.assertRaises(ValidationError) as error:
+            SourceCardService._validate_refresh_params(
+                definition,
+                {"region_code": "77", "unexpected": "value"},
+            )
+
+        self.assertIn("Неизвестные параметры обновления", str(error.exception.detail))
+
+    def test_validate_refresh_params_casts_integers(self):
+        definition = SourceCardService.get_definition("public-procurements")
+
+        validated = SourceCardService._validate_refresh_params(
+            definition,
+            {
+                "region_code": "77",
+                "current_year": "2025",
+                "current_month": "2",
+            },
+        )
+
+        self.assertEqual(
+            validated,
+            {
+                "region_code": "77",
+                "law_type": "44",
+                "current_year": 2025,
+                "current_month": 2,
+            },
+        )
+
+    def test_validate_refresh_params_raises_on_invalid_integer(self):
+        definition = SourceCardService.get_definition("public-procurements")
+
+        with self.assertRaises(ValidationError) as error:
+            SourceCardService._validate_refresh_params(
+                definition,
+                {"region_code": "77", "current_year": "not-a-number"},
+            )
+
+        self.assertIn("Значение должно быть целым числом", str(error.exception.detail))
+
+    @patch(
+        "apps.parsers.source_cards.SourceCardService._enqueue_task",
+        side_effect=[
+            {"task_id": "task-1", "task_name": "apps.parsers.tasks.parse_industrial_production"},
+            {"task_id": "task-2", "task_name": "apps.parsers.tasks.parse_industrial_products"},
+            {"task_id": "task-3", "task_name": "apps.parsers.tasks.parse_manufactures"},
+        ],
+    )
+    def test_refresh_card_for_manufacturers_enqueues_three_tasks(self, enqueue_mock):
+        result = SourceCardService.refresh_card(
+            slug="manufacturers-and-products",
+            requested_by_id=12,
+        )
+
+        self.assertEqual(result["source_card"], "manufacturers-and-products")
+        self.assertEqual([item["task_id"] for item in result["tasks"]], ["task-1", "task-2", "task-3"])
+        self.assertEqual(enqueue_mock.call_count, 3)
+
+    @patch(
+        "apps.parsers.source_cards.SourceCardService._enqueue_task",
+        return_value={"task_id": "task-1", "task_name": "apps.parsers.tasks.sync_inspections"},
+    )
+    def test_launch_refresh_for_inspections_passes_supported_kwargs_only(self, enqueue_mock):
+        definition = SourceCardService.get_definition("planned-inspections")
+
+        result = SourceCardService._launch_refresh(
+            definition,
+            requested_by_id=44,
+            params={
+                "current_year": 2025,
+                "current_month": 3,
+                "use_playwright": True,
+                "ignored": "value",
+            },
+        )
+
+        self.assertEqual(result, [{"task_id": "task-1", "task_name": "apps.parsers.tasks.sync_inspections"}])
+        self.assertEqual(
+            enqueue_mock.call_args.kwargs["kwargs"],
+            {
+                "requested_by_id": 44,
+                "current_year": 2025,
+                "current_month": 3,
+                "use_playwright": True,
+            },
+        )
+
+    @patch(
+        "apps.parsers.source_cards.SourceCardService._enqueue_task",
+        return_value={"task_id": "task-9", "task_name": "apps.parsers.tasks.sync_procurements"},
+    )
+    def test_refresh_card_for_procurements_uses_default_law_type(self, enqueue_mock):
+        result = SourceCardService.refresh_card(
+            slug="public-procurements",
+            requested_by_id=10,
+            params={"region_code": "77", "current_year": "2026"},
+        )
+
+        self.assertEqual(result["source_card"], "public-procurements")
+        self.assertEqual(result["tasks"][0]["task_id"], "task-9")
+        self.assertEqual(
+            enqueue_mock.call_args.kwargs["kwargs"],
+            {
+                "requested_by_id": 10,
+                "region_code": "77",
+                "law_type": "44",
+                "current_year": 2026,
+            },
+        )
+
+    def test_launch_refresh_raises_for_unsupported_card(self):
+        definition = SourceCardDefinition(
+            slug="custom-source",
+            title="Custom",
+            description="Custom card",
+            order=999,
+            task_names=(),
+            source_items=(
+                SourceItemDefinition(
+                    code="custom",
+                    title="Custom",
+                    description="Custom source",
+                ),
+            ),
+        )
+
+        with self.assertRaises(ValidationError) as error:
+            SourceCardService._launch_refresh(
+                definition,
+                requested_by_id=1,
+                params={},
+            )
+
+        self.assertIn("Обновление для карточки не поддерживается", str(error.exception.detail))
+
+    def test_enqueue_task_deletes_background_job_on_async_error(self):
+        task = MagicMock()
+        task.apply_async.side_effect = RuntimeError("broker down")
+        queryset = MagicMock()
+
+        with patch("apps.parsers.source_cards.uuid.uuid4", return_value="task-id-1"):
+            with patch("apps.parsers.source_cards.BackgroundJobService.create_job"):
+                with patch(
+                    "apps.parsers.source_cards.BackgroundJobService.get_queryset",
+                    return_value=queryset,
+                ):
+                    with self.assertRaisesMessage(RuntimeError, "broker down"):
+                        SourceCardService._enqueue_task(
+                            task=task,
+                            task_name="apps.parsers.tasks.sync_procurements",
+                            requested_by_id=5,
+                            meta={"source_card": "public-procurements"},
+                            kwargs={"region_code": "77"},
+                        )
+
+        queryset.filter.assert_called_once_with(task_id="task-id-1")
+        queryset.filter.return_value.delete.assert_called_once_with()
+
+    def test_helper_methods_cover_unknown_codes_and_status_variants(self):
+        self.assertEqual(SourceCardService._get_source_records_count("unknown"), 0)
+        self.assertEqual(SourceCardService._get_source_organizations_count("unknown"), 0)
+        self.assertIsNone(SourceCardService._get_source_data_timestamp("unknown"))
+        self.assertIsNone(SourceCardService._get_latest_load_by_source(None))
+        self.assertEqual(SourceCardService._get_status_label("custom"), "custom")
+
+        unavailable_definition = SourceCardDefinition(
+            slug="unavailable",
+            title="Unavailable",
+            description="Unavailable source",
+            order=1,
+            task_names=(),
+            source_items=(),
+            is_available=False,
+        )
+        in_progress_load = SimpleNamespace(status="in_progress")
+        failed_load = SimpleNamespace(status="failed")
+
+        self.assertEqual(
+            SourceCardService._get_status(
+                definition=unavailable_definition,
+                active_tasks=[],
+                latest_load=None,
+                last_updated_at=None,
+            ),
+            "unavailable",
+        )
+        self.assertEqual(
+            SourceCardService._get_status(
+                definition=SourceCardService.get_definition("financial-indicators"),
+                active_tasks=[{"progress": 10}],
+                latest_load=None,
+                last_updated_at=None,
+            ),
+            "in_progress",
+        )
+        self.assertEqual(
+            SourceCardService._get_status(
+                definition=SourceCardService.get_definition("financial-indicators"),
+                active_tasks=[],
+                latest_load=in_progress_load,
+                last_updated_at=None,
+            ),
+            "in_progress",
+        )
+        self.assertEqual(
+            SourceCardService._get_status(
+                definition=SourceCardService.get_definition("financial-indicators"),
+                active_tasks=[],
+                latest_load=failed_load,
+                last_updated_at=None,
+            ),
+            "error",
+        )
+        self.assertEqual(
+            SourceCardService._get_status(
+                definition=SourceCardService.get_definition("financial-indicators"),
+                active_tasks=[],
+                latest_load=None,
+                last_updated_at=object(),
+            ),
+            "success",
+        )
+        self.assertEqual(
+            SourceCardService._get_status(
+                definition=SourceCardService.get_definition("financial-indicators"),
+                active_tasks=[],
+                latest_load=None,
+                last_updated_at=None,
+            ),
+            "idle",
+        )