pip install plain

import pytest
from plain.runtime import settings, setup
from plain.test.client import Client, RequestFactory


def pytest_configure(config):
    # Run Plain setup before anything else
    setup()


@pytest.fixture(autouse=True, scope="session")
def _allowed_hosts_testserver():
    # Add testserver to ALLOWED_HOSTS so the test client can make requests
    settings.ALLOWED_HOSTS = [*settings.ALLOWED_HOSTS, "testserver"]


@pytest.fixture()
def client() -> Client:
    """A Plain test client instance."""
    return Client()


@pytest.fixture()
def request_factory() -> RequestFactory:
    """A Plain RequestFactory instance."""
    return RequestFactory()

import pytest

from plain.signals import request_finished, request_started

from .. import transaction
from ..backends.base.base import BaseDatabaseWrapper
from ..db import close_old_connections, connections
from .utils import (
    setup_databases,
    teardown_databases,
)


@pytest.fixture(autouse=True)
def _db_disabled():
    """
    Every test should use this fixture by default to prevent
    access to the normal database.
    """

    def cursor_disabled(self):
        pytest.fail("Database access not allowed without the `db` fixture")

    BaseDatabaseWrapper._old_cursor = BaseDatabaseWrapper.cursor
    BaseDatabaseWrapper.cursor = cursor_disabled

    yield

    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._old_cursor


@pytest.fixture(scope="session")
def setup_db(request):
    """
    This fixture is called automatically by `db`,
    so a test database will only be setup if the `db` fixture is used.
    """
    verbosity = request.config.option.verbose

    # Set up the test db across the entire session
    _old_db_config = setup_databases(verbosity=verbosity)

    # Keep connections open during request client / testing
    request_started.disconnect(close_old_connections)
    request_finished.disconnect(close_old_connections)

    yield _old_db_config

    # Put the signals back...
    request_started.connect(close_old_connections)
    request_finished.connect(close_old_connections)

    # When the test session is done, tear down the test db
    teardown_databases(_old_db_config, verbosity=verbosity)


@pytest.fixture()
def db(setup_db):
    # Set .cursor() back to the original implementation
    BaseDatabaseWrapper.cursor = BaseDatabaseWrapper._old_cursor

    # Keep track of the atomic blocks so we can roll them back
    atomics = {}

    for connection in connections.all():
        # By default we use transactions to rollback changes,
        # so we need to ensure the database supports transactions
        if not connection.features.supports_transactions:
            pytest.fail("Database does not support transactions")

        # Clear the queries log before each test?
        # connection.queries_log.clear()

        atomic = transaction.atomic(using=connection.alias)
        atomic._from_testcase = True  # TODO remove this somehow?
        atomic.__enter__()
        atomics[connection] = atomic

    yield setup_db

    for connection, atomic in atomics.items():
        if (
            connection.features.can_defer_constraint_checks
            and not connection.needs_rollback
            and connection.is_usable()
        ):
            connection.check_constraints()

        transaction.set_rollback(True, using=connection.alias)
        atomic.__exit__(None, None, None)

        connection.close()

def test_a_thing(db):
    # This test has a database connection
    pass

name: release
on:
  workflow_dispatch: {}
  push:
    branches:
      - main

jobs:
  release:
    if: ${{ startsWith(github.event.head_commit.message, 'Release') || github.event_name == 'workflow_dispatch' }}
    runs-on: ubuntu-latest
    permissions:
      id-token: write
    steps:
    - uses: actions/checkout@v3

    - run: pipx install poetry

    - uses: actions/setup-python@v4
      with:
        python-version: "3.12"
        cache: poetry

    # https://docs.pypi.org/trusted-publishers/using-a-publisher/
    - name: Mint API token
      id: mint-token
      run: |
        # retrieve the ambient OIDC token
        resp=$(curl -H "Authorization: bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
          "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=pypi")
        oidc_token=$(jq -r '.value' <<< "${resp}")

        # exchange the OIDC token for an API token
        resp=$(curl -X POST https://pypi.org/_/oidc/mint-token -d "{\"token\": \"${oidc_token}\"}")
        api_token=$(jq -r '.token' <<< "${resp}")

        # mask the newly minted API token, so that we don't accidentally leak it
        echo "::add-mask::${api_token}"

        # see the next step in the workflow for an example of using this step output
        echo "api-token=${api_token}" >> "${GITHUB_OUTPUT}"

    - name: Publish packages
      run: |
        for package_dir in plain*; do
            cd $package_dir
            rm -rf dist
            poetry build
            poetry publish --no-interaction --skip-existing
            cd ..
        done
      env:
        POETRY_PYPI_TOKEN_PYPI: ${{ steps.mint-token.outputs.api-token }}