From 50ec987a817a4bec89bb9a7f9d0af9dac6a4dfe7 Mon Sep 17 00:00:00 2001 From: Trenton H <797416+stumpylog@users.noreply.github.com> Date: Mon, 20 Apr 2026 15:43:43 -0700 Subject: [PATCH] Chore: Refactors all of the mail tests to use model factories instead of bare create (#12613) --- src/paperless_mail/tests/conftest.py | 4 +- src/paperless_mail/tests/factories.py | 57 ++ src/paperless_mail/tests/test_api.py | 498 ++---------------- src/paperless_mail/tests/test_mail.py | 34 +- src/paperless_mail/tests/test_mail_oauth.py | 13 +- src/paperless_mail/tests/test_preprocessor.py | 4 +- 6 files changed, 125 insertions(+), 485 deletions(-) create mode 100644 src/paperless_mail/tests/factories.py diff --git a/src/paperless_mail/tests/conftest.py b/src/paperless_mail/tests/conftest.py index b662d46f3..75c33ac76 100644 --- a/src/paperless_mail/tests/conftest.py +++ b/src/paperless_mail/tests/conftest.py @@ -4,6 +4,7 @@ import pytest from paperless_mail.mail import MailAccountHandler from paperless_mail.models import MailAccount +from paperless_mail.tests.factories import MailAccountFactory @pytest.fixture() @@ -11,14 +12,13 @@ def greenmail_mail_account(db: None) -> Generator[MailAccount, None, None]: """ Create a mail account configured for local Greenmail server. """ - account = MailAccount.objects.create( + account = MailAccountFactory( name="Greenmail Test", imap_server="localhost", imap_port=3143, imap_security=MailAccount.ImapSecurity.NONE, username="test@localhost", password="test", - character_set="UTF-8", ) yield account account.delete() diff --git a/src/paperless_mail/tests/factories.py b/src/paperless_mail/tests/factories.py new file mode 100644 index 000000000..22c90da47 --- /dev/null +++ b/src/paperless_mail/tests/factories.py @@ -0,0 +1,57 @@ +from __future__ import annotations + +import factory +from django.utils import timezone +from factory.django import DjangoModelFactory + +from paperless_mail.models import MailAccount +from paperless_mail.models import MailRule +from paperless_mail.models import ProcessedMail + + +class MailAccountFactory(DjangoModelFactory): + class Meta: + model = MailAccount + + name = factory.Sequence(lambda n: f"Mail Account {n}") + imap_server = "imap.example.com" + imap_port = 993 + imap_security = MailAccount.ImapSecurity.SSL + username = factory.Sequence(lambda n: f"user{n}@example.com") + password = "password" + character_set = "UTF-8" + account_type = MailAccount.MailAccountType.IMAP + is_token = False + + +class MailRuleFactory(DjangoModelFactory): + class Meta: + model = MailRule + + name = factory.Sequence(lambda n: f"Mail Rule {n}") + account = factory.SubFactory(MailAccountFactory) + enabled = True + folder = "INBOX" + order = 0 + maximum_age = 30 + attachment_type = MailRule.AttachmentProcessing.ATTACHMENTS_ONLY + consumption_scope = MailRule.ConsumptionScope.ATTACHMENTS_ONLY + pdf_layout = MailRule.PdfLayout.DEFAULT + action = MailRule.MailAction.MARK_READ + assign_title_from = MailRule.TitleSource.FROM_SUBJECT + assign_correspondent_from = MailRule.CorrespondentSource.FROM_NOTHING + assign_owner_from_rule = True + stop_processing = False + + +class ProcessedMailFactory(DjangoModelFactory): + class Meta: + model = ProcessedMail + + rule = factory.SubFactory(MailRuleFactory) + folder = "INBOX" + uid = factory.Sequence(lambda n: str(n)) + subject = factory.Faker("sentence", nb_words=4) + received = factory.LazyFunction(timezone.now) + processed = factory.LazyFunction(timezone.now) + status = "SUCCESS" diff --git a/src/paperless_mail/tests/test_api.py b/src/paperless_mail/tests/test_api.py index 6cf1f6717..f00a8059e 100644 --- a/src/paperless_mail/tests/test_api.py +++ b/src/paperless_mail/tests/test_api.py @@ -3,18 +3,20 @@ from unittest import mock from django.contrib.auth.models import Permission from django.contrib.auth.models import User -from django.utils import timezone from guardian.shortcuts import assign_perm from rest_framework import status from rest_framework.test import APITestCase -from documents.models import Correspondent -from documents.models import DocumentType -from documents.models import Tag +from documents.tests.factories import CorrespondentFactory +from documents.tests.factories import DocumentTypeFactory +from documents.tests.factories import TagFactory from documents.tests.utils import DirectoriesMixin from paperless_mail.models import MailAccount from paperless_mail.models import MailRule from paperless_mail.models import ProcessedMail +from paperless_mail.tests.factories import MailAccountFactory +from paperless_mail.tests.factories import MailRuleFactory +from paperless_mail.tests.factories import ProcessedMailFactory from paperless_mail.tests.test_mail import BogusMailBox @@ -46,14 +48,12 @@ class TestAPIMailAccounts(DirectoriesMixin, APITestCase): - Configured mail accounts are provided """ - account1 = MailAccount.objects.create( + account1 = MailAccountFactory( name="Email1", username="username1", password="password1", imap_server="server.example.com", imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", ) response = self.client.get(self.ENDPOINT) @@ -118,15 +118,7 @@ class TestAPIMailAccounts(DirectoriesMixin, APITestCase): - Account is deleted """ - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) + account1 = MailAccountFactory() response = self.client.delete( f"{self.ENDPOINT}{account1.pk}/", @@ -146,15 +138,7 @@ class TestAPIMailAccounts(DirectoriesMixin, APITestCase): - The mail account is updated, password only updated if not '****' """ - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) + account1 = MailAccountFactory() response = self.client.patch( f"{self.ENDPOINT}{account1.pk}/", @@ -245,14 +229,11 @@ class TestAPIMailAccounts(DirectoriesMixin, APITestCase): THEN: - API returns success """ - account = MailAccount.objects.create( - name="Email1", + account = MailAccountFactory( username="admin", password="secret", imap_server="server.example.com", imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", ) response = self.client.post( @@ -302,51 +283,10 @@ class TestAPIMailAccounts(DirectoriesMixin, APITestCase): user2 = User.objects.create_user(username="temp_admin2") - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - account2 = MailAccount.objects.create( - name="Email2", - username="username2", - password="password2", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - account2.owner = self.user - account2.save() - - account3 = MailAccount.objects.create( - name="Email3", - username="username3", - password="password3", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - account3.owner = user2 - account3.save() - - account4 = MailAccount.objects.create( - name="Email4", - username="username4", - password="password4", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - account4.owner = user2 - account4.save() + account1 = MailAccountFactory(name="Email1") + account2 = MailAccountFactory(name="Email2", owner=self.user) + _account3 = MailAccountFactory(name="Email3", owner=user2) + account4 = MailAccountFactory(name="Email4", owner=user2) assign_perm("view_mailaccount", self.user, account4) response = self.client.get(self.ENDPOINT) @@ -379,31 +319,15 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): - Configured mail rules are provided """ - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - rule1 = MailRule.objects.create( + account1 = MailAccountFactory() + rule1 = MailRuleFactory( name="Rule1", account=account1, - folder="INBOX", filter_from="from@example.com", filter_to="someone@somewhere.com", filter_subject="subject", filter_body="body", filter_attachment_filename_include="file.pdf", - maximum_age=30, - action=MailRule.MailAction.MARK_READ, - assign_title_from=MailRule.TitleSource.FROM_SUBJECT, - assign_correspondent_from=MailRule.CorrespondentSource.FROM_NOTHING, - order=0, - attachment_type=MailRule.AttachmentProcessing.ATTACHMENTS_ONLY, ) response = self.client.get(self.ENDPOINT) @@ -443,27 +367,10 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): - A new mail rule is created """ - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - tag = Tag.objects.create( - name="t", - ) - - correspondent = Correspondent.objects.create( - name="c", - ) - - document_type = DocumentType.objects.create( - name="dt", - ) + account1 = MailAccountFactory() + tag = TagFactory(name="t") + correspondent = CorrespondentFactory(name="c") + document_type = DocumentTypeFactory(name="dt") rule1 = { "name": "Rule1", @@ -548,31 +455,8 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): - Rule is deleted """ - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - rule1 = MailRule.objects.create( - name="Rule1", - account=account1, - folder="INBOX", - filter_from="from@example.com", - filter_subject="subject", - filter_body="body", - filter_attachment_filename_include="file.pdf", - maximum_age=30, - action=MailRule.MailAction.MARK_READ, - assign_title_from=MailRule.TitleSource.FROM_SUBJECT, - assign_correspondent_from=MailRule.CorrespondentSource.FROM_NOTHING, - order=0, - attachment_type=MailRule.AttachmentProcessing.ATTACHMENTS_ONLY, - ) + account1 = MailAccountFactory() + rule1 = MailRuleFactory(account=account1) response = self.client.delete( f"{self.ENDPOINT}{rule1.pk}/", @@ -592,31 +476,8 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): - The mail rule is updated """ - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - rule1 = MailRule.objects.create( - name="Rule1", - account=account1, - folder="INBOX", - filter_from="from@example.com", - filter_subject="subject", - filter_body="body", - filter_attachment_filename_include="file.pdf", - maximum_age=30, - action=MailRule.MailAction.MARK_READ, - assign_title_from=MailRule.TitleSource.FROM_SUBJECT, - assign_correspondent_from=MailRule.CorrespondentSource.FROM_NOTHING, - order=0, - attachment_type=MailRule.AttachmentProcessing.ATTACHMENTS_ONLY, - ) + account1 = MailAccountFactory() + rule1 = MailRuleFactory(account=account1) response = self.client.patch( f"{self.ENDPOINT}{rule1.pk}/", @@ -634,16 +495,7 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): def test_create_mail_rule_forbidden_for_unpermitted_account(self) -> None: other_user = User.objects.create_user(username="mail-owner") - foreign_account = MailAccount.objects.create( - name="ForeignEmail", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - owner=other_user, - ) + foreign_account = MailAccountFactory(name="ForeignEmail", owner=other_user) response = self.client.post( self.ENDPOINT, @@ -668,16 +520,7 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): self, ) -> None: other_user = User.objects.create_user(username="mail-owner") - foreign_account = MailAccount.objects.create( - name="ForeignEmail", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - owner=other_user, - ) + foreign_account = MailAccountFactory(name="ForeignEmail", owner=other_user) assign_perm("change_mailaccount", self.user, foreign_account) response = self.client.post( @@ -700,38 +543,10 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): self.assertEqual(MailRule.objects.get().account, foreign_account) def test_update_mail_rule_forbidden_for_unpermitted_account(self) -> None: - own_account = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) + own_account = MailAccountFactory() other_user = User.objects.create_user(username="mail-owner") - foreign_account = MailAccount.objects.create( - name="ForeignEmail", - username="username2", - password="password2", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - owner=other_user, - ) - rule1 = MailRule.objects.create( - name="Rule1", - account=own_account, - folder="INBOX", - filter_from="from@example.com", - maximum_age=30, - action=MailRule.MailAction.MARK_READ, - assign_title_from=MailRule.TitleSource.FROM_SUBJECT, - assign_correspondent_from=MailRule.CorrespondentSource.FROM_NOTHING, - order=0, - attachment_type=MailRule.AttachmentProcessing.ATTACHMENTS_ONLY, - ) + foreign_account = MailAccountFactory(owner=other_user) + rule1 = MailRuleFactory(account=own_account) response = self.client.patch( f"{self.ENDPOINT}{rule1.pk}/", @@ -753,54 +568,11 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): """ user2 = User.objects.create_user(username="temp_admin2") - - account1 = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - rule1 = MailRule.objects.create( - name="Rule1", - account=account1, - folder="INBOX", - filter_from="from@example1.com", - order=0, - ) - - rule2 = MailRule.objects.create( - name="Rule2", - account=account1, - folder="INBOX", - filter_from="from@example2.com", - order=1, - ) - rule2.owner = self.user - rule2.save() - - rule3 = MailRule.objects.create( - name="Rule3", - account=account1, - folder="INBOX", - filter_from="from@example3.com", - order=2, - ) - rule3.owner = user2 - rule3.save() - - rule4 = MailRule.objects.create( - name="Rule4", - account=account1, - folder="INBOX", - filter_from="from@example4.com", - order=3, - ) - rule4.owner = user2 - rule4.save() + account1 = MailAccountFactory() + rule1 = MailRuleFactory(account=account1, order=0) + rule2 = MailRuleFactory(account=account1, order=1, owner=self.user) + MailRuleFactory(account=account1, order=2, owner=user2) + rule4 = MailRuleFactory(account=account1, order=3, owner=user2) assign_perm("view_mailrule", self.user, rule4) response = self.client.get(self.ENDPOINT) @@ -820,15 +592,7 @@ class TestAPIMailRules(DirectoriesMixin, APITestCase): THEN: - The API should reject the request """ - account = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) + account = MailAccountFactory() rule_data = { "name": "Rule1", @@ -874,72 +638,16 @@ class TestAPIProcessedMails(DirectoriesMixin, APITestCase): - Only unowned, owned by user or granted processed mails are provided """ user2 = User.objects.create_user(username="temp_admin2") - - account = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - rule = MailRule.objects.create( - name="Rule1", - account=account, - folder="INBOX", - filter_from="from@example.com", - order=0, - ) - - pm1 = ProcessedMail.objects.create( - rule=rule, - folder="INBOX", - uid="1", - subject="Subj1", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - ) - - pm2 = ProcessedMail.objects.create( + rule = MailRuleFactory() + pm1 = ProcessedMailFactory(rule=rule) + pm2 = ProcessedMailFactory( rule=rule, - folder="INBOX", - uid="2", - subject="Subj2", - received=timezone.now(), - processed=timezone.now(), status="FAILED", error="err", owner=self.user, ) - - ProcessedMail.objects.create( - rule=rule, - folder="INBOX", - uid="3", - subject="Subj3", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - owner=user2, - ) - - pm4 = ProcessedMail.objects.create( - rule=rule, - folder="INBOX", - uid="4", - subject="Subj4", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - ) - pm4.owner = user2 - pm4.save() + ProcessedMailFactory(rule=rule, owner=user2) + pm4 = ProcessedMailFactory(rule=rule, owner=user2) assign_perm("view_processedmail", self.user, pm4) response = self.client.get(self.ENDPOINT) @@ -958,62 +666,12 @@ class TestAPIProcessedMails(DirectoriesMixin, APITestCase): THEN: - Only processed mails for that rule are returned """ - account = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - rule1 = MailRule.objects.create( - name="Rule1", - account=account, - folder="INBOX", - filter_from="from1@example.com", - order=0, - ) - rule2 = MailRule.objects.create( - name="Rule2", - account=account, - folder="INBOX", - filter_from="from2@example.com", - order=1, - ) - - pm1 = ProcessedMail.objects.create( - rule=rule1, - folder="INBOX", - uid="r1-1", - subject="R1-A", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - owner=self.user, - ) - pm2 = ProcessedMail.objects.create( - rule=rule1, - folder="INBOX", - uid="r1-2", - subject="R1-B", - received=timezone.now(), - processed=timezone.now(), - status="FAILED", - error="e", - ) - ProcessedMail.objects.create( - rule=rule2, - folder="INBOX", - uid="r2-1", - subject="R2-A", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - ) + account = MailAccountFactory() + rule1 = MailRuleFactory(account=account) + rule2 = MailRuleFactory(account=account) + pm1 = ProcessedMailFactory(rule=rule1, owner=self.user) + pm2 = ProcessedMailFactory(rule=rule1, status="FAILED", error="e") + ProcessedMailFactory(rule=rule2) response = self.client.get(f"{self.ENDPOINT}?rule={rule1.pk}") @@ -1031,70 +689,18 @@ class TestAPIProcessedMails(DirectoriesMixin, APITestCase): - Only the specified processed mails are deleted, respecting ownership and permissions """ user2 = User.objects.create_user(username="temp_admin2") - - account = MailAccount.objects.create( - name="Email1", - username="username1", - password="password1", - imap_server="server.example.com", - imap_port=443, - imap_security=MailAccount.ImapSecurity.SSL, - character_set="UTF-8", - ) - - rule = MailRule.objects.create( - name="Rule1", - account=account, - folder="INBOX", - filter_from="from@example.com", - order=0, - ) - - # unowned and owned by self, and one with explicit object perm - pm_unowned = ProcessedMail.objects.create( + rule = MailRuleFactory() + # unowned, owned by self, and one with explicit object perm + pm_unowned = ProcessedMailFactory(rule=rule) + pm_owned = ProcessedMailFactory( rule=rule, - folder="INBOX", - uid="u1", - subject="Unowned", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - ) - pm_owned = ProcessedMail.objects.create( - rule=rule, - folder="INBOX", - uid="u2", - subject="Owned", - received=timezone.now(), - processed=timezone.now(), status="FAILED", error="e", owner=self.user, ) - pm_granted = ProcessedMail.objects.create( - rule=rule, - folder="INBOX", - uid="u3", - subject="Granted", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - owner=user2, - ) + pm_granted = ProcessedMailFactory(rule=rule, owner=user2) assign_perm("delete_processedmail", self.user, pm_granted) - pm_forbidden = ProcessedMail.objects.create( - rule=rule, - folder="INBOX", - uid="u4", - subject="Forbidden", - received=timezone.now(), - processed=timezone.now(), - status="SUCCESS", - error=None, - owner=user2, - ) + pm_forbidden = ProcessedMailFactory(rule=rule, owner=user2) # Success for allowed items response = self.client.post( diff --git a/src/paperless_mail/tests/test_mail.py b/src/paperless_mail/tests/test_mail.py index 26ee5307e..48e066646 100644 --- a/src/paperless_mail/tests/test_mail.py +++ b/src/paperless_mail/tests/test_mail.py @@ -28,6 +28,7 @@ from rest_framework.test import APITestCase from documents.models import Correspondent from documents.models import MatchingModel +from documents.tests.factories import CorrespondentFactory from documents.tests.utils import DirectoriesMixin from documents.tests.utils import FileSystemAssertsMixin from paperless_mail import tasks @@ -38,6 +39,8 @@ from paperless_mail.mail import apply_mail_action from paperless_mail.models import MailAccount from paperless_mail.models import MailRule from paperless_mail.models import ProcessedMail +from paperless_mail.tests.factories import MailAccountFactory +from paperless_mail.tests.factories import MailRuleFactory @dataclasses.dataclass @@ -433,8 +436,8 @@ class TestMail( "fake@localhost.com", ) - me_localhost = Correspondent.objects.create(name=message2.from_) - someone_else = Correspondent.objects.create(name="someone else") + me_localhost = CorrespondentFactory(name=message2.from_) + someone_else = CorrespondentFactory(name="someone else") handler = MailAccountHandler() @@ -1575,21 +1578,8 @@ class TestMail( class TestPostConsumeAction(TestCase): def setUp(self) -> None: - self.account = MailAccount.objects.create( - name="test", - imap_server="imap.test.com", - imap_port=993, - imap_security=MailAccount.ImapSecurity.SSL, - username="testuser", - password="password", - ) - self.rule = MailRule.objects.create( - name="testrule", - account=self.account, - action=MailRule.MailAction.MARK_READ, - action_parameter="", - folder="INBOX", - ) + self.account = MailAccountFactory() + self.rule = MailRuleFactory(account=self.account) self.message_uid = "12345" self.message_subject = "Test Subject" self.message_date = timezone.make_aware(timezone.datetime(2023, 1, 1, 12, 0, 0)) @@ -2037,15 +2027,7 @@ class TestMailRuleAPI(APITestCase): password="testpassword", ) self.client.force_authenticate(user=self.user) - self.account = MailAccount.objects.create( - imap_server="imap.example.com", - imap_port=993, - imap_security=MailAccount.ImapSecurity.SSL, - username="admin", - password="secret", - account_type=MailAccount.MailAccountType.IMAP, - owner=self.user, - ) + self.account = MailAccountFactory(owner=self.user) self.url = "/api/mail_rules/" def test_create_mail_rule(self) -> None: diff --git a/src/paperless_mail/tests/test_mail_oauth.py b/src/paperless_mail/tests/test_mail_oauth.py index d94e7947b..fd891dfeb 100644 --- a/src/paperless_mail/tests/test_mail_oauth.py +++ b/src/paperless_mail/tests/test_mail_oauth.py @@ -13,6 +13,7 @@ from rest_framework import status from paperless_mail.mail import MailAccountHandler from paperless_mail.models import MailAccount from paperless_mail.oauth import PaperlessMailOAuth2Manager +from paperless_mail.tests.factories import MailAccountFactory @override_settings( @@ -289,11 +290,9 @@ class TestMailOAuth( mock_mailbox = mock.MagicMock() mock_get_mailbox.return_value.__enter__.return_value = mock_mailbox - mail_account = MailAccount.objects.create( + mail_account = MailAccountFactory( name="Test Gmail Mail Account", username="test_username", - imap_security=MailAccount.ImapSecurity.SSL, - imap_port=993, account_type=MailAccount.MailAccountType.GMAIL_OAUTH, is_token=True, refresh_token="test_refresh_token", @@ -315,11 +314,9 @@ class TestMailOAuth( "refresh_token": "test_refresh", "expires_in": 3600, } - outlook_mail_account = MailAccount.objects.create( + outlook_mail_account = MailAccountFactory( name="Test Outlook Mail Account", username="test_username", - imap_security=MailAccount.ImapSecurity.SSL, - imap_port=993, account_type=MailAccount.MailAccountType.OUTLOOK_OAUTH, is_token=True, refresh_token="test_refresh_token", @@ -352,11 +349,9 @@ class TestMailOAuth( mock_mailbox = mock.MagicMock() mock_get_mailbox.return_value.__enter__.return_value = mock_mailbox - mail_account = MailAccount.objects.create( + mail_account = MailAccountFactory( name="Test Gmail Mail Account", username="test_username", - imap_security=MailAccount.ImapSecurity.SSL, - imap_port=993, account_type=MailAccount.MailAccountType.GMAIL_OAUTH, is_token=True, refresh_token="test_refresh_token", diff --git a/src/paperless_mail/tests/test_preprocessor.py b/src/paperless_mail/tests/test_preprocessor.py index 5d665831f..33c9b3839 100644 --- a/src/paperless_mail/tests/test_preprocessor.py +++ b/src/paperless_mail/tests/test_preprocessor.py @@ -13,9 +13,9 @@ from django.test import override_settings from imap_tools import MailMessage from paperless_mail.mail import MailAccountHandler -from paperless_mail.models import MailAccount from paperless_mail.models import MailRule from paperless_mail.preprocessor import MailMessageDecryptor +from paperless_mail.tests.factories import MailAccountFactory from paperless_mail.tests.test_mail import TestMail from paperless_mail.tests.test_mail import _AttachmentDef @@ -251,7 +251,7 @@ class TestMailMessageGpgDecryptor(TestMail): encrypted_message = self.messageEncryptor.encrypt(message) - account = MailAccount.objects.create() + account = MailAccountFactory() rule = MailRule( assign_title_from=MailRule.TitleSource.FROM_FILENAME, consumption_scope=MailRule.ConsumptionScope.EVERYTHING, -- 2.47.3