Release 1.33.0

Exclude SCM and CI files from distribution

.appveyor.yml

@@ -0,0 +1,21 @@
+environment:
+  matrix:
+  - TOXENV: "py27-pytestlatest"
+  - TOXENV: "py35-pytestlatest"
+  - TOXENV: "py36-pytestlatest"
+  - TOXENV: "py37-pytestlatest"
+  - TOXENV: "py38-pytestlatest"
+  - TOXENV: "py38-pytestmaster"
+
+install:
+  - C:\Python38\python -m pip install -U pip setuptools virtualenv
+  - C:\Python38\python -m pip install -U tox setuptools_scm
+
+build: false  # Not a C# project, build stuff at the test step instead.
+
+test_script:
+  - C:\Python38\python -m tox
+
+# We don't deploy anything on tags with AppVeyor, we use Travis instead, so we
+# might as well save resources
+skip_tags: true

.github/PULL_REQUEST_TEMPLATE.md

@@ -13,5 +13,3 @@ Here's a quick checklist that should be present in PRs:
     ```
     Fix issue with non-ascii contents in doctest text files.
     ```
-
-

.gitignore

@@ -23,12 +23,13 @@ include/
 lib/
 bin/
 env/
-xdist/_version.py*
+src/xdist/_version.py*
 pytest_xdist.egg-info
 issue/
 3rdparty/
 pytestdebug.log
 .tox/
 .cache/
+.pytest_cache/
 .eggs/
 .idea/

.pre-commit-config.yaml

@@ -0,0 +1,24 @@
+repos:
+-   repo: https://github.com/ambv/black
+    rev: 19.10b0
+    hooks:
+    -   id: black
+        args: [--safe, --quiet]
+        language_version: python3.7
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.4.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: debug-statements
+    -   id: flake8
+-   repo: local
+    hooks:
+    -   id: rst
+        name: rst
+        entry: rst-lint --encoding utf-8
+        files: ^(CHANGELOG.rst|HOWTORELEASE.rst|README.rst|changelog/.*)$
+        language: python
+        additional_dependencies: [pygments, restructuredtext_lint]
+        language_version: python3.7

.travis.yml

@@ -1,56 +1,59 @@
-sudo: false
+dist: xenial
 language: python
 
 notifications:
   irc:
     channels:
-    - 'chat.freenode.net#pytest'
+      - 'chat.freenode.net#pytest'
     on_success: change
     on_failure: change
     skip_join: true
   email:
   - pytest-commit@python.org
 
-python:
-- '2.7'
-- '3.4'
-- '3.5'
-- '3.6'
-env:
-- TOXENV=py-pytest30
-- TOXENV=py-pytest31
-- TOXENV=py-pytest32
-- TOXENV=py-pytest33
-
-install: pip install tox setuptools_scm
+install:
+  - pip install -U pip setuptools
+  - pip install tox setuptools_scm
 script: tox
 
+stages:
+  - baseline
+  - test
+  - name: deploy
+    if: repo = pytest-dev/pytest-xdist AND tag IS present
+
 jobs:
   include:
+    - stage: baseline
+      python: '3.7'
+      env: TOXENV=linting
+      cache:
+        directories:
+          - $HOME/.cache/pre-commit
+    - python: '3.8'
+      env: TOXENV=py38-pytestlatest
+    - python: '2.7'
+      env: TOXENV=py27-pytestlatest
+
     - stage: test
-    # python x env above are already included into this stage
-    - python: "2.7"
-      env: TOXENV=py27-pytestmaster
-    - python: "2.7"
-      env: TOXENV=py27-pytestfeatures
+      python: "3.5"
+      env: TOXENV=py35-pytestlatest
     - python: "3.6"
-      env: TOXENV=py36-pytestmaster
-    - python: "3.6"
-      env: TOXENV=py36-pytestfeatures
-    - python: "3.6"
-      env: TOXENV=flakes
-    - python: "3.6"
-      env: TOXENV=readme
+      env: TOXENV=py36-pytestlatest
+    - python: "3.7"
+      env: TOXENV=py37-pytestlatest
+    - python: "3.8"
+      env: TOXENV=py38-pytestmaster
 
     - stage: deploy
-      python: '3.6'
+      python: '3.8'
       env:
       install: pip install -U setuptools setuptools_scm
       script: skip
       deploy:
         provider: pypi
         user: ronny
-        distributions: sdist bdist_wheel  
+        distributions: sdist bdist_wheel
         skip_upload_docs: true
         password:
           secure: cxmSDho5d+PYKEM4ZCg8ms1P4lzhYkrw6fEOm2HtTcsuCyY6aZMSgImWAnEYbJHSkdzgcxlXK9UKJ9B0YenXmBCkAr7UjdnpNXNmkySr0sYzlH/sfqt/dDATCHFaRKxnkOSOVywaDYhT9n8YudbXI77pXwD12i/CeSSJDbHhsu0JYUfAcb+D6YjRYoA2SEGCnzSzg+gDDfwXZx4ZiODCGLVwieNp1klCg88YROUE1BaYYNuUOONvfXX8+TWowbCF6ChH1WL/bZ49OStEYQNuYxZQZr4yClIqu9VJbchrU8j860K9ott2kkGTgfB/dDrQB/XncBubyIX9ikzCQAmmBXWAI3eyvWLPDk2Jz7kW2l2RT7syct80tCq3JhvQ1qdwr5ap7siocTLgnBW0tF4tkHSTFN3510fkc43npnp6FThebESQpnI24vqpwJ9hI/kW5mYi014Og2E/cpCXnz2XO8iZPDbqAMQpDsqEQoyhfGNgPTGp4K30TxRtwZBI5hHhDKnnR16fXtRgt1gYPvz/peUQvvpOm4JzIzGXPzluuutpnCBy75v5+oiwT3YRrLL/Meims9FtDDXL3qQubAE/ezIOOpm0N5XXV8DxIom8EN71yq5ab1tqhM+tBX7owRjy4FR4If2Q8feBdmTuh26DIQt/y+qSG8VkB9Sw/JCjc7c=

CHANGELOG.rst

@@ -1,3 +1,268 @@
+pytest-xdist 1.33.0 (2020-07-09)
+================================
+
+Features
+--------
+
+- `#554 <https://github.com/pytest-dev/pytest-xdist/issues/554>`_: Fix warnings support for upcoming pytest 6.0.
+
+
+Trivial Changes
+---------------
+
+- `#548 <https://github.com/pytest-dev/pytest-xdist/issues/548>`_: SCM and CI files are no longer included in the source distribution.
+
+
+pytest-xdist 1.32.0 (2020-05-03)
+================================
+
+Deprecations and Removals
+-------------------------
+
+- `#475 <https://github.com/pytest-dev/pytest-xdist/issues/475>`_: Drop support for EOL Python 3.4.
+
+
+Features
+--------
+
+- `#524 <https://github.com/pytest-dev/pytest-xdist/issues/524>`_: Add `testrun_uid` fixture. This is a shared value that uniquely identifies a test run among all workers.
+  This also adds a `PYTEST_XDIST_TESTRUNUID` environment variable that is accessible within a test as well as a command line option `--testrunuid` to manually set the value from outside.
+
+
+pytest-xdist 1.31.0 (2019-12-19)
+================================
+
+Features
+--------
+
+- `#486 <https://github.com/pytest-dev/pytest-xdist/issues/486>`_: Add support for Python 3.8.
+
+
+Bug Fixes
+---------
+
+- `#491 <https://github.com/pytest-dev/pytest-xdist/issues/491>`_: Fix regression that caused custom plugin command-line arguments to be discarded when using ``--tx`` mode.
+
+
+
+pytest-xdist 1.30.0 (2019-10-01)
+================================
+
+Features
+--------
+
+- `#448 <https://github.com/pytest-dev/pytest-xdist/issues/448>`_: Initialization between workers and master nodes is now more consistent, which fixes a number of
+  long-standing issues related to startup with the ``-c`` option.
+
+  Issues:
+
+  * `#6 <https://github.com/pytest-dev/pytest-xdist/issues/6>`__: Poor interaction between ``-n#`` and ``-c X.cfg``
+  * `#445 <https://github.com/pytest-dev/pytest-xdist/issues/445>`__: pytest-xdist is not reporting the same nodeid as pytest does
+
+  This however only works with **pytest 5.1 or later**, as it required changes in pytest itself.
+
+
+Bug Fixes
+---------
+
+- `#467 <https://github.com/pytest-dev/pytest-xdist/issues/467>`_: Fix crash issues related to running xdist with the terminal plugin disabled.
+
+
+pytest-xdist 1.29.0 (2019-06-14)
+================================
+
+Features
+--------
+
+- `#226 <https://github.com/pytest-dev/pytest-xdist/issues/226>`_: ``--max-worker-restart`` now assumes a more reasonable value (4 times the number of
+  nodes) when not given explicitly. This prevents test suites from running forever when the suite crashes during collection.
+
+- `#435 <https://github.com/pytest-dev/pytest-xdist/issues/435>`_: When the test session is interrupted due to running out of workers, the reason is shown in the test summary
+  for easier viewing.
+
+- `#442 <https://github.com/pytest-dev/pytest-xdist/issues/442>`_: Compatibility fix for upcoming pytest 5.0: ``session.exitstatus`` is now an ``IntEnum`` object.
+
+
+Bug Fixes
+---------
+
+- `#435 <https://github.com/pytest-dev/pytest-xdist/issues/435>`_: No longer show an internal error when we run out of workers due to crashes.
+
+
+pytest-xdist 1.28.0 (2019-04-02)
+================================
+
+Features
+--------
+
+- `#426 <https://github.com/pytest-dev/pytest-xdist/issues/426>`_: ``pytest-xdist`` now uses the new ``pytest_report_to_serializable`` and ``pytest_report_from_serializable``
+  hooks from ``pytest 4.4`` (still experimental). This will make report serialization more reliable and
+  extensible.
+
+  This also means that ``pytest-xdist`` now requires ``pytest>=4.4``.
+
+
+pytest-xdist 1.27.0 (2019-02-15)
+================================
+
+Features
+--------
+
+- `#374 <https://github.com/pytest-dev/pytest-xdist/issues/374>`_: The new ``pytest_xdist_getremotemodule`` hook allows overriding the module run on remote nodes.
+
+- `#415 <https://github.com/pytest-dev/pytest-xdist/issues/415>`_: Improve behavior of ``--numprocesses=auto`` to work well with ``--pdb`` option.
+
+
+pytest-xdist 1.26.1 (2019-01-28)
+================================
+
+Bug Fixes
+---------
+
+- `#406 <https://github.com/pytest-dev/pytest-xdist/issues/406>`_: Do not implement deprecated ``pytest_logwarning`` hook in pytest versions where it is deprecated.
+
+
+pytest-xdist 1.26.0 (2019-01-11)
+================================
+
+Features
+--------
+
+- `#376 <https://github.com/pytest-dev/pytest-xdist/issues/376>`_: The current directory is no longer added ``sys.path`` for local workers, only for remote connections.
+
+  This behavior is surprising because it makes xdist runs and non-xdist runs to potentially behave differently.
+
+
+Bug Fixes
+---------
+
+- `#379 <https://github.com/pytest-dev/pytest-xdist/issues/379>`_: Warning attributes are checked to make sure they can be dumped prior to
+  serializing the warning for submission to the master node.
+
+
+pytest-xdist 1.25.0 (2018-12-12)
+================================
+
+Deprecations and Removals
+-------------------------
+
+- `#372 <https://github.com/pytest-dev/pytest-xdist/issues/372>`_: Pytest versions older than 3.6 are no longer supported.
+
+
+Features
+--------
+
+- `#373 <https://github.com/pytest-dev/pytest-xdist/issues/373>`_: Node setup information is hidden when pytest is run in quiet mode to reduce noise on many-core machines.
+
+- `#388 <https://github.com/pytest-dev/pytest-xdist/issues/388>`_: ``mainargv`` is made available in ``workerinput`` from the host's ``sys.argv``.
+
+  This can be used via ``request.config.workerinput["mainargv"]``.
+
+
+Bug Fixes
+---------
+
+- `#332 <https://github.com/pytest-dev/pytest-xdist/issues/332>`_: Fix report of module-level skips (``pytest.skip(reason, allow_module_level=True)``).
+
+- `#378 <https://github.com/pytest-dev/pytest-xdist/issues/378>`_: Fix support for gevent monkeypatching
+
+- `#384 <https://github.com/pytest-dev/pytest-xdist/issues/384>`_: pytest 4.1 support: ``ExceptionInfo`` API changes.
+
+- `#390 <https://github.com/pytest-dev/pytest-xdist/issues/390>`_: pytest 4.1 support: ``pytest_logwarning`` hook removed.
+
+
+pytest-xdist 1.24.1 (2018-11-09)
+================================
+
+Bug Fixes
+---------
+
+- `#349 <https://github.com/pytest-dev/pytest-xdist/issues/349>`_: Correctly handle warnings created with arguments that can't be serialized during the transfer from workers to master node.
+
+
+pytest-xdist 1.24.0 (2018-10-18)
+================================
+
+Features
+--------
+
+- `#337 <https://github.com/pytest-dev/pytest-xdist/issues/337>`_: New ``--maxprocesses`` command-line option that limits the maximum number of workers when using ``--numprocesses=auto``.
+
+
+Bug Fixes
+---------
+
+- `#351 <https://github.com/pytest-dev/pytest-xdist/issues/351>`_: Fix scheduling deadlock in case of inter-test locking.
+
+
+pytest-xdist 1.23.2 (2018-09-28)
+================================
+
+Bug Fixes
+---------
+
+- `#344 <https://github.com/pytest-dev/pytest-xdist/issues/344>`_: Fix issue where Warnings could cause pytest to fail if they do not set the args attribute correctly.
+
+
+pytest-xdist 1.23.1 (2018-09-25)
+================================
+
+Bug Fixes
+---------
+
+- `#341 <https://github.com/pytest-dev/pytest-xdist/issues/341>`_: Fix warnings transfer between workers and master node with pytest >= 3.8.
+
+
+pytest-xdist 1.23.0 (2018-08-23)
+================================
+
+Features
+--------
+
+- `#330 <https://github.com/pytest-dev/pytest-xdist/issues/330>`_: Improve collection performance by reducing the number of events sent to ``master`` node.
+
+
+pytest-xdist 1.22.5 (2018-07-27)
+================================
+
+Bug Fixes
+---------
+
+- `#321 <https://github.com/pytest-dev/pytest-xdist/issues/321>`_: Revert change that dropped support for ``pytest<3.4`` and require ``six``.
+
+  This change caused problems in some installations, and was a mistaken
+  in the first place as we should not change version requirements
+  in bug-fix releases unless they fix an actual bug.
+
+
+pytest-xdist 1.22.4 (2018-07-27)
+================================
+
+Bug Fixes
+---------
+
+- `#305 <https://github.com/pytest-dev/pytest-xdist/issues/305>`_: Remove last references to obsolete ``py.code``.
+
+  Remove some unnecessary references to ``py.builtin``.
+
+- `#316 <https://github.com/pytest-dev/pytest-xdist/issues/316>`_: Workaround cpu detection on Travis CI.
+
+
+pytest-xdist 1.22.3 (2018-07-23)
+================================
+
+Bug Fixes
+---------
+
+- Fix issue of virtualized or containerized environments not reporting the number of CPUs correctly. (`#9 <https://github.com/pytest-dev/pytest-xdist/issues/9>`_)
+
+
+Trivial Changes
+---------------
+
+- Make all classes subclass from ``object`` and fix ``super()`` call in ``LoadFileScheduling``; (`#297 <https://github.com/pytest-dev/pytest-xdist/issues/297>`_)
+
+
 pytest-xdist 1.22.2 (2018-02-26)
 ================================
 
