I think fixes the last of the testing

src/documents/consumer.py

@@ -253,7 +253,13 @@ class ConsumerFilePhase(str, Enum):
     FAILED = "FAILED"
 
 
-class ConsumerPlugin(AlwaysRunPluginMixin, ConsumeTaskPlugin, LoggingMixin):
+class ConsumerPlugin(
+    AlwaysRunPluginMixin,
+    NoSetupPluginMixin,
+    NoCleanupPluginMixin,
+    LoggingMixin,
+    ConsumeTaskPlugin,
+):
     logging_name = "paperless.consumer"
 
     def __init__(
@@ -266,6 +272,8 @@ class ConsumerPlugin(AlwaysRunPluginMixin, ConsumeTaskPlugin, LoggingMixin):
     ) -> None:
         super().__init__(input_doc, metadata, status_mgr, base_tmp_dir, task_id)
 
+        self.renew_logging_group()
+
         self.original_path = self.input_doc.original_file
         self.filename = self.metadata.filename or self.input_doc.original_file.name
         self.override_title = self.metadata.title
@@ -282,12 +290,6 @@ class ConsumerPlugin(AlwaysRunPluginMixin, ConsumeTaskPlugin, LoggingMixin):
         self.override_change_groups = self.metadata.change_groups
         self.override_custom_field_ids = self.metadata.custom_field_ids
 
