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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.7.6.dev21
+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.dev21 → 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.dev21
+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.dev21 → 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.dev21 → 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.dev21 → django_pfx-1.7.6.dev25}/django_pfx.egg-info/scm_version.json

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

{django_pfx-1.7.6.dev21 → 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.dev21 → 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.dev21 → 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.dev21 → django_pfx-1.7.6.dev25}/pfx/pfxcore/fields/media_field.py

@@ -1,7 +1,9 @@
+import base64
+import binascii
 import io
 import logging
 from importlib import import_module
-from urllib.request import urlopen
+from urllib.parse import unquote_to_bytes
 
 from django.core.exceptions import ValidationError
 from django.db import models
@@ -15,6 +17,30 @@ logger = logging.getLogger(__name__)
 DEFAULT_KEYS = {"key", "name", "content-type", "content-length"}
 
 
+def decode_data_uri(value):
+    """Return the bytes carried by a ``data:`` URI, and only that.
+
+    The uploaded content reaches the server as this string. It used to be
+    handed to ``urlopen``, which also opens ``file://`` and ``http://``:
+    a client could then have the server read a local file or reach the
+    internal network. Only the ``data:`` scheme is accepted here, and it
+    is decoded in place, never opened.
+
+    :raises ValidationError: when the value is not a valid ``data:`` URI
+    """
+    if not isinstance(value, str) or not value.startswith('data:'):
+        raise ValidationError("Le contenu doit être une URI « data: ».")
+    header, sep, data = value[len('data:'):].partition(',')
+    if not sep:
+        raise ValidationError("URI « data: » invalide.")
+    if ';base64' in header:
+        try:
+            return base64.b64decode(data, validate=True)
+        except (binascii.Error, ValueError):
+            raise ValidationError("URI « data: » invalide.")
+    return unquote_to_bytes(data)
+
+
 def get_storage_class(class_path):
     ps = class_path.split('.')
     return getattr(import_module('.'.join(ps[:-1])), ps[-1])()
@@ -91,8 +117,10 @@ class MediaField(models.JSONField):
             after_save.append(lambda: self.delete(self._db_value))
             setattr(obj, self.name, None)
         if b64:
-            with urlopen(b64) as response:
-                file = response.read()
+            try:
+                file = decode_data_uri(b64)
+            except ValidationError as e:
+                raise ValidationError({self.name: e.messages})
             setattr(obj, self.name, dict(key=self.get_key(obj, name)))
             after_save.append(lambda: save_file(obj, file, name))
         return after_save

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.dev21 → 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.dev21 → django_pfx-1.7.6.dev25}/tests/tests/basic_api_test.py

@@ -847,6 +847,37 @@ class BasicAPITest(TestAssertMixin, TestCase):
         self.assertJE(response, 'local_file', None)
         self.assertFalse(Path(f'/tmp/django-pfx-filestore/{key2}').exists())
 
+    def test_create_file_rejects_non_data_uri(self):
+        """A media upload only accepts a ``data:`` URI.
+
+        The content used to be handed to ``urlopen``, so ``file://`` made
+        the server read a local file and ``http://`` reach the network.
+        Both are refused now, with a field error, before anything is read.
+        """
+        for uri in (
+                'file:///etc/hostname',
+                'http://169.254.169.254/latest/meta-data/',
+                'not a uri at all'):
+            response = self.client.post('/api/books', dict(
+                name="Test Book",
+                author=self.author1.pk,
+                pub_date='2000-01-01',
+                local_file=dict(name='x.txt', base64=uri)))
+            self.assertRC(response, 422)
+            self.assertJEExists(response, 'local_file')
+
+    def test_create_file_url_encoded_data_uri(self):
+        """A ``data:`` URI without ``;base64`` is percent-decoded, as
+        ``urlopen`` did, so that path keeps working without it."""
+        response = self.client.post('/api/books', dict(
+            name="Test Book",
+            author=self.author1.pk,
+            pub_date='2000-01-01',
+            local_file=dict(
+                name='test.txt', base64='data:text/plain,Hello%20world')))
+        self.assertRC(response, 200)
+        self.assertJE(response, 'local_file.content-length', '11')
+
     def test_get_file_content_disposition(self):
         """The file name must survive both local serving paths.
 

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()