Chore: Converts all call sites and test asserts to use apply_async and headers (#12591)

src/documents/tests/test_bulk_edit.py

@@ -31,7 +31,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         self.group1 = Group.objects.create(name="group1")
         self.group2 = Group.objects.create(name="group2")
 
-        patcher = mock.patch("documents.bulk_edit.bulk_update_documents.delay")
+        patcher = mock.patch("documents.bulk_edit.bulk_update_documents.apply_async")
         self.async_task = patcher.start()
         self.addCleanup(patcher.stop)
         self.c1 = Correspondent.objects.create(name="c1")
@@ -74,7 +74,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         )
         self.assertEqual(Document.objects.filter(correspondent=self.c2).count(), 3)
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc1.id, self.doc2.id])
 
     def test_unset_correspondent(self) -> None:
@@ -82,7 +82,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         bulk_edit.set_correspondent([self.doc1.id, self.doc2.id, self.doc3.id], None)
         self.assertEqual(Document.objects.filter(correspondent=self.c2).count(), 0)
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc2.id, self.doc3.id])
 
     def test_set_document_type(self) -> None:
@@ -93,7 +93,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         )
         self.assertEqual(Document.objects.filter(document_type=self.dt2).count(), 3)
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc1.id, self.doc2.id])
 
     def test_unset_document_type(self) -> None:
@@ -101,7 +101,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         bulk_edit.set_document_type([self.doc1.id, self.doc2.id, self.doc3.id], None)
         self.assertEqual(Document.objects.filter(document_type=self.dt2).count(), 0)
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc2.id, self.doc3.id])
 
     def test_set_document_storage_path(self) -> None:
@@ -123,7 +123,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         self.assertEqual(Document.objects.filter(storage_path=None).count(), 4)
 
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
 
         self.assertCountEqual(kwargs["document_ids"], [self.doc1.id])
 
@@ -154,7 +154,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         self.assertEqual(Document.objects.filter(storage_path=None).count(), 5)
 
         self.async_task.assert_called()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
 
         self.assertCountEqual(kwargs["document_ids"], [self.doc1.id])
 
@@ -166,7 +166,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         )
         self.assertEqual(Document.objects.filter(tags__id=self.t1.id).count(), 4)
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc1.id, self.doc3.id])
 
     def test_remove_tag(self) -> None:
@@ -174,7 +174,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         bulk_edit.remove_tag([self.doc1.id, self.doc3.id, self.doc4.id], self.t1.id)
         self.assertEqual(Document.objects.filter(tags__id=self.t1.id).count(), 1)
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc4.id])
 
     def test_modify_tags(self) -> None:
@@ -191,7 +191,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         self.assertCountEqual(list(self.doc3.tags.all()), [self.t2, tag_unrelated])
 
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         # TODO: doc3 should not be affected, but the query for that is rather complicated
         self.assertCountEqual(kwargs["document_ids"], [self.doc2.id, self.doc3.id])
 
@@ -248,7 +248,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         )
 
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc1.id, self.doc2.id])
 
     def test_modify_custom_fields_with_values(self) -> None:
@@ -325,7 +325,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         )
 
         self.async_task.assert_called_once()
-        _, kwargs = self.async_task.call_args
+        kwargs = self.async_task.call_args.kwargs["kwargs"]
         self.assertCountEqual(kwargs["document_ids"], [self.doc1.id, self.doc2.id])
 
         # removal of document link cf, should also remove symmetric link
@@ -428,7 +428,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         self.assertEqual(source_doc.id, version2.id)
         self.assertNotEqual(source_doc.id, version1.id)
 
-    @mock.patch("documents.tasks.bulk_update_documents.delay")
+    @mock.patch("documents.tasks.bulk_update_documents.apply_async")
     def test_set_permissions(self, m) -> None:
         doc_ids = [self.doc1.id, self.doc2.id, self.doc3.id]
 
@@ -467,7 +467,7 @@ class TestBulkEdit(DirectoriesMixin, TestCase):
         )
         self.assertEqual(groups_with_perms.count(), 1)
 
-    @mock.patch("documents.tasks.bulk_update_documents.delay")
+    @mock.patch("documents.tasks.bulk_update_documents.apply_async")
     def test_set_permissions_merge(self, m) -> None:
         doc_ids = [self.doc1.id, self.doc2.id, self.doc3.id]
 
@@ -643,20 +643,20 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         )
 
         mock_consume_file.assert_called()