-    def setup(self) -> None:
-        pass
-
-    def cleanup(self) -> None:
-        pass
-
     def _send_progress(
         self,
         current_progress: int,

src/documents/loggers.py

@@ -3,9 +3,6 @@ import uuid
 
 
 class LoggingMixin:
-    def __init__(self) -> None:
-        self.renew_logging_group()
-
     def renew_logging_group(self):
         """
         Creates a new UUID to group subsequent log calls together with

src/documents/parsers.py

@@ -328,6 +328,7 @@ class DocumentParser(LoggingMixin):
 
     def __init__(self, logging_group, progress_callback=None):
         super().__init__()
+        self.renew_logging_group()
         self.logging_group = logging_group
         self.settings = self.get_settings()
         settings.SCRATCH_DIR.mkdir(parents=True, exist_ok=True)

src/documents/tests/test_barcodes.py

@@ -14,6 +14,7 @@ from documents.barcodes import BarcodePlugin
 from documents.data_models import ConsumableDocument
 from documents.data_models import DocumentMetadataOverrides
 from documents.data_models import DocumentSource
+from documents.models import Document
 from documents.models import Tag
 from documents.plugins.base import StopConsumeTaskError
 from documents.tests.utils import DirectoriesMixin
@@ -674,9 +675,7 @@ class TestAsnBarcode(DirectoriesMixin, SampleDirMixin, GetReaderPluginMixin, Tes
         dst = settings.SCRATCH_DIR / "barcode-39-asn-123.pdf"
         shutil.copy(test_file, dst)
 
-        with mock.patch(
+        with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
-            "documents.consumer.Consumer.try_consume_file",
-        ) as mocked_consumer:
             tasks.consume_file(
                 ConsumableDocument(
                     source=DocumentSource.ConsumeFolder,
@@ -684,10 +683,10 @@ class TestAsnBarcode(DirectoriesMixin, SampleDirMixin, GetReaderPluginMixin, Tes
                 ),
                 None,
             )
-            mocked_consumer.assert_called_once()
-            args, kwargs = mocked_consumer.call_args
 
-            self.assertEqual(kwargs["override_asn"], 123)
+            document = Document.objects.first()
+
+            self.assertEqual(document.archive_serial_number, 123)
 
     @override_settings(CONSUMER_BARCODE_SCANNER="PYZBAR")
     def test_scan_file_for_qrcode_without_upscale(self):

src/documents/tests/test_consumer.py

@@ -721,7 +721,7 @@ class TestConsumer(
         self.assertIsFile(filename)
 
         # Database empty
-        self.assertEqual(len(Document.objects.all()), 0)
+        self.assertEqual(Document.objects.all().count(), 0)
 
     @override_settings(FILENAME_FORMAT="{correspondent}/{title}")
     def testFilenameHandling(self):
@@ -878,22 +878,24 @@ class TestConsumer(
         with self.get_consumer(settings.CONSUMPTION_DIR / "simple.png") as consumer:
             consumer.run()
 
-            doc1 = Document.objects.last()
+            doc1 = Document.objects.filter(pk=1).first()
 
         with self.get_consumer(settings.CONSUMPTION_DIR / "simple.pdf") as consumer:
             consumer.run()
 
-            doc2 = Document.objects.last()
+            doc2 = Document.objects.filter(pk=2).first()
 
         with self.get_consumer(settings.CONSUMPTION_DIR / "simple.png.pdf") as consumer:
             consumer.run()
 
-            doc3 = Document.objects.last()
+            doc3 = Document.objects.filter(pk=3).first()
 
         self.assertEqual(doc1.filename, "simple.png")
         self.assertEqual(doc1.archive_filename, "simple.pdf")
+
         self.assertEqual(doc2.filename, "simple.pdf")
         self.assertEqual(doc2.archive_filename, "simple_01.pdf")
+
         self.assertEqual(doc3.filename, "simple.png.pdf")
         self.assertEqual(doc3.archive_filename, "simple.png.pdf")
 

src/documents/tests/test_workflows.py

@@ -1,3 +1,4 @@
+import shutil
 from datetime import timedelta
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -88,8 +89,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
 
         return super().setUp()
 
-    @mock.patch("documents.consumer.ConsumerPlugin.run")
+    def test_workflow_match(self):
-    def test_workflow_match(self, m):
         """
         GIVEN:
             - Existing workflow
@@ -102,7 +102,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
             type=WorkflowTrigger.WorkflowTriggerType.CONSUMPTION,
             sources=f"{DocumentSource.ApiUpload},{DocumentSource.ConsumeFolder},{DocumentSource.MailFetch}",
             filter_filename="*simple*",
-            filter_path="*/samples/*",
+            filter_path=f"*/{self.dirs.scratch_dir.parts[-1]}/*",
         )
         action = WorkflowAction.objects.create(
             assign_title="Doc from {correspondent}",
@@ -133,7 +133,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         self.assertEqual(trigger.__str__(), "WorkflowTrigger 1")
         self.assertEqual(action.__str__(), "WorkflowAction 1")
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="INFO") as cm:
@@ -144,26 +147,53 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+
-                _, overrides = m.call_args
+                document = Document.objects.first()
-                self.assertEqual(overrides["override_correspondent_id"], self.c.pk)
+                self.assertEqual(document.correspondent, self.c)
-                self.assertEqual(overrides["override_document_type_id"], self.dt.pk)
+                self.assertEqual(document.document_type, self.dt)
+                self.assertEqual(list(document.tags.all()), [self.t1, self.t2, self.t3])
+                self.assertEqual(document.storage_path, self.sp)
+                self.assertEqual(document.owner, self.user2)
                 self.assertEqual(
-                    overrides["override_tag_ids"],
+                    list(
-                    [self.t1.pk, self.t2.pk, self.t3.pk],
+                        get_users_with_perms(
-                )
+                            document,
-                self.assertEqual(overrides["override_storage_path_id"], self.sp.pk)
+                            only_with_perms_in=["view_document"],
-                self.assertEqual(overrides["override_owner_id"], self.user2.pk)
+                        ),
-                self.assertEqual(overrides["override_view_users"], [self.user3.pk])
+                    ),
-                self.assertEqual(overrides["override_view_groups"], [self.group1.pk])
+                    [self.user3],
-                self.assertEqual(overrides["override_change_users"], [self.user3.pk])
-                self.assertEqual(overrides["override_change_groups"], [self.group1.pk])
-                self.assertEqual(
-                    overrides["override_title"],
-                    "Doc from {correspondent}",
                 )
                 self.assertEqual(
-                    overrides["override_custom_field_ids"],
+                    list(
+                        get_groups_with_perms(
+                            document,
+                        ),
+                    ),
+                    [self.group1],
+                )
+                self.assertEqual(
+                    list(
+                        get_users_with_perms(
+                            document,
+                            only_with_perms_in=["change_document"],
+                        ),
+                    ),
+                    [self.user3],
+                )
+                self.assertEqual(
+                    list(
+                        get_groups_with_perms(
+                            document,
+                        ),
+                    ),
+                    [self.group1],
+                )
+                self.assertEqual(
+                    document.title,
+                    f"Doc from {self.c.name}",
+                )
+                self.assertEqual(
+                    list(document.custom_fields.all().values_list("field", flat=True)),
                     [self.cf1.pk, self.cf2.pk],
                 )
 
