django-pfx 1.7.6.dev33__tar.gz → 1.7.6.dev37__tar.gz

{django_pfx-1.7.6.dev33 → django_pfx-1.7.6.dev37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.7.6.dev33
+Version: 1.7.6.dev37
 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.dev33 → django_pfx-1.7.6.dev37}/django_pfx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.7.6.dev33
+Version: 1.7.6.dev37
 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.dev33 → django_pfx-1.7.6.dev37}/django_pfx.egg-info/SOURCES.txt

@@ -220,6 +220,7 @@ tests/tests/__init__.py
 tests/tests/basic_api_errors.py
 tests/tests/basic_api_test.py
 tests/tests/mfa_test_utils.py
+tests/tests/parallel_scenarios.py
 tests/tests/test_api_doc.py
 tests/tests/test_api_doc_search.py
 tests/tests/test_auth_api.py

{django_pfx-1.7.6.dev33 → django_pfx-1.7.6.dev37}/django_pfx.egg-info/scm_file_list.json

@@ -210,6 +210,7 @@
     "tests/tests/basic_api_errors.py",
     "tests/tests/basic_api_test.py",
     "tests/tests/mfa_test_utils.py",
+    "tests/tests/parallel_scenarios.py",
     "tests/tests/test_api_doc.py",
     "tests/tests/test_api_doc_search.py",
     "tests/tests/test_auth_api.py",

django_pfx-1.7.6.dev37/django_pfx.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.7.5",
+  "distance": 37,
+  "node": "g213d2ffb86d53a7b1417f5fa4929daa928146735",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-20"
+}

{django_pfx-1.7.6.dev33 → django_pfx-1.7.6.dev37}/pfx/pfxcore/fields/media_field.py

@@ -7,7 +7,7 @@ from urllib.parse import unquote_to_bytes
 
 from django.core.exceptions import ValidationError
 from django.db import models
-from django.db.models.signals import post_delete, post_init
+from django.db.models.signals import post_delete, post_init, post_save
 from django.dispatch import receiver
 
 from pfx.pfxcore.shortcuts import settings
@@ -80,7 +80,6 @@ class MediaField(models.JSONField):
         self.auto_delete = auto_delete
         self.allowed_keys = DEFAULT_KEYS.union(extra_keys or set())
         self.convert_heic = convert_heic
-        self._db_value = None
 
         # Inject default validator if empty
         kwargs.setdefault("validators", [validate_media_json])
@@ -113,8 +112,9 @@ class MediaField(models.JSONField):
         else:
             b64 = None
 
-        if self._db_value and (b64 or not value):
-            after_save.append(lambda: self.delete(self._db_value))
+        db_value = obj._media_db_values.get(self.name)
+        if db_value and (b64 or not value):
+            after_save.append(lambda: self.delete(db_value))
             setattr(obj, self.name, None)
         if b64:
             try:
@@ -160,11 +160,17 @@ class MediaField(models.JSONField):
         return self.storage.delete(value)
 
 
+# Kept on the instance: the field is shared by every instance of the model.
 @receiver(post_init)
-def post_init_media(sender, instance, **kwargs):
+@receiver(post_save)
+def store_media_db_values(sender, instance, update_fields=None, **kwargs):
     for field in sender._meta.fields:
-        if isinstance(field, MediaField):
-            field._db_value = field.value_from_object(instance)
+        if isinstance(field, MediaField) and (
+                update_fields is None or field.name in update_fields):
+            if not hasattr(instance, '_media_db_values'):
+                instance._media_db_values = {}
+            instance._media_db_values[field.name] = (
+                field.value_from_object(instance))
 
 
 @receiver(post_delete)

{django_pfx-1.7.6.dev33 → django_pfx-1.7.6.dev37}/pfx/pfxcore/test.py

@@ -1,6 +1,8 @@
+import copy
 import json
 import logging
 import re
+import traceback
 from functools import reduce
 from http.cookies import SimpleCookie
 from json import JSONDecodeError
@@ -9,7 +11,12 @@ 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 (
+    DiscoverRunner,
+    ParallelTestSuite,
+    RemoteTestResult,
+    RemoteTestRunner,
+)
 from django.test.runner import _init_worker as django_init_worker
 from django.utils.module_loading import import_string
 
