fix pre-commit

tests/apps/backups/test_services.py

@@ -39,7 +39,6 @@ from tests.apps.registers.factories import (
 )
 from tests.apps.user.factories import UserFactory
 
-
 TEST_BACKUP_KEY = base64.urlsafe_b64encode(b"k" * 32).decode("ascii").rstrip("=")
 
 
@@ -146,7 +145,9 @@ class BackupExportServiceTest(TestCase):
             period_end=200,
         )
 
-        artifact = BackupExportService.build_backup_archive(actual_date=date(2026, 3, 15))
+        artifact = BackupExportService.build_backup_archive(
+            actual_date=date(2026, 3, 15)
+        )
 
         self.assertIsInstance(artifact, BackupArtifact)
         self.assertEqual(artifact.organizations_count, 1)
@@ -174,7 +175,9 @@ class BackupExportServiceTest(TestCase):
         self.assertEqual(payload["actual_date"], "2026-03-15")
         self.assertEqual(payload["organizations_count"], 1)
         self.assertEqual(len(payload["data"]["registers.Organization"]), 1)
-        self.assertEqual(payload["data"]["registers.Organization"][0]["pn_name"], "Active Org")
+        self.assertEqual(
+            payload["data"]["registers.Organization"][0]["pn_name"], "Active Org"
+        )
         self.assertEqual(len(payload["data"]["parsers.FinancialReportLine"]), 1)
 
     def test_normalize_value_supports_scalar_types(self):
@@ -217,12 +220,11 @@ class BackupExportServiceTest(TestCase):
         with patch(
             "apps.backups.services.base64.urlsafe_b64decode",
             side_effect=ValueError("bad base64"),
+        ), self.assertRaisesMessage(
+            BackupExportError,
+            "BACKUP_ENCRYPTION_KEY должен быть base64-url кодированным ключом",
         ):
-            with self.assertRaisesMessage(
-                BackupExportError,
-                "BACKUP_ENCRYPTION_KEY должен быть base64-url кодированным ключом",
-            ):
-                BackupExportService._read_encryption_key()
+            BackupExportService._read_encryption_key()
 
     @override_settings(
         BACKUP_ENCRYPTION_KEY=base64.urlsafe_b64encode(b"short").decode("ascii")
@@ -243,15 +245,16 @@ class BackupExportServiceTest(TestCase):
             def encode(self, *_args, **_kwargs):
                 return HugeBytes(b"{}")
 
-        with patch("apps.backups.services.json.dumps", return_value=HugeJson("{}")):
-            with self.assertRaisesMessage(
-                BackupExportError,
-                "Заголовок backup контейнера слишком большой",
-            ):
-                BackupExportService._build_bin_container(
-                    encrypted_payload=b"payload",
-                    header_payload={},
-                )
+        with patch(
+            "apps.backups.services.json.dumps", return_value=HugeJson("{}")
+        ), self.assertRaisesMessage(
+            BackupExportError,
+            "Заголовок backup контейнера слишком большой",
+        ):
+            BackupExportService._build_bin_container(
+                encrypted_payload=b"payload",
+                header_payload={},
+            )
 
 
 class BackupExportJobServiceTest(TestCase):
@@ -286,7 +289,9 @@ class BackupExportJobServiceTest(TestCase):
         self.assertEqual(download_result.action, "download")
 
     def test_enqueue_backup_task_calls_celery(self):
-        with patch("apps.backups.tasks.generate_backup_for_date.apply_async") as apply_async:
+        with patch(
+            "apps.backups.tasks.generate_backup_for_date.apply_async"
+        ) as apply_async:
             BackupExportJobService._enqueue_backup_task(job_id=5, task_id="task-5")
 
         apply_async.assert_called_once_with(kwargs={"job_id": 5}, task_id="task-5")
@@ -305,20 +310,24 @@ class BackupExportJobServiceTest(TestCase):
             BackupExportJobService.consume_ready_archive(actual_date=job.actual_date)
 
     def test_consume_ready_archive_deletes_job_when_file_missing(self):
-        job = BackupExportJob.objects.create(
-            actual_date=date(2026, 3, 22),
-            status=BackupExportJob.Status.SUCCESS,
-            task_id="task-success",
-            archive_path="/tmp/does-not-exist.zip",
-        )
+        with TemporaryDirectory() as tmp_dir:
+            missing_archive = Path(tmp_dir) / "does-not-exist.zip"
+            job = BackupExportJob.objects.create(
+                actual_date=date(2026, 3, 22),
+                status=BackupExportJob.Status.SUCCESS,
+                task_id="task-success",
+                archive_path=str(missing_archive),
+            )
 
-        with self.assertRaisesMessage(
-            BackupExportError,
-            "Файл бэкапа отсутствует, запустите формирование снова",
-        ):
-            BackupExportJobService.consume_ready_archive(actual_date=job.actual_date)
+            with self.assertRaisesMessage(
+                BackupExportError,
+                "Файл бэкапа отсутствует, запустите формирование снова",
+            ):
+                BackupExportJobService.consume_ready_archive(
+                    actual_date=job.actual_date
+                )
 
-        self.assertTrue(BackupExportJob.objects.filter(id=job.id).exists())
+            self.assertTrue(BackupExportJob.objects.filter(id=job.id).exists())
 
     def test_consume_ready_archive_reads_file_and_uses_path_name_as_fallback(self):
         with TemporaryDirectory() as tmp_dir:
@@ -335,7 +344,9 @@ class BackupExportJobServiceTest(TestCase):
                 organizations_count=3,
             )
 
