diff -pruN 1.1.1+ds-1/.github/dependabot.yml 1.2.0+ds-1/.github/dependabot.yml --- 1.1.1+ds-1/.github/dependabot.yml 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/.github/dependabot.yml 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,13 @@ +# Keep GitHub Actions up to date with GitHub's Dependabot... +# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot +# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem +version: 2 +updates: + - package-ecosystem: github-actions + directory: / + groups: + github-actions: + patterns: + - "*" # Group all Actions updates into a single larger pull request + schedule: + interval: weekly diff -pruN 1.1.1+ds-1/.github/workflows/build-package.yml 1.2.0+ds-1/.github/workflows/build-package.yml --- 1.1.1+ds-1/.github/workflows/build-package.yml 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/.github/workflows/build-package.yml 1970-01-01 00:00:00.000000000 +0000 @@ -1,42 +0,0 @@ -# This workflow will install Python dependencies, run tests and lint with a variety of Python versions -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python - -name: Build package - -on: - [push] - -jobs: - build: - - runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - python-version: ["3.7", "3.8", "3.9", "3.10"] - - steps: - - uses: actions/checkout@v3 - - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 - with: - python-version: ${{ matrix.python-version }} - - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install flake8 pytest - if [ -f requirements.txt ]; then pip install -r requirements.txt; fi - pip install . - - - name: Lint with flake8 - run: | - # stop the build if there are Python syntax errors or undefined names - flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics - # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - - - name: Test with pytest - run: | - pytest diff -pruN 1.1.1+ds-1/.github/workflows/deploy.yml 1.2.0+ds-1/.github/workflows/deploy.yml --- 1.1.1+ds-1/.github/workflows/deploy.yml 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/.github/workflows/deploy.yml 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,65 @@ +name: deploy + +on: + workflow_dispatch: + inputs: + version: + description: 'Release version' + required: true + default: '1.2.3' + +jobs: + + package: + runs-on: ubuntu-latest + # Required by attest-build-provenance-github. + permissions: + id-token: write + attestations: write + env: + SETUPTOOLS_SCM_PRETEND_VERSION: ${{ github.event.inputs.version }} + + steps: + - uses: actions/checkout@v4 + + - name: Build and Check Package + uses: hynek/build-and-inspect-python-package@v2.13.0 + with: + attest-build-provenance-github: 'true' + + + deploy: + needs: package + runs-on: ubuntu-latest + environment: deploy + permissions: + id-token: write # For PyPI trusted publishers. + contents: write # For tag and release notes. + + steps: + - uses: actions/checkout@v4 + + - name: Download Package + uses: actions/download-artifact@v4 + with: + name: Packages + path: dist + + - name: Publish package to PyPI + uses: pypa/gh-action-pypi-publish@v1.12.4 + with: + attestations: true + + - name: Push tag + run: | + git config user.name "pytest bot" + git config user.email "pytestbot@gmail.com" + git tag --annotate --message=v${{ github.event.inputs.version }} v${{ github.event.inputs.version }} ${{ github.sha }} + git push origin v${{ github.event.inputs.version }} + + - name: GitHub Release + uses: softprops/action-gh-release@v2 + with: + body_path: scripts/latest-release-notes.md + files: dist/* + tag_name: v${{ github.event.inputs.version }} diff -pruN 1.1.1+ds-1/.github/workflows/publish-package.yml 1.2.0+ds-1/.github/workflows/publish-package.yml --- 1.1.1+ds-1/.github/workflows/publish-package.yml 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/.github/workflows/publish-package.yml 1970-01-01 00:00:00.000000000 +0000 @@ -1,35 +0,0 @@ -# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python - -name: Publish package - -on: - release: - types: [published] - -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - - uses: actions/checkout@v3 - - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 - with: - python-version: '3.x' - - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install build - - - name: Build package - run: python -m build - - - name: Publish a Python distribution to PyPI - uses: pypa/gh-action-pypi-publish@release/v1 - with: - user: __token__ - password: ${{ secrets.PYPI_API_TOKEN }} diff -pruN 1.1.1+ds-1/.github/workflows/test.yml 1.2.0+ds-1/.github/workflows/test.yml --- 1.1.1+ds-1/.github/workflows/test.yml 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/.github/workflows/test.yml 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,62 @@ +name: test + +on: + push: + branches: + - main + - "test-me-*" + + pull_request: + + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + + package: + runs-on: ubuntu-latest + permissions: + id-token: write + attestations: write + steps: + - uses: actions/checkout@v4 + - name: Build and Check Package + uses: hynek/build-and-inspect-python-package@v2.13.0 + + test: + + needs: [package] + + runs-on: ${{ matrix.os }} + + strategy: + fail-fast: false + matrix: + python: ["3.9", "3.10", "3.11", "3.12", "3.13"] + os: [ubuntu-latest, windows-latest] + + steps: + - uses: actions/checkout@v4 + + - name: Download Package + uses: actions/download-artifact@v4 + with: + name: Packages + path: dist + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python }} + + - name: Install tox + run: | + python -m pip install --upgrade pip + pip install tox + + - name: Test + shell: bash + run: | + tox run -e py --installpkg `find dist/*.tar.gz` diff -pruN 1.1.1+ds-1/.pre-commit-config.yaml 1.2.0+ds-1/.pre-commit-config.yaml --- 1.1.1+ds-1/.pre-commit-config.yaml 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/.pre-commit-config.yaml 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,15 @@ +repos: + - repo: local + hooks: + - id: rst + name: rst + entry: rst-lint --encoding utf-8 + files: ^(CHANGELOG.rst|README.rst|HOWTORELEASE.rst)$ + language: python + additional_dependencies: [pygments, restructuredtext_lint] + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.3.3 + hooks: + - id: ruff + args: ["--fix"] + - id: ruff-format diff -pruN 1.1.1+ds-1/CHANGELOG.rst 1.2.0+ds-1/CHANGELOG.rst --- 1.1.1+ds-1/CHANGELOG.rst 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/CHANGELOG.rst 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,71 @@ + +-------------- +Changelog +-------------- + +1.2.0 ++++++ + +*2025-06-22* + +* Dropped support for EOL Python versions and added support for Python 3.13. +* Fix `#58 `_: ``return`` in a ``finally`` block swallows exceptions and raises a warning in Python 3.14. + +1.1.1 ++++++ + +*2024-01-20* + +* Fixes #54 - ``AttributeError`` when cacheprovider plugin disabled. Thanks @jhanm12 + + +1.1.0 ++++++ + +*2022-12-03* + +* Fixes xdist support (thanks @matejsp) + + +1.0.4 ++++++ + +*2018-11-30* + +* Fixes issues with doctests reported in #36 - ``class``, ``package`` and ``module`` didn't work + because ``DoctestItem`` doesn't have ``cls`` or ``module`` attributes. Thanks @tobywf. +* Deprecate ``none`` bucket type. **Update**: this was a mistake, it will be kept for backwards compatibility. +* With tox, run tests of pytest-random-order with both pytest 3 and 4. + +1.0.3 ++++++ + +*2018-11-16* + +* Fixes compatibility issues with pytest 4.0.0, works with pytest 3.0+ as before. +* Tests included in the source distribution. + +1.0.0 ++++++ + +*2018-10-20* + +* Plugin no longer alters the test order by default. You will have to either 1) pass ``--random-order``, + or ``--random-order-bucket=``, or ``--random-order-seed=``, or + 2) edit your pytest configuration file and add one of these options + there under ``addopts``, or 3) specify these flags in environment variable ``PYTEST_ADDOPTS``. +* Python 3.5+ is required. If you want to use this plugin with Python 2.7, use v0.8.0 which is stable and fine + if you are happy with it randomising the test order by default. +* The name under which the plugin registers itself is changed from ``random-order`` (hyphen) to ``random_order`` + (underscore). This addresses the issue of consistency when disabling or enabling this plugin via the standard + ``-p`` flag. Previously, the plugin could be disabled by passing ``-p no:random-order`` yet re-enabled + only by passing ``-p pytest_random_order.plugin``. Now they are ``-p no:random_order`` + to disable and ``-p random_order.plugin`` to enable (The ``.plugin`` bit, I think, is required because + pytest probably thinks it's an unrelated thing to ``random_order`` and import it, yet without it it's the + same thing so doesn't import it). + + +0.8.0 ++++++ + +* pytest cache plugin's ``--failed-first`` works now. diff -pruN 1.1.1+ds-1/MANIFEST.in 1.2.0+ds-1/MANIFEST.in --- 1.1.1+ds-1/MANIFEST.in 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/MANIFEST.in 1970-01-01 00:00:00.000000000 +0000 @@ -1,6 +0,0 @@ -include LICENSE -include README.rst -graft tests - -recursive-exclude * __pycache__ -recursive-exclude * *.py[co] diff -pruN 1.1.1+ds-1/README.rst 1.2.0+ds-1/README.rst --- 1.1.1+ds-1/README.rst 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/README.rst 2025-06-22 14:40:12.000000000 +0000 @@ -120,9 +120,10 @@ grandparent global All tests fall in the same bucket, full randomness, tests probably take longer to run. -none (deprecated) - Disable shuffling. *Deprecated since 1.0.4 because this plugin no longer shuffles tests by default - so there is nothing to disable.* +none + Disable shuffling. This plugin no longer shuffles tests by default + so there is nothing to disable, however, there are scenarios where this is useful + due to the way test configs are specified, see #40. If you have three buckets of tests ``A``, ``B``, and ``C`` with three tests ``1`` and ``2``, and ``3`` in each of them, @@ -227,58 +228,6 @@ pass undeservedly, you can disable it: Note that randomisation is disabled by default. By passing ``-p no:random_order`` you are stopping the plugin from being registered so its hooks won't be registered and its command line options won't appear in ``--help``. --------------- -Changelog --------------- - -v1.1.1 (2024-01-20) -+++++++++++++++++++ - - * Fixes #54 - ``AttributeError`` when cacheprovider plugin disabled. Thanks @jhanm12 - - -v1.1.0 (2022-12-03) -+++++++++++++++++++ - - * Fixes xdist support (thanks @matejsp) - - -v1.0.4 (2018-11-30) -+++++++++++++++++++ - -* Fixes issues with doctests reported in #36 - ``class``, ``package`` and ``module`` didn't work - because ``DoctestItem`` doesn't have ``cls`` or ``module`` attributes. Thanks @tobywf. -* Deprecate ``none`` bucket type. -* With tox, run tests of pytest-random-order with both pytest 3 and 4. - -v1.0.3 (2018-11-16) -+++++++++++++++++++ - -* Fixes compatibility issues with pytest 4.0.0, works with pytest 3.0+ as before. -* Tests included in the source distribution. - -v1.0.0 (2018-10-20) -+++++++++++++++++++ - -* Plugin no longer alters the test order by default. You will have to either 1) pass ``--random-order``, - or ``--random-order-bucket=``, or ``--random-order-seed=``, or - 2) edit your pytest configuration file and add one of these options - there under ``addopts``, or 3) specify these flags in environment variable ``PYTEST_ADDOPTS``. -* Python 3.5+ is required. If you want to use this plugin with Python 2.7, use v0.8.0 which is stable and fine - if you are happy with it randomising the test order by default. -* The name under which the plugin registers itself is changed from ``random-order`` (hyphen) to ``random_order`` - (underscore). This addresses the issue of consistency when disabling or enabling this plugin via the standard - ``-p`` flag. Previously, the plugin could be disabled by passing ``-p no:random-order`` yet re-enabled - only by passing ``-p pytest_random_order.plugin``. Now they are ``-p no:random_order`` - to disable and ``-p random_order.plugin`` to enable (The ``.plugin`` bit, I think, is required because - pytest probably thinks it's an unrelated thing to ``random_order`` and import it, yet without it it's the - same thing so doesn't import it). - - -v0.8.0 -++++++ - -* pytest cache plugin's ``--failed-first`` works now. ------- Credits diff -pruN 1.1.1+ds-1/RELEASING.rst 1.2.0+ds-1/RELEASING.rst --- 1.1.1+ds-1/RELEASING.rst 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/RELEASING.rst 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,12 @@ +Here are the steps on how to make a new release. + +1. Create a ``release-VERSION`` branch from ``upstream/main``. +2. Update ``CHANGELOG.rst``. +3. Push the branch to ``upstream``. +4. Once all tests pass, start the ``deploy`` workflow manually or via: + + ``` + gh workflow run deploy.yml --repo pytest-dev/pytest-random-order --ref release-VERSION -f version=VERSION + ``` + +5. Merge the PR. diff -pruN 1.1.1+ds-1/debian/changelog 1.2.0+ds-1/debian/changelog --- 1.1.1+ds-1/debian/changelog 2024-02-06 10:13:42.000000000 +0000 +++ 1.2.0+ds-1/debian/changelog 2025-10-24 08:49:24.000000000 +0000 @@ -1,3 +1,18 @@ +python-pytest-random-order (1.2.0+ds-1) unstable; urgency=medium + + * Team upload. + * New upstream version 1.2.0+ds + * Switch to pybuild-plugin-pyproject + + [ Francesco Ballarin ] + * Add Francesco Ballarin to uploaders + * Fix watchfile to detect new versions on github + + [ Nick Morrott ] + * Remove myself from Uploaders + + -- Alexandre Detiste Fri, 24 Oct 2025 10:49:24 +0200 + python-pytest-random-order (1.1.1+ds-1) unstable; urgency=medium * New upstream version 1.1.1+ds diff -pruN 1.1.1+ds-1/debian/control 1.2.0+ds-1/debian/control --- 1.1.1+ds-1/debian/control 2024-02-06 10:13:42.000000000 +0000 +++ 1.2.0+ds-1/debian/control 2025-10-24 08:49:24.000000000 +0000 @@ -3,20 +3,20 @@ Section: python Priority: optional Maintainer: Debian Python Team Uploaders: - Nick Morrott , + Francesco Ballarin Build-Depends: debhelper-compat (= 13), - dh-python, + dh-sequence-python3, + pybuild-plugin-pyproject, python3-all, python3-py, python3-pytest, python3-pytest-xdist, python3-setuptools, -Standards-Version: 4.6.2 +Standards-Version: 4.7.2 Homepage: https://github.com/jbasko/pytest-random-order Vcs-Browser: https://salsa.debian.org/python-team/packages/python-pytest-random-order Vcs-Git: https://salsa.debian.org/python-team/packages/python-pytest-random-order.git -Rules-Requires-Root: no Package: python3-pytest-random-order Architecture: all diff -pruN 1.1.1+ds-1/debian/rules 1.2.0+ds-1/debian/rules --- 1.1.1+ds-1/debian/rules 2024-02-06 10:13:42.000000000 +0000 +++ 1.2.0+ds-1/debian/rules 2025-10-24 08:49:24.000000000 +0000 @@ -11,12 +11,11 @@ export LC_ALL=C.UTF-8 export PYBUILD_NAME=pytest-random-order %: - dh $@ --with python3 --buildsystem=pybuild + dh $@ --buildsystem=pybuild override_dh_auto_test: -override_dh_auto_install: - dh_auto_install +execute_after_dh_auto_install: # run tests after install: plugin needs to get registered by # setup.py/entry_points (from python-pytest-pylink) PYBUILD_SYSTEM=custom PYBUILD_TEST_ARGS="{interpreter} -m pytest -v -x --ignore debian" dh_auto_test diff -pruN 1.1.1+ds-1/debian/watch 1.2.0+ds-1/debian/watch --- 1.1.1+ds-1/debian/watch 2024-02-06 10:13:42.000000000 +0000 +++ 1.2.0+ds-1/debian/watch 2025-10-24 08:47:47.000000000 +0000 @@ -1,3 +1,3 @@ version=4 opts=dversionmangle=s/@DEB_EXT@//,repacksuffix=+ds,filenamemangle=s%(?:.*?)?v?(\d[\d.]*)\.tar\.gz%@PACKAGE@-$1.tar.gz% \ - https://github.com/jbasko/pytest-random-order/tags .*/archive/refs/tags/v?@ANY_VERSION@@ARCHIVE_EXT@ + https://github.com/jbasko/pytest-random-order/tags .*/refs/tags/v?@ANY_VERSION@@ARCHIVE_EXT@ diff -pruN 1.1.1+ds-1/pyproject.toml 1.2.0+ds-1/pyproject.toml --- 1.1.1+ds-1/pyproject.toml 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/pyproject.toml 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,15 @@ +[build-system] +requires = [ + "setuptools", + "setuptools-scm>=8", +] +build-backend = "setuptools.build_meta" + +[tool.setuptools_scm] + +[tool.pytest.ini_options] +testpaths = ["tests"] +addopts = "-r a" + +[tool.ruff] +line-length = 120 \ No newline at end of file diff -pruN 1.1.1+ds-1/pytest.ini 1.2.0+ds-1/pytest.ini --- 1.1.1+ds-1/pytest.ini 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/pytest.ini 1970-01-01 00:00:00.000000000 +0000 @@ -1,3 +0,0 @@ -[pytest] -filterwarnings = - ignore:.*usage of Session..*:DeprecationWarning diff -pruN 1.1.1+ds-1/random_order/bucket_types.py 1.2.0+ds-1/random_order/bucket_types.py --- 1.1.1+ds-1/random_order/bucket_types.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/random_order/bucket_types.py 2025-06-22 14:40:12.000000000 +0000 @@ -11,7 +11,6 @@ def bucket_type_key(bucket_type): """ def decorator(f): - @functools.wraps(f) def wrapped(item, session): key = f(item) @@ -28,24 +27,24 @@ def bucket_type_key(bucket_type): return decorator -@bucket_type_key('global') +@bucket_type_key("global") def get_global_key(item): return None -@bucket_type_key('package') +@bucket_type_key("package") def get_package_key(item): if not hasattr(item, "module"): return os.path.split(item.location[0])[0] return item.module.__package__ -@bucket_type_key('module') +@bucket_type_key("module") def get_module_key(item): return item.location[0] -@bucket_type_key('class') +@bucket_type_key("class") def get_class_key(item): if not hasattr(item, "cls"): return item.location[0] @@ -55,19 +54,19 @@ def get_class_key(item): return item.module.__name__ -@bucket_type_key('parent') +@bucket_type_key("parent") def get_parent_key(item): return item.parent -@bucket_type_key('grandparent') +@bucket_type_key("grandparent") def get_grandparent_key(item): return item.parent.parent -@bucket_type_key('none') +@bucket_type_key("none") def get_none_key(item): - raise RuntimeError('When shuffling is disabled (bucket_type=none), item key should not be calculated') + raise RuntimeError("When shuffling is disabled (bucket_type=none), item key should not be calculated") bucket_types = bucket_type_keys.keys() diff -pruN 1.1.1+ds-1/random_order/cache.py 1.2.0+ds-1/random_order/cache.py --- 1.1.1+ds-1/random_order/cache.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/random_order/cache.py 2025-06-22 14:40:12.000000000 +0000 @@ -5,24 +5,24 @@ This module is called "cache" because it """ -FAILED_FIRST_LAST_FAILED_BUCKET_KEY = '' +FAILED_FIRST_LAST_FAILED_BUCKET_KEY = "" def process_failed_first_last_failed(session, config, items): - if not hasattr(config, 'cache'): + if not hasattr(config, "cache"): return - if not config.getoption('failedfirst'): + if not config.getoption("failedfirst"): return - last_failed_raw = config.cache.get('cache/lastfailed', None) + last_failed_raw = config.cache.get("cache/lastfailed", None) if not last_failed_raw: return # Get the names of last failed tests last_failed = [] for key in last_failed_raw.keys(): - parts = key.split('::') + parts = key.split("::") if len(parts) == 3: last_failed.append(tuple(parts)) elif len(parts) == 2: diff -pruN 1.1.1+ds-1/random_order/config.py 1.2.0+ds-1/random_order/config.py --- 1.1.1+ds-1/random_order/config.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/random_order/config.py 2025-06-22 14:40:12.000000000 +0000 @@ -1,5 +1,4 @@ class Config: - @classmethod def default_value(cls, value): return "default:" + str(value) @@ -10,25 +9,22 @@ class Config: @property def bucket_type(self): if not self.is_enabled: - return 'none' + return "none" else: - return self._remove_default_prefix(self._config.getoption('random_order_bucket')) + return self._remove_default_prefix(self._config.getoption("random_order_bucket")) @property def is_enabled(self): - return ( - self._config.getoption('random_order_enabled') or - any( - not self._config.getoption(name).startswith('default:') - for name in ('random_order_bucket', 'random_order_seed') - ) + return self._config.getoption("random_order_enabled") or any( + not self._config.getoption(name).startswith("default:") + for name in ("random_order_bucket", "random_order_seed") ) @property def seed(self): - return self._remove_default_prefix(self._config.getoption('random_order_seed')) + return self._remove_default_prefix(self._config.getoption("random_order_seed")) def _remove_default_prefix(self, value): - if value.startswith('default:'): - return value[len('default:'):] + if value.startswith("default:"): + return value[len("default:") :] return value diff -pruN 1.1.1+ds-1/random_order/plugin.py 1.2.0+ds-1/random_order/plugin.py --- 1.1.1+ds-1/random_order/plugin.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/random_order/plugin.py 2025-06-22 14:40:12.000000000 +0000 @@ -13,45 +13,44 @@ from random_order.xdist import XdistHook def pytest_addoption(parser): - group = parser.getgroup('pytest-random-order options') + group = parser.getgroup("pytest-random-order options") group.addoption( - '--random-order', - action='store_true', - dest='random_order_enabled', - help='Randomise test order (by default, it is disabled) with default configuration.', + "--random-order", + action="store_true", + dest="random_order_enabled", + help="Randomise test order (by default, it is disabled) with default configuration.", ) group.addoption( - '--random-order-bucket', - action='store', - dest='random_order_bucket', - default=Config.default_value('module'), + "--random-order-bucket", + action="store", + dest="random_order_bucket", + default=Config.default_value("module"), choices=bucket_types, - help='Randomise test order within specified test buckets.', + help="Randomise test order within specified test buckets.", ) group.addoption( - '--random-order-seed', - action='store', - dest='random_order_seed', + "--random-order-seed", + action="store", + dest="random_order_seed", default=Config.default_value(str(random.randint(1, 1000000))), - help='Randomise test order using a specific seed.', + help="Randomise test order using a specific seed.", ) def pytest_configure(config): config.addinivalue_line( - 'markers', - 'random_order(disabled=True): disable reordering of tests within a module or class' + "markers", "random_order(disabled=True): disable reordering of tests within a module or class" ) - if config.pluginmanager.hasplugin('xdist'): + if config.pluginmanager.hasplugin("xdist"): config.pluginmanager.register(XdistHooks()) - if hasattr(config, 'workerinput'): + if hasattr(config, "workerinput"): # pytest-xdist: use seed generated on main. - seed = config.workerinput['random_order_seed'] - if hasattr(config, 'cache'): + seed = config.workerinput["random_order_seed"] + if hasattr(config, "cache"): assert config.cache is not None - config.cache.set('random_order_seed', seed) + config.cache.set("random_order_seed", seed) config.option.random_order_seed = seed @@ -59,10 +58,9 @@ def pytest_report_header(config): plugin = Config(config) if not plugin.is_enabled: return "Test order randomisation NOT enabled. Enable with --random-order or --random-order-bucket=" - return ( - 'Using --random-order-bucket={plugin.bucket_type}\n' - 'Using --random-order-seed={plugin.seed}\n' - ).format(plugin=plugin) + return ("Using --random-order-bucket={plugin.bucket_type}\n" "Using --random-order-seed={plugin.seed}\n").format( + plugin=plugin + ) def pytest_collection_modifyitems(session, config, items): @@ -78,7 +76,7 @@ def pytest_collection_modifyitems(sessio try: seed = plugin.seed bucket_type = plugin.bucket_type - if bucket_type != 'none': + if bucket_type != "none": _shuffle_items( items, bucket_key=bucket_type_keys[bucket_type], @@ -90,8 +88,8 @@ def pytest_collection_modifyitems(sessio except Exception as e: # See the finally block -- we only fail if we have lost user's tests. _, _, exc_tb = sys.exc_info() - failure = 'pytest-random-order plugin has failed with {0!r}:\n{1}'.format( - e, ''.join(traceback.format_tb(exc_tb, 10)) + failure = "pytest-random-order plugin has failed with {0!r}:\n{1}".format( + e, "".join(traceback.format_tb(exc_tb, 10)) ) if not hasattr(pytest, "PytestWarning"): config.warn(0, failure, None) @@ -102,5 +100,5 @@ def pytest_collection_modifyitems(sessio # Fail only if we have lost user's tests if item_ids != _get_set_of_item_ids(items): if not failure: - failure = 'pytest-random-order plugin has failed miserably' + failure = "pytest-random-order plugin has failed miserably" raise RuntimeError(failure) diff -pruN 1.1.1+ds-1/random_order/shuffler.py 1.2.0+ds-1/random_order/shuffler.py --- 1.1.1+ds-1/random_order/shuffler.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/random_order/shuffler.py 2025-06-22 14:40:12.000000000 +0000 @@ -16,7 +16,7 @@ In some cases it is important for the `d to preserve a distinct disabled sub-bucket within a larger bucket and not mix it up with another disabled sub-bucket of the same larger bucket. """ -ItemKey = namedtuple('ItemKey', field_names=('bucket', 'disabled', 'x')) +ItemKey = namedtuple("ItemKey", field_names=("bucket", "disabled", "x")) ItemKey.__new__.__defaults__ = (None, None) @@ -93,20 +93,16 @@ def _shuffle_items(items, bucket_key=Non def _get_set_of_item_ids(items): - s = {} - try: - s = set(item.nodeid for item in items) - finally: - return s + return set(item.nodeid for item in items) def _disable(item, session): - if hasattr(item, 'get_closest_marker'): - marker = item.get_closest_marker('random_order') + if hasattr(item, "get_closest_marker"): + marker = item.get_closest_marker("random_order") else: - marker = item.get_marker('random_order') + marker = item.get_marker("random_order") if marker: - is_disabled = marker.kwargs.get('disabled', False) + is_disabled = marker.kwargs.get("disabled", False) if is_disabled: # A test item can only be disabled in its parent context -- where it is part of some order. # We use parent name as the key so that all children of the same parent get the same disabled key. diff -pruN 1.1.1+ds-1/random_order/xdist.py 1.2.0+ds-1/random_order/xdist.py --- 1.1.1+ds-1/random_order/xdist.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/random_order/xdist.py 2025-06-22 14:40:12.000000000 +0000 @@ -2,7 +2,6 @@ import pytest class XdistHooks: - def pytest_configure_node(self, node: pytest.Item) -> None: - seed = node.config.getoption('random_order_seed') - node.workerinput['random_order_seed'] = seed + seed = node.config.getoption("random_order_seed") + node.workerinput["random_order_seed"] = seed diff -pruN 1.1.1+ds-1/requirements.txt 1.2.0+ds-1/requirements.txt --- 1.1.1+ds-1/requirements.txt 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/requirements.txt 1970-01-01 00:00:00.000000000 +0000 @@ -1,5 +0,0 @@ -coverage -py -pytest -pytest-xdist -sphinx diff -pruN 1.1.1+ds-1/setup.cfg 1.2.0+ds-1/setup.cfg --- 1.1.1+ds-1/setup.cfg 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/setup.cfg 1970-01-01 00:00:00.000000000 +0000 @@ -1,15 +0,0 @@ -[flake8] -max-line-length = 120 -exclude = - .tox - build - -[isort] -known_first_party = - random_order -line_length = 120 -multi_line_output = 5 -not_skip = __init__.py -skip = - .tox - build diff -pruN 1.1.1+ds-1/setup.py 1.2.0+ds-1/setup.py --- 1.1.1+ds-1/setup.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/setup.py 2025-06-22 14:40:12.000000000 +0000 @@ -9,47 +9,41 @@ from setuptools import setup def read(fname): file_path = os.path.join(os.path.dirname(__file__), fname) - return codecs.open(file_path, encoding='utf-8').read() + return codecs.open(file_path, encoding="utf-8").read() setup( - name='pytest-random-order', - version='1.1.1', - author='Jazeps Basko', - author_email='jazeps.basko@gmail.com', - maintainer='Jazeps Basko', - maintainer_email='jazeps.basko@gmail.com', - license='MIT', - url='https://github.com/jbasko/pytest-random-order', - description='Randomise the order in which pytest tests are run with some control over the randomness', - long_description=read('README.rst'), + name="pytest-random-order", + author="Jazeps Basko", + author_email="jazeps.basko@gmail.com", + maintainer="Jazeps Basko", + maintainer_email="jazeps.basko@gmail.com", + license="MIT", + url="https://github.com/jbasko/pytest-random-order", + description="Randomise the order in which pytest tests are run with some control over the randomness", + long_description=read("README.rst"), + long_description_content_type="text/x-rst", packages=[ - 'random_order', + "random_order", ], include_package_data=True, - python_requires=">=3.5.0", + python_requires=">=3.9", install_requires=[ - 'pytest>=3.0.0', + "pytest", ], classifiers=[ - 'Development Status :: 5 - Production/Stable', - 'Framework :: Pytest', - 'Intended Audience :: Developers', - 'Topic :: Software Development :: Testing', - 'Programming Language :: Python', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.5', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', - 'Programming Language :: Python :: 3.8', - 'Programming Language :: Python :: 3.9', - 'Programming Language :: Python :: 3.10', - 'License :: OSI Approved :: MIT License', + "Development Status :: 5 - Production/Stable", + "Framework :: Pytest", + "Intended Audience :: Developers", + "Topic :: Software Development :: Testing", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", ], - keywords='pytest random test order shuffle', + keywords="pytest random test order shuffle", entry_points={ - 'pytest11': [ - 'random_order = random_order.plugin', # >=1.0.0 + "pytest11": [ + "random_order = random_order.plugin", ], }, ) diff -pruN 1.1.1+ds-1/tests/conftest.py 1.2.0+ds-1/tests/conftest.py --- 1.1.1+ds-1/tests/conftest.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/conftest.py 2025-06-22 14:40:12.000000000 +0000 @@ -2,10 +2,10 @@ import collections import pytest -pytest_plugins = 'pytester' +pytest_plugins = "pytester" -Call = collections.namedtuple('Call', field_names=('package', 'module', 'cls', 'name')) +Call = collections.namedtuple("Call", field_names=("package", "module", "cls", "name")) def _get_test_calls(result): @@ -14,13 +14,15 @@ def _get_test_calls(result): """ calls = [] - for c in result.reprec.getcalls('pytest_runtest_call'): - calls.append(Call( - package=c.item.module.__package__, - module=c.item.module.__name__, - cls=(c.item.module.__name__, c.item.cls.__name__) if c.item.cls else None, - name=c.item.name, - )) + for c in result.reprec.getcalls("pytest_runtest_call"): + calls.append( + Call( + package=c.item.module.__package__, + module=c.item.module.__name__, + cls=(c.item.module.__name__, c.item.cls.__name__) if c.item.cls else None, + name=c.item.name, + ) + ) return tuple(calls) @@ -36,13 +38,13 @@ def get_test_calls(): def twenty_tests(): code = [] for i in range(20): - code.append('def test_a{0}(): assert True\n'.format(str(i).zfill(2))) - return ''.join(code) + code.append("def test_a{0}(): assert True\n".format(str(i).zfill(2))) + return "".join(code) @pytest.fixture def twenty_cls_tests(): code = [] for i in range(20): - code.append('\tdef test_b{0}(self): self.assertTrue\n'.format(str(i).zfill(2))) - return ''.join(code) + code.append("\tdef test_b{0}(self): self.assertTrue\n".format(str(i).zfill(2))) + return "".join(code) diff -pruN 1.1.1+ds-1/tests/test_actual_test_runs.py 1.2.0+ds-1/tests/test_actual_test_runs.py --- 1.1.1+ds-1/tests/test_actual_test_runs.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/test_actual_test_runs.py 2025-06-22 14:40:12.000000000 +0000 @@ -22,50 +22,61 @@ def tmp_tree_of_tests(testdir): If module name doesn't start with "test_", it isn't picked up by runpytest. """ - sup = testdir.mkpydir('shallow_tests') + sup = testdir.mkpydir("shallow_tests") - sup.join('test_a.py').write(py.code.Source(""" + sup.join("test_a.py").write( + py.code.Source(""" def test_a1(): assert False def test_a2(): assert True def test_a3(): assert True - """)) + """) + ) - sup.join('test_ax.py').write(py.code.Source(""" + sup.join("test_ax.py").write( + py.code.Source(""" def test_ax1(): assert True def test_ax2(): assert True def test_ax3(): assert True - """)) + """) + ) - sub = testdir.mkpydir('shallow_tests/deep_tests') + sub = testdir.mkpydir("shallow_tests/deep_tests") - sub.join('test_b.py').write(py.code.Source(""" + sub.join("test_b.py").write( + py.code.Source(""" def test_b1(): assert True def test_b2(): assert False def test_b3(): assert True - """)) + """) + ) - sub.join('test_c.py').write(py.code.Source(""" + sub.join("test_c.py").write( + py.code.Source(""" def test_c1(): assert True - """)) + """) + ) - sub.join('test_d.py').write(py.code.Source(""" + sub.join("test_d.py").write( + py.code.Source(""" def test_d1(): assert True def test_d2(): assert True - """)) + """) + ) - sub.join('test_e.py').write(py.code.Source(""" + sub.join("test_e.py").write( + py.code.Source(""" from unittest import TestCase class EeTest(TestCase): def test_ee1(self): @@ -80,12 +91,13 @@ def tmp_tree_of_tests(testdir): self.assertTrue(True) def test_ex2(self): self.assertTrue(True) - """)) + """) + ) return testdir -def check_call_sequence(seq, bucket='module'): +def check_call_sequence(seq, bucket="module"): all_values = collections.defaultdict(list) num_switches = collections.defaultdict(int) @@ -98,35 +110,35 @@ def check_call_sequence(seq, bucket='mod for i, this_call in enumerate(seq): prev_call = seq[i - 1] if i > 0 else None - inspect_attr(this_call, prev_call, 'package') - inspect_attr(this_call, prev_call, 'module') - inspect_attr(this_call, prev_call, 'cls') - - num_packages = len(set(all_values['package'])) - num_package_switches = num_switches['package'] - num_modules = len(set(all_values['module'])) - num_module_switches = num_switches['module'] - num_classes = len(set(all_values['class'])) - num_class_switches = num_switches['class'] + inspect_attr(this_call, prev_call, "package") + inspect_attr(this_call, prev_call, "module") + inspect_attr(this_call, prev_call, "cls") + + num_packages = len(set(all_values["package"])) + num_package_switches = num_switches["package"] + num_modules = len(set(all_values["module"])) + num_module_switches = num_switches["module"] + num_classes = len(set(all_values["class"])) + num_class_switches = num_switches["class"] # These are just sanity tests, the actual shuffling is tested in test_shuffle, # assertions here are very relaxed. - if bucket == 'global': + if bucket == "global": if num_module_switches <= num_modules: - pytest.fail('Too few module switches for global shuffling') + pytest.fail("Too few module switches for global shuffling") if num_package_switches <= num_packages: - pytest.fail('Too few package switches for global shuffling') + pytest.fail("Too few package switches for global shuffling") - elif bucket == 'package': + elif bucket == "package": assert num_package_switches == num_packages if num_module_switches <= num_modules: - pytest.fail('Too few module switches for package-limited shuffling') + pytest.fail("Too few module switches for package-limited shuffling") - elif bucket == 'module': + elif bucket == "module": assert num_module_switches == num_modules - elif bucket == 'class': + elif bucket == "class": # Each class can contribute to 1 or 2 switches. assert num_class_switches <= num_classes * 2 @@ -136,20 +148,23 @@ def check_call_sequence(seq, bucket='mod assert num_modules <= num_module_switches <= num_modules + 1 -@pytest.mark.parametrize('bucket,min_sequences,max_sequences', [ - ('class', 2, 5), - ('module', 2, 5), - ('package', 2, 5), - ('global', 2, 5), - ('none', 1, 1), - ('parent', 1, 5), - ('grandparent', 1, 5), -]) +@pytest.mark.parametrize( + "bucket,min_sequences,max_sequences", + [ + ("class", 2, 5), + ("module", 2, 5), + ("package", 2, 5), + ("global", 2, 5), + ("none", 1, 1), + ("parent", 1, 5), + ("grandparent", 1, 5), + ], +) def test_it_works_with_actual_tests(tmp_tree_of_tests, get_test_calls, bucket, min_sequences, max_sequences): sequences = set() for x in range(5): - result = tmp_tree_of_tests.runpytest('--random-order-bucket={0}'.format(bucket), '--verbose') + result = tmp_tree_of_tests.runpytest("--random-order-bucket={0}".format(bucket), "--verbose") result.assert_outcomes(passed=14, failed=3) seq = get_test_calls(result) check_call_sequence(seq, bucket=bucket) @@ -162,68 +177,71 @@ def test_it_works_with_actual_tests(tmp_ def test_random_order_seed_is_respected(testdir, twenty_tests, get_test_calls): testdir.makepyfile(twenty_tests) call_sequences = { - '1': None, - '2': None, - '3': None, + "1": None, + "2": None, + "3": None, } for seed in call_sequences.keys(): - result = testdir.runpytest('--random-order-seed={0}'.format(seed)) + result = testdir.runpytest("--random-order-seed={0}".format(seed)) - result.stdout.fnmatch_lines([ - '*Using --random-order-seed={0}*'.format(seed), - ]) + result.stdout.fnmatch_lines( + [ + "*Using --random-order-seed={0}*".format(seed), + ] + ) result.assert_outcomes(passed=20) call_sequences[seed] = get_test_calls(result) for seed in call_sequences.keys(): - result = testdir.runpytest('--random-order-seed={0}'.format(seed)) + result = testdir.runpytest("--random-order-seed={0}".format(seed)) result.assert_outcomes(passed=20) assert call_sequences[seed] == get_test_calls(result) - assert call_sequences['1'] != call_sequences['2'] != call_sequences['3'] + assert call_sequences["1"] != call_sequences["2"] != call_sequences["3"] def test_generated_seed_is_reported_and_run_can_be_reproduced(testdir, twenty_tests, get_test_calls): testdir.makepyfile(twenty_tests) - result = testdir.runpytest('-v', '--random-order') + result = testdir.runpytest("-v", "--random-order") result.assert_outcomes(passed=20) - result.stdout.fnmatch_lines([ - '*Using --random-order-seed=*' - ]) + result.stdout.fnmatch_lines(["*Using --random-order-seed=*"]) calls = get_test_calls(result) # find the seed in output seed = None for line in result.outlines: - g = re.match('^Using --random-order-seed=(.+)$', line) + g = re.match("^Using --random-order-seed=(.+)$", line) if g: seed = g.group(1) break assert seed - result2 = testdir.runpytest('-v', '--random-order-seed={0}'.format(seed)) + result2 = testdir.runpytest("-v", "--random-order-seed={0}".format(seed)) result2.assert_outcomes(passed=20) calls2 = get_test_calls(result2) assert calls == calls2 -@pytest.mark.parametrize('bucket', [ - 'global', - 'package', - 'module', - 'class', - 'parent', - 'grandparent', - 'none', -]) +@pytest.mark.parametrize( + "bucket", + [ + "global", + "package", + "module", + "class", + "parent", + "grandparent", + "none", + ], +) def test_failed_first(tmp_tree_of_tests, get_test_calls, bucket): - result1 = tmp_tree_of_tests.runpytest('--random-order-bucket={0}'.format(bucket), '--verbose') + result1 = tmp_tree_of_tests.runpytest("--random-order-bucket={0}".format(bucket), "--verbose") result1.assert_outcomes(passed=14, failed=3) - result2 = tmp_tree_of_tests.runpytest('--random-order-bucket={0}'.format(bucket), '--failed-first', '--verbose') + result2 = tmp_tree_of_tests.runpytest("--random-order-bucket={0}".format(bucket), "--failed-first", "--verbose") result2.assert_outcomes(passed=14, failed=3) calls2 = get_test_calls(result2) first_three_tests = set(c.name for c in calls2[:3]) - assert set(['test_a1', 'test_b2', 'test_ee2']) == first_three_tests + assert set(["test_a1", "test_b2", "test_ee2"]) == first_three_tests diff -pruN 1.1.1+ds-1/tests/test_cli.py 1.2.0+ds-1/tests/test_cli.py --- 1.1.1+ds-1/tests/test_cli.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/test_cli.py 2025-06-22 14:40:12.000000000 +0000 @@ -1,18 +1,22 @@ def test_help_message(testdir): result = testdir.runpytest( - '--help', + "--help", + ) + result.stdout.fnmatch_lines( + [ + "pytest-random-order options:", + "*--random-order-bucket={global,package,module,class,parent,grandparent,none}*", + "*--random-order-seed=*", + ] ) - result.stdout.fnmatch_lines([ - 'pytest-random-order options:', - '*--random-order-bucket={global,package,module,class,parent,grandparent,none}*', - '*--random-order-seed=*', - ]) def test_markers_message(testdir): result = testdir.runpytest( - '--markers', + "--markers", + ) + result.stdout.fnmatch_lines( + [ + "*@pytest.mark.random_order(disabled=True): disable reordering*", + ] ) - result.stdout.fnmatch_lines([ - '*@pytest.mark.random_order(disabled=True): disable reordering*', - ]) diff -pruN 1.1.1+ds-1/tests/test_doctests.py 1.2.0+ds-1/tests/test_doctests.py --- 1.1.1+ds-1/tests/test_doctests.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/test_doctests.py 2025-06-22 14:40:12.000000000 +0000 @@ -12,10 +12,11 @@ def tmp_tree_of_tests(testdir): """ - utils_package = testdir.mkpydir('utils') - utils_package.join('__init__.py').write('') + utils_package = testdir.mkpydir("utils") + utils_package.join("__init__.py").write("") - utils_package.join('foo.py').write(py.code.Source(''' + utils_package.join("foo.py").write( + py.code.Source(''' def add(a, b): """ >>> add(1, 1) @@ -33,24 +34,31 @@ def tmp_tree_of_tests(testdir): -2 """ return a - b - ''')) + ''') + ) return testdir -@pytest.mark.parametrize('bucket', [ - 'global', - 'package', - 'module', - 'class', - 'parent', - 'grandparent', - 'none', -]) +@pytest.mark.parametrize( + "bucket", + [ + "global", + "package", + "module", + "class", + "parent", + "grandparent", + "none", + ], +) def test_doctests(tmp_tree_of_tests, get_test_calls, bucket): result1 = tmp_tree_of_tests.runpytest( - '--doctest-modules', '--random-order-bucket={0}'.format(bucket), '--verbose', '-s', + "--doctest-modules", + "--random-order-bucket={0}".format(bucket), + "--verbose", + "-s", ) result1.assert_outcomes(passed=2, failed=0) - assert 'PytestWarning' not in result1.stdout.str() - assert 'PytestWarning' not in result1.stderr.str() + assert "PytestWarning" not in result1.stdout.str() + assert "PytestWarning" not in result1.stderr.str() diff -pruN 1.1.1+ds-1/tests/test_markers.py 1.2.0+ds-1/tests/test_markers.py --- 1.1.1+ds-1/tests/test_markers.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/test_markers.py 2025-06-22 14:40:12.000000000 +0000 @@ -1,15 +1,13 @@ import pytest -@pytest.mark.parametrize('disabled', [True, False]) +@pytest.mark.parametrize("disabled", [True, False]) def test_marker_disables_random_order_in_module(testdir, twenty_tests, get_test_calls, disabled): testdir.makepyfile( - 'import pytest\n' + - ('pytestmark = pytest.mark.random_order(disabled={0})\n'.format(disabled)) + - twenty_tests + "import pytest\n" + ("pytestmark = pytest.mark.random_order(disabled={0})\n".format(disabled)) + twenty_tests ) - result = testdir.runpytest('--random-order', '-v') + result = testdir.runpytest("--random-order", "-v") result.assert_outcomes(passed=20) names = [c.name for c in get_test_calls(result)] sorted_names = sorted(list(names)) @@ -20,17 +18,18 @@ def test_marker_disables_random_order_in assert names != sorted_names -@pytest.mark.parametrize('disabled', [True, False]) +@pytest.mark.parametrize("disabled", [True, False]) def test_marker_disables_random_order_in_class(testdir, twenty_cls_tests, get_test_calls, disabled): testdir.makepyfile( - 'import pytest\n\n' + - 'from unittest import TestCase\n\n' + - 'class MyTest(TestCase):\n' + - '\tpytestmark = pytest.mark.random_order(disabled={0})\n'.format(disabled) + - twenty_cls_tests + '\n' + "import pytest\n\n" + + "from unittest import TestCase\n\n" + + "class MyTest(TestCase):\n" + + "\tpytestmark = pytest.mark.random_order(disabled={0})\n".format(disabled) + + twenty_cls_tests + + "\n" ) - result = testdir.runpytest('--random-order', '-v') + result = testdir.runpytest("--random-order", "-v") result.assert_outcomes(passed=20) names = [c.name for c in get_test_calls(result)] sorted_names = sorted(list(names)) diff -pruN 1.1.1+ds-1/tests/test_plugin_failure.py 1.2.0+ds-1/tests/test_plugin_failure.py --- 1.1.1+ds-1/tests/test_plugin_failure.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/test_plugin_failure.py 2025-06-22 14:40:12.000000000 +0000 @@ -3,13 +3,13 @@ import pytest def acceptably_failing_shuffle_items(items, **kwargs): # Does not mess up items collection - raise ValueError('shuffling failed') + raise ValueError("shuffling failed") def critically_failing_shuffle_items(items, **kwargs): # Messes up items collection, an item is effectively lost items[1] = items[0] - raise ValueError('shuffling failed') + raise ValueError("shuffling failed") def critically_not_failing_shuffle_items(items, **kwargs): @@ -30,9 +30,9 @@ def simple_testdir(testdir): def test_faulty_shuffle_that_preserves_items_does_not_fail_test_run(monkeypatch, simple_testdir): - monkeypatch.setattr('random_order.plugin._shuffle_items', acceptably_failing_shuffle_items) + monkeypatch.setattr("random_order.plugin._shuffle_items", acceptably_failing_shuffle_items) - result = simple_testdir.runpytest('--random-order') + result = simple_testdir.runpytest("--random-order") result.assert_outcomes(passed=2) result.stdout.fnmatch_lines(""" *pytest-random-order plugin has failed with ValueError* @@ -40,8 +40,8 @@ def test_faulty_shuffle_that_preserves_i def test_faulty_shuffle_that_loses_items_fails_test_run(monkeypatch, simple_testdir): - monkeypatch.setattr('random_order.plugin._shuffle_items', critically_failing_shuffle_items) - result = simple_testdir.runpytest('--random-order') + monkeypatch.setattr("random_order.plugin._shuffle_items", critically_failing_shuffle_items) + result = simple_testdir.runpytest("--random-order") result.assert_outcomes(passed=0, failed=0, skipped=0) result.stdout.fnmatch_lines(""" *INTERNALERROR> RuntimeError: pytest-random-order plugin has failed with ValueError* @@ -49,8 +49,8 @@ def test_faulty_shuffle_that_loses_items def test_seemingly_ok_shuffle_that_loses_items_fails_test_run(monkeypatch, simple_testdir): - monkeypatch.setattr('random_order.plugin._shuffle_items', critically_not_failing_shuffle_items) - result = simple_testdir.runpytest('--random-order') + monkeypatch.setattr("random_order.plugin._shuffle_items", critically_not_failing_shuffle_items) + result = simple_testdir.runpytest("--random-order") result.assert_outcomes(passed=0, failed=0, skipped=0) result.stdout.fnmatch_lines(""" *INTERNALERROR> RuntimeError: pytest-random-order plugin has failed miserably* diff -pruN 1.1.1+ds-1/tests/test_shuffle.py 1.2.0+ds-1/tests/test_shuffle.py --- 1.1.1+ds-1/tests/test_shuffle.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/test_shuffle.py 2025-06-22 14:40:12.000000000 +0000 @@ -23,11 +23,14 @@ def disable_if_gt_1000(item, session): return False -@pytest.mark.parametrize('key', [ - None, - lambda item, session: None, - lambda item, session: item % 2, -]) +@pytest.mark.parametrize( + "key", + [ + None, + lambda item, session: None, + lambda item, session: item % 2, + ], +) def test_shuffles_empty_list_in_place(key): items = [] items_id = id(items) @@ -36,11 +39,14 @@ def test_shuffles_empty_list_in_place(ke assert id(items) == items_id -@pytest.mark.parametrize('key', [ - None, - lambda item, session: None, - lambda item, session: item % 2, -]) +@pytest.mark.parametrize( + "key", + [ + None, + lambda item, session: None, + lambda item, session: item % 2, + ], +) def test_shuffles_one_item_list_in_place(key): items = [42] items_id = id(items) @@ -75,14 +81,22 @@ def test_two_bucket_reshuffle(): def test_eight_bucket_reshuffle(): # This is a cross-check to test shuffling of buckets. items = [ - 1, 1, - 2, 2, - 3, 3, - 4, 4, - 5, 5, - 6, 6, - 7, 7, - 8, 8, + 1, + 1, + 2, + 2, + 3, + 3, + 4, + 4, + 5, + 5, + 6, + 6, + 7, + 7, + 8, + 8, ] items_copy = list(items) @@ -98,8 +112,26 @@ def test_eight_bucket_reshuffle(): def test_shuffle_respects_single_disabled_group_in_each_of_two_buckets(): items = [ - 11, 13, 9995, 9997, 19, 21, 23, 25, 27, 29, # bucket 1 -- odd numbers - 12, 14, 9996, 9998, 20, 22, 24, 26, 28, 30, # bucket 2 -- even numbers + 11, + 13, + 9995, + 9997, + 19, + 21, + 23, + 25, + 27, + 29, # bucket 1 -- odd numbers + 12, + 14, + 9996, + 9998, + 20, + 22, + 24, + 26, + 28, + 30, # bucket 2 -- even numbers ] items_copy = list(items) @@ -117,15 +149,24 @@ def test_shuffle_respects_two_distinct_d # This is simulating two disabled modules within same package. # The two modules shouldn't be mixed up in one bucket. items = [ - 11, 13, 8885, 8887, 8889, 21, 23, 9995, 9997, 9999, + 11, + 13, + 8885, + 8887, + 8889, + 21, + 23, + 9995, + 9997, + 9999, ] items_copy = list(items) for i in range(5): _shuffle_items(items, bucket_key=modulus_2_key, disable=disable_if_gt_1000) if items != items_copy: - assert items[items.index(8885):items.index(8885) + 3] == [8885, 8887, 8889] - assert items[items.index(9995):items.index(9995) + 3] == [9995, 9997, 9999] + assert items[items.index(8885) : items.index(8885) + 3] == [8885, 8887, 8889] + assert items[items.index(9995) : items.index(9995) + 3] == [9995, 9997, 9999] return assert False diff -pruN 1.1.1+ds-1/tests/test_xdist.py 1.2.0+ds-1/tests/test_xdist.py --- 1.1.1+ds-1/tests/test_xdist.py 2024-01-20 09:19:47.000000000 +0000 +++ 1.2.0+ds-1/tests/test_xdist.py 2025-06-22 14:40:12.000000000 +0000 @@ -1,6 +1,5 @@ - def test_xdist_not_broken(testdir, twenty_tests): testdir.makepyfile(twenty_tests) - result = testdir.runpytest('--random-order', '-n', '5') + result = testdir.runpytest("--random-order", "-n", "5") result.assert_outcomes(passed=20) diff -pruN 1.1.1+ds-1/tox.ini 1.2.0+ds-1/tox.ini --- 1.1.1+ds-1/tox.ini 1970-01-01 00:00:00.000000000 +0000 +++ 1.2.0+ds-1/tox.ini 2025-06-22 14:40:12.000000000 +0000 @@ -0,0 +1,10 @@ +[tox] +minversion = 4.0 +envlist = py{39,310,311,312,313} + +[testenv] +deps = + py + pytest-xdist +commands = + pytest tests --color=yes