@@ -171,8 +201,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         expected_str = f"Document matched {trigger} from {w}"
         self.assertIn(expected_str, info)
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_match_mailrule(self):
-    def test_workflow_match_mailrule(self, m):
         """
         GIVEN:
             - Existing workflow
@@ -211,7 +240,11 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
+
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="INFO") as cm:
                 tasks.consume_file(
@@ -222,31 +255,55 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
+                self.assertEqual(document.correspondent, self.c)
-                self.assertEqual(overrides["override_correspondent_id"], self.c.pk)
+                self.assertEqual(document.document_type, self.dt)
-                self.assertEqual(overrides["override_document_type_id"], self.dt.pk)
+                self.assertEqual(list(document.tags.all()), [self.t1, self.t2, self.t3])
+                self.assertEqual(document.storage_path, self.sp)
+                self.assertEqual(document.owner, self.user2)
                 self.assertEqual(
-                    overrides["override_tag_ids"],
+                    list(
-                    [self.t1.pk, self.t2.pk, self.t3.pk],
+                        get_users_with_perms(
+                            document,
+                            only_with_perms_in=["view_document"],
+                        ),
+                    ),
+                    [self.user3],
                 )
-                self.assertEqual(overrides["override_storage_path_id"], self.sp.pk)
-                self.assertEqual(overrides["override_owner_id"], self.user2.pk)
-                self.assertEqual(overrides["override_view_users"], [self.user3.pk])
-                self.assertEqual(overrides["override_view_groups"], [self.group1.pk])
-                self.assertEqual(overrides["override_change_users"], [self.user3.pk])
-                self.assertEqual(overrides["override_change_groups"], [self.group1.pk])
                 self.assertEqual(
-                    overrides["override_title"],
+                    list(
-                    "Doc from {correspondent}",
+                        get_groups_with_perms(
+                            document,
+                        ),
+                    ),
+                    [self.group1],
+                )
+                self.assertEqual(
+                    list(
+                        get_users_with_perms(
+                            document,
+                            only_with_perms_in=["change_document"],
+                        ),
+                    ),
+                    [self.user3],
+                )
+                self.assertEqual(
+                    list(
+                        get_groups_with_perms(
+                            document,
+                        ),
+                    ),
+                    [self.group1],
+                )
+                self.assertEqual(
+                    document.title,
+                    f"Doc from {self.c.name}",
                 )
-
         info = cm.output[0]
         expected_str = f"Document matched {trigger} from {w}"
         self.assertIn(expected_str, info)
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_match_multiple(self):
-    def test_workflow_match_multiple(self, m):
         """
         GIVEN:
             - Multiple existing workflow
@@ -259,7 +316,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         trigger1 = WorkflowTrigger.objects.create(
             type=WorkflowTrigger.WorkflowTriggerType.CONSUMPTION,
             sources=f"{DocumentSource.ApiUpload},{DocumentSource.ConsumeFolder},{DocumentSource.MailFetch}",
-            filter_path="*/samples/*",
+            filter_path=f"*/{self.dirs.scratch_dir.parts[-1]}/*",
         )
         action1 = WorkflowAction.objects.create(
             assign_title="Doc from {correspondent}",
@@ -301,7 +358,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w2.actions.add(action2)
         w2.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="INFO") as cm:
@@ -312,21 +372,25 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
                 # template 1
-                self.assertEqual(overrides["override_document_type_id"], self.dt.pk)
+                self.assertEqual(document.document_type, self.dt)
                 # template 2
-                self.assertEqual(overrides["override_correspondent_id"], self.c2.pk)
+                self.assertEqual(document.correspondent, self.c2)
-                self.assertEqual(overrides["override_storage_path_id"], self.sp.pk)
+                self.assertEqual(document.storage_path, self.sp)
                 # template 1 & 2
                 self.assertEqual(
-                    overrides["override_tag_ids"],
+                    list(document.tags.all()),
-                    [self.t1.pk, self.t2.pk, self.t3.pk],
+                    [self.t1, self.t2, self.t3],
                 )
                 self.assertEqual(
-                    overrides["override_view_users"],
+                    list(
-                    [self.user2.pk, self.user3.pk],
+                        get_users_with_perms(
+                            document,
+                            only_with_perms_in=["view_document"],
+                        ),
+                    ),
+                    [self.user2, self.user3],
                 )
 
         expected_str = f"Document matched {trigger1} from {w1}"
@@ -334,8 +398,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         expected_str = f"Document matched {trigger2} from {w2}"
         self.assertIn(expected_str, cm.output[1])
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_fnmatch_path(self):
-    def test_workflow_fnmatch_path(self, m):
         """
         GIVEN:
             - Existing workflow
@@ -348,7 +411,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         trigger = WorkflowTrigger.objects.create(
             type=WorkflowTrigger.WorkflowTriggerType.CONSUMPTION,
             sources=f"{DocumentSource.ApiUpload},{DocumentSource.ConsumeFolder},{DocumentSource.MailFetch}",
-            filter_path="*sample*",
+            filter_path=f"*{self.dirs.scratch_dir.parts[-1]}*",
         )
         action = WorkflowAction.objects.create(
             assign_title="Doc fnmatch title",
@@ -363,7 +426,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="DEBUG") as cm:
@@ -374,15 +440,13 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
+                self.assertEqual(document.title, "Doc fnmatch title")
-                self.assertEqual(overrides["override_title"], "Doc fnmatch title")
 
         expected_str = f"Document matched {trigger} from {w}"
         self.assertIn(expected_str, cm.output[0])
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_no_match_filename(self):
-    def test_workflow_no_match_filename(self, m):
         """
         GIVEN:
             - Existing workflow