@@ -206,17 +471,6 @@ Improved Documentation
 - Added ``HOWTORELEASE`` documentation. (#155)
 
 
-..
-    You should *NOT* be adding new change log entries to this file, this
-    file is managed by towncrier. You *may* edit previous change logs to
-    fix problems like typo corrections or such.
-    To add a new change log entry, please see
-    https://pip.pypa.io/en/latest/development/#adding-a-news-entry
-    We named the news folder ``changelog``
-
-.. towncrier release notes start
-
-
 1.17.0
 ------
 

HOWTORELEASE.rst

@@ -24,13 +24,13 @@ To publish a new release ``X.Y.Z``, the steps are as follows:
 
 #. Create a new branch named ``release-X.Y.Z`` from the latest ``master``.
 
-#. Install ``pytest-xdist`` and dev requirements in a virtualenv::
+#. Install ``tox`` in a virtualenv::
 
-    $ pip install -e . -U -r dev-requirements.txt
+    $ pip install tox
 
-#. Update ``CHANGELOG.rst`` file by running::
+#. Update the necessary files with::
 
-    $ towncrier --version X.Y.Z --yes
+    $ tox -e release -- X.Y.Z
 
 #. Commit and push the branch for review.
 

ISSUES.txt

@@ -19,7 +19,7 @@ tag: feature
 
 allow to run xdist own tests using its own mechanism.
 currently this doesn't work because the remote side
-has no py.test plugin.   How to configure/do
+has no pytest plugin.   How to configure/do
 register "xdist.plugin" on the remote side?
 
 see to avoid any "from _pytest" internal imports

LICENSE

@@ -5,10 +5,10 @@
   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   copies of the Software, and to permit persons to whom the Software is
   furnished to do so, subject to the following conditions:
-     
+
   The above copyright notice and this permission notice shall be included in all
   copies or substantial portions of the Software.
- 
+
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -16,4 +16,3 @@
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
-

MANIFEST.in

@@ -0,0 +1,5 @@
+exclude .appveyor.yml
+exclude .gitignore
+exclude .pre-commit-config.yaml
+exclude .travis.yml
+prune .github

OVERVIEW.md

@@ -1,78 +1,76 @@
 # Overview #
 
 `xdist` works by spawning one or more **workers**, which are controlled
-by the **master**. Each **worker** is responsible for performing 
+by the **master**. Each **worker** is responsible for performing
 a full test collection and afterwards running tests as dictated by the **master**.
 
 The execution flow is:
 
 1. **master** spawns one or more **workers** at the beginning of
-   the test session. The communication between **master** and **worker** nodes makes use of 
+   the test session. The communication between **master** and **worker** nodes makes use of
    [execnet](http://codespeak.net/execnet/) and its [gateways](http://codespeak.net/execnet/basics.html#gateways-bootstrapping-python-interpreters).
    The actual interpreters executing the code for the **workers** might
-   be remote or local. 
-  
+   be remote or local.
+
 1. Each **worker** itself is a mini pytest runner. **workers** at this
-   point perform a full test collection, sending back the collected 
+   point perform a full test collection, sending back the collected
    test-ids back to the **master** which does not
    perform any collection itself.
-     
+
 1. The **master** receives the result of the collection from all nodes.
    At this point the **master** performs some sanity check to ensure that
    all **workers** collected the same tests (including order), bailing out otherwise.
    If all is well, it converts the list of test-ids into a list of simple
    indexes, where each index corresponds to the position of that test in the
-   original collection list. This works because all nodes have the same 
+   original collection list. This works because all nodes have the same
    collection list, and saves bandwidth because the **master** can now tell
    one of the workers to just *execute test index 3* index of passing the
    full test id.
-   
+
 1. If **dist-mode** is **each**: the **master** just sends the full list
    of test indexes to each node at this moment.
-   
+
 1. If **dist-mode** is **load**: the **master** takes around 25% of the
    tests and sends them one by one to each **worker** in a round robin
    fashion. The rest of the tests will be distributed later as **workers**
    finish tests (see below).
 
 1. Note that `pytest_xdist_make_scheduler` hook can be used to implement custom tests distribution logic.
-   
+
 1. **workers** re-implement `pytest_runtestloop`: pytest's default implementation
    basically loops over all collected items in the `session` object and executes
-   the `pytest_runtest_protocol` for each test item, but in xdist **workers** sit idly 
+   the `pytest_runtest_protocol` for each test item, but in xdist **workers** sit idly
    waiting for **master** to send tests for execution. As tests are
-   received by **workers**, `pytest_runtest_protocol` is executed for each test. 
-   Here it worth noting an implementation detail: **workers** always must keep at 
-   least one test item on their queue due to how the `pytest_runtest_protocol(item, nextitem)` 
-   hook is defined: in order to pass the `nextitem` to the hook, the worker must wait for more 
-   instructions from master before executing that remaining test. If it receives more tests, 
-   then it can safely call `pytest_runtest_protocol` because it knows what the `nextitem` parameter will be. 
-   If it receives a "shutdown" signal, then it can execute the hook passing `nextitem` as `None`. 
-   
+   received by **workers**, `pytest_runtest_protocol` is executed for each test.
+   Here it worth noting an implementation detail: **workers** always must keep at
+   least one test item on their queue due to how the `pytest_runtest_protocol(item, nextitem)`
+   hook is defined: in order to pass the `nextitem` to the hook, the worker must wait for more
+   instructions from master before executing that remaining test. If it receives more tests,
+   then it can safely call `pytest_runtest_protocol` because it knows what the `nextitem` parameter will be.
+   If it receives a "shutdown" signal, then it can execute the hook passing `nextitem` as `None`.
+
 1. As tests are started and completed at the **workers**, the results are sent
-   back to the **master**, which then just forwards the results to 
-   the appropriate pytest hooks: `pytest_runtest_logstart` and 
+   back to the **master**, which then just forwards the results to
+   the appropriate pytest hooks: `pytest_runtest_logstart` and
    `pytest_runtest_logreport`. This way other plugins (for example `junitxml`)
-   can work normally. The **master** (when in dist-mode **load**) 
+   can work normally. The **master** (when in dist-mode **load**)
    decides to send more tests to a node when a test completes, using
    some heuristics such as test durations and how many tests each **worker**
    still has to run.
-   
+
 1. When the **master** has no more pending tests it will
-   send a "shutdown" signal to all **workers**, which will then run their 
-   remaining tests to completion and shut down. At this point the 
+   send a "shutdown" signal to all **workers**, which will then run their
+   remaining tests to completion and shut down. At this point the
    **master** will sit waiting for **workers** to shut down, still
    processing events such as `pytest_runtest_logreport`.
- 
+
 ## FAQ ##
 
-> Why does each worker do its own collection, as opposed to having 
+> Why does each worker do its own collection, as opposed to having
 the master collect once and distribute from that collection to the workers?
 
-If collection was performed by master then it would have to 
-serialize collected items to send them through the wire, as workers live in another process. 
-The problem is that test items are not easily (impossible?) to serialize, as they contain references to 
-the test functions, fixture managers, config objects, etc. Even if one manages to serialize it, 
-it seems it would be very hard to get it right and easy to break by any small change in pytest. 
-  
-
+If collection was performed by master then it would have to
+serialize collected items to send them through the wire, as workers live in another process.
+The problem is that test items are not easily (impossible?) to serialize, as they contain references to
+the test functions, fixture managers, config objects, etc. Even if one manages to serialize it,
+it seems it would be very hard to get it right and easy to break by any small change in pytest.

README.rst

@@ -4,14 +4,13 @@
     :alt: PyPI version
     :target: https://pypi.python.org/pypi/pytest-xdist
 
+.. image:: https://img.shields.io/conda/vn/conda-forge/pytest-xdist.svg
+    :target: https://anaconda.org/conda-forge/pytest-xdist
+
 .. image:: https://img.shields.io/pypi/pyversions/pytest-xdist.svg
     :alt: Python versions
     :target: https://pypi.python.org/pypi/pytest-xdist
 
-.. image:: https://anaconda.org/conda-forge/pytest-xdist/badges/version.svg
-    :alt: Anaconda version
-    :target: https://anaconda.org/conda-forge/pytest-xdist
-
 .. image:: https://travis-ci.org/pytest-dev/pytest-xdist.svg?branch=master
     :alt: Travis CI build status
     :target: https://travis-ci.org/pytest-dev/pytest-xdist
@@ -20,10 +19,13 @@
     :alt: AppVeyor build status
     :target: https://ci.appveyor.com/project/pytestbot/pytest-xdist
 
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/ambv/black
+
 xdist: pytest distributed testing plugin
 ========================================
 
-The `pytest-xdist`_ plugin extends py.test with some unique
+The `pytest-xdist`_ plugin extends pytest with some unique
 test execution modes:
 
 * test run parallelization_: if you have multiple CPUs or hosts you can use
@@ -32,19 +34,19 @@ test execution modes:
 
 
 * ``--looponfail``: run your tests repeatedly in a subprocess.  After each run
-  py.test waits until a file in your project changes and then re-runs
+  pytest waits until a file in your project changes and then re-runs
   the previously failing tests.  This is repeated until all tests pass
   after which again a full run is performed.
 
 * `Multi-Platform`_ coverage: you can specify different Python interpreters
   or different platforms and run tests in parallel on all of them.
 
-Before running tests remotely, ``py.test`` efficiently "rsyncs" your
+Before running tests remotely, ``pytest`` efficiently "rsyncs" your
 program source code to the remote place.  All test results
 are reported back and displayed to your local terminal.
 You may specify different Python versions and interpreters.
 
-If you would like to know how pytest-xdist works under the covers, checkout 
+If you would like to know how pytest-xdist works under the covers, checkout
 `OVERVIEW <https://github.com/pytest-dev/pytest-xdist/blob/master/OVERVIEW.md>`_.
 
 
@@ -67,7 +69,7 @@ Speed up test runs by sending tests to multiple CPUs
 
 To send tests to multiple CPUs, type::
 
-    py.test -n NUM
+    pytest -n NUM
 
 Especially for longer running tests or tests requiring
 a lot of I/O this can lead to considerable speed ups. This option can
@@ -93,12 +95,65 @@ any guaranteed order, but you can control this with these options:
   in version ``1.21``.
 
 
+Making session-scoped fixtures execute only once
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``pytest-xdist`` is designed so that each worker process will perform its own collection and execute
+a subset of all tests. This means that tests in different processes requesting a high-level
+scoped fixture (for example ``session``) will execute the fixture code more than once, which
+breaks expectations and might be undesired in certain situations.
+
+While ``pytest-xdist`` does not have a builtin support for ensuring a session-scoped fixture is
+executed exactly once, this can be achieved by using a lock file for inter-process communication.
+
+The example below needs to execute the fixture ``session_data`` only once (because it is
+resource intensive, or needs to execute only once to define configuration options, etc), so it makes
+use of a `FileLock <https://pypi.org/project/filelock/>`_ to produce the fixture data only once
+when the first process requests the fixture, while the other processes will then read
+the data from a file.
+
+Here is the code:
+
+.. code-block:: python
+
+    import json
+
+    import pytest
+    from filelock import FileLock
+
+
+    @pytest.fixture(scope="session")
+    def session_data(tmp_path_factory, worker_id):
+        if not worker_id:
+            # not executing in with multiple workers, just produce the data and let
+            # pytest's fixture caching do its job
+            return produce_expensive_data()
+
+        # get the temp directory shared by all workers
+        root_tmp_dir = tmp_path_factory.getbasetemp().parent
+
+        fn = root_tmp_dir / "data.json"
+        with FileLock(str(fn) + ".lock"):
+            if fn.is_file():
+                data = json.loads(fn.read_text())
+            else:
+                data = produce_expensive_data()
+                fn.write_text(json.dumps(data))
+        return data
+
+
+The example above can also be use in cases a fixture needs to execute exactly once per test session, like
+initializing a database service and populating initial tables.
+
+This technique might not work for every case, but should be a starting point for many situations
+where executing a high-scope fixture exactly once is important.
+
 Running tests in a Python subprocess
 ------------------------------------
 
 To instantiate a python3.5 subprocess and send tests to it, you may type::
 
-    py.test -d --tx popen//python=python3.5
+    pytest -d --tx popen//python=python3.5
 
 This will start a subprocess which is run with the ``python3.5``
 Python interpreter, found in your system binary lookup path.
@@ -129,10 +184,10 @@ tests that you can successfully run locally. And you
 have a ssh-reachable machine ``myhost``.  Then
 you can ad-hoc distribute your tests by typing::
 
-    py.test -d --tx ssh=myhostpopen --rsyncdir mypkg mypkg
+    pytest -d --tx ssh=myhostpopen --rsyncdir mypkg mypkg
 
 This will synchronize your :code:`mypkg` package directory
-to an remote ssh account and then locally collect tests
+to a remote ssh account and then locally collect tests
 and send them to remote places for execution.
 
 You can specify multiple :code:`--rsyncdir` directories
@@ -140,11 +195,11 @@ to be sent to the remote side.
 
 .. note::
 
-  For py.test to collect and send tests correctly
+  For pytest to collect and send tests correctly
   you not only need to make sure all code and tests
   directories are rsynced, but that any test (sub) directory
   also has an :code:`__init__.py` file because internally
-  py.test references tests as a fully qualified python
+  pytest references tests as a fully qualified python
   module path.  **You will otherwise get strange errors**
   during setup of the remote side.
 
@@ -168,7 +223,7 @@ It will tell you that it starts listening on the default
 port.  You can now on your home machine specify this
 new socket host with something like this::
 
-    py.test -d --tx socket=192.168.1.102:8888 --rsyncdir mypkg mypkg
+    pytest -d --tx socket=192.168.1.102:8888 --rsyncdir mypkg mypkg
 
 
 .. _`atonce`:
@@ -180,7 +235,7 @@ Running tests on many platforms at once
 
 The basic command to run tests on multiple platforms is::
 
-    py.test --dist=each --tx=spec1 --tx=spec2
+    pytest --dist=each --tx=spec1 --tx=spec2
 
 If you specify a windows host, an OSX host and a Linux
 environment this command will send each tests to all
@@ -222,6 +277,47 @@ The information about the worker_id in a test is stored in the ``TestReport`` as
 well, under the ``worker_id`` attribute.
 
 
+Uniquely identifying the current test run
+-----------------------------------------
+
+*New in version 1.32.*
+
+If you need to globally distinguish one test run from others in your
+workers, you can use the ``testrun_uid`` fixture. For instance, let's say you
+wanted to create a separate database for each test run:
+
+.. code-block:: python
+
+    import pytest
+    from posix_ipc import Semaphore, O_CREAT
+
+    @pytest.fixture(scope="session", autouse=True)
+    def create_unique_database(testrun_uid):
+        """ create a unique database for this particular test run """
+        database_url = f"psql://myapp-{testrun_uid}"
+
+        with Semaphore(f"/{testrun_uid}-lock", flags=O_CREAT, initial_value=1):
+            if not database_exists(database_url):
+                create_database(database_url)
+
+    @pytest.fixture()
+    def db(testrun_uid):
+        """ retrieve unique database """
+        database_url = f"psql://myapp-{testrun_uid}"
+        return database_get_instance(database_url)
+
+
+Additionally, during a test run, the following environment variable is defined:
+
+* ``PYTEST_XDIST_TESTRUNUID``: the unique id of the test run.
+
+Accessing ``sys.argv`` from the master node in workers
+------------------------------------------------------
+
+To access the ``sys.argv`` passed to the command-line of the master node, use
+``request.config.workerinput["mainargv"]``.
+
+
 Specifying test exec environments in an ini file
 ------------------------------------------------
 
@@ -242,7 +338,7 @@ You can also add default environments like this:
 
 and then just type::
 
-    py.test --dist=each
+    pytest --dist=each
 
 to run tests in each of the environments.
 

appveyor.yml

@@ -1,19 +0,0 @@
-environment:
-  matrix:
-  # note: please use "tox --listenvs" to populate the build matrix
-  - TOXENV: "py27-pytest33"
-  - TOXENV: "py34-pytest33"
-  - TOXENV: "py35-pytest33"
-  - TOXENV: "py36-pytest33"
-  - TOXENV: "py27-pytest33-pexpect"
-  - TOXENV: "py36-pytest33-pexpect"
-  - TOXENV: "flakes"
-  - TOXENV: "readme"
-
-install:
-  - C:\Python35\python -m pip install -U tox setuptools_scm pip
-
-build: false  # Not a C# project, build stuff at the test step instead.
-
-test_script:
-  - C:\Python35\python -m tox

changelog/_template.rst

@@ -13,8 +13,7 @@
 
 {% if definitions[category]['showcontent'] %}
 {% for text, values in sections[section][category]|dictsort(by='value') %}
-- {{ text }}{% if category != 'vendor' %} (`{{ values[0] }} <https://github.com/pytest-dev/pytest-xdist/issues/{{ values[0][1:] }}>`_){% endif %}
-
+- `{{ values[0] }} <https://github.com/pytest-dev/pytest-xdist/issues/{{ values[0][1:] }}>`_: {{ text }}
 
 {% endfor %}
 {% else %}

dev-requirements.txt

@@ -1 +0,0 @@
-towncrier

example/boxed.txt

@@ -1,8 +1,8 @@
 .. note::
 
-  Since 1.19.0, the actual implementation of the ``--boxed`` option has been moved to a 
-  separate plugin, `pytest-forked <https://github.com/pytest-dev/pytest-forked>`_ 
-  which can be installed independently. The ``--boxed`` command-line options remains 
+  Since 1.19.0, the actual implementation of the ``--boxed`` option has been moved to a
+  separate plugin, `pytest-forked <https://github.com/pytest-dev/pytest-forked>`_
+  which can be installed independently. The ``--boxed`` command-line options remains
   for backward compatibility reasons.
 
 
@@ -25,7 +25,7 @@ to run each test in a controlled subprocess.  Here is a basic example::
 
 If you run this with::
 
-    $ py.test -n1
+    $ pytest -n1
     =========================== test session starts ============================
     platform linux2 -- Python 2.7.3 -- pytest-2.3.0.dev8
     plugins: xdist, bugzilla, cache, oejskit, cli, pep8, cov
@@ -46,7 +46,7 @@ You'll see that a couple of tests are reported as crashing, indicated
 by lower-case ``f`` and the respective failure summary. You can also use
 the xdist-provided parallelization feature to speed up your testing::
 
-    $ py.test -n3
+    $ pytest -n3
     =========================== test session starts ============================
     platform linux2 -- Python 2.7.3 -- pytest-2.3.0.dev8
     plugins: xdist, bugzilla, cache, oejskit, cli, pep8, cov

example/loadscope/test/test_delta.py

@@ -3,7 +3,6 @@ from unittest import TestCase
 
 
 class Delta1(TestCase):
-
     def test_delta0(self):
         sleep(5)
         assert True
@@ -46,7 +45,6 @@ class Delta1(TestCase):
 
 
 class Delta2(TestCase):
-
     def test_delta0(self):
         sleep(5)
         assert True

example/loadscope/tox.ini

@@ -8,7 +8,7 @@ passenv = http_proxy https_proxy
 deps = -rrequirements.txt
 changedir = {envtmpdir}
 commands =
-    py.test -s -v \
+    pytest -s -v \
         --doctest-modules \
         --junitxml=tests.xml \
         --dist=loadscope \

setup.py

@@ -1,47 +1,50 @@
 from setuptools import setup, find_packages
 
-install_requires = ['execnet>=1.1', 'pytest>=3.0.0', 'pytest-forked']
+install_requires = ["execnet>=1.1", "pytest>=4.4.0", "pytest-forked", "six"]
 
 
+with open("README.rst") as f:
+    long_description = f.read()
+
 setup(
     name="pytest-xdist",
-    use_scm_version={'write_to': 'xdist/_version.py'},
-    description='py.test xdist plugin for distributed testing'
-                ' and loop-on-failing modes',
-    long_description=open('README.rst').read(),
-    license='MIT',
-    author='holger krekel and contributors',
-    author_email='pytest-dev@python.org,holger@merlinux.eu',
-    url='https://github.com/pytest-dev/pytest-xdist',
-    platforms=['linux', 'osx', 'win32'],
-    packages=find_packages(exclude=['testing', 'example']),
+    use_scm_version={"write_to": "src/xdist/_version.py"},
+    description="pytest xdist plugin for distributed testing"
+    " and loop-on-failing modes",
+    long_description=long_description,
+    license="MIT",
+    author="holger krekel and contributors",
+    author_email="pytest-dev@python.org,holger@merlinux.eu",
+    url="https://github.com/pytest-dev/pytest-xdist",
+    platforms=["linux", "osx", "win32"],
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    extras_require={"testing": ["filelock"]},
     entry_points={
-        'pytest11': [
-            'xdist = xdist.plugin',
-            'xdist.looponfail = xdist.looponfail',
-        ],
+        "pytest11": ["xdist = xdist.plugin", "xdist.looponfail = xdist.looponfail"]
     },
     zip_safe=False,
-    python_requires='>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*',
+    python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*",
     install_requires=install_requires,
-    setup_requires=['setuptools_scm'],
+    setup_requires=["setuptools_scm"],
     classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Framework :: Pytest',
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: POSIX',
-        'Operating System :: Microsoft :: Windows',
-        'Operating System :: MacOS :: MacOS X',
-        'Topic :: Software Development :: Testing',
-        'Topic :: Software Development :: Quality Assurance',
-        'Topic :: Utilities',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.4',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
+        "Development Status :: 5 - Production/Stable",
+        "Framework :: Pytest",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: POSIX",
+        "Operating System :: Microsoft :: Windows",
+        "Operating System :: MacOS :: MacOS X",
+        "Topic :: Software Development :: Testing",
+        "Topic :: Software Development :: Quality Assurance",
+        "Topic :: Utilities",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
     ],
 )

src/xdist/__init__.py

@@ -1,3 +1,3 @@
 from xdist._version import version as __version__
 
-__all__ = ['__version__']
+__all__ = ["__version__"]

src/xdist/dsession.py

@@ -10,15 +10,15 @@ from xdist.scheduler import (
 )
 
 
-queue = py.builtin._tryimport('queue', 'Queue')
+from six.moves.queue import Empty, Queue
 
 
 class Interrupted(KeyboardInterrupt):
     """ signals an immediate interruption. """
 
 
-class DSession:
-    """A py.test plugin which runs a distributed test session
+class DSession(object):
+    """A pytest plugin which runs a distributed test session
 
     At the beginning of the test session this creates a NodeManager
     instance which creates and starts all nodes.  Nodes then emit
@@ -26,7 +26,7 @@ class DSession:
     methods.
 
     Once a node is started it will automatically start running the
-    py.test mainloop with some custom hooks.  This means a node
+    pytest mainloop with some custom hooks.  This means a node
     automatically starts collecting tests.  Once tests are collected
     it will wait for instructions.
     """
@@ -41,19 +41,16 @@ class DSession:
         self.shuttingdown = False
         self.countfailures = 0
         self.maxfail = config.getvalue("maxfail")
-        self.queue = queue.Queue()
+        self.queue = Queue()
         self._session = None
         self._failed_collection_errors = {}
         self._active_nodes = set()
         self._failed_nodes_count = 0
-        self._max_worker_restart = self.config.option.maxworkerrestart
-        if self._max_worker_restart is not None:
-            self._max_worker_restart = int(self._max_worker_restart)
-        try:
-            self.terminal = config.pluginmanager.getplugin("terminalreporter")
-        except KeyError:
-            self.terminal = None
-        else:
+        self._max_worker_restart = get_default_max_worker_restart(self.config)
+        # summary message to print at the end of the session
+        self._summary_report = None
+        self.terminal = config.pluginmanager.getplugin("terminalreporter")
+        if self.terminal:
             self.trdist = TerminalDistReporter(config)
             config.pluginmanager.register(self.trdist, "terminaldistreporter")
 
@@ -84,7 +81,7 @@ class DSession:
 
     def pytest_sessionfinish(self, session):
         """Shutdown all nodes."""
-        nm = getattr(self, 'nodemanager', None)  # if not fully initialized
+        nm = getattr(self, "nodemanager", None)  # if not fully initialized
         if nm is not None:
             nm.teardown_nodes()
         self._session = None
@@ -95,19 +92,18 @@ class DSession:
 
     @pytest.mark.trylast
     def pytest_xdist_make_scheduler(self, config, log):
-        dist = config.getvalue('dist')
+        dist = config.getvalue("dist")
         schedulers = {
-            'each': EachScheduling,
-            'load': LoadScheduling,
-            'loadscope': LoadScopeScheduling,
-            'loadfile': LoadFileScheduling,
+            "each": EachScheduling,
+            "load": LoadScheduling,
+            "loadscope": LoadScopeScheduling,
+            "loadfile": LoadFileScheduling,
         }
         return schedulers[dist](config, log)
 
     def pytest_runtestloop(self):
         self.sched = self.config.hook.pytest_xdist_make_scheduler(
-            config=self.config,
-            log=self.log
+            config=self.config, log=self.log
         )
         assert self.sched is not None
 
@@ -129,7 +125,7 @@ class DSession:
             try:
                 eventcall = self.queue.get(timeout=2.0)
                 break
-            except queue.Empty:
+            except Empty:
                 continue
         callname, kwargs = eventcall
         assert callname, kwargs
@@ -151,8 +147,8 @@ class DSession:
         collection without any further input.
         """
         node.workerinfo = workerinfo
-        node.workerinfo['id'] = node.gateway.id
-        node.workerinfo['spec'] = node.gateway.spec
+        node.workerinfo["id"] = node.gateway.id
+        node.workerinfo["spec"] = node.gateway.spec
 
         # TODO: (#234 task) needs this for pytest. Remove when refactor in pytest repo
         node.slaveinfo = node.workerinfo
@@ -172,8 +168,8 @@ class DSession:
         workerready before shutdown was triggered.
         """
         self.config.hook.pytest_testnodedown(node=node, error=None)
-        if node.workeroutput['exitstatus'] == 2:  # keyboard-interrupt
-            self.shouldstop = "%s received keyboard-interrupt" % (node,)
+        if node.workeroutput["exitstatus"] == 2:  # keyboard-interrupt
+            self.shouldstop = "{} received keyboard-interrupt".format(node)
             self.worker_errordown(node, "keyboard-interrupt")
             return
         if node in self.sched.nodes:
@@ -193,20 +189,29 @@ class DSession:
                 self.handle_crashitem(crashitem, node)
 
         self._failed_nodes_count += 1
-        maximum_reached = (self._max_worker_restart is not None and
-                           self._failed_nodes_count > self._max_worker_restart)
+        maximum_reached = (
+            self._max_worker_restart is not None
+            and self._failed_nodes_count > self._max_worker_restart
+        )
         if maximum_reached:
             if self._max_worker_restart == 0:
-                msg = 'Worker restarting disabled'
+                msg = "worker {} crashed and worker restarting disabled".format(
+                    node.gateway.id
+                )
             else:
-                msg = "Maximum crashed workers reached: %d" % \
-                      self._max_worker_restart
-            self.report_line(msg)
+                msg = "maximum crashed workers reached: %d" % self._max_worker_restart
+            self._summary_report = msg
+            self.report_line("\n" + msg)
+            self.triggershutdown()
         else:
-            self.report_line("Replacing crashed worker %s" % node.gateway.id)
+            self.report_line("\nreplacing crashed worker %s" % node.gateway.id)
             self._clone_node(node)
         self._active_nodes.remove(node)
 
+    def pytest_terminal_summary(self, terminalreporter):
+        if self.config.option.verbose >= 0 and self._summary_report:
+            terminalreporter.write_sep("=", "xdist: {}".format(self._summary_report))
+
     def worker_collectionfinish(self, node, ids):
         """worker has finished test collection.
 
@@ -218,8 +223,7 @@ class DSession:
         """
         if self.shuttingdown:
             return
-        self.config.hook.pytest_xdist_node_collection_finished(node=node,
-                                                               ids=ids)
+        self.config.hook.pytest_xdist_node_collection_finished(node=node, ids=ids)
         # tell session which items were effectively collected otherwise
         # the master node will finish the session with EXIT_NOTESTSCOLLECTED
         self._session.testscollected = len(ids)
@@ -230,19 +234,19 @@ class DSession:
             if self.terminal and not self.sched.has_pending:
                 self.trdist.ensure_show_status()
                 self.terminal.write_line("")
-                self.terminal.write_line("scheduling tests via %s" % (
-                    self.sched.__class__.__name__))
+                if self.config.option.verbose > 0:
+                    self.terminal.write_line(
+                        "scheduling tests via %s" % (self.sched.__class__.__name__)
+                    )
             self.sched.schedule()
 
     def worker_logstart(self, node, nodeid, location):
         """Emitted when a node calls the pytest_runtest_logstart hook."""
-        self.config.hook.pytest_runtest_logstart(
-            nodeid=nodeid, location=location)
+        self.config.hook.pytest_runtest_logstart(nodeid=nodeid, location=location)
 
     def worker_logfinish(self, node, nodeid, location):
         """Emitted when a node calls the pytest_runtest_logfinish hook."""
-        self.config.hook.pytest_runtest_logfinish(
-            nodeid=nodeid, location=location)
+        self.config.hook.pytest_runtest_logfinish(nodeid=nodeid, location=location)
 
     def worker_testreport(self, node, rep):
         """Emitted when a node calls the pytest_runtest_logreport hook."""
@@ -259,15 +263,31 @@ class DSession:
         self.sched.mark_test_complete(node, item_index, duration)
 
     def worker_collectreport(self, node, rep):
-        """Emitted when a node calls the pytest_collectreport hook."""
-        if rep.failed:
-            self._failed_worker_collectreport(node, rep)
+        """Emitted when a node calls the pytest_collectreport hook.
+
+        Because we only need the report when there's a failure/skip, as optimization
+        we only expect to receive failed/skipped reports from workers (#330).
+        """
+        assert not rep.passed
+        self._failed_worker_collectreport(node, rep)
 
     def worker_logwarning(self, message, code, nodeid, fslocation):
         """Emitted when a node calls the pytest_logwarning hook."""
         kwargs = dict(message=message, code=code, nodeid=nodeid, fslocation=fslocation)
         self.config.hook.pytest_logwarning.call_historic(kwargs=kwargs)
 
+    def worker_warning_captured(self, warning_message, when, item):
+        """Emitted when a node calls the pytest_warning_captured hook (deprecated in 6.0)."""
+        kwargs = dict(warning_message=warning_message, when=when, item=item)
+        self.config.hook.pytest_warning_captured.call_historic(kwargs=kwargs)
+
+    def worker_warning_recorded(self, warning_message, when, nodeid, location):
+        """Emitted when a node calls the pytest_warning_recorded hook."""
+        kwargs = dict(
+            warning_message=warning_message, when=when, nodeid=nodeid, location=location
+        )
+        self.config.hook.pytest_warning_recorded.call_historic(kwargs=kwargs)
+
     def _clone_node(self, node):
         """Return new node based on an existing one.
 
@@ -295,8 +315,7 @@ class DSession:
         if rep.failed:
             self.countfailures += 1
             if self.maxfail and self.countfailures >= self.maxfail:
-                self.shouldstop = "stopping after %d failures" % (
-                    self.countfailures)
+                self.shouldstop = "stopping after %d failures" % (self.countfailures)
 
     def triggershutdown(self):
         self.log("triggering shutdown")
@@ -309,20 +328,21 @@ class DSession:
         # XXX count no of failures and retry N times
         runner = self.config.pluginmanager.getplugin("runner")
         fspath = nodeid.split("::")[0]
-        msg = "Worker %r crashed while running %r" % (worker.gateway.id, nodeid)
-        rep = runner.TestReport(nodeid, (fspath, None, fspath),
-                                (), "failed", msg, "???")
+        msg = "worker {!r} crashed while running {!r}".format(worker.gateway.id, nodeid)
+        rep = runner.TestReport(
+            nodeid, (fspath, None, fspath), (), "failed", msg, "???"
+        )
         rep.node = worker
         self.config.hook.pytest_runtest_logreport(report=rep)
 
 
-class TerminalDistReporter:
+class TerminalDistReporter(object):
     def __init__(self, config):
         self.config = config
         self.tr = config.pluginmanager.getplugin("terminalreporter")
         self._status = {}
         self._lastlen = 0
-        self._isatty = getattr(self.tr, 'isatty', self.tr.hasmarkup)
+        self._isatty = getattr(self.tr, "isatty", self.tr.hasmarkup)
 
     def write_line(self, msg):
         self.tr.write_line(msg)
@@ -337,9 +357,13 @@ class TerminalDistReporter:
             self.rewrite(self.getstatus())
 
     def getstatus(self):
-        parts = ["%s %s" % (spec.id, self._status[spec.id])
-                 for spec in self._specs]
-        return " / ".join(parts)
+        if self.config.option.verbose >= 0:
+            parts = [
+                "{} {}".format(spec.id, self._status[spec.id]) for spec in self._specs
+            ]
+            return " / ".join(parts)
+        else:
+            return "bringing up nodes..."
 
     def rewrite(self, line, newline=False):
         pline = line + " " * max(self._lastlen - len(line), 0)
@@ -361,29 +385,37 @@ class TerminalDistReporter:
         if self.config.option.verbose > 0:
             rinfo = gateway._rinfo()
             version = "%s.%s.%s" % rinfo.version_info[:3]
-            self.rewrite("[%s] %s Python %s cwd: %s" % (
-                gateway.id, rinfo.platform, version, rinfo.cwd),
-                newline=True)
+            self.rewrite(
+                "[%s] %s Python %s cwd: %s"
+                % (gateway.id, rinfo.platform, version, rinfo.cwd),
+                newline=True,
+            )
         self.setstatus(gateway.spec, "C")
 
     def pytest_testnodeready(self, node):
         if self.config.option.verbose > 0:
             d = node.workerinfo
-            infoline = "[%s] Python %s" % (
-                d['id'],
-                d['version'].replace('\n', ' -- '),)
+            infoline = "[{}] Python {}".format(
+                d["id"], d["version"].replace("\n", " -- ")
+            )
             self.rewrite(infoline, newline=True)
         self.setstatus(node.gateway.spec, "ok")
 
     def pytest_testnodedown(self, node, error):
         if not error:
             return
-        self.write_line("[%s] node down: %s" % (node.gateway.id, error))
+        self.write_line("[{}] node down: {}".format(node.gateway.id, error))
 
-    # def pytest_xdist_rsyncstart(self, source, gateways):
-    #    targets = ",".join([gw.id for gw in gateways])
-    #    msg = "[%s] rsyncing: %s" %(targets, source)
-    #    self.write_line(msg)
-    # def pytest_xdist_rsyncfinish(self, source, gateways):
-    #    targets = ", ".join(["[%s]" % gw.id for gw in gateways])
-    #    self.write_line("rsyncfinish: %s -> %s" %(source, targets))
+
+def get_default_max_worker_restart(config):
+    """gets the default value of --max-worker-restart option if it is not provided.
+
+    Use a reasonable default to avoid workers from restarting endlessly due to crashing collections (#226).
+    """
+    result = config.option.maxworkerrestart
+    if result is not None:
+        result = int(result)
+    elif config.option.numprocesses:
+        # if --max-worker-restart was not provided, use a reasonable default (#226)
+        result = config.option.numprocesses * 4
+    return result

src/xdist/looponfail.py

@@ -1,34 +1,38 @@
 """
-    Implement -f aka looponfailing for py.test.
+    Implement -f aka looponfailing for pytest.
 
     NOTE that we try to avoid loading and depending on application modules
     within the controlling process (the one that starts repeatedly test
     processes) otherwise changes to source code can crash
     the controlling process which should best never happen.
 """
-
+from __future__ import print_function
 import py
 import pytest
 import sys
+import time
 import execnet
 
 
 def pytest_addoption(parser):
     group = parser.getgroup("xdist", "distributed and subprocess testing")
     group._addoption(
-        '-f', '--looponfail',
-        action="store_true", dest="looponfail", default=False,
+        "-f",
+        "--looponfail",
+        action="store_true",
+        dest="looponfail",
+        default=False,
         help="run tests in subprocess, wait for modified files "
-             "and re-run failing test set until all pass.")
+        "and re-run failing test set until all pass.",
+    )
 
 
 def pytest_cmdline_main(config):
 
     if config.getoption("looponfail"):
-        usepdb = config.getoption('usepdb')  # a core option
+        usepdb = config.getoption("usepdb", False)  # a core option
         if usepdb:
-            raise pytest.UsageError(
-                "--pdb incompatible with --looponfail.")
+            raise pytest.UsageError("--pdb is incompatible with --looponfail.")
         looponfail_main(config)
         return 2  # looponfail only can get stop with ctrl-C anyway
 
@@ -44,8 +48,8 @@ def looponfail_main(config):
                 # the last failures passed, let's immediately rerun all
                 continue
             repr_pytest_looponfailinfo(
-                failreports=remotecontrol.failures,
-                rootdirs=rootdirs)
+                failreports=remotecontrol.failures, rootdirs=rootdirs
+            )
             statrecorder.waitonchange(checkinterval=2.0)
     except KeyboardInterrupt:
         print()