@@ -351,8 +358,72 @@ def _init_worker(*args, **kwargs):
     override_settings(**get_test_backends()).enable()
 
 
+class UnpicklableTestError(Exception):
+    """An error a parallel worker could not send back, as text."""
+
+
+class UnpicklableTestFailure(UnpicklableTestError, AssertionError):
+    """A failure a parallel worker could not send back, as text."""
+
+
+class _Repr(str):
+    def __repr__(self):
+        return str(self)
+
+
+class PicklableRemoteTestResult(RemoteTestResult):
+    """Send every outcome of a parallel worker back to the parent.
+
+    Django aborts the whole run, without the traceback, on an exception it
+    cannot pickle (one holding a request, a lock, a local class…). Such an
+    exception is sent as its formatted traceback instead, and the run goes
+    on."""
+
+    def _picklable(self, err):
+        try:
+            self._confirm_picklable(err)
+        except Exception:
+            cls = (
+                UnpicklableTestFailure if issubclass(err[0], AssertionError)
+                else UnpicklableTestError)
+            return cls, cls(''.join(traceback.format_exception(*err))), None
+        return err
+
+    def _picklable_subtest(self, test, subtest):
+        # The subtest holds the running test case, which can become
+        # unpicklable after the failure: a fresh one is always sent.
+        subtest = copy.copy(subtest)
+        subtest.test_case = type(test)(test._testMethodName)
+        try:
+            self._confirm_picklable(subtest)
+        except Exception:
+            subtest.params = {
+                k: _Repr(repr(v)) for k, v in subtest.params.items()}
+        return subtest
+
+    def addError(self, test, err):
+        super().addError(test, self._picklable(err))
+
+    def addFailure(self, test, err):
+        super().addFailure(test, self._picklable(err))
+
+    def addExpectedFailure(self, test, err):
+        super().addExpectedFailure(test, self._picklable(err))
+
+    def addSubTest(self, test, subtest, err):
+        if err is not None:
+            err = self._picklable(err)
+            subtest = self._picklable_subtest(test, subtest)
+        super().addSubTest(test, subtest, err)
+
+
+class PicklableRemoteTestRunner(RemoteTestRunner):
+    resultclass = PicklableRemoteTestResult
+
+
 class MemoryBackendsParallelTestSuite(ParallelTestSuite):
     init_worker = _init_worker
+    runner_class = PicklableRemoteTestRunner
 
 
 class MemoryBackendsRunnerMixin:
@@ -371,7 +442,10 @@ class MemoryBackendsRunnerMixin:
       validated, which ``locmem`` never does.
 
     A test class decorated with ``override_settings`` keeps its own
-    backends."""
+    backends.
+
+    With ``--parallel``, the workers also send back the errors Django
+    cannot pickle (see :class:`PicklableRemoteTestResult`)."""
 
     parallel_test_suite = MemoryBackendsParallelTestSuite
 

{django_pfx-1.7.6.dev33 → django_pfx-1.7.6.dev37}/requirements.txt

@@ -4,6 +4,8 @@ pre-commit
 flake8
 isort
 coverage
+# Pickles the tracebacks of the --parallel workers.
+tblib
 psycopg
 Babel
 pyjwt>=2.1

{django_pfx-1.7.6.dev33 → django_pfx-1.7.6.dev37}/tests/tests/basic_api_test.py

@@ -847,6 +847,64 @@ class BasicAPITest(TestAssertMixin, TestCase):
         self.assertJE(response, 'local_file', None)
         self.assertFalse(Path(f'/tmp/django-pfx-filestore/{key2}').exists())
 