-            artifact = BackupExportJobService.consume_ready_archive(actual_date=job.actual_date)
+            artifact = BackupExportJobService.consume_ready_archive(
+                actual_date=job.actual_date
+            )
 
         self.assertEqual(artifact.archive_bytes, archive_bytes)
         self.assertEqual(artifact.archive_filename, "backup-export.zip")
@@ -355,16 +366,16 @@ class BackupExportJobServiceTest(TestCase):
                 archive_path=str(stale_path),
             )
 
-            with patch("apps.backups.services.uuid.uuid4", return_value="new-task-id"):
-                with patch.object(
-                    BackupExportJobService,
-                    "_enqueue_backup_task",
-                ) as enqueue_mock:
-                    with self.captureOnCommitCallbacks(execute=True):
-                        result = BackupExportJobService.check_or_start_job(
-                            actual_date=today,
-                            requested_by_id=user.id,
-                        )
+            with patch(
+                "apps.backups.services.uuid.uuid4", return_value="new-task-id"
+            ), patch.object(
+                BackupExportJobService,
+                "_enqueue_backup_task",
+            ) as enqueue_mock, self.captureOnCommitCallbacks(execute=True):
+                result = BackupExportJobService.check_or_start_job(
+                    actual_date=today,
+                    requested_by_id=user.id,
+                )
 
         self.assertEqual(result.action, "started")
         self.assertEqual(result.task_id, "new-task-id")
@@ -374,7 +385,9 @@ class BackupExportJobServiceTest(TestCase):
         self.assertEqual(new_job.task_id, "new-task-id")
         enqueue_mock.assert_called_once_with(job_id=new_job.id, task_id="new-task-id")
 