@@ -59,7 +63,7 @@ class RemoteControl(object):
     def trace(self, *args):
         if self.config.option.debug:
             msg = " ".join([str(x) for x in args])
-            py.builtin.print_("RemoteControl:", msg)
+            print("RemoteControl:", msg)
 
     def initgateway(self):
         return execnet.makegateway("popen")
@@ -67,7 +71,7 @@ class RemoteControl(object):
     def setup(self, out=None):
         if out is None:
             out = py.io.TerminalWriter()
-        if hasattr(self, 'gateway'):
+        if hasattr(self, "gateway"):
             raise ValueError("already have gateway %r" % self.gateway)
         self.trace("setting up worker session")
         self.gateway = self.initgateway()
@@ -81,15 +85,16 @@ class RemoteControl(object):
         def write(s):
             out._file.write(s)
             out._file.flush()
+
         remote_outchannel.setcallback(write)
 
     def ensure_teardown(self):
-        if hasattr(self, 'channel'):
+        if hasattr(self, "channel"):
             if not self.channel.isclosed():
                 self.trace("closing", self.channel)
                 self.channel.close()
             del self.channel
-        if hasattr(self, 'gateway'):
+        if hasattr(self, "gateway"):
             self.trace("exiting", self.gateway)
             self.gateway.exit()
             del self.gateway
@@ -131,14 +136,15 @@ def repr_pytest_looponfailinfo(failreports, rootdirs):
                 tr.line(report, red=True)
     tr.sep("#", "waiting for changes", bold=True)
     for rootdir in rootdirs:
-        tr.line("### Watching:   %s" % (rootdir,), bold=True)
+        tr.line("### Watching:   {}".format(rootdir), bold=True)
 
 
 def init_worker_session(channel, args, option_dict):
     import os
     import sys
+
     outchannel = channel.gateway.newchannel()
-    sys.stdout = sys.stderr = outchannel.makefile('w')
+    sys.stdout = sys.stderr = outchannel.makefile("w")
     channel.send(outchannel)
     # prune sys.path to not contain relative paths
     newpaths = []
@@ -151,13 +157,15 @@ def init_worker_session(channel, args, option_dict):
 
     # fullwidth, hasmarkup = channel.receive()
     from _pytest.config import Config
+
     config = Config.fromdictargs(option_dict, list(args))
     config.args = args
     from xdist.looponfail import WorkerFailSession
+
     WorkerFailSession(config, channel).main()
 
 
-class WorkerFailSession:
+class WorkerFailSession(object):
     def __init__(self, config, channel):
         self.config = config
         self.channel = channel
@@ -180,7 +188,8 @@ class WorkerFailSession:
         except pytest.UsageError:
             items = session.perform_collect(None)
         hook.pytest_collection_modifyitems(
-            session=session, config=session.config, items=items)
+            session=session, config=session.config, items=items
+        )
         hook.pytest_collection_finish(session=session)
         return True
 
@@ -206,12 +215,12 @@ class WorkerFailSession:
         for rep in self.recorded_failures:
             trails.append(rep.nodeid)
             loc = rep.longrepr
-            loc = str(getattr(loc, 'reprcrash', loc))
+            loc = str(getattr(loc, "reprcrash", loc))
             failreports.append(loc)
         self.channel.send((trails, failreports, self.collection_failed))
 
 
-class StatRecorder:
+class StatRecorder(object):
     def __init__(self, rootdirlist):
         self.rootdirlist = rootdirlist
         self.statcache = {}
@@ -228,7 +237,7 @@ class StatRecorder:
             changed = self.check()
             if changed:
                 return
-            py.std.time.sleep(checkinterval)
+            time.sleep(checkinterval)
 
     def check(self, removepycfiles=True):  # noqa, too complex
         changed = False
@@ -244,10 +253,12 @@ class StatRecorder:
                         changed = True
                 else:
                     if oldstat:
-                        if oldstat.mtime != curstat.mtime or \
-                           oldstat.size != curstat.size:
+                        if (
+                            oldstat.mtime != curstat.mtime
+                            or oldstat.size != curstat.size
+                        ):
                             changed = True
-                            py.builtin.print_("# MODIFIED", path)
+                            print("# MODIFIED", path)
                             if removepycfiles and path.ext == ".py":
                                 pycfile = path + "c"
                                 if pycfile.check():

src/xdist/newhooks.py

@@ -30,6 +30,11 @@ def pytest_xdist_rsyncfinish(source, gateways):
     """ called after rsyncing a directory to remote gateways takes place. """
 
 
+@pytest.mark.firstresult
+def pytest_xdist_getremotemodule():
+    """ called when creating remote node"""
+
+
 def pytest_configure_node(node):
     """ configure node information before it gets instantiated. """
 

src/xdist/plugin.py

@@ -0,0 +1,236 @@
+import os
+import uuid
+
+import py
+import pytest
+
+
+def auto_detect_cpus():
+    try:
+        from os import sched_getaffinity
+    except ImportError:
+        if os.environ.get("TRAVIS") == "true":
+            # workaround https://bitbucket.org/pypy/pypy/issues/2375
+            return 2
+        try:
+            from os import cpu_count
+        except ImportError:
+            from multiprocessing import cpu_count
+    else:
+
+        def cpu_count():
+            return len(sched_getaffinity(0))
+
+    try:
+        n = cpu_count()
+    except NotImplementedError:
+        return 1
+    return n if n else 1
+
+
+class AutoInt(int):
+    """Mark value as auto-detected."""
+
+
+def parse_numprocesses(s):
+    if s == "auto":
+        return AutoInt(auto_detect_cpus())
+    elif s is not None:
+        return int(s)
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("xdist", "distributed and subprocess testing")
+    group._addoption(
+        "-n",
+        "--numprocesses",
+        dest="numprocesses",
+        metavar="numprocesses",
+        action="store",
+        type=parse_numprocesses,
+        help="shortcut for '--dist=load --tx=NUM*popen', "
+        "you can use 'auto' here for auto detection CPUs number on "
+        "host system and it will be 0 when used with --pdb",
+    )
+    group.addoption(
+        "--maxprocesses",
+        dest="maxprocesses",
+        metavar="maxprocesses",
+        action="store",
+        type=int,
+        help="limit the maximum number of workers to process the tests when using --numprocesses=auto",
+    )
+    group.addoption(
+        "--max-worker-restart",
+        "--max-slave-restart",
+        action="store",
+        default=None,
+        dest="maxworkerrestart",
+        help="maximum number of workers that can be restarted "
+        "when crashed (set to zero to disable this feature)\n"
+        "'--max-slave-restart' option is deprecated and will be removed in "
+        "a future release",
+    )
+    group.addoption(
+        "--dist",
+        metavar="distmode",
+        action="store",
+        choices=["each", "load", "loadscope", "loadfile", "no"],
+        dest="dist",
+        default="no",
+        help=(
+            "set mode for distributing tests to exec environments.\n\n"
+            "each: send each test to all available environments.\n\n"
+            "load: load balance by sending any pending test to any"
+            " available environment.\n\n"
+            "loadscope: load balance by sending pending groups of tests in"
+            " the same scope to any available environment.\n\n"
+            "loadfile: load balance by sending test grouped by file"
+            " to any available environment.\n\n"
+            "(default) no: run tests inprocess, don't distribute."
+        ),
+    )
+    group.addoption(
+        "--tx",
+        dest="tx",
+        action="append",
+        default=[],
+        metavar="xspec",
+        help=(
+            "add a test execution environment. some examples: "
+            "--tx popen//python=python2.5 --tx socket=192.168.1.102:8888 "
+            "--tx ssh=user@codespeak.net//chdir=testcache"
+        ),
+    )
+    group._addoption(
+        "-d",
+        action="store_true",
+        dest="distload",
+        default=False,
+        help="load-balance tests.  shortcut for '--dist=load'",
+    )
+    group.addoption(
+        "--rsyncdir",
+        action="append",
+        default=[],
+        metavar="DIR",
+        help="add directory for rsyncing to remote tx nodes.",
+    )
+    group.addoption(
+        "--rsyncignore",
+        action="append",
+        default=[],
+        metavar="GLOB",
+        help="add expression for ignores when rsyncing to remote tx nodes.",
+    )
+    group.addoption(
+        "--boxed",
+        action="store_true",
+        help="backward compatibility alias for pytest-forked --forked",
+    )
+    group.addoption(
+        "--testrunuid",
+        action="store",
+        help=(
+            "provide an identifier shared amongst all workers as the value of "
+            "the 'testrun_uid' fixture,\n\n,"
+            "if not provided, 'testrun_uid' is filled with a new unique string "
+            "on every test run."
+        ),
+    )
+
+    parser.addini(
+        "rsyncdirs",
+        "list of (relative) paths to be rsynced for remote distributed testing.",
+        type="pathlist",
+    )
+    parser.addini(
+        "rsyncignore",
+        "list of (relative) glob-style paths to be ignored for rsyncing.",
+        type="pathlist",
+    )
+    parser.addini(
+        "looponfailroots",
+        type="pathlist",
+        help="directories to check for changes",
+        default=[py.path.local()],
+    )
+
+
+# -------------------------------------------------------------------------
+# distributed testing hooks
+# -------------------------------------------------------------------------
+
+
+def pytest_addhooks(pluginmanager):
+    from xdist import newhooks
+
+    pluginmanager.add_hookspecs(newhooks)
+
+
+# -------------------------------------------------------------------------
+# distributed testing initialization
+# -------------------------------------------------------------------------
+
+
+@pytest.mark.trylast
+def pytest_configure(config):
+    if config.getoption("dist") != "no" and not config.getvalue("collectonly"):
+        from xdist.dsession import DSession
+
+        session = DSession(config)
+        config.pluginmanager.register(session, "dsession")
+        tr = config.pluginmanager.getplugin("terminalreporter")
+        if tr:
+            tr.showfspath = False
+    if config.getoption("boxed"):
+        config.option.forked = True
+
+
+@pytest.mark.tryfirst
+def pytest_cmdline_main(config):
+    usepdb = config.getoption("usepdb", False)  # a core option
+    if isinstance(config.option.numprocesses, AutoInt):
+        config.option.numprocesses = 0 if usepdb else int(config.option.numprocesses)
+
+    if config.option.numprocesses:
+        if config.option.dist == "no":
+            config.option.dist = "load"
+        numprocesses = config.option.numprocesses
+        if config.option.maxprocesses:
+            numprocesses = min(numprocesses, config.option.maxprocesses)
+        config.option.tx = ["popen"] * numprocesses
+    if config.option.distload:
+        config.option.dist = "load"
+    val = config.getvalue
+    if not val("collectonly"):
+        if val("dist") != "no":
+            if usepdb:
+                raise pytest.UsageError(
+                    "--pdb is incompatible with distributing tests; try using -n0 or -nauto."
+                )  # noqa: E501
+
+
+# -------------------------------------------------------------------------
+# fixtures
+# -------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="session")
+def worker_id(request):
+    """Return the id of the current worker ('gw0', 'gw1', etc) or 'master'
+    if running on the master node.
+    """
+    if hasattr(request.config, "workerinput"):
+        return request.config.workerinput["workerid"]
+    else:
+        return "master"
+
+
+@pytest.fixture(scope="session")
+def testrun_uid(request):
+    """Return the unique id of the current test."""
+    if hasattr(request.config, "workerinput"):
+        return request.config.workerinput["testrunuid"]
+    else:
+        return uuid.uuid4().hex