-        consume_file_args, _ = mock_consume_file.call_args
+        call_kwargs = mock_consume_file.call_args.kwargs
         self.assertEqual(
-            Path(consume_file_args[0].original_file).name,
+            Path(call_kwargs["input_doc"].original_file).name,
             expected_filename,
         )
-        self.assertEqual(consume_file_args[1].title, None)
+        self.assertEqual(call_kwargs["overrides"].title, None)
         # No metadata_document_id, delete_originals False, so ASN should be None
-        self.assertIsNone(consume_file_args[1].asn)
+        self.assertIsNone(call_kwargs["overrides"].asn)
 
         # With metadata_document_id overrides
         result = bulk_edit.merge(doc_ids, metadata_document_id=metadata_document_id)
-        consume_file_args, _ = mock_consume_file.call_args
-        self.assertEqual(consume_file_args[1].title, "B (merged)")
-        self.assertEqual(consume_file_args[1].created, self.doc2.created)
+        call_kwargs = mock_consume_file.call_args.kwargs
+        self.assertEqual(call_kwargs["overrides"].title, "B (merged)")
+        self.assertEqual(call_kwargs["overrides"].created, self.doc2.created)
 
         self.assertEqual(result, "OK")
 
@@ -720,16 +720,15 @@ class TestPDFActions(DirectoriesMixin, TestCase):
 
         mock_consume_file.assert_called()
         mock_delete_documents.assert_called()
-        consume_sig = mock_consume_file.return_value
-        consume_sig.apply_async.assert_called_once()
+        mock_consume_file.return_value.set.return_value.apply_async.assert_called_once()
 
-        consume_file_args, _ = mock_consume_file.call_args
+        call_kwargs = mock_consume_file.call_args.kwargs
         self.assertEqual(
-            Path(consume_file_args[0].original_file).name,
+            Path(call_kwargs["input_doc"].original_file).name,
             expected_filename,
         )
-        self.assertEqual(consume_file_args[1].title, None)
-        self.assertEqual(consume_file_args[1].asn, 101)
+        self.assertEqual(call_kwargs["overrides"].title, None)
+        self.assertEqual(call_kwargs["overrides"].asn, 101)
 
         delete_documents_args, _ = mock_delete_documents.call_args
         self.assertEqual(
@@ -764,7 +763,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         self.doc1.archive_serial_number = 111
         self.doc1.save()
         sig = mock.Mock()
-        sig.apply_async.side_effect = Exception("boom")
+        sig.set.return_value.apply_async.side_effect = Exception("boom")
         mock_consume_file.return_value = sig
 
         with self.assertRaises(Exception):
@@ -801,8 +800,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         )
         self.assertEqual(result, "OK")
 
-        consume_file_args, _ = mock_consume_file.call_args
-        self.assertEqual(consume_file_args[1].asn, 202)
+        self.assertEqual(mock_consume_file.call_args.kwargs["overrides"].asn, 202)
 
     def test_restore_archive_serial_numbers_task(self) -> None:
         """
@@ -843,9 +841,8 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         )
 
         mock_consume_file.assert_called()
-        consume_file_args, _ = mock_consume_file.call_args
         self.assertEqual(
-            Path(consume_file_args[0].original_file).name,
+            Path(mock_consume_file.call_args.kwargs["input_doc"].original_file).name,
             expected_filename,
         )
 
@@ -889,9 +886,11 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         user = User.objects.create(username="test_user")
         result = bulk_edit.split(doc_ids, pages, delete_originals=False, user=user)
         self.assertEqual(mock_consume_file.call_count, 2)
-        consume_file_args, _ = mock_consume_file.call_args
-        self.assertEqual(consume_file_args[1].title, "B (split 2)")
-        self.assertIsNone(consume_file_args[1].asn)
+        self.assertEqual(
+            mock_consume_file.call_args.kwargs["overrides"].title,
+            "B (split 2)",
+        )
+        self.assertIsNone(mock_consume_file.call_args.kwargs["overrides"].asn)
 
         self.assertEqual(result, "OK")
 
@@ -953,8 +952,10 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         self.assertEqual(result, "OK")
 
         self.assertEqual(mock_consume_file.call_count, 2)
-        consume_file_args, _ = mock_consume_file.call_args
-        self.assertEqual(consume_file_args[1].title, "B (split 2)")
+        self.assertEqual(
+            mock_consume_file.call_args.kwargs["overrides"].title,
+            "B (split 2)",
+        )
 
         mock_delete_documents.assert_called()
         mock_chord.assert_called_once()
@@ -1001,7 +1002,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         self.doc2.refresh_from_db()
         self.assertEqual(self.doc2.archive_serial_number, 222)
 
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.Pdf.save")
     def test_split_with_errors(self, mock_save_pdf, mock_consume_file) -> None:
         """
