Release 1.24.0

Add --maxprocesses option to use with --numprocesses=auto

.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

@@ -22,6 +22,7 @@ dist/
 include/
 lib/
 bin/
+env/
 xdist/_version.py*
 pytest_xdist.egg-info
 issue/
@@ -29,5 +30,6 @@ issue/
 pytestdebug.log
 .tox/
 .cache/
+.pytest_cache/
 .eggs/
 .idea/

.pre-commit-config.yaml

@@ -0,0 +1,24 @@
+repos:
+-   repo: https://github.com/ambv/black
+    rev: 18.6b4
+    hooks:
+    -   id: black
+        args: [--safe, --quiet]
+        language_version: python3.6
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v1.3.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]
+        python_version: python3.6

.travis.yml

@@ -21,12 +21,24 @@ env:
 - TOXENV=py-pytest31
 - TOXENV=py-pytest32
 - TOXENV=py-pytest33
+- TOXENV=py-pytest36
+- TOXENV=py-pytest38
 
 install: pip install tox setuptools_scm
 script: tox
 
+stages:
+- linting
+- test
+- name: deploy
+  if: repo = pytest-dev/pytest-xdist AND tag IS present
+
 jobs:
   include:
+    - stage: linting
+      python: '3.6'
+      script:
+      - tox -e linting
     - stage: test
     # python x env above are already included into this stage
     - python: "2.7"
@@ -37,10 +49,6 @@ jobs:
       env: TOXENV=py36-pytestmaster
     - python: "3.6"
       env: TOXENV=py36-pytestfeatures
-    - python: "3.6"
-      env: TOXENV=flakes
-    - python: "3.6"
-      env: TOXENV=readme
 
     - stage: deploy
       python: '3.6'
@@ -50,7 +58,7 @@ jobs:
       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,116 @@
+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)
+================================
+
+Bug Fixes
+---------
+
+- Add backward compatibility for ``slaveoutput`` attribute to
+  ``WorkerController`` instances. (`#285
+  <https://github.com/pytest-dev/pytest-xdist/issues/285>`_)
+
+
+pytest-xdist 1.22.1 (2018-02-19)
+================================
+
+Bug Fixes
+---------
+
+- Fix issue when using ``loadscope`` or ``loadfile`` where tests would fail to
+  start if the first scope had only one test. (`#257
+  <https://github.com/pytest-dev/pytest-xdist/issues/257>`_)
+
+
+Trivial Changes
+---------------
+
+- Change terminology used by ``pytest-xdist`` to *master* and *worker* in
+  arguments and messages (for example ``--max-worker-reset``). (`#234
+  <https://github.com/pytest-dev/pytest-xdist/issues/234>`_)
+
+
 pytest-xdist 1.22.0 (2018-01-11)
 ================================
 

HOWTORELEASE.rst

@@ -24,15 +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 . -r dev-requirements.txt
+    $ pip install tox
 
-#. Update ``CHANGELOG.rst`` file by running::
+#. Update the necessary files with::
 
-    $ towncrier --version X.Y.Z
-
-   It might ask for confirmation to remove news fragments; answer 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.
-

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
 
-xdist: pytest distributed testing plugin
-=========================================
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/ambv/black
 
-The `pytest-xdist`_ plugin extends py.test with some unique
+xdist: pytest distributed testing plugin
+========================================
+
+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,24 +34,24 @@ 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>`_.
 
 
 Installation
------------------------
+------------
 
 Install the plugin with::
 
@@ -58,43 +60,54 @@ Install the plugin with::
 or use the package in develop/in-place mode with
 a checkout of the `pytest-xdist repository`_ ::
 
-    python setup.py develop
-
-Usage examples
----------------------
+    pip install --editable .
 
 .. _parallelization:
 
 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 IO this can lead to considerable speed ups. This option can
+a lot of I/O this can lead to considerable speed ups. This option can
 also be set to ``auto`` for automatic detection of the number of CPUs.
 
 If a test crashes the interpreter, pytest-xdist will automatically restart
-that slave and report the failure as usual. You can use the
-``--max-slave-restart`` option to limit the number of slaves that can
-be restarted, or disable restarting altogether using ``--max-slave-restart=0``.
+that worker and report the failure as usual. You can use the
+``--max-worker-restart`` option to limit the number of workers that can
+be restarted, or disable restarting altogether using ``--max-worker-restart=0``.
+
+By default, the ``-n`` option will send pending tests to any worker that is available, without
+any guaranteed order, but you can control this with these options:
+
+* ``--dist=loadscope``: tests will be grouped by **module** for *test functions* and
+  by **class** for *test methods*, then each group will be sent to an available worker,
+  guaranteeing that all tests in a group run in the same process. This can be useful if you have
+  expensive module-level or class-level fixtures. Currently the groupings can't be customized,
+  with grouping by class takes priority over grouping by module.
+  This feature was added in version ``1.19``.
+
+* ``--dist=loadfile``: tests will be grouped by file name, and then will be sent to an available
+  worker, guaranteeing that all tests in a group run in the same worker. This feature was added
+  in version ``1.21``.
 
 
 Running tests in a Python subprocess
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+------------------------------------
 
-To instantiate a python2.5 sub process and send tests to it, you may type::
+To instantiate a python3.5 subprocess and send tests to it, you may type::
 
-    py.test -d --tx popen//python=python2.5
+    pytest -d --tx popen//python=python3.5
 
-This will start a subprocess which is run with the "python2.5"
+This will start a subprocess which is run with the ``python3.5``
 Python interpreter, found in your system binary lookup path.
 
 If you prefix the --tx option value like this::
 
-    --tx 3*popen//python=python2.5
+    --tx 3*popen//python=python3.5
 
 then three subprocesses would be created and tests
 will be load-balanced across these three processes.
@@ -102,38 +115,26 @@ will be load-balanced across these three processes.
 .. _boxed:
 
 Running tests in a boxed subprocess
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-If you have tests involving C or C++ libraries you might have to deal
-with tests crashing the process.  For this case you may use the boxing
-options::
-
-    py.test --boxed
-
-which will run each test in a subprocess and will report if a test
-crashed the process.  You can also combine this option with
-running multiple processes to speed up the test run and use your CPU cores::
-
-    py.test -n3 --boxed
-
-this would run 3 testing subprocesses in parallel which each
-create new boxed subprocesses for each test.
+-----------------------------------
 
+This functionality has been moved to the
+`pytest-forked <https://github.com/pytest-dev/pytest-forked>`_ plugin, but the ``--boxed`` option
+is still kept for backward compatibility.
 
 .. _`remote machines`:
 
 Sending tests to remote SSH accounts
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+------------------------------------
 
 Suppose you have a package ``mypkg`` which contains some
 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
@@ -141,11 +142,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.
 
@@ -158,7 +159,7 @@ ini-file option(s).
 
 
 Sending tests to remote Socket Servers
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+--------------------------------------
 
 Download the single-module `socketserver.py`_ Python program
 and run it like this::
