modoboa 2.4.11__py3-none-any.whl → 2.5.0__py3-none-any.whl

modoboa/amavis/tests/test_handlers.py

@@ -0,0 +1,214 @@
+"""Amavis tests."""
+
+import os
+
+from django.test import override_settings
+from django.urls import reverse
+
+from modoboa.admin import factories as admin_factories, models as admin_models
+from modoboa.core import models as core_models
+from modoboa.lib.tests import ModoAPITestCase
+from modoboa.transport import factories as tr_factories
+from .. import factories, lib, models
+
+
+class DomainTestCase(ModoAPITestCase):
+    """Check that database is populated."""
+
+    databases = "__all__"
+
+    def setUp(self):
+        """Initiate test context."""
+        self.admin = core_models.User.objects.get(username="admin")
+
+    def test_create_domain(self):
+        """Test domain creation."""
+        domain = admin_factories.DomainFactory(name="domain.test")
+        name = f"@{domain.name}"
+        policy = models.Policy.objects.get(policy_name=name)
+        user = models.Users.objects.filter(policy=policy).first()
+        self.assertIsNot(user, None)
+        self.assertEqual(user.email, name)
+
+        # Create a domain alias
+        self.client.force_authenticate(self.admin)
+        url = reverse("v2:domain_alias-list")
+        data = {"name": "dalias.test", "target": domain.pk}
+        resp = self.client.post(url, data, format="json")
+        self.assertEqual(resp.status_code, 201)
+        name = "@dalias.test"
+        self.assertFalse(models.Policy.objects.filter(policy_name=name).exists())
+        user = models.Users.objects.get(email=name)
+        self.assertEqual(user.policy, policy)
+
+        # Delete domain alias
+        url = reverse("v2:domain_alias-detail", args=[resp.json()["pk"]])
+        resp = self.client.delete(url)
+        self.assertEqual(resp.status_code, 204)
+        self.assertFalse(models.Users.objects.filter(email=name).exists())
+
+    def test_rename_domain(self):
+        """Test domain rename."""
+        domain = admin_factories.DomainFactory(name="domain.test")
+        domain.name = "domain1.test"
+        domain.save()
+        name = f"@{domain.name}"
+        self.assertTrue(models.Users.objects.filter(email=name).exists())
+        self.assertTrue(models.Policy.objects.filter(policy_name=name).exists())
+
+        # Now from form
+        self.client.force_authenticate(self.admin)
+        rdomain = admin_factories.DomainFactory(name="domain.relay", type="relaydomain")
+        rdomain.transport = tr_factories.TransportFactory(
+            pattern=rdomain.name,
+            service="relay",
+            _settings={
+                "relay_target_host": "external.host.tld",
+                "relay_target_port": "25",
+                "relay_verify_recipients": False,
+            },
+        )
+        rdomain.save()
+        url = reverse("v2:domain-detail", args=[rdomain.pk])
+        values = {
+            "name": "domain2.relay",
+            "quota": rdomain.quota,
+            "default_mailbox_quota": rdomain.default_mailbox_quota,
+            "type": "relaydomain",
+            "enabled": rdomain.enabled,
+            "transport": {
+                "service": rdomain.transport.service,
+                "settings": {
+                    "relay_target_host": "127.0.0.1",
+                    "relay_target_port": 25,
+                },
+            },
+        }
+        resp = self.client.put(url, values, format="json")
+        self.assertTrue(resp.status_code, 200)
+
+    def test_delete_domain(self):
+        """Test domain removal."""
+        domain = admin_factories.DomainFactory(name="domain.test")
+        domain.delete(None)
+        name = f"@{domain.name}"
+        self.assertFalse(models.Users.objects.filter(email=name).exists())
+        self.assertFalse(models.Policy.objects.filter(policy_name=name).exists())
+
+    def test_update_domain_policy(self):
+        """Check domain policy edition."""
+        self.client.force_authenticate(self.admin)
+        domain = admin_factories.DomainFactory(name="domain.test")
+        url = reverse("v2:amavis-policy-detail", args=[domain.pk])
+        custom_title = "This is SPAM!"
+        data = {"bypass_virus_checks": "Y", "spam_subject_tag2": custom_title}
+        resp = self.client.patch(url, data, format="json")
+        self.assertEqual(resp.status_code, 200)
+        name = f"@{domain.name}"
+        policy = models.Policy.objects.get(policy_name=name)
+        self.assertEqual(policy.spam_subject_tag2, custom_title)
+
+
+@override_settings(SA_LOOKUP_PATH=(os.path.dirname(__file__),))
+class ManualLearningTestCase(ModoAPITestCase):
+    """Check manual learning mode."""
+
+    databases = "__all__"
+
+    @classmethod
+    def setUpTestData(cls):  # NOQA:N802
+        """Create test data."""
+        super().setUpTestData()
+        admin_factories.populate_database()
+
+    def test_alias_creation(self):
+        """Check alias creation."""
+        self.set_global_parameter("user_level_learning", True)
+
+        # Fake activation because we don't have test data yet for
+        # amavis...
+        lib.setup_manual_learning_for_mbox(
+            admin_models.Mailbox.objects.get(address="user", domain__name="test.com")
+        )
+        lib.setup_manual_learning_for_mbox(
+            admin_models.Mailbox.objects.get(address="admin", domain__name="test.com")
+        )
+
+        url = reverse("v2:alias-list")
+        values = {
+            "address": "alias1000@test.com",
+            "recipients": ["admin@test.com"],
+            "enabled": True,
+        }
+        resp = self.client.post(url, values, format="json")
+        self.assertEqual(resp.status_code, 201)
+        policy = models.Policy.objects.get(policy_name=values["recipients"][0])
+        user = models.Users.objects.get(email=values["address"])
+        self.assertEqual(user.policy, policy)
+
+        values = {
+            "address": "user@test.com",
+            "recipients": ["admin@test.com"],
+            "enabled": True,
+        }
+        resp = self.client.post(url, values, format="json")
+        self.assertEqual(resp.status_code, 201)
+        policy = models.Policy.objects.get(policy_name=values["recipients"][0])
+        user = models.Users.objects.get(email=values["address"])
+        self.assertEqual(user.policy, policy)
+
+    def test_mailbox_rename(self):
+        """Check rename case."""
+        self.set_global_parameter("user_level_learning", True)
+
+        lib.setup_manual_learning_for_mbox(
+            admin_models.Mailbox.objects.get(address="user", domain__name="test.com")
+        )
+
+        user = core_models.User.objects.get(username="user@test.com")
+        url = reverse("v2:account-detail", args=[user.pk])
+        values = {
+            "username": "user2@test.com",
+            "role": "SimpleUsers",
+            "mailbox": {"use_domain_quota": True},
+        }
+        resp = self.client.put(url, values, format="json")
+        self.assertEqual(resp.status_code, 200)
+        self.assertTrue(models.Users.objects.filter(email=values["username"]).exists())
+
+    def test_learn_alias_spam_as_admin(self):
+        """Check learning spam for an alias address as admin user."""
+        user = core_models.User.objects.get(username="admin")
+        recipient_db = "user"
+        rcpt = "alias@test.com"
+        sender = "spam@evil.corp"
+        content = factories.SPAM_BODY.format(rcpt=rcpt, sender=sender)
+
+        saclient = lib.SpamassassinClient(user, recipient_db)
+        result = saclient.learn_spam(rcpt, content)
+        self.assertTrue(result)
+
+    def test_delete_catchall_alias(self):
+        """Check that Users record is not deleted."""
+        self.set_global_parameter("user_level_learning", True)
+
+        # Fake activation because we don't have test data yet for
+        # amavis...
+        lib.setup_manual_learning_for_mbox(
+            admin_models.Mailbox.objects.get(address="admin", domain__name="test.com")
+        )
+
+        url = reverse("v2:alias-list")
+        values = {
+            "address": "@test.com",
+            "recipients": ["admin@test.com"],
+            "enabled": True,
+        }
+        resp = self.client.post(url, values, format="json")
+        self.assertTrue(resp.status_code, 201)
+
+        alias = admin_models.Alias.objects.get(address="@test.com")
+        url = reverse("v2:alias-detail", args=[alias.pk])
+        resp = self.client.delete(url)
+        self.assertEqual(resp.status_code, 204)
+        self.assertTrue(models.Users.objects.get(email="@test.com"))

modoboa/amavis/tests/test_lib.py

@@ -0,0 +1,90 @@
+from django.test import SimpleTestCase
+
+from modoboa.lib.tests import ModoTestCase
+from modoboa.amavis.lib import cleanup_email_address, make_query_args
+
+
+class MakeQueryArgsTests(ModoTestCase):
+    """Tests for modoboa_amavis.lib.make_query_args()."""
+
+    def test_simple_email_address_001(self):
+        """Check case insensitive email address without recipient delimiter."""
+        self.set_global_parameter("localpart_is_case_sensitive", False)
+        self.set_global_parameter("recipient_delimiter", "")
+        address = "User+Foo@sub.exAMPLE.COM"
+        expected_output = [
+            "user+foo@sub.example.com",
+        ]
+        output = make_query_args(address)
+        self.assertEqual(output, expected_output)
+
+    def test_simple_email_address_002(self):
+        """Check case sensitive email address with recipient delimiter."""
+        self.set_global_parameter("localpart_is_case_sensitive", True)
+        self.set_global_parameter("recipient_delimiter", "+")
+        address = "User+Foo@sub.exAMPLE.COM"
+        expected_output = [
+            "User+Foo@sub.exAMPLE.COM",
+            "User+Foo@sub.example.com",
+            "User@sub.example.com",
+        ]
+        output = make_query_args(address)
+        self.assertEqual(output, expected_output)
+
+    def test_simple_email_address_003(self):
+        """Check email address with recipient delimiter wildcard."""
+        self.set_global_parameter("localpart_is_case_sensitive", False)
+        self.set_global_parameter("recipient_delimiter", "+")
+        address = "User+Foo@sub.exAMPLE.COM"
+        expected_output = [
+            "user+foo@sub.example.com",
+            "user+.*@sub.example.com",
+            "user@sub.example.com",
+        ]
+        output = make_query_args(address, exact_extension=False, wildcard=".*")
+        self.assertEqual(output, expected_output)
+
+    def test_simple_email_address_004(self):
+        """Check domain search."""
+        self.set_global_parameter("localpart_is_case_sensitive", False)
+        self.set_global_parameter("recipient_delimiter", "+")
+        address = "User+Foo@sub.exAMPLE.COM"
+        expected_output = [
+            "user+foo@sub.example.com",
+            "user+.*@sub.example.com",
+            "user@sub.example.com",
+            "@sub.example.com",
+            "@.",
+        ]
+        output = make_query_args(
+            address, exact_extension=False, wildcard=".*", domain_search=True
+        )
+        self.assertEqual(output, expected_output)
+
+    def test_simple_email_address_idn(self):
+        """Check email address with international domain name."""
+        self.set_global_parameter("localpart_is_case_sensitive", False)
+        self.set_global_parameter("recipient_delimiter", "")
+        address = "Pingüino@Pájaro.Niño.exAMPLE.COM"
+        expected_output = [
+            "Pingüino@Pájaro.Niño.exAMPLE.COM",
+            "pingüino@xn--pjaro-xqa.xn--nio-8ma.example.com",
+        ]
+        output = make_query_args(address)
+        self.assertEqual(output, expected_output)
+
+
+class FixUTF8EncodingTests(SimpleTestCase):
+    """Tests for modoboa_amavis.lib.cleanup_email_address()."""
+
+    def test_value_with_newline(self):
+        value = '"John Smith" <john.smith@example.com>\n'
+        expected_output = "John Smith <john.smith@example.com>"
+        output = cleanup_email_address(value)
+        self.assertEqual(output, expected_output)
+
+    def test_no_name(self):
+        value = "<john.smith@example.com>"
+        expected_output = "john.smith@example.com"
+        output = cleanup_email_address(value)
+        self.assertEqual(output, expected_output)

modoboa/amavis/tests/test_management_commands.py

@@ -0,0 +1,45 @@
+"""Management commands tests."""
+
+from dateutil.relativedelta import relativedelta
+
+from django.core.management import call_command
+from django.utils import timezone
+
+from modoboa.lib.tests import ModoTestCase
+from .. import factories, models
+
+
+class ManagementCommandTestCase(ModoTestCase):
+    """Management commands tests."""
+
+    databases = "__all__"
+
+    def test_qcleanup(self):
+        """Test qcleanup command."""
+        factories.create_spam("user@test.com", rs="D")
+        call_command("qcleanup")
+        self.assertEqual(models.Quarantine.objects.count(), 0)
+        self.assertEqual(models.Msgs.objects.count(), 0)
+        self.assertEqual(models.Maddr.objects.count(), 0)
+        self.assertEqual(models.Msgrcpt.objects.count(), 0)
+
+        factories.create_spam("user@test.com", rs="D")
+        msgrcpt = factories.create_spam("user@test.com", rs="R")
+        call_command("qcleanup")
+        # Should not raise anything
+        msgrcpt.refresh_from_db()
+
+        self.set_global_parameter("released_msgs_cleanup", True)
+        call_command("qcleanup")
+        with self.assertRaises(models.Msgrcpt.DoesNotExist):
+            msgrcpt.refresh_from_db()
+
+        msgrcpt = factories.create_spam("user@test.com")
+        msgrcpt.mail.time_num = int(
+            (timezone.now() - relativedelta(days=40)).strftime("%s")
+        )
+        msgrcpt.mail.save(update_fields=["time_num"])
+        self.set_global_parameter("max_messages_age", 30)
+        call_command("qcleanup")
+        with self.assertRaises(models.Msgrcpt.DoesNotExist):
+            msgrcpt.refresh_from_db()

