django-pfx 1.7.6.dev23__tar.gz → 1.7.6.dev25__tar.gz

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.7.6.dev23
+Version: 1.7.6.dev25
 Summary: Django PFX is a toolkit designed to streamline the development of RESTful APIs using the Django framework.
 Author: Hervé Martinet
 Author-email: herve.martinet@gmail.com

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/django_pfx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.7.6.dev23
+Version: 1.7.6.dev25
 Summary: Django PFX is a toolkit designed to streamline the development of RESTful APIs using the Django framework.
 Author: Hervé Martinet
 Author-email: herve.martinet@gmail.com

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/django_pfx.egg-info/SOURCES.txt

@@ -41,8 +41,10 @@ pfx/emails/apps.py
 pfx/emails/exceptions.py
 pfx/emails/shortcuts.py
 pfx/emails/tasks.py
+pfx/emails/test.py
 pfx/emails/urls.py
 pfx/emails/email_backend/__init__.py
+pfx/emails/email_backend/memory_email_backend.py
 pfx/emails/email_backend/q_mailjet_email_backend.py
 pfx/emails/locale/fr/LC_MESSAGES/django.mo
 pfx/emails/locale/fr/LC_MESSAGES/django.po
@@ -73,6 +75,7 @@ pfx/pfxcore/shortcuts.py
 pfx/pfxcore/test.py
 pfx/pfxcore/urls.py
 pfx/pfxcore/version_check.py
+pfx/pfxcore/xml_test_runner.py
 pfx/pfxcore/apidoc/__init__.py
 pfx/pfxcore/apidoc/parameters.py
 pfx/pfxcore/apidoc/schema.py
@@ -133,6 +136,7 @@ pfx/pfxcore/sms/__init__.py
 pfx/pfxcore/sms/backends/__init__.py
 pfx/pfxcore/sms/backends/base.py
 pfx/pfxcore/sms/backends/console.py
+pfx/pfxcore/sms/backends/memory.py
 pfx/pfxcore/storage/__init__.py
 pfx/pfxcore/storage/exceptions.py
 pfx/pfxcore/storage/local_storage.py
@@ -225,6 +229,7 @@ tests/tests/test_emails_email_api.py
 tests/tests/test_emails_email_model.py
 tests/tests/test_emails_q_mailjet_email_backend.py
 tests/tests/test_emails_send_email_message.py
+tests/tests/test_emails_test_tools.py
 tests/tests/test_fields_choices.py
 tests/tests/test_fields_date.py
 tests/tests/test_fields_decimal.py
@@ -246,6 +251,7 @@ tests/tests/test_post_migrate_groups_update.py
 tests/tests/test_profiling_middleware.py
 tests/tests/test_settings.py
 tests/tests/test_shortcuts.py
+tests/tests/test_test_runner.py
 tests/tests/test_timezone_middleware.py
 tests/tests/test_tools.py
 tests/tests/test_user_job_api.py

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/django_pfx.egg-info/scm_file_list.json

@@ -29,6 +29,7 @@
     "pfx/emails/__init__.py",
     "pfx/emails/apps.py",
     "pfx/emails/email_backend/__init__.py",
+    "pfx/emails/email_backend/memory_email_backend.py",
     "pfx/emails/email_backend/q_mailjet_email_backend.py",
     "pfx/emails/exceptions.py",
     "pfx/emails/locale/fr/LC_MESSAGES/django.po",
@@ -50,6 +51,7 @@
     "pfx/emails/templates/emails/base_template.html",
     "pfx/emails/templates/emails/base_template.txt",
     "pfx/emails/templates/emails/base_template_subject.txt",
+    "pfx/emails/test.py",
     "pfx/emails/urls.py",
     "pfx/emails/views/__init__.py",
     "pfx/emails/views/email_rest_view.py",
@@ -118,6 +120,7 @@
     "pfx/pfxcore/sms/backends/__init__.py",
     "pfx/pfxcore/sms/backends/base.py",
     "pfx/pfxcore/sms/backends/console.py",
+    "pfx/pfxcore/sms/backends/memory.py",
     "pfx/pfxcore/storage/__init__.py",
     "pfx/pfxcore/storage/exceptions.py",
     "pfx/pfxcore/storage/local_storage.py",
@@ -158,6 +161,7 @@
     "pfx/pfxcore/views/parameters/subset_page_size.py",
     "pfx/pfxcore/views/parameters/subset_page_subset.py",
     "pfx/pfxcore/views/rest_views.py",