-    def test_check_or_start_job_retries_create_after_integrity_error_with_stale_job(self):
+    def test_check_or_start_job_retries_create_after_integrity_error_with_stale_job(
+        self,
+    ):
         today = date(2026, 3, 26)
         user = UserFactory.create_user()
         stale_job = BackupExportJob.objects.create(
@@ -394,29 +407,24 @@ class BackupExportJobServiceTest(TestCase):
             BackupExportJobService,
             "_get_job_for_update",
             side_effect=[None, stale_job],
-        ):
-            with patch.object(
-                BackupExportJobService,
-                "_result_for_existing_job",
-                return_value=None,
-            ):
-                with patch(
-                    "apps.backups.services.BackupExportJob.objects.create",
-                    side_effect=create_side_effect,
-                ):
-                    with patch(
-                        "apps.backups.services.uuid.uuid4",
-                        return_value="retry-task-id",
-                    ):
-                        with patch.object(
-                            BackupExportJobService,
-                            "_enqueue_backup_task",
-                        ) as enqueue_mock:
-                            with self.captureOnCommitCallbacks(execute=True):
-                                result = BackupExportJobService.check_or_start_job(
-                                    actual_date=today,
-                                    requested_by_id=user.id,
-                                )
+        ), patch.object(
+            BackupExportJobService,
+            "_result_for_existing_job",
+            return_value=None,
+        ), patch(
+            "apps.backups.services.BackupExportJob.objects.create",
+            side_effect=create_side_effect,
+        ), patch(
+            "apps.backups.services.uuid.uuid4",
+            return_value="retry-task-id",
+        ), patch.object(
+            BackupExportJobService,
+            "_enqueue_backup_task",
+        ) as enqueue_mock, self.captureOnCommitCallbacks(execute=True):
+            result = BackupExportJobService.check_or_start_job(
+                actual_date=today,
+                requested_by_id=user.id,
+            )
 
         self.assertEqual(result.action, "started")
         self.assertEqual(result.task_id, "retry-task-id")
@@ -425,7 +433,9 @@ class BackupExportJobServiceTest(TestCase):
         self.assertEqual(new_job.task_id, "retry-task-id")
         enqueue_mock.assert_called_once_with(job_id=new_job.id, task_id="retry-task-id")
 
-    def test_check_or_start_job_retries_create_after_integrity_error_without_concurrent_job(self):
+    def test_check_or_start_job_retries_create_after_integrity_error_without_concurrent_job(
+        self,
+    ):
         today = date(2026, 3, 28)
         user = UserFactory.create_user()
         original_create = BackupExportJob.objects.create
@@ -440,35 +450,32 @@ class BackupExportJobServiceTest(TestCase):
             BackupExportJobService,
             "_get_job_for_update",
             side_effect=[None, None],
-        ):
-            with patch.object(
-                BackupExportJobService,
-                "_result_for_existing_job",
-                return_value=None,
-            ):
-                with patch(
-                    "apps.backups.services.BackupExportJob.objects.create",
-                    side_effect=create_side_effect,
-                ):
-                    with patch(
-                        "apps.backups.services.uuid.uuid4",
-                        return_value="retry-task-id-2",
-                    ):
-                        with patch.object(
-                            BackupExportJobService,
-                            "_enqueue_backup_task",
-                        ) as enqueue_mock:
-                            with self.captureOnCommitCallbacks(execute=True):
-                                result = BackupExportJobService.check_or_start_job(
-                                    actual_date=today,
-                                    requested_by_id=user.id,
-                                )
+        ), patch.object(
+            BackupExportJobService,
+            "_result_for_existing_job",
+            return_value=None,
+        ), patch(
+            "apps.backups.services.BackupExportJob.objects.create",
+            side_effect=create_side_effect,
+        ), patch(
+            "apps.backups.services.uuid.uuid4",
+            return_value="retry-task-id-2",
+        ), patch.object(
+            BackupExportJobService,
+            "_enqueue_backup_task",
+        ) as enqueue_mock, self.captureOnCommitCallbacks(execute=True):
+            result = BackupExportJobService.check_or_start_job(
+                actual_date=today,
+                requested_by_id=user.id,
+            )
 
         self.assertEqual(result.action, "started")
         self.assertEqual(result.task_id, "retry-task-id-2")
         new_job = BackupExportJob.objects.get(actual_date=today)
         self.assertEqual(new_job.task_id, "retry-task-id-2")
-        enqueue_mock.assert_called_once_with(job_id=new_job.id, task_id="retry-task-id-2")
+        enqueue_mock.assert_called_once_with(
+            job_id=new_job.id, task_id="retry-task-id-2"
+        )
 
     def test_archive_exists_and_cleanup_job_artifact(self):
         with TemporaryDirectory() as tmp_dir: