plain.pytest 0.0.0__tar.gz

plain_pytest-0.0.0/LICENSE

@@ -0,0 +1,58 @@
+## Plain is released under the BSD 3-Clause License
+
+BSD 3-Clause License
+
+Copyright (c) 2023, Dropseed, LLC
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+## This package contains code forked from github.com/pytest-dev/pytest-django
+
+Copyright (c) 2015-2018, pytest-django authors (see AUTHORS file)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+ * The names of its contributors may not be used to endorse or promote products
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

plain_pytest-0.0.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: plain.pytest
+Version: 0.0.0
+Summary: Testing for Plain
+Home-page: https://www.plainpackages.com/
+License: MIT
+Keywords: django,saas,plain,framework
+Author: Dave Gaeddert
+Author-email: dave.gaeddert@dropseed.dev
+Requires-Python: >=3.8,<4.0
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.0.0)
+Requires-Dist: pytest (>=7.0.0,<8.0.0)
+Project-URL: Documentation, https://www.plainpackages.com/docs/
+Project-URL: Repository, https://github.com/plainpackages/plain-pytest
+Description-Content-Type: text/markdown
+
+<!-- This file is compiled from plain-pytest/plain/pytest/README.md. Do not edit this file directly. -->
+
+## Testing - pytest
+
+Write and run tests with pytest.
+
+Django includes its own test runner and [unittest](https://docs.python.org/3/library/unittest.html#module-unittest) classes.
+But a lot of people (myself included) prefer [pytest](https://docs.pytest.org/en/latest/contents.html).
+
+In Plain I've removed the Django test runner and a lot of the implications that come with it.
+There are a few utilities that remain to make testing easier,
+and `plain-test` is a wrapper around `pytest`.
+

plain_pytest-0.0.0/README.md

@@ -0,0 +1,12 @@
+<!-- This file is compiled from plain-pytest/plain/pytest/README.md. Do not edit this file directly. -->
+
+## Testing - pytest
+
+Write and run tests with pytest.
+
+Django includes its own test runner and [unittest](https://docs.python.org/3/library/unittest.html#module-unittest) classes.
+But a lot of people (myself included) prefer [pytest](https://docs.pytest.org/en/latest/contents.html).
+
+In Plain I've removed the Django test runner and a lot of the implications that come with it.
+There are a few utilities that remain to make testing easier,
+and `plain-test` is a wrapper around `pytest`.

plain_pytest-0.0.0/plain/pytest/README.md

@@ -0,0 +1,10 @@
+## Testing - pytest
+
+Write and run tests with pytest.
+
+Django includes its own test runner and [unittest](https://docs.python.org/3/library/unittest.html#module-unittest) classes.
+But a lot of people (myself included) prefer [pytest](https://docs.pytest.org/en/latest/contents.html).
+
+In Plain I've removed the Django test runner and a lot of the implications that come with it.
+There are a few utilities that remain to make testing easier,
+and `plain-test` is a wrapper around `pytest`.

plain_pytest-0.0.0/plain/pytest/__init__.py

@@ -0,0 +1,3 @@
+from .cli import cli
+
+__all__ = ["cli"]

plain_pytest-0.0.0/plain/pytest/cli.py

@@ -0,0 +1,48 @@
+import os
+import subprocess
+import sys
+
+import click
+
+from plain.runtime import settings
+
+
+@click.command(
+    context_settings={
+        "ignore_unknown_options": True,
+    }
+)
+@click.argument("pytest_args", nargs=-1, type=click.UNPROCESSED)
+def cli(pytest_args):
+    """Run tests with pytest"""
+
+    plain_tmp_dir = str(settings.PLAIN_TEMP_PATH)
+
+    if not os.path.exists(os.path.join(plain_tmp_dir, ".gitignore")):
+        os.makedirs(plain_tmp_dir, exist_ok=True)
+        with open(os.path.join(plain_tmp_dir, ".gitignore"), "w") as f:
+            f.write("*\n")
+
+    # Turn deprecation warnings into errors
+    #     if "-W" not in pytest_args:
+    #         pytest_args = list(pytest_args)  # Make sure it's a list instead of tuple
+    #         pytest_args.append("-W")
+    #         pytest_args.append("error::DeprecationWarning")
+
+    os.environ.setdefault("PLAIN_ENV", "test")
+
+    click.secho(f"Running pytest with PLAIN_ENV={os.environ['PLAIN_ENV']}", bold=True)
+
+    result = subprocess.run(
+        [
+            "pytest",
+            *pytest_args,
+        ],
+        env={
+            **os.environ,
+        },
+    )
+
+    if result.returncode:
+        # Can be invoked by pre-commit, so only exit if it fails
+        sys.exit(result.returncode)

plain_pytest-0.0.0/plain/pytest/pytest/fixtures.py

@@ -0,0 +1,335 @@
+"""All pytest-plain fixtures"""
+from collections.abc import Generator, Iterable
+from contextlib import contextmanager
+from functools import partial
+from typing import Any, Optional, Union
+
+import pytest
+
+from ..testcases import TestCase, TransactionTestCase
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Literal
+
+    import plain.runtime
+
+    _DjangoDbDatabases = Optional[Union["Literal['__all__']", Iterable[str]]]
+    # transaction, reset_sequences, databases, serialized_rollback
+    _DjangoDb = tuple[bool, bool, _DjangoDbDatabases, bool]
+
+
+__all__ = [
+    "plain_db_setup",
+    "db",
+    "transactional_db",
+    "plain_db_reset_sequences",
+    "plain_db_serialized_rollback",
+    "client",
+    "rf",
+    "settings",
+    "plain_assert_num_queries",
+    "plain_assert_max_num_queries",
+]
+
+
+@pytest.fixture(scope="session")
+def plain_db_setup(
+    request,
+    plain_test_environment: None,
+    plain_db_blocker,
+) -> None:
+    """Top level fixture to ensure test databases are available"""
+    from plain.test.utils import setup_databases, teardown_databases
+
+    setup_databases_args = {}
+
+    if request.config.getvalue("reuse_db") and not request.config.getvalue("create_db"):
+        setup_databases_args["keepdb"] = True
+
+    with plain_db_blocker.unblock():
+        db_cfg = setup_databases(
+            verbosity=request.config.option.verbose,
+            interactive=False,
+            **setup_databases_args,
+        )
+
+    def teardown_database() -> None:
+        with plain_db_blocker.unblock():
+            try:
+                teardown_databases(db_cfg, verbosity=request.config.option.verbose)
+            except Exception as exc:
+                request.node.warn(
+                    pytest.PytestWarning(
+                        f"Error when trying to teardown test databases: {exc!r}"
+                    )
+                )
+
+    if not request.config.getvalue("reuse_db"):
+        request.addfinalizer(teardown_database)
+
+
+@pytest.fixture()
+def _plain_db_helper(
+    request,
+    plain_db_setup: None,
+    plain_db_blocker,
+) -> None:
+    marker = request.node.get_closest_marker("plain_db")
+    if marker:
+        (
+            transactional,
+            reset_sequences,
+            databases,
+            serialized_rollback,
+        ) = validate_plain_db(marker)
+    else:
+        (
+            transactional,
+            reset_sequences,
+            databases,
+            serialized_rollback,
+        ) = (
+            False,
+            False,
+            None,
+            False,
+        )
+
+    transactional = (
+        transactional or reset_sequences or ("transactional_db" in request.fixturenames)
+    )
+    reset_sequences = reset_sequences or (
+        "plain_db_reset_sequences" in request.fixturenames
+    )
+    serialized_rollback = serialized_rollback or (
+        "plain_db_serialized_rollback" in request.fixturenames
+    )
+
+    plain_db_blocker.unblock()
+    request.addfinalizer(plain_db_blocker.restore)
+
+    if transactional:
+        test_case_class = TransactionTestCase
+    else:
+        test_case_class = TestCase
+
+    _reset_sequences = reset_sequences
+    _serialized_rollback = serialized_rollback
+    _databases = databases
+
+    class PytestDjangoTestCase(test_case_class):  # type: ignore[misc,valid-type]
+        reset_sequences = _reset_sequences
+        serialized_rollback = _serialized_rollback
+        if _databases is not None:
+            databases = _databases
+
+    PytestDjangoTestCase.setUpClass()
+
+    request.addfinalizer(PytestDjangoTestCase.doClassCleanups)
+    request.addfinalizer(PytestDjangoTestCase.tearDownClass)
+
+    test_case = PytestDjangoTestCase(methodName="__init__")
+    test_case._pre_setup()
+    request.addfinalizer(test_case._post_teardown)
+
+
+def validate_plain_db(marker) -> "_DjangoDb":
+    """Validate the plain_db marker.
+
+    It checks the signature and creates the ``transaction``,
+    ``reset_sequences``, ``databases`` and ``serialized_rollback`` attributes on
+    the marker which will have the correct values.
+
+    Sequence reset and serialized_rollback are only allowed when combined with
+    transaction.
+    """
+
+    def apifun(
+        transaction: bool = False,
+        reset_sequences: bool = False,
+        databases: "_DjangoDbDatabases" = None,
+        serialized_rollback: bool = False,
+    ) -> "_DjangoDb":
+        return transaction, reset_sequences, databases, serialized_rollback
+
+    return apifun(*marker.args, **marker.kwargs)
+
+
+# ############### User visible fixtures ################
+
+
+@pytest.fixture()
+def db(_plain_db_helper: None) -> None:
+    """Require a plain test database.
+
+    This database will be setup with the default fixtures and will have
+    the transaction management disabled. At the end of the test the outer
+    transaction that wraps the test itself will be rolled back to undo any
+    changes to the database (in case the backend supports transactions).
+    This is more limited than the ``transactional_db`` fixture but
+    faster.
+
+    If both ``db`` and ``transactional_db`` are requested,
+    ``transactional_db`` takes precedence.
+    """
+    # The `_plain_db_helper` fixture checks if `db` is requested.
+
+
+@pytest.fixture()
+def transactional_db(_plain_db_helper: None) -> None:
+    """Require a plain test database with transaction support.
+
+    This will re-initialise the plain database for each test and is
+    thus slower than the normal ``db`` fixture.
+
+    If you want to use the database with transactions you must request
+    this resource.
+
+    If both ``db`` and ``transactional_db`` are requested,
+    ``transactional_db`` takes precedence.
+    """
+    # The `_plain_db_helper` fixture checks if `transactional_db` is requested.
+
+
+@pytest.fixture()
+def plain_db_reset_sequences(
+    _plain_db_helper: None,
+    transactional_db: None,
+) -> None:
+    """Require a transactional test database with sequence reset support.
+
+    This requests the ``transactional_db`` fixture, and additionally
+    enforces a reset of all auto increment sequences.  If the enquiring
+    test relies on such values (e.g. ids as primary keys), you should
+    request this resource to ensure they are consistent across tests.
+    """
+    # The `_plain_db_helper` fixture checks if `plain_db_reset_sequences`
+    # is requested.
+
+
+@pytest.fixture()
+def plain_db_serialized_rollback(
+    _plain_db_helper: None,
+    db: None,
+) -> None:
+    """Require a test database with serialized rollbacks.
+
+    This requests the ``db`` fixture, and additionally performs rollback
+    emulation - serializes the database contents during setup and restores
+    it during teardown.
+
+    This fixture may be useful for transactional tests, so is usually combined
+    with ``transactional_db``, but can also be useful on databases which do not
+    support transactions.
+
+    Note that this will slow down that test suite by approximately 3x.
+    """
+    # The `_plain_db_helper` fixture checks if `plain_db_serialized_rollback`
+    # is requested.
+
+
+@pytest.fixture()
+def client() -> "plain.test.client.Client":
+    """A Plain test client instance."""
+    from plain.test.client import Client
+
+    return Client()
+
+
+@pytest.fixture()
+def rf() -> "plain.test.client.RequestFactory":
+    """RequestFactory instance"""
+    from plain.test.client import RequestFactory
+
+    return RequestFactory()
+
+
+class SettingsWrapper:
+    _to_restore: list[Any] = []
+
+    def __delattr__(self, attr: str) -> None:
+        from plain.test import override_settings
+
+        override = override_settings()
+        override.enable()
+        from plain.runtime import settings
+
+        delattr(settings, attr)
+
+        self._to_restore.append(override)
+
+    def __setattr__(self, attr: str, value) -> None:
+        from plain.test import override_settings
+
+        override = override_settings(**{attr: value})
+        override.enable()
+        self._to_restore.append(override)
+
+    def __getattr__(self, attr: str):
+        from plain.runtime import settings
+
+        return getattr(settings, attr)
+
+    def finalize(self) -> None:
+        for override in reversed(self._to_restore):
+            override.disable()
+
+        del self._to_restore[:]
+
+
+@pytest.fixture()
+def settings():
+    """A Plain settings object which restores changes after the testrun"""
+    wrapper = SettingsWrapper()
+    yield wrapper
+    wrapper.finalize()
+
+
+@contextmanager
+def _assert_num_queries(
+    config,
+    num: int,
+    exact: bool = True,
+    connection=None,
+    info=None,
+) -> Generator["plain.test.utils.CaptureQueriesContext", None, None]:
+    from plain.test.utils import CaptureQueriesContext
+
+    if connection is None:
+        from plain.models import connection as conn
+    else:
+        conn = connection
+
+    verbose = config.getoption("verbose") > 0
+    with CaptureQueriesContext(conn) as context:
+        yield context
+        num_performed = len(context)
+        if exact:
+            failed = num != num_performed
+        else:
+            failed = num_performed > num
+        if failed:
+            msg = f"Expected to perform {num} queries "
+            if not exact:
+                msg += "or less "
+            verb = "was" if num_performed == 1 else "were"
+            msg += f"but {num_performed} {verb} done"
+            if info:
+                msg += f"\n{info}"
+            if verbose:
+                sqls = (q["sql"] for q in context.captured_queries)
+                msg += "\n\nQueries:\n========\n\n" + "\n\n".join(sqls)
+            else:
+                msg += " (add -v option to show queries)"
+            pytest.fail(msg)
+
+
+@pytest.fixture()
+def plain_assert_num_queries(pytestconfig):
+    return partial(_assert_num_queries, pytestconfig)
+
+
+@pytest.fixture()
+def plain_assert_max_num_queries(pytestconfig):
+    return partial(_assert_num_queries, pytestconfig, exact=False)

plain_pytest-0.0.0/plain/pytest/pytest/plugin.py

@@ -0,0 +1,339 @@
+"""A pytest plugin which helps testing Plain applications
+
+This plugin handles creating and destroying the test environment and
+test database and provides some useful text fixtures.
+"""
+
+
+import pytest
+
+from .fixtures import (
+    _plain_db_helper,  # noqa
+    plain_assert_max_num_queries,  # noqa
+    plain_assert_num_queries,  # noqa
+    plain_db_reset_sequences,  # noqa
+    plain_db_serialized_rollback,  # noqa
+    plain_db_setup,  # noqa
+    client,  # noqa
+    db,  # noqa
+    rf,  # noqa
+    settings,  # noqa
+    transactional_db,  # noqa
+    validate_plain_db,
+)
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import ContextManager, NoReturn
+
+    import plain.runtime
+
+
+# ############### pytest hooks ################
+
+
+@pytest.hookimpl()
+def pytest_addoption(parser) -> None:
+    group = parser.getgroup("plain")
+    group.addoption(
+        "--reuse-db",
+        action="store_true",
+        dest="reuse_db",
+        default=False,
+        help="Re-use the testing database if it already exists, "
+        "and do not remove it when the test finishes.",
+    )
+    group.addoption(
+        "--create-db",
+        action="store_true",
+        dest="create_db",
+        default=False,
+        help="Re-create the database, even if it exists. This "
+        "option can be used to override --reuse-db.",
+    )
+
+    parser.addini(
+        "plain_debug_mode",
+        "How to set the Plain DEBUG setting (default `False`). "
+        "Use `keep` to not override.",
+        default="False",
+    )
+
+
+def _setup_plain() -> None:
+    import plain.runtime
+
+    plain.runtime.setup()
+
+    _blocking_manager.block()
+
+
+def _get_boolean_value(
+    x: None | bool | str,
+    name: str,
+    default: bool | None = None,
+) -> bool:
+    if x is None:
+        return bool(default)
+    if isinstance(x, bool):
+        return x
+    possible_values = {"true": True, "false": False, "1": True, "0": False}
+    try:
+        return possible_values[x.lower()]
+    except KeyError:
+        possible = ", ".join(possible_values)
+        raise ValueError(
+            f"{x} is not a valid value for {name}. It must be one of {possible}."
+        )
+
+
+@pytest.hookimpl()
+def pytest_load_initial_conftests(
+    early_config,
+    parser,
+    args: list[str],
+) -> None:
+    # Register the marks
+    early_config.addinivalue_line(
+        "markers",
+        "plain_db(transaction=False, reset_sequences=False, databases=None, "
+        "serialized_rollback=False): "
+        "Mark the test as using the Plain test database.  "
+        "The *transaction* argument allows you to use real transactions "
+        "in the test like Plain's TransactionTestCase.  "
+        "The *reset_sequences* argument resets database sequences before "
+        "the test.  "
+        "The *databases* argument sets which database aliases the test "
+        "uses (by default, only 'default'). Use '__all__' for all databases.  "
+        "The *serialized_rollback* argument enables rollback emulation for "
+        "the test.",
+    )
+    early_config.addinivalue_line(
+        "markers",
+        "urls(modstr): Use a different URLconf for this test, similar to "
+        "the `urls` attribute of Plain's `TestCase` objects.  *modstr* is "
+        "a string specifying the module of a URL config, e.g. "
+        '"my_app.test_urls".',
+    )
+    early_config.addinivalue_line(
+        "markers",
+        "ignore_template_errors(): ignore errors from invalid template "
+        "variables (if --fail-on-template-vars is used).",
+    )
+
+    options = parser.parse_known_args(args)
+
+    if options.version or options.help:
+        return
+
+    _setup_plain()
+
+
+@pytest.hookimpl(trylast=True)
+def pytest_configure() -> None:
+    # Allow Plain settings to be configured in a user pytest_configure call,
+    # but make sure we call plain.setup()
+    _setup_plain()
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_collection_modifyitems(items: list[pytest.Item]) -> None:
+    def get_order_number(test: pytest.Item) -> int:
+        marker_db = test.get_closest_marker("plain_db")
+        if marker_db:
+            (
+                transaction,
+                reset_sequences,
+                databases,
+                serialized_rollback,
+            ) = validate_plain_db(marker_db)
+            uses_db = True
+            transactional = transaction or reset_sequences
+        else:
+            uses_db = False
+            transactional = False
+        fixtures = getattr(test, "fixturenames", [])
+        transactional = transactional or "transactional_db" in fixtures
+        uses_db = uses_db or "db" in fixtures
+
+        if transactional:
+            return 1
+        elif uses_db:
+            return 0
+        else:
+            return 2
+
+    items.sort(key=get_order_number)
+
+
+@pytest.fixture(autouse=True, scope="session")
+def plain_test_environment(request) -> None:
+    """
+    Ensure that Plain is loaded and has its testing environment setup.
+
+    XXX It is a little dodgy that this is an autouse fixture.  Perhaps
+        an email fixture should be requested in order to be able to
+        use the Plain email machinery just like you need to request a
+        db fixture for access to the Plain database, etc.  But
+        without duplicating a lot more of Plain's test support code
+        we need to follow this model.
+    """
+    _setup_plain()
+    from plain.test.utils import (
+        setup_test_environment,
+        teardown_test_environment,
+    )
+
+    debug_ini = request.config.getini("plain_debug_mode")
+    if debug_ini == "keep":
+        debug = None
+    else:
+        debug = _get_boolean_value(debug_ini, "plain_debug_mode", False)
+
+    setup_test_environment(debug=debug)
+    request.addfinalizer(teardown_test_environment)
+
+
+@pytest.fixture(scope="session")
+def plain_db_blocker() -> "_DatabaseBlocker | None":
+    """Wrapper around Plain's database access.
+
+    This object can be used to re-enable database access.  This fixture is used
+    internally in pytest-plain to build the other fixtures and can be used for
+    special database handling.
+
+    The object is a context manager and provides the methods
+    .unblock()/.block() and .restore() to temporarily enable database access.
+
+    This is an advanced feature that is meant to be used to implement database
+    fixtures.
+    """
+    return _blocking_manager
+
+
+@pytest.fixture(autouse=True)
+def _plain_db_marker(request) -> None:
+    """Implement the plain_db marker, internal to pytest-plain."""
+    marker = request.node.get_closest_marker("plain_db")
+    if marker:
+        request.getfixturevalue("_plain_db_helper")
+
+
+@pytest.fixture(autouse=True)
+def _dj_autoclear_mailbox() -> None:
+    try:
+        from plain import mail
+
+        del mail.outbox[:]
+    except ImportError:
+        pass
+
+
+@pytest.fixture()
+def mailoutbox(
+    plain_mail_patch_dns: None,
+    _dj_autoclear_mailbox: None,
+) -> "list[plain.mail.EmailMessage] | None":
+    try:
+        from plain import mail
+
+        return mail.outbox
+    except ImportError:
+        pass
+
+
+@pytest.fixture()
+def plain_mail_patch_dns(
+    monkeypatch,
+    plain_mail_dnsname: str,
+) -> None:
+    try:
+        from plain import mail
+
+        monkeypatch.setattr(mail.message, "DNS_NAME", plain_mail_dnsname)
+    except ImportError:
+        pass
+
+
+@pytest.fixture()
+def plain_mail_dnsname() -> str:
+    return "fake-tests.example.com"
+
+
+# ############### Helper Functions ################
+
+
+class _DatabaseBlockerContextManager:
+    def __init__(self, db_blocker) -> None:
+        self._db_blocker = db_blocker
+
+    def __enter__(self) -> None:
+        pass
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self._db_blocker.restore()
+
+
+class _DatabaseBlocker:
+    """Manager for plain.models.backends.base.base.BaseDatabaseWrapper.
+
+    This is the object returned by plain_db_blocker.
+    """
+
+    def __init__(self):
+        self._history = []
+        self._real_ensure_connection = None
+
+    @property
+    def _dj_db_wrapper(self) -> "plain.models.backends.base.base.BaseDatabaseWrapper":
+        from plain.models.backends.base.base import BaseDatabaseWrapper
+
+        # The first time the _dj_db_wrapper is accessed, we will save a
+        # reference to the real implementation.
+        if self._real_ensure_connection is None:
+            self._real_ensure_connection = BaseDatabaseWrapper.ensure_connection
+
+        return BaseDatabaseWrapper
+
+    def _save_active_wrapper(self) -> None:
+        self._history.append(self._dj_db_wrapper.ensure_connection)
+
+    def _blocking_wrapper(*args, **kwargs) -> "NoReturn":
+        __tracebackhide__ = True
+        __tracebackhide__  # Silence pyflakes
+        raise RuntimeError(
+            "Database access not allowed, "
+            'use the "plain_db" mark, or the '
+            '"db" or "transactional_db" fixtures to enable it.'
+        )
+
+    def unblock(self) -> "ContextManager[None]":
+        """Enable access to the Plain database."""
+        self._save_active_wrapper()
+        self._dj_db_wrapper.ensure_connection = self._real_ensure_connection
+        return _DatabaseBlockerContextManager(self)
+
+    def block(self) -> "ContextManager[None]":
+        """Disable access to the Plain database."""
+        self._save_active_wrapper()
+        self._dj_db_wrapper.ensure_connection = self._blocking_wrapper
+        return _DatabaseBlockerContextManager(self)
+
+    def restore(self) -> None:
+        self._dj_db_wrapper.ensure_connection = self._history.pop()
+
+
+_blocking_manager = _DatabaseBlocker()
+
+
+def validate_urls(marker) -> list[str]:
+    """Validate the urls marker.
+
+    It checks the signature and creates the `urls` attribute on the
+    marker which will have the correct value.
+    """
+
+    def apifun(urls: list[str]) -> list[str]:
+        return urls
+
+    return apifun(*marker.args, **marker.kwargs)

plain_pytest-0.0.0/plain/pytest/testcases.py

@@ -0,0 +1,473 @@
+import logging
+import sys
+import unittest
+from contextlib import contextmanager
+from difflib import get_close_matches
+from unittest.suite import _DebugResult
+
+from plain.exceptions import ImproperlyConfigured
+from plain.internal.legacy.management import call_command
+from plain.internal.legacy.management.color import no_style
+from plain.internal.legacy.management.sql import emit_post_migrate_signal
+from plain.models import DEFAULT_DB_ALIAS, connections, transaction
+from plain.packages import packages
+from plain.test.client import Client
+from plain.test.utils import (
+    modify_settings,
+    override_settings,
+)
+
+logger = logging.getLogger("plain.test")
+
+__all__ = (
+    "TestCase",
+    "TransactionTestCase",
+)
+
+
+class DatabaseOperationForbidden(AssertionError):
+    pass
+
+
+class _DatabaseFailure:
+    def __init__(self, wrapped, message):
+        self.wrapped = wrapped
+        self.message = message
+
+    def __call__(self):
+        raise DatabaseOperationForbidden(self.message)
+
+
+class TransactionTestCase(unittest.TestCase):
+    # The class we'll use for the test client self.client.
+    # Can be overridden in derived classes.
+    client_class = Client
+    _overridden_settings = None
+    _modified_settings = None
+
+    databases = set()
+    _disallowed_database_msg = (
+        "Database %(operation)s to %(alias)r are not allowed in SimpleTestCase "
+        "subclasses. Either subclass TestCase or TransactionTestCase to ensure "
+        "proper test isolation or add %(alias)r to %(test)s.databases to silence "
+        "this failure."
+    )
+    _disallowed_connection_methods = [
+        ("connect", "connections"),
+        ("temporary_connection", "connections"),
+        ("cursor", "queries"),
+        ("chunked_cursor", "queries"),
+    ]
+
+    # Subclasses can ask for resetting of auto increment sequence before each
+    # test case
+    reset_sequences = False
+
+    # Subclasses can enable only a subset of packages for faster tests
+    available_packages = None
+
+    # Subclasses can define fixtures which will be automatically installed.
+    fixtures = None
+
+    databases = {DEFAULT_DB_ALIAS}
+    _disallowed_database_msg = (
+        "Database %(operation)s to %(alias)r are not allowed in this test. "
+        "Add %(alias)r to %(test)s.databases to ensure proper test isolation "
+        "and silence this failure."
+    )
+
+    # If transactions aren't available, Plain will serialize the database
+    # contents into a fixture during setup and flush and reload them
+    # during teardown (as flush does not restore data from migrations).
+    # This can be slow; this flag allows enabling on a per-case basis.
+    serialized_rollback = False
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        if cls._overridden_settings:
+            cls._cls_overridden_context = override_settings(**cls._overridden_settings)
+            cls._cls_overridden_context.enable()
+            cls.addClassCleanup(cls._cls_overridden_context.disable)
+        if cls._modified_settings:
+            cls._cls_modified_context = modify_settings(cls._modified_settings)
+            cls._cls_modified_context.enable()
+            cls.addClassCleanup(cls._cls_modified_context.disable)
+        cls._add_databases_failures()
+        cls.addClassCleanup(cls._remove_databases_failures)
+
+    @classmethod
+    def _validate_databases(cls):
+        if cls.databases == "__all__":
+            return frozenset(connections)
+        for alias in cls.databases:
+            if alias not in connections:
+                message = (
+                    "{}.{}.databases refers to {!r} which is not defined in "
+                    "settings.DATABASES.".format(
+                        cls.__module__,
+                        cls.__qualname__,
+                        alias,
+                    )
+                )
+                close_matches = get_close_matches(alias, list(connections))
+                if close_matches:
+                    message += " Did you mean %r?" % close_matches[0]
+                raise ImproperlyConfigured(message)
+        return frozenset(cls.databases)
+
+    @classmethod
+    def _add_databases_failures(cls):
+        cls.databases = cls._validate_databases()
+        for alias in connections:
+            if alias in cls.databases:
+                continue
+            connection = connections[alias]
+            for name, operation in cls._disallowed_connection_methods:
+                message = cls._disallowed_database_msg % {
+                    "test": f"{cls.__module__}.{cls.__qualname__}",
+                    "alias": alias,
+                    "operation": operation,
+                }
+                method = getattr(connection, name)
+                setattr(connection, name, _DatabaseFailure(method, message))
+
+    @classmethod
+    def _remove_databases_failures(cls):
+        for alias in connections:
+            if alias in cls.databases:
+                continue
+            connection = connections[alias]
+            for name, _ in cls._disallowed_connection_methods:
+                method = getattr(connection, name)
+                setattr(connection, name, method.wrapped)
+
+    def __call__(self, result=None):
+        """
+        Wrapper around default __call__ method to perform common Plain test
+        set up. This means that user-defined Test Cases aren't required to
+        include a call to super().setUp().
+        """
+        self._setup_and_call(result)
+
+    def debug(self):
+        """Perform the same as __call__(), without catching the exception."""
+        debug_result = _DebugResult()
+        self._setup_and_call(debug_result, debug=True)
+
+    def _setup_and_call(self, result, debug=False):
+        """
+        Perform the following in order: pre-setup, run test, post-teardown,
+        skipping pre/post hooks if test is set to be skipped.
+
+        If debug=True, reraise any errors in setup and use super().debug()
+        instead of __call__() to run the test.
+        """
+        testMethod = getattr(self, self._testMethodName)
+        skipped = getattr(self.__class__, "__unittest_skip__", False) or getattr(
+            testMethod, "__unittest_skip__", False
+        )
+
+        if not skipped:
+            try:
+                self._pre_setup()
+            except Exception:
+                if debug:
+                    raise
+                result.addError(self, sys.exc_info())
+                return
+        if debug:
+            super().debug()
+        else:
+            super().__call__(result)
+        if not skipped:
+            try:
+                self._post_teardown()
+            except Exception:
+                if debug:
+                    raise
+                result.addError(self, sys.exc_info())
+                return
+
+    def _pre_setup(self):
+        """
+        Perform pre-test setup:
+        * Create a test client.
+        * Clear the mail test outbox.
+        """
+        self.client = self.client_class()
+
+        try:
+            from plain import mail
+
+            mail.outbox = []
+        except ImportError:
+            pass
+
+        if self.available_packages is not None:
+            packages.set_available_packages(self.available_packages)
+            for db_name in self._databases_names(include_mirrors=False):
+                emit_post_migrate_signal(verbosity=0, interactive=False, db=db_name)
+        try:
+            self._fixture_setup()
+        except Exception:
+            if self.available_packages is not None:
+                packages.unset_available_packages()
+            raise
+        # Clear the queries_log so that it's less likely to overflow (a single
+        # test probably won't execute 9K queries). If queries_log overflows,
+        # then assertNumQueries() doesn't work.
+        for db_name in self._databases_names(include_mirrors=False):
+            connections[db_name].queries_log.clear()
+
+    def _post_teardown(self):
+        """
+        Perform post-test things:
+        * Flush the contents of the database to leave a clean slate. If the
+          class has an 'available_packages' attribute, don't fire post_migrate.
+        * Force-close the connection so the next test gets a clean cursor.
+        """
+        try:
+            self._fixture_teardown()
+            if self._should_reload_connections():
+                # Some DB cursors include SQL statements as part of cursor
+                # creation. If you have a test that does a rollback, the effect
+                # of these statements is lost, which can affect the operation of
+                # tests (e.g., losing a timezone setting causing objects to be
+                # created with the wrong time). To make sure this doesn't
+                # happen, get a clean connection at the start of every test.
+                for conn in connections.all(initialized_only=True):
+                    conn.close()
+        finally:
+            if self.available_packages is not None:
+                packages.unset_available_packages()
+
+    def settings(self, **kwargs):
+        """
+        A context manager that temporarily sets a setting and reverts to the
+        original value when exiting the context.
+        """
+        return override_settings(**kwargs)
+
+    def modify_settings(self, **kwargs):
+        """
+        A context manager that temporarily applies changes a list setting and
+        reverts back to the original value when exiting the context.
+        """
+        return modify_settings(**kwargs)
+
+    @classmethod
+    def _databases_names(cls, include_mirrors=True):
+        # Only consider allowed database aliases, including mirrors or not.
+        return [
+            alias
+            for alias in connections
+            if alias in cls.databases
+            and (
+                include_mirrors
+                or not connections[alias].settings_dict["TEST"]["MIRROR"]
+            )
+        ]
+
+    def _reset_sequences(self, db_name):
+        conn = connections[db_name]
+        if conn.features.supports_sequence_reset:
+            sql_list = conn.ops.sequence_reset_by_name_sql(
+                no_style(), conn.introspection.sequence_list()
+            )
+            if sql_list:
+                with transaction.atomic(using=db_name):
+                    with conn.cursor() as cursor:
+                        for sql in sql_list:
+                            cursor.execute(sql)
+
+    def _fixture_setup(self):
+        for db_name in self._databases_names(include_mirrors=False):
+            # Reset sequences
+            if self.reset_sequences:
+                self._reset_sequences(db_name)
+
+            # Provide replica initial data from migrated packages, if needed.
+            # if self.serialized_rollback and hasattr(
+            #     connections[db_name], "_test_serialized_contents"
+            # ):
+            #     if self.available_packages is not None:
+            #         packages.unset_available_packages()
+            #     connections[db_name].creation.deserialize_db_from_string(
+            #         connections[db_name]._test_serialized_contents
+            #     )
+            #     if self.available_packages is not None:
+            #         packages.set_available_packages(self.available_packages)
+
+            if self.fixtures:
+                # We have to use this slightly awkward syntax due to the fact
+                # that we're using *args and **kwargs together.
+                call_command(
+                    "loaddata", *self.fixtures, **{"verbosity": 0, "database": db_name}
+                )
+
+    def _should_reload_connections(self):
+        return True
+
+    def _fixture_teardown(self):
+        # Allow TRUNCATE ... CASCADE and don't emit the post_migrate signal
+        # when flushing only a subset of the packages
+        for db_name in self._databases_names(include_mirrors=False):
+            # Flush the database
+            inhibit_post_migrate = (
+                self.available_packages is not None
+                or (  # Inhibit the post_migrate signal when using serialized
+                    # rollback to avoid trying to recreate the serialized data.
+                    self.serialized_rollback
+                    # and hasattr(connections[db_name], "_test_serialized_contents")
+                )
+            )
+            call_command(
+                "flush",
+                verbosity=0,
+                interactive=False,
+                database=db_name,
+                reset_sequences=False,
+                allow_cascade=self.available_packages is not None,
+                inhibit_post_migrate=inhibit_post_migrate,
+            )
+
+
+def connections_support_transactions(aliases=None):
+    """
+    Return whether or not all (or specified) connections support
+    transactions.
+    """
+    conns = (
+        connections.all()
+        if aliases is None
+        else (connections[alias] for alias in aliases)
+    )
+    return all(conn.features.supports_transactions for conn in conns)
+
+
+class TestCase(TransactionTestCase):
+    """
+    Similar to TransactionTestCase, but use `transaction.atomic()` to achieve
+    test isolation.
+
+    In most situations, TestCase should be preferred to TransactionTestCase as
+    it allows faster execution. However, there are some situations where using
+    TransactionTestCase might be necessary (e.g. testing some transactional
+    behavior).
+
+    On database backends with no transaction support, TestCase behaves as
+    TransactionTestCase.
+    """
+
+    @classmethod
+    def _enter_atomics(cls):
+        """Open atomic blocks for multiple databases."""
+        atomics = {}
+        for db_name in cls._databases_names():
+            atomic = transaction.atomic(using=db_name)
+            atomic._from_testcase = True
+            atomic.__enter__()
+            atomics[db_name] = atomic
+        return atomics
+
+    @classmethod
+    def _rollback_atomics(cls, atomics):
+        """Rollback atomic blocks opened by the previous method."""
+        for db_name in reversed(cls._databases_names()):
+            transaction.set_rollback(True, using=db_name)
+            atomics[db_name].__exit__(None, None, None)
+
+    @classmethod
+    def _databases_support_transactions(cls):
+        return connections_support_transactions(cls.databases)
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        if not cls._databases_support_transactions():
+            return
+        cls.cls_atomics = cls._enter_atomics()
+
+        if cls.fixtures:
+            for db_name in cls._databases_names(include_mirrors=False):
+                try:
+                    call_command(
+                        "loaddata",
+                        *cls.fixtures,
+                        **{"verbosity": 0, "database": db_name},
+                    )
+                except Exception:
+                    cls._rollback_atomics(cls.cls_atomics)
+                    raise
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls._databases_support_transactions():
+            cls._rollback_atomics(cls.cls_atomics)
+            for conn in connections.all(initialized_only=True):
+                conn.close()
+        super().tearDownClass()
+
+    def _should_reload_connections(self):
+        if self._databases_support_transactions():
+            return False
+        return super()._should_reload_connections()
+
+    def _fixture_setup(self):
+        if not self._databases_support_transactions():
+            return super()._fixture_setup()
+
+        if self.reset_sequences:
+            raise TypeError("reset_sequences cannot be used on TestCase instances")
+        self.atomics = self._enter_atomics()
+
+    def _fixture_teardown(self):
+        if not self._databases_support_transactions():
+            return super()._fixture_teardown()
+        try:
+            for db_name in reversed(self._databases_names()):
+                if self._should_check_constraints(connections[db_name]):
+                    connections[db_name].check_constraints()
+        finally:
+            self._rollback_atomics(self.atomics)
+
+    def _should_check_constraints(self, connection):
+        return (
+            connection.features.can_defer_constraint_checks
+            and not connection.needs_rollback
+            and connection.is_usable()
+        )
+
+    @classmethod
+    @contextmanager
+    def captureOnCommitCallbacks(cls, *, using=DEFAULT_DB_ALIAS, execute=False):
+        """Context manager to capture transaction.on_commit() callbacks."""
+        callbacks = []
+        start_count = len(connections[using].run_on_commit)
+        try:
+            yield callbacks
+        finally:
+            while True:
+                callback_count = len(connections[using].run_on_commit)
+                for _, callback, robust in connections[using].run_on_commit[
+                    start_count:
+                ]:
+                    callbacks.append(callback)
+                    if execute:
+                        if robust:
+                            try:
+                                callback()
+                            except Exception as e:
+                                logger.error(
+                                    f"Error calling {callback.__qualname__} in "
+                                    f"on_commit() (%s).",
+                                    e,
+                                    exc_info=True,
+                                )
+                        else:
+                            callback()
+
+                if callback_count == len(connections[using].run_on_commit):
+                    break
+                start_count = callback_count

plain_pytest-0.0.0/pyproject.toml

@@ -0,0 +1,44 @@
+[tool.poetry]
+
+name = "plain.pytest"
+packages = [
+    { include = "plain" },
+]
+
+version = "0.0.0"
+description = "Testing for Plain"
+authors = ["Dave Gaeddert <dave.gaeddert@dropseed.dev>"]
+license = "MIT"
+readme = "README.md"
+homepage = "https://www.plainpackages.com/"
+documentation = "https://www.plainpackages.com/docs/"
+repository = "https://github.com/plainpackages/plain-pytest"
+keywords = ["django", "saas", "plain", "framework"]
+classifiers = [
+    "Environment :: Web Environment",
+    "Framework :: Django",
+    "Framework :: Django :: 4",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+]
+
+# Make the CLI available without adding to INSTALLED_APPS
+[tool.poetry.plugins."plain.cli"]
+"test" = "plain.pytest:cli"
+
+# Automatically sets this up with pytest
+[tool.poetry.plugins."pytest11"]
+"plain" = "plain.pytest.pytest.plugin"
+
+
+[tool.poetry.dependencies]
+python = "^3.8"
+click = ">=8.0.0"
+pytest = "^7.0.0"
+
+[tool.poetry.dev-dependencies]
+ipdb = "^0.13.9"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"