@@ -414,7 +478,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="DEBUG") as cm:
@@ -425,26 +492,36 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
+                self.assertIsNone(document.correspondent)
-                self.assertIsNone(overrides["override_correspondent_id"])
+                self.assertIsNone(document.document_type)
-                self.assertIsNone(overrides["override_document_type_id"])
+                self.assertEqual(document.tags.all().count(), 0)
-                self.assertIsNone(overrides["override_tag_ids"])
+                self.assertIsNone(document.storage_path)
-                self.assertIsNone(overrides["override_storage_path_id"])
+                self.assertIsNone(document.owner)
-                self.assertIsNone(overrides["override_owner_id"])
+                self.assertEqual(
-                self.assertIsNone(overrides["override_view_users"])
+                    get_users_with_perms(
-                self.assertIsNone(overrides["override_view_groups"])
+                        document,
-                self.assertIsNone(overrides["override_change_users"])
+                        only_with_perms_in=["view_document"],
-                self.assertIsNone(overrides["override_change_groups"])
+                    ).count(),
-                self.assertIsNone(overrides["override_title"])
+                    0,
+                )
+                self.assertEqual(get_groups_with_perms(document).count(), 0)
+                self.assertEqual(
+                    get_users_with_perms(
+                        document,
+                        only_with_perms_in=["change_document"],
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(get_groups_with_perms(document).count(), 0)
+                self.assertEqual(document.title, "simple")
 
         expected_str = f"Document did not match {w}"
         self.assertIn(expected_str, cm.output[0])
         expected_str = f"Document filename {test_file.name} does not match"
         self.assertIn(expected_str, cm.output[1])
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_no_match_path(self):
-    def test_workflow_no_match_path(self, m):
         """
         GIVEN:
             - Existing workflow
@@ -475,7 +552,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="DEBUG") as cm:
@@ -486,26 +566,46 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
+                self.assertIsNone(document.correspondent)
-                self.assertIsNone(overrides["override_correspondent_id"])
+                self.assertIsNone(document.document_type)
-                self.assertIsNone(overrides["override_document_type_id"])
+                self.assertEqual(document.tags.all().count(), 0)
-                self.assertIsNone(overrides["override_tag_ids"])
+                self.assertIsNone(document.storage_path)
-                self.assertIsNone(overrides["override_storage_path_id"])
+                self.assertIsNone(document.owner)
-                self.assertIsNone(overrides["override_owner_id"])
+                self.assertEqual(
-                self.assertIsNone(overrides["override_view_users"])
+                    get_users_with_perms(
-                self.assertIsNone(overrides["override_view_groups"])
+                        document,
-                self.assertIsNone(overrides["override_change_users"])
+                        only_with_perms_in=["view_document"],
-                self.assertIsNone(overrides["override_change_groups"])
+                    ).count(),
-                self.assertIsNone(overrides["override_title"])
+                    0,
+                )
+                self.assertEqual(
+                    get_groups_with_perms(
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_users_with_perms(
+                        document,
+                        only_with_perms_in=["change_document"],
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_groups_with_perms(
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(document.title, "simple")
 
         expected_str = f"Document did not match {w}"
         self.assertIn(expected_str, cm.output[0])
         expected_str = f"Document path {test_file} does not match"
         self.assertIn(expected_str, cm.output[1])
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_no_match_mail_rule(self):
-    def test_workflow_no_match_mail_rule(self, m):
         """
         GIVEN:
             - Existing workflow
@@ -536,7 +636,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="DEBUG") as cm:
@@ -548,26 +651,46 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
+                self.assertIsNone(document.correspondent)
-                self.assertIsNone(overrides["override_correspondent_id"])
+                self.assertIsNone(document.document_type)
-                self.assertIsNone(overrides["override_document_type_id"])
+                self.assertEqual(document.tags.all().count(), 0)
-                self.assertIsNone(overrides["override_tag_ids"])
+                self.assertIsNone(document.storage_path)
-                self.assertIsNone(overrides["override_storage_path_id"])
+                self.assertIsNone(document.owner)
-                self.assertIsNone(overrides["override_owner_id"])
+                self.assertEqual(
-                self.assertIsNone(overrides["override_view_users"])
+                    get_users_with_perms(
-                self.assertIsNone(overrides["override_view_groups"])
+                        document,
-                self.assertIsNone(overrides["override_change_users"])
+                        only_with_perms_in=["view_document"],
-                self.assertIsNone(overrides["override_change_groups"])
+                    ).count(),
-                self.assertIsNone(overrides["override_title"])
+                    0,
+                )
+                self.assertEqual(
+                    get_groups_with_perms(
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_users_with_perms(
+                        document,
+                        only_with_perms_in=["change_document"],
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_groups_with_perms(
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(document.title, "simple")
 
         expected_str = f"Document did not match {w}"
         self.assertIn(expected_str, cm.output[0])
         expected_str = "Document mail rule 99 !="
         self.assertIn(expected_str, cm.output[1])
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_no_match_source(self):
-    def test_workflow_no_match_source(self, m):
         """
         GIVEN:
             - Existing workflow
@@ -598,7 +721,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="DEBUG") as cm:
@@ -609,18 +735,39 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
+                self.assertIsNone(document.correspondent)
-                self.assertIsNone(overrides["override_correspondent_id"])
+                self.assertIsNone(document.document_type)
-                self.assertIsNone(overrides["override_document_type_id"])
+                self.assertEqual(document.tags.all().count(), 0)
-                self.assertIsNone(overrides["override_tag_ids"])
+                self.assertIsNone(document.storage_path)
-                self.assertIsNone(overrides["override_storage_path_id"])
+                self.assertIsNone(document.owner)
-                self.assertIsNone(overrides["override_owner_id"])
+                self.assertEqual(
-                self.assertIsNone(overrides["override_view_users"])
+                    get_users_with_perms(
-                self.assertIsNone(overrides["override_view_groups"])
+                        document,
-                self.assertIsNone(overrides["override_change_users"])
+                        only_with_perms_in=["view_document"],
-                self.assertIsNone(overrides["override_change_groups"])
+                    ).count(),
-                self.assertIsNone(overrides["override_title"])
+                    0,
+                )
+                self.assertEqual(
+                    get_groups_with_perms(
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_users_with_perms(
+                        document,
+                        only_with_perms_in=["change_document"],
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_groups_with_perms(
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(document.title, "simple")
 
         expected_str = f"Document did not match {w}"
         self.assertIn(expected_str, cm.output[0])
@@ -662,8 +809,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
             expected_str = f"No matching triggers with type {WorkflowTrigger.WorkflowTriggerType.DOCUMENT_ADDED} found"
             self.assertIn(expected_str, cm.output[1])
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_workflow_repeat_custom_fields(self):
-    def test_workflow_repeat_custom_fields(self, m):
         """
         GIVEN:
             - Existing workflows which assign the same custom field
@@ -693,7 +839,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action1, action2)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="INFO") as cm:
@@ -704,10 +853,9 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
                 self.assertEqual(
-                    overrides["override_custom_field_ids"],
+                    list(document.custom_fields.all().values_list("field", flat=True)),
                     [self.cf1.pk],
                 )
 
@@ -1369,8 +1517,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         group_perms: QuerySet = get_groups_with_perms(doc)
         self.assertNotIn(self.group1, group_perms)
 
-    @mock.patch("documents.consumer.Consumer.try_consume_file")
+    def test_removal_action_document_consumed(self):
-    def test_removal_action_document_consumed(self, m):
         """
         GIVEN:
             - Workflow with assignment and removal actions
@@ -1429,7 +1576,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action2)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="INFO") as cm:
@@ -1440,26 +1590,57 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+
-                _, overrides = m.call_args
+                document = Document.objects.first()
-                self.assertIsNone(overrides["override_correspondent_id"])
+
-                self.assertIsNone(overrides["override_document_type_id"])
+                self.assertIsNone(document.correspondent)
+                self.assertIsNone(document.document_type)
                 self.assertEqual(
-                    overrides["override_tag_ids"],
+                    list(document.tags.all()),
-                    [self.t2.pk, self.t3.pk],
+                    [self.t2, self.t3],
                 )
-                self.assertIsNone(overrides["override_storage_path_id"])
+                self.assertIsNone(document.storage_path)
-                self.assertIsNone(overrides["override_owner_id"])
+                self.assertIsNone(document.owner)
-                self.assertEqual(overrides["override_view_users"], [self.user2.pk])
-                self.assertEqual(overrides["override_view_groups"], [self.group2.pk])
-                self.assertEqual(overrides["override_change_users"], [self.user2.pk])
-                self.assertEqual(overrides["override_change_groups"], [self.group2.pk])
                 self.assertEqual(
-                    overrides["override_title"],
+                    list(
-                    "Doc from {correspondent}",
+                        get_users_with_perms(
+                            document,
+                            only_with_perms_in=["view_document"],
+                        ),
+                    ),
+                    [self.user2],
                 )
                 self.assertEqual(
-                    overrides["override_custom_field_ids"],
+                    list(
+                        get_groups_with_perms(
+                            document,
+                        ),
+                    ),
+                    [self.group2],
+                )
+                self.assertEqual(
+                    list(
+                        get_users_with_perms(
+                            document,
+                            only_with_perms_in=["change_document"],
+                        ),
+                    ),
+                    [self.user2],
+                )
+                self.assertEqual(
+                    list(
+                        get_groups_with_perms(
+                            document,
+                        ),
+                    ),
+                    [self.group2],
+                )
+                self.assertEqual(
+                    document.title,
+                    "Doc from None",
+                )
+                self.assertEqual(
+                    list(document.custom_fields.all().values_list("field", flat=True)),
                     [self.cf2.pk],
                 )
 
@@ -1467,8 +1648,7 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         expected_str = f"Document matched {trigger} from {w}"
         self.assertIn(expected_str, info)
 
-    @mock.patch("documents.consumer.ConsumerPlugin.run")
+    def test_removal_action_document_consumed_remove_all(self):
-    def test_removal_action_document_consumed_removeall(self, m):
         """
         GIVEN:
             - Workflow with assignment and removal actions with remove all fields set
@@ -1519,7 +1699,10 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
         w.actions.add(action2)
         w.save()
 
-        test_file = self.SAMPLE_DIR / "simple.pdf"
+        test_file = shutil.copy(
+            self.SAMPLE_DIR / "simple.pdf",
+            self.dirs.scratch_dir / "simple.pdf",
+        )
 
         with mock.patch("documents.tasks.ProgressManager", DummyProgressManager):
             with self.assertLogs("paperless.matching", level="INFO") as cm:
@@ -1530,23 +1713,46 @@ class TestWorkflows(DirectoriesMixin, FileSystemAssertsMixin, APITestCase):
                     ),
                     None,
                 )
-                m.assert_called_once()
+                document = Document.objects.first()
-                _, overrides = m.call_args
+                self.assertIsNone(document.correspondent)
-                self.assertIsNone(overrides["override_correspondent_id"])
+                self.assertIsNone(document.document_type)
-                self.assertIsNone(overrides["override_document_type_id"])
+                self.assertEqual(document.tags.all().count(), 0)
+
+                self.assertIsNone(document.storage_path)
+                self.assertIsNone(document.owner)
                 self.assertEqual(
-                    overrides["override_tag_ids"],
+                    get_users_with_perms(
-                    [],
+                        document,
+                        only_with_perms_in=["view_document"],
+                    ).count(),
+                    0,
                 )
-                self.assertIsNone(overrides["override_storage_path_id"])
-                self.assertIsNone(overrides["override_owner_id"])
-                self.assertEqual(overrides["override_view_users"], [])
-                self.assertEqual(overrides["override_view_groups"], [])
-                self.assertEqual(overrides["override_change_users"], [])
-                self.assertEqual(overrides["override_change_groups"], [])
                 self.assertEqual(
-                    overrides["override_custom_field_ids"],
+                    get_groups_with_perms(
-                    [],
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_users_with_perms(
+                        document,
+                        only_with_perms_in=["change_document"],
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    get_groups_with_perms(
+                        document,
+                    ).count(),
+                    0,
+                )
+                self.assertEqual(
+                    document.custom_fields.all()
+                    .values_list(
+                        "field",
+                    )
+                    .count(),
+                    0,
                 )
 
         info = cm.output[0]

src/paperless_mail/mail.py

@@ -425,6 +425,10 @@ class MailAccountHandler(LoggingMixin):
 
     logging_name = "paperless_mail"
 
+    def __init__(self) -> None:
+        super().__init__()
+        self.renew_logging_group()
+
     def _correspondent_from_name(self, name: str) -> Optional[Correspondent]:
         try:
             return Correspondent.objects.get_or_create(name=name)[0]