+    "pfx/pfxcore/xml_test_runner.py",
     "pfx/settings/__init__.py",
     "pfx/settings/dev.py",
     "pfx/userjobs/__init__.py",
@@ -215,6 +219,7 @@
     "tests/tests/test_emails_email_model.py",
     "tests/tests/test_emails_q_mailjet_email_backend.py",
     "tests/tests/test_emails_send_email_message.py",
+    "tests/tests/test_emails_test_tools.py",
     "tests/tests/test_fields_choices.py",
     "tests/tests/test_fields_date.py",
     "tests/tests/test_fields_decimal.py",
@@ -236,6 +241,7 @@
     "tests/tests/test_profiling_middleware.py",
     "tests/tests/test_settings.py",
     "tests/tests/test_shortcuts.py",
+    "tests/tests/test_test_runner.py",
     "tests/tests/test_timezone_middleware.py",
     "tests/tests/test_tools.py",
     "tests/tests/test_user_job_api.py",

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/django_pfx.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "1.7.5",
-  "distance": 23,
-  "node": "g844445a9b16ab6666628821913df2ba5050b36d4",
+  "distance": 25,
+  "node": "gf7233748745b72df513a97dd8d75f55284f00bed",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-05"

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/doc/source/authentication.md

@@ -183,6 +183,8 @@ removed.
 * `PFX_SMS_BACKEND`: Dotted path to the SMS backend class (optional, default
   `'pfx.pfxcore.sms.backends.console.ConsoleSMSBackend'`).
   Implement {class}`pfx.pfxcore.sms.backends.base.BaseSMSBackend` to integrate a real SMS provider.
+  In the tests, `pfx.pfxcore.test.TestRunner` replaces it with
+  {class}`pfx.pfxcore.sms.backends.memory.MemorySMSBackend` (see [Testing](testing.md)).
 * `PFX_TOKEN_OTP_VALIDITY`: Validity for OTP tokens (corresponds to the maximum time to enter
   an OTP code after logging in with a password) (optional, default `{'minutes': 15}`)
 * `PFX_HOTP_CODE_VALIDITY`: Validity of HOTP codes in minutes (used to send code by email or SMS) (optional, default `15`).

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/doc/source/testing.md