@@ -1025,7 +1026,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
 
         mock_consume_file.assert_not_called()
 
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     def test_rotate(self, mock_consume_delay):
         """
         GIVEN:
@@ -1042,12 +1043,12 @@ class TestPDFActions(DirectoriesMixin, TestCase):
             mock_consume_delay.call_args_list,
             doc_ids,
         ):
-            consumable, overrides = call.args
-            self.assertEqual(consumable.root_document_id, expected_id)
-            self.assertIsNotNone(overrides)
+            task_kwargs = call.kwargs["kwargs"]
+            self.assertEqual(task_kwargs["input_doc"].root_document_id, expected_id)
+            self.assertIsNotNone(task_kwargs["overrides"])
         self.assertEqual(result, "OK")
 
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.Pdf.save")
     def test_rotate_with_error(
         self,
@@ -1073,7 +1074,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
             self.assertIn(expected_str, error_str)
             mock_consume_delay.assert_not_called()
 
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     def test_rotate_non_pdf(
         self,
         mock_consume_delay,
@@ -1091,13 +1092,13 @@ class TestPDFActions(DirectoriesMixin, TestCase):
             expected_str = f"Document {self.img_doc.id} is not a PDF, skipping rotation"
             self.assertTrue(any(expected_str in line for line in cm.output))
             self.assertEqual(mock_consume_delay.call_count, 1)
-            consumable, overrides = mock_consume_delay.call_args[0]
-            self.assertEqual(consumable.root_document_id, self.doc2.id)
-            self.assertIsNotNone(overrides)
+            task_kwargs = mock_consume_delay.call_args.kwargs["kwargs"]
+            self.assertEqual(task_kwargs["input_doc"].root_document_id, self.doc2.id)
+            self.assertIsNotNone(task_kwargs["overrides"])
             self.assertEqual(result, "OK")
 
     @mock.patch("documents.data_models.magic.from_file", return_value="application/pdf")
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.open")
     def test_rotate_explicit_selection_uses_root_source_when_root_selected(
         self,
@@ -1124,7 +1125,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         mock_open.assert_called_once_with(self.doc2.source_path)
         mock_consume_delay.assert_called_once()
 
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.Pdf.save")
     @mock.patch("documents.data_models.magic.from_file", return_value="application/pdf")
     def test_delete_pages(self, mock_magic, mock_pdf_save, mock_consume_delay):
@@ -1142,14 +1143,16 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         result = bulk_edit.delete_pages(doc_ids, pages)
         mock_pdf_save.assert_called_once()
         mock_consume_delay.assert_called_once()
-        consumable, overrides = mock_consume_delay.call_args[0]
-        self.assertEqual(consumable.root_document_id, self.doc2.id)
-        self.assertTrue(str(consumable.original_file).endswith("_pages_deleted.pdf"))
-        self.assertIsNotNone(overrides)
+        task_kwargs = mock_consume_delay.call_args.kwargs["kwargs"]
+        self.assertEqual(task_kwargs["input_doc"].root_document_id, self.doc2.id)
+        self.assertTrue(
+            str(task_kwargs["input_doc"].original_file).endswith("_pages_deleted.pdf"),
+        )
+        self.assertIsNotNone(task_kwargs["overrides"])
         self.assertEqual(result, "OK")
 
     @mock.patch("documents.data_models.magic.from_file", return_value="application/pdf")
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.open")
     def test_delete_pages_explicit_selection_uses_root_source_when_root_selected(
         self,
@@ -1176,7 +1179,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         mock_open.assert_called_once_with(self.doc2.source_path)
         mock_consume_delay.assert_called_once()
 
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.Pdf.save")
     def test_delete_pages_with_error(self, mock_pdf_save, mock_consume_delay):
         """
@@ -1259,8 +1262,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         result = bulk_edit.edit_pdf(doc_ids, operations, delete_original=True)
         self.assertEqual(result, "OK")
         mock_chord.assert_called_once()
