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

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

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

@@ -1,8 +0,0 @@
-{
-  "tag": "1.7.5",
-  "distance": 35,
-  "node": "gb6a06c83048f8ebb878d880aa41c71f04adb2127",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-19"
-}

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

@@ -1,117 +0,0 @@
-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)