@@ -340,3 +340,93 @@ class BookPermsAPITest(TestPermsAssertMixin):
             post=403, put=403, delete=403),
     }
 ```
+
+## Test runner
+`pfx.pfxcore.test.TestRunner` replaces the SMS and email backends for the
+whole run, parallel workers included: nothing leaves the tests, whatever
+the local settings contain, and what would be sent is kept for the
+assertions.
+
+```python
+TEST_RUNNER = 'pfx.pfxcore.test.TestRunner'
+```
+
+- `PFX_SMS_BACKEND` becomes
+  `pfx.pfxcore.sms.backends.memory.MemorySMSBackend`, which collects the
+  SMS in memory.
+- If `pfx.emails` is installed, `EMAIL_BACKEND` becomes
+  `pfx.emails.email_backend.MemoryEmailBackend` instead of the `locmem`
+  backend set by Django. `locmem` puts the emails in
+  `django.core.mail.outbox`: the email model is never built nor validated,
+  and a sending path that would create an invalid email goes unnoticed.
+  `MemoryEmailBackend` builds, validates and saves the email as
+  `QMailjetEmailBackend` does, with the `manual` send mode: nothing is
+  sent.
+
+A project without `pfx.emails` can use the runner as well: only the SMS
+backend is replaced, and the emails stay in Django's `locmem` outbox.
+
+To use subclasses of these backends (to fill extra fields of your email
+model, for instance):
+```python
+PFX_TEST_SMS_BACKEND = 'myapp.tests.MyMemorySMSBackend'
+PFX_TEST_EMAIL_BACKEND = 'myapp.tests.MyMemoryEmailBackend'
+```
+
+For the XML reports of `unittest-xml-reporting` (to install in the
+project), use the XML variant:
+```python
+TEST_RUNNER = 'pfx.pfxcore.xml_test_runner.XMLTestRunner'
+```
+
+With another runner, combine it with `MemoryBackendsRunnerMixin`:
+```python
+from pfx.pfxcore.test import MemoryBackendsRunnerMixin
+
+
+class MyTestRunner(MemoryBackendsRunnerMixin, OtherTestRunner):
+    pass
+```
+
+A test class that needs another backend keeps its
+`override_settings(EMAIL_BACKEND=…)` or `override_settings(PFX_SMS_BACKEND=…)`.
+
+## SMSTestMixin
+Helpers to check the SMS of a test. The outbox is emptied before each
+test. They fail if the SMS backend is not a `MemorySMSBackend`, rather
+than reporting an empty outbox.
+
+- `sms_outbox()`: the SMS sent so far, as `(to, message)` tuples.
+- `clear_sms_outbox()`: forget the SMS sent so far.
+
+## EmailTestMixin
+`pfx.emails.test.EmailTestMixin` gives helpers to check the emails of a
+test. They fail if the emails are not saved in the email model (with
+`locmem`, for instance), rather than reporting an empty outbox.
+
+- `outbox()`: the emails created so far, in creation order.
+- `clear_outbox()`: delete the emails created so far.
+- `email_to(email)`: the addresses of the `To`, without the names.
+- `get_email_html(email)`: the HTML part, fails if there is none.
+
+Example :
+```python
+from django.test import TestCase
+
+from pfx.emails.test import EmailTestMixin
+from pfx.pfxcore.test import SMSTestMixin
+
+
+class ATestClass(EmailTestMixin, SMSTestMixin, TestCase):
+
+    def a_test(self):
+        # … something that sends an email to jrr@example.com
+        [email] = self.outbox()
+        self.assertEqual(self.email_to(email), ['jrr@example.com'])
+        self.assertIn('Welcome', self.get_email_html(email))
+
+    def another_test(self):
+        # … something that sends an SMS
+        [(to, message)] = self.sms_outbox()
+        self.assertEqual(to, '+41791234567')
+```

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/pfx/emails/email_backend/__init__.py

@@ -1 +1,2 @@
+from .memory_email_backend import MemoryEmailBackend
 from .q_mailjet_email_backend import QMailjetEmailBackend

django_pfx-1.7.6.dev25/pfx/emails/email_backend/memory_email_backend.py

@@ -0,0 +1,14 @@
+from .q_mailjet_email_backend import QMailjetEmailBackend
+
+
+class MemoryEmailBackend(QMailjetEmailBackend):
+    """Create the emails as :class:`QMailjetEmailBackend` does, but never
+    send them.
+
+    The email model is built, validated and saved, so a sending path that
+    would create an invalid email fails. The ``manual`` send mode stops
+    there: nothing is queued nor sent to Mailjet."""
+
+    def create_mail(self, message):
+        message.send_mode = 'manual'
+        super().create_mail(message)

django_pfx-1.7.6.dev25/pfx/emails/test.py

@@ -0,0 +1,40 @@
+from django.conf import settings
+from django.utils.module_loading import import_string
+
+from pfx.emails.email_backend import QMailjetEmailBackend
+from pfx.emails.models import get_email_model
+
+
+class EmailTestMixin:
+    """Helpers to check the emails created by a test."""
+
+    @classmethod
+    def _check_email_backend(cls):
+        backend = import_string(settings.EMAIL_BACKEND)
+        if not issubclass(backend, QMailjetEmailBackend):
+            raise AssertionError(
+                f"EMAIL_BACKEND is {settings.EMAIL_BACKEND}, the emails are "
+                f"not saved in the email model. Run the tests with a runner "
+                f"using pfx.pfxcore.test.MemoryBackendsRunnerMixin.")
+
+    @classmethod
+    def outbox(cls):
+        """The emails created so far, in creation order."""
+        cls._check_email_backend()
+        return list(get_email_model().objects.order_by('pk'))
+
+    @classmethod
+    def clear_outbox(cls):
+        cls._check_email_backend()
+        get_email_model().objects.all().delete()
+
+    @classmethod
+    def email_to(cls, email):
+        """The addresses of the ``To`` of ``email``, without the names."""
+        return [r['Email'] for r in email.mail_to]
+
+    @classmethod
+    def get_email_html(cls, email):
+        if not email.html_part:
+            raise AssertionError("Email does not contain an HTML part.")
+        return email.html_part

django_pfx-1.7.6.dev25/pfx/pfxcore/sms/backends/memory.py

@@ -0,0 +1,15 @@
+from .base import BaseSMSBackend
+
+
+class MemorySMSBackend(BaseSMSBackend):
+    """Collect the SMS in :attr:`outbox` instead of sending them.
+
+    A new backend instance is built for each send (see
+    :func:`pfx.pfxcore.sms.get_sms_backend`), so the outbox is a class
+    attribute."""
+
+    #: The sent SMS, as ``(to, message)`` tuples.
+    outbox = []
+
+    def send_sms(self, to, message):
+        self.outbox.append((to, message))

{django_pfx-1.7.6.dev23 → django_pfx-1.7.6.dev25}/pfx/pfxcore/test.py

@@ -5,8 +5,16 @@ from functools import reduce
 from http.cookies import SimpleCookie
 from json import JSONDecodeError
 
+from django.apps import apps
 from django.db import transaction
+from django.test import override_settings
 from django.test.client import Client as DjangoClient
+from django.test.runner import DiscoverRunner, ParallelTestSuite
+from django.test.runner import _init_worker as django_init_worker
+from django.utils.module_loading import import_string
+
+from pfx.pfxcore.settings import settings
+from pfx.pfxcore.sms.backends.memory import MemorySMSBackend
 
 logger = logging.getLogger(__name__)
 
@@ -322,3 +330,94 @@ class MockBoto3Client:
 
     def delete_object(self, *args, **kwargs):
         pass
+
+
+def get_test_backends():
+    """The backends that replace the real ones during the tests."""
+    backends = dict(PFX_SMS_BACKEND=getattr(
+        settings, 'PFX_TEST_SMS_BACKEND',
+        'pfx.pfxcore.sms.backends.memory.MemorySMSBackend'))
+    if apps.is_installed('pfx.emails'):
+        backends['EMAIL_BACKEND'] = getattr(
+            settings, 'PFX_TEST_EMAIL_BACKEND',
+            'pfx.emails.email_backend.MemoryEmailBackend')
+    return backends
+
+
+def _init_worker(*args, **kwargs):
+    # A spawned worker calls setup_test_environment() again, which puts
+    # locmem back.
+    django_init_worker(*args, **kwargs)
+    override_settings(**get_test_backends()).enable()
+
+
+class MemoryBackendsParallelTestSuite(ParallelTestSuite):
+    init_worker = _init_worker
+
+
+class MemoryBackendsRunnerMixin:
+    """Replace the SMS and email backends for the whole run.
+
+    Nothing leaves the tests, whatever the local settings contain, and
+    what would be sent is kept for the assertions (see
+    :class:`SMSTestMixin` and :class:`pfx.emails.test.EmailTestMixin`).
+
+    - ``PFX_SMS_BACKEND`` becomes ``PFX_TEST_SMS_BACKEND`` (default
+      :class:`pfx.pfxcore.sms.backends.memory.MemorySMSBackend`).
+    - If ``pfx.emails`` is installed, ``EMAIL_BACKEND`` becomes
+      ``PFX_TEST_EMAIL_BACKEND`` (default
+      :class:`pfx.emails.email_backend.MemoryEmailBackend`) instead of
+      the ``locmem`` backend set by Django: the email model is built and
+      validated, which ``locmem`` never does.
+
+    A test class decorated with ``override_settings`` keeps its own
+    backends."""
+
+    parallel_test_suite = MemoryBackendsParallelTestSuite
+
+    def setup_test_environment(self, **kwargs):
+        super().setup_test_environment(**kwargs)
+        self._test_backends = override_settings(**get_test_backends())
+        self._test_backends.enable()
+
+    def teardown_test_environment(self, **kwargs):
+        self._test_backends.disable()
+        super().teardown_test_environment(**kwargs)
+
+
+class TestRunner(MemoryBackendsRunnerMixin, DiscoverRunner):
+    pass
+
+
+class SMSTestMixin:
+    """Helpers to check the SMS sent by a test.
+
+    The outbox is emptied before each test, as Django does for
+    ``mail.outbox``."""
+
+    @classmethod
+    def _sms_backend(cls):
+        backend = import_string(settings.PFX_SMS_BACKEND)
+        if not issubclass(backend, MemorySMSBackend):
+            raise AssertionError(
+                f"PFX_SMS_BACKEND is {settings.PFX_SMS_BACKEND}, the SMS "
+                f"are not collected. Run the tests with a runner using "
+                f"pfx.pfxcore.test.MemoryBackendsRunnerMixin.")
+        return backend
+
+    # __call__ rather than _pre_setup: a classmethod in Django 5.2, an
+    # instance method in 4.2.
+    def __call__(self, *args, **kwargs):
+        backend = import_string(settings.PFX_SMS_BACKEND)
+        if issubclass(backend, MemorySMSBackend):
+            backend.outbox.clear()
+        return super().__call__(*args, **kwargs)
+
+    @classmethod
+    def sms_outbox(cls):
+        """The SMS sent so far, as ``(to, message)`` tuples."""
+        return list(cls._sms_backend().outbox)
+
+    @classmethod
+    def clear_sms_outbox(cls):
+        cls._sms_backend().outbox.clear()

django_pfx-1.7.6.dev25/pfx/pfxcore/xml_test_runner.py

@@ -0,0 +1,8 @@
+from xmlrunner.extra.djangotestrunner import XMLTestRunner as BaseXMLTestRunner
+
+from pfx.pfxcore.test import MemoryBackendsRunnerMixin
+
+
+class XMLTestRunner(MemoryBackendsRunnerMixin, BaseXMLTestRunner):
+    """:class:`pfx.pfxcore.test.TestRunner` with the XML reports of
+    ``unittest-xml-reporting``, which must be installed."""

django_pfx-1.7.6.dev25/tests/tests/test_emails_test_tools.py

@@ -0,0 +1,60 @@
+from django.core import mail
+from django.core.exceptions import ValidationError
+from django.core.mail import EmailMultiAlternatives, send_mail
+from django.test import TestCase, override_settings
+
+from pfx.emails.models import Email
+from pfx.emails.test import EmailTestMixin
+
+MEMORY_BACKEND = 'pfx.emails.email_backend.MemoryEmailBackend'
+
+
+@override_settings(EMAIL_BACKEND=MEMORY_BACKEND)
+class TestMemoryEmailBackend(EmailTestMixin, TestCase):
+    """The backend goes as far as the saved email, never further."""
+
+    def test_the_email_is_saved_and_not_sent(self):
+        send_mail(
+            'Subject', 'Content', 'from@example.com', ['to@example.com'])
+        email = Email.objects.get()
+        self.assertEqual(email.send_mode, 'manual')
+        self.assertEqual(email.status, 'to_send')
+        self.assertEqual(mail.outbox, [])
+
+    def test_an_invalid_email_fails(self):
+        """What locmem cannot see: the email model refuses the message."""
+        with self.assertRaises(ValidationError):
+            send_mail(
+                'Subject', 'Content', 'from@example.com', ['not-an-email'])
+
+    def test_outbox_helpers(self):
+        send_mail(
+            'First', 'Content', 'from@example.com',
+            ['"Jean Dupont" <jean@example.com>', 'paul@example.com'])
+        message = EmailMultiAlternatives(
+            'Second', 'Text', 'from@example.com', ['marie@example.com'])
+        message.attach_alternative('<p>HTML</p>', 'text/html')
+        message.send()
+
+        first, second = self.outbox()
+        self.assertEqual(
+            [first.subject, second.subject], ['First', 'Second'])
+        self.assertEqual(
+            self.email_to(first), ['jean@example.com', 'paul@example.com'])
+        self.assertEqual(self.get_email_html(second), '<p>HTML</p>')
+        with self.assertRaises(AssertionError):
+            self.get_email_html(first)
+
+        self.clear_outbox()
+        self.assertEqual(self.outbox(), [])
+
+
+class TestEmailTestMixinWithLocmem(EmailTestMixin, TestCase):
+    """Without the runner, locmem is still there: the helpers refuse to
+    answer instead of reporting an empty outbox."""
+
+    def test_the_helpers_refuse_locmem(self):
+        with self.assertRaises(AssertionError):
+            self.outbox()
+        with self.assertRaises(AssertionError):
+            self.clear_outbox()

django_pfx-1.7.6.dev25/tests/tests/test_test_runner.py

@@ -0,0 +1,117 @@
+import unittest
+from unittest.mock import patch
+
+from django.conf import settings
+from django.test import SimpleTestCase, override_settings
+from django.test.utils import setup_test_environment, teardown_test_environment
+
+from pfx.pfxcore.settings import settings as pfx_settings
+from pfx.pfxcore.sms import get_sms_backend
+from pfx.pfxcore.sms.backends.memory import MemorySMSBackend
+from pfx.pfxcore.test import (
+    MemoryBackendsParallelTestSuite,
+    MemoryBackendsRunnerMixin,
+    SMSTestMixin,
+    TestRunner,
+    _init_worker,
+    get_test_backends,
+)
+
+MEMORY_EMAIL = 'pfx.emails.email_backend.MemoryEmailBackend'
+MEMORY_SMS = 'pfx.pfxcore.sms.backends.memory.MemorySMSBackend'
+
+
+class TestMemoryBackendsRunner(SimpleTestCase):
+
+    def test_the_runner_replaces_the_backends(self):
+        """The runner swaps the backends for the whole run, and puts the
+        original ones back at the end, locmem restored by Django included.
+
+        The test environment of the current run is torn down first, as
+        Django refuses to set it up twice, and restored afterwards."""
+        teardown_test_environment()
+        try:
+            email = settings.EMAIL_BACKEND
+            sms = pfx_settings.PFX_SMS_BACKEND
+            runner = TestRunner()
+            runner.setup_test_environment()
+            try:
+                self.assertEqual(settings.EMAIL_BACKEND, MEMORY_EMAIL)
+                self.assertEqual(pfx_settings.PFX_SMS_BACKEND, MEMORY_SMS)
+            finally:
+                runner.teardown_test_environment()
+            self.assertEqual(settings.EMAIL_BACKEND, email)
+            self.assertEqual(pfx_settings.PFX_SMS_BACKEND, sms)
+        finally:
+            setup_test_environment(debug=False)
+
+    def test_the_parallel_workers_get_the_backends(self):
+        """A spawned worker sets up the test environment again, locmem
+        included: the suite of the runner uses a worker init that puts the
+        backends back."""
+        self.assertIs(
+            TestRunner.parallel_test_suite, MemoryBackendsParallelTestSuite)
+        self.assertIs(
+            MemoryBackendsParallelTestSuite.init_worker, _init_worker)
+
+    def test_the_backends_are_configurable(self):
+        self.assertEqual(get_test_backends(), dict(
+            EMAIL_BACKEND=MEMORY_EMAIL, PFX_SMS_BACKEND=MEMORY_SMS))
+        with override_settings(
+                PFX_TEST_EMAIL_BACKEND='my.EmailBackend',
+                PFX_TEST_SMS_BACKEND='my.SMSBackend'):
+            self.assertEqual(get_test_backends(), dict(
+                EMAIL_BACKEND='my.EmailBackend',
+                PFX_SMS_BACKEND='my.SMSBackend'))
+
+    def test_the_email_backend_needs_pfx_emails(self):
+        """Without pfx.emails, there is no email model to fill: locmem
+        stays."""
+        with patch('pfx.pfxcore.test.apps.is_installed', return_value=False):
+            self.assertEqual(
+                get_test_backends(), dict(PFX_SMS_BACKEND=MEMORY_SMS))
+
+
+@override_settings(PFX_SMS_BACKEND=MEMORY_SMS)
+class TestSMSTestMixin(SMSTestMixin, SimpleTestCase):
+
+    def test_the_sms_are_collected(self):
+        get_sms_backend().send_sms('+41791234567', 'Code: 123456')
+        self.assertEqual(
+            self.sms_outbox(), [('+41791234567', 'Code: 123456')])
+        self.clear_sms_outbox()
+        self.assertEqual(self.sms_outbox(), [])
+
+    def test_the_outbox_is_emptied_before_each_test(self):
+        """An SMS left by a previous test is gone when the next starts."""
+        class ATest(SMSTestMixin, SimpleTestCase):
+            def test(self):
+                self.outbox_at_start = self.sms_outbox()
+
+        MemorySMSBackend.outbox.append(('+41791234567', 'Left over'))
+        test = ATest('test')
+        result = unittest.TestResult()
+        test(result)
+        self.assertTrue(result.wasSuccessful(), result.errors)
+        self.assertEqual(test.outbox_at_start, [])
+
+    @override_settings(
+        PFX_SMS_BACKEND='pfx.pfxcore.sms.backends.console.ConsoleSMSBackend')
+    def test_the_helpers_refuse_another_backend(self):
+        with self.assertRaises(AssertionError):
+            self.sms_outbox()
+
+
+class TestXMLTestRunner(SimpleTestCase):
+
+    def test_the_xml_runner_replaces_the_backends(self):
+        """The XML variant is the same runner: same backends, same parallel
+        workers, and the XML reports."""
+        from xmlrunner.extra.djangotestrunner import XMLTestRunner as Base
+
+        from pfx.pfxcore.xml_test_runner import XMLTestRunner
+
+        self.assertTrue(issubclass(XMLTestRunner, Base))
+        self.assertTrue(issubclass(XMLTestRunner, MemoryBackendsRunnerMixin))
+        self.assertIs(
+            XMLTestRunner.parallel_test_suite, MemoryBackendsParallelTestSuite)