-        consume_file_args, _ = mock_consume_file.call_args
-        self.assertEqual(consume_file_args[1].asn, 250)
+        self.assertEqual(mock_consume_file.call_args.kwargs["overrides"].asn, 250)
         self.doc2.refresh_from_db()
         self.assertIsNone(self.doc2.archive_serial_number)
 
@@ -1297,7 +1299,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         self.doc2.refresh_from_db()
         self.assertEqual(self.doc2.archive_serial_number, 333)
 
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     def test_edit_pdf_with_update_document(self, mock_consume_delay):
         """
         GIVEN:
@@ -1319,13 +1321,15 @@ class TestPDFActions(DirectoriesMixin, TestCase):
 
         self.assertEqual(result, "OK")
         mock_consume_delay.assert_called_once()
-        consumable, overrides = mock_consume_delay.call_args[0]
-        self.assertEqual(consumable.root_document_id, self.doc2.id)
-        self.assertTrue(str(consumable.original_file).endswith("_edited.pdf"))
-        self.assertIsNotNone(overrides)
+        task_kwargs = mock_consume_delay.call_args.kwargs["kwargs"]
+        self.assertEqual(task_kwargs["input_doc"].root_document_id, self.doc2.id)
+        self.assertTrue(
+            str(task_kwargs["input_doc"].original_file).endswith("_edited.pdf"),
+        )
+        self.assertIsNotNone(task_kwargs["overrides"])
 
     @mock.patch("documents.data_models.magic.from_file", return_value="application/pdf")
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.new")
     @mock.patch("pikepdf.open")
     def test_edit_pdf_explicit_selection_uses_root_source_when_root_selected(
@@ -1433,7 +1437,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         mock_consume_file.assert_not_called()
 
     @mock.patch("documents.bulk_edit.update_document_content_maybe_archive_file.delay")
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("documents.bulk_edit.tempfile.mkdtemp")
     @mock.patch("pikepdf.open")
     def test_remove_password_update_document(
@@ -1468,18 +1472,18 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         fake_pdf.remove_unreferenced_resources.assert_called_once()
         mock_update_document.assert_not_called()
         mock_consume_delay.assert_called_once()
-        consumable, overrides = mock_consume_delay.call_args[0]
+        task_kwargs = mock_consume_delay.call_args.kwargs["kwargs"]
         expected_path = temp_dir / f"{doc.id}_unprotected.pdf"
         self.assertTrue(expected_path.exists())
         self.assertEqual(
-            Path(consumable.original_file).resolve(),
+            Path(task_kwargs["input_doc"].original_file).resolve(),
             expected_path.resolve(),
         )
-        self.assertEqual(consumable.root_document_id, doc.id)
-        self.assertIsNotNone(overrides)
+        self.assertEqual(task_kwargs["input_doc"].root_document_id, doc.id)
+        self.assertIsNotNone(task_kwargs["overrides"])
 
     @mock.patch("documents.data_models.magic.from_file", return_value="application/pdf")
-    @mock.patch("documents.tasks.consume_file.delay")
+    @mock.patch("documents.tasks.consume_file.apply_async")
     @mock.patch("pikepdf.open")
     def test_remove_password_explicit_selection_uses_root_source_when_root_selected(
         self,
@@ -1548,9 +1552,9 @@ class TestPDFActions(DirectoriesMixin, TestCase):
         self.assertEqual(result, "OK")
         mock_open.assert_called_once_with(doc.source_path, password="secret")
         mock_consume_file.assert_called_once()
-        consume_args, _ = mock_consume_file.call_args
-        consumable_document = consume_args[0]
-        overrides = consume_args[1]
+        call_kwargs = mock_consume_file.call_args.kwargs
+        consumable_document = call_kwargs["input_doc"]
+        overrides = call_kwargs["overrides"]
         expected_path = temp_dir / f"{doc.id}_unprotected.pdf"
         self.assertTrue(expected_path.exists())
         self.assertEqual(
@@ -1558,7 +1562,9 @@ class TestPDFActions(DirectoriesMixin, TestCase):
             expected_path.resolve(),
         )
         self.assertEqual(overrides.owner_id, user.id)
-        mock_group.assert_called_once_with([mock_consume_file.return_value])
+        mock_group.assert_called_once_with(
+            [mock_consume_file.return_value.set.return_value],
+        )
         mock_group.return_value.delay.assert_called_once()
         mock_chord.assert_not_called()