src/xdist/remote.py

@@ -0,0 +1,273 @@
+"""
+    This module is executed in remote subprocesses and helps to
+    control a remote testing session and relay back information.
+    It assumes that 'py' is importable and does not have dependencies
+    on the rest of the xdist code.  This means that the xdist-plugin
+    needs not to be installed in remote environments.
+"""
+
+import sys
+import os
+import time
+
+import py
+import _pytest.hookspec
+import pytest
+from execnet.gateway_base import dumps, DumpError
+
+from _pytest.config import _prepareconfig, Config
+
+
+class WorkerInteractor(object):
+    def __init__(self, config, channel):
+        self.config = config
+        self.workerid = config.workerinput.get("workerid", "?")
+        self.testrunuid = config.workerinput["testrunuid"]
+        self.log = py.log.Producer("worker-%s" % self.workerid)
+        if not config.option.debug:
+            py.log.setconsumer(self.log._keywords, None)
+        self.channel = channel
+        config.pluginmanager.register(self)
+
+    def sendevent(self, name, **kwargs):
+        self.log("sending", name, kwargs)
+        self.channel.send((name, kwargs))
+
+    def pytest_internalerror(self, excrepr):
+        for line in str(excrepr).split("\n"):
+            self.log("IERROR>", line)
+
+    def pytest_sessionstart(self, session):
+        self.session = session
+        workerinfo = getinfodict()
+        self.sendevent("workerready", workerinfo=workerinfo)
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_sessionfinish(self, exitstatus):
+        # in pytest 5.0+, exitstatus is an IntEnum object
+        self.config.workeroutput["exitstatus"] = int(exitstatus)
+        yield
+        self.sendevent("workerfinished", workeroutput=self.config.workeroutput)
+
+    def pytest_collection(self, session):
+        self.sendevent("collectionstart")
+
+    def pytest_runtestloop(self, session):
+        self.log("entering main loop")
+        torun = []
+        while 1:
+            try:
+                name, kwargs = self.channel.receive()
+            except EOFError:
+                return True
+            self.log("received command", name, kwargs)
+            if name == "runtests":
+                torun.extend(kwargs["indices"])
+            elif name == "runtests_all":
+                torun.extend(range(len(session.items)))
+            self.log("items to run:", torun)
+            # only run if we have an item and a next item
+            while len(torun) >= 2:
+                self.run_one_test(torun)
+            if name == "shutdown":
+                if torun:
+                    self.run_one_test(torun)
+                break
+        return True
+
+    def run_one_test(self, torun):
+        items = self.session.items
+        self.item_index = torun.pop(0)
+        item = items[self.item_index]
+        if torun:
+            nextitem = items[torun[0]]
+        else:
+            nextitem = None
+
+        start = time.time()
+        self.config.hook.pytest_runtest_protocol(item=item, nextitem=nextitem)
+        duration = time.time() - start
+        self.sendevent(
+            "runtest_protocol_complete", item_index=self.item_index, duration=duration
+        )
+
+    def pytest_collection_finish(self, session):
+        self.sendevent(
+            "collectionfinish",
+            topdir=str(session.fspath),
+            ids=[item.nodeid for item in session.items],
+        )
+
+    def pytest_runtest_logstart(self, nodeid, location):
+        self.sendevent("logstart", nodeid=nodeid, location=location)
+
+    # the pytest_runtest_logfinish hook was introduced in pytest 3.4
+    if hasattr(_pytest.hookspec, "pytest_runtest_logfinish"):
+
+        def pytest_runtest_logfinish(self, nodeid, location):
+            self.sendevent("logfinish", nodeid=nodeid, location=location)
+
+    def pytest_runtest_logreport(self, report):
+        data = self.config.hook.pytest_report_to_serializable(
+            config=self.config, report=report
+        )
+        data["item_index"] = self.item_index
+        data["worker_id"] = self.workerid
+        data["testrun_uid"] = self.testrunuid
+        assert self.session.items[self.item_index].nodeid == report.nodeid
+        self.sendevent("testreport", data=data)
+
+    def pytest_collectreport(self, report):
+        # send only reports that have not passed to master as optimization (#330)
+        if not report.passed:
+            data = self.config.hook.pytest_report_to_serializable(
+                config=self.config, report=report
+            )
+            self.sendevent("collectreport", data=data)
+
+    # the pytest_logwarning hook was deprecated since pytest 4.0
+    if hasattr(
+        _pytest.hookspec, "pytest_logwarning"
+    ) and not _pytest.hookspec.pytest_logwarning.pytest_spec.get("warn_on_impl"):
+
+        def pytest_logwarning(self, message, code, nodeid, fslocation):
+            self.sendevent(
+                "logwarning",
+                message=message,
+                code=code,
+                nodeid=nodeid,
+                fslocation=str(fslocation),
+            )
+
+    # the pytest_warning_captured hook was introduced in pytest 3.8
+    if hasattr(_pytest.hookspec, "pytest_warning_captured"):
+
+        def pytest_warning_captured(self, warning_message, when, item):
+            self.sendevent(
+                "warning_captured",
+                warning_message_data=serialize_warning_message(warning_message),
+                when=when,
+                # item cannot be serialized and will always be None when used with xdist
+                item=None,
+            )
+
+    # the pytest_warning_recorded hook was introduced in pytest 6.0
+    if hasattr(_pytest.hookspec, "pytest_warning_recorded"):
+
+        def pytest_warning_recorded(self, warning_message, when, nodeid, location):
+            self.sendevent(
+                "warning_recorded",
+                warning_message_data=serialize_warning_message(warning_message),
+                when=when,
+                nodeid=nodeid,
+                location=location,
+            )
+
+
+def serialize_warning_message(warning_message):
+    if isinstance(warning_message.message, Warning):
+        message_module = type(warning_message.message).__module__
+        message_class_name = type(warning_message.message).__name__
+        message_str = str(warning_message.message)
+        # check now if we can serialize the warning arguments (#349)
+        # if not, we will just use the exception message on the master node
+        try:
+            dumps(warning_message.message.args)
+        except DumpError:
+            message_args = None
+        else:
+            message_args = warning_message.message.args
+    else:
+        message_str = warning_message.message
+        message_module = None
+        message_class_name = None
+        message_args = None
+    if warning_message.category:
+        category_module = warning_message.category.__module__
+        category_class_name = warning_message.category.__name__
+    else:
+        category_module = None
+        category_class_name = None
+
+    result = {
+        "message_str": message_str,
+        "message_module": message_module,
+        "message_class_name": message_class_name,
+        "message_args": message_args,
+        "category_module": category_module,
+        "category_class_name": category_class_name,
+    }
+    # access private _WARNING_DETAILS because the attributes vary between Python versions
+    for attr_name in warning_message._WARNING_DETAILS:
+        if attr_name in ("message", "category"):
+            continue
+        attr = getattr(warning_message, attr_name)
+        # Check if we can serialize the warning detail, marking `None` otherwise
+        # Note that we need to define the attr (even as `None`) to allow deserializing
+        try:
+            dumps(attr)
+        except DumpError:
+            result[attr_name] = repr(attr)
+        else:
+            result[attr_name] = attr
+    return result
+
+
+def getinfodict():
+    import platform
+
+    return dict(
+        version=sys.version,
+        version_info=tuple(sys.version_info),
+        sysplatform=sys.platform,
+        platform=platform.platform(),
+        executable=sys.executable,
+        cwd=os.getcwd(),
+    )
+
+
+def remote_initconfig(option_dict, args):
+    option_dict["plugins"].append("no:terminal")
+    return Config.fromdictargs(option_dict, args)
+
+
+def setup_config(config, basetemp):
+    config.option.looponfail = False
+    config.option.usepdb = False
+    config.option.dist = "no"
+    config.option.distload = False
+    config.option.numprocesses = None
+    config.option.maxprocesses = None
+    config.option.basetemp = basetemp
+
+
+if __name__ == "__channelexec__":
+    channel = channel  # noqa
+    workerinput, args, option_dict, change_sys_path = channel.receive()
+
+    if change_sys_path:
+        importpath = os.getcwd()
+        sys.path.insert(0, importpath)
+        os.environ["PYTHONPATH"] = (
+            importpath + os.pathsep + os.environ.get("PYTHONPATH", "")
+        )
+
+    os.environ["PYTEST_XDIST_TESTRUNUID"] = workerinput["testrunuid"]
+    os.environ["PYTEST_XDIST_WORKER"] = workerinput["workerid"]
+    os.environ["PYTEST_XDIST_WORKER_COUNT"] = str(workerinput["workercount"])
+
+    if hasattr(Config, "InvocationParams"):
+        config = _prepareconfig(args, None)
+    else:
+        config = remote_initconfig(option_dict, args)
+        config.args = args
+
+    setup_config(config, option_dict.get("basetemp"))
+    config._parser.prog = os.path.basename(workerinput["mainargv"][0])
+    config.workerinput = workerinput
+    config.workeroutput = {}
+    # TODO: deprecated name, backward compatibility only. Remove it in future
+    config.slaveinput = config.workerinput
+    config.slaveoutput = config.workeroutput
+    interactor = WorkerInteractor(config, channel)
+    config.hook.pytest_cmdline_main(config=config)

src/xdist/report.py

@@ -1,4 +1,4 @@
-import py
+from __future__ import print_function
 from difflib import unified_diff
 
 
@@ -11,16 +11,11 @@ def report_collection_diff(from_collection, to_collection, from_id, to_id):
     if from_collection == to_collection:
         return None
 
-    diff = unified_diff(
-        from_collection,
-        to_collection,
-        fromfile=from_id,
-        tofile=to_id,
-    )
-    error_message = py.builtin._totext(
-        'Different tests were collected between {from_id} and {to_id}. '
-        'The difference is:\n'
-        '{diff}'
-    ).format(from_id=from_id, to_id=to_id, diff='\n'.join(diff))
+    diff = unified_diff(from_collection, to_collection, fromfile=from_id, tofile=to_id)
+    error_message = (
+        u"Different tests were collected between {from_id} and {to_id}. "
+        u"The difference is:\n"
+        u"{diff}"
+    ).format(from_id=from_id, to_id=to_id, diff="\n".join(diff))
     msg = "\n".join([x.rstrip() for x in error_message.split("\n")])
     return msg

src/xdist/scheduler/__init__.py

@@ -1,4 +1,4 @@
 from xdist.scheduler.each import EachScheduling  # noqa
 from xdist.scheduler.load import LoadScheduling  # noqa
+from xdist.scheduler.loadfile import LoadFileScheduling  # noqa
 from xdist.scheduler.loadscope import LoadScopeScheduling  # noqa
-from xdist.scheduler.filescope import LoadFileScheduling  # noqa

src/xdist/scheduler/each.py

@@ -4,7 +4,7 @@ from xdist.workermanage import parse_spec_config
 from xdist.report import report_collection_diff
 
 
-class EachScheduling:
+class EachScheduling(object):
     """Implement scheduling of test items on all nodes
 
     If a node gets added after the test run is started then it is
@@ -86,10 +86,12 @@ class EachScheduling:
                 if deadnode.gateway.spec == node.gateway.spec:
                     dead_collection = self.node2collection[deadnode]
                     if collection != dead_collection:
-                        msg = report_collection_diff(dead_collection,
-                                                     collection,
-                                                     deadnode.gateway.id,
-                                                     node.gateway.id)
+                        msg = report_collection_diff(
+                            dead_collection,
+                            collection,
+                            deadnode.gateway.id,
+                            node.gateway.id,
+                        )
                         self.log(msg)
                         return
                     pending = self._removed2pending.pop(deadnode)
@@ -124,6 +126,7 @@ class EachScheduling:
             if not pending:
                 pending[:] = range(len(self.node2collection[node]))
                 node.send_runtest_all()
+                node.shutdown()
             else:
                 node.send_runtest_some(pending)
             self._started.append(node)

src/xdist/scheduler/load.py

@@ -7,7 +7,7 @@ from xdist.workermanage import parse_spec_config
 from xdist.report import report_collection_diff
 
 
-class LoadScheduling:
+class LoadScheduling(object):
     """Implement load scheduling across nodes.
 
     This distributes the tests collected across all nodes so each test
@@ -133,10 +133,9 @@ class LoadScheduling:
             assert self.collection
             if collection != self.collection:
                 other_node = next(iter(self.node2collection.keys()))
-                msg = report_collection_diff(self.collection,
-                                             collection,
-                                             other_node.gateway.id,
-                                             node.gateway.id)
+                msg = report_collection_diff(
+                    self.collection, collection, other_node.gateway.id, node.gateway.id
+                )
                 self.log(msg)
                 return
         self.node2collection[node] = list(collection)
@@ -179,6 +178,9 @@ class LoadScheduling:
                     return
                 num_send = items_per_node_max - len(node_pending)
                 self._send_tests(node, num_send)
+        else:
+            node.shutdown()
+
         self.log("num items waiting for node:", len(self.pending))
 
     def remove_node(self, node):
@@ -226,7 +228,7 @@ class LoadScheduling:
 
         # XXX allow nodes to have different collections
         if not self._check_nodes_have_same_collection():
-            self.log('**Different tests collected, aborting run**')
+            self.log("**Different tests collected, aborting run**")
             return
 
         # Collections are identical, create the index of pending items.
@@ -238,8 +240,7 @@ class LoadScheduling:
         # Send a batch of tests to run. If we don't have at least two
         # tests per node, we have to send them all so that we can send
         # shutdown signals and get all nodes working.
-        initial_batch = max(len(self.pending) // 4,
-                            2 * len(self.nodes))
+        initial_batch = max(len(self.pending) // 4, 2 * len(self.nodes))
 
         # distribute tests round-robin up to the batch size
         # (or until we run out)
@@ -271,18 +272,15 @@ class LoadScheduling:
         same_collection = True
         for node, collection in node_collection_items[1:]:
             msg = report_collection_diff(
-                col,
-                collection,
-                first_node.gateway.id,
-                node.gateway.id,
+                col, collection, first_node.gateway.id, node.gateway.id
             )
             if msg:
                 same_collection = False
                 self.log(msg)
                 if self.config is not None:
                     rep = CollectReport(
-                        node.gateway.id, 'failed',
-                        longrepr=msg, result=[])
+                        node.gateway.id, "failed", longrepr=msg, result=[]
+                    )
                     self.config.hook.pytest_collectreport(report=rep)
 
         return same_collection

src/xdist/scheduler/loadfile.py

@@ -1,4 +1,4 @@
-from . import LoadScopeScheduling
+from .loadscope import LoadScopeScheduling
 from py.log import Producer
 
 
@@ -20,10 +20,10 @@ class LoadFileScheduling(LoadScopeScheduling):
     This class behaves very much like LoadScopeScheduling, but with a file-level scope.
     """
 
-    def __init(self, config, log=None):
+    def __init__(self, config, log=None):
         super(LoadFileScheduling, self).__init__(config, log)
         if log is None:
-            self.log = Producer('loadfilesched')
+            self.log = Producer("loadfilesched")
         else:
             self.log = log.loadfilesched
 
@@ -49,4 +49,4 @@ class LoadFileScheduling(LoadScopeScheduling):
             example/loadsuite/test/test_delta.py
             example/loadsuite/epsilon/__init__.py
         """
-        return nodeid.split('::', 1)[0]
+        return nodeid.split("::", 1)[0]

src/xdist/scheduler/loadscope.py

@@ -6,7 +6,7 @@ from xdist.report import report_collection_diff
 from xdist.workermanage import parse_spec_config
 
 
-class LoadScopeScheduling:
+class LoadScopeScheduling(object):
     """Implement load scheduling across nodes, but grouping test by scope.
 
     This distributes the tests collected across all nodes so each test is run
@@ -93,7 +93,7 @@ class LoadScopeScheduling:
         self.registered_collections = OrderedDict()
 
         if log is None:
-            self.log = Producer('loadscopesched')
+            self.log = Producer("loadscopesched")
         else:
             self.log = log.loadscopesched
 
@@ -187,8 +187,7 @@ class LoadScopeScheduling:
             break
         else:
             raise RuntimeError(
-                'Unable to identify crashitem on a workload with '
-                'pending items'
+                "Unable to identify crashitem on a workload with pending items"
             )
 
         # Made uncompleted work unit available again
@@ -224,10 +223,7 @@ class LoadScopeScheduling:
                 other_node = next(iter(self.registered_collections.keys()))
 
                 msg = report_collection_diff(
-                    self.collection,
-                    collection,
-                    other_node.gateway.id,
-                    node.gateway.id
+                    self.collection, collection, other_node.gateway.id, node.gateway.id
                 )
                 self.log(msg)
                 return
@@ -255,9 +251,7 @@ class LoadScopeScheduling:
         scope, work_unit = self.workqueue.popitem(last=False)
 
         # Keep track of the assigned work
-        assigned_to_node = self.assigned_work.setdefault(
-            node, default=OrderedDict()
-        )
+        assigned_to_node = self.assigned_work.setdefault(node, default=OrderedDict())
         assigned_to_node[scope] = work_unit
 
         # Ask the node to execute the workload
@@ -292,14 +286,11 @@ class LoadScopeScheduling:
             example/loadsuite/test/test_delta.py::Delta1
             example/loadsuite/epsilon/__init__.py
         """
-        return nodeid.rsplit('::', 1)[0]
+        return nodeid.rsplit("::", 1)[0]
 
     def _pending_of(self, workload):
         """Return the number of pending tests in a workload."""
-        pending = sum(
-            list(scope.values()).count(False)
-            for scope in workload.values()
-        )
+        pending = sum(list(scope.values()).count(False) for scope in workload.values())
         return pending
 
     def _reschedule(self, node):
@@ -315,9 +306,10 @@ class LoadScopeScheduling:
 
         # Check that more work is available
         if not self.workqueue:
+            node.shutdown()
             return
 
-        self.log('Number of units waiting for node:', len(self.workqueue))
+        self.log("Number of units waiting for node:", len(self.workqueue))
 
         # Check that the node is almost depleted of work
         # 2: Heuristic of minimum tests to enqueue more work
@@ -348,13 +340,11 @@ class LoadScopeScheduling:
 
         # Check that all nodes collected the same tests
         if not self._check_nodes_have_same_collection():
-            self.log('**Different tests collected, aborting run**')
+            self.log("**Different tests collected, aborting run**")
             return
 
         # Collections are identical, create the final list of items
-        self.collection = list(
-            next(iter(self.registered_collections.values()))
-        )
+        self.collection = list(next(iter(self.registered_collections.values())))
         if not self.collection:
             return
 
@@ -368,12 +358,12 @@ class LoadScopeScheduling:
         extra_nodes = len(self.nodes) - len(self.workqueue)
 
         if extra_nodes > 0:
-            self.log('Shuting down {0} nodes'.format(extra_nodes))
+            self.log("Shuting down {} nodes".format(extra_nodes))
 
             for _ in range(extra_nodes):
                 unused_node, assigned = self.assigned_work.popitem(last=True)
 
-                self.log('Shuting down unused node {0}'.format(unused_node))
+                self.log("Shuting down unused node {}".format(unused_node))
                 unused_node.shutdown()
 
         # Assign initial workload
@@ -402,10 +392,7 @@ class LoadScopeScheduling:
 
         for node, collection in node_collection_items[1:]:
             msg = report_collection_diff(
-                col,
-                collection,
-                first_node.gateway.id,
-                node.gateway.id,
+                col, collection, first_node.gateway.id, node.gateway.id
             )
             if not msg:
                 continue
@@ -416,12 +403,7 @@ class LoadScopeScheduling:
             if self.config is None:
                 continue
 
-            rep = CollectReport(
-                node.gateway.id,
-                'failed',
-                longrepr=msg,
-                result=[]
-            )
+            rep = CollectReport(node.gateway.id, "failed", longrepr=msg, result=[])
             self.config.hook.pytest_collectreport(report=rep)
 
         return same_collection

src/xdist/workermanage.py

@@ -1,13 +1,15 @@
+from __future__ import print_function
 import fnmatch
 import os
 import re
+import sys
+import uuid
 
 import py
 import pytest
 import execnet
-import xdist.remote
 
-from _pytest import runner  # XXX load dynamically
+import xdist.remote
 
 
 def parse_spec_config(config):
@@ -19,21 +21,24 @@ def parse_spec_config(config):
         except ValueError:
             xspeclist.append(xspec)
         else:
-            xspeclist.extend([xspec[i + 1:]] * num)
+            xspeclist.extend([xspec[i + 1 :]] * num)
     if not xspeclist:
         raise pytest.UsageError(
-            "MISSING test execution (tx) nodes: please specify --tx")
+            "MISSING test execution (tx) nodes: please specify --tx"
+        )
     return xspeclist
 
 
 class NodeManager(object):
     EXIT_TIMEOUT = 10
-    DEFAULT_IGNORES = ['.*', '*.pyc', '*.pyo', '*~']
+    DEFAULT_IGNORES = [".*", "*.pyc", "*.pyo", "*~"]
 
     def __init__(self, config, specs=None, defaultchdir="pyexecnetcache"):
         self.config = config
-        self._nodesready = py.std.threading.Event()
         self.trace = self.config.trace.get("nodemanager")
+        self.testrunuid = self.config.getoption("testrunuid")
+        if self.testrunuid is None:
+            self.testrunuid = uuid.uuid4().hex
         self.group = execnet.Group()
         if specs is None:
             specs = self._getxspecs()
@@ -47,7 +52,7 @@ class NodeManager(object):
             self.specs.append(spec)
         self.roots = self._getrsyncdirs()
         self.rsyncoptions = self._getrsyncoptions()
-        self._rsynced_specs = py.builtin.set()
+        self._rsynced_specs = set()
 
     def rsync_roots(self, gateway):
         """Rsync the set of roots to the node's gateway cwd."""
@@ -56,20 +61,16 @@ class NodeManager(object):
                 self.rsync(gateway, root, **self.rsyncoptions)
 
     def setup_nodes(self, putevent):
-        self.config.hook.pytest_xdist_setupnodes(config=self.config,
-                                                 specs=self.specs)
+        self.config.hook.pytest_xdist_setupnodes(config=self.config, specs=self.specs)
         self.trace("setting up nodes")
-        nodes = []
-        for spec in self.specs:
-            nodes.append(self.setup_node(spec, putevent))
-        return nodes
+        return [self.setup_node(spec, putevent) for spec in self.specs]
 
     def setup_node(self, spec, putevent):
         gw = self.group.makegateway(spec)
         self.config.hook.pytest_xdist_newgateway(gateway=gw)
         self.rsync_roots(gw)
         node = WorkerController(self, gw, self.config, putevent)
-        gw.node = node          # keep the node alive
+        gw.node = node  # keep the node alive
         node.setup()
         self.trace("started node %r" % node)
         return node
@@ -88,6 +89,7 @@ class NodeManager(object):
             return []
         import pytest
         import _pytest
+
         pytestpath = pytest.__file__.rstrip("co")
         pytestdir = py.path.local(_pytest.__file__).dirpath()
         config = self.config
@@ -100,7 +102,7 @@ class NodeManager(object):
         for root in candidates:
             root = py.path.local(root).realpath()
             if not root.check():
-                raise pytest.UsageError("rsyncdir doesn't exist: %r" % (root,))
+                raise pytest.UsageError("rsyncdir doesn't exist: {!r}".format(root))
             if root not in roots:
                 roots.append(root)
         return roots
@@ -112,8 +114,8 @@ class NodeManager(object):
         ignores += self.config.getini("rsyncignore")
 
         return {
-            'ignores': ignores,
-            'verbose': self.config.option.verbose,
+            "ignores": ignores,
+            "verbose": getattr(self.config.option, "verbose", False),
         }
 
     def rsync(self, gateway, source, notify=None, verbose=False, ignores=None):
@@ -126,9 +128,12 @@ class NodeManager(object):
         if spec.popen and not spec.chdir:
             # XXX This assumes that sources are python-packages
             #     and that adding the basedir does not hurt.
-            gateway.remote_exec("""
+            gateway.remote_exec(
+                """
                 import sys ; sys.path.insert(0, %r)
-            """ % os.path.dirname(str(source))).waitclose()
+            """
+                % os.path.dirname(str(source))
+            ).waitclose()
             return
         if (spec, source) in self._rsynced_specs:
             return
@@ -136,29 +141,24 @@ class NodeManager(object):
         def finished():
             if notify:
                 notify("rsyncrootready", spec, source)
+
         rsync.add_target_host(gateway, finished=finished)
         self._rsynced_specs.add((spec, source))
-        self.config.hook.pytest_xdist_rsyncstart(
-            source=source,
-            gateways=[gateway],
-        )
+        self.config.hook.pytest_xdist_rsyncstart(source=source, gateways=[gateway])
         rsync.send()
-        self.config.hook.pytest_xdist_rsyncfinish(
-            source=source,
-            gateways=[gateway],
-        )
+        self.config.hook.pytest_xdist_rsyncfinish(source=source, gateways=[gateway])
 
 
 class HostRSync(execnet.RSync):
     """ RSyncer that filters out common files
     """
+
     def __init__(self, sourcedir, *args, **kwargs):
         self._synced = {}
-        self._ignores = []
-        ignores = kwargs.pop('ignores', None) or []
-        for x in ignores:
-            x = getattr(x, 'strpath', x)
-            self._ignores.append(re.compile(fnmatch.translate(x)))
+        ignores = kwargs.pop("ignores", None) or []
+        self._ignores = [
+            re.compile(fnmatch.translate(getattr(x, "strpath", x))) for x in ignores
+        ]
         super(HostRSync, self).__init__(sourcedir=sourcedir, **kwargs)
 
     def filter(self, path):
@@ -171,32 +171,34 @@ class HostRSync(execnet.RSync):
 
     def add_target_host(self, gateway, finished=None):
         remotepath = os.path.basename(self._sourcedir)
-        super(HostRSync, self).add_target(gateway, remotepath,
-                                          finishedcallback=finished,
-                                          delete=True,)
+        super(HostRSync, self).add_target(
+            gateway, remotepath, finishedcallback=finished, delete=True
+        )
 
     def _report_send_file(self, gateway, modified_rel_path):
         if self._verbose:
             path = os.path.basename(self._sourcedir) + "/" + modified_rel_path
             remotepath = gateway.spec.chdir
-            py.builtin.print_('%s:%s <= %s' %
-                              (gateway.spec, remotepath, path))
+            print("{}:{} <= {}".format(gateway.spec, remotepath, path))
 
 
 def make_reltoroot(roots, args):
-    # XXX introduce/use public API for splitting py.test args
+    # XXX introduce/use public API for splitting pytest args
     splitcode = "::"
     result = []
     for arg in args:
         parts = arg.split(splitcode)
         fspath = py.path.local(parts[0])
+        if not fspath.exists():
+            result.append(arg)
+            continue
         for root in roots:
             x = fspath.relto(root)
             if x or fspath == root:
                 parts[0] = root.basename + "/" + x
                 break
         else:
-            raise ValueError("arg %s not relative to an rsync root" % (arg,))
+            raise ValueError("arg {} not relative to an rsync root".format(arg))
         result.append(splitcode.join(parts))
     return result
 
@@ -204,16 +206,25 @@ def make_reltoroot(roots, args):
 class WorkerController(object):
     ENDMARK = -1
 
+    class RemoteHook:
+        @pytest.mark.trylast
+        def pytest_xdist_getremotemodule(self):
+            return xdist.remote
+
     def __init__(self, nodemanager, gateway, config, putevent):
+        config.pluginmanager.register(self.RemoteHook())
         self.nodemanager = nodemanager
         self.putevent = putevent
         self.gateway = gateway
         self.config = config
-        self.workerinput = {'workerid': gateway.id,
-                            'workercount': len(nodemanager.specs),
-                            'slaveid': gateway.id,
-                            'slavecount': len(nodemanager.specs)
-                            }
+        self.workerinput = {
+            "workerid": gateway.id,
+            "workercount": len(nodemanager.specs),
+            "slaveid": gateway.id,
+            "slavecount": len(nodemanager.specs),
+            "testrunuid": nodemanager.testrunuid,
+            "mainargv": sys.argv,
+        }
         # TODO: deprecated name, backward compatibility only. Remove it in future
         self.slaveinput = self.workerinput
         self._down = False
@@ -223,7 +234,7 @@ class WorkerController(object):
             py.log.setconsumer(self.log._keywords, None)
 
     def __repr__(self):
-        return "<%s %s>" % (self.__class__.__name__, self.gateway.id,)
+        return "<{} {}>".format(self.__class__.__name__, self.gateway.id)
 
     @property
     def shutting_down(self):
@@ -232,30 +243,37 @@ class WorkerController(object):
     def setup(self):
         self.log("setting up worker session")
         spec = self.gateway.spec
-        args = self.config.args
+        if hasattr(self.config, "invocation_params"):
+            args = [str(x) for x in self.config.invocation_params.args or ()]
+            option_dict = {}
+        else:
+            args = self.config.args
+            option_dict = vars(self.config.option)
         if not spec.popen or spec.chdir:
             args = make_reltoroot(self.nodemanager.roots, args)
-        option_dict = vars(self.config.option)
         if spec.popen:
             name = "popen-%s" % self.gateway.id
-            if hasattr(self.config, '_tmpdirhandler'):
+            if hasattr(self.config, "_tmpdirhandler"):
                 basetemp = self.config._tmpdirhandler.getbasetemp()
-                option_dict['basetemp'] = str(basetemp.join(name))
+                option_dict["basetemp"] = str(basetemp.join(name))
         self.config.hook.pytest_configure_node(node=self)
-        self.channel = self.gateway.remote_exec(xdist.remote)
-        self.channel.send((self.workerinput, args, option_dict))
+
+        remote_module = self.config.hook.pytest_xdist_getremotemodule()
+        self.channel = self.gateway.remote_exec(remote_module)
+        # change sys.path only for remote workers
+        change_sys_path = not self.gateway.spec.popen
+        self.channel.send((self.workerinput, args, option_dict, change_sys_path))
+
         if self.putevent:
-            self.channel.setcallback(
-                self.process_from_remote,
-                endmarker=self.ENDMARK)
+            self.channel.setcallback(self.process_from_remote, endmarker=self.ENDMARK)
 
     def ensure_teardown(self):
-        if hasattr(self, 'channel'):
+        if hasattr(self, "channel"):
             if not self.channel.isclosed():
                 self.log("closing", self.channel)
                 self.channel.close()
             # del self.channel
-        if hasattr(self, 'gateway'):
+        if hasattr(self, "gateway"):
             self.log("exiting", self.gateway)
             self.gateway.exit()
             # del self.gateway
@@ -264,23 +282,23 @@ class WorkerController(object):
         self.sendcommand("runtests", indices=indices)
 
     def send_runtest_all(self):
-        self.sendcommand("runtests_all",)
+        self.sendcommand("runtests_all")
 
     def shutdown(self):
         if not self._down:
             try:
                 self.sendcommand("shutdown")
-            except IOError:
+            except (IOError, OSError):
                 pass
             self._shutdown_sent = True
 
     def sendcommand(self, name, **kwargs):
         """ send a named parametrized command to the other side. """
-        self.log("sending command %s(**%s)" % (name, kwargs))
+        self.log("sending command {}(**{})".format(name, kwargs))
         self.channel.send((name, kwargs))
 
     def notify_inproc(self, eventname, **kwargs):
-        self.log("queuing %s(**%s)" % (eventname, kwargs))
+        self.log("queuing {}(**{})".format(eventname, kwargs))
         self.putevent((eventname, kwargs))
 
     def process_from_remote(self, eventcall):  # noqa too complex
@@ -302,119 +320,112 @@ class WorkerController(object):
                 return
             eventname, kwargs = eventcall
             if eventname in ("collectionstart",):
-                self.log("ignoring %s(%s)" % (eventname, kwargs))
+                self.log("ignoring {}({})".format(eventname, kwargs))
             elif eventname == "workerready":
                 self.notify_inproc(eventname, node=self, **kwargs)
             elif eventname == "workerfinished":
                 self._down = True
-                self.workeroutput = self.slaveoutput = kwargs['workeroutput']
+                self.workeroutput = self.slaveoutput = kwargs["workeroutput"]
                 self.notify_inproc("workerfinished", node=self)
             elif eventname in ("logstart", "logfinish"):
                 self.notify_inproc(eventname, node=self, **kwargs)
-            elif eventname in (
-                    "testreport", "collectreport", "teardownreport"):
+            elif eventname in ("testreport", "collectreport", "teardownreport"):
                 item_index = kwargs.pop("item_index", None)
-                rep = unserialize_report(eventname, kwargs['data'])
+                rep = self.config.hook.pytest_report_from_serializable(
+                    config=self.config, data=kwargs["data"]
+                )
                 if item_index is not None:
                     rep.item_index = item_index
                 self.notify_inproc(eventname, node=self, rep=rep)
             elif eventname == "collectionfinish":
-                self.notify_inproc(eventname, node=self, ids=kwargs['ids'])
+                self.notify_inproc(eventname, node=self, ids=kwargs["ids"])
             elif eventname == "runtest_protocol_complete":
                 self.notify_inproc(eventname, node=self, **kwargs)
             elif eventname == "logwarning":
-                self.notify_inproc(eventname, message=kwargs['message'],
-                                   code=kwargs['code'], nodeid=kwargs['nodeid'],
-                                   fslocation=kwargs['nodeid'])
+                self.notify_inproc(
+                    eventname,
+                    message=kwargs["message"],
+                    code=kwargs["code"],
+                    nodeid=kwargs["nodeid"],
+                    fslocation=kwargs["nodeid"],
+                )
+            elif eventname == "warning_captured":
+                warning_message = unserialize_warning_message(
+                    kwargs["warning_message_data"]
+                )
+                self.notify_inproc(
+                    eventname,
+                    warning_message=warning_message,
+                    when=kwargs["when"],
+                    item=kwargs["item"],
+                )
+            elif eventname == "warning_recorded":
+                warning_message = unserialize_warning_message(
+                    kwargs["warning_message_data"]
+                )
+                self.notify_inproc(
+                    eventname,
+                    warning_message=warning_message,
+                    when=kwargs["when"],
+                    nodeid=kwargs["nodeid"],
+                    location=kwargs["location"],
+                )
             else:
-                raise ValueError("unknown event: %s" % (eventname,))
+                raise ValueError("unknown event: {}".format(eventname))
         except KeyboardInterrupt:
             # should not land in receiver-thread
             raise
         except:  # noqa
-            excinfo = py.code.ExceptionInfo()
-            py.builtin.print_("!" * 20, excinfo)
+            from _pytest._code import ExceptionInfo
+
+            # ExceptionInfo API changed in pytest 4.1
+            if hasattr(ExceptionInfo, "from_current"):
+                excinfo = ExceptionInfo.from_current()
+            else:
+                excinfo = ExceptionInfo()
+            print("!" * 20, excinfo)
             self.config.notify_exception(excinfo)
             self.shutdown()
             self.notify_inproc("errordown", node=self, error=excinfo)
 
 
-def unserialize_report(name, reportdict):
-    def assembled_report(reportdict):
-        from _pytest._code.code import (
-            ReprEntry,
-            ReprEntryNative,
-            ReprExceptionInfo,
-            ReprFileLocation,
-            ReprFuncArgs,
-            ReprLocals,
-            ReprTraceback
-        )
-        if reportdict['longrepr']:
-            if 'reprcrash' in reportdict['longrepr'] and 'reprtraceback' in reportdict['longrepr']:
+def unserialize_warning_message(data):
+    import warnings
+    import importlib
 
-                reprtraceback = reportdict['longrepr']['reprtraceback']
-                reprcrash = reportdict['longrepr']['reprcrash']
+    if data["message_module"]:
+        mod = importlib.import_module(data["message_module"])
+        cls = getattr(mod, data["message_class_name"])
+        message = None
+        if data["message_args"] is not None:
+            try:
+                message = cls(*data["message_args"])
+            except TypeError:
+                pass
+        if message is None:
+            # could not recreate the original warning instance;
+            # create a generic Warning instance with the original
+            # message at least
+            message_text = "{mod}.{cls}: {msg}".format(
+                mod=data["message_module"],
+                cls=data["message_class_name"],
+                msg=data["message_str"],
+            )
+            message = Warning(message_text)
+    else:
+        message = data["message_str"]
 
-                unserialized_entries = []
-                reprentry = None
-                for entry_data in reprtraceback['reprentries']:
-                    data = entry_data['data']
-                    entry_type = entry_data['type']
-                    if entry_type == 'ReprEntry':
-                        reprfuncargs = None
-                        reprfileloc = None
-                        reprlocals = None
-                        if data['reprfuncargs']:
-                            reprfuncargs = ReprFuncArgs(
-                                **data['reprfuncargs'])
-                        if data['reprfileloc']:
-                            reprfileloc = ReprFileLocation(
-                                **data['reprfileloc'])
-                        if data['reprlocals']:
-                            reprlocals = ReprLocals(
-                                data['reprlocals']['lines'])
+    if data["category_module"]:
+        mod = importlib.import_module(data["category_module"])
+        category = getattr(mod, data["category_class_name"])
+    else:
+        category = None
 
-                        reprentry = ReprEntry(
-                            lines=data['lines'],
-                            reprfuncargs=reprfuncargs,
-                            reprlocals=reprlocals,
-                            filelocrepr=reprfileloc,
-                            style=data['style']
-                        )
-                    elif entry_type == 'ReprEntryNative':
-                        reprentry = ReprEntryNative(data['lines'])
-                    else:
-                        report_unserialization_failure(
-                            entry_type, name, reportdict)
-                    unserialized_entries.append(reprentry)
-                reprtraceback['reprentries'] = unserialized_entries
+    kwargs = {"message": message, "category": category}
+    # access private _WARNING_DETAILS because the attributes vary between Python versions
+    for attr_name in warnings.WarningMessage._WARNING_DETAILS:
+        if attr_name in ("message", "category"):
+            continue
+        kwargs[attr_name] = data[attr_name]
 
-                exception_info = ReprExceptionInfo(
-                    reprtraceback=ReprTraceback(**reprtraceback),
-                    reprcrash=ReprFileLocation(**reprcrash),
-                )
-
-                for section in reportdict['longrepr']['sections']:
-                    exception_info.addsection(*section)
-                reportdict['longrepr'] = exception_info
-        return reportdict
-
-    if name == "testreport":
-        return runner.TestReport(**assembled_report(reportdict))
-    elif name == "collectreport":
-        return runner.CollectReport(**assembled_report(reportdict))
-
-
-def report_unserialization_failure(type_name, report_name, reportdict):
-    from pprint import pprint
-    url = 'https://github.com/pytest-dev/pytest-xdist/issues'
-    stream = py.io.TextIO()
-    pprint('-' * 100, stream=stream)
-    pprint('INTERNALERROR: Unknown entry type returned: %s' % type_name,
-           stream=stream)
-    pprint('report_name: %s' % report_name, stream=stream)
-    pprint(reportdict, stream=stream)
-    pprint('Please report this bug at %s' % url, stream=stream)
-    pprint('-' * 100, stream=stream)
-    assert 0, stream.getvalue()
+    return warnings.WarningMessage(**kwargs)

testing/conftest.py

@@ -1,40 +1,46 @@
+import six
 import py
 import pytest
 import execnet
 
-
-@pytest.fixture(scope="session", autouse=True)
-def _ensure_imports():
-    # we import some modules because pytest-2.8's testdir fixture
-    # will unload all modules after each test and this cause
-    # (unknown) problems with execnet.Group()
-    execnet.Group
-    execnet.makegateway
-
-
 pytest_plugins = "pytester"
 
-# rsyncdirs = ['.', '../xdist', py.path.local(execnet.__file__).dirpath()]
+if six.PY2:
+
+    @pytest.fixture(scope="session", autouse=True)
+    def _ensure_imports():
+        # we import some modules because pytest-2.8's testdir fixture
+        # will unload all modules after each test and this cause
+        # (unknown) problems with execnet.Group()
+        execnet.Group
+        execnet.makegateway
 
 
 @pytest.fixture(autouse=True)
 def _divert_atexit(request, monkeypatch):
     import atexit
+
     finalizers = []
 
-    def finish():
-        while finalizers:
-            finalizers.pop()()
+    def fake_register(func, *args, **kwargs):
+        finalizers.append((func, args, kwargs))
 
-    monkeypatch.setattr(atexit, "register", finalizers.append)
-    request.addfinalizer(finish)
+    monkeypatch.setattr(atexit, "register", fake_register)
+
+    yield
+
+    while finalizers:
+        func, args, kwargs = finalizers.pop()
+        func(*args, **kwargs)
 
 
 def pytest_addoption(parser):