modoboa/amavis/tests/test_sql_email.py

@@ -0,0 +1,67 @@
+"""Tests for sql_email."""
+
+import os
+
+from django.test import TestCase
+from django.utils.encoding import smart_str
+
+from ..sql_email import SQLemail
+
+SAMPLES_DIR = os.path.realpath(
+    os.path.join(os.path.dirname(__file__), "sample_messages")
+)
+
+
+class EmailTestImplementation(SQLemail):
+
+    def _fetch_message(self):
+        message_path = os.path.join(SAMPLES_DIR, f"{self.mailid}-input.txt")
+        assert os.path.isfile(message_path), f"{message_path} does not exist."
+
+        with open(message_path, "rb") as fp:
+            mail_text = fp.read()
+
+        return mail_text
+
+
+class EmailTests(TestCase):
+    """Tests for modoboa_amavis.sql_email.SQLEmail
+
+    When writing new sample messages use the following naming convention for
+    the sample files stored in sample_messages:
+
+    input:  {message_id}-input.txt
+    output: {message_id}-output-{dformat}_{no,}links.txt
+    """
+
+    def _get_expected_output(self, message_id, **kwargs):
+        ext = kwargs.get("dformat", "plain")
+        ext += "_links" if "links" in kwargs and kwargs["links"] else "_nolinks"
+        message_path = os.path.join(SAMPLES_DIR, f"{message_id}-output-{ext}.txt")
+        assert os.path.isfile(message_path), f"{message_path} does not exist."
+
+        with open(message_path, "rb") as fp:
+            # output should always be unicode (py2) or str (py3)
+            mail_text = smart_str(fp.read())
+
+        return mail_text
+
+    def _test_email(self, message_id, **kwargs):
+        """Boiler plate code for testing e-mails."""
+        expected_output = self._get_expected_output(message_id, **kwargs)
+        output = EmailTestImplementation(message_id, **kwargs).body
+        self.assertEqual(output, expected_output)
+
+    def test_amavis_aleart_header(self):
+        email = EmailTestImplementation("quarantined")
+        self.assertEqual(email.qtype, "BAD HEADER SECTION")
+        self.assertEqual(
+            email.qreason,
+            "Non-encoded non-ASCII data (and not UTF-8) (char 85 "
+            "hex): Subject: I think I saw you in my dreams\\x{85}",
+        )
+
+    def test_email_multipart_with_no_text(self):
+        """for a multipart message without a text/plain part convert the
+        text/html to text/plain"""
+        self._test_email("quarantined")

modoboa/amavis/tests/test_utils.py

@@ -0,0 +1,19 @@
+from django.test import SimpleTestCase
+
+from modoboa.amavis.utils import fix_utf8_encoding
+
+
+class FixUTF8EncodingTests(SimpleTestCase):
+    """Tests for modoboa_amavis.utils.fix_utf8_encoding()."""
+
+    def test_4_byte_unicode(self):
+        value = "\xf0\x9f\x99\x88"
+        expected_output = "\U0001f648"  # == See No Evil Moneky
+        output = fix_utf8_encoding(value)
+        self.assertEqual(output, expected_output)
+
+    def test_truncated_4_byte_unicode(self):
+        value = "\xf0\x9f\x99"
+        expected_output = "\xf0\x9f\x99"
+        output = fix_utf8_encoding(value)
+        self.assertEqual(output, expected_output)