@@ -169,7 +170,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`:
@@ -177,16 +178,16 @@ new socket host with something like this::
 
 
 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
 platforms - and report back failures from all platforms
-at once.   The specifications strings use the `xspec syntax`_.
+at once. The specifications strings use the `xspec syntax`_.
 
 .. _`xspec syntax`: http://codespeak.net/execnet/basics.html#xspec
 
@@ -195,7 +196,7 @@ at once.   The specifications strings use the `xspec syntax`_.
 .. _`execnet`: http://codespeak.net/execnet
 
 Identifying the worker process during a test
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+--------------------------------------------
 
 *New in version 1.15.*
 
@@ -219,16 +220,15 @@ defined:
 * ``PYTEST_XDIST_WORKER_COUNT``: the total number of workers in this session,
   e.g., ``"4"`` when ``-n 4`` is given in the command-line.
 
-The information about the worker_id in a test is stored in the TestReport as
-well, under worker_id attribute.
+The information about the worker_id in a test is stored in the ``TestReport`` as
+well, under the ``worker_id`` attribute.
 
 
 Specifying test exec environments in an ini file
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+------------------------------------------------
 
-pytest (since version 2.0) supports ini-style cofiguration.
-You can for example make running with three subprocesses
-your default like this:
+You can use pytest's ini file configuration to avoid typing common options.
+You can for example make running with three subprocesses your default like this:
 
 .. code-block:: ini
 
@@ -240,109 +240,17 @@ You can also add default environments like this:
 .. code-block:: ini
 
     [pytest]
-    addopts = --tx ssh=myhost//python=python2.5 --tx ssh=myhost//python=python3.6
+    addopts = --tx ssh=myhost//python=python3.5 --tx ssh=myhost//python=python3.6
 
 and then just type::
 
-    py.test --dist=each
+    pytest --dist=each
 
 to run tests in each of the environments.
 
 
-Sending groups of related tests to the same worker
-++++++++++++++++++++++++++++++++++++++++++++++++++
-
-*New in version 1.19.*
-
-.. note::
-    This is an **experimental** feature: the actual functionality will
-    likely stay the same, but the CLI might change slightly in future versions.
-
-You can send groups of related tests to the same worker by using the
-``--dist=loadscope`` option. Tests will be grouped by **module**
-for *test functions* and by **class** for *test methods*.
-
-For example, consider this two test files:
-
-.. code-block:: python
-
-    # content of test_container.py
-    import pytest
-
-    def test_container_startup():
-        pass
-
-    def test_container_logging():
-        pass
-
-    @pytest.mark.parametrize('methods', ['ssh', 'http'])
-    def test_container_communication(methods):
-        pass
-
-    # content of test_io.py
-    class TestHDF:
-
-        def test_listing(self):
-            pass
-
-        def test_search(self):
-            pass
-
-
-    class TestXML:
-
-        def test_listing(self):
-            pass
-
-        def test_search(self):
-            pass
-
-
-By executing ``pytest -v --dist=loadscope -n4`` you might get this output
-(sorted by worker for readability)::
-
-    ============================= test session starts =============================
-    <skip header>
-    gw0 [8] / gw1 [8] / gw2 [8] / gw3 [8]
-    scheduling tests via LoadScopeScheduling
-
-    [gw0] PASSED test_container.py::test_container_communication[http]
-    [gw0] PASSED test_container.py::test_container_communication[ssh]
-    [gw0] PASSED test_container.py::test_container_logging
-    [gw0] PASSED test_container.py::test_container_startup
-    [gw1] PASSED test_io.py::TestHDF::test_listing
-    [gw1] PASSED test_io.py::TestHDF::test_search
-    [gw2] PASSED test_io.py::TestXML::test_listing
-    [gw2] PASSED test_io.py::TestXML::test_search
-
-    ========================== 8 passed in 0.56 seconds ===========================
-
-As you can see, all test functions from ``test_container.py`` executed on
-the same worker ``gw0``, while the test methods from classes ``TestHDF`` and
-``TestXML`` executed in workers ``gw1`` and ``gw2`` respectively.
-
-Currently the groupings can't be customized, with grouping by class takes
-priority over grouping by module.
-
-Sending tests to the same worker based on their file
-++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-*New in version 1.21.*
-
-.. note::
-    This is an **experimental** feature: the actual functionality will
-    likely stay the same, but the CLI might change slightly in future versions.
-
-You can send tests to the same worker grouped by their filename by using the
-``--dist=loadfile`` option, so tests of the same file are guaranteed to run
-in the same worker.
-
-Using the example in the previous section, all tests from ``test_container.py`` will
-run in the same worker, as well as the tests in ``test_io.py``.
-
-
 Specifying "rsync" dirs in an ini-file
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+--------------------------------------
 
 In a ``tox.ini`` or ``setup.cfg`` file in your root project directory
 you may specify directories to include or to exclude in synchronisation:

appveyor.yml

@@ -5,15 +5,19 @@ environment:
   - TOXENV: "py34-pytest33"
   - TOXENV: "py35-pytest33"
   - TOXENV: "py36-pytest33"
+  - TOXENV: "py36-pytest36"
+  - TOXENV: "py36-pytest38"
   - TOXENV: "py27-pytest33-pexpect"
   - TOXENV: "py36-pytest33-pexpect"
-  - TOXENV: "flakes"
-  - TOXENV: "readme"
 
 install:
-  - C:\Python35\python -m pip install -U tox setuptools_scm pip
+  - C:\Python36\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
+  - C:\Python36\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

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 \

pyproject.toml

@@ -33,4 +33,4 @@ template = "changelog/_template.rst"
   [[tool.towncrier.type]]
   directory = "trivial"
   name = "Trivial Changes"
-  showcontent = false
+  showcontent = true

setup.py

@@ -1,47 +1,44 @@
 from setuptools import setup, find_packages
 
-install_requires = ['execnet>=1.1', 'pytest>=3.0.0', 'pytest-forked']
+install_requires = ["execnet>=1.1", "pytest>=3.0.0", "pytest-forked", "six"]
 
 
 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": "xdist/_version.py"},
+    description="pytest 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"]),
     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.*",
     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.4",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
     ],
 )

testing/conftest.py

@@ -20,6 +20,7 @@ pytest_plugins = "pytester"
 @pytest.fixture(autouse=True)
 def _divert_atexit(request, monkeypatch):
     import atexit
+
     finalizers = []
 
     def finish():
@@ -31,10 +32,12 @@ def _divert_atexit(request, monkeypatch):
 
 
 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

testing/test_dsession.py

@@ -1,9 +1,6 @@
 from xdist.dsession import DSession
 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
@@ -203,7 +200,7 @@ class TestLoadScheduling:
     def test_different_tests_collected(self, testdir):
         """
         Test that LoadScheduling is reporting collection errors when
-        different test ids are collected by slaves.
+        different test ids are collected by workers.
         """
 
         class CollectHook(object):
@@ -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,50 @@ 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_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

@@ -60,7 +60,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 +84,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 +110,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 +137,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 +157,87 @@ 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+")
+    @py.test.mark.xfail(py.test.__version__ >= "3.1", reason="broken by pytest 3.1+")
     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 +246,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 +261,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 +283,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,58 @@ 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)
         """
-        testdir.makeconftest("""
+        testdir.makeconftest(
+            """
             def pytest_runtest_logreport(report):
                 if hasattr(report, 'node'):
                     if report.when == "call":
-                        slaveid = report.node.slaveinput['slaveid']
-                        if slaveid != report.worker_id:
+                        workerid = report.node.workerinput['workerid']
+                        if workerid != report.worker_id:
                             print("HOOK: Worker id mismatch: %s %s"
-                                   % (slaveid, report.worker_id))
+                                   % (workerid, report.worker_id))
                         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*',
-        ])
+        """
+        )
+        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):
-                slaveid = node.slaveinput['slaveid']
+                workerid = node.workerinput['workerid']
                 stripped_ids = [x.split('::')[1] for x in ids]
-                print("HOOK: %s %s" % (slaveid, ', '.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*',
-        ])
+                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*"])

testing/test_plugin.py

@@ -1,6 +1,6 @@
 import py
 import execnet
-from xdist.slavemanage import NodeManager
+from xdist.workermanage import NodeManager
 
 
 def test_dist_incompatibility_messages(testdir):
@@ -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,31 @@ 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)
+
+    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
+
+    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
@@ -85,13 +100,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 +114,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,12 @@
 import py
+import pprint
 import pytest
-from xdist.slavemanage import SlaveController, unserialize_report
+from xdist.workermanage import WorkerController, unserialize_report
 from xdist.remote import serialize_report
 import execnet
 import marshal
 
-queue = py.builtin._tryimport("queue", "Queue")
+from six.moves.queue import Queue
 
 WAIT_TIMEOUT = 10.0
 
@@ -14,7 +15,7 @@ def check_marshallable(d):
     try:
         marshal.dumps(d)
     except ValueError:
-        py.std.pprint.pprint(d)
+        pprint.pprint(d)
         raise ValueError("not marshallable")
 
 
@@ -26,15 +27,15 @@ class EventCall:
         return "<EventCall %s(**%s)>" % (self.name, self.kwargs)
 
 
-class SlaveSetup:
+class WorkerSetup:
     use_callback = False
 
     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()
@@ -44,8 +45,7 @@ class SlaveSetup:
         class DummyMananger:
             specs = [0, 1]
 
-        self.slp = SlaveController(DummyMananger, self.gateway, config,
-                                   putevent)
+        self.slp = WorkerController(DummyMananger, self.gateway, config, putevent)
         self.request.addfinalizer(self.slp.ensure_teardown)
         self.slp.setup()
 
@@ -58,20 +58,21 @@ class SlaveSetup:
             ev = EventCall(data)
             if name is None or ev.name == name:
                 return ev
-            print("skipping %s" % (ev, ))
+            print("skipping %s" % (ev,))
 
     def sendcommand(self, name, **kwargs):
         self.slp.sendcommand(name, **kwargs)
 
 
 @pytest.fixture
-def slave(request, testdir):
-    return SlaveSetup(request, testdir)
+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__
@@ -80,29 +81,33 @@ def test_remoteinitconfig(testdir):
 
 class TestReportSerialization:
     def test_xdist_longrepr_to_str_issue_241(self, testdir):
-        testdir.makepyfile("""
+        testdir.makepyfile(
+            """
             import os
             def test_a(): assert False
             def test_b(): pass
-        """)
-        testdir.makeconftest("""
+        """
+        )
+        testdir.makeconftest(
+            """
             def pytest_runtest_logreport(report):
                 print(report.longrepr)
-        """)
-        res = testdir.runpytest('-n1', '-s')
-        res.stdout.fnmatch_lines([
-            '*1 failed, 1 passed *'
-        ])
+        """
+        )
+        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("""
+        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"), "*")
+        added_section = ("Failure Metadata", str("metadata metadata"), "*")
         rep.longrepr.sections.append(added_section)
         d = serialize_report(rep)
         check_marshallable(d)
@@ -110,28 +115,31 @@ class TestReportSerialization:
         # Check assembled == rep
         assert a.__dict__.keys() == rep.__dict__.keys()
         for key in rep.__dict__.keys():
-            if key != 'longrepr':
+            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.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("""
+
+        reprec = testdir.inline_runsource(
+            """
                             def test_repr_entry():
                                 x = 0
                                 assert x
-                        """, '--showlocals')
+                        """,
+            "--showlocals",
+        )
         reports = reprec.getreports("pytest_runtest_logreport")
         assert len(reports) == 3
         rep = reports[1]
@@ -145,7 +153,9 @@ class TestReportSerialization:
             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.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
@@ -153,11 +163,15 @@ class TestReportSerialization:
 
     def test_reprentries_serialization_196(self, testdir):
         from _pytest._code.code import ReprEntryNative
-        reprec = testdir.inline_runsource("""
+
+        reprec = testdir.inline_runsource(
+            """
                             def test_repr_entry_native():
                                 x = 0
                                 assert x
-                        """, '--tb=native')
+                        """,
+            "--tb=native",
+        )
         reports = reprec.getreports("pytest_runtest_logreport")
         assert len(reports) == 3
         rep = reports[1]
@@ -171,7 +185,8 @@ class TestReportSerialization:
             assert rep_entries[i].lines == a_entries[i].lines
 
     def test_itemreport_outcomes(self, testdir):
-        reprec = testdir.inline_runsource("""
+        reprec = testdir.inline_runsource(
+            """
             import py
             def test_pass(): pass
             def test_fail(): 0/0
@@ -183,7 +198,8 @@ class TestReportSerialization:
             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:
@@ -243,133 +259,144 @@ class TestReportSerialization:
                 assert newrep.longrepr == str(rep.longrepr)
 
 
-class TestSlaveInteractor:
-    def test_basic_collect_and_runtests(self, slave):
-        slave.testdir.makepyfile("""
+class TestWorkerInteractor:
+    def test_basic_collect_and_runtests(self, worker):
+        worker.testdir.makepyfile(
+            """
             def test_func():
                 pass
-        """)
-        slave.setup()
-        ev = slave.popevent()
-        assert ev.name == "slaveready"
-        ev = slave.popevent()
+        """
+        )
+        worker.setup()
+        ev = worker.popevent()
+        assert ev.name == "workerready"
+        ev = worker.popevent()
         assert ev.name == "collectionstart"
         assert not ev.kwargs
-        ev = slave.popevent("collectionfinish")
-        assert ev.kwargs['topdir'] == slave.testdir.tmpdir
-        ids = ev.kwargs['ids']
+        ev = worker.popevent("collectionfinish")
+        assert ev.kwargs["topdir"] == worker.testdir.tmpdir
+        ids = ev.kwargs["ids"]
         assert len(ids) == 1
-        slave.sendcommand("runtests", indices=list(range(len(ids))))
-        slave.sendcommand("shutdown")
-        ev = slave.popevent("logstart")
+        worker.sendcommand("runtests", indices=list(range(len(ids))))
+        worker.sendcommand("shutdown")
+        ev = worker.popevent("logstart")
         assert ev.kwargs["nodeid"].endswith("test_func")
         assert len(ev.kwargs["location"]) == 3
-        ev = slave.popevent("testreport")  # setup
-        ev = slave.popevent("testreport")
+        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.name, ev.kwargs["data"])
         assert rep.nodeid.endswith("::test_func")
         assert rep.passed
         assert rep.when == "call"
-        ev = slave.popevent("slavefinished")
-        assert 'slaveoutput' in ev.kwargs
+        ev = worker.popevent("workerfinished")
+        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, slave):
-        slave.testdir.makepyfile("""
+    @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")
-        """)
-        slave.setup()
-        ev = slave.popevent("collectionstart")
+        """
+        )
+        worker.setup()
+        ev = worker.popevent("collectionstart")
         assert not ev.kwargs
-        ev = slave.popevent()
+        ev = worker.popevent()
         assert ev.name == "collectreport"
-        ev = slave.popevent()
+        ev = worker.popevent()
         assert ev.name == "collectreport"
-        rep = unserialize_report(ev.name, ev.kwargs['data'])
+        rep = unserialize_report(ev.name, ev.kwargs["data"])
         assert rep.skipped
-        ev = slave.popevent("collectionfinish")
-        assert not ev.kwargs['ids']
+        ev = worker.popevent("collectionfinish")
+        assert not ev.kwargs["ids"]
 
-    def test_remote_collect_fail(self, slave):
-        slave.testdir.makepyfile("""aasd qwe""")
-        slave.setup()
-        ev = slave.popevent("collectionstart")
+    def test_remote_collect_fail(self, worker):
+        worker.testdir.makepyfile("""aasd qwe""")
+        worker.setup()
+        ev = worker.popevent("collectionstart")
         assert not ev.kwargs
-        ev = slave.popevent()
+        ev = worker.popevent()
         assert ev.name == "collectreport"
-        ev = slave.popevent()
-        assert ev.name == "collectreport"
-        rep = unserialize_report(ev.name, ev.kwargs['data'])
+        rep = unserialize_report(ev.name, ev.kwargs["data"])
         assert rep.failed
-        ev = slave.popevent("collectionfinish")
-        assert not ev.kwargs['ids']
+        ev = worker.popevent("collectionfinish")
+        assert not ev.kwargs["ids"]
 
-    def test_runtests_all(self, slave):
-        slave.testdir.makepyfile("""
+    def test_runtests_all(self, worker):
+        worker.testdir.makepyfile(
+            """
             def test_func(): pass
             def test_func2(): pass
-        """)
-        slave.setup()
-        ev = slave.popevent()
-        assert ev.name == "slaveready"
-        ev = slave.popevent()
+        """
+        )
+        worker.setup()
+        ev = worker.popevent()
+        assert ev.name == "workerready"
+        ev = worker.popevent()
         assert ev.name == "collectionstart"
         assert not ev.kwargs
-        ev = slave.popevent("collectionfinish")
-        ids = ev.kwargs['ids']
+        ev = worker.popevent("collectionfinish")
+        ids = ev.kwargs["ids"]
         assert len(ids) == 2
-        slave.sendcommand("runtests_all", )
-        slave.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 = slave.popevent("testreport")
+                ev = worker.popevent("testreport")
                 assert ev.name == "testreport"
-                rep = unserialize_report(ev.name, ev.kwargs['data'])
+                rep = unserialize_report(ev.name, ev.kwargs["data"])
                 assert rep.nodeid.endswith(func)
-        ev = slave.popevent("slavefinished")
-        assert 'slaveoutput' in ev.kwargs
+        ev = worker.popevent("workerfinished")
+        assert "workeroutput" in ev.kwargs
 
-    def test_happy_run_events_converted(self, testdir, slave):
+    def test_happy_run_events_converted(self, testdir, worker):
         py.test.xfail("implement a simple test for event production")
-        assert not slave.use_callback
-        slave.testdir.makepyfile("""
+        assert not worker.use_callback
+        worker.testdir.makepyfile(
+            """
             def test_func():
                 pass
-        """)
-        slave.setup()
-        hookrec = testdir.getreportrecorder(slave.config)
-        for data in slave.slp.channel:
-            slave.slp.process_from_remote(data)
-        slave.slp.process_from_remote(slave.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"),
-        ])
+        """
+        )
+        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)
+        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, slave, capsys):
-        slave.use_callback = True
-        slave.setup()
-        slave.slp.process_from_remote(('<nonono>', ()))
+    def test_process_from_remote_error_handling(self, worker, capsys):
+        worker.use_callback = True
+        worker.setup()
+        worker.slp.process_from_remote(("<nonono>", ()))
         out, err = capsys.readouterr()
-        assert 'INTERNALERROR> ValueError: unknown event: <nonono>' in out
-        ev = slave.popevent()
+        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 os.environ['PYTEST_XDIST_WORKER'] in ('gw0', 'gw1')
             assert os.environ['PYTEST_XDIST_WORKER_COUNT'] == '2'
-    ''')
-    result = testdir.runpytest('-n2', '--max-slave-restart=0')
+    """
+    )
+    result = testdir.runpytest("-n2", "--max-worker-restart=0")
     assert result.ret == 0

testing/test_slavemanage.py

@@ -1,9 +1,11 @@
+from __future__ import print_function
 import py
 import pytest
+import textwrap
 import execnet
 from _pytest.pytester import HookRecorder
-from xdist import slavemanage, newhooks
-from xdist.slavemanage import HostRSync, NodeManager
+from xdist import workermanage, newhooks
+from xdist.workermanage import HostRSync, NodeManager
 
 pytest_plugins = "pytester"
 
@@ -32,7 +34,7 @@ def mysetup(tmpdir):
 
 
 @pytest.fixture
-def slavecontroller(monkeypatch):
+def workercontroller(monkeypatch):
     class MockController(object):
         def __init__(self, *args):
             pass
@@ -40,7 +42,7 @@ def slavecontroller(monkeypatch):
         def setup(self):
             pass
 
-    monkeypatch.setattr(slavemanage, 'SlaveController', 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,
-                                      slavecontroller):
+    def test_popen_makegateway_events(self, config, hookrecorder, workercontroller):
         hm = NodeManager(config, ["popen"] * 2)
         hm.setup_nodes(None)
         call = hookrecorder.popcall("pytest_xdist_setupnodes")
@@ -72,7 +73,7 @@ class TestNodeManagerPopen:
         hm.teardown_nodes()
         assert not len(hm.group)
 
-    def test_popens_rsync(self, config, mysetup, slavecontroller):
+    def test_popens_rsync(self, config, mysetup, workercontroller):
         source = mysetup.source
         hm = NodeManager(config, ["popen"] * 2)
         hm.setup_nodes(None)
@@ -97,7 +98,7 @@ class TestNodeManagerPopen:
         assert not len(hm.group)
         assert "sys.path.insert" in gw.remote_exec.args[0]
 
-    def test_rsync_popen_with_path(self, config, mysetup, slavecontroller):
+    def test_rsync_popen_with_path(self, config, mysetup, workercontroller):
         source, dest = mysetup.source, mysetup.dest
         hm = NodeManager(config, ["popen//chdir=%s" % dest] * 1)
         hm.setup_nodes(None)
@@ -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,
-                                    slavecontroller):
+    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
@@ -167,41 +169,48 @@ class TestNodeManager:
         nodemanager.makegateways()
         nodemanager.rsync_roots()
         p, = nodemanager.gwmanager.multi_exec(
-            "import os ; channel.send(os.getcwd())").receive_each()
+            "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()
 
-    def test_popen_rsync_subdir(self, testdir, mysetup, slavecontroller):
+    def test_popen_rsync_subdir(self, testdir, mysetup, workercontroller):
         source, dest = mysetup.source, mysetup.dest
         dir1 = mysetup.source.mkdir("dir1")
         dir2 = dir1.mkdir("dir2")
         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, slavecontroller):
+    def test_init_rsync_roots(self, testdir, mysetup, workercontroller):
         source, dest = mysetup.source, mysetup.dest
         dir2 = source.ensure("dir1", "dir2", dir=1)
         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()
@@ -209,7 +218,7 @@ class TestNodeManager:
         assert not dest.join("dir1").check()
         assert not dest.join("bogus").check()
 
-    def test_rsyncignore(self, testdir, mysetup, slavecontroller):
+    def test_rsyncignore(self, testdir, mysetup, workercontroller):
         source, dest = mysetup.source, mysetup.dest
         dir2 = source.ensure("dir1", "dir2", dir=1)
         source.ensure("dir5", "dir6", "bogus")
@@ -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, slavecontroller):
+    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)
+        """,
+        )
+        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,11 +1,10 @@
 [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
+  linting
+  py{27,34,35,36}-pytest{30,31,32,33,36,38}
+  py{27,36}-pytest36-pexpect
   py{27,36}-pytest{master,features}
-  flakes
-  readme
 
 
 [testenv]
@@ -19,28 +18,41 @@ deps =
   pytest31: pytest~=3.1.0
   pytest32: pytest~=3.2.0
   pytest33: pytest~=3.3.0
+  pytest36: pytest~=3.6.0
+  pytest38: pytest~=3.8.0
   pytestmaster: git+https://github.com/pytest-dev/pytest.git@master
   pytestfeatures: git+https://github.com/pytest-dev/pytest.git@features
   pexpect: pexpect
+  filelock
 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.6
+skipsdist = True
+usedevelop = True
+passenv = *
+deps =
+    towncrier
+commands =
+    towncrier --version {posargs} --yes
 
 [pytest]
 addopts = -rsfxX
-;; hello
+
+[flake8]
+max-line-length = 120
+ignore = E203,W503

xdist/__init__.py

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

xdist/dsession.py

@@ -1,7 +1,7 @@
 import py
 import pytest
 
-from xdist.slavemanage import NodeManager
+from xdist.workermanage import NodeManager
 from xdist.scheduler import (
     EachScheduling,
     LoadScheduling,
@@ -10,23 +10,23 @@ 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
-    events processed in the pytest_runtestloop hook using the slave_*
+    events processed in the pytest_runtestloop hook using the worker_*
     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,14 +41,14 @@ 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_slave_restart = self.config.getoption('max_slave_restart')
-        if self._max_slave_restart is not None:
-            self._max_slave_restart = int(self._max_slave_restart)
+        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:
@@ -75,7 +75,7 @@ class DSession:
         """Creates and starts the nodes.
 
         The nodes are setup to put their events onto self.queue.  As
-        soon as nodes start they will emit the slave_slaveready event.
+        soon as nodes start they will emit the worker_workerready event.
         """
         self.nodemanager = NodeManager(self.config)
         nodes = self.nodemanager.setup_nodes(putevent=self.queue.put)
@@ -84,7 +84,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 +95,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
 
@@ -120,7 +119,7 @@ class DSession:
         return True
 
     def loop_once(self):
-        """Process one callback from one of the slaves."""
+        """Process one callback from one of the workers."""
         while 1:
             if not self._active_nodes:
                 # If everything has died stop looping
@@ -129,11 +128,11 @@ class DSession:
             try:
                 eventcall = self.queue.get(timeout=2.0)
                 break
-            except queue.Empty:
+            except Empty:
                 continue
         callname, kwargs = eventcall
         assert callname, kwargs
-        method = "slave_" + callname
+        method = "worker_" + callname
         call = getattr(self, method)
         self.log("calling method", method, kwargs)
         call(**kwargs)
@@ -141,44 +140,48 @@ class DSession:
             self.triggershutdown()
 
     #
-    # callbacks for processing events from slaves
+    # callbacks for processing events from workers
     #
 
-    def slave_slaveready(self, node, slaveinfo):
+    def worker_workerready(self, node, workerinfo):
         """Emitted when a node first starts up.
 
         This adds the node to the scheduler, nodes continue with
         collection without any further input.
         """
-        node.slaveinfo = slaveinfo
-        node.slaveinfo['id'] = node.gateway.id
-        node.slaveinfo['spec'] = node.gateway.spec
+        node.workerinfo = workerinfo
+        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
+
         self.config.hook.pytest_testnodeready(node=node)
         if self.shuttingdown:
             node.shutdown()
         else:
             self.sched.add_node(node)
 
-    def slave_slavefinished(self, node):
+    def worker_workerfinished(self, node):
         """Emitted when node executes its pytest_sessionfinish hook.
 
         Removes the node from the scheduler.
 
         The node might not be in the scheduler if it had not emitted
-        slaveready before shutdown was triggered.
+        workerready before shutdown was triggered.
         """
         self.config.hook.pytest_testnodedown(node=node, error=None)
-        if node.slaveoutput['exitstatus'] == 2:  # keyboard-interrupt
+        if node.workeroutput["exitstatus"] == 2:  # keyboard-interrupt
             self.shouldstop = "%s received keyboard-interrupt" % (node,)
-            self.slave_errordown(node, "keyboard-interrupt")
+            self.worker_errordown(node, "keyboard-interrupt")
             return
         if node in self.sched.nodes:
             crashitem = self.sched.remove_node(node)
             assert not crashitem, (crashitem, node)
         self._active_nodes.remove(node)
 
-    def slave_errordown(self, node, error):
-        """Emitted by the SlaveController when a node dies."""
+    def worker_errordown(self, node, error):
+        """Emitted by the WorkerController when a node dies."""
         self.config.hook.pytest_testnodedown(node=node, error=error)
         try:
             crashitem = self.sched.remove_node(node)
@@ -189,22 +192,23 @@ class DSession:
                 self.handle_crashitem(crashitem, node)
 
         self._failed_nodes_count += 1
-        maximum_reached = (self._max_slave_restart is not None and
-                           self._failed_nodes_count > self._max_slave_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_slave_restart == 0:
-                msg = 'Slave restarting disabled'
+            if self._max_worker_restart == 0:
+                msg = "Worker restarting disabled"
             else:
-                msg = "Maximum crashed slaves reached: %d" % \
-                      self._max_slave_restart
+                msg = "Maximum crashed workers reached: %d" % self._max_worker_restart
             self.report_line(msg)
         else:
-            self.report_line("Replacing crashed slave %s" % node.gateway.id)
+            self.report_line("Replacing crashed worker %s" % node.gateway.id)
             self._clone_node(node)
         self._active_nodes.remove(node)
 
-    def slave_collectionfinish(self, node, ids):
-        """Slave has finished test collection.
+    def worker_collectionfinish(self, node, ids):
+        """worker has finished test collection.
 
         This adds the collection for this node to the scheduler.  If
         the scheduler indicates collection is finished (i.e. all
@@ -214,8 +218,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)
@@ -226,27 +229,26 @@ 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__))
+                self.terminal.write_line(
+                    "scheduling tests via %s" % (self.sched.__class__.__name__)
+                )
             self.sched.schedule()
 
-    def slave_logstart(self, node, nodeid, location):
+    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 slave_logfinish(self, node, nodeid, 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 slave_testreport(self, node, rep):
+    def worker_testreport(self, node, rep):
         """Emitted when a node calls the pytest_runtest_logreport hook."""
         rep.node = node
         self.config.hook.pytest_runtest_logreport(report=rep)
         self._handlefailures(rep)
 
-    def slave_runtest_protocol_complete(self, node, item_index, duration):
+    def worker_runtest_protocol_complete(self, node, item_index, duration):
         """
         Emitted when a node fires the 'runtest_protocol_complete' event,
         signalling that a test has completed the runtestprotocol and should be
@@ -254,23 +256,32 @@ class DSession:
         """
         self.sched.mark_test_complete(node, item_index, duration)
 
-    def slave_collectreport(self, node, rep):
-        """Emitted when a node calls the pytest_collectreport hook."""
-        if rep.failed:
-            self._failed_slave_collectreport(node, rep)
+    def worker_collectreport(self, node, rep):
+        """Emitted when a node calls the pytest_collectreport hook.
 
-    def slave_logwarning(self, message, code, nodeid, fslocation):
+        Because we only need the report when there's a failure, as optimization
+        we only expect to receive failed reports from workers (#330).
+        """
+        assert rep.failed
+        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_logwarning hook."""
+        kwargs = dict(warning_message=warning_message, when=when, item=item)
+        self.config.hook.pytest_warning_captured.call_historic(kwargs=kwargs)
+
     def _clone_node(self, node):
         """Return new node based on an existing one.
 
         This is normally for when a node dies, this will copy the spec
         of the existing node and create a new one with a new id.  The
         new node will have been setup so it will start calling the
-        "slave_*" hooks and do work soon.
+        "worker_*" hooks and do work soon.
         """
         spec = node.gateway.spec
         spec.id = None
@@ -279,9 +290,9 @@ class DSession:
         self._active_nodes.add(node)
         return node
 
-    def _failed_slave_collectreport(self, node, rep):
+    def _failed_worker_collectreport(self, node, rep):
         # Check we haven't already seen this report (from
-        # another slave).
+        # another worker).
         if rep.longrepr not in self._failed_collection_errors:
             self._failed_collection_errors[rep.longrepr] = True
             self.config.hook.pytest_collectreport(report=rep)
@@ -291,8 +302,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")
@@ -300,25 +310,26 @@ class DSession:
         for node in self.sched.nodes:
             node.shutdown()
 
-    def handle_crashitem(self, nodeid, slave):
+    def handle_crashitem(self, nodeid, worker):
         # XXX get more reporting info by recording pytest_runtest_logstart?
         # XXX count no of failures and retry N times
         runner = self.config.pluginmanager.getplugin("runner")
         fspath = nodeid.split("::")[0]
-        msg = "Slave %r crashed while running %r" % (slave.gateway.id, nodeid)
-        rep = runner.TestReport(nodeid, (fspath, None, fspath),
-                                (), "failed", msg, "???")
-        rep.node = slave
+        msg = "Worker %r crashed while running %r" % (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)
@@ -333,8 +344,7 @@ class TerminalDistReporter:
             self.rewrite(self.getstatus())
 
     def getstatus(self):
-        parts = ["%s %s" % (spec.id, self._status[spec.id])
-                 for spec in self._specs]
+        parts = ["%s %s" % (spec.id, self._status[spec.id]) for spec in self._specs]
         return " / ".join(parts)
 
     def rewrite(self, line, newline=False):
@@ -357,17 +367,17 @@ 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.slaveinfo
-            infoline = "[%s] Python %s" % (
-                d['id'],
-                d['version'].replace('\n', ' -- '),)
+            d = node.workerinfo
+            infoline = "[%s] Python %s" % (d["id"], d["version"].replace("\n", " -- "))
             self.rewrite(infoline, newline=True)
         self.setstatus(node.gateway.spec, "ok")
 

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")  # a core option
         if usepdb:
-            raise pytest.UsageError(
-                "--pdb incompatible with --looponfail.")
+            raise pytest.UsageError("--pdb 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,12 +71,12 @@ 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 slave session")
+        self.trace("setting up worker session")
         self.gateway = self.initgateway()
         self.channel = channel = self.gateway.remote_exec(
-            init_slave_session,
+            init_worker_session,
             args=self.config.args,
             option_dict=vars(self.config.option),
         )
@@ -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
@@ -134,11 +139,12 @@ def repr_pytest_looponfailinfo(failreports, rootdirs):
         tr.line("### Watching:   %s" % (rootdir,), bold=True)
 
 
-def init_slave_session(channel, args, option_dict):
+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_slave_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 SlaveFailSession
-    SlaveFailSession(config, channel).main()
+    from xdist.looponfail import WorkerFailSession
+
+    WorkerFailSession(config, channel).main()
 
 
-class SlaveFailSession:
+class WorkerFailSession(object):
     def __init__(self, config, channel):
         self.config = config
         self.channel = channel
@@ -180,7 +188,8 @@ class SlaveFailSession:
         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
 
@@ -194,11 +203,11 @@ class SlaveFailSession:
             self.collection_failed = True
 
     def main(self):
-        self.DEBUG("SLAVE: received configuration, waiting for command trails")
+        self.DEBUG("WORKER: received configuration, waiting for command trails")
         try:
             command = self.channel.receive()
         except KeyboardInterrupt:
-            return  # in the slave we can't do much about this
+            return  # in the worker we can't do much about this
         self.DEBUG("received", command)
         self.current_command = command
         self.config.hook.pytest_cmdline_main(config=self.config)
@@ -206,12 +215,12 @@ class SlaveFailSession:
         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():

xdist/plugin.py

@@ -1,18 +1,35 @@
+import os
+
 import py
 import pytest
 
 
-def parse_numprocesses(s):
-    if s == 'auto':
+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
-        try:
-            n = cpu_count()
-        except NotImplementedError:
-            return 1
-        return n if n else 1
+    else:
+
+        def cpu_count():
+            return len(sched_getaffinity(0))
+
+    try:
+        n = cpu_count()
+    except NotImplementedError:
+        return 1
+    return n if n else 1
+
+
+def parse_numprocesses(s):
+    if s == "auto":
+        return auto_detect_cpus()
     else:
         return int(s)
 
@@ -20,57 +37,109 @@ def parse_numprocesses(s):
 def pytest_addoption(parser):
     group = parser.getgroup("xdist", "distributed and subprocess testing")
     group._addoption(
-        '-n', '--numprocesses', dest="numprocesses", metavar="numprocesses",
+        "-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-slave-restart', action="store", default=None,
-                    help="maximum number of slaves that can be restarted "
-                         "when crashed (set to zero to disable this feature)")
+        "you can use 'auto' here for auto detection CPUs number on "
+        "host system",
+    )
     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."))
+        "--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(
-        '--tx', dest="tx", action="append", default=[],
+        "--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"))
+        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'")
+        "-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.")
+        "--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.")
+        "--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")
+        "--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")
+        "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")
+        "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()])
+        "looponfailroots",
+        type="pathlist",
+        help="directories to check for changes",
+        default=[py.path.local()],
+    )
 
 
 # -------------------------------------------------------------------------
@@ -80,12 +149,14 @@ def pytest_addoption(parser):
 
 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
 # -------------------------------------------------------------------------
@@ -95,6 +166,7 @@ def pytest_addhooks(pluginmanager):
 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")
@@ -106,18 +178,23 @@ def pytest_configure(config):
 @pytest.mark.tryfirst
 def pytest_cmdline_main(config):
     if config.option.numprocesses:
-        if config.option.dist == 'no':
+        if config.option.dist == "no":
             config.option.dist = "load"
-        config.option.tx = ['popen'] * config.option.numprocesses
+        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"):
-        usepdb = config.getoption('usepdb')  # a core option
+        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
+                    "--pdb is incompatible with distributing tests; try using -n0."
+                )  # noqa: E501
+
 
 # -------------------------------------------------------------------------
 # fixtures
@@ -129,7 +206,7 @@ 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, 'slaveinput'):
-        return request.config.slaveinput['slaveid']
+    if hasattr(request.config, "workerinput"):
+        return request.config.workerinput["workerid"]
     else:
-        return 'master'
+        return "master"

xdist/remote.py

@@ -14,11 +14,11 @@ import _pytest.hookspec
 import pytest
 
 
-class SlaveInteractor:
+class WorkerInteractor(object):
     def __init__(self, config, channel):
         self.config = config
-        self.slaveid = config.slaveinput.get('slaveid', "?")
-        self.log = py.log.Producer("slave-%s" % self.slaveid)
+        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
@@ -34,14 +34,14 @@ class SlaveInteractor:
 
     def pytest_sessionstart(self, session):
         self.session = session
-        slaveinfo = getinfodict()
-        self.sendevent("slaveready", slaveinfo=slaveinfo)
+        workerinfo = getinfodict()
+        self.sendevent("workerready", workerinfo=workerinfo)
 
     @pytest.hookimpl(hookwrapper=True)
     def pytest_sessionfinish(self, exitstatus):
-        self.config.slaveoutput['exitstatus'] = exitstatus
+        self.config.workeroutput["exitstatus"] = exitstatus
         yield
-        self.sendevent("slavefinished", slaveoutput=self.config.slaveoutput)
+        self.sendevent("workerfinished", workeroutput=self.config.workeroutput)
 
     def pytest_collection(self, session):
         self.sendevent("collectionstart")
@@ -56,7 +56,7 @@ class SlaveInteractor:
                 return True
             self.log("received command", name, kwargs)
             if name == "runtests":
-                torun.extend(kwargs['indices'])
+                torun.extend(kwargs["indices"])
             elif name == "runtests_all":
                 torun.extend(range(len(session.items)))
             self.log("items to run:", torun)
@@ -79,41 +79,61 @@ class SlaveInteractor:
             nextitem = None
 
         start = time.time()
-        self.config.hook.pytest_runtest_protocol(
-            item=item,
-            nextitem=nextitem)
+        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)
+        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])
+            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'):
+    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.slaveid
+        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)
+        # master only needs reports that failed, as optimization send only them instead (#330)
+        if report.failed:
+            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))
+        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,
+            )
 
 
 def serialize_report(rep):
@@ -122,34 +142,33 @@ def serialize_report(rep):
         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()
+        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
+        reprtraceback["reprentries"] = new_entries
 
         return {
-            'reprcrash': reprcrash,
-            'reprtraceback': reprtraceback,
-            'sections': rep.longrepr.sections
+            "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)
+    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)
+            d["longrepr"] = str(rep.longrepr)
     else:
-        d['longrepr'] = rep.longrepr
+        d["longrepr"] = rep.longrepr
     for name in d:
         if isinstance(d[name], py.path.local):
             d[name] = str(d[name])
@@ -158,8 +177,43 @@ def serialize_report(rep):
     return d
 
 
+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_args = warning_message.message.args
+        message_str = str(warning_message.message)
+    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
+        result[attr_name] = getattr(warning_message, attr_name)
+    return result
+
+
 def getinfodict():
     import platform
+
     return dict(
         version=sys.version,
         version_info=tuple(sys.version_info),
@@ -172,31 +226,37 @@ def getinfodict():
 
 def remote_initconfig(option_dict, args):
     from _pytest.config import Config
-    option_dict['plugins'].append("no:terminal")
+
+    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.option.maxprocesses = None
     config.args = args
     return config
 
 
-if __name__ == '__channelexec__':
+if __name__ == "__channelexec__":
     channel = channel  # noqa
-    slaveinput, args, option_dict = channel.receive()
+    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'] = slaveinput['slaveid']
-    os.environ['PYTEST_XDIST_WORKER_COUNT'] = str(slaveinput['slavecount'])
+    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.slaveinput = slaveinput
-    config.slaveoutput = {}
-    interactor = SlaveInteractor(config, channel)
+    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)

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

xdist/scheduler/each.py

@@ -1,10 +1,10 @@
 from py.log import Producer
 
-from xdist.slavemanage import parse_spec_config
+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)

xdist/scheduler/filescope.py

@@ -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]

xdist/scheduler/load.py

@@ -3,11 +3,11 @@ from itertools import cycle
 from py.log import Producer
 from _pytest.runner import CollectReport
 
-from xdist.slavemanage import parse_spec_config
+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
@@ -113,7 +113,7 @@ class LoadScheduling:
         From now on the node will be allocated chunks of tests to
         execute.
 
-        Called by the ``DSession.slave_slaveready`` hook when it
+        Called by the ``DSession.worker_workerready`` hook when it
         successfully bootstraps a new node.
         """
         assert node not in self.node2pending
@@ -123,7 +123,7 @@ class LoadScheduling:
         """Add the collected test items from a node
 
         The collection is stored in the ``.node2collection`` map.
-        Called by the ``DSession.slave_collectionfinish`` hook.
+        Called by the ``DSession.worker_collectionfinish`` hook.
         """
         assert node in self.node2pending
         if self.collection_is_completed:
@@ -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)
@@ -147,7 +146,7 @@ class LoadScheduling:
         The duration it took to execute the item is used as a hint to
         the scheduler.
 
-        This is called by the ``DSession.slave_testreport`` hook.
+        This is called by the ``DSession.worker_testreport`` hook.
         """
         self.node2pending[node].remove(item_index)
         self.check_schedule(node, duration=duration)
@@ -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):
@@ -187,8 +189,8 @@ class LoadScheduling:
         This should be called either when the node crashed or at
         shutdown time.  In the former case any pending items assigned
         to the node will be re-scheduled.  Called by the
-        ``DSession.slave_slavefinished`` and
-        ``DSession.slave_errordown`` hooks.
+        ``DSession.worker_workerfinished`` and
+        ``DSession.worker_errordown`` hooks.
 
         Return the item which was being executing while the node
         crashed or None if the node has no more pending items.
@@ -213,7 +215,7 @@ class LoadScheduling:
         ``.check_schedule()`` on all nodes so that newly added nodes
         will start to be used.
 
-        This is called by the ``DSession.slave_collectionfinish`` hook
+        This is called by the ``DSession.worker_collectionfinish`` hook
         if ``.collection_is_completed`` is True.
         """
         assert self.collection_is_completed
@@ -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

xdist/scheduler/loadscope.py

@@ -3,10 +3,10 @@ from collections import OrderedDict
 from _pytest.runner import CollectReport
 from py.log import Producer
 from xdist.report import report_collection_diff
-from xdist.slavemanage import parse_spec_config
+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
 
@@ -151,7 +151,7 @@ class LoadScopeScheduling:
 
         From now on the node will be assigned work units to be executed.
 
-        Called by the ``DSession.slave_slaveready`` hook when it successfully
+        Called by the ``DSession.worker_workerready`` hook when it successfully
         bootstraps a new node.
         """
         assert node not in self.assigned_work
@@ -166,8 +166,8 @@ class LoadScopeScheduling:
 
         Called by the hooks:
 
-        - ``DSession.slave_slavefinished``.
-        - ``DSession.slave_errordown``.
+        - ``DSession.worker_workerfinished``.
+        - ``DSession.worker_errordown``.
 
         Return the item being executed while the node crashed or None if the
         node has no more pending items.
@@ -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
@@ -206,7 +205,7 @@ class LoadScopeScheduling:
 
         Called by the hook:
 
-        - ``DSession.slave_collectionfinish``.
+        - ``DSession.worker_collectionfinish``.
         """
 
         # Check that add_node() was called on the node before
@@ -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
@@ -239,7 +235,7 @@ class LoadScopeScheduling:
 
         Called by the hook:
 
-        - ``DSession.slave_testreport``.
+        - ``DSession.worker_testreport``.
         """
         nodeid = self.registered_collections[node][item_index]
         scope = self._split_scope(nodeid)
@@ -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
@@ -336,7 +328,7 @@ class LoadScopeScheduling:
 
         If ``.collection_is_completed`` is True, this is called by the hook:
 
-        - ``DSession.slave_collectionfinish``.
+        - ``DSession.worker_collectionfinish``.
         """
         assert self.collection_is_completed
 
@@ -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,18 +358,22 @@ 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 {0} 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 {0}".format(unused_node))
                 unused_node.shutdown()
 
         # Assign initial workload
         for node in self.nodes:
             self._assign_work_unit(node)
 
+        # Ensure nodes start with at least two work units if possible (#277)
+        for node in self.nodes:
+            self._reschedule(node)
+
         # Initial distribution sent all tests, start node shutdown
         if not self.workqueue:
             for node in self.nodes:
@@ -398,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
@@ -412,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

xdist/workermanage.py

@@ -1,10 +1,13 @@
+from __future__ import print_function
 import fnmatch
 import os
 import re
+import threading
 
 import py
 import pytest
 import execnet
+
 import xdist.remote
 
 from _pytest import runner  # XXX load dynamically
@@ -19,20 +22,21 @@ 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._nodesready = threading.Event()
         self.trace = self.config.trace.get("nodemanager")
         self.group = execnet.Group()
         if specs is None:
@@ -47,7 +51,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,8 +60,7 @@ 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:
@@ -68,8 +71,8 @@ class NodeManager(object):
         gw = self.group.makegateway(spec)
         self.config.hook.pytest_xdist_newgateway(gateway=gw)
         self.rsync_roots(gw)
-        node = SlaveController(self, gw, self.config, putevent)
-        gw.node = node          # keep the node alive
+        node = WorkerController(self, gw, self.config, putevent)
+        gw.node = node  # keep the node alive
         node.setup()
         self.trace("started node %r" % node)
         return node
@@ -88,6 +91,7 @@ class NodeManager(object):
             return []
         import pytest
         import _pytest
+
         pytestpath = pytest.__file__.rstrip("co")
         pytestdir = py.path.local(_pytest.__file__).dirpath()
         config = self.config
@@ -111,10 +115,7 @@ class NodeManager(object):
         ignores += self.config.option.rsyncignore
         ignores += self.config.getini("rsyncignore")
 
-        return {
-            'ignores': ignores,
-            'verbose': self.config.option.verbose,
-        }
+        return {"ignores": ignores, "verbose": self.config.option.verbose}
 
     def rsync(self, gateway, source, notify=None, verbose=False, ignores=None):
         """Perform rsync to remote hosts for node."""
@@ -126,9 +127,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,28 +140,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 []
+        ignores = kwargs.pop("ignores", None) or []
         for x in ignores:
-            x = getattr(x, 'strpath', x)
+            x = getattr(x, "strpath", x)
             self._ignores.append(re.compile(fnmatch.translate(x)))
         super(HostRSync, self).__init__(sourcedir=sourcedir, **kwargs)
 
@@ -171,20 +171,19 @@ 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("%s:%s <= %s" % (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:
@@ -201,7 +200,7 @@ def make_reltoroot(roots, args):
     return result
 
 
-class SlaveController(object):
+class WorkerController(object):
     ENDMARK = -1
 
     def __init__(self, nodemanager, gateway, config, putevent):
@@ -209,23 +208,29 @@ class SlaveController(object):
         self.putevent = putevent
         self.gateway = gateway
         self.config = config
-        self.slaveinput = {'slaveid': gateway.id,
-                           'slavecount': len(nodemanager.specs)}
+        self.workerinput = {
+            "workerid": gateway.id,
+            "workercount": len(nodemanager.specs),
+            "slaveid": gateway.id,
+            "slavecount": len(nodemanager.specs),
+        }
+        # TODO: deprecated name, backward compatibility only. Remove it in future
+        self.slaveinput = self.workerinput
         self._down = False
         self._shutdown_sent = False
-        self.log = py.log.Producer("slavectl-%s" % gateway.id)
+        self.log = py.log.Producer("workerctl-%s" % gateway.id)
         if not self.config.option.debug:
             py.log.setconsumer(self.log._keywords, None)
 
     def __repr__(self):
-        return "<%s %s>" % (self.__class__.__name__, self.gateway.id,)
+        return "<%s %s>" % (self.__class__.__name__, self.gateway.id)
 
     @property
     def shutting_down(self):
         return self._down or self._shutdown_sent
 
     def setup(self):
-        self.log("setting up slave session")
+        self.log("setting up worker session")
         spec = self.gateway.spec
         args = self.config.args
         if not spec.popen or spec.chdir:
@@ -233,24 +238,22 @@ class SlaveController(object):
         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.slaveinput, args, option_dict))
+        self.channel.send((self.workerinput, args, option_dict))
         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
@@ -259,7 +262,7 @@ class SlaveController(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:
@@ -298,37 +301,52 @@ class SlaveController(object):
             eventname, kwargs = eventcall
             if eventname in ("collectionstart",):
                 self.log("ignoring %s(%s)" % (eventname, kwargs))
-            elif eventname == "slaveready":
+            elif eventname == "workerready":
                 self.notify_inproc(eventname, node=self, **kwargs)
-            elif eventname == "slavefinished":
+            elif eventname == "workerfinished":
                 self._down = True
-                self.slaveoutput = kwargs['slaveoutput']
-                self.notify_inproc("slavefinished", node=self)
+                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 = unserialize_report(eventname, 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"],
+                )
             else:
                 raise ValueError("unknown event: %s" % (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
+
+            excinfo = ExceptionInfo()
+            print("!" * 20, excinfo)
             self.config.notify_exception(excinfo)
             self.shutdown()
             self.notify_inproc("errordown", node=self, error=excinfo)
@@ -343,56 +361,56 @@ def unserialize_report(name, reportdict):
             ReprFileLocation,
             ReprFuncArgs,
             ReprLocals,
-            ReprTraceback
+            ReprTraceback,
         )
-        if reportdict['longrepr']:
-            if 'reprcrash' in reportdict['longrepr'] and 'reprtraceback' in reportdict['longrepr']:
 
-                reprtraceback = reportdict['longrepr']['reprtraceback']
-                reprcrash = reportdict['longrepr']['reprcrash']
+        if reportdict["longrepr"]:
+            if (
+                "reprcrash" in reportdict["longrepr"]
+                and "reprtraceback" in reportdict["longrepr"]
+            ):
+
+                reprtraceback = reportdict["longrepr"]["reprtraceback"]
+                reprcrash = reportdict["longrepr"]["reprcrash"]
 
                 unserialized_entries = []
                 reprentry = None
-                for entry_data in reprtraceback['reprentries']:
-                    data = entry_data['data']
-                    entry_type = entry_data['type']
-                    if entry_type == 'ReprEntry':
+                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["reprfuncargs"]:
+                            reprfuncargs = ReprFuncArgs(**data["reprfuncargs"])
+                        if data["reprfileloc"]:
+                            reprfileloc = ReprFileLocation(**data["reprfileloc"])
+                        if data["reprlocals"]:
+                            reprlocals = ReprLocals(data["reprlocals"]["lines"])
 
                         reprentry = ReprEntry(
-                            lines=data['lines'],
+                            lines=data["lines"],
                             reprfuncargs=reprfuncargs,
                             reprlocals=reprlocals,
                             filelocrepr=reprfileloc,
-                            style=data['style']
+                            style=data["style"],
                         )
-                    elif entry_type == 'ReprEntryNative':
-                        reprentry = ReprEntryNative(data['lines'])
+                    elif entry_type == "ReprEntryNative":
+                        reprentry = ReprEntryNative(data["lines"])
                     else:
-                        report_unserialization_failure(
-                            entry_type, name, reportdict)
+                        report_unserialization_failure(entry_type, name, reportdict)
                     unserialized_entries.append(reprentry)
-                reprtraceback['reprentries'] = unserialized_entries
+                reprtraceback["reprentries"] = unserialized_entries
 
                 exception_info = ReprExceptionInfo(
                     reprtraceback=ReprTraceback(**reprtraceback),
                     reprcrash=ReprFileLocation(**reprcrash),
                 )
 
-                for section in reportdict['longrepr']['sections']:
+                for section in reportdict["longrepr"]["sections"]:
                     exception_info.addsection(*section)
-                reportdict['longrepr'] = exception_info
+                reportdict["longrepr"] = exception_info
         return reportdict
 
     if name == "testreport":
@@ -401,15 +419,50 @@ def unserialize_report(name, reportdict):
         return runner.CollectReport(**assembled_report(reportdict))
 
 
+def unserialize_warning_message(data):
+    import warnings
+    import importlib
+
+    if data["message_module"]:
+        mod = importlib.import_module(data["message_module"])
+        cls = getattr(mod, data["message_class_name"])
+        try:
+            message = cls(*data["message_args"])
+        except TypeError:
+            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"]
+
+    if data["category_module"]:
+        mod = importlib.import_module(data["category_module"])
+        category = getattr(mod, data["category_class_name"])
+    else:
+        category = None
+
+    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]
+
+    return warnings.WarningMessage(**kwargs)
+
+
 def report_unserialization_failure(type_name, report_name, reportdict):
     from pprint import pprint
-    url = 'https://github.com/pytest-dev/pytest-xdist/issues'
+
+    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("-" * 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)
+    pprint("Please report this bug at %s" % url, stream=stream)
+    pprint("-" * 100, stream=stream)
     assert 0, stream.getvalue()