-    parser.addoption('--gx',
-                     action="append",
-                     dest="gspecs",
-                     help="add a global test environment, XSpec-syntax. ")
+    parser.addoption(
+        "--gx",
+        action="append",
+        dest="gspecs",
+        help="add a global test environment, XSpec-syntax. ",
+    )
 
 
 @pytest.fixture
@@ -42,14 +48,6 @@ def specssh(request):
     return getspecssh(request.config)
 
 
-@pytest.fixture
-def testdir(testdir):
-    # pytest before 2.8 did not have a runpytest_subprocess
-    if not hasattr(testdir, "runpytest_subprocess"):
-        testdir.runpytest_subprocess = testdir.runpytest
-    return testdir
-
-
 # configuration information for tests
 def getgspecs(config):
     return [execnet.XSpec(spec) for spec in config.getvalueorskip("gspecs")]

testing/test_dsession.py

@@ -1,9 +1,6 @@
-from xdist.dsession import DSession
+from xdist.dsession import DSession, get_default_max_worker_restart
 from xdist.report import report_collection_diff
-from xdist.scheduler import (
-    EachScheduling,
-    LoadScheduling,
-)
+from xdist.scheduler import EachScheduling, LoadScheduling
 
 import py
 import pytest
@@ -60,7 +57,7 @@ class TestEachScheduling:
         sched = EachScheduling(config)
         sched.add_node(node1)
         sched.add_node(node2)
-        collection = ["a.py::test_1", ]
+        collection = ["a.py::test_1"]
         assert not sched.collection_is_completed
         sched.add_node_collection(node1, collection)
         assert not sched.collection_is_completed
@@ -70,8 +67,8 @@ class TestEachScheduling:
         assert sched.node2collection[node2] == collection
         sched.schedule()
         assert sched.tests_finished
-        assert node1.sent == ['ALL']
-        assert node2.sent == ['ALL']
+        assert node1.sent == ["ALL"]
+        assert node2.sent == ["ALL"]
         sched.mark_test_complete(node1, 0)
         assert sched.tests_finished
         sched.mark_test_complete(node2, 0)
@@ -82,7 +79,7 @@ class TestEachScheduling:
         config = testdir.parseconfig("--tx=popen")
         sched = EachScheduling(config)
         sched.add_node(node1)
-        collection = ["a.py::test_1", ]
+        collection = ["a.py::test_1"]
         assert not sched.collection_is_completed
         sched.add_node_collection(node1, collection)
         assert sched.collection_is_completed
@@ -230,7 +227,7 @@ class TestLoadScheduling:
         sched.schedule()
         assert len(collect_hook.reports) == 1
         rep = collect_hook.reports[0]
-        assert 'Different tests were collected between' in rep.longrepr
+        assert "Different tests were collected between" in rep.longrepr
 
 
 class TestDistReporter:
@@ -238,6 +235,7 @@ class TestDistReporter:
     def test_rsync_printing(self, testdir, linecomp):
         config = testdir.parseconfig()
         from _pytest.pytest_terminal import TerminalReporter
+
         rep = TerminalReporter(config, file=linecomp.stringio)
         config.pluginmanager.register(rep, "terminalreporter")
         dsession = DSession(config)
@@ -249,6 +247,7 @@ class TestDistReporter:
         class gw2:
             id = "X2"
             spec = execnet.XSpec("popen")
+
         # class rinfo:
         #    version_info = (2, 5, 1, 'final', 0)
         #    executable = "hello"
@@ -260,47 +259,68 @@ class TestDistReporter:
         #     "*X1*popen*xyz*2.5*"
         # ])
         dsession.pytest_xdist_rsyncstart(source="hello", gateways=[gw1, gw2])
-        linecomp.assert_contains_lines(["[X1,X2] rsyncing: hello", ])
+        linecomp.assert_contains_lines(["[X1,X2] rsyncing: hello"])
 
 
 def test_report_collection_diff_equal():
     """Test reporting of equal collections."""
-    from_collection = to_collection = ['aaa', 'bbb', 'ccc']
+    from_collection = to_collection = ["aaa", "bbb", "ccc"]
     assert report_collection_diff(from_collection, to_collection, 1, 2) is None
 
 
+def test_default_max_worker_restart():
+    class config:
+        class option:
+            maxworkerrestart = None
+            numprocesses = 0
+
+    assert get_default_max_worker_restart(config) is None
+
+    config.option.numprocesses = 2
+    assert get_default_max_worker_restart(config) == 8
+
+    config.option.maxworkerrestart = "1"
+    assert get_default_max_worker_restart(config) == 1
+
+    config.option.maxworkerrestart = "0"
+    assert get_default_max_worker_restart(config) == 0
+
+
 def test_report_collection_diff_different():
     """Test reporting of different collections."""
-    from_collection = ['aaa', 'bbb', 'ccc', 'YYY']
-    to_collection = ['aZa', 'bbb', 'XXX', 'ccc']
+    from_collection = ["aaa", "bbb", "ccc", "YYY"]
+    to_collection = ["aZa", "bbb", "XXX", "ccc"]
     error_message = (
-        'Different tests were collected between 1 and 2. The difference is:\n'
-        '--- 1\n'
-        '\n'
-        '+++ 2\n'
-        '\n'
-        '@@ -1,4 +1,4 @@\n'
-        '\n'
-        '-aaa\n'
-        '+aZa\n'
-        ' bbb\n'
-        '+XXX\n'
-        ' ccc\n'
-        '-YYY')
+        "Different tests were collected between 1 and 2. The difference is:\n"
+        "--- 1\n"
+        "\n"
+        "+++ 2\n"
+        "\n"
+        "@@ -1,4 +1,4 @@\n"
+        "\n"
+        "-aaa\n"
+        "+aZa\n"
+        " bbb\n"
+        "+XXX\n"
+        " ccc\n"
+        "-YYY"
+    )
 
-    msg = report_collection_diff(from_collection, to_collection, '1', '2')
+    msg = report_collection_diff(from_collection, to_collection, "1", "2")
     assert msg == error_message
 
 
 @pytest.mark.xfail(reason="duplicate test ids not supported yet")
 def test_pytest_issue419(testdir):
-    testdir.makepyfile("""
+    testdir.makepyfile(
+        """
         import pytest
 
         @pytest.mark.parametrize('birth_year', [1988, 1988, ])
         def test_2011_table(birth_year):
             pass
-    """)
+    """
+    )
     reprec = testdir.inline_run("-n1")
     reprec.assertoutcome(passed=2)
     assert 0

testing/test_looponfail.py

@@ -1,4 +1,7 @@
 import py
+import pytest
+from pkg_resources import parse_version
+
 from xdist.looponfail import RemoteControl
 from xdist.looponfail import StatRecorder
 
@@ -60,7 +63,7 @@ class TestStatRecorder:
         p.remove()
         # make check()'s visit() call return our just removed
         # path as if we were in a race condition
-        monkeypatch.setattr(tmp, 'visit', lambda *args: [p])
+        monkeypatch.setattr(tmp, "visit", lambda *args: [p])
 
         changed = sd.check()
         assert changed
@@ -84,7 +87,7 @@ class TestStatRecorder:
         sd = StatRecorder([tmp])
 
         ret_values = [True, False]
-        monkeypatch.setattr(StatRecorder, 'check', lambda self: ret_values.pop())
+        monkeypatch.setattr(StatRecorder, "check", lambda self: ret_values.pop())
         sd.waitonchange(checkinterval=0.2)
         assert not ret_values
 
@@ -110,19 +113,25 @@ class TestRemoteControl:
         assert not failures
 
     def test_failure_change(self, testdir):
-        modcol = testdir.getitem("""
+        modcol = testdir.getitem(
+            """
             def test_func():
                 assert 0
-        """)
+        """
+        )
         control = RemoteControl(modcol.config)
         control.loop_once()
         assert control.failures
-        modcol.fspath.write(py.code.Source("""
+        modcol.fspath.write(
+            py.code.Source(
+                """
             def test_func():
                 assert 1
             def test_new():
                 assert 0
-        """))
+        """
+            )
+        )
         removepyc(modcol.fspath)
         control.loop_once()
         assert not control.failures
@@ -131,14 +140,17 @@ class TestRemoteControl:
         assert str(control.failures).find("test_new") != -1
 
     def test_failure_subdir_no_init(self, testdir):
-        modcol = testdir.getitem("""
+        modcol = testdir.getitem(
+            """
             def test_func():
                 assert 0
-        """)
+        """
+        )
         parent = modcol.fspath.dirpath().dirpath()
         parent.chdir()
-        modcol.config.args = [py.path.local(x).relto(parent)
-                              for x in modcol.config.args]
+        modcol.config.args = [
+            py.path.local(x).relto(parent) for x in modcol.config.args
+        ]
         control = RemoteControl(modcol.config)
         control.loop_once()
         assert control.failures
@@ -148,70 +160,91 @@ class TestRemoteControl:
 
 class TestLooponFailing:
     def test_looponfail_from_fail_to_ok(self, testdir):
-        modcol = testdir.getmodulecol("""
+        modcol = testdir.getmodulecol(
+            """
             def test_one():
                 x = 0
                 assert x == 1
             def test_two():
                 assert 1
-        """)
+        """
+        )
         remotecontrol = RemoteControl(modcol.config)
         remotecontrol.loop_once()
         assert len(remotecontrol.failures) == 1
 
-        modcol.fspath.write(py.code.Source("""
+        modcol.fspath.write(
+            py.code.Source(
+                """
             def test_one():
                 assert 1
             def test_two():
                 assert 1
-        """))
+        """
+            )
+        )
         removepyc(modcol.fspath)
         remotecontrol.loop_once()
         assert not remotecontrol.failures
 
     def test_looponfail_from_one_to_two_tests(self, testdir):
-        modcol = testdir.getmodulecol("""
+        modcol = testdir.getmodulecol(
+            """
             def test_one():
                 assert 0
-        """)
+        """
+        )
         remotecontrol = RemoteControl(modcol.config)
         remotecontrol.loop_once()
         assert len(remotecontrol.failures) == 1
-        assert 'test_one' in remotecontrol.failures[0]
+        assert "test_one" in remotecontrol.failures[0]
 
-        modcol.fspath.write(py.code.Source("""
+        modcol.fspath.write(
+            py.code.Source(
+                """
             def test_one():
                 assert 1 # passes now
             def test_two():
                 assert 0 # new and fails
-        """))
+        """
+            )
+        )
         removepyc(modcol.fspath)
         remotecontrol.loop_once()
         assert len(remotecontrol.failures) == 0
         remotecontrol.loop_once()
         assert len(remotecontrol.failures) == 1
-        assert 'test_one' not in remotecontrol.failures[0]
-        assert 'test_two' in remotecontrol.failures[0]
+        assert "test_one" not in remotecontrol.failures[0]
+        assert "test_two" in remotecontrol.failures[0]
 
-    @py.test.mark.xfail(py.test.__version__ >= "3.1",
-                        reason="broken by pytest 3.1+")
+    @pytest.mark.xfail(
+        parse_version(pytest.__version__) >= parse_version("3.1"),
+        reason="broken by pytest 3.1+",
+        strict=True,
+    )
     def test_looponfail_removed_test(self, testdir):
-        modcol = testdir.getmodulecol("""
+        modcol = testdir.getmodulecol(
+            """
             def test_one():
                 assert 0
             def test_two():
                 assert 0
-        """)
+        """
+        )
         remotecontrol = RemoteControl(modcol.config)
         remotecontrol.loop_once()
         assert len(remotecontrol.failures) == 2
 
-        modcol.fspath.write(py.code.Source("""
+        modcol.fspath.write(
+            py.code.Source(
+                """
             def test_xxx(): # renamed test
                 assert 0
             def test_two():
                 assert 1 # pass now
-        """))
+        """
+            )
+        )
         removepyc(modcol.fspath)
         remotecontrol.loop_once()
         assert len(remotecontrol.failures) == 0
@@ -220,10 +253,12 @@ class TestLooponFailing:
         assert len(remotecontrol.failures) == 1
 
     def test_looponfail_multiple_errors(self, testdir, monkeypatch):
-        modcol = testdir.getmodulecol("""
+        modcol = testdir.getmodulecol(
+            """
             def test_one():
                 assert 0
-        """)
+        """
+        )
         remotecontrol = RemoteControl(modcol.config)
         orig_runsession = remotecontrol.runsession
 
@@ -233,18 +268,20 @@ class TestLooponFailing:
             print(failures)
             return failures * 2, reports, collection_failed
 
-        monkeypatch.setattr(remotecontrol, 'runsession', runsession_dups)
+        monkeypatch.setattr(remotecontrol, "runsession", runsession_dups)
         remotecontrol.loop_once()
         assert len(remotecontrol.failures) == 1
 
 
 class TestFunctional:
     def test_fail_to_ok(self, testdir):
-        p = testdir.makepyfile("""
+        p = testdir.makepyfile(
+            """
             def test_one():
                 x = 0
                 assert x == 1
-        """)
+        """
+        )
         # p = testdir.mkdir("sub").join(p1.basename)
         # p1.move(p)
         child = testdir.spawn_pytest("-f %s --traceconfig" % p)
@@ -253,21 +290,27 @@ class TestFunctional:
         child.expect("1 failed")
         child.expect("### LOOPONFAILING ####")
         child.expect("waiting for changes")
-        p.write(py.code.Source("""
+        p.write(
+            py.code.Source(
+                """
             def test_one():
                 x = 1
                 assert x == 1
-        """))
+        """
+            )
+        )
         child.expect(".*1 passed.*")
         child.kill(15)
 
     def test_xfail_passes(self, testdir):
-        p = testdir.makepyfile("""
+        p = testdir.makepyfile(
+            """
             import py
             @py.test.mark.xfail
             def test_one():
                 pass
-        """)
+        """
+        )
         child = testdir.spawn_pytest("-f %s" % p)
         child.expect("1 xpass")
         # child.expect("### LOOPONFAILING ####")

testing/test_newhooks.py

@@ -2,54 +2,62 @@ import pytest
 
 
 class TestHooks:
-
     @pytest.fixture(autouse=True)
     def create_test_file(self, testdir):
-        testdir.makepyfile("""
+        testdir.makepyfile(
+            """
             import os
             def test_a(): pass
             def test_b(): pass
             def test_c(): pass
-        """)
+        """
+        )
 
     def test_runtest_logreport(self, testdir):
         """Test that log reports from pytest_runtest_logreport when running
-        with xdist contain "node", "nodeid" and "worker_id" attributes. (#8)
+        with xdist contain "node", "nodeid", "worker_id", and "testrun_uid" attributes. (#8)
         """
-        testdir.makeconftest("""
+        testdir.makeconftest(
+            """
             def pytest_runtest_logreport(report):
                 if hasattr(report, 'node'):
                     if report.when == "call":
                         workerid = report.node.workerinput['workerid']
+                        testrunuid = report.node.workerinput['testrunuid']
                         if workerid != report.worker_id:
                             print("HOOK: Worker id mismatch: %s %s"
                                    % (workerid, report.worker_id))
+                        elif testrunuid != report.testrun_uid:
+                            print("HOOK: Testrun uid mismatch: %s %s"
+                                   % (testrunuid, report.testrun_uid))
                         else:
-                            print("HOOK: %s %s"
-                                   % (report.nodeid, report.worker_id))
-        """)
-        res = testdir.runpytest('-n1', '-s')
-        res.stdout.fnmatch_lines([
-            '*HOOK: test_runtest_logreport.py::test_a gw0*',
-            '*HOOK: test_runtest_logreport.py::test_b gw0*',
-            '*HOOK: test_runtest_logreport.py::test_c gw0*',
-            '*3 passed*',
-        ])
+                            print("HOOK: %s %s %s"
+                                   % (report.nodeid, report.worker_id, report.testrun_uid))
+        """
+        )
+        res = testdir.runpytest("-n1", "-s")
+        res.stdout.fnmatch_lines(
+            [
+                "*HOOK: test_runtest_logreport.py::test_a gw0 *",
+                "*HOOK: test_runtest_logreport.py::test_b gw0 *",
+                "*HOOK: test_runtest_logreport.py::test_c gw0 *",
+                "*3 passed*",
+            ]
+        )
 
     def test_node_collection_finished(self, testdir):
         """Test pytest_xdist_node_collection_finished hook (#8).
         """
-        testdir.makeconftest("""
+        testdir.makeconftest(
+            """
             def pytest_xdist_node_collection_finished(node, ids):
                 workerid = node.workerinput['workerid']
                 stripped_ids = [x.split('::')[1] for x in ids]
                 print("HOOK: %s %s" % (workerid, ', '.join(stripped_ids)))
-        """)
-        res = testdir.runpytest('-n2', '-s')
-        res.stdout.fnmatch_lines_random([
-            '*HOOK: gw0 test_a, test_b, test_c',
-            '*HOOK: gw1 test_a, test_b, test_c',
-        ])
-        res.stdout.fnmatch_lines([
-            '*3 passed*',
-        ])
+        """
+        )
+        res = testdir.runpytest("-n2", "-s")
+        res.stdout.fnmatch_lines_random(
+            ["*HOOK: gw0 test_a, test_b, test_c", "*HOOK: gw1 test_a, test_b, test_c"]
+        )
+        res.stdout.fnmatch_lines(["*3 passed*"])

testing/test_plugin.py

@@ -16,14 +16,19 @@ def test_dist_incompatibility_messages(testdir):
 
 def test_dist_options(testdir):
     from xdist.plugin import pytest_cmdline_main as check_options
+
     config = testdir.parseconfigure("-n 2")
     check_options(config)
     assert config.option.dist == "load"
-    assert config.option.tx == ['popen'] * 2
+    assert config.option.tx == ["popen"] * 2
     config = testdir.parseconfigure("--numprocesses", "2")
     check_options(config)
     assert config.option.dist == "load"
-    assert config.option.tx == ['popen'] * 2
+    assert config.option.tx == ["popen"] * 2
+    config = testdir.parseconfigure("--numprocesses", "3", "--maxprocesses", "2")
+    check_options(config)
+    assert config.option.dist == "load"
+    assert config.option.tx == ["popen"] * 2
     config = testdir.parseconfigure("-d")
     check_options(config)
     assert config.option.dist == "load"
@@ -31,21 +36,37 @@ def test_dist_options(testdir):
 
 def test_auto_detect_cpus(testdir, monkeypatch):
     import os
-    if hasattr(os, 'cpu_count'):
-        monkeypatch.setattr(os, 'cpu_count', lambda: 99)
+    from xdist.plugin import pytest_cmdline_main as check_options
+
+    if hasattr(os, "sched_getaffinity"):
+        monkeypatch.setattr(os, "sched_getaffinity", lambda _pid: set(range(99)))
+    elif hasattr(os, "cpu_count"):
+        monkeypatch.setattr(os, "cpu_count", lambda: 99)
     else:
         import multiprocessing
-        monkeypatch.setattr(multiprocessing, 'cpu_count', lambda: 99)
+
+        monkeypatch.setattr(multiprocessing, "cpu_count", lambda: 99)
 
     config = testdir.parseconfigure("-n2")
-    assert config.getoption('numprocesses') == 2
+    assert config.getoption("numprocesses") == 2
 
     config = testdir.parseconfigure("-nauto")
-    assert config.getoption('numprocesses') == 99
+    assert config.getoption("numprocesses") == 99
+
+    config = testdir.parseconfigure("-nauto", "--pdb")
+    check_options(config)
+    assert config.getoption("usepdb")
+    assert config.getoption("numprocesses") == 0
+
+    monkeypatch.delattr(os, "sched_getaffinity", raising=False)
+    monkeypatch.setenv("TRAVIS", "true")
+    config = testdir.parseconfigure("-nauto")
+    assert config.getoption("numprocesses") == 2
 
 
 def test_boxed_with_collect_only(testdir):
     from xdist.plugin import pytest_cmdline_main as check_options
+
     config = testdir.parseconfigure("-n1", "--boxed")
     check_options(config)
     assert config.option.forked
@@ -74,6 +95,18 @@ def test_dsession_with_collect_only(testdir):
     assert not config.pluginmanager.hasplugin("dsession")
 
 
+def test_testrunuid_provided(testdir):
+    config = testdir.parseconfigure("--testrunuid", "test123", "--tx=popen")
+    nm = NodeManager(config)
+    assert nm.testrunuid == "test123"
+
+
+def test_testrunuid_generated(testdir):
+    config = testdir.parseconfigure("--tx=popen")
+    nm = NodeManager(config)
+    assert len(nm.testrunuid) == 32
+
+
 class TestDistOptions:
     def test_getxspecs(self, testdir):
         config = testdir.parseconfigure("--tx=popen", "--tx", "ssh=xyz")
@@ -85,13 +118,13 @@ class TestDistOptions:
         assert xspecs[1].ssh == "xyz"
 
     def test_xspecs_multiplied(self, testdir):
-        config = testdir.parseconfigure("--tx=3*popen", )
+        config = testdir.parseconfigure("--tx=3*popen")
         xspecs = NodeManager(config)._getxspecs()
         assert len(xspecs) == 3
         assert xspecs[1].popen
 
     def test_getrsyncdirs(self, testdir):
-        config = testdir.parseconfigure('--rsyncdir=' + str(testdir.tmpdir))
+        config = testdir.parseconfigure("--rsyncdir=" + str(testdir.tmpdir))
         nm = NodeManager(config, specs=[execnet.XSpec("popen")])
         assert not nm._getrsyncdirs()
         nm = NodeManager(config, specs=[execnet.XSpec("popen//chdir=qwe")])
@@ -99,23 +132,24 @@ class TestDistOptions:
         assert testdir.tmpdir in nm.roots
 
     def test_getrsyncignore(self, testdir):
-        config = testdir.parseconfigure('--rsyncignore=fo*')
+        config = testdir.parseconfigure("--rsyncignore=fo*")
         nm = NodeManager(config, specs=[execnet.XSpec("popen//chdir=qwe")])
-        assert 'fo*' in nm.rsyncoptions['ignores']
+        assert "fo*" in nm.rsyncoptions["ignores"]
 
     def test_getrsyncdirs_with_conftest(self, testdir):
         p = py.path.local()
-        for bn in 'x y z'.split():
+        for bn in "x y z".split():
             p.mkdir(bn)
-        testdir.makeini("""
+        testdir.makeini(
+            """
             [pytest]
             rsyncdirs= x
-        """)
-        config = testdir.parseconfigure(
-            testdir.tmpdir, '--rsyncdir=y', '--rsyncdir=z')
+        """
+        )
+        config = testdir.parseconfigure(testdir.tmpdir, "--rsyncdir=y", "--rsyncdir=z")
         nm = NodeManager(config, specs=[execnet.XSpec("popen//chdir=xyz")])
         roots = nm._getrsyncdirs()
         # assert len(roots) == 3 + 1 # pylib
-        assert py.path.local('y') in roots
-        assert py.path.local('z') in roots
-        assert testdir.tmpdir.join('x') in roots
+        assert py.path.local("y") in roots
+        assert py.path.local("z") in roots
+        assert testdir.tmpdir.join("x") in roots

testing/test_remote.py

@@ -1,11 +1,14 @@
 import py
+import pprint
 import pytest
-from xdist.workermanage import WorkerController, unserialize_report
-from xdist.remote import serialize_report
+import sys
+import uuid
+
+from xdist.workermanage import WorkerController
 import execnet
 import marshal
 
-queue = py.builtin._tryimport("queue", "Queue")
+from six.moves.queue import Queue
 
 WAIT_TIMEOUT = 10.0
 
@@ -14,7 +17,7 @@ def check_marshallable(d):
     try:
         marshal.dumps(d)
     except ValueError:
-        py.std.pprint.pprint(d)
+        pprint.pprint(d)
         raise ValueError("not marshallable")
 
 
@@ -23,7 +26,7 @@ class EventCall:
         self.name, self.kwargs = eventcall
 
     def __str__(self):
-        return "<EventCall %s(**%s)>" % (self.name, self.kwargs)
+        return "<EventCall {}(**{})>".format(self.name, self.kwargs)
 
 
 class WorkerSetup:
@@ -32,9 +35,9 @@ class WorkerSetup:
     def __init__(self, request, testdir):
         self.request = request
         self.testdir = testdir
-        self.events = queue.Queue()
+        self.events = Queue()
 
-    def setup(self, ):
+    def setup(self,):
         self.testdir.chdir()
         # import os ; os.environ['EXECNET_DEBUG'] = "2"
         self.gateway = execnet.makegateway()
@@ -42,10 +45,10 @@ class WorkerSetup:
         putevent = self.use_callback and self.events.put or None
 
         class DummyMananger:
+            testrunuid = uuid.uuid4().hex
             specs = [0, 1]
 
-        self.slp = WorkerController(DummyMananger, self.gateway, config,
-                                    putevent)
+        self.slp = WorkerController(DummyMananger, self.gateway, config, putevent)
         self.request.addfinalizer(self.slp.ensure_teardown)
         self.slp.setup()
 
@@ -58,7 +61,7 @@ class WorkerSetup:
             ev = EventCall(data)
             if name is None or ev.name == name:
                 return ev
-            print("skipping %s" % (ev, ))
+            print("skipping {}".format(ev))
 
     def sendcommand(self, name, **kwargs):
         self.slp.sendcommand(name, **kwargs)
@@ -69,186 +72,33 @@ def worker(request, testdir):
     return WorkerSetup(request, testdir)
 
 
-@pytest.mark.xfail(reason='#59')
+@pytest.mark.xfail(reason="#59")
 def test_remoteinitconfig(testdir):
     from xdist.remote import remote_initconfig
+
     config1 = testdir.parseconfig()
     config2 = remote_initconfig(config1.option.__dict__, config1.args)
     assert config2.option.__dict__ == config1.option.__dict__
     assert config2.pluginmanager.getplugin("terminal") in (-1, None)
 
 
-class TestReportSerialization:
-    def test_xdist_longrepr_to_str_issue_241(self, testdir):
-        testdir.makepyfile("""
-            import os
-            def test_a(): assert False
-            def test_b(): pass
-        """)
-        testdir.makeconftest("""
-            def pytest_runtest_logreport(report):
-                print(report.longrepr)
-        """)
-        res = testdir.runpytest('-n1', '-s')
-        res.stdout.fnmatch_lines([
-            '*1 failed, 1 passed *'
-        ])
-
-    def test_xdist_report_longrepr_reprcrash_130(self, testdir):
-        reprec = testdir.inline_runsource("""
-                    import py
-                    def test_fail(): assert False, 'Expected Message'
-                """)
-        reports = reprec.getreports("pytest_runtest_logreport")
-        assert len(reports) == 3
-        rep = reports[1]
-        added_section = ('Failure Metadata', str("metadata metadata"), "*")
-        rep.longrepr.sections.append(added_section)
-        d = serialize_report(rep)
-        check_marshallable(d)
-        a = unserialize_report("testreport", d)
-        # Check assembled == rep
-        assert a.__dict__.keys() == rep.__dict__.keys()
-        for key in rep.__dict__.keys():
-            if key != 'longrepr':
-                assert getattr(a, key) == getattr(rep, key)
-        assert rep.longrepr.reprcrash.lineno == a.longrepr.reprcrash.lineno
-        assert rep.longrepr.reprcrash.message == a.longrepr.reprcrash.message
-        assert rep.longrepr.reprcrash.path == a.longrepr.reprcrash.path
-        assert rep.longrepr.reprtraceback.entrysep \
-            == a.longrepr.reprtraceback.entrysep
-        assert rep.longrepr.reprtraceback.extraline \
-            == a.longrepr.reprtraceback.extraline
-        assert rep.longrepr.reprtraceback.style \
-            == a.longrepr.reprtraceback.style
-        assert rep.longrepr.sections == a.longrepr.sections
-        # Missing section attribute PR171
-        assert added_section in a.longrepr.sections
-
-    def test_reprentries_serialization_170(self, testdir):
-        from _pytest._code.code import ReprEntry
-        reprec = testdir.inline_runsource("""
-                            def test_repr_entry():
-                                x = 0
-                                assert x
-                        """, '--showlocals')
-        reports = reprec.getreports("pytest_runtest_logreport")
-        assert len(reports) == 3
-        rep = reports[1]
-        d = serialize_report(rep)
-        a = unserialize_report("testreport", d)
-
-        rep_entries = rep.longrepr.reprtraceback.reprentries
-        a_entries = a.longrepr.reprtraceback.reprentries
-        for i in range(len(a_entries)):
-            assert isinstance(rep_entries[i], ReprEntry)
-            assert rep_entries[i].lines == a_entries[i].lines
-            assert rep_entries[i].localssep == a_entries[i].localssep
-            assert rep_entries[i].reprfileloc.lineno == a_entries[i].reprfileloc.lineno
-            assert rep_entries[i].reprfileloc.message == a_entries[i].reprfileloc.message
-            assert rep_entries[i].reprfileloc.path == a_entries[i].reprfileloc.path
-            assert rep_entries[i].reprfuncargs.args == a_entries[i].reprfuncargs.args
-            assert rep_entries[i].reprlocals.lines == a_entries[i].reprlocals.lines
-            assert rep_entries[i].style == a_entries[i].style
-
-    def test_reprentries_serialization_196(self, testdir):
-        from _pytest._code.code import ReprEntryNative
-        reprec = testdir.inline_runsource("""
-                            def test_repr_entry_native():
-                                x = 0
-                                assert x
-                        """, '--tb=native')
-        reports = reprec.getreports("pytest_runtest_logreport")
-        assert len(reports) == 3
-        rep = reports[1]
-        d = serialize_report(rep)
-        a = unserialize_report("testreport", d)
-
-        rep_entries = rep.longrepr.reprtraceback.reprentries
-        a_entries = a.longrepr.reprtraceback.reprentries
-        for i in range(len(a_entries)):
-            assert isinstance(rep_entries[i], ReprEntryNative)
-            assert rep_entries[i].lines == a_entries[i].lines
-
-    def test_itemreport_outcomes(self, testdir):
-        reprec = testdir.inline_runsource("""
-            import py
-            def test_pass(): pass
-            def test_fail(): 0/0
-            @py.test.mark.skipif("True")
-            def test_skip(): pass
-            def test_skip_imperative():
-                py.test.skip("hello")
-            @py.test.mark.xfail("True")
-            def test_xfail(): 0/0
-            def test_xfail_imperative():
-                py.test.xfail("hello")
-        """)
-        reports = reprec.getreports("pytest_runtest_logreport")
-        assert len(reports) == 17  # with setup/teardown "passed" reports
-        for rep in reports:
-            d = serialize_report(rep)
-            check_marshallable(d)
-            newrep = unserialize_report("testreport", d)
-            assert newrep.passed == rep.passed
-            assert newrep.failed == rep.failed
-            assert newrep.skipped == rep.skipped
-            if newrep.skipped and not hasattr(newrep, "wasxfail"):
-                assert len(newrep.longrepr) == 3
-            assert newrep.outcome == rep.outcome
-            assert newrep.when == rep.when
-            assert newrep.keywords == rep.keywords
-            if rep.failed:
-                assert newrep.longreprtext == rep.longreprtext
-
-    def test_collectreport_passed(self, testdir):
-        reprec = testdir.inline_runsource("def test_func(): pass")
-        reports = reprec.getreports("pytest_collectreport")
-        for rep in reports:
-            d = serialize_report(rep)
-            check_marshallable(d)
-            newrep = unserialize_report("collectreport", d)
-            assert newrep.passed == rep.passed
-            assert newrep.failed == rep.failed
-            assert newrep.skipped == rep.skipped
-
-    def test_collectreport_fail(self, testdir):
-        reprec = testdir.inline_runsource("qwe abc")
-        reports = reprec.getreports("pytest_collectreport")
-        assert reports
-        for rep in reports:
-            d = serialize_report(rep)
-            check_marshallable(d)
-            newrep = unserialize_report("collectreport", d)
-            assert newrep.passed == rep.passed
-            assert newrep.failed == rep.failed
-            assert newrep.skipped == rep.skipped
-            if rep.failed:
-                assert newrep.longrepr == str(rep.longrepr)
-
-    def test_extended_report_deserialization(self, testdir):
-        reprec = testdir.inline_runsource("qwe abc")
-        reports = reprec.getreports("pytest_collectreport")
-        assert reports
-        for rep in reports:
-            rep.extra = True
-            d = serialize_report(rep)
-            check_marshallable(d)
-            newrep = unserialize_report("collectreport", d)
-            assert newrep.extra
-            assert newrep.passed == rep.passed
-            assert newrep.failed == rep.failed
-            assert newrep.skipped == rep.skipped
-            if rep.failed:
-                assert newrep.longrepr == str(rep.longrepr)
-
-
 class TestWorkerInteractor:
-    def test_basic_collect_and_runtests(self, worker):
-        worker.testdir.makepyfile("""
+    @pytest.fixture
+    def unserialize_report(self, pytestconfig):
+        def unserialize(data):
+            return pytestconfig.hook.pytest_report_from_serializable(
+                config=pytestconfig, data=data
+            )
+
+        return unserialize
+
+    def test_basic_collect_and_runtests(self, worker, unserialize_report):
+        worker.testdir.makepyfile(
+            """
             def test_func():
                 pass
-        """)
+        """
+        )
         worker.setup()
         ev = worker.popevent()
         assert ev.name == "workerready"
@@ -256,8 +106,8 @@ class TestWorkerInteractor:
         assert ev.name == "collectionstart"
         assert not ev.kwargs
         ev = worker.popevent("collectionfinish")
-        assert ev.kwargs['topdir'] == worker.testdir.tmpdir
-        ids = ev.kwargs['ids']
+        assert ev.kwargs["topdir"] == worker.testdir.tmpdir
+        ids = ev.kwargs["ids"]
         assert len(ids) == 1
         worker.sendcommand("runtests", indices=list(range(len(ids))))
         worker.sendcommand("shutdown")
@@ -267,51 +117,50 @@ class TestWorkerInteractor:
         ev = worker.popevent("testreport")  # setup
         ev = worker.popevent("testreport")
         assert ev.name == "testreport"
-        rep = unserialize_report(ev.name, ev.kwargs['data'])
+        rep = unserialize_report(ev.kwargs["data"])
         assert rep.nodeid.endswith("::test_func")
         assert rep.passed
         assert rep.when == "call"
         ev = worker.popevent("workerfinished")
-        assert 'workeroutput' in ev.kwargs
+        assert "workeroutput" in ev.kwargs
 
-    @pytest.mark.skipif(pytest.__version__ >= '3.0',
-                        reason='skip at module level illegal in pytest 3.0')
-    def test_remote_collect_skip(self, worker):
-        worker.testdir.makepyfile("""
-            import py
-            py.test.skip("hello")
-        """)
+    def test_remote_collect_skip(self, worker, unserialize_report):
+        worker.testdir.makepyfile(
+            """
+            import pytest
+            pytest.skip("hello", allow_module_level=True)
+        """
+        )
         worker.setup()
         ev = worker.popevent("collectionstart")
         assert not ev.kwargs
         ev = worker.popevent()
         assert ev.name == "collectreport"
-        ev = worker.popevent()
-        assert ev.name == "collectreport"
-        rep = unserialize_report(ev.name, ev.kwargs['data'])
+        rep = unserialize_report(ev.kwargs["data"])
         assert rep.skipped
+        assert rep.longrepr[2] == "Skipped: hello"
         ev = worker.popevent("collectionfinish")
-        assert not ev.kwargs['ids']
+        assert not ev.kwargs["ids"]
 
-    def test_remote_collect_fail(self, worker):
+    def test_remote_collect_fail(self, worker, unserialize_report):
         worker.testdir.makepyfile("""aasd qwe""")
         worker.setup()
         ev = worker.popevent("collectionstart")
         assert not ev.kwargs
         ev = worker.popevent()
         assert ev.name == "collectreport"
-        ev = worker.popevent()
-        assert ev.name == "collectreport"
-        rep = unserialize_report(ev.name, ev.kwargs['data'])
+        rep = unserialize_report(ev.kwargs["data"])
         assert rep.failed
         ev = worker.popevent("collectionfinish")
-        assert not ev.kwargs['ids']
+        assert not ev.kwargs["ids"]
 
-    def test_runtests_all(self, worker):
-        worker.testdir.makepyfile("""
+    def test_runtests_all(self, worker, unserialize_report):
+        worker.testdir.makepyfile(
+            """
             def test_func(): pass
             def test_func2(): pass
-        """)
+        """
+        )
         worker.setup()
         ev = worker.popevent()
         assert ev.name == "workerready"
@@ -319,57 +168,125 @@ class TestWorkerInteractor:
         assert ev.name == "collectionstart"
         assert not ev.kwargs
         ev = worker.popevent("collectionfinish")
-        ids = ev.kwargs['ids']
+        ids = ev.kwargs["ids"]
         assert len(ids) == 2
-        worker.sendcommand("runtests_all", )
-        worker.sendcommand("shutdown", )
+        worker.sendcommand("runtests_all")
+        worker.sendcommand("shutdown")
         for func in "::test_func", "::test_func2":
             for i in range(3):  # setup/call/teardown
                 ev = worker.popevent("testreport")
                 assert ev.name == "testreport"
-                rep = unserialize_report(ev.name, ev.kwargs['data'])
+                rep = unserialize_report(ev.kwargs["data"])
                 assert rep.nodeid.endswith(func)
         ev = worker.popevent("workerfinished")
-        assert 'workeroutput' in ev.kwargs
+        assert "workeroutput" in ev.kwargs
 
     def test_happy_run_events_converted(self, testdir, worker):
         py.test.xfail("implement a simple test for event production")
         assert not worker.use_callback
-        worker.testdir.makepyfile("""
+        worker.testdir.makepyfile(
+            """
             def test_func():
                 pass
-        """)
+        """
+        )
         worker.setup()
         hookrec = testdir.getreportrecorder(worker.config)
         for data in worker.slp.channel:
             worker.slp.process_from_remote(data)
         worker.slp.process_from_remote(worker.slp.ENDMARK)
-        py.std.pprint.pprint(hookrec.hookrecorder.calls)
-        hookrec.hookrecorder.contains([
-            ("pytest_collectstart", "collector.fspath == aaa"),
-            ("pytest_pycollect_makeitem", "name == 'test_func'"),
-            ("pytest_collectreport", "report.collector.fspath == aaa"),
-            ("pytest_collectstart", "collector.fspath == bbb"),
-            ("pytest_pycollect_makeitem", "name == 'test_func'"),
-            ("pytest_collectreport", "report.collector.fspath == bbb"),
-        ])
+        pprint.pprint(hookrec.hookrecorder.calls)
+        hookrec.hookrecorder.contains(
+            [
+                ("pytest_collectstart", "collector.fspath == aaa"),
+                ("pytest_pycollect_makeitem", "name == 'test_func'"),
+                ("pytest_collectreport", "report.collector.fspath == aaa"),
+                ("pytest_collectstart", "collector.fspath == bbb"),
+                ("pytest_pycollect_makeitem", "name == 'test_func'"),
+                ("pytest_collectreport", "report.collector.fspath == bbb"),
+            ]
+        )
 
     def test_process_from_remote_error_handling(self, worker, capsys):
         worker.use_callback = True
         worker.setup()
-        worker.slp.process_from_remote(('<nonono>', ()))
+        worker.slp.process_from_remote(("<nonono>", ()))
         out, err = capsys.readouterr()
-        assert 'INTERNALERROR> ValueError: unknown event: <nonono>' in out
+        assert "INTERNALERROR> ValueError: unknown event: <nonono>" in out
         ev = worker.popevent()
         assert ev.name == "errordown"
 
 
 def test_remote_env_vars(testdir):