+    def _create_book_with_file(self, name):
+        response = self.client.post('/api/books', dict(
+            name=name,
+            author=self.author1.pk,
+            pub_date='2000-01-01',
+            local_file=dict(
+                name='test.txt',
+                base64='data:text/plain;charset=utf-8;'
+                'base64,VGVzdCBjb250ZW50')))
+        self.assertRC(response, 200)
+        return (
+            self.get_val(response, 'pk'),
+            self.get_val(response, 'local_file.key'))
+
+    def _replace_file(self, book):
+        book.local_file = dict(
+            name='new.txt',
+            base64='data:text/plain;charset=utf-8;base64,TmV3IGNvbnRlbnQ=')
+        funcs = Book._meta.get_field('local_file').media_pre_save(book)
+        book.save()
+        for func in funcs:
+            func()
+        return book.local_file['key']
+
+    def test_replace_file_after_loading_another_object(self):
+        """Replacing a file deletes the old file of that object only.
+
+        The original value used to live on the field, shared by every
+        instance of the model: loading a second book overwrote it, and
+        replacing the first book's file deleted the second book's file
+        while leaving the first one's old file orphaned.
+        """
+        pk1, key1 = self._create_book_with_file("Book 1")
+        pk2, key2 = self._create_book_with_file("Book 2")
+
+        book1 = Book.objects.get(pk=pk1)
+        Book.objects.get(pk=pk2)
+        self._replace_file(book1)
+
+        self.assertFalse(Path(f'/tmp/django-pfx-filestore/{key1}').exists())
+        self.assertTrue(Path(f'/tmp/django-pfx-filestore/{key2}').exists())
+
+    def test_replace_file_twice_on_same_instance(self):
+        """The original value follows each save, so a second replacement
+        on the same instance deletes the file of the first one rather
+        than the long-gone file it was loaded with."""
+        pk, key = self._create_book_with_file("Book")
+
+        book = Book.objects.get(pk=pk)
+        new_key = self._replace_file(book)
+        self.assertTrue(
+            Path(f'/tmp/django-pfx-filestore/{new_key}').exists())
+        self._replace_file(book)
+
+        self.assertFalse(Path(f'/tmp/django-pfx-filestore/{key}').exists())
+        self.assertFalse(
+            Path(f'/tmp/django-pfx-filestore/{new_key}').exists())
+
     def test_create_file_rejects_non_data_uri(self):
         """A media upload only accepts a ``data:`` URI.
 
@@ -1332,19 +1390,20 @@ class BasicAPITest(TestAssertMixin, TestCase):
         STORAGE_S3_AWS_PUT_URL_EXPIRE=300)
     @patch("boto3.client", MagicMock(return_value=MockBoto3Client()))
     def test_media_field(self):
+        key = f"Book/{self.author1_book1.pk}/cover.png"
         response = self.client.get(
             f'/api/books/{self.author1_book1.pk}/cover/upload-url/'
             'cover.png?content-type=image/png')
         self.assertRC(response, 200)
-        self.assertJE(response, 'file.key', "Book/1/cover.png")
+        self.assertJE(response, 'file.key', key)
         self.assertJE(response, 'file.name', "cover.png")
         self.assertJE(
-            response, 'url', "http://dragonfly.fake/Book/1/cover.png")
+            response, 'url', f"http://dragonfly.fake/{key}")
 
         response = self.client.put(f'/api/books/{self.author1_book1.pk}', dict(
             cover=response.json_content['file']))
         self.assertRC(response, 200)
-        self.assertJE(response, 'cover.key', "Book/1/cover.png")
+        self.assertJE(response, 'cover.key', key)
         self.assertJE(response, 'cover.name', "cover.png")
         self.assertJE(response, 'cover.content-length', 1000)
         self.assertJE(response, 'cover.content-type', "image/png")
@@ -1353,18 +1412,18 @@ class BasicAPITest(TestAssertMixin, TestCase):
             f'/api/books/{self.author1_book1.pk}/cover')
         self.assertRC(response, 200)
         self.assertJE(
-            response, 'url', "http://dragonfly.fake/Book/1/cover.png")
+            response, 'url', f"http://dragonfly.fake/{key}")
 
         response = self.client.get(
             f'/api/books/{self.author1_book1.pk}/cover?redirect=false')
         self.assertRC(response, 200)
         self.assertJE(
-            response, 'url', "http://dragonfly.fake/Book/1/cover.png")
+            response, 'url', f"http://dragonfly.fake/{key}")
 
         response = self.client.get(
             f'/api/books/{self.author1_book1.pk}/cover?redirect=true')
         self.assertRedirects(
-            response, "http://dragonfly.fake/Book/1/cover.png",
+            response, f"http://dragonfly.fake/{key}",
             fetch_redirect_response=False)
 
         with patch.object(
@@ -1374,7 +1433,7 @@ class BasicAPITest(TestAssertMixin, TestCase):
                 f'/api/books/{self.author1_book1.pk}')
             mock_delete.assert_called_with(
                 Bucket='dragonfly.fake',
-                Key=f'Book/{self.author1_book1.pk}/cover.png')
+                Key=key)
 
     def test_annotate_meta_service(self):
         response = self.client.get('/api/authors-annotate/meta')

django_pfx-1.7.6.dev37/tests/tests/parallel_scenarios.py

@@ -0,0 +1,89 @@
+"""Test cases that fail in ways a parallel worker cannot pickle.
+
+Run by test_test_runner.py, not by the discovery (the name does not start
+with ``test``). They live at module level as real test classes do: the
+parent process rebuilds a test case from its class."""
+import threading
+import unittest
+
+
+class Unpicklable(Exception):
+    def __init__(self):
+        super().__init__("holds a lock")
+        self.lock = threading.Lock()
+
+
+class KeywordOnly(Exception):
+    """Pickles, but cannot be rebuilt from its args."""
+
+    def __init__(self, *, code):
+        super().__init__(f"code {code}")
+        self.code = code
+
+
+class UnpicklableAssertion(AssertionError):
+    def __init__(self):
+        super().__init__("assertion holding a lock")
+        self.lock = threading.Lock()
+
+
+class Scenarios(unittest.TestCase):
+
+    def test_plain_failure(self):
+        self.assertEqual(1, 2)
+
+    def test_lock_in_the_exception(self):
+        raise Unpicklable()
+
+    def test_unpicklable_cause(self):
+        try:
+            raise Unpicklable()
+        except Unpicklable as e:
+            raise ValueError("wrapped") from e
+
+    def test_local_class(self):
+        class Local(Exception):
+            pass
+        raise Local("local class")
+
+    def test_keyword_only_init(self):
+        raise KeywordOnly(code=42)
+
+    def test_unpicklable_assertion(self):
+        raise UnpicklableAssertion()
+
+    @unittest.expectedFailure
+    def test_expected_failure(self):
+        raise Unpicklable()
+
+    def test_subtest_then_a_lock(self):
+        with self.subTest(i=1):
+            self.assertEqual(1, 5)
+        self.lock = threading.Lock()
+
+    def test_subtest_with_a_lock_param(self):
+        with self.subTest(lock=threading.Lock()):
+            self.fail("with a lock as param")
+
+    def test_subtest_unpicklable_error(self):
+        with self.subTest(n=1):
+            raise Unpicklable()
+
+
+class TearDownError(unittest.TestCase):
+
+    def tearDown(self):
+        raise Unpicklable()
+
+    def test_ok(self):
+        pass
+
+
+class SetUpClassError(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        raise Unpicklable()
+
+    def test_never_runs(self):
+        pass

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

@@ -0,0 +1,234 @@
+import io
+import pickle
+import re
+import unittest
+from contextlib import redirect_stdout
+from unittest.mock import patch
+
+from django.conf import settings
+from django.test import SimpleTestCase, override_settings
+from django.test.runner import RemoteTestRunner
+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,
+    PicklableRemoteTestResult,
+    PicklableRemoteTestRunner,
+    SMSTestMixin,
+    TestRunner,
+    _init_worker,
+    get_test_backends,
+)
+
+from . import parallel_scenarios
+
+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))
+
+
+def run_in_worker(runner_class, *tests):
+    """Run the tests as a parallel worker does, send its events through
+    pickle as multiprocessing does, and replay them in a parent result.
+
+    The tests are listed before the run: the suite drops them as they
+    run."""
+    suite = unittest.TestSuite(tests)
+    listed = list(suite)
+    events = pickle.loads(pickle.dumps(runner_class().run(suite).events))
+    parent = unittest.TestResult()
+    for event in events:
+        MemoryBackendsParallelTestSuite([], 1).handle_event(
+            parent, listed, event)
+    return parent
+
+
+def outcomes(results):
+    """{test id without its module: last line of the traceback}
+
+    The ``[<object object at 0x…>]`` of a subtest without message is left
+    out: unittest compares its message to a sentinel object, which does not
+    survive pickling, in Django as here."""
+    prefix = f'{parallel_scenarios.__name__}.'
+    return {
+        re.sub(r' \[<object object at 0x\w+>\]', '', test.id())
+        .removeprefix(prefix): text.strip().splitlines()[-1]
+        for test, text in results}
+
+
+class TestPicklableRemoteTestResult(SimpleTestCase):
+
+    def test_the_runners_use_it(self):
+        self.assertIs(
+            MemoryBackendsParallelTestSuite.runner_class,
+            PicklableRemoteTestRunner)
+
+    def test_django_aborts_on_an_unpicklable_error(self):
+        """Why this result exists: the Django one lets the pickling error
+        rise, which aborts the whole run in the parent process."""
+        with redirect_stdout(io.StringIO()), self.assertRaises(TypeError):
+            run_in_worker(RemoteTestRunner, parallel_scenarios.Scenarios(
+                'test_lock_in_the_exception'))
+
+    def test_every_outcome_is_sent_back(self):
+        """Each way of failing Django cannot pickle reaches the parent,
+        under its test, as an error or a failure as it was raised, with
+        the original exception at the end of the traceback."""
+        names = unittest.TestLoader().getTestCaseNames(
+            parallel_scenarios.Scenarios)
+        parent = run_in_worker(
+            PicklableRemoteTestRunner,
+            *map(parallel_scenarios.Scenarios, names),
+            parallel_scenarios.TearDownError('test_ok'))
+        module = parallel_scenarios.__name__
+        lock = f'{module}.Unpicklable: holds a lock'
+        self.assertEqual(outcomes(parent.errors), {
+            'Scenarios.test_keyword_only_init':
+                f'{module}.KeywordOnly: code 42',
+            'Scenarios.test_local_class':
+                f'{module}.Scenarios.test_local_class.<locals>.Local: '
+                'local class',
+            'Scenarios.test_lock_in_the_exception': lock,
+            'Scenarios.test_subtest_unpicklable_error (n=1)': lock,
+            'Scenarios.test_unpicklable_cause': 'ValueError: wrapped',
+            'TearDownError.test_ok': lock,
+        })
+        [cause] = [
+            text for test, text in parent.errors
+            if test.id().endswith('test_unpicklable_cause')]
+        self.assertIn(lock, cause)
+        failures = outcomes(parent.failures)
+        # The lock of the subtest params is sent as its repr.
+        [lock_param] = [
+            k for k in failures if k.startswith(
+                'Scenarios.test_subtest_with_a_lock_param (lock=<unlocked')]
+        self.assertEqual(failures, {
+            'Scenarios.test_plain_failure': 'AssertionError: 1 != 2',
+            'Scenarios.test_subtest_then_a_lock (i=1)':
+                'AssertionError: 1 != 5',
+            lock_param: 'AssertionError: with a lock as param',
+            'Scenarios.test_unpicklable_assertion':
+                f'{module}.UnpicklableAssertion: assertion holding a lock',
+        })
+        self.assertEqual(
+            list(outcomes(parent.expectedFailures)),
+            ['Scenarios.test_expected_failure'])
+
+    def test_a_class_fixture_error_is_sent_back(self):
+        """Django sends each class in its own subsuite: a setUpClass error
+        comes before the first test, and is reported under the class."""
+        parent = run_in_worker(
+            PicklableRemoteTestRunner,
+            parallel_scenarios.SetUpClassError('test_never_runs'))
+        module = parallel_scenarios.__name__
+        self.assertEqual(outcomes(parent.errors), {
+            f'setUpClass ({module}.SetUpClassError)':
+                f'{module}.Unpicklable: holds a lock'})
+
+    def test_a_picklable_error_is_sent_as_is(self):
+        """What pickles goes through untouched, as with Django.
+
+        Checked without a traceback: a traceback only pickles with tblib,
+        and without it every error is sent as text (where Django aborts
+        the run and asks for tblib)."""
+        err = (AssertionError, AssertionError('1 != 2'), None)
+        self.assertIs(PicklableRemoteTestResult()._picklable(err), err)
+
+
+@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)

django_pfx-1.7.6.dev33/django_pfx.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.7.5",
-  "distance": 33,
-  "node": "gcc4ff94bcc60ebba66f3ffe5034d8ffcdd15cdde",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-14"
-}