-    testdir.makepyfile('''
+    testdir.makepyfile(
+        """
         import os
         def test():
+            assert len(os.environ['PYTEST_XDIST_TESTRUNUID']) == 32
             assert os.environ['PYTEST_XDIST_WORKER'] in ('gw0', 'gw1')
             assert os.environ['PYTEST_XDIST_WORKER_COUNT'] == '2'
-    ''')
-    result = testdir.runpytest('-n2', '--max-worker-restart=0')
+    """
+    )
+    result = testdir.runpytest("-n2", "--max-worker-restart=0")
     assert result.ret == 0
+
+
+def test_remote_inner_argv(testdir):
+    """Test/document the behavior due to execnet using `python -c`."""
+    testdir.makepyfile(
+        """
+        import sys
+
+        def test_argv():
+            assert sys.argv == ["-c"]
+        """
+    )
+    result = testdir.runpytest("-n1")
+    assert result.ret == 0
+
+
+def test_remote_mainargv(testdir):
+    outer_argv = sys.argv
+
+    testdir.makepyfile(
+        """
+        def test_mainargv(request):
+            assert request.config.workerinput["mainargv"] == {!r}
+        """.format(
+            outer_argv
+        )
+    )
+    result = testdir.runpytest("-n1")
+    assert result.ret == 0
+
+
+def test_remote_usage_prog(testdir, request):
+    if not hasattr(request.config._parser, "prog"):
+        pytest.skip("prog not available in config parser")
+    testdir.makeconftest(
+        """
+        import pytest
+
+        config_parser = None
+
+        @pytest.fixture
+        def get_config_parser():
+            return config_parser
+
+        def pytest_configure(config):
+            global config_parser
+            config_parser = config._parser
+    """
+    )
+    testdir.makepyfile(
+        """
+        import sys
+
+        def test(get_config_parser, request):
+            get_config_parser._getparser().error("my_usage_error")
+    """
+    )
+
+    result = testdir.runpytest_subprocess("-n1")
+    assert result.ret == 1
+    result.stdout.fnmatch_lines(["*usage: *", "*error: my_usage_error"])

testing/test_slavemanage.py

@@ -1,5 +1,7 @@
+from __future__ import print_function
 import py
 import pytest
+import textwrap
 import execnet
 from _pytest.pytester import HookRecorder
 from xdist import workermanage, newhooks
@@ -40,7 +42,7 @@ def workercontroller(monkeypatch):
         def setup(self):
             pass
 
-    monkeypatch.setattr(workermanage, 'WorkerController', MockController)
+    monkeypatch.setattr(workermanage, "WorkerController", MockController)
     return MockController
 
 
@@ -56,8 +58,7 @@ class TestNodeManagerPopen:
         for spec in NodeManager(config, specs, defaultchdir="abc").specs:
             assert spec.chdir == "abc"
 
-    def test_popen_makegateway_events(self, config, hookrecorder,
-                                      workercontroller):
+    def test_popen_makegateway_events(self, config, hookrecorder, workercontroller):
         hm = NodeManager(config, ["popen"] * 2)
         hm.setup_nodes(None)
         call = hookrecorder.popcall("pytest_xdist_setupnodes")
@@ -106,15 +107,16 @@ class TestNodeManagerPopen:
         for gw in hm.group:
             hm.rsync(gw, source, notify=lambda *args: notifications.append(args))
         assert len(notifications) == 1
-        assert notifications[0] == ("rsyncrootready", hm.group['gw0'].spec, source)
+        assert notifications[0] == ("rsyncrootready", hm.group["gw0"].spec, source)
         hm.teardown_nodes()
         dest = dest.join(source.basename)
         assert dest.join("dir1").check()
         assert dest.join("dir1", "dir2").check()
-        assert dest.join("dir1", "dir2", 'hello').check()
+        assert dest.join("dir1", "dir2", "hello").check()
 
-    def test_rsync_same_popen_twice(self, config, mysetup, hookrecorder,
-                                    workercontroller):
+    def test_rsync_same_popen_twice(
+        self, config, mysetup, hookrecorder, workercontroller
+    ):
         source, dest = mysetup.source, mysetup.dest
         hm = NodeManager(config, ["popen//chdir=%s" % dest] * 2)
         hm.roots = []
@@ -140,9 +142,9 @@ class TestHRSync:
         files = list(source.visit(rec=syncer.filter, fil=syncer.filter))
         assert len(files) == 3
         basenames = [x.basename for x in files]
-        assert 'dir' in basenames
-        assert 'file.txt' in basenames
-        assert 'somedir' in basenames
+        assert "dir" in basenames
+        assert "file.txt" in basenames
+        assert "somedir" in basenames
 
     def test_hrsync_one_host(self, mysetup):
         source, dest = mysetup.source, mysetup.dest
@@ -166,10 +168,11 @@ class TestNodeManager:
         # assert nodemanager.config.topdir == source == config.topdir
         nodemanager.makegateways()
         nodemanager.rsync_roots()
-        p, = nodemanager.gwmanager.multi_exec(
-            "import os ; channel.send(os.getcwd())").receive_each()
+        (p,) = nodemanager.gwmanager.multi_exec(
+            "import os ; channel.send(os.getcwd())"
+        ).receive_each()
         p = py.path.local(p)
-        py.builtin.print_("remote curdir", p)
+        print("remote curdir", p)
         assert p == mysetup.dest.join(config.topdir.basename)
         assert p.join("dir1").check()
         assert p.join("dir1", "file1").check()
@@ -181,15 +184,17 @@ class TestNodeManager:
         dir2.ensure("hello")
         for rsyncroot in (dir1, source):
             dest.remove()
-            nodemanager = NodeManager(testdir.parseconfig(
-                "--tx", "popen//chdir=%s" % dest, "--rsyncdir", rsyncroot,
-                source, ))
+            nodemanager = NodeManager(
+                testdir.parseconfig(
+                    "--tx", "popen//chdir=%s" % dest, "--rsyncdir", rsyncroot, source
+                )
+            )
             nodemanager.setup_nodes(None)  # calls .rsync_roots()
             if rsyncroot == source:
                 dest = dest.join("source")
             assert dest.join("dir1").check()
             assert dest.join("dir1", "dir2").check()
-            assert dest.join("dir1", "dir2", 'hello').check()
+            assert dest.join("dir1", "dir2", "hello").check()
             nodemanager.teardown_nodes()
 
     def test_init_rsync_roots(self, testdir, mysetup, workercontroller):
@@ -198,10 +203,14 @@ class TestNodeManager:
         source.ensure("dir1", "somefile", dir=1)
         dir2.ensure("hello")
         source.ensure("bogusdir", "file")
-        source.join("tox.ini").write(py.std.textwrap.dedent("""
+        source.join("tox.ini").write(
+            textwrap.dedent(
+                """
             [pytest]
             rsyncdirs=dir1/dir2
-        """))
+        """
+            )
+        )
         config = testdir.parseconfig(source)
         nodemanager = NodeManager(config, ["popen//chdir=%s" % dest])
         nodemanager.setup_nodes(None)  # calls .rsync_roots()
@@ -217,27 +226,31 @@ class TestNodeManager:
         dir2.ensure("hello")
         source.ensure("foo", "bar")
         source.ensure("bar", "foo")
-        source.join("tox.ini").write(py.std.textwrap.dedent("""
+        source.join("tox.ini").write(
+            textwrap.dedent(
+                """
             [pytest]
             rsyncdirs = dir1 dir5
             rsyncignore = dir1/dir2 dir5/dir6 foo*
-        """))
+        """
+            )
+        )
         config = testdir.parseconfig(source)
-        config.option.rsyncignore = ['bar']
+        config.option.rsyncignore = ["bar"]
         nodemanager = NodeManager(config, ["popen//chdir=%s" % dest])
         nodemanager.setup_nodes(None)  # calls .rsync_roots()
         assert dest.join("dir1").check()
         assert not dest.join("dir1", "dir2").check()
         assert dest.join("dir5", "file").check()
         assert not dest.join("dir6").check()
-        assert not dest.join('foo').check()
-        assert not dest.join('bar').check()
+        assert not dest.join("foo").check()
+        assert not dest.join("bar").check()
 
     def test_optimise_popen(self, testdir, mysetup, workercontroller):
         source = mysetup.source
         specs = ["popen"] * 3
         source.join("conftest.py").write("rsyncdirs = ['a']")
-        source.ensure('a', dir=1)
+        source.ensure("a", dir=1)
         config = testdir.parseconfig(source)
         nodemanager = NodeManager(config, specs)
         nodemanager.setup_nodes(None)  # calls .rysnc_roots()
@@ -246,12 +259,15 @@ class TestNodeManager:
             assert not gwspec.chdir
 
     def test_ssh_setup_nodes(self, specssh, testdir):
-        testdir.makepyfile(__init__="",
-                           test_x="""
+        testdir.makepyfile(
+            __init__="",
+            test_x="""
             def test_one():
                 pass
-        """)
-        reprec = testdir.inline_run("-d", "--rsyncdir=%s" % testdir.tmpdir,
-                                    "--tx", specssh, testdir.tmpdir)
-        rep, = reprec.getreports("pytest_runtest_logreport")
+        """,
+        )
+        reprec = testdir.inline_run(
+            "-d", "--rsyncdir=%s" % testdir.tmpdir, "--tx", specssh, testdir.tmpdir
+        )
+        (rep,) = reprec.getreports("pytest_runtest_logreport")
         assert rep.passed

tox.ini

@@ -1,46 +1,41 @@
 [tox]
-# if you change the envlist, please update .travis.yml file as well
 envlist=
-  py{27,34,35,36}-pytest{30,31,32,33}
-  py{27,36}-pytest{30,31,32,33}-pexpect
-  py{27,36}-pytest{master,features}
-  flakes
-  readme
-
+  linting
+  py{27,35,36,37,38}-pytestlatest
+  py38-pytestmaster
 
 [testenv]
-changedir=testing
 passenv = USER USERNAME
+extras = testing
 deps =
-  pycmd
-  # to avoid .eggs
-  setuptools_scm
-  pytest30: pytest~=3.0.5
-  pytest31: pytest~=3.1.0
-  pytest32: pytest~=3.2.0
-  pytest33: pytest~=3.3.0
+  pytestlatest: pytest
   pytestmaster: git+https://github.com/pytest-dev/pytest.git@master
-  pytestfeatures: git+https://github.com/pytest-dev/pytest.git@features
-  pexpect: pexpect
-platform=
-  pexpect: linux|darwin
 commands=
-  # always clean to avoid code unmarshal mismatch on old python/pytest
-  py.cleanup -aq
-  py.test {posargs}
+  pytest {posargs}
 
-[testenv:flakes]
+[testenv:linting]
+skipsdist = True
+usedevelop = True
+deps =
+  pre-commit
+commands = pre-commit run --all-files --show-diff-on-failure
+
+[testenv:release]
 changedir=
-deps = flake8
-commands = flake8 setup.py testing xdist
-
-[testenv:readme]
-changedir =
-deps = readme
-skip_install = true
-commands = python setup.py check -r -s
-
+decription = do a release, required posarg of the version number
+basepython = python3.7
+skipsdist = True
+usedevelop = True
+passenv = *
+deps =
+    towncrier
+commands =
+    towncrier --version {posargs} --yes
 
 [pytest]
-addopts = -rsfxX
-;; hello
+addopts = -ra
+testpaths = testing
+
+[flake8]
+max-line-length = 120
+ignore = E203,W503

xdist/plugin.py

@@ -1,138 +0,0 @@
-import py
-import pytest
-
-
-def parse_numprocesses(s):
-    if s == 'auto':
-        try:
-            from os import cpu_count
-        except ImportError:
-            from multiprocessing import cpu_count
-        try:
-            n = cpu_count()
-        except NotImplementedError:
-            return 1
-        return n if n else 1
-    else:
-        return int(s)
-
-
-def pytest_addoption(parser):
-    group = parser.getgroup("xdist", "distributed and subprocess testing")
-    group._addoption(
-        '-n', '--numprocesses', dest="numprocesses", metavar="numprocesses",
-        action="store",
-        type=parse_numprocesses,
-        help="shortcut for '--dist=load --tx=NUM*popen', "
-             "you can use 'auto' here for auto detection CPUs number on "
-             "host system")
-    group.addoption('--max-worker-restart', '--max-slave-restart', action="store", default=None,
-                    dest="maxworkerrestart",
-                    help="maximum number of workers that can be restarted "
-                         "when crashed (set to zero to disable this feature)\n"
-                         "'--max-slave-restart' option is deprecated and will be removed in "
-                         "a future release")
-    group.addoption(
-        '--dist', metavar="distmode",
-        action="store", choices=['each', 'load', 'loadscope', 'loadfile', 'no'],
-        dest="dist", default="no",
-        help=("set mode for distributing tests to exec environments.\n\n"
-              "each: send each test to all available environments.\n\n"
-              "load: load balance by sending any pending test to any"
-              " available environment.\n\n"
-              "loadscope: load balance by sending pending groups of tests in"
-              " the same scope to any available environment.\n\n"
-              "loadfile: load balance by sending test grouped by file"
-              " to any available environment.\n\n"
-              "(default) no: run tests inprocess, don't distribute."))
-    group.addoption(
-        '--tx', dest="tx", action="append", default=[],
-        metavar="xspec",
-        help=("add a test execution environment. some examples: "
-              "--tx popen//python=python2.5 --tx socket=192.168.1.102:8888 "
-              "--tx ssh=user@codespeak.net//chdir=testcache"))
-    group._addoption(
-        '-d',
-        action="store_true", dest="distload", default=False,
-        help="load-balance tests.  shortcut for '--dist=load'")
-    group.addoption(
-        '--rsyncdir', action="append", default=[], metavar="DIR",
-        help="add directory for rsyncing to remote tx nodes.")
-    group.addoption(
-        '--rsyncignore', action="append", default=[], metavar="GLOB",
-        help="add expression for ignores when rsyncing to remote tx nodes.")
-
-    group.addoption(
-        "--boxed", action="store_true",
-        help="backward compatibility alias for pytest-forked --forked")
-    parser.addini(
-        'rsyncdirs', 'list of (relative) paths to be rsynced for'
-        ' remote distributed testing.', type="pathlist")
-    parser.addini(
-        'rsyncignore', 'list of (relative) glob-style paths to be ignored '
-        'for rsyncing.', type="pathlist")
-    parser.addini(
-        "looponfailroots", type="pathlist",
-        help="directories to check for changes", default=[py.path.local()])
-
-
-# -------------------------------------------------------------------------
-# distributed testing hooks
-# -------------------------------------------------------------------------
-
-
-def pytest_addhooks(pluginmanager):
-    from xdist import newhooks
-    # avoid warnings with pytest-2.8
-    method = getattr(pluginmanager, "add_hookspecs", None)
-    if method is None:
-        method = pluginmanager.addhooks
-    method(newhooks)
-
-# -------------------------------------------------------------------------
-# distributed testing initialization
-# -------------------------------------------------------------------------
-
-
-@pytest.mark.trylast
-def pytest_configure(config):
-    if config.getoption("dist") != "no" and not config.getvalue("collectonly"):
-        from xdist.dsession import DSession
-        session = DSession(config)
-        config.pluginmanager.register(session, "dsession")
-        tr = config.pluginmanager.getplugin("terminalreporter")
-        tr.showfspath = False
-    if config.getoption("boxed"):
-        config.option.forked = True
-
-
-@pytest.mark.tryfirst
-def pytest_cmdline_main(config):
-    if config.option.numprocesses:
-        if config.option.dist == 'no':
-            config.option.dist = "load"
-        config.option.tx = ['popen'] * config.option.numprocesses
-    if config.option.distload:
-        config.option.dist = "load"
-    val = config.getvalue
-    if not val("collectonly"):
-        usepdb = config.getoption('usepdb')  # a core option
-        if val("dist") != "no":
-            if usepdb:
-                raise pytest.UsageError(
-                    "--pdb is incompatible with distributing tests; try using -n0.")  # noqa: E501
-
-# -------------------------------------------------------------------------
-# fixtures
-# -------------------------------------------------------------------------
-
-
-@pytest.fixture(scope="session")
-def worker_id(request):
-    """Return the id of the current worker ('gw0', 'gw1', etc) or 'master'
-    if running on the master node.
-    """
-    if hasattr(request.config, 'workerinput'):
-        return request.config.workerinput['workerid']
-    else:
-        return 'master'

xdist/remote.py

@@ -1,205 +0,0 @@
-"""
-    This module is executed in remote subprocesses and helps to
-    control a remote testing session and relay back information.
-    It assumes that 'py' is importable and does not have dependencies
-    on the rest of the xdist code.  This means that the xdist-plugin
-    needs not to be installed in remote environments.
-"""
-
-import sys
-import os
-import time
-
-import _pytest.hookspec
-import pytest
-
-
-class WorkerInteractor:
-    def __init__(self, config, channel):
-        self.config = config
-        self.workerid = config.workerinput.get('workerid', "?")
-        self.log = py.log.Producer("worker-%s" % self.workerid)
-        if not config.option.debug:
-            py.log.setconsumer(self.log._keywords, None)
-        self.channel = channel
-        config.pluginmanager.register(self)
-
-    def sendevent(self, name, **kwargs):
-        self.log("sending", name, kwargs)
-        self.channel.send((name, kwargs))
-
-    def pytest_internalerror(self, excrepr):
-        for line in str(excrepr).split("\n"):
-            self.log("IERROR>", line)
-
-    def pytest_sessionstart(self, session):
-        self.session = session
-        workerinfo = getinfodict()
-        self.sendevent("workerready", workerinfo=workerinfo)
-
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_sessionfinish(self, exitstatus):
-        self.config.workeroutput['exitstatus'] = exitstatus
-        yield
-        self.sendevent("workerfinished", workeroutput=self.config.workeroutput)
-
-    def pytest_collection(self, session):
-        self.sendevent("collectionstart")
-
-    def pytest_runtestloop(self, session):
-        self.log("entering main loop")
-        torun = []
-        while 1:
-            try:
-                name, kwargs = self.channel.receive()
-            except EOFError:
-                return True
-            self.log("received command", name, kwargs)
-            if name == "runtests":
-                torun.extend(kwargs['indices'])
-            elif name == "runtests_all":
-                torun.extend(range(len(session.items)))
-            self.log("items to run:", torun)
-            # only run if we have an item and a next item
-            while len(torun) >= 2:
-                self.run_one_test(torun)
-            if name == "shutdown":
-                if torun:
-                    self.run_one_test(torun)
-                break
-        return True
-
-    def run_one_test(self, torun):
-        items = self.session.items
-        self.item_index = torun.pop(0)
-        item = items[self.item_index]
-        if torun:
-            nextitem = items[torun[0]]
-        else:
-            nextitem = None
-
-        start = time.time()
-        self.config.hook.pytest_runtest_protocol(
-            item=item,
-            nextitem=nextitem)
-        duration = time.time() - start
-        self.sendevent("runtest_protocol_complete", item_index=self.item_index,
-                       duration=duration)
-
-    def pytest_collection_finish(self, session):
-        self.sendevent(
-            "collectionfinish",
-            topdir=str(session.fspath),
-            ids=[item.nodeid for item in session.items])
-
-    def pytest_runtest_logstart(self, nodeid, location):
-        self.sendevent("logstart", nodeid=nodeid, location=location)
-
-    # the pytest_runtest_logfinish hook was introduced in pytest 3.4
-    if hasattr(_pytest.hookspec, 'pytest_runtest_logfinish'):
-        def pytest_runtest_logfinish(self, nodeid, location):
-            self.sendevent("logfinish", nodeid=nodeid, location=location)
-
-    def pytest_runtest_logreport(self, report):
-        data = serialize_report(report)
-        data["item_index"] = self.item_index
-        data["worker_id"] = self.workerid
-        assert self.session.items[self.item_index].nodeid == report.nodeid
-        self.sendevent("testreport", data=data)
-
-    def pytest_collectreport(self, report):
-        data = serialize_report(report)
-        self.sendevent("collectreport", data=data)
-
-    def pytest_logwarning(self, message, code, nodeid, fslocation):
-        self.sendevent("logwarning", message=message, code=code, nodeid=nodeid,
-                       fslocation=str(fslocation))
-
-
-def serialize_report(rep):
-    def disassembled_report(rep):
-        reprtraceback = rep.longrepr.reprtraceback.__dict__.copy()
-        reprcrash = rep.longrepr.reprcrash.__dict__.copy()
-
-        new_entries = []
-        for entry in reprtraceback['reprentries']:
-            entry_data = {
-                'type': type(entry).__name__,
-                'data': entry.__dict__.copy(),
-            }
-            for key, value in entry_data['data'].items():
-                if hasattr(value, '__dict__'):
-                    entry_data['data'][key] = value.__dict__.copy()
-            new_entries.append(entry_data)
-
-        reprtraceback['reprentries'] = new_entries
-
-        return {
-            'reprcrash': reprcrash,
-            'reprtraceback': reprtraceback,
-            'sections': rep.longrepr.sections
-        }
-
-    import py
-    d = rep.__dict__.copy()
-    if hasattr(rep.longrepr, 'toterminal'):
-        if hasattr(rep.longrepr, 'reprtraceback') \
-                and hasattr(rep.longrepr, 'reprcrash'):
-            d['longrepr'] = disassembled_report(rep)
-        else:
-            d['longrepr'] = str(rep.longrepr)
-    else:
-        d['longrepr'] = rep.longrepr
-    for name in d:
-        if isinstance(d[name], py.path.local):
-            d[name] = str(d[name])
-        elif name == "result":
-            d[name] = None  # for now
-    return d
-
-
-def getinfodict():
-    import platform
-    return dict(
-        version=sys.version,
-        version_info=tuple(sys.version_info),
-        sysplatform=sys.platform,
-        platform=platform.platform(),
-        executable=sys.executable,
-        cwd=os.getcwd(),
-    )
-
-
-def remote_initconfig(option_dict, args):
-    from _pytest.config import Config
-    option_dict['plugins'].append("no:terminal")
-    config = Config.fromdictargs(option_dict, args)
-    config.option.looponfail = False
-    config.option.usepdb = False
-    config.option.dist = "no"
-    config.option.distload = False
-    config.option.numprocesses = None
-    config.args = args
-    return config
-
-
-if __name__ == '__channelexec__':
-    channel = channel  # noqa
-    workerinput, args, option_dict = channel.receive()
-    importpath = os.getcwd()
-    sys.path.insert(0, importpath)  # XXX only for remote situations
-    os.environ['PYTHONPATH'] = (
-        importpath + os.pathsep +
-        os.environ.get('PYTHONPATH', ''))
-    os.environ['PYTEST_XDIST_WORKER'] = workerinput['workerid']
-    os.environ['PYTEST_XDIST_WORKER_COUNT'] = str(workerinput['workercount'])
-    # os.environ['PYTHONPATH'] = importpath
-    import py
-    config = remote_initconfig(option_dict, args)
-    config.workerinput = workerinput
-    config.workeroutput = {}
-    # TODO: deprecated name, backward compatibility only. Remove it in future
-    config.slaveinput = config.workerinput
-    config.slaveoutput = config.workeroutput
-    interactor = WorkerInteractor(config, channel)
-    config.hook.pytest_cmdline_main(config=config)