finalize 1.12 version, some more adaptation for pytest versions, streamlining tox.ini

is random.  Thanks Bruno Oliveira.

.hgignore

@@ -14,8 +14,17 @@ syntax:glob
 *.class
 *.orig
 
+*.sublime-*
+.Python
+
 build/
 dist/
+include/
+lib/
+bin/
 pytest_xdist.egg-info
 issue/
 3rdparty/
+pytestdebug.log
+.tox
+.cache

.hgtags

@@ -1 +1,18 @@
 42c6503ee48fae9c4c96d406afb12bfc86f15803 1.0
+eca7ce17eabf296983c36812c8b8be901e7055a3 1.1
+56d8e5280be224a0ad3220a9deed55334710bd23 1.2
+e6c4ce20db4bf65086ff55807a3c306cad7ca393 1.3
+e6c4ce20db4bf65086ff55807a3c306cad7ca393 1.3
+eaf8b1cb7c312883598677231be5bbeea3b5c127 1.3
+a423748bf17ee778a37853225210257699cad9c1 1.4
+cd44a941c833c098e4899fe3d42a96703754d0d5 1.5
+4815040bdad8f182a5487f57a9da385483836e75 1.6
+20875fed94e7f3dff50bdf762df91153b15ceca6 1.7
+20875fed94e7f3dff50bdf762df91153b15ceca6 1.7
+29c38e195526f5f0fdd651fb51f59d6efaaafbb0 1.7
+0d1c00018008433956aa7d93007bab6ea7de96e4 1.8
+0d1c00018008433956aa7d93007bab6ea7de96e4 1.8
+1d27987c267577899350a25ba5828d55d87083ad 1.8
+5c5cb6d59e12e566fbb0217aea718dc31578bee1 1.9
+4406fc2a6427fadc021ed7e43e7aa5032b1ea91f 1.10
+220f6e46eb71a6212ccbe6b67b9e6edcf8ee4fa5 1.11

CHANGELOG

@@ -1,3 +1,133 @@
+1.12
+-------------------------
+
+- fix issue594: properly report errors when the test collection
+  is random.  Thanks Bruno Oliveira.
+
+- some internal test suite adaptation (to become forward
+  compatible with the upcoming pytest-2.8)
+
+
+1.11
+-------------------------
+
+- fix pytest/xdist issue485 (also depends on py-1.4.22):
+  attach stdout/stderr on --boxed processes that die.
+
+- fix pytest/xdist issue503: make sure that a node has usually
+  two items to execute to avoid scoped fixtures to be torn down
+  pre-maturely (fixture teardown/setup is "nextitem" sensitive).
+  Thanks to Andreas Pelme for bug analysis and failing test.
+
+- restart crashed nodes by internally refactoring setup handling
+  of nodes.  Also includes better code documentation.  
+  Many thanks to Floris Bruynooghe for the complete PR.
+
+
+1.10
+-------------------------
+
+- add glob support for rsyncignores, add command line option to pass
+  additional rsyncignores. Thanks Anatoly Bubenkov.
+
+- fix pytest issue382 - produce "pytest_runtest_logstart" event again
+  in master. Thanks Aron Curzon.
+
+- fix pytest issue419 by sending/receiving indices into the test 
+  collection instead of node ids (which are not neccessarily unique
+  for functions parametrized with duplicate values)
+
+- send multiple "to test" indices in one network message to a slave
+  and improve heuristics for sending chunks where the chunksize
+  depends on the number of remaining tests rather than fixed numbers.
+  This reduces the number of master -> node messages (but not the
+  reverse direction)
+
+
+1.9
+-------------------------
+
+- changed LICENSE to MIT
+
+- fix duplicate reported test ids with --looponfailing
+  (thanks Jeremy Thurgood)
+
+- fix pytest issue41: re-run tests on all file changes, not just
+  randomly select ones like .py/.c.
+
+- fix pytest issue347: slaves running on top of Python3.2
+  will set PYTHONDONTWRITEYBTECODE to 1 to avoid import concurrency
+  bugs.
+
+1.8
+-------------------------
+
+- fix pytest-issue93 - use the refined pytest-2.2.1 runtestprotocol
+  interface to perform eager teardowns for test items.
+
+1.7
+-------------------------
+
+- fix incompatibilities with pytest-2.2.0 (allow multiple
+  pytest_runtest_logreport reports for a test item)
+
+1.6
+-------------------------
+
+- terser collection reporting
+
+- fix issue34 - distributed testing with -p plugin now works correctly
+
+- fix race condition in looponfail mode where a concurrent file removal
+  could cause a crash
+
+1.5
+-------------------------
+
+- adapt to and require pytest-2.0 changes, rsyncdirs and rsyncignore can now
+  only be specified in [pytest] sections of ini files, see "py.test -h"
+  for details.
+- major internal refactoring to match the pytest-2.0 event refactoring
+  - perform test collection always at slave side instead of at the master
+  - make python2/python3 bridging work, remove usage of pickling
+- improve initial reporting by using line-rewriting
+- remove all trailing whitespace from source
+
+1.4
+-------------------------
+
+- perform distributed testing related reporting in the plugin
+  rather than having dist-related code in the generic py.test
+  distribution
+
+- depend on execnet-1.0.7 which adds "env1:NAME=value" keys to
+  gateway specification strings.
+
+- show detailed gateway setup and platform information only when
+  "-v" or "--verbose" is specified.
+
+1.3
+-------------------------
+
+- fix --looponfailing - it would not actually run against the fully changed
+  source tree when initial conftest files load application state.
+
+- adapt for py-1.3.1's new --maxfailure option
+
+1.2
+-------------------------
+
+- fix issue79: sessionfinish/teardown hooks are now called systematically
+  on the slave side
+- introduce a new data input/output mechanism to allow the master side
+  to send and receive data from a slave.
+- fix race condition in underlying pickling/unpickling handling
+- use and require new register hooks facility of py.test>=1.3.0
+- require improved execnet>=1.0.6 because of various race conditions
+  that can arise in xdist testing modes.
+- fix some python3 related pickling related race conditions
+- fix PyPI description
+
 1.1
 -------------------------
 

ISSUES.txt

@@ -1,5 +1,19 @@
+next release critical
+-----------------------------------------------
+tag: bug
 
-allow to run xdist tests with xdist 
+miserably fails: --dist=each --tx popen --tx socket=...
+
+
+rename / hooks
+-----------------------------------------------
+tag: bug
+
+node -> slave
+transition for hooks?
+configure_node -> configure_slave
+
+allow to remotely run xdist tests with xdist
 -----------------------------------------------
 tag: feature
 
@@ -8,3 +22,10 @@ currently this doesn't work because the remote side
 has no py.test plugin.   How to configure/do
 register "xdist.plugin" on the remote side?
 
+see to avoid any "from _pytest" internal imports
+-----------------------------------------------
+tag: feature
+
+currently tests and even xdist core code imports
+names from the internal _pytest namespace.
+See to avoid it.

LICENSE

@@ -1,13 +1,19 @@
-The execnet package is released under the provisions of the Gnu Public
-License (GPL), version 2 or later.  
 
-See http://www.fsf.org/licensing/licenses/ for more information.
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  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:
      
-This package also contains some minor parts which 
-which are useable under the MIT license. 
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
  
-If you have questions and/or want to use parts of 
-the code under a different license than the GPL 
-please contact me. 
+  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
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  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.
 
-holger krekel, January 2010, holger at merlinux eu 

MANIFEST.in

@@ -2,9 +2,6 @@ include CHANGELOG
 include LICENSE 
 include README.txt
 include setup.py
+include tox.ini
 graft testing
-exclude *.orig 
-exclude *.rej 
-recursive-exclude testing *.pyc *$py.class
-prune .svn 
 prune .hg 

README.txt

@@ -1,29 +1,215 @@
-py.test xdist plugin: distributed testing and loop failure
-===============================================================
+.. image:: https://drone.io/bitbucket.org/pytest-dev/pytest-xdist/status.png
+   :target: https://drone.io/bitbucket.org/pytest-dev/pytest-xdist/latest
+.. image:: https://pypip.in/v/pytest-xdist/badge.png
+   :target: https://pypi.python.org/pypi/pytest-xdist
 
-.. _`pytest-xdist respository`: http://bitbucket.org/hpk42/pytest-xdist
-.. _`pytest`: http://pytest.org
+xdist: pytest distributed testing plugin
+============================
 
-The pytest-xdist plugin extends `py.test`_ to ad-hoc distribute test 
-runs to multiple CPUs or remote machines.   It requires setuptools
-or distribute which help to pull in the neccessary execnet and 
-pytest-core dependencies. 
+The `pytest-xdist`_ plugin extends py.test with some unique
+test execution modes:
 
-Install the plugin locally with::
+* test run parallelization_: if you have multiple CPUs or hosts you can use
+  those for a combined test run.  This allows to speed up
+  development or to use special resources of `remote machines`_.
 
-    python setup.py install   
+* ``--boxed``: (not available on Windows) run each test in a boxed_
+  subprocess to survive ``SEGFAULTS`` or otherwise dying processes
 
-or use the package in develope/in-place mode, particularly
-useful with a checkout of the `pytest-xdist repository`_::
+* ``--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
+  the previously failing tests.  This is repeated until all tests pass
+  after which again a full run is performed.
 
-    python setup.py develop
+* `Multi-Platform`_ coverage: you can specify different Python interpreters
+  or different platforms and run tests in parallel on all of them.
 
-or use one of::
+Before running tests remotely, ``py.test`` 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.
+
+
+Installation
+-----------------------
+
+Install the plugin with::
 
     easy_install pytest-xdist
 
+    # or
+
     pip install pytest-xdist
 
-for downloading and installing it in one go.
+or use the package in develope/in-place mode with
+a checkout of the `pytest-xdist repository`_ ::
 
-holger krekel <holger at merlinux eu>
+    python setup.py develop
+
+Usage examples
+---------------------
+
+.. _parallelization:
+
+Speed up test runs by sending tests to multiple CPUs
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+To send tests to multiple CPUs, type::
+
+    py.test -n NUM
+
+Especially for longer running tests or tests requiring
+a lot of IO this can lead to considerable speed ups.
+
+
+Running tests in a Python subprocess
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+To instantiate a python2.5 sub process and send tests to it, you may type::
+
+    py.test -d --tx popen//python=python2.5
+
+This will start a subprocess which is run with the "python2.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
+
+then three subprocesses would be created and tests
+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.
+
+
+.. _`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
+
+This will synchronize your ``mypkg`` package directory
+to an remote ssh account and then locally collect tests
+and send them to remote places for execution.
+
+You can specify multiple ``--rsyncdir`` directories
+to be sent to the remote side.
+
+**NOTE:** For py.test 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 ``__init__.py`` file because internally
+py.test references tests as a fully qualified python
+module path.  **You will otherwise get strange errors**
+during setup of the remote side.
+
+You can specify multiple ``--rsyncignore`` glob-patterns
+to be ignored when file are sent to the remote side.
+There are also internal ignores: .*, *.pyc, *.pyo, *~
+Those you cannot override using rsyncignore command-line or
+ini-file option(s).
+
+
+Sending tests to remote Socket Servers
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+Download the single-module `socketserver.py`_ Python program
+and run it like this::
+
+    python socketserver.py
+
+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
+
+
+.. _`atonce`:
+.. _`Multi-Platform`:
+
+
+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
+
+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`_.
+
+.. _`xspec syntax`: http://codespeak.net/execnet/trunk/basics.html#xspec
+
+.. _`socketserver.py`: http://bitbucket.org/hpk42/execnet/raw/2af991418160/execnet/script/socketserver.py
+
+.. _`execnet`: http://codespeak.net/execnet
+
+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::
+
+    [pytest]
+    addopts = -n3
+
+You can also add default environments like this::
+
+    [pytest]
+    addopts = --tx ssh=myhost//python=python2.5 --tx ssh=myhost//python=python2.6
+
+and then just type::
+
+    py.test --dist=each
+
+to run tests in each of the environments.
+
+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::
+
+    [pytest]
+    rsyncdirs = . mypkg helperpkg
+    rsyncignore = .hg
+
+These directory specifications are relative to the directory
+where the configuration file was found.
+
+.. _`pytest-xdist`: http://pypi.python.org/pypi/pytest-xdist
+.. _`pytest-xdist repository`: http://bitbucket.org/pytest-dev/pytest-xdist
+.. _`pytest`: http://pytest.org
+
+Issue and Bug Tracker
+------------------------
+
+Please use the pytest issue tracker for bugs in this plugin, see https://bitbucket.org/hpk42/pytest/issues .

example/boxed.txt

@@ -0,0 +1,62 @@
+
+
+If your testing involves C or C++ libraries you might have to deal
+with crashing processes.  The xdist-plugin provides the ``--boxed`` option
+to run each test in a controled subprocess.  Here is a basic example::
+
+    # content of test_module.py
+
+    import pytest
+    import os
+    import time
+
+    # run test function 50 times with different argument
+    @pytest.mark.parametrize("arg", range(50))
+    def test_func(arg):
+        time.sleep(0.05) # each tests takes a while
+        if arg % 19 == 0: 
+            os.kill(os.getpid(), 15)
+
+If you run this with::
+
+    $ py.test --boxed
+    =========================== test session starts ============================
+    platform linux2 -- Python 2.7.3 -- pytest-2.3.0.dev8
+    plugins: xdist, bugzilla, cache, oejskit, cli, pep8, cov
+    collecting ... collected 50 items
+    
+    test_module.py f..................f..................f...........
+    
+    ================================= FAILURES =================================
+    _______________________________ test_func[0] _______________________________
+    /home/hpk/tmp/doc-exec-420/test_module.py:6: running the test CRASHED with signal 15
+    ______________________________ test_func[19] _______________________________
+    /home/hpk/tmp/doc-exec-420/test_module.py:6: running the test CRASHED with signal 15
+    ______________________________ test_func[38] _______________________________
+    /home/hpk/tmp/doc-exec-420/test_module.py:6: running the test CRASHED with signal 15
+    =================== 3 failed, 47 passed in 3.41 seconds ====================
+
+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 --boxed -n3
+    =========================== test session starts ============================
+    platform linux2 -- Python 2.7.3 -- pytest-2.3.0.dev8
+    plugins: xdist, bugzilla, cache, oejskit, cli, pep8, cov
+    gw0 I / gw1 I / gw2 I
+    gw0 [50] / gw1 [50] / gw2 [50]
+    
+    scheduling tests via LoadScheduling
+    ..f...............f..................f............
+    ================================= FAILURES =================================
+    _______________________________ test_func[0] _______________________________
+    [gw0] linux2 -- Python 2.7.3 /home/hpk/venv/1/bin/python
+    /home/hpk/tmp/doc-exec-420/test_module.py:6: running the test CRASHED with signal 15
+    ______________________________ test_func[19] _______________________________
+    [gw2] linux2 -- Python 2.7.3 /home/hpk/venv/1/bin/python
+    /home/hpk/tmp/doc-exec-420/test_module.py:6: running the test CRASHED with signal 15
+    ______________________________ test_func[38] _______________________________
+    [gw2] linux2 -- Python 2.7.3 /home/hpk/venv/1/bin/python
+    /home/hpk/tmp/doc-exec-420/test_module.py:6: running the test CRASHED with signal 15
+    =================== 3 failed, 47 passed in 2.03 seconds ====================

setup.py

@@ -1,31 +1,23 @@
-"""
-py.test 'xdist' plugin for distributed testing and loop-on-failing modes. 
-
-See http://pytest.org/plugin/xdist.html for documentation and, after
-installation of the ``pytest-xdist`` PyPI package, ``py.test -h`` 
-for the new options. 
-"""
-
 from setuptools import setup
 
 setup(
     name="pytest-xdist",
-    version="1.1",
-    description='py.test figleaf coverage plugin',
-    long_description=__doc__,
-    license='GPLv2 or later',
+    version='1.12',
+    description='py.test xdist plugin for distributed testing and loop-on-failing modes',
+    long_description=open('README.txt').read(),
+    license='MIT',
     author='holger krekel and contributors',
-    author_email='py-dev@codespeak.net,holger@merlinux.eu', 
+    author_email='pytest-dev@python.org,holger@merlinux.eu',
     url='http://bitbucket.org/hpk42/pytest-xdist',
     platforms=['linux', 'osx', 'win32'],
     packages = ['xdist'],
     entry_points = {'pytest11': ['xdist = xdist.plugin'],},
     zip_safe=False,
-    install_requires = ['execnet>=1.0.4', 'py>=1.2.0'],
+    install_requires = ['execnet>=1.1', 'pytest>=2.4.2', 'py>=1.4.22'],
     classifiers=[
-    'Development Status :: 4 - Beta',
+    'Development Status :: 5 - Production/Stable',
     'Intended Audience :: Developers',
-    'License :: OSI Approved :: GNU General Public License (GPL)',
+    'License :: OSI Approved :: MIT License',
     'Operating System :: POSIX',
     'Operating System :: Microsoft :: Windows',
     'Operating System :: MacOS :: MacOS X',
@@ -33,5 +25,6 @@ setup(
     'Topic :: Software Development :: Quality Assurance',
     'Topic :: Utilities',
     'Programming Language :: Python',
+    'Programming Language :: Python :: 3',
     ],
 )

testing/__init__.py

@@ -1 +0,0 @@
-#

testing/acceptance_test.py

@@ -1,6 +1,78 @@
 import py
+import pytest
+
 
 class TestDistribution:
+    def test_n1_pass(self, testdir):
+        p1 = testdir.makepyfile("""
+            def test_ok():
+                pass
+        """)
+        result = testdir.runpytest(p1, "-n1")
+        assert result.ret == 0
+        result.stdout.fnmatch_lines([
+            "*1 passed*",
+        ])
+
+    def test_n1_fail(self, testdir):
+        p1 = testdir.makepyfile("""
+            def test_fail():
+                assert 0
+        """)
+        result = testdir.runpytest(p1, "-n1")
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "*1 failed*",
+        ])
+
+    def test_n1_import_error(self, testdir):
+        p1 = testdir.makepyfile("""
+            import __import_of_missing_module
+            def test_import():
+                pass
+        """)
+        result = testdir.runpytest(p1, "-n1")
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "E   ImportError: *__import_of_missing_module*",
+        ])
+
+    def test_n2_import_error(self, testdir):
+        """Check that we don't report the same import error multiple times
+        in distributed mode."""
+        p1 = testdir.makepyfile("""
+            import __import_of_missing_module
+            def test_import():
+                pass
+        """)
+        result1 = testdir.runpytest(p1, "-n2")
+        result2 = testdir.runpytest(p1, "-n1")
+        assert len(result1.stdout.lines) == len(result2.stdout.lines)
+
+    def test_n1_skip(self, testdir):
+        p1 = testdir.makepyfile("""
+            def test_skip():
+                import py
+                py.test.skip("myreason")
+        """)
+        result = testdir.runpytest(p1, "-n1")
+        assert result.ret == 0
+        result.stdout.fnmatch_lines([
+            "*1 skipped*",
+        ])
+
+    def test_manytests_to_one_import_error(self, testdir):
+        p1 = testdir.makepyfile("""
+            import __import_of_missing_module
+            def test_import():
+                pass
+        """)
+        result = testdir.runpytest(p1, '--tx=popen', '--tx=popen')
+        assert result.ret == 1
+        result.stdout.fnmatch_lines([
+            "E   ImportError: *__import_of_missing_module*",
+        ])
+
     def test_manytests_to_one_popen(self, testdir):
         p1 = testdir.makepyfile("""
                 import py
@@ -14,15 +86,40 @@ class TestDistribution:
                     py.test.skip("hello")
             """,
         )
-        result = testdir.runpytest(p1, '-d', '--tx=popen', '--tx=popen')
+        result = testdir.runpytest(p1, "-v", '-d', '--tx=popen', '--tx=popen')
         result.stdout.fnmatch_lines([
-            "*0*popen*Python*",
-            "*1*popen*Python*",
+            "*1*Python*",
             "*2 failed, 1 passed, 1 skipped*",
         ])
         assert result.ret == 1
 
-    def test_dist_conftest_specified(self, testdir):
+    def test_n1_fail_minus_x(self, testdir):
+        p1 = testdir.makepyfile("""
+            def test_fail1():
+                assert 0
+            def test_fail2():
+                assert 0
+        """)
+        result = testdir.runpytest(p1, "-x", "-v", "-n1")
+        assert result.ret == 2
+        result.stdout.fnmatch_lines([
+            "*Interrupted: stopping*1*",
+            "*1 failed*",
+        ])
+
+    def test_basetemp_in_subprocesses(self, testdir):
+        p1 = testdir.makepyfile("""
+            def test_send(tmpdir):
+                import py
+                assert tmpdir.relto(py.path.local(%r)), tmpdir
+        """ % str(testdir.tmpdir))
+        result = testdir.runpytest_subprocess(p1, "-n1")
+        assert result.ret == 0
+        result.stdout.fnmatch_lines([
+            "*1 passed*",
+        ])
+
+    def test_dist_ini_specified(self, testdir):
         p1 = testdir.makepyfile("""
                 import py
                 def test_fail0():
@@ -35,18 +132,18 @@ class TestDistribution:
                     py.test.skip("hello")
             """,
         )
-        testdir.makeconftest("""
-            option_tx = 'popen popen popen'.split()
+        testdir.makeini("""
+            [pytest]
+            addopts = --tx=3*popen
         """)
-        result = testdir.runpytest(p1, '-d')
+        result = testdir.runpytest(p1, '-d', "-v")
         result.stdout.fnmatch_lines([
-            "*0*popen*Python*",
-            "*1*popen*Python*",
-            "*2*popen*Python*",
+            "*2*Python*",
             "*2 failed, 1 passed, 1 skipped*",
         ])
         assert result.ret == 1
 
+    @py.test.mark.xfail("sys.platform.startswith('java')", run=False)
     def test_dist_tests_with_crash(self, testdir):
         if not hasattr(py.std.os, 'kill'):
             py.test.skip("no os.kill")
@@ -68,12 +165,11 @@ class TestDistribution:
                     os.kill(os.getpid(), 15)
             """
         )
-        result = testdir.runpytest(p1, '-d', '--tx=3*popen')
+        result = testdir.runpytest(p1, "-v", '-d', '-n1')
         result.stdout.fnmatch_lines([
-            "*popen*Python*",
-            "*popen*Python*",
-            "*popen*Python*",
-            "*node down*",
+            "*Python*",
+            "*PASS**test_ok*",
+            "*node*down*",
             "*3 failed, 1 passed, 1 skipped*"
         ])
         assert result.ret == 1
@@ -84,21 +180,105 @@ class TestDistribution:
         subdir = source.mkdir("example_pkg")
         subdir.ensure("__init__.py")
         p = subdir.join("test_one.py")
-        p.write("def test_5(): assert not __file__.startswith(%r)" % str(p))
-        result = testdir.runpytest("-d", "--rsyncdir=%(subdir)s" % locals(), 
+        p.write("def test_5():\n  assert not __file__.startswith(%r)" % str(p))
+        result = testdir.runpytest("-v", "-d",
+            "--rsyncdir=%(subdir)s" % locals(),
             "--tx=popen//chdir=%(dest)s" % locals(), p)
         assert result.ret == 0
         result.stdout.fnmatch_lines([
-            "*0* *popen*platform*",
+            "*0* *cwd*",
             #"RSyncStart: [G1]",
             #"RSyncFinished: [G1]",
             "*1 passed*"
         ])
         assert dest.join(subdir.basename).check(dir=1)
 
-    def test_dist_each(self, testdir):
+    def test_data_exchange(self, testdir):
+        testdir.makeconftest("""
+            # This hook only called on master.
+            def pytest_configure_node(node):
+                node.slaveinput['a'] = 42
+                node.slaveinput['b'] = 7
+
+            def pytest_configure(config):
+                # this attribute is only set on slaves
+                if hasattr(config, 'slaveinput'):
+                    a = config.slaveinput['a']
+                    b = config.slaveinput['b']
+                    r = a + b
+                    config.slaveoutput['r'] = r
+
+            # This hook only called on master.
+            def pytest_testnodedown(node, error):
+                node.config.calc_result = node.slaveoutput['r']
+
+            def pytest_terminal_summary(terminalreporter):
+                if not hasattr(terminalreporter.config, 'slaveinput'):
+                    calc_result = terminalreporter.config.calc_result
+                    terminalreporter._tw.sep('-',
+                        'calculated result is %s' % calc_result)
+        """)
+        p1 = testdir.makepyfile("def test_func(): pass")
+        result = testdir.runpytest("-v", p1, '-d', '--tx=popen')
+        result.stdout.fnmatch_lines([
+            "*0*Python*",
+            "*calculated result is 49*",
+            "*1 passed*"
+        ])
+        assert result.ret == 0
+
+    def test_keyboardinterrupt_hooks_issue79(self, testdir):
+        testdir.makepyfile(__init__="", test_one="""
+            def test_hello():
+                raise KeyboardInterrupt()
+        """)
+        testdir.makeconftest("""
+            def pytest_sessionfinish(session):
+                # on the slave
+                if hasattr(session.config, 'slaveoutput'):
+                    session.config.slaveoutput['s2'] = 42
+            # on the master
+            def pytest_testnodedown(node, error):
+                assert node.slaveoutput['s2'] == 42
+                print ("s2call-finished")
+        """)
+        args = ["-n1", "--debug"]
+        result = testdir.runpytest_subprocess(*args)
+        s = result.stdout.str()
+        assert result.ret == 2
+        assert 's2call' in s
+        assert "Interrupted" in s
+
+    def test_keyboard_interrupt_dist(self, testdir):
+        # xxx could be refined to check for return code
+        testdir.makepyfile("""
+            def test_sleep():
+                import time
+                time.sleep(10)
+        """)
+        child = testdir.spawn_pytest("-n1 -v")
+        child.expect(".*test_sleep.*")
+        child.kill(2) # keyboard interrupt
+        child.expect(".*KeyboardInterrupt.*")
+        #child.expect(".*seconds.*")
+        child.close()
+        #assert ret == 2
+
+class TestDistEach:
+    def test_simple(self, testdir):
+        testdir.makepyfile("""
+            def test_hello():
+                pass
+        """)
+        result = testdir.runpytest_subprocess("--debug", "--dist=each", "--tx=2*popen")
+        assert not result.ret
+        result.stdout.fnmatch_lines(["*2 pass*"])
+
+    @py.test.mark.xfail(run=False,
+        reason="other python versions might not have py.test installed")
+    def test_simple_diffoutput(self, testdir):
         interpreters = []
-        for name in ("python2.4", "python2.5"):
+        for name in ("python2.5", "python2.6"):
             interp = py.path.local.sysfind(name)
             if interp is None:
                 py.test.skip("%s not found" % name)
@@ -110,10 +290,274 @@ class TestDistribution:
                 print("%s...%s" % sys.version_info[:2])
                 assert 0
         """)
-        args = ["--dist=each"]
+        args = ["--dist=each", "-v"]
         args += ["--tx", "popen//python=%s" % interpreters[0]]
         args += ["--tx", "popen//python=%s" % interpreters[1]]
         result = testdir.runpytest(*args)
         s = result.stdout.str()
-        assert "2.4" in s
-        assert "2.5" in s
+        assert "2...5" in s
+        assert "2...6" in s
+
+class TestTerminalReporting:
+    def test_pass_skip_fail(self, testdir):
+        testdir.makepyfile("""
+            import py
+            def test_ok():
+                pass
+            def test_skip():
+                py.test.skip("xx")
+            def test_func():
+                assert 0
+        """)
+        result = testdir.runpytest("-n1", "-v")
+        result.stdout.fnmatch_lines_random([
+            "*PASS*test_pass_skip_fail.py*test_ok*",
+            "*SKIP*test_pass_skip_fail.py*test_skip*",
+            "*FAIL*test_pass_skip_fail.py*test_func*",
+        ])
+        result.stdout.fnmatch_lines([
+            "*def test_func():",
+            ">       assert 0",
+            "E       assert 0",
+        ])
+
+    def test_fail_platinfo(self, testdir):
+        testdir.makepyfile("""
+            def test_func():
+                assert 0
+        """)
+        result = testdir.runpytest("-n1", "-v")
+        result.stdout.fnmatch_lines([
+            "*FAIL*test_fail_platinfo.py*test_func*",
+            "*0*Python*",
+            "*def test_func():",
+            ">       assert 0",
+            "E       assert 0",
+        ])
+
+def test_teardownfails_one_function(testdir):
+    p = testdir.makepyfile("""
+        def test_func():
+            pass
+        def teardown_function(function):
+            assert 0
+    """)
+    result = testdir.runpytest(p, '-n1', '--tx=popen')
+    result.stdout.fnmatch_lines([
+        "*def teardown_function(function):*",
+        "*1 passed*1 error*"
+    ])
+
+@py.test.mark.xfail
+def test_terminate_on_hangingnode(testdir):
+    p = testdir.makeconftest("""
+        def pytest_sessionfinish(session):
+            if session.nodeid == "my": # running on slave
+                import time
+                time.sleep(3)
+    """)
+    result = testdir.runpytest(p, '--dist=each', '--tx=popen//id=my')
+    assert result.duration < 2.0
+    result.stdout.fnmatch_lines([
+        "*killed*my*",
+    ])
+
+
+@pytest.mark.xfail(reason="works if run outside test suite", run=False)
+def test_session_hooks(testdir):
+    testdir.makeconftest("""
+        import sys
+        def pytest_sessionstart(session):
+            sys.pytestsessionhooks = session
+        def pytest_sessionfinish(session):
+            if hasattr(session.config, 'slaveinput'):
+                name = "slave"
+            else:
+                name = "master"
+            f = open(name, "w")
+            f.write("xy")
+            f.close()
+            # let's fail on the slave
+            if name == "slave":
+                raise ValueError(42)
+    """)
+    p = testdir.makepyfile("""
+        import sys
+        def test_hello():
+            assert hasattr(sys, 'pytestsessionhooks')
+    """)
+    result = testdir.runpytest(p, "--dist=each", "--tx=popen")
+    result.stdout.fnmatch_lines([
+        "*ValueError*",
+        "*1 passed*",
+    ])
+    assert not result.ret
+    d = result.parseoutcomes()
+    assert d['passed'] == 1
+    assert testdir.tmpdir.join("slave").check()
+    assert testdir.tmpdir.join("master").check()
+
+def test_funcarg_teardown_failure(testdir):
+    p = testdir.makepyfile("""
+        def pytest_funcarg__myarg(request):
+            def teardown(val):
+                raise ValueError(val)
+            return request.cached_setup(setup=lambda: 42, teardown=teardown,
+                scope="module")
+        def test_hello(myarg):
+            pass
+    """)
+    result = testdir.runpytest_subprocess("--debug", p) # , "-n1")
+    result.stdout.fnmatch_lines([
+        "*ValueError*42*",
+        "*1 passed*1 error*",
+    ])
+    assert result.ret
+
+def test_crashing_item(testdir):
+    p = testdir.makepyfile("""
+        import py
+        import os
+        def test_crash():
+            py.process.kill(os.getpid())
+        def test_noncrash():
+            pass
+    """)
+    result = testdir.runpytest("-n2", p)
+    result.stdout.fnmatch_lines([
+        "*crashed*test_crash*",
+        "*1 failed*1 passed*"
+    ])
+
+
+
+def test_skipping(testdir):
+    p = testdir.makepyfile("""
+        import pytest
+        def test_crash():
+            pytest.skip("hello")
+    """)
+    result = testdir.runpytest("-n1", '-rs', p)
+    assert result.ret == 0
+    result.stdout.fnmatch_lines([
+        "*hello*",
+        "*1 skipped*"
+    ])
+
+def test_issue34_pluginloading_in_subprocess(testdir):
+    testdir.tmpdir.join("plugin123.py").write(py.code.Source("""
+        def pytest_namespace():
+            return {'sample_variable': 'testing'}
+    """))
+    testdir.makepyfile("""
+        import pytest
+        def test_hello():
+            assert pytest.sample_variable == "testing"
+    """)
+    result = testdir.runpytest_subprocess("-n1", "-p", "plugin123")
+    assert result.ret == 0
+    result.stdout.fnmatch_lines([
+        "*1 passed*",
+    ])
+
+
+def test_fixture_scope_caching_issue503(testdir):
+    p1 = testdir.makepyfile("""
+            import pytest
+
+            @pytest.fixture(scope='session')
+            def fix():
+                assert fix.counter == 0, 'session fixture was invoked multiple times'
+                fix.counter += 1
+            fix.counter = 0
+
+            def test_a(fix):
+                pass
+
+            def test_b(fix):
+                pass
+    """)
+    result = testdir.runpytest(p1, '-v', '-n1')
+    assert result.ret == 0
+    result.stdout.fnmatch_lines([
+    "*2 passed*",
+    ])
+
+
+def test_issue_594_random_parametrize(testdir):
+    """
+    Make sure that tests that are randomly parametrized display an appropriate
+    error message, instead of silently skipping the entire test run.
+    """
+    p1 = testdir.makepyfile("""
+        import pytest
+        import random
+
+        xs = list(range(10))
+        random.shuffle(xs)
+        @pytest.mark.parametrize('x', xs)
+        def test_foo(x):
+            assert 1
+    """)
+    result = testdir.runpytest(p1, '-v', '-n4')
+    assert result.ret == 1
+    result.stdout.fnmatch_lines([
+        "Different tests were collected between gw* and gw*",
+    ])
+
+
+class TestNodeFailure:
+
+    def test_load_single(self, testdir):
+        f = testdir.makepyfile("""
+            import os
+            def test_a(): os._exit(1)
+            def test_b(): pass
+        """)
+        res = testdir.runpytest(f, '-n1')
+        res.stdout.fnmatch_lines([
+            "*Replacing failed node*",
+            "*Slave*crashed while running*",
+            "*1 failed*1 passed*",
+        ])
+
+    def test_load_multiple(self, testdir):
+        f = testdir.makepyfile("""
+            import os
+            def test_a(): pass
+            def test_b(): os._exit(1)
+            def test_c(): pass
+            def test_d(): pass
+        """)
+        res = testdir.runpytest(f, '-n2')
+        res.stdout.fnmatch_lines([
+            "*Replacing failed node*",
+            "*Slave*crashed while running*",
+            "*1 failed*3 passed*",
+        ])
+
+    def test_each_single(self, testdir):
+        f = testdir.makepyfile("""
+            import os
+            def test_a(): os._exit(1)
+            def test_b(): pass
+        """)
+        res = testdir.runpytest(f, '--dist=each', '--tx=popen')
+        res.stdout.fnmatch_lines([
+            "*Replacing failed node*",
+            "*Slave*crashed while running*",
+            "*1 failed*1 passed*",
+        ])
+
+    def test_each_multiple(self, testdir):
+        f = testdir.makepyfile("""
+            import os
+            def test_a(): os._exit(1)
+            def test_b(): pass
+        """)
+        res = testdir.runpytest(f, '--dist=each', '--tx=2*popen')
+        res.stdout.fnmatch_lines([
+            "*Replacing failed node*",
+            "*Slave*crashed while running*",
+            "*2 failed*2 passed*",
+        ])

testing/conftest.py

@@ -1,21 +1,43 @@
 import py
+import pytest
 import execnet
 
+@pytest.fixture(scope="session", autouse=True)
+def _ensure_imports():
+    # we import some modules because pytest-2.8's testdir fixture
+    # will unload all modules after each test and this cause
+    # (unknown) problems with execnet.Group()
+    execnet.Group
+    execnet.makegateway
+
 pytest_plugins = "pytester"
-option_report = 'skipped'
 
 #rsyncdirs = ['.', '../xdist', py.path.local(execnet.__file__).dirpath()]
 
+@pytest.fixture(autouse=True)
+def _divert_atexit(request, monkeypatch):
+    import atexit
+    l = []
+    def finish():
+        while l:
+            l.pop()()
+    monkeypatch.setattr(atexit, "register", l.append)
+    request.addfinalizer(finish)
+
 def pytest_addoption(parser):
     parser.addoption('--gx',
-       action="append", dest="gspecs", default=None,
+       action="append", dest="gspecs",
        help=("add a global test environment, XSpec-syntax. "))
 
 def pytest_funcarg__specssh(request):
     return getspecssh(request.config)
-def getgspecs(config):
-    return [execnet.XSpec(spec)
-                for spec in config.getvalueorskip("gspecs")]
+
+@pytest.fixture
+def testdir(testdir):
+    # pytest before 2.8 did not have a runpytest_subprocess
+    if not hasattr(testdir, "runpytest_subprocess"):
+        testdir.runpytest_subprocess = testdir.runpytest
+    return testdir
 
 # configuration information for tests
 def getgspecs(config):
@@ -28,7 +50,7 @@ def getspecssh(config):
         if spec.ssh:
             if not py.path.local.sysfind("ssh"):
                 py.test.skip("command not found: ssh")
-            return spec
+            return str(spec)
     py.test.skip("need '--gx ssh=...'")
 
 def getsocketspec(config):

testing/test_boxed.py

@@ -1,6 +1,10 @@
-import py
+import pytest
+import os
 
-@py.test.mark.skipif("not hasattr(os, 'fork')")
+needsfork = pytest.mark.skipif(not hasattr(os, "fork"),
+                               reason="os.fork required")
+
+@needsfork
 def test_functional_boxed(testdir):
     p1 = testdir.makepyfile("""
         import os
@@ -8,23 +12,45 @@ def test_functional_boxed(testdir):
             os.kill(os.getpid(), 15)
     """)
     result = testdir.runpytest(p1, "--boxed")
-    assert result.stdout.fnmatch_lines([
+    result.stdout.fnmatch_lines([
         "*CRASHED*",
         "*1 failed*"
     ])
 
+@needsfork
+@pytest.mark.parametrize("capmode", [
+    "no",
+    pytest.mark.xfail("sys", reason="capture cleanup needed"),
+    pytest.mark.xfail("fd", reason="capture cleanup needed")])
+def test_functional_boxed_capturing(testdir, capmode):
+    p1 = testdir.makepyfile("""
+        import os
+        import sys
+        def test_function():
+            sys.stdout.write("hello\\n")
+            sys.stderr.write("world\\n")
+            os.kill(os.getpid(), 15)
+    """)
+    result = testdir.runpytest(p1, "--boxed", "--capture=%s" % capmode)
+    result.stdout.fnmatch_lines("""
+        *CRASHED*
+        *stdout*
+        hello
+        *stderr*
+        world
+        *1 failed*
+    """)
+
 class TestOptionEffects:
     def test_boxed_option_default(self, testdir):
         tmpdir = testdir.tmpdir.ensure("subdir", dir=1)
-        config = testdir.reparseconfig()
-        config.initsession()
+        config = testdir.parseconfig()
         assert not config.option.boxed
-        py.test.importorskip("execnet")
-        config = testdir.reparseconfig(['-d', tmpdir])
-        config.initsession()
+        pytest.importorskip("execnet")
+        config = testdir.parseconfig('-d', tmpdir)
         assert not config.option.boxed
 
     def test_is_not_boxed_by_default(self, testdir):
-        config = testdir.reparseconfig([testdir.tmpdir])
+        config = testdir.parseconfig(testdir.tmpdir)
         assert not config.option.boxed
 

testing/test_deprecated.py

@@ -1,37 +0,0 @@
-import py
-
-def test_dist_conftest_options(testdir):
-    p1 = testdir.tmpdir.ensure("dir", 'p1.py')
-    p1.dirpath("__init__.py").write("")
-    p1.dirpath("conftest.py").write(py.code.Source("""
-        import py
-        from py.builtin import print_
-        print_("importing conftest", __file__)
-        Option = py.test.config.Option 
-        option = py.test.config.addoptions("someopt", 
-            Option('--someopt', action="store_true", 
-                    dest="someopt", default=False))
-        dist_rsync_roots = ['../dir']
-        print_("added options", option)
-        print_("config file seen from conftest", py.test.config)
-    """))
-    p1.write(py.code.Source("""
-        import py
-        from %s import conftest
-        from py.builtin import print_
-        def test_1(): 
-            print_("config from test_1", py.test.config)
-            print_("conftest from test_1", conftest.__file__)
-            print_("test_1: py.test.config.option.someopt", py.test.config.option.someopt)
-            print_("test_1: conftest", conftest)
-            print_("test_1: conftest.option.someopt", conftest.option.someopt)
-            assert conftest.option.someopt 
-    """ % p1.dirpath().purebasename ))
-    result = testdir.runpytest('-d', '--tx=popen', p1, '--someopt')
-    assert result.ret == 0
-    result.stderr.fnmatch_lines([
-        "*Deprecation*pytest_addoptions*",
-    ])
-    result.stdout.fnmatch_lines([
-        "*1 passed*", 
-    ])

testing/test_dsession.py

@@ -1,6 +1,11 @@
-from xdist.dsession import DSession
-from py._test import outcome
+from xdist.dsession import (
+    DSession,
+    LoadScheduling,
+    EachScheduling,
+    report_collection_diff,
+)
 import py
+import pytest
 import execnet
 
 XSpec = execnet.XSpec
@@ -12,15 +17,22 @@ def run(item, node, excinfo=None):
     rep.node = node
     return rep
 
+class MockGateway:
+    _count = 0
+    def __init__(self):
+        self.id = str(self._count)
+        self._count += 1
+
 class MockNode:
     def __init__(self):
         self.sent = []
+        self.gateway = MockGateway()
 
-    def send(self, item):
-        self.sent.append(item)
+    def send_runtest_some(self, indices):
+        self.sent.extend(indices)
 
-    def sendlist(self, items):
-        self.sent.extend(items)
+    def send_runtest_all(self):
+        self.sent.append("ALL")
 
     def shutdown(self):
         self._shutdown=True
@@ -29,373 +41,147 @@ def dumpqueue(queue):
     while queue.qsize():
         print(queue.get())
 
-class TestDSession:
-    def test_add_remove_node(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        node = MockNode()
-        rep = run(item, node)
-        session = DSession(item.config)
-        assert not session.node2pending
-        session.addnode(node)
-        assert len(session.node2pending) == 1
-        session.senditems_load([item])
-        pending = session.removenode(node)
-        assert pending == [item]
-        assert item not in session.item2nodes
-        l = session.removenode(node)
-        assert not l 
-
-    def test_senditems_each_and_receive_with_two_nodes(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
+class TestEachScheduling:
+    def test_schedule_load_simple(self):
         node1 = MockNode()
         node2 = MockNode()
-        session = DSession(item.config)
-        session.addnode(node1)
-        session.addnode(node2)
-        session.senditems_each([item])
-        assert session.node2pending[node1] == [item]
-        assert session.node2pending[node2] == [item]
-        assert node1 in session.item2nodes[item]
-        assert node2 in session.item2nodes[item]
-        session.removeitem(item, node1)
-        assert session.item2nodes[item] == [node2]
-        session.removeitem(item, node2)
-        assert not session.node2pending[node1] 
-        assert not session.item2nodes
+        sched = EachScheduling(2)
+        sched.addnode(node1)
+        sched.addnode(node2)
+        collection = ["a.py::test_1", ]
+        assert not sched.collection_is_completed
+        sched.addnode_collection(node1, collection)
+        assert not sched.collection_is_completed
+        sched.addnode_collection(node2, collection)
+        assert sched.collection_is_completed
+        assert sched.node2collection[node1] == collection
+        assert sched.node2collection[node2] == collection
+        sched.init_distribute()
+        assert sched.tests_finished()
+        assert node1.sent == ['ALL']
+        assert node2.sent == ['ALL']
+        sched.remove_item(node1, 0)
+        assert sched.tests_finished()
+        sched.remove_item(node2, 0)
+        assert sched.tests_finished()
 
-    def test_senditems_load_and_receive_one_node(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        node = MockNode()
-        rep = run(item, node)
-        session = DSession(item.config)
-        session.addnode(node)
-        session.senditems_load([item])  
-        assert session.node2pending[node] == [item]
-        assert session.item2nodes[item] == [node]
-        session.removeitem(item, node)
-        assert not session.node2pending[node] 
-        assert not session.item2nodes
-
-    def test_triggertesting_collect(self, testdir):
-        modcol = testdir.getmodulecol("""
-            def test_func():
-                pass
-        """)
-        session = DSession(modcol.config)
-        reprec = testdir.getreportrecorder(session)
-        items = session.collect_all_items([modcol])
-        assert len(items) == 1
-        calls= reprec.getcalls("pytest_collectreport")
-        assert len(calls) == 1
-        call = calls[0]
-        assert len(call.report.result) == 1
-
-    def test_senditems_load(self, testdir, monkeypatch):
-        item = testdir.getitem("def test_func(): pass")
-        session = DSession(item.config)
+    def test_schedule_remove_node(self):
         node1 = MockNode()
-        node2 = MockNode()
-        session.addnode(node1)
-        session.addnode(node2)
-        monkeypatch.setattr(session, 'ITEM_CHUNKSIZE', 3)
-        session.senditems_load([item] * (2*session.ITEM_CHUNKSIZE +1))
+        sched = EachScheduling(1)
+        sched.addnode(node1)
+        collection = ["a.py::test_1", ]
+        assert not sched.collection_is_completed
+        sched.addnode_collection(node1, collection)
+        assert sched.collection_is_completed
+        assert sched.node2collection[node1] == collection
+        sched.init_distribute()
+        assert sched.tests_finished()
+        crashitem = sched.remove_node(node1)
+        assert crashitem
+        assert sched.tests_finished()
+        assert not sched.hasnodes()
+
+class TestLoadScheduling:
+    def test_schedule_load_simple(self):
+        sched = LoadScheduling(2)
+        sched.addnode(MockNode())
+        sched.addnode(MockNode())
+        node1, node2 = sched.nodes
+        collection = ["a.py::test_1", "a.py::test_2"]
+        assert not sched.collection_is_completed
+        sched.addnode_collection(node1, collection)
+        assert not sched.collection_is_completed
+        sched.addnode_collection(node2, collection)
+        assert sched.collection_is_completed
+        assert sched.node2collection[node1] == collection
+        assert sched.node2collection[node2] == collection
+        sched.init_distribute()
+        assert not sched.pending
+        assert not sched.tests_finished()
+        assert len(node1.sent) == 2
+        assert len(node2.sent) == 0
+        assert node1.sent == [0, 1]
+        sched.remove_item(node1, node1.sent[0])
+        assert sched.tests_finished()
+        sched.remove_item(node1, node1.sent[1])
+        assert sched.tests_finished()
+
+    def test_init_distribute_chunksize(self):
+        sched = LoadScheduling(2)
+        sched.addnode(MockNode())
+        sched.addnode(MockNode())
+        node1, node2 = sched.nodes
+        col = ["xyz"] * (6)
+        sched.addnode_collection(node1, col)
+        sched.addnode_collection(node2, col)
+        sched.init_distribute()
+        #assert not sched.tests_finished()
         sent1 = node1.sent
         sent2 = node2.sent
-        chunkitems = [item] * session.ITEM_CHUNKSIZE
-        assert sent1 == chunkitems
-        assert sent2 == chunkitems
-        assert session.node2pending[node1] == sent1
-        assert session.node2pending[node2] == sent2
-        name, args, kwargs = session.queue.get(block=False)
-        assert name == "pytest_rescheduleitems"
-        assert kwargs['items'] == [item]
+        assert sent1 == [0, 1]
+        assert sent2 == [2, 3]
+        assert sched.pending == [4, 5]
+        assert sched.node2pending[node1] == sent1
+        assert sched.node2pending[node2] == sent2
+        assert len(sched.pending) == 2
+        sched.remove_item(node1, 0)
+        assert node1.sent == [0, 1, 4]
+        assert sched.pending == [5]
+        assert node2.sent == [2, 3]
+        sched.remove_item(node1, 1)
+        assert node1.sent == [0, 1, 4, 5]
+        assert not sched.pending
 
-    
-    def test_keyboardinterrupt(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        session = DSession(item.config)
-        def raise_(timeout=None): raise KeyboardInterrupt()
-        session.queue.get = raise_
-        exitstatus = session.loop([])
-        assert exitstatus == outcome.EXIT_INTERRUPTED
-
-    def test_internalerror(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        session = DSession(item.config)
-        def raise_(): raise ValueError()
-        session.queue.get = raise_
-        exitstatus = session.loop([])
-        assert exitstatus == outcome.EXIT_INTERNALERROR
-
-    def test_rescheduleevent(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        session = DSession(item.config)
+    def test_add_remove_node(self):
         node = MockNode()
-        session.addnode(node)
-        loopstate = session._initloopstate([])
-        session.queueevent("pytest_rescheduleitems", items=[item])
-        session.loop_once(loopstate)
-        # we need to do work because nothing is pending / we would not wake up
-        assert loopstate.dowork == True
+        sched = LoadScheduling(1)
+        sched.addnode(node)
+        collection = ["test_file.py::test_func"]
+        sched.addnode_collection(node, collection)
+        assert sched.collection_is_completed
+        sched.init_distribute()
+        assert not sched.pending
+        crashitem = sched.remove_node(node)
+        assert crashitem == collection[0]
 
-        session.node2pending[node].append(item)
-        session.queueevent("pytest_rescheduleitems", items=[item])
-        session.loop_once(loopstate)
-        # now we want to not directly trigger work again to avoid busy-wait
-        assert loopstate.dowork == False 
+    def test_different_tests_collected(self, testdir):
+        """
+        Test that LoadScheduling is reporting collection errors when
+        different test ids are collected by slaves.
+        """
+        class CollectHook(object):
+            """
+            Dummy hook that stores collection reports.
+            """
 
-        session.queueevent(None)
-        session.loop_once(loopstate)
-        session.queueevent(None)
-        session.loop_once(loopstate)
-        assert node.sent == [item, item]
-        session.queueevent("pytest_runtest_logreport", report=run(item, node))
-        session.loop_once(loopstate)
-        session.queueevent("pytest_runtest_logreport", report=run(item, node))
-        session.loop_once(loopstate)
-        assert loopstate.shuttingdown 
-        assert not loopstate.testsfailed 
+            def __init__(self):
+                self.reports = []
 
-    def test_no_node_remaining_for_tests(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        # setup a session with one node
-        session = DSession(item.config)
-        node = MockNode()
-        session.addnode(node)
+            def pytest_collectreport(self, report):
+                self.reports.append(report)
 
-        # setup a HostDown event
-        session.queueevent("pytest_testnodedown", node=node, error=None)
-
-        loopstate = session._initloopstate([item])
-        loopstate.dowork = False
-        session.loop_once(loopstate)
-        dumpqueue(session.queue)
-        assert loopstate.exitstatus == outcome.EXIT_NOHOSTS
-
-    def test_removeitem_from_failing_teardown(self, testdir):
-        # teardown reports only come in when they signal a failure
-        # internal session-management should basically ignore them 
-        # XXX probably it'S best to invent a new error hook for 
-        # teardown/setup related failures
-        modcol = testdir.getmodulecol("""
-            def test_one(): 
-                pass 
-            def teardown_function(function):
-                assert 0
-        """)
-        item1, = modcol.collect()
-
-        # setup a session with two nodes
-        session = DSession(item1.config)
-        node1, node2 = MockNode(), MockNode()
-        session.addnode(node1)
-        session.addnode(node2)
-      
-        # have one test pending for a node that goes down 
-        session.senditems_each([item1])
-        nodes = session.item2nodes[item1]
-        class rep:
-            failed = True
-            item = item1
-            node = nodes[0]
-            when = "call"
-        session.queueevent("pytest_runtest_logreport", report=rep)
-        reprec = testdir.getreportrecorder(session)
-        print(session.item2nodes)
-        loopstate = session._initloopstate([])
-        assert len(session.item2nodes[item1]) == 2
-        session.loop_once(loopstate)
-        assert len(session.item2nodes[item1]) == 1
-        rep.when = "teardown"
-        session.queueevent("pytest_runtest_logreport", report=rep)
-        session.loop_once(loopstate)
-        assert len(session.item2nodes[item1]) == 1
-
-    def test_testnodeready_adds_to_available(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        # setup a session with two nodes
-        session = DSession(item.config)
+        collect_hook = CollectHook()
+        config = testdir.parseconfig()
+        config.pluginmanager.register(collect_hook, "collect_hook")
         node1 = MockNode()
-        session.queueevent("pytest_testnodeready", node=node1)
-        loopstate = session._initloopstate([item])
-        loopstate.dowork = False
-        assert len(session.node2pending) == 0
-        session.loop_once(loopstate)
-        assert len(session.node2pending) == 1
+        node2 = MockNode()
+        sched = LoadScheduling(2, config=config)
+        sched.addnode(node1)
+        sched.addnode(node2)
+        sched.addnode_collection(node1, ["a.py::test_1"])
+        sched.addnode_collection(node2, ["a.py::test_2"])
+        sched.init_distribute()
+        assert len(collect_hook.reports) == 1
+        rep = collect_hook.reports[0]
+        assert 'Different tests were collected between' in rep.longrepr
 
-    def runthrough(self, item, excinfo=None):
-        session = DSession(item.config)
-        node = MockNode()
-        session.addnode(node)
-        loopstate = session._initloopstate([item])
 
-        session.queueevent(None)
-        session.loop_once(loopstate)
-
-        assert node.sent == [item]
-        ev = run(item, node, excinfo=excinfo) 
-        session.queueevent("pytest_runtest_logreport", report=ev)
-        session.loop_once(loopstate)
-        assert loopstate.shuttingdown  
-        session.queueevent("pytest_testnodedown", node=node, error=None)
-        session.loop_once(loopstate)
-        dumpqueue(session.queue)
-        return session, loopstate.exitstatus 
-
-    def test_exit_completed_tests_ok(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        session, exitstatus = self.runthrough(item)
-        assert exitstatus == outcome.EXIT_OK
-
-    def test_exit_completed_tests_fail(self, testdir):
-        item = testdir.getitem("def test_func(): 0/0")
-        session, exitstatus = self.runthrough(item, excinfo="fail")
-        assert exitstatus == outcome.EXIT_TESTSFAILED
-
-    def test_exit_on_first_failing(self, testdir):
-        modcol = testdir.getmodulecol("""
-            def test_fail(): 
-                assert 0
-            def test_pass(): 
-                pass
-        """)
-        modcol.config.option.exitfirst = True
-        session = DSession(modcol.config)
-        node = MockNode()
-        session.addnode(node)
-        items = modcol.config.hook.pytest_make_collect_report(collector=modcol).result
-
-        # trigger testing  - this sends tests to the node
-        session.triggertesting(items)
-
-        # run tests ourselves and produce reports 
-        ev1 = run(items[0], node, "fail")
-        ev2 = run(items[1], node, None)
-        session.queueevent("pytest_runtest_logreport", report=ev1) # a failing one
-        session.queueevent("pytest_runtest_logreport", report=ev2)
-        # now call the loop
-        loopstate = session._initloopstate(items)
-        from xdist.dsession import ExitFirstInterrupt
-        py.test.raises(ExitFirstInterrupt, "session.loop_once(loopstate)")
-        assert loopstate.testsfailed
-        #assert loopstate.shuttingdown
-
-    def test_shuttingdown_filters(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        session = DSession(item.config)
-        node = MockNode()
-        session.addnode(node)
-        loopstate = session._initloopstate([])
-        loopstate.shuttingdown = True
-        reprec = testdir.getreportrecorder(session)
-        session.queueevent("pytest_runtest_logreport", report=run(item, node))
-        session.loop_once(loopstate)
-        assert not reprec.getcalls("pytest_testnodedown")
-        session.queueevent("pytest_testnodedown", node=node, error=None)
-        session.loop_once(loopstate)
-        assert reprec.getcall('pytest_testnodedown').node == node
-
-    def test_filteritems(self, testdir):
-        modcol = testdir.getmodulecol("""
-            def test_fail(): 
-                assert 0
-            def test_pass(): 
-                pass
-        """)
-        session = DSession(modcol.config)
-
-        modcol.config.option.keyword = "nothing"
-        dsel = session.filteritems([modcol])
-        assert dsel == [modcol] 
-        items = modcol.collect()
-        hookrecorder = testdir.getreportrecorder(session).hookrecorder
-        remaining = session.filteritems(items)
-        assert remaining == []
-        
-        event = hookrecorder.getcalls("pytest_deselected")[-1]
-        assert event.items == items 
-
-        modcol.config.option.keyword = "test_fail"
-        remaining = session.filteritems(items)
-        assert remaining == [items[0]]
-
-        event = hookrecorder.getcalls("pytest_deselected")[-1]
-        assert event.items == [items[1]]
-
-    def test_testnodedown_shutdown_after_completion(self, testdir):
-        item = testdir.getitem("def test_func(): pass")
-        session = DSession(item.config)
-
-        node = MockNode()
-        session.addnode(node)
-        session.senditems_load([item])
-        session.queueevent("pytest_runtest_logreport", report=run(item, node))
-        loopstate = session._initloopstate([])
-        session.loop_once(loopstate)
-        assert node._shutdown is True
-        assert loopstate.exitstatus is None, "loop did not wait for testnodedown"
-        assert loopstate.shuttingdown 
-        session.queueevent("pytest_testnodedown", node=node, error=None)
-        session.loop_once(loopstate)
-        assert loopstate.exitstatus == 0
-
-    def test_nopending_but_collection_remains(self, testdir):
-        modcol = testdir.getmodulecol("""
-            def test_fail(): 
-                assert 0
-            def test_pass(): 
-                pass
-        """)
-        session = DSession(modcol.config)
-        node = MockNode()
-        session.addnode(node)
-
-        colreport = modcol.config.hook.pytest_make_collect_report(collector=modcol)
-        item1, item2 = colreport.result
-        session.senditems_load([item1])
-        # node2pending will become empty when the loop sees the report 
-        rep = run(item1, node)
-        session.queueevent("pytest_runtest_logreport", report=run(item1, node)) 
-
-        # but we have a collection pending
-        session.queueevent("pytest_collectreport", report=colreport) 
-
-        loopstate = session._initloopstate([])
-        session.loop_once(loopstate)
-        assert loopstate.exitstatus is None, "loop did not care for collection report"
-        assert not loopstate.colitems 
-        session.loop_once(loopstate)
-        assert loopstate.colitems == colreport.result
-        assert loopstate.exitstatus is None, "loop did not care for colitems"
-
-    def test_dist_some_tests(self, testdir):
-        p1 = testdir.makepyfile(test_one="""
-            def test_1(): 
-                pass
-            def test_x():
-                import py
-                py.test.skip("aaa")
-            def test_fail():
-                assert 0
-        """)
-        config = testdir.parseconfig('-d', p1, '--tx=popen')
-        dsession = DSession(config)
-        hookrecorder = testdir.getreportrecorder(config).hookrecorder
-        dsession.main([config.getnode(p1)])
-        rep = hookrecorder.popcall("pytest_runtest_logreport").report
-        assert rep.passed
-        rep = hookrecorder.popcall("pytest_runtest_logreport").report
-        assert rep.skipped
-        rep = hookrecorder.popcall("pytest_runtest_logreport").report
-        assert rep.failed
-        # see that the node is really down 
-        node = hookrecorder.popcall("pytest_testnodedown").node
-        assert node.gateway.spec.popen
-        #XXX eq.geteventargs("pytest_sessionfinish")
+class TestDistReporter:
 
+    @py.test.mark.xfail
     def test_rsync_printing(self, testdir, linecomp):
         config = testdir.parseconfig()
-        from py._plugin.pytest_terminal import TerminalReporter
+        from _pytest.pytest_terminal import TerminalReporter
         rep = TerminalReporter(config, file=linecomp.stringio)
         config.pluginmanager.register(rep, "terminalreporter")
         dsession = DSession(config)
@@ -411,123 +197,54 @@ class TestDSession:
         #    platform = "xyz"
         #    cwd = "qwe"
 
-        #dsession.pytest_gwmanage_newgateway(gw1, rinfo)
+        #dsession.pytest_xdist_newgateway(gw1, rinfo)
         #linecomp.assert_contains_lines([
         #    "*X1*popen*xyz*2.5*"
         #])
-        dsession.pytest_gwmanage_rsyncstart(source="hello", gateways=[gw1, gw2])
+        dsession.pytest_xdist_rsyncstart(source="hello", gateways=[gw1, gw2])
         linecomp.assert_contains_lines([
             "[X1,X2] rsyncing: hello",
         ])
 
-def test_collected_function_causes_remote_skip(testdir):
-    sub = testdir.mkpydir("testing")
-    sub.join("test_module.py").write(py.code.Source("""
-        import py
-        path = py.path.local(%r)
-        if path.check():
-            path.remove()
-        else:
-            py.test.skip("remote skip")
-        def test_func(): 
-            pass
-        def test_func2(): 
-            pass
-    """ % str(sub.ensure("somefile"))))
-    result = testdir.runpytest('-v', '--dist=each', '--tx=popen')
-    result.stdout.fnmatch_lines([
-        "*2 skipped*"
-    ])
 
-def test_teardownfails_one_function(testdir):
-    p = testdir.makepyfile("""
-        def test_func(): 
+def test_report_collection_diff_equal():
+    """Test reporting of equal collections."""
+    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']
+    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'
+    )
+
+    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("""
+        import pytest
+
+        @pytest.mark.parametrize('birth_year', [1988, 1988, ])
+        def test_2011_table(birth_year):
             pass
-        def teardown_function(function):
+    """)
+    reprec = testdir.inline_run("-n1")
+    reprec.assertoutcome(passed=2)
     assert 0
-    """)
-    result = testdir.runpytest(p, '--dist=each', '--tx=popen')
-    result.stdout.fnmatch_lines([
-        "*def teardown_function(function):*", 
-        "*1 passed*1 error*"
-    ])
-
-@py.test.mark.xfail
-def test_terminate_on_hangingnode(testdir):
-    p = testdir.makeconftest("""
-        def pytest__teardown_final(session):
-            if session.nodeid == "my": # running on slave
-                import time
-                time.sleep(3)
-    """)
-    result = testdir.runpytest(p, '--dist=each', '--tx=popen//id=my')
-    assert result.duration < 2.0 
-    result.stdout.fnmatch_lines([
-        "*killed*my*",
-    ])
-
-
-
-def test_session_hooks(testdir):
-    testdir.makeconftest("""
-        import sys
-        def pytest_sessionstart(session):
-            sys.pytestsessionhooks = session
-        def pytest_sessionfinish(session):
-            f = open(session.nodeid or "master", 'w')
-            f.write("xy")
-            f.close()
-            # let's fail on the slave
-            if session.nodeid: 
-                raise ValueError(42)
-    """) 
-    p = testdir.makepyfile("""
-        import sys
-        def test_hello():
-            assert hasattr(sys, 'pytestsessionhooks')
-    """)
-    result = testdir.runpytest(p, "--dist=each", "--tx=popen//id=my1")
-    result.stdout.fnmatch_lines([
-        "*ValueError*",
-        "*1 passed*",
-    ])
-    assert result.ret 
-    d = result.parseoutcomes()
-    assert d['passed'] == 1
-    assert testdir.tmpdir.join("my1").check()
-    assert testdir.tmpdir.join("master").check()
-
-def test_funcarg_teardown_failure(testdir):
-    p = testdir.makepyfile("""
-        def pytest_funcarg__myarg(request):
-            def teardown(val):
-                raise ValueError(val)
-            return request.cached_setup(setup=lambda: 42, teardown=teardown, 
-                scope="module")
-        def test_hello(myarg):
-            pass
-    """)
-    result = testdir.runpytest(p, "-n1")
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*ValueError*42*",
-        "*1 passed*1 error*",
-    ])
-
-def test_crashing_item(testdir):
-    p = testdir.makepyfile("""
-        import py
-        import os
-        def test_crash():
-            py.process.kill(os.getpid())
-        def test_noncrash():
-            pass
-    """)
-    result = testdir.runpytest("-n2", p)
-    result.stdout.fnmatch_lines([
-        "*crashed*test_crash*",
-        "*1 failed*1 passed*"
-    ])
-
-
-    

testing/test_gwmanage.py

@@ -1,120 +0,0 @@
-import py
-import os
-from xdist.gwmanage import GatewayManager, HostRSync
-from py._test.pluginmanager import HookRelay, Registry
-from py._plugin import hookspec
-import execnet
-
-def pytest_funcarg__hookrecorder(request):
-    _pytest = request.getfuncargvalue('_pytest')
-    hook = request.getfuncargvalue('hook')
-    return _pytest.gethookrecorder(hook)
-
-def pytest_funcarg__hook(request):
-    return HookRelay(hookspec, Registry())
-
-class TestGatewayManagerPopen:
-    def test_popen_no_default_chdir(self, hook):
-        gm = GatewayManager(["popen"], hook)
-        assert gm.specs[0].chdir is None
-
-    def test_default_chdir(self, hook):
-        l = ["ssh=noco", "socket=xyz"]
-        for spec in GatewayManager(l, hook).specs:
-            assert spec.chdir == "pyexecnetcache"
-        for spec in GatewayManager(l, hook, defaultchdir="abc").specs:
-            assert spec.chdir == "abc"
-        
-    def test_popen_makegateway_events(self, hook, hookrecorder, _pytest):
-        hm = GatewayManager(["popen"] * 2, hook)
-        hm.makegateways()
-        call = hookrecorder.popcall("pytest_gwmanage_newgateway")
-        assert call.gateway.spec == execnet.XSpec("popen")
-        assert call.gateway.id == "gw0"
-        assert call.platinfo.executable == call.gateway._rinfo().executable
-        call = hookrecorder.popcall("pytest_gwmanage_newgateway")
-        assert call.gateway.id == "gw1" 
-        assert len(hm.group) == 2
-        hm.exit()
-        assert not len(hm.group) 
-
-    def test_popens_rsync(self, hook, mysetup):
-        source = mysetup.source
-        hm = GatewayManager(["popen"] * 2, hook)
-        hm.makegateways()
-        assert len(hm.group) == 2
-        for gw in hm.group:
-            class pseudoexec:
-                args = []
-                def __init__(self, *args):
-                    self.args.extend(args)
-                def waitclose(self):
-                    pass
-            gw.remote_exec = pseudoexec
-        l = []
-        hm.rsync(source, notify=lambda *args: l.append(args))
-        assert not l
-        hm.exit()
-        assert not len(hm.group) 
-        assert "sys.path.insert" in gw.remote_exec.args[0] 
-
-    def test_rsync_popen_with_path(self, hook, mysetup):
-        source, dest = mysetup.source, mysetup.dest 
-        hm = GatewayManager(["popen//chdir=%s" %dest] * 1, hook)
-        hm.makegateways()
-        source.ensure("dir1", "dir2", "hello")
-        l = []
-        hm.rsync(source, notify=lambda *args: l.append(args))
-        assert len(l) == 1
-        assert l[0] == ("rsyncrootready", hm.group['gw0'].spec, source)
-        hm.exit()
-        dest = dest.join(source.basename)
-        assert dest.join("dir1").check()
-        assert dest.join("dir1", "dir2").check()
-        assert dest.join("dir1", "dir2", 'hello').check()
-
-    def test_rsync_same_popen_twice(self, hook, mysetup, hookrecorder):
-        source, dest = mysetup.source, mysetup.dest 
-        hm = GatewayManager(["popen//chdir=%s" %dest] * 2, hook)
-        hm.makegateways()
-        source.ensure("dir1", "dir2", "hello")
-        hm.rsync(source)
-        call = hookrecorder.popcall("pytest_gwmanage_rsyncstart") 
-        assert call.source == source 
-        assert len(call.gateways) == 1
-        assert call.gateways[0] in hm.group
-        call = hookrecorder.popcall("pytest_gwmanage_rsyncfinish") 
-
-class pytest_funcarg__mysetup:
-    def __init__(self, request):
-        tmp = request.getfuncargvalue('tmpdir')
-        self.source = tmp.mkdir("source")
-        self.dest = tmp.mkdir("dest")
-
-class TestHRSync:
-    def test_hrsync_filter(self, mysetup):
-        source, dest = mysetup.source, mysetup.dest
-        source.ensure("dir", "file.txt")
-        source.ensure(".svn", "entries")
-        source.ensure(".somedotfile", "moreentries")
-        source.ensure("somedir", "editfile~")
-        syncer = HostRSync(source)
-        l = list(source.visit(rec=syncer.filter,
-                                   fil=syncer.filter))
-        assert len(l) == 3
-        basenames = [x.basename for x in l]
-        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
-        gw = execnet.makegateway("popen//chdir=%s" % dest)
-        finished = []
-        rsync = HostRSync(source)
-        rsync.add_target_host(gw, finished=lambda: finished.append(1))
-        source.join("hello.py").write("world")
-        rsync.send()
-        gw.exit()
-        assert dest.join(source.basename, "hello.py").check()
-        assert len(finished) == 1

testing/test_looponfail.py

@@ -0,0 +1,280 @@
+import py
+from xdist.looponfail import RemoteControl
+from xdist.looponfail import StatRecorder
+
+class TestStatRecorder:
+    def test_filechange(self, tmpdir):
+        tmp = tmpdir
+        hello = tmp.ensure("hello.py")
+        sd = StatRecorder([tmp])
+        changed = sd.check()
+        assert not changed
+
+        hello.write("world")
+        changed = sd.check()
+        assert changed
+
+        (hello + "c").write("hello")
+        changed = sd.check()
+        assert not changed
+
+        p = tmp.ensure("new.py")
+        changed = sd.check()
+        assert changed
+
+        p.remove()
+        changed = sd.check()
+        assert changed
+
+        tmp.join("a", "b", "c.py").ensure()
+        changed = sd.check()
+        assert changed
+
+        tmp.join("a", "c.txt").ensure()
+        changed = sd.check()
+        assert changed
+        changed = sd.check()
+        assert not changed
+
+        tmp.join("a").remove()
+        changed = sd.check()
+        assert changed
+
+    def test_dirchange(self, tmpdir):
+        tmp = tmpdir
+        tmp.ensure("dir", "hello.py")
+        sd = StatRecorder([tmp])
+        assert not sd.fil(tmp.join("dir"))
+
+    def test_filechange_deletion_race(self, tmpdir, monkeypatch):
+        tmp = tmpdir
+        sd = StatRecorder([tmp])
+        changed = sd.check()
+        assert not changed
+
+        p = tmp.ensure("new.py")
+        changed = sd.check()
+        assert changed
+
+        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])
+
+        changed = sd.check()
+        assert changed
+
+    def test_pycremoval(self, tmpdir):
+        tmp = tmpdir
+        hello = tmp.ensure("hello.py")
+        sd = StatRecorder([tmp])
+        changed = sd.check()
+        assert not changed
+
+        pycfile = hello + "c"
+        pycfile.ensure()
+        hello.write("world")
+        changed = sd.check()
+        assert changed
+        assert not pycfile.check()
+
+    def test_waitonchange(self, tmpdir, monkeypatch):
+        tmp = tmpdir
+        sd = StatRecorder([tmp])
+
+        l = [True, False]
+        monkeypatch.setattr(StatRecorder, 'check', lambda self: l.pop())
+        sd.waitonchange(checkinterval=0.2)
+        assert not l
+
+class TestRemoteControl:
+    def test_nofailures(self, testdir):
+        item = testdir.getitem("def test_func(): pass\n")
+        control = RemoteControl(item.config)
+        control.setup()
+        topdir, failures = control.runsession()[:2]
+        assert not failures
+
+    def test_failures_somewhere(self, testdir):
+        item = testdir.getitem("def test_func():\n assert 0\n")
+        control = RemoteControl(item.config)
+        control.setup()
+        failures = control.runsession()
+        assert failures
+        control.setup()
+        item.fspath.write("def test_func():\n assert 1\n")
+        removepyc(item.fspath)
+        topdir, failures = control.runsession()[:2]
+        assert not failures
+
+    def test_failure_change(self, testdir):
+        modcol = testdir.getitem("""
+            def test_func():
+                assert 0
+        """)
+        control = RemoteControl(modcol.config)
+        control.loop_once()
+        assert control.failures
+        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
+        control.loop_once()
+        assert control.failures
+        assert str(control.failures).find("test_new") != -1
+
+    def test_failure_subdir_no_init(self, testdir):
+        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]
+        control = RemoteControl(modcol.config)
+        control.loop_once()
+        assert control.failures
+        control.loop_once()
+        assert control.failures
+
+class TestLooponFailing:
+    def test_looponfail_from_fail_to_ok(self, testdir):
+        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("""
+            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("""
+            def test_one():
+                assert 0
+        """)
+        remotecontrol = RemoteControl(modcol.config)
+        remotecontrol.loop_once()
+        assert len(remotecontrol.failures) == 1
+        assert 'test_one' in remotecontrol.failures[0]
+
+        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]
+
+    def test_looponfail_removed_test(self, testdir):
+        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("""
+            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
+
+        remotecontrol.loop_once()
+        assert len(remotecontrol.failures) == 1
+
+    def test_looponfail_multiple_errors(self, testdir, monkeypatch):
+        modcol = testdir.getmodulecol("""
+            def test_one():
+                assert 0
+        """)
+        remotecontrol = RemoteControl(modcol.config)
+        orig_runsession = remotecontrol.runsession
+
+        def runsession_dups():
+            # twisted.trial test cases may report multiple errors.
+            failures, reports, collection_failed = orig_runsession()
+            print (failures)
+            return failures * 2, reports, collection_failed
+
+        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("""
+            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)
+        child.expect("def test_one")
+        child.expect("x == 1")
+        child.expect("1 failed")
+        child.expect("### LOOPONFAILING ####")
+        child.expect("waiting for changes")
+        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("""
+            import py
+            @py.test.mark.xfail
+            def test_one():
+                pass
+        """)
+        child = testdir.spawn_pytest("-f %s" % p)
+        child.expect("1 xpass")
+        child.expect("### LOOPONFAILING ####")
+        child.expect("waiting for changes")
+        child.kill(15)
+
+def removepyc(path):
+    # XXX damn those pyc files
+    pyc = path + "c"
+    if pyc.check():
+        pyc.remove()
+    c = path.dirpath("__pycache__")
+    if c.check():
+        c.remove()
+

testing/test_mypickle.py

@@ -1,254 +0,0 @@
-
-import py
-import sys
-import execnet
-
-Queue = py.builtin._tryimport('queue', 'Queue').Queue
-
-from xdist.mypickle import ImmutablePickler, PickleChannel
-from xdist.mypickle import UnpickleError, makekey
-# first let's test some basic functionality 
-
-def pytest_generate_tests(metafunc):
-    if 'picklemod' in metafunc.funcargnames:
-        import pickle
-        metafunc.addcall(funcargs={'picklemod': pickle})
-        try:
-            import cPickle
-        except ImportError:
-            pass
-        else:
-            metafunc.addcall(funcargs={'picklemod': cPickle})
-    elif "obj" in metafunc.funcargnames and "proto" in metafunc.funcargnames:
-        a1 = A()
-        a2 = A()
-        a2.a1 = a1
-        for proto in (0,1,2, -1):
-            for obj in {1:2}, [1,2,3], a1, a2:
-                metafunc.addcall(funcargs=dict(obj=obj, proto=proto))
-
-def test_underlying_basic_pickling_mechanisms(picklemod):
-    f1 = py.io.BytesIO()
-    f2 = py.io.BytesIO()
-
-    pickler1 = picklemod.Pickler(f1)
-    unpickler1 = picklemod.Unpickler(f2)
-
-    pickler2 = picklemod.Pickler(f2)
-    unpickler2 = picklemod.Unpickler(f1)
-
-    #pickler1.memo = unpickler1.memo = {}
-    #pickler2.memo = unpickler2.memo = {}
-
-    d = {}
-
-    pickler1.dump(d)
-    f1.seek(0)
-    d_other = unpickler2.load()
-
-    # translate unpickler2 memo to pickler2
-    pickler2.memo = dict([(id(obj), (int(x), obj))
-                            for x, obj in unpickler2.memo.items()])
-
-    pickler2.dump(d_other)
-    f2.seek(0)
-        
-    unpickler1.memo = dict([(makekey(x), y) 
-                                for x, y in pickler1.memo.values()])
-    d_back = unpickler1.load()
-    assert d is d_back
-
-
-class A: 
-    pass
-
-        
-def test_pickle_and_back_IS_same(obj, proto):
-    p1 = ImmutablePickler(uneven=False, protocol=proto)
-    p2 = ImmutablePickler(uneven=True, protocol=proto)
-    s1 = p1.dumps(obj)
-    d2 = p2.loads(s1)
-    s2 = p2.dumps(d2)
-    obj_back = p1.loads(s2)
-    assert obj is obj_back 
-
-def test_pickling_twice_before_unpickling():
-    p1 = ImmutablePickler(uneven=False)
-    p2 = ImmutablePickler(uneven=True)
-
-    a1 = A()
-    a2 = A()
-    a3 = A() 
-    a3.a1 = a1
-    a2.a1 = a1
-    s1 = p1.dumps(a1)
-    a1.a3 = a3
-    s2 = p1.dumps(a2)
-    other_a1 = p2.loads(s1)
-    other_a2 = p2.loads(s2)
-    back_a1 = p1.loads(p2.dumps(other_a1))
-    other_a3 = p2.loads(p1.dumps(a3))
-    back_a3 = p1.loads(p2.dumps(other_a3))
-    back_a2 = p1.loads(p2.dumps(other_a2))
-    back_a1 = p1.loads(p2.dumps(other_a1))
-    assert back_a1 is a1
-    assert back_a2 is a2
-
-def test_pickling_concurrently():
-    p1 = ImmutablePickler(uneven=False)
-    p2 = ImmutablePickler(uneven=True)
-
-    a1 = A()
-    a1.hasattr = 42
-    a2 = A()
-
-    s1 = p1.dumps(a1)  
-    s2 = p2.dumps(a2)
-    other_a1 = p2.loads(s1)
-    other_a2 = p1.loads(s2)
-    a1_back = p1.loads(p2.dumps(other_a1))
-
-def test_self_memoize():
-    p1 = ImmutablePickler(uneven=False)
-    a1 = A()
-    p1.selfmemoize(a1)
-    x = p1.loads(p1.dumps(a1))
-    assert x is a1
-
-TESTTIMEOUT = 2.0
-class TestPickleChannelFunctional:
-    def setup_class(cls):
-        cls.gw = execnet.PopenGateway()
-        cls.gw.remote_exec(
-            "import py ; py.path.local(%r).pyimport()" %(__file__)
-        )
-        cls.gw.remote_init_threads(5)
-        # we need the remote test code to import 
-        # the same test module here
-
-    def test_popen_send_instance(self):
-        channel = self.gw.remote_exec("""
-            from xdist.mypickle import PickleChannel
-            channel = PickleChannel(channel)
-            from testing.test_mypickle import A
-            a1 = A()
-            a1.hello = 10
-            channel.send(a1)
-            a2 = channel.receive()
-            channel.send(a2 is a1)
-        """)
-        channel = PickleChannel(channel)
-        a_received = channel.receive()
-        assert isinstance(a_received, A)
-        assert a_received.hello == 10
-        channel.send(a_received)
-        remote_a2_is_a1 = channel.receive()
-        assert remote_a2_is_a1 
-
-    def test_send_concurrent(self):
-        channel = self.gw.remote_exec("""
-            from xdist.mypickle import PickleChannel
-            channel = PickleChannel(channel)
-            from testing.test_mypickle import A
-            l = [A() for i in range(10)]
-            channel.send(l)
-            other_l = channel.receive() 
-            channel.send((l, other_l))
-            channel.send(channel.receive())
-            channel.receive()
-        """)
-        channel = PickleChannel(channel)
-        l = [A() for i in range(10)]
-        channel.send(l)
-        other_l = channel.receive()
-        channel.send(other_l)
-        ret = channel.receive()
-        assert ret[0] is other_l
-        assert ret[1] is l 
-        back = channel.receive()
-        assert other_l is other_l 
-        channel.send(None)
-
-    #s1 = p1.dumps(a1)  
-    #s2 = p2.dumps(a2)
-    #other_a1 = p2.loads(s1)
-    #other_a2 = p1.loads(s2)
-    #a1_back = p1.loads(p2.dumps(other_a1))
-        
-    def test_popen_with_callback(self):
-        channel = self.gw.remote_exec("""
-            from xdist.mypickle import PickleChannel
-            channel = PickleChannel(channel)
-            from testing.test_mypickle import A
-            a1 = A()
-            a1.hello = 10
-            channel.send(a1)
-            a2 = channel.receive()
-            channel.send(a2 is a1)
-        """)
-        channel = PickleChannel(channel)
-        queue = Queue()
-        channel.setcallback(queue.put)
-        a_received = queue.get(timeout=TESTTIMEOUT)
-        assert isinstance(a_received, A)
-        assert a_received.hello == 10
-        channel.send(a_received)
-        #remote_a2_is_a1 = queue.get(timeout=TESTTIMEOUT)
-        #assert remote_a2_is_a1 
-
-    def test_popen_with_callback_with_endmarker(self):
-        channel = self.gw.remote_exec("""
-            from xdist.mypickle import PickleChannel
-            channel = PickleChannel(channel)
-            from testing.test_mypickle import A
-            a1 = A()
-            a1.hello = 10
-            channel.send(a1)
-            a2 = channel.receive()
-            channel.send(a2 is a1)
-        """)
-        channel = PickleChannel(channel)
-        queue = Queue()
-        channel.setcallback(queue.put, endmarker=-1)
-          
-        a_received = queue.get(timeout=TESTTIMEOUT)
-        assert isinstance(a_received, A)
-        assert a_received.hello == 10
-        channel.send(a_received)
-        remote_a2_is_a1 = queue.get(timeout=TESTTIMEOUT)
-        assert remote_a2_is_a1 
-        endmarker = queue.get(timeout=TESTTIMEOUT)
-        assert endmarker == -1
-
-    def test_popen_with_callback_with_endmarker_and_unpickling_error(self):
-        channel = self.gw.remote_exec("""
-            from xdist.mypickle import PickleChannel
-            channel = PickleChannel(channel)
-            from testing.test_mypickle import A
-            a1 = A()
-            channel.send(a1)
-            channel.send(a1)
-        """)
-        channel = PickleChannel(channel)
-        queue = Queue()
-        a = channel.receive()
-        channel._ipickle._unpicklememo.clear()
-        channel.setcallback(queue.put, endmarker=-1)
-        next = queue.get(timeout=TESTTIMEOUT)
-        assert next == -1 
-        error = channel._getremoteerror()
-        assert isinstance(error, UnpickleError)
-
-    def test_popen_with_various_methods(self):
-        channel = self.gw.remote_exec("""
-            from xdist.mypickle import PickleChannel
-            channel = PickleChannel(channel)
-            channel.receive()
-        """)
-        channel = PickleChannel(channel)
-        assert not channel.isclosed()
-        assert not channel._getremoteerror()
-        channel.send(2)
-        channel.waitclose(timeout=2)
-
-

testing/test_nodemanage.py

@@ -1,120 +0,0 @@
-import py
-from xdist.nodemanage import NodeManager
-
-class pytest_funcarg__mysetup:
-    def __init__(self, request):
-        basetemp = request.config.mktemp(
-            "mysetup-%s" % request.function.__name__, 
-            numbered=True)
-        self.source = basetemp.mkdir("source")
-        self.dest = basetemp.mkdir("dest")
-        request.getfuncargvalue("_pytest")
-
-class TestNodeManager:
-    @py.test.mark.xfail
-    def test_rsync_roots_no_roots(self, testdir, mysetup):
-        mysetup.source.ensure("dir1", "file1").write("hello")
-        config = testdir.reparseconfig([source])
-        nodemanager = NodeManager(config, ["popen//chdir=%s" % mysetup.dest])
-        assert nodemanager.config.topdir == source == config.topdir
-        nodemanager.rsync_roots()
-        p, = nodemanager.gwmanager.multi_exec("import os ; channel.send(os.getcwd())").receive_each()
-        p = py.path.local(p)
-        py.builtin.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):
-        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, 
-            ))
-            assert nodemanager.config.topdir == source
-            nodemanager.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()
-            nodemanager.gwmanager.exit()
-
-    def test_init_rsync_roots(self, testdir, mysetup):
-        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("conftest.py").write(py.code.Source("""
-            rsyncdirs = ['dir1/dir2']
-        """))
-        session = testdir.reparseconfig([source]).initsession()
-        nodemanager = NodeManager(session.config, ["popen//chdir=%s" % dest])
-        nodemanager.rsync_roots()
-        assert dest.join("dir2").check()
-        assert not dest.join("dir1").check()
-        assert not dest.join("bogus").check()
-
-    def test_rsyncignore(self, testdir, mysetup):
-        source, dest = mysetup.source, mysetup.dest
-        dir2 = source.ensure("dir1", "dir2", dir=1)
-        dir5 = source.ensure("dir5", "dir6", "bogus")
-        dirf = source.ensure("dir5", "file")
-        dir2.ensure("hello")
-        source.join("conftest.py").write(py.code.Source("""
-            rsyncdirs = ['dir1', 'dir5']
-            rsyncignore = ['dir1/dir2', 'dir5/dir6']
-        """))
-        session = testdir.reparseconfig([source]).initsession()
-        nodemanager = NodeManager(session.config,
-                         ["popen//chdir=%s" % dest])
-        nodemanager.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()
-
-    def test_optimise_popen(self, testdir, mysetup):
-        source, dest = mysetup.source, mysetup.dest
-        specs = ["popen"] * 3
-        source.join("conftest.py").write("rsyncdirs = ['a']")
-        source.ensure('a', dir=1)
-        config = testdir.reparseconfig([source])
-        nodemanager = NodeManager(config, specs)
-        nodemanager.rsync_roots()
-        for gwspec in nodemanager.gwmanager.specs:
-            assert gwspec._samefilesystem()
-            assert not gwspec.chdir
-
-    def test_setup_DEBUG(self, mysetup, testdir):
-        source = mysetup.source
-        specs = ["popen"] * 2
-        source.join("conftest.py").write("rsyncdirs = ['a']")
-        source.ensure('a', dir=1)
-        config = testdir.reparseconfig([source, '--debug'])
-        assert config.option.debug
-        nodemanager = NodeManager(config, specs)
-        reprec = testdir.getreportrecorder(config).hookrecorder
-        nodemanager.setup_nodes(putevent=[].append)
-        for spec in nodemanager.gwmanager.specs:
-            l = reprec.getcalls("pytest_trace")
-            assert l 
-        nodemanager.teardown_nodes()
-
-    def test_ssh_setup_nodes(self, specssh, testdir):
-        testdir.makepyfile(__init__="", test_x="""
-            def test_one():
-                pass
-        """)
-        reprec = testdir.inline_run("-d", "--rsyncdir=%s" % testdir.tmpdir, 
-                "--tx", specssh, testdir.tmpdir)
-        rep, = reprec.getreports("pytest_runtest_logreport")
-        assert rep.passed 
-

testing/test_pickling.py

@@ -1,82 +0,0 @@
-import py
-import pickle
-
-def setglobals(request):
-    oldconfig = py.test.config 
-    print("setting py.test.config to None")
-    py.test.config = None
-    def resetglobals():
-        py.builtin.print_("setting py.test.config to", oldconfig)
-        py.test.config = oldconfig
-    request.addfinalizer(resetglobals)
-
-def pytest_funcarg__testdir(request):
-    setglobals(request)
-    return request.getfuncargvalue("testdir")
-
-class ImmutablePickleTransport:
-    def __init__(self, request):
-        from xdist.mypickle import ImmutablePickler
-        self.p1 = ImmutablePickler(uneven=0)
-        self.p2 = ImmutablePickler(uneven=1)
-        setglobals(request)
-
-    def p1_to_p2(self, obj):
-        return self.p2.loads(self.p1.dumps(obj))
-
-    def p2_to_p1(self, obj):
-        return self.p1.loads(self.p2.dumps(obj))
-
-    def unifyconfig(self, config):
-        p2config = self.p1_to_p2(config)
-        p2config._initafterpickle(config.topdir)
-        return p2config
-
-pytest_funcarg__pickletransport = ImmutablePickleTransport
-
-class TestImmutablePickling:
-    def test_pickle_config(self, testdir, pickletransport):
-        config1 = testdir.parseconfig()
-        assert config1.topdir == testdir.tmpdir
-        testdir.chdir()
-        p2config = pickletransport.p1_to_p2(config1)
-        assert p2config.topdir.realpath() == config1.topdir.realpath()
-        config_back = pickletransport.p2_to_p1(p2config)
-        assert config_back is config1
-
-    def test_pickle_modcol(self, testdir, pickletransport):
-        modcol1 = testdir.getmodulecol("def test_one(): pass")
-        modcol2a = pickletransport.p1_to_p2(modcol1)
-        modcol2b = pickletransport.p1_to_p2(modcol1)
-        assert modcol2a is modcol2b
-
-        modcol1_back = pickletransport.p2_to_p1(modcol2a)
-        assert modcol1_back
-
-    def test_pickle_func(self, testdir, pickletransport):
-        modcol1 = testdir.getmodulecol("def test_one(): pass")
-        item = modcol1.collect_by_name("test_one")
-        testdir.chdir()
-        item2a = pickletransport.p1_to_p2(item)
-        assert item is not item2a # of course
-        assert item2a.name == item.name
-        modback = pickletransport.p2_to_p1(item2a.parent)
-        assert modback is modcol1
-
-
-def test_config__setstate__wired_correctly_in_childprocess(testdir):
-    execnet = py.test.importorskip("execnet")
-    from xdist.mypickle import PickleChannel
-    gw = execnet.makegateway()
-    channel = gw.remote_exec("""
-        import py
-        from xdist.mypickle import PickleChannel
-        channel = PickleChannel(channel)
-        config = channel.receive()
-        assert py.test.config == config 
-    """)
-    channel = PickleChannel(channel)
-    config = testdir.parseconfig()
-    channel.send(config)
-    channel.waitclose() # this will potentially raise 
-    gw.exit()

testing/test_plugin.py

@@ -1,11 +1,10 @@
 import py
-
 import execnet
-from xdist.nodemanage import NodeManager
+from xdist.slavemanage import NodeManager
 
 def test_dist_incompatibility_messages(testdir):
-    Error = py.test.config.Error
-    py.test.raises(Error, "testdir.parseconfigure('--pdb', '--looponfail')")
+    result = testdir.runpytest("--pdb", "--looponfail")
+    assert result.ret != 0
     result = testdir.runpytest("--pdb", "-n", "3")
     assert result.ret != 0
     assert "incompatible" in result.stderr.str()
@@ -14,10 +13,13 @@ def test_dist_incompatibility_messages(testdir):
     assert "incompatible" in result.stderr.str()
 
 def test_dist_options(testdir):
+    from xdist.plugin import check_options
     config = testdir.parseconfigure("-n 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"
 
 class TestDistOptions:
@@ -39,22 +41,29 @@ class TestDistOptions:
     def test_getrsyncdirs(self, testdir):
         config = testdir.parseconfigure('--rsyncdir=' + str(testdir.tmpdir))
         nm = NodeManager(config, specs=[execnet.XSpec("popen")])
-        roots = nm._getrsyncdirs()
-        assert len(roots) == 1 + 2 # pylib + xdist
-        assert testdir.tmpdir in roots
+        assert not nm._getrsyncdirs()
+        nm = NodeManager(config, specs=[execnet.XSpec("popen//chdir=qwe")])
+        assert nm.roots
+        assert testdir.tmpdir in nm.roots
+
+    def test_getrsyncignore(self, testdir):
+        config = testdir.parseconfigure('--rsyncignore=fo*')
+        nm = NodeManager(config, specs=[execnet.XSpec("popen//chdir=qwe")])
+        assert 'fo*' in nm.rsyncoptions['ignores']
 
     def test_getrsyncdirs_with_conftest(self, testdir):
         p = py.path.local()
         for bn in 'x y z'.split():
             p.mkdir(bn)
-        testdir.makeconftest("""
-            rsyncdirs= 'x', 
+        testdir.makeini("""
+            [pytest]
+            rsyncdirs= x
         """)
         config = testdir.parseconfigure(
               testdir.tmpdir, '--rsyncdir=y', '--rsyncdir=z')
-        nm = NodeManager(config, specs=[execnet.XSpec("popen")])
+        nm = NodeManager(config, specs=[execnet.XSpec("popen//chdir=xyz")])
         roots = nm._getrsyncdirs()
-        assert len(roots) == 3 + 2 # pylib + xdist
+        #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

testing/test_remote.py

@@ -1,151 +1,248 @@
 import py
-py.test.importorskip("execnet")
-from xdist.remote import LooponfailingSession, LoopState, RemoteControl 
+from xdist.slavemanage import SlaveController, unserialize_report
+from xdist.remote import serialize_report
+import execnet
+queue = py.builtin._tryimport("queue", "Queue")
+import marshal
 
-class TestRemoteControl:
-    def test_nofailures(self, testdir):
-        item = testdir.getitem("def test_func(): pass\n")
-        control = RemoteControl(item.config)
-        control.setup()
-        failures = control.runsession()
-        assert not failures
+WAIT_TIMEOUT = 10.0
 
-    def test_failures_somewhere(self, testdir):
-        item = testdir.getitem("def test_func(): assert 0\n")
-        control = RemoteControl(item.config)
-        control.setup()
-        failures = control.runsession()
-        assert failures 
-        control.setup()
-        item.fspath.write("def test_func(): assert 1\n")
-        pyc = item.fspath.new(ext=".pyc")
-        if pyc.check():
-            pyc.remove()
-        failures = control.runsession(failures)
-        assert not failures
+def check_marshallable(d):
+    try:
+        marshal.dumps(d)
+    except ValueError:
+        py.std.pprint.pprint(d)
+        raise ValueError("not marshallable")
 
-    def test_failure_change(self, testdir):
-        modcol = testdir.getitem("""
+class EventCall:
+    def __init__(self, eventcall):
+        self.name, self.kwargs = eventcall
+
+    def __str__(self):
+        return "<EventCall %s(**%s)>" %(self.name, self.kwargs)
+
+class SlaveSetup:
+    use_callback = False
+
+    def __init__(self, request):
+        self.testdir = request.getfuncargvalue("testdir")
+        self.request = request
+        self.events = queue.Queue()
+
+    def setup(self, ):
+        self.testdir.chdir()
+        #import os ; os.environ['EXECNET_DEBUG'] = "2"
+        self.gateway = execnet.makegateway()
+        self.config = config = self.testdir.parseconfigure()
+        putevent = self.use_callback and self.events.put or None
+        self.slp = SlaveController(None, self.gateway, config, putevent)
+        self.request.addfinalizer(self.slp.ensure_teardown)
+        self.slp.setup()
+
+    def popevent(self, name=None):
+        while 1:
+            if self.use_callback:
+                data = self.events.get(timeout=WAIT_TIMEOUT)
+            else:
+                data = self.slp.channel.receive(timeout=WAIT_TIMEOUT)
+            ev = EventCall(data)
+            if name is None or ev.name == name:
+                return ev
+            print("skipping %s" % (ev,))
+
+    def sendcommand(self, name, **kwargs):
+        self.slp.sendcommand(name, **kwargs)
+
+def pytest_funcarg__slave(request):
+    return SlaveSetup(request)
+
+def test_remoteinitconfig(testdir):
+    from xdist.remote import remote_initconfig
+    config1 = testdir.parseconfig()
+    config2 = remote_initconfig(config1.option.__dict__, config1.args)
+    assert config2.option.__dict__ == config1.option.__dict__
+    assert config2.pluginmanager.getplugin("terminal") in (-1, None)
+
+class TestReportSerialization:
+    def test_itemreport_outcomes(self, testdir):
+        reprec = testdir.inline_runsource("""
+            import py
+            def test_pass(): pass
+            def test_fail(): 0/0
+            @py.test.mark.skipif("True")
+            def test_skip(): pass
+            def test_skip_imperative():
+                py.test.skip("hello")
+            @py.test.mark.xfail("True")
+            def test_xfail(): 0/0
+            def test_xfail_imperative():
+                py.test.xfail("hello")
+        """)
+        reports = reprec.getreports("pytest_runtest_logreport")
+        assert len(reports) == 17 # with setup/teardown "passed" reports
+        for rep in reports:
+            d = serialize_report(rep)
+            check_marshallable(d)
+            newrep = unserialize_report("testreport", d)
+            assert newrep.passed == rep.passed
+            assert newrep.failed == rep.failed
+            assert newrep.skipped == rep.skipped
+            if newrep.skipped and not hasattr(newrep, "wasxfail"):
+                assert len(newrep.longrepr) == 3
+            assert newrep.outcome == rep.outcome
+            assert newrep.when == rep.when
+            assert newrep.keywords == rep.keywords
+            if rep.failed:
+                assert newrep.longrepr == str(rep.longrepr)
+
+    def test_collectreport_passed(self, testdir):
+        reprec = testdir.inline_runsource("def test_func(): pass")
+        reports = reprec.getreports("pytest_collectreport")
+        for rep in reports:
+            d = serialize_report(rep)
+            check_marshallable(d)
+            newrep = unserialize_report("collectreport", d)
+            assert newrep.passed == rep.passed
+            assert newrep.failed == rep.failed
+            assert newrep.skipped == rep.skipped
+
+    def test_collectreport_fail(self, testdir):
+        reprec = testdir.inline_runsource("qwe abc")
+        reports = reprec.getreports("pytest_collectreport")
+        assert reports
+        for rep in reports:
+            d = serialize_report(rep)
+            check_marshallable(d)
+            newrep = unserialize_report("collectreport", d)
+            assert newrep.passed == rep.passed
+            assert newrep.failed == rep.failed
+            assert newrep.skipped == rep.skipped
+            if rep.failed:
+                assert newrep.longrepr == str(rep.longrepr)
+
+    def test_extended_report_deserialization(self, testdir):
+        reprec = testdir.inline_runsource("qwe abc")
+        reports = reprec.getreports("pytest_collectreport")
+        assert reports
+        for rep in reports:
+            rep.extra = True
+            d = serialize_report(rep)
+            check_marshallable(d)
+            newrep = unserialize_report("collectreport", d)
+            assert newrep.extra
+            assert newrep.passed == rep.passed
+            assert newrep.failed == rep.failed
+            assert newrep.skipped == rep.skipped
+            if rep.failed:
+                assert newrep.longrepr == str(rep.longrepr)
+
+
+class TestSlaveInteractor:
+    def test_basic_collect_and_runtests(self, slave):
+        slave.testdir.makepyfile("""
             def test_func():
-                assert 0
+                pass
         """)
-        control = RemoteControl(modcol.config)
-        control.setup()
-        failures = control.runsession()
-        assert failures 
-        control.setup()
-        modcol.fspath.write(py.code.Source("""
+        slave.setup()
+        ev = slave.popevent()
+        assert ev.name == "slaveready"
+        ev = slave.popevent()
+        assert ev.name == "collectionstart"
+        assert not ev.kwargs
+        ev = slave.popevent("collectionfinish")
+        assert ev.kwargs['topdir'] == slave.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")
+        assert ev.kwargs["nodeid"].endswith("test_func")
+        assert len(ev.kwargs["location"]) == 3
+        ev = slave.popevent("testreport") # setup
+        ev = slave.popevent("testreport")
+        assert ev.name == "testreport"
+        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
+
+    def test_remote_collect_skip(self, slave):
+        slave.testdir.makepyfile("""
+            import py
+            py.test.skip("hello")
+        """)
+        slave.setup()
+        ev = slave.popevent("collectionstart")
+        assert not ev.kwargs
+        ev = slave.popevent()
+        assert ev.name == "collectreport"
+        ev = slave.popevent()
+        assert ev.name == "collectreport"
+        rep = unserialize_report(ev.name, ev.kwargs['data'])
+        assert rep.skipped
+        ev = slave.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")
+        assert not ev.kwargs
+        ev = slave.popevent()
+        assert ev.name == "collectreport"
+        ev = slave.popevent()
+        assert ev.name == "collectreport"
+        rep = unserialize_report(ev.name, ev.kwargs['data'])
+        assert rep.failed
+        ev = slave.popevent("collectionfinish")
+        assert not ev.kwargs['ids']
+
+    def test_runtests_all(self, slave):
+        slave.testdir.makepyfile("""
+            def test_func(): pass
+            def test_func2(): pass
+        """)
+        slave.setup()
+        ev = slave.popevent()
+        assert ev.name == "slaveready"
+        ev = slave.popevent()
+        assert ev.name == "collectionstart"
+        assert not ev.kwargs
+        ev = slave.popevent("collectionfinish")
+        ids = ev.kwargs['ids']
+        assert len(ids) == 2
+        slave.sendcommand("runtests_all", )
+        slave.sendcommand("shutdown", )
+        for func in "::test_func", "::test_func2":
+            for i in range(3):  # setup/call/teardown
+                ev = slave.popevent("testreport")
+                assert ev.name == "testreport"
+                rep = unserialize_report(ev.name, ev.kwargs['data'])
+                assert rep.nodeid.endswith(func)
+        ev = slave.popevent("slavefinished")
+        assert 'slaveoutput' in ev.kwargs
+
+    def test_happy_run_events_converted(self, testdir, slave):
+        py.test.xfail("implement a simple test for event production")
+        assert not slave.use_callback
+        slave.testdir.makepyfile("""
             def test_func():
-                assert 1
-            def test_new():
-                assert 0
-        """))
-        pyc = modcol.fspath.new(ext=".pyc")
-        if pyc.check():
-            pyc.remove()
-        failures = control.runsession(failures)
-        assert not failures
-        control.setup()
-        failures = control.runsession()
-        assert failures
-        assert str(failures).find("test_new") != -1
-
-class TestLooponFailing:
-    def test_looponfail_from_fail_to_ok(self, testdir):
-        modcol = testdir.getmodulecol("""
-            def test_one():
-                x = 0
-                assert x == 1
-            def test_two():
-                assert 1
+                pass
         """)
-        session = LooponfailingSession(modcol.config)
-        loopstate = LoopState()
-        session.remotecontrol.setup()
-        session.loop_once(loopstate)
-        assert len(loopstate.colitems) == 1
- 
-        modcol.fspath.write(py.code.Source("""
-            def test_one():
-                x = 15
-                assert x == 15
-            def test_two():
-                assert 1
-        """))
-        assert session.statrecorder.check()
-        session.loop_once(loopstate)
-        assert not loopstate.colitems 
-
-    def test_looponfail_from_one_to_two_tests(self, testdir):
-        modcol = testdir.getmodulecol("""
-            def test_one():
-                assert 0
-        """)
-        session = LooponfailingSession(modcol.config)
-        loopstate = LoopState()
-        session.remotecontrol.setup()
-        loopstate.colitems = []
-        session.loop_once(loopstate)
-        assert len(loopstate.colitems) == 1
-
-        modcol.fspath.write(py.code.Source("""
-            def test_one():
-                assert 1 # passes now
-            def test_two():
-                assert 0 # new and fails
-        """))
-        assert session.statrecorder.check()
-        session.loop_once(loopstate)
-        assert len(loopstate.colitems) == 0
-
-        session.loop_once(loopstate)
-        assert len(loopstate.colitems) == 1
-
-    def test_looponfail_removed_test(self, testdir):
-        modcol = testdir.getmodulecol("""
-            def test_one():
-                assert 0
-            def test_two():
-                assert 0
-        """)
-        session = LooponfailingSession(modcol.config)
-        loopstate = LoopState()
-        session.remotecontrol.setup()
-        loopstate.colitems = []
-        session.loop_once(loopstate)
-        assert len(loopstate.colitems) == 2
-
-        modcol.fspath.write(py.code.Source("""
-            def test_xxx(): # renamed test
-                assert 0 
-            def test_two():
-                assert 1 # pass now
-        """))
-        assert session.statrecorder.check()
-        session.loop_once(loopstate)
-        assert len(loopstate.colitems) == 0
-
-        session.loop_once(loopstate)
-        assert len(loopstate.colitems) == 1
-
-
-    def test_looponfail_functional_fail_to_ok(self, testdir):
-        p = testdir.makepyfile("""
-            def test_one():
-                x = 0
-                assert x == 1
-        """)
-        child = testdir.spawn_pytest("-f %s" % p)
-        child.expect("def test_one")
-        child.expect("x == 1")
-        child.expect("1 failed")
-        child.expect("### LOOPONFAILING ####")
-        child.expect("waiting for changes")
-        p.write(py.code.Source("""
-            def test_one():
-                x = 1
-                assert x == 1
-        """))
-        child.expect(".*1 passed.*")
-        child.kill(15)
+        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"),
+        ])
 

testing/test_slavemanage.py

@@ -0,0 +1,240 @@
+import py
+import pytest
+import execnet
+from _pytest.pytester import HookRecorder
+from xdist import slavemanage, newhooks
+from xdist.slavemanage import HostRSync, NodeManager
+
+pytest_plugins = "pytester"
+
+def pytest_funcarg__hookrecorder(request, config):
+    hookrecorder = HookRecorder(config.pluginmanager)
+    if hasattr(hookrecorder, "start_recording"):
+        hookrecorder.start_recording(newhooks)
+    request.addfinalizer(hookrecorder.finish_recording)
+    return hookrecorder
+
+def pytest_funcarg__config(testdir):
+    return testdir.parseconfig()
+
+def pytest_funcarg__mysetup(tmpdir):
+    class mysetup:
+        source = tmpdir.mkdir("source")
+        dest = tmpdir.mkdir("dest")
+    return mysetup()
+
+@pytest.fixture
+def slavecontroller(monkeypatch):
+    class MockController(object):
+        def __init__(self, *args): pass
+        def setup(self): pass
+    monkeypatch.setattr(slavemanage, 'SlaveController', MockController)
+    return MockController
+
+class TestNodeManagerPopen:
+    def test_popen_no_default_chdir(self, config):
+        gm = NodeManager(config, ["popen"])
+        assert gm.specs[0].chdir is None
+
+    def test_default_chdir(self, config):
+        l = ["ssh=noco", "socket=xyz"]
+        for spec in NodeManager(config, l).specs:
+            assert spec.chdir == "pyexecnetcache"
+        for spec in NodeManager(config, l, defaultchdir="abc").specs:
+            assert spec.chdir == "abc"
+
+    def test_popen_makegateway_events(self, config, hookrecorder, slavecontroller):
+        hm = NodeManager(config, ["popen"] * 2)
+        hm.setup_nodes(None)
+        call = hookrecorder.popcall("pytest_xdist_setupnodes")
+        assert len(call.specs) == 2
+
+        call = hookrecorder.popcall("pytest_xdist_newgateway")
+        assert call.gateway.spec == execnet.XSpec("popen")
+        assert call.gateway.id == "gw0"
+        call = hookrecorder.popcall("pytest_xdist_newgateway")
+        assert call.gateway.id == "gw1"
+        assert len(hm.group) == 2
+        hm.teardown_nodes()
+        assert not len(hm.group)
+
+    def test_popens_rsync(self, config, mysetup, slavecontroller):
+        source = mysetup.source
+        hm = NodeManager(config, ["popen"] * 2)
+        hm.setup_nodes(None)
+        assert len(hm.group) == 2
+        for gw in hm.group:
+            class pseudoexec:
+                args = []
+                def __init__(self, *args):
+                    self.args.extend(args)
+                def waitclose(self):
+                    pass
+            gw.remote_exec = pseudoexec
+        l = []
+        for gw in hm.group:
+            hm.rsync(gw, source, notify=lambda *args: l.append(args))
+        assert not l
+        hm.teardown_nodes()
+        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):
+        source, dest = mysetup.source, mysetup.dest
+        hm = NodeManager(config, ["popen//chdir=%s" % dest] * 1)
+        hm.setup_nodes(None)
+        source.ensure("dir1", "dir2", "hello")
+        l = []
+        for gw in hm.group:
+            hm.rsync(gw, source, notify=lambda *args: l.append(args))
+        assert len(l) == 1
+        assert l[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()
+
+    def test_rsync_same_popen_twice(self, config, mysetup,
+                                    hookrecorder, slavecontroller):
+        source, dest = mysetup.source, mysetup.dest
+        hm = NodeManager(config, ["popen//chdir=%s" % dest] * 2)
+        hm.roots = []
+        hm.setup_nodes(None)
+        source.ensure("dir1", "dir2", "hello")
+        gw = hm.group[0]
+        hm.rsync(gw, source)
+        call = hookrecorder.popcall("pytest_xdist_rsyncstart")
+        assert call.source == source
+        assert len(call.gateways) == 1
+        assert call.gateways[0] in hm.group
+        call = hookrecorder.popcall("pytest_xdist_rsyncfinish")
+
+class TestHRSync:
+    def test_hrsync_filter(self, mysetup):
+        source, _ = mysetup.source, mysetup.dest  # noqa
+        source.ensure("dir", "file.txt")
+        source.ensure(".svn", "entries")
+        source.ensure(".somedotfile", "moreentries")
+        source.ensure("somedir", "editfile~")
+        syncer = HostRSync(source, ignores=NodeManager.DEFAULT_IGNORES)
+        l = list(source.visit(rec=syncer.filter,
+                                   fil=syncer.filter))
+        assert len(l) == 3
+        basenames = [x.basename for x in l]
+        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
+        gw = execnet.makegateway("popen//chdir=%s" % dest)
+        finished = []
+        rsync = HostRSync(source)
+        rsync.add_target_host(gw, finished=lambda: finished.append(1))
+        source.join("hello.py").write("world")
+        rsync.send()
+        gw.exit()
+        assert dest.join(source.basename, "hello.py").check()
+        assert len(finished) == 1
+
+
+class TestNodeManager:
+    @py.test.mark.xfail(run=False)
+    def test_rsync_roots_no_roots(self, testdir, mysetup):
+        mysetup.source.ensure("dir1", "file1").write("hello")
+        config = testdir.parseconfig(mysetup.source)
+        nodemanager = NodeManager(config, ["popen//chdir=%s" % mysetup.dest])
+        #assert nodemanager.config.topdir == source == config.topdir
+        nodemanager.makegateways()
+        nodemanager.rsync_roots()
+        p, = nodemanager.gwmanager.multi_exec(
+            "import os ; channel.send(os.getcwd())").receive_each()
+        p = py.path.local(p)
+        py.builtin.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):
+        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.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()
+            nodemanager.teardown_nodes()
+
+    def test_init_rsync_roots(self, testdir, mysetup, slavecontroller):
+        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("""
+            [pytest]
+            rsyncdirs=dir1/dir2
+        """))
+        config = testdir.parseconfig(source)
+        nodemanager = NodeManager(config, ["popen//chdir=%s" % dest])
+        nodemanager.setup_nodes(None)  # calls .rsync_roots()
+        assert dest.join("dir2").check()
+        assert not dest.join("dir1").check()
+        assert not dest.join("bogus").check()
+
+    def test_rsyncignore(self, testdir, mysetup, slavecontroller):
+        source, dest = mysetup.source, mysetup.dest
+        dir2 = source.ensure("dir1", "dir2", dir=1)
+        source.ensure("dir5", "dir6", "bogus")
+        source.ensure("dir5", "file")
+        dir2.ensure("hello")
+        source.ensure("foo", "bar")
+        source.ensure("bar", "foo")
+        source.join("tox.ini").write(py.std.textwrap.dedent("""
+            [pytest]
+            rsyncdirs = dir1 dir5
+            rsyncignore = dir1/dir2 dir5/dir6 foo*
+        """))
+        config = testdir.parseconfig(source)
+        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()
+
+    def test_optimise_popen(self, testdir, mysetup, slavecontroller):
+        source = mysetup.source
+        specs = ["popen"] * 3
+        source.join("conftest.py").write("rsyncdirs = ['a']")
+        source.ensure('a', dir=1)
+        config = testdir.parseconfig(source)
+        nodemanager = NodeManager(config, specs)
+        nodemanager.setup_nodes(None)  # calls .rysnc_roots()
+        for gwspec in nodemanager.specs:
+            assert gwspec._samefilesystem()
+            assert not gwspec.chdir
+
+    def test_ssh_setup_nodes(self, specssh, testdir):
+        testdir.makepyfile(__init__="", test_x="""
+            def test_one():
+                pass
+        """)
+        reprec = testdir.inline_run("-d", "--rsyncdir=%s" % testdir.tmpdir,
+                                    "--tx", specssh, testdir.tmpdir)
+        rep, = reprec.getreports("pytest_runtest_logreport")
+        assert rep.passed

testing/test_txnode.py

@@ -1,148 +0,0 @@
-
-import py
-import execnet
-from xdist.txnode import TXNode
-queue = py.builtin._tryimport("queue", "Queue")
-Queue = queue.Queue
-
-class EventQueue:
-    def __init__(self, registry, queue=None):
-        if queue is None:
-            queue = Queue()
-        self.queue = queue
-        registry.register(self)
-
-    def geteventargs(self, eventname, timeout=2.0):
-        events = []
-        while 1:
-            try:
-                eventcall = self.queue.get(timeout=timeout)
-            except queue.Empty:
-                #print "node channel", self.node.channel
-                #print "remoteerror", self.node.channel._getremoteerror()
-                py.builtin.print_("seen events", events)
-                raise IOError("did not see %r events" % (eventname))
-            else:
-                name, args, kwargs = eventcall 
-                assert isinstance(name, str)
-                if name == eventname:
-                    if args:
-                        return args
-                    return kwargs
-                events.append(name)
-                if name == "pytest_internalerror":
-                    py.builtin.print_(str(kwargs["excrepr"]))
-
-class MySetup:
-    def __init__(self, request):
-        self.id = 0
-        self.request = request
-
-    def geteventargs(self, eventname, timeout=2.0):
-        eq = EventQueue(self.config.pluginmanager, self.queue)
-        return eq.geteventargs(eventname, timeout=timeout)
-
-    def makenode(self, config=None):
-        if config is None:
-            testdir = self.request.getfuncargvalue("testdir")
-            config = testdir.reparseconfig([])
-        self.config = config
-        self.queue = Queue()
-        self.xspec = execnet.XSpec("popen")
-        self.gateway = execnet.makegateway(self.xspec)
-        self.id += 1
-        self.gateway.id = str(self.id)
-        self.node = TXNode(self.gateway, self.config, putevent=self.queue.put)
-        assert not self.node.channel.isclosed()
-        return self.node 
-
-    def xfinalize(self):
-        if hasattr(self, 'node'):
-            gw = self.node.gateway
-            py.builtin.print_("exiting:", gw)
-            gw.exit()
-
-def pytest_funcarg__mysetup(request):
-    mysetup = MySetup(request)
-    #pyfuncitem.addfinalizer(mysetup.finalize)
-    return mysetup
-
-def test_node_hash_equality(mysetup):
-    node = mysetup.makenode()
-    node2 = mysetup.makenode()
-    assert node != node2
-    assert node == node
-    assert not (node != node)
-
-class TestMasterSlaveConnection:
-    def test_crash_invalid_item(self, mysetup):
-        node = mysetup.makenode()
-        node.send(123) # invalid item 
-        kwargs = mysetup.geteventargs("pytest_testnodedown")
-        assert kwargs['node'] is node 
-        assert isinstance(kwargs['error'], execnet.RemoteError)
-
-    def test_crash_killed(self, testdir, mysetup):
-        if not hasattr(py.std.os, 'kill'):
-            py.test.skip("no os.kill")
-        item = testdir.getitem("""
-            def test_func():
-                import os
-                os.kill(os.getpid(), 9)
-        """)
-        node = mysetup.makenode(item.config)
-        node.send(item) 
-        kwargs = mysetup.geteventargs("pytest_testnodedown")
-        assert kwargs['node'] is node 
-        assert "Not properly terminated" in str(kwargs['error'])
-
-    def test_node_down(self, mysetup):
-        node = mysetup.makenode()
-        node.shutdown()
-        kwargs = mysetup.geteventargs("pytest_testnodedown")
-        assert kwargs['node'] is node 
-        assert not kwargs['error']
-        node.callback(node.ENDMARK)
-        excinfo = py.test.raises(IOError, 
-            "mysetup.geteventargs('testnodedown', timeout=0.01)")
-
-    def test_send_on_closed_channel(self, testdir, mysetup):
-        item = testdir.getitem("def test_func(): pass")
-        node = mysetup.makenode(item.config)
-        node.channel.close()
-        py.test.raises(IOError, "node.send(item)")
-        #ev = self.getcalls(pytest_internalerror)
-        #assert ev.excinfo.errisinstance(IOError)
-
-    def test_send_one(self, testdir, mysetup):
-        item = testdir.getitem("def test_func(): pass")
-        node = mysetup.makenode(item.config)
-        node.send(item)
-        kwargs = mysetup.geteventargs("pytest_runtest_logreport")
-        rep = kwargs['report'] 
-        assert rep.passed 
-        py.builtin.print_(rep)
-        assert rep.item == item
-
-    def test_send_some(self, testdir, mysetup):
-        items = testdir.getitems("""
-            def test_pass(): 
-                pass
-            def test_fail():
-                assert 0
-            def test_skip():
-                import py
-                py.test.skip("x")
-        """)
-        node = mysetup.makenode(items[0].config)
-        for item in items:
-            node.send(item)
-        for outcome in "passed failed skipped".split():
-            kwargs = mysetup.geteventargs("pytest_runtest_logreport")
-            report = kwargs['report']
-            assert getattr(report, outcome) 
-
-        node.sendlist(items)
-        for outcome in "passed failed skipped".split():
-            rep = mysetup.geteventargs("pytest_runtest_logreport")['report']
-            assert getattr(rep, outcome) 

testing/test_util.py

@@ -1,61 +0,0 @@
-import py
-from xdist.util import StatRecorder
-
-def test_filechange(tmpdir):
-    tmp = tmpdir
-    hello = tmp.ensure("hello.py")
-    sd = StatRecorder([tmp])
-    changed = sd.check()
-    assert not changed
-
-    hello.write("world")
-    changed = sd.check()
-    assert changed
-
-    tmp.ensure("new.py")
-    changed = sd.check()
-    assert changed
-    
-    tmp.join("new.py").remove()
-    changed = sd.check()
-    assert changed
-
-    tmp.join("a", "b", "c.py").ensure()
-    changed = sd.check()
-    assert changed
-
-    tmp.join("a", "c.txt").ensure()
-    changed = sd.check()
-    assert changed
-    changed = sd.check()
-    assert not changed
-
-    tmp.join("a").remove()
-    changed = sd.check()
-    assert changed
-
-def test_pycremoval(tmpdir):
-    tmp = tmpdir
-    hello = tmp.ensure("hello.py")
-    sd = StatRecorder([tmp])
-    changed = sd.check()
-    assert not changed
-
-    pycfile = hello + "c"
-    pycfile.ensure()
-    changed = sd.check()
-    assert not changed 
-
-    hello.write("world")
-    changed = sd.check()
-    assert not pycfile.check()
-    
-
-def test_waitonchange(tmpdir, monkeypatch):
-    tmp = tmpdir
-    sd = StatRecorder([tmp])
-
-    l = [True, False]
-    monkeypatch.setattr(StatRecorder, 'check', lambda self: l.pop())
-    sd.waitonchange(checkinterval=0.2)
-    assert not l

tox.ini

@@ -0,0 +1,43 @@
+[tox]
+envlist=py26,py33,py34,py27,py27-pexpect,py33-pexpect,py26-old,py33-old,flakes
+
+[testenv]
+changedir=testing
+deps=pytest>=2.5.1
+commands= py.test {posargs}
+
+[testenv:py27-pexpect]
+deps={[testenv]deps}
+    pexpect
+[testenv:py33-pexpect]
+deps={[testenv]deps}
+    pexpect
+
+[testenv:flakes]
+changedir=
+deps = pytest-flakes>=0.2
+commands = py.test --flakes -m flakes testing xdist
+
+[testenv:py26-old]
+basepython = python2.6
+deps=
+    pytest==2.5.2
+    pycmd
+
+commands= 
+    py.cleanup -a
+    py.test {posargs}
+
+[testenv:py33-old]
+basepython = python3.3
+deps=
+    pytest==2.5.2
+    pycmd
+
+commands= 
+    py.cleanup -a
+    py.test {posargs}
+
+[pytest]
+addopts = -rsfxX
+;; hello

xdist/__init__.py

@@ -1,3 +1,2 @@
 #
-__version__ = "1.1"
-
+__version__ = '1.12'

xdist/gwmanage.py

@@ -1,100 +0,0 @@
-"""
-    instantiating, managing and rsyncing to test hosts
-"""
-
-import py
-import sys, os.path
-import execnet
-from execnet.gateway_base import RemoteError
-
-class GatewayManager:
-    EXIT_TIMEOUT = 10
-    RemoteError = RemoteError
-    def __init__(self, specs, hook, defaultchdir="pyexecnetcache"):
-        self.specs = []
-        self.hook = hook
-        self.group = execnet.Group()
-        for spec in specs:
-            if not isinstance(spec, execnet.XSpec):
-                spec = execnet.XSpec(spec)
-            if not spec.chdir and not spec.popen:
-                spec.chdir = defaultchdir
-            self.specs.append(spec)
-
-    def makegateways(self):
-        assert not list(self.group)
-        for spec in self.specs:
-            gw = self.group.makegateway(spec)
-            self.hook.pytest_gwmanage_newgateway(
-                gateway=gw, platinfo=gw._rinfo())
-
-    def rsync(self, source, notify=None, verbose=False, ignores=None):
-        """ perform rsync to all remote hosts. 
-        """ 
-        rsync = HostRSync(source, verbose=verbose, ignores=ignores)
-        seen = py.builtin.set()
-        gateways = []
-        for gateway in self.group:
-            spec = gateway.spec
-            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("""
-                    import sys ; sys.path.insert(0, %r)
-                """ % os.path.dirname(str(source))).waitclose()
-                continue
-            if spec not in seen:
-                def finished():
-                    if notify:
-                        notify("rsyncrootready", spec, source)
-                rsync.add_target_host(gateway, finished=finished)
-                seen.add(spec)
-                gateways.append(gateway)
-        if seen:
-            self.hook.pytest_gwmanage_rsyncstart(
-                source=source, 
-                gateways=gateways, 
-            )
-            rsync.send()
-            self.hook.pytest_gwmanage_rsyncfinish(
-                source=source, 
-                gateways=gateways, 
-            )
-
-    def exit(self):
-        self.group.terminate(self.EXIT_TIMEOUT)
-
-class HostRSync(execnet.RSync):
-    """ RSyncer that filters out common files 
-    """
-    def __init__(self, sourcedir, *args, **kwargs):
-        self._synced = {}
-        ignores= None
-        if 'ignores' in kwargs:
-            ignores = kwargs.pop('ignores')
-        self._ignores = ignores or []
-        super(HostRSync, self).__init__(sourcedir=sourcedir, **kwargs)
-
-    def filter(self, path):
-        path = py.path.local(path)
-        if not path.ext in ('.pyc', '.pyo'):
-            if not path.basename.endswith('~'): 
-                if path.check(dotfile=0):
-                    for x in self._ignores:
-                        if path == x:
-                            break
-                    else:
-                        return True
-
-    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,)
-
-    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))

xdist/looponfail.py

@@ -0,0 +1,230 @@
+"""
+    Implement -f aka looponfailing for py.test.
+
+    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.
+"""
+
+import py, pytest
+import sys
+import execnet
+
+def looponfail_main(config):
+    remotecontrol = RemoteControl(config)
+    rootdirs = config.getini("looponfailroots")
+    statrecorder = StatRecorder(rootdirs)
+    try:
+        while 1:
+            remotecontrol.loop_once()
+            if not remotecontrol.failures and remotecontrol.wasfailing:
+                continue # the last failures passed, let's immediately rerun all
+            repr_pytest_looponfailinfo(
+                failreports=remotecontrol.failures,
+                rootdirs=rootdirs)
+            statrecorder.waitonchange(checkinterval=2.0)
+    except KeyboardInterrupt:
+        print()
+
+class RemoteControl(object):
+    def __init__(self, config):
+        self.config = config
+        self.failures = []
+
+    def trace(self, *args):
+        if self.config.option.debug:
+            msg = " ".join([str(x) for x in args])
+            py.builtin.print_("RemoteControl:", msg)
+
+    def initgateway(self):
+        return execnet.makegateway("popen")
+
+    def setup(self, out=None):
+        if out is None:
+            out = py.io.TerminalWriter()
+        if hasattr(self, 'gateway'):
+            raise ValueError("already have gateway %r" % self.gateway)
+        self.trace("setting up slave session")
+        self.gateway = self.initgateway()
+        self.channel = channel = self.gateway.remote_exec(init_slave_session,
+            args=self.config.args,
+            option_dict=vars(self.config.option),
+        )
+        remote_outchannel = channel.receive()
+        def write(s):
+            out._file.write(s)
+            out._file.flush()
+        remote_outchannel.setcallback(write)
+
+    def ensure_teardown(self):
+        if hasattr(self, 'channel'):
+            if not self.channel.isclosed():
+                self.trace("closing", self.channel)
+                self.channel.close()
+            del self.channel
+        if hasattr(self, 'gateway'):
+            self.trace("exiting", self.gateway)
+            self.gateway.exit()
+            del self.gateway
+
+    def runsession(self):
+        try:
+            self.trace("sending", self.failures)
+            self.channel.send(self.failures)
+            try:
+                return self.channel.receive()
+            except self.channel.RemoteError:
+                e = sys.exc_info()[1]
+                self.trace("ERROR", e)
+                raise
+        finally:
+            self.ensure_teardown()
+
+    def loop_once(self):
+        self.setup()
+        self.wasfailing = self.failures and len(self.failures)
+        result = self.runsession()
+        failures, reports, collection_failed = result
+        if collection_failed:
+            pass # "Collection failed, keeping previous failure set"
+        else:
+            uniq_failures = []
+            for failure in failures:
+                if failure not in uniq_failures:
+                    uniq_failures.append(failure)
+            self.failures = uniq_failures
+
+def repr_pytest_looponfailinfo(failreports, rootdirs):
+    tr = py.io.TerminalWriter()
+    if failreports:
+        tr.sep("#", "LOOPONFAILING", bold=True)
+        for report in failreports:
+            if report:
+                tr.line(report, red=True)
+    tr.sep("#", "waiting for changes", bold=True)
+    for rootdir in rootdirs:
+        tr.line("### Watching:   %s" %(rootdir,), bold=True)
+
+
+def init_slave_session(channel, args, option_dict):
+    import os, sys
+    outchannel = channel.gateway.newchannel()
+    sys.stdout = sys.stderr = outchannel.makefile('w')
+    channel.send(outchannel)
+    # prune sys.path to not contain relative paths
+    newpaths = []
+    for p in sys.path:
+        if p:
+            if not os.path.isabs(p):
+                p = os.path.abspath(p)
+            newpaths.append(p)
+    sys.path[:] = newpaths
+
+    #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()
+
+class SlaveFailSession:
+    def __init__(self, config, channel):
+        self.config = config
+        self.channel = channel
+        self.recorded_failures = []
+        self.collection_failed = False
+        config.pluginmanager.register(self)
+        config.option.looponfail = False
+        config.option.usepdb = False
+
+    def DEBUG(self, *args):
+        if self.config.option.debug:
+            print(" ".join(map(str, args)))
+
+    def pytest_collection(self, session):
+        self.session = session
+        self.trails = self.current_command
+        hook = self.session.ihook
+        try:
+            items = session.perform_collect(self.trails or None)
+        except pytest.UsageError:
+            items = session.perform_collect(None)
+        hook.pytest_collection_modifyitems(session=session, config=session.config, items=items)
+        hook.pytest_collection_finish(session=session)
+        return True
+
+    def pytest_runtest_logreport(self, report):
+        if report.failed:
+            self.recorded_failures.append(report)
+
+    def pytest_collectreport(self, report):
+        if report.failed:
+            self.recorded_failures.append(report)
+            self.collection_failed = True
+
+    def main(self):
+        self.DEBUG("SLAVE: received configuration, waiting for command trails")
+        try:
+            command = self.channel.receive()
+        except KeyboardInterrupt:
+            return # in the slave we can't do much about this
+        self.DEBUG("received", command)
+        self.current_command = command
+        self.config.hook.pytest_cmdline_main(config=self.config)
+        trails, failreports = [], []
+        for rep in self.recorded_failures:
+            trails.append(rep.nodeid)
+            loc = rep.longrepr
+            loc = str(getattr(loc, 'reprcrash', loc))
+            failreports.append(loc)
+        self.channel.send((trails, failreports, self.collection_failed))
+
+class StatRecorder:
+    def __init__(self, rootdirlist):
+        self.rootdirlist = rootdirlist
+        self.statcache = {}
+        self.check() # snapshot state
+
+    def fil(self, p):
+        return p.check(file=1, dotfile=0) and p.ext != ".pyc"
+    def rec(self, p):
+        return p.check(dotfile=0)
+
+    def waitonchange(self, checkinterval=1.0):
+        while 1:
+            changed = self.check()
+            if changed:
+                return
+            py.std.time.sleep(checkinterval)
+
+    def check(self, removepycfiles=True):
+        changed = False
+        statcache = self.statcache
+        newstat = {}
+        for rootdir in self.rootdirlist:
+            for path in rootdir.visit(self.fil, self.rec):
+                oldstat = statcache.pop(path, None)
+                try:
+                    newstat[path] = curstat = path.stat()
+                except py.error.ENOENT:
+                    if oldstat:
+                        changed = True
+                else:
+                    if oldstat:
+                       if oldstat.mtime != curstat.mtime or \
+                          oldstat.size != curstat.size:
+                            changed = True
+                            py.builtin.print_("# MODIFIED", path)
+                            if removepycfiles and path.ext == ".py":
+                                pycfile = path + "c"
+                                if pycfile.check():
+                                    pycfile.remove()
+
+                    else:
+                        changed = True
+        if statcache:
+            changed = True
+        self.statcache = newstat
+        return changed
+

xdist/mypickle.py

@@ -1,187 +0,0 @@
-"""
-
-   Pickling support for two processes that want to exchange 
-   *immutable* object instances.  Immutable in the sense 
-   that the receiving side of an object can modify its 
-   copy but when it sends it back the original sending 
-   side will continue to see its unmodified version
-   (and no actual state will go over the wire).
-
-   This module also implements an experimental 
-   execnet pickling channel using this idea. 
-
-"""
-
-import py
-import sys, os, struct
-#debug = open("log-mypickle-%d" % os.getpid(), 'w')
-
-if sys.version_info >= (3,0):
-    makekey = lambda x: x
-    fromkey = lambda x: x 
-    from pickle import _Pickler as Pickler
-    from pickle import _Unpickler as Unpickler
-else:
-    makekey = str
-    fromkey = int
-    from pickle import Pickler, Unpickler
-
-
-class MyPickler(Pickler):
-    """ Pickler with a custom memoize()
-        to take care of unique ID creation. 
-        See the usage in ImmutablePickler
-        XXX we could probably extend Pickler 
-            and Unpickler classes to directly
-            update the other'S memos. 
-    """
-    def __init__(self, file, protocol, uneven):
-        Pickler.__init__(self, file, protocol)
-        self.uneven = uneven
-        
-    def memoize(self, obj):
-        if self.fast:
-            return
-        assert id(obj) not in self.memo
-        memo_len = len(self.memo)
-        key = memo_len * 2 + self.uneven
-        self.write(self.put(key))
-        self.memo[id(obj)] = key, obj
-
-    #if sys.version_info < (3,0):
-    #    def save_string(self, obj, pack=struct.pack):
-    #        obj = unicode(obj)
-    #        self.save_unicode(obj, pack=pack)
-    #    Pickler.dispatch[str] = save_string 
-
-class ImmutablePickler:
-    def __init__(self, uneven, protocol=0):
-        """ ImmutablePicklers are instantiated in Pairs. 
-            The two sides need to create unique IDs
-            while pickling their objects.  This is
-            done by using either even or uneven 
-            numbers, depending on the instantiation
-            parameter.
-        """
-        self._picklememo = {}
-        self._unpicklememo = {}
-        self._protocol = protocol
-        self.uneven = uneven and 1 or 0
-
-    def selfmemoize(self, obj):
-        # this is for feeding objects to ourselfes
-        # which be the case e.g. if you want to pickle 
-        # from a forked process back to the original 
-        f = py.io.BytesIO()
-        pickler = MyPickler(f, self._protocol, uneven=self.uneven)
-        pickler.memo = self._picklememo
-        pickler.memoize(obj)
-        self._updateunpicklememo()
-
-    def dumps(self, obj):
-        f = py.io.BytesIO()
-        pickler = MyPickler(f, self._protocol, uneven=self.uneven)
-        pickler.memo = self._picklememo
-        pickler.dump(obj)
-        if obj is not None:
-            self._updateunpicklememo()
-        #print >>debug, "dumped", obj 
-        #print >>debug, "picklememo", self._picklememo
-        return f.getvalue()
-
-    def loads(self, string):
-        f = py.io.BytesIO(string)
-        unpickler = Unpickler(f)
-        unpickler.memo = self._unpicklememo
-        res = unpickler.load()
-        self._updatepicklememo()
-        #print >>debug, "loaded", res
-        #print >>debug, "unpicklememo", self._unpicklememo
-        return res
-
-    def _updatepicklememo(self):
-        for x, obj in self._unpicklememo.items():
-            self._picklememo[id(obj)] = (fromkey(x), obj)
-
-    def _updateunpicklememo(self):
-        for key,obj in self._picklememo.values():
-            key = makekey(key) 
-            if key in self._unpicklememo:
-                assert self._unpicklememo[key] is obj
-            self._unpicklememo[key] = obj
-
-NO_ENDMARKER_WANTED = object()
-
-class UnpickleError(Exception):
-    """ Problems while unpickling. """
-    def __init__(self, formatted):
-        self.formatted = formatted
-        Exception.__init__(self, formatted)
-    def __str__(self):
-        return self.formatted
-
-class PickleChannel(object):
-    """ PickleChannels wrap execnet channels 
-        and allow to send/receive by using
-        "immutable pickling". 
-    """
-    _unpicklingerror = None
-    def __init__(self, channel):
-        self._channel = channel
-        # we use the fact that each side of a 
-        # gateway connection counts with uneven
-        # or even numbers depending on which 
-        # side it is (for the purpose of creating
-        # unique ids - which is what we need it here for)
-        uneven = channel.gateway._channelfactory.count % 2 
-        self._ipickle = ImmutablePickler(uneven=uneven) 
-        self.RemoteError = channel.RemoteError
-
-    def send(self, obj):
-        pickled_obj = self._ipickle.dumps(obj)
-        self._channel.send(pickled_obj)
-
-    def receive(self):
-        pickled_obj = self._channel.receive()
-        return self._unpickle(pickled_obj)
-
-    def _unpickle(self, pickled_obj):
-        if isinstance(pickled_obj, self._channel.__class__):
-            return pickled_obj
-        return self._ipickle.loads(pickled_obj)
-
-    def _getremoteerror(self):
-        return self._unpicklingerror or self._channel._getremoteerror()
-
-    def close(self):
-        return self._channel.close()
-
-    def isclosed(self):
-        return self._channel.isclosed()
-
-    def waitclose(self, timeout=None):
-        return self._channel.waitclose(timeout=timeout)
-
-    def setcallback(self, callback, endmarker=NO_ENDMARKER_WANTED):
-        if endmarker is NO_ENDMARKER_WANTED:
-            def unpickle_callback(pickled_obj):
-                obj = self._unpickle(pickled_obj)
-                callback(obj)
-            self._channel.setcallback(unpickle_callback)
-            return
-        uniqueendmarker = object()
-        def unpickle_callback(pickled_obj):
-            if pickled_obj is uniqueendmarker:
-                return callback(endmarker)
-            try:
-                obj = self._unpickle(pickled_obj)
-            except KeyboardInterrupt:
-                raise
-            except:
-                excinfo = py.code.ExceptionInfo()
-                formatted = str(excinfo.getrepr(showlocals=True,funcargs=True))
-                self._unpicklingerror = UnpickleError(formatted)
-                callback(endmarker)
-            else:
-                callback(obj)
-        self._channel.setcallback(unpickle_callback, uniqueendmarker)

xdist/newhooks.py

@@ -0,0 +1,21 @@
+
+def pytest_xdist_setupnodes(config, specs):
+    """ called before any remote node is set up. """
+
+def pytest_xdist_newgateway(gateway):
+    """ called on new raw gateway creation. """
+
+def pytest_xdist_rsyncstart(source, gateways):
+    """ called before rsyncing a directory to remote gateways takes place. """
+
+def pytest_xdist_rsyncfinish(source, gateways):
+    """ called after rsyncing a directory to remote gateways takes place. """
+
+def pytest_configure_node(node):
+    """ configure node information before it gets instantiated. """
+
+def pytest_testnodeready(node):
+    """ Test Node is ready to operate. """
+
+def pytest_testnodedown(node, error):
+    """ Test Node is down. """

xdist/nodemanage.py

@@ -1,99 +0,0 @@
-import py
-import sys, os
-import xdist
-from xdist.txnode import TXNode
-from xdist.gwmanage import GatewayManager
-import execnet
-    
-class NodeManager(object):
-    def __init__(self, config, specs=None):
-        self.config = config 
-        if specs is None:
-            specs = self._getxspecs()
-        self.roots = self._getrsyncdirs()
-        self.gwmanager = GatewayManager(specs, config.hook)
-        self._nodesready = py.std.threading.Event()
-
-    def trace(self, msg):
-        self.config.hook.pytest_trace(category="nodemanage", msg=msg)
-
-    def config_getignores(self):
-        return self.config.getconftest_pathlist("rsyncignore")
-
-    def rsync_roots(self):
-        """ make sure that all remote gateways
-            have the same set of roots in their
-            current directory. 
-        """
-        self.makegateways()
-        options = {
-            'ignores': self.config_getignores(), 
-            'verbose': self.config.option.verbose,
-        }
-        if self.roots:
-            # send each rsync root
-            for root in self.roots:
-                self.gwmanager.rsync(root, **options)
-        else: 
-            XXX # do we want to care for situations without explicit rsyncdirs? 
-            # we transfer our topdir as the root
-            self.gwmanager.rsync(self.config.topdir, **options)
-            # and cd into it 
-            self.gwmanager.multi_chdir(self.config.topdir.basename, inplacelocal=False)
-
-    def makegateways(self):
-        # we change to the topdir sot that 
-        # PopenGateways will have their cwd 
-        # such that unpickling configs will 
-        # pick it up as the right topdir 
-        # (for other gateways this chdir is irrelevant)
-        self.trace("making gateways")
-        old = self.config.topdir.chdir()  
-        try:
-            self.gwmanager.makegateways()
-        finally:
-            old.chdir()
-
-    def setup_nodes(self, putevent):
-        self.rsync_roots()
-        self.trace("setting up nodes")
-        for gateway in self.gwmanager.group:
-            node = TXNode(gateway, self.config, putevent)
-            gateway.node = node  # to keep node alive 
-            self.trace("started node %r" % node)
-
-    def teardown_nodes(self):
-        self.gwmanager.exit()
-
-    def _getxspecs(self):
-        config = self.config
-        xspeclist = []
-        for xspec in config.getvalue("tx"):
-            i = xspec.find("*")
-            try:
-                num = int(xspec[:i])
-            except ValueError:
-                xspeclist.append(xspec)
-            else:
-                xspeclist.extend([xspec[i+1:]] * num)
-        if not xspeclist:
-            raise config.Error(
-                "MISSING test execution (tx) nodes: please specify --tx")
-        return [execnet.XSpec(x) for x in xspeclist]
-
-    def _getrsyncdirs(self):
-        config = self.config
-        candidates = [py._pydir] 
-        candidates += [py.path.local(xdist.__file__).dirpath()]
-        candidates += config.option.rsyncdir
-        conftestroots = config.getconftest_pathlist("rsyncdirs")
-        if conftestroots:
-            candidates.extend(conftestroots)
-        roots = []
-        for root in candidates:
-            root = py.path.local(root).realpath()
-            if not root.check():
-                raise config.Error("rsyncdir doesn't exist: %r" %(root,))
-            if root not in roots:
-                roots.append(root)
-        return roots

xdist/plugin.py

@@ -1,147 +1,5 @@
-"""loop on failing tests, distribute test runs to CPUs and hosts.
-
-The `pytest-xdist`_ plugin extends py.test with some unique 
-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 the previously
-  failing tests.  This is repeated until all tests pass after which again
-  a full run is performed. 
-
-* Load-balancing: if you have multiple CPUs or hosts you can use
-  those for a combined test run.  This allows to speed up 
-  development or to use special resources of remote machines.  
-
-* 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 synchronizes your 
-program source code to the remote place.  All test results 
-are reported back and displayed to your local test session.  
-You may specify different Python versions and interpreters.
-
-.. _`pytest-xdist`: http://pypi.python.org/pypi/pytest-xdist
-
-Usage examples
----------------------
-
-Speed up test runs by sending tests to multiple CPUs
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-To send tests to multiple CPUs, type::
-
-    py.test -n NUM
-
-Especially for longer running tests or tests requiring 
-a lot of IO this can lead to considerable speed ups. 
-
-
-Running tests in a Python subprocess 
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-To instantiate a python2.4 sub process and send tests to it, you may type::
-
-    py.test -d --tx popen//python=python2.4
-
-This will start a subprocess which is run with the "python2.4"
-Python interpreter, found in your system binary lookup path. 
-
-If you prefix the --tx option value like this::
-
-    --tx 3*popen//python=python2.4
-
-then three subprocesses would be created and tests
-will be load-balanced across these three processes. 
-
-
-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
-
-This will synchronize your ``mypkg`` package directory 
-to an remote ssh account and then locally collect tests 
-and send them to remote places for execution.  
-
-You can specify multiple ``--rsyncdir`` directories 
-to be sent to the remote side. 
-
-**NOTE:** For py.test 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 ``__init__.py`` file because internally
-py.test references tests as a fully qualified python
-module path.  **You will otherwise get strange errors** 
-during setup of the remote side.
-
-Sending tests to remote Socket Servers
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-Download the single-module `socketserver.py`_ Python program 
-and run it like this::
-
-    python socketserver.py
-
-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
-
-
-.. _`atonce`:
-
-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 
-
-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`_. 
-
-.. _`xspec syntax`: http://codespeak.net/execnet/trunk/basics.html#xspec
-
-.. _`socketserver.py`: http://codespeak.net/svn/py/dist/py/execnet/script/socketserver.py
-
-.. _`execnet`: http://codespeak.net/execnet
-
-Specifying test exec environments in a conftest.py
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-Instead of specifying command line options, you can 
-put options values in a ``conftest.py`` file like this::
-
-    pytest_option_tx = ['ssh=myhost//python=python2.5', 'popen//python=python2.5']
-    pytest_option_dist = True
-
-Any commandline ``--tx`` specifictions  will add to the list of available execution
-environments. 
-
-Specifying "rsync" dirs in a conftest.py
-+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-In your ``mypkg/conftest.py`` you may specify directories to synchronise
-or to exclude::
-
-    rsyncdirs = ['.', '../plugins']
-    rsyncignore = ['_cache']
-
-These directory specifications are relative to the directory
-where the ``conftest.py`` is found.
-
-"""
-
-import sys
 import py
+import pytest
 
 def pytest_addoption(parser):
     group = parser.getgroup("xdist", "distributed and subprocess testing")
@@ -170,10 +28,50 @@ def pytest_addoption(parser):
     group._addoption('-d',
            action="store_true", dest="distload", default=False,
            help="load-balance tests.  shortcut for '--dist=load'")
-    group.addoption('--rsyncdir', action="append", default=[], metavar="dir1", 
+    group.addoption('--rsyncdir', action="append", default=[], metavar="DIR",
            help="add directory for rsyncing to remote tx nodes.")
+    group.addoption('--rsyncignore', action="append", default=[], metavar="GLOB",
+           help="add expression for ignores when rsyncing to remote tx nodes.")
 
+    parser.addini('rsyncdirs', 'list of (relative) paths to be rsynced for'
+         ' remote distributed testing.', type="pathlist")
+    parser.addini('rsyncignore', 'list of (relative) glob-style paths to be ignored '
+         'for rsyncing.', type="pathlist")
+    parser.addini("looponfailroots", type="pathlist",
+        help="directories to check for changes", default=[py.path.local()])
+
+# -------------------------------------------------------------------------
+# distributed testing hooks
+# -------------------------------------------------------------------------
+def pytest_addhooks(pluginmanager):
+    from xdist import newhooks
+    # avoid warnings with pytest-2.8
+    method = getattr(pluginmanager, "add_hookspecs", None)
+    if method is None:
+        method = pluginmanager.addhooks
+    method(newhooks)
+
+# -------------------------------------------------------------------------
+# distributed testing initialization
+# -------------------------------------------------------------------------
+
+def pytest_cmdline_main(config):
+    check_options(config)
+    if config.getoption("looponfail"):
+        from xdist.looponfail import looponfail_main
+        looponfail_main(config)
+        return 2 # looponfail only can get stop with ctrl-C anyway
+
+@pytest.mark.trylast
 def pytest_configure(config):
+    if config.getoption("dist") != "no":
+        from xdist.dsession import DSession
+        session = DSession(config)
+        config.pluginmanager.register(session, "dsession")
+        tr = config.pluginmanager.getplugin("terminalreporter")
+        tr.showfspath = False
+
+def check_options(config):
     if config.option.numprocesses:
         config.option.dist = "load"
         config.option.tx = ['popen'] * int(config.option.numprocesses)
@@ -184,14 +82,11 @@ def pytest_configure(config):
         usepdb = config.option.usepdb  # a core option
         if val("looponfail"):
             if usepdb:
-                raise config.Error("--pdb incompatible with --looponfail.")
-            from xdist.remote import LooponfailingSession
-            config.setsessionclass(LooponfailingSession)
+                raise pytest.UsageError("--pdb incompatible with --looponfail.")
         elif val("dist") != "no":
             if usepdb:
-                raise config.Error("--pdb incompatible with distributing tests.")
-            from xdist.dsession import DSession
-            config.setsessionclass(DSession)
+                raise pytest.UsageError("--pdb incompatible with distributing tests.")
+
 
 def pytest_runtest_protocol(item):
     if item.config.getvalue("boxed"):
@@ -203,25 +98,23 @@ def pytest_runtest_protocol(item):
 def forked_run_report(item):
     # for now, we run setup/teardown in the subprocess
     # XXX optionally allow sharing of setup/teardown
-    from py._plugin.pytest_runner import runtestprotocol
+    from _pytest.runner import runtestprotocol
     EXITSTATUS_TESTEXIT = 4
-    from xdist.mypickle import ImmutablePickler
-    ipickle = ImmutablePickler(uneven=0)
-    ipickle.selfmemoize(item.config)
-    # XXX workaround the issue that 2.6 cannot pickle 
-    # instances of classes defined in global conftest.py files
-    ipickle.selfmemoize(item) 
+    import marshal
+    from xdist.remote import serialize_report
+    from xdist.slavemanage import unserialize_report
     def runforked():
         try:
             reports = runtestprotocol(item, log=False)
         except KeyboardInterrupt:
             py.std.os._exit(EXITSTATUS_TESTEXIT)
-        return ipickle.dumps(reports)
+        return marshal.dumps([serialize_report(x) for x in reports])
 
     ff = py.process.ForkedFunc(runforked)
     result = ff.waitfinish()
     if result.retval is not None:
-        return ipickle.loads(result.retval)
+        report_dumps = marshal.loads(result.retval)
+        return [unserialize_report("testreport", x) for x in report_dumps]
     else:
         if result.exitstatus == EXITSTATUS_TESTEXIT:
             py.test.exit("forked test item %s raised Exit" %(item,))
@@ -229,8 +122,14 @@ def forked_run_report(item):
 
 def report_process_crash(item, result):
     path, lineno = item._getfslineno()
-    info = "%s:%s: running the test CRASHED with signal %d" %(
-            path, lineno, result.signal)
-    from py._plugin.pytest_runner import ItemTestReport
-    return ItemTestReport(item, excinfo=info, when="???")
-
+    info = ("%s:%s: running the test CRASHED with signal %d" %
+            (path, lineno, result.signal))
+    from _pytest import runner
+    call = runner.CallInfo(lambda: 0/0, "???")
+    call.excinfo = info
+    rep = runner.pytest_runtest_makereport(item, call)
+    if result.out:
+        rep.sections.append(("captured stdout", result.out))
+    if result.err:
+        rep.sections.append(("captured stderr", result.err))
+    return rep

xdist/remote.py

@@ -1,177 +1,147 @@
 """
-    LooponfailingSession and Helpers. 
-
-    NOTE that one really has 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 never happen. 
+    This module is executed in remote subprocesses and helps to
+    control a remote testing session and relay back information.
+    It assumes that 'py' is importable and does not have dependencies
+    on the rest of the xdist code.  This means that the xdist-plugin
+    needs not to be installed in remote environments.
 """
-import py
-import sys
-import execnet
-from py._test.session import Session
-from xdist import util
 
-class LooponfailingSession(Session):
-    def __init__(self, config):
-        super(LooponfailingSession, self).__init__(config=config)
-        self.rootdirs = [self.config.topdir] # xxx dist_rsync_roots? 
-        self.statrecorder = util.StatRecorder(self.rootdirs) 
-        self.remotecontrol = RemoteControl(self.config)
-        self.out = py.io.TerminalWriter()
+import sys, os
 
-    def main(self, initialitems):
-        try:
-            self.loopstate = loopstate = LoopState([])
-            self.remotecontrol.setup()
-            while 1:
-                self.loop_once(loopstate)
-                if not loopstate.colitems and loopstate.wasfailing:
-                    continue # the last failures passed, let's rerun all
-                self.statrecorder.waitonchange(checkinterval=2.0) 
-        except KeyboardInterrupt:
-            print
-
-    def loop_once(self, loopstate):
-        colitems = loopstate.colitems
-        loopstate.wasfailing = colitems and len(colitems)
-        loopstate.colitems = self.remotecontrol.runsession(colitems or ())
-        self.remotecontrol.setup()
-
-class LoopState:
-    def __init__(self, colitems=None):
-        self.colitems = colitems
-
-class RemoteControl(object):
-    def __init__(self, config):
+class SlaveInteractor:
+    def __init__(self, config, channel):
         self.config = config
+        self.slaveid = config.slaveinput.get('slaveid', "?")
+        self.log = py.log.Producer("slave-%s" % self.slaveid)
+        if not config.option.debug:
+            py.log.setconsumer(self.log._keywords, None)
+        self.channel = channel
+        config.pluginmanager.register(self)
 
-    def trace(self, *args):
-        if self.config.option.debug:
-            msg = " ".join([str(x) for x in args])
-            py.builtin.print_("RemoteControl:", msg)
+    def sendevent(self, name, **kwargs):
+        self.log("sending", name, kwargs)
+        self.channel.send((name, kwargs))
 
-    def initgateway(self):
-        return execnet.makegateway("popen")
+    def pytest_internalerror(self, excrepr):
+        for line in str(excrepr).split("\n"):
+            self.log("IERROR>", line)
 
-    def setup(self, out=None):
-        if out is None:
-            out = py.io.TerminalWriter()
-        if hasattr(self, 'gateway'):
-            raise ValueError("already have gateway %r" % self.gateway)
-        self.trace("setting up slave session")
-        self.gateway = self.initgateway()
-        self.channel = channel = self.gateway.remote_exec("""
-            import os, sys
-            import py
-            chdir = channel.receive()
-            outchannel = channel.gateway.newchannel()
-            channel.send(outchannel)
-            # prune sys.path to not contain relative paths
-            newpaths = []
-            for p in sys.path:
-                if p:
-                    if not os.path.isabs(p):
-                        p = os.path.abspath(p)
-                    newpaths.append(p)
-            sys.path[:] = newpaths     
-            os.chdir(chdir) # unpickling config uses cwd as topdir
+    def pytest_sessionstart(self, session):
+        self.session = session
+        slaveinfo = getinfodict()
+        self.sendevent("slaveready", slaveinfo=slaveinfo)
 
-            config_state = channel.receive()
-            fullwidth, hasmarkup = channel.receive()
-            py.test.config.__setstate__(config_state)
+    def pytest_sessionfinish(self, __multicall__, exitstatus):
+        self.config.slaveoutput['exitstatus'] = exitstatus
+        res = __multicall__.execute()
+        self.sendevent("slavefinished", slaveoutput=self.config.slaveoutput)
+        return res
 
-            import sys
-            sys.stdout = sys.stderr = outchannel.makefile('w')
+    def pytest_collection(self, session):
+        self.sendevent("collectionstart")
 
-            from xdist.remote import slave_runsession
-            slave_runsession(channel, py.test.config, fullwidth, hasmarkup) 
-        """)
-        channel.send(str(self.config.topdir))
-        remote_outchannel = channel.receive()
-        def write(s):
-            out._file.write(s)
-            out._file.flush()
-        remote_outchannel.setcallback(write)
-        channel.send(self.config.__getstate__())
-        channel.send((out.fullwidth, out.hasmarkup))
-        self.trace("set up of slave session complete")
+    def pytest_runtestloop(self, session):
+        self.log("entering main loop")
+        torun = []
+        while 1:
+            name, kwargs = self.channel.receive()
+            self.log("received command", name, kwargs)
+            if name == "runtests":
+                torun.extend(kwargs['indices'])
+            elif name == "runtests_all":
+                torun.extend(range(len(session.items)))
+            self.log("items to run:", torun)
+            # only run if we have an item and a next item
+            while len(torun) >= 2:
+                self.run_tests(torun)
+            if name == "shutdown":
+                if torun:
+                    self.run_tests(torun)
+                break
+        return True
 
-    def ensure_teardown(self):
-        if hasattr(self, 'channel'):
-            if not self.channel.isclosed():
-                self.trace("closing", self.channel)
-                self.channel.close()
-            del self.channel
-        if hasattr(self, 'gateway'):
-            self.trace("exiting", self.gateway)
-            self.gateway.exit()
-            del self.gateway
-
-    def runsession(self, colitems=()):
-        try:
-            self.trace("sending", colitems)
-            trails = colitems
-            self.channel.send(trails)
-            try:
-                return self.channel.receive()
-            except self.channel.RemoteError:
-                e = sys.exc_info()[1]
-                self.trace("ERROR", e)
-                raise
-        finally:
-            self.ensure_teardown()
-
-def slave_runsession(channel, config, fullwidth, hasmarkup):
-    """ we run this on the other side. """
-    if config.option.debug:
-        def DEBUG(*args): 
-            print(" ".join(map(str, args)))
+    def run_tests(self, torun):
+        items = self.session.items
+        self.item_index = torun.pop(0)
+        if torun:
+            nextitem = items[torun[0]]
         else:
-        def DEBUG(*args): pass
+            nextitem = None
+        self.config.hook.pytest_runtest_protocol(
+            item=items[self.item_index],
+            nextitem=nextitem)
 
-    DEBUG("SLAVE: received configuration, using topdir:", config.topdir)
-    #config.option.session = None
+    def pytest_collection_finish(self, session):
+        self.sendevent("collectionfinish",
+            topdir=str(session.fspath),
+            ids=[item.nodeid for item in session.items])
+
+    def pytest_runtest_logstart(self, nodeid, location):
+        self.sendevent("logstart", nodeid=nodeid, location=location)
+
+    def pytest_runtest_logreport(self, report):
+        data = serialize_report(report)
+        data["item_index"] = self.item_index
+        assert self.session.items[self.item_index].nodeid == report.nodeid
+        self.sendevent("testreport", data=data)
+
+    def pytest_collectreport(self, report):
+        data = serialize_report(report)
+        self.sendevent("collectreport", data=data)
+
+def serialize_report(rep):
+    import py
+    d = rep.__dict__.copy()
+    if hasattr(rep.longrepr, 'toterminal'):
+        d['longrepr'] = str(rep.longrepr)
+    else:
+        d['longrepr'] = rep.longrepr
+    for name in d:
+        if isinstance(d[name], py.path.local):
+            d[name] = str(d[name])
+        elif name == "result":
+            d[name] = None # for now
+    return d
+
+def getinfodict():
+    import platform
+    return dict(
+        version = sys.version,
+        version_info = tuple(sys.version_info),
+        sysplatform = sys.platform,
+        platform = platform.platform(),
+        executable = sys.executable,
+        cwd = os.getcwd(),
+    )
+
+def remote_initconfig(option_dict, args):
+    from _pytest.config import Config
+    option_dict['plugins'].append("no:terminal")
+    config = Config.fromdictargs(option_dict, args)
     config.option.looponfail = False
     config.option.usepdb = False
-    try:
-        trails = channel.receive()
-    except KeyboardInterrupt:
-        return # in the slave we can't do much about this
-    config.pluginmanager.do_configure(config)
-    DEBUG("SLAVE: initsession()")
-    session = config.initsession()
-    # XXX configure the reporter object's terminal writer more directly
-    # XXX and write a test for this remote-terminal setting logic 
-    config.pytest_terminal_hasmarkup = hasmarkup
-    config.pytest_terminal_fullwidth = fullwidth
-    if trails:
-        colitems = []
-        for trail in trails:
-            try:
-                colitem = config._rootcol.fromtrail(trail)
-            except ValueError:
-                #XXX send info for "test disappeared" or so
-                continue 
-            colitems.append(colitem)
-    else:
-        colitems = config.getinitialnodes()
-    session.shouldclose = channel.isclosed 
+    config.option.dist = "no"
+    config.option.distload = False
+    config.option.numprocesses = None
+    config.args = args
+    return config
 
-    class Failures(list):
-        def pytest_runtest_logreport(self, report):
-            if report.failed:
-                self.append(report)
-        pytest_collectreport = pytest_runtest_logreport
 
-    failreports = Failures()
-    session.pluginmanager.register(failreports)
-
-    DEBUG("SLAVE: starting session.main()")
-    session.main(colitems)
-    session.config.hook.pytest_looponfailinfo(
-        failreports=list(failreports), 
-        rootdirs=[config.topdir])
-    rootcol = session.config._rootcol
-    channel.send([rootcol.totrail(rep.getnode()) for rep in failreports])
+if __name__ == '__channelexec__':
+    channel = channel  # noqa
+    # python3.2 is not concurrent import safe, so let's play it safe
+    # https://bitbucket.org/hpk42/pytest/issue/347/pytest-xdist-and-python-32
+    if sys.version_info[:2] == (3,2):
+        os.environ["PYTHONDONTWRITEBYTECODE"] = "1"
+    slaveinput,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['PYTHONPATH'] = importpath
+    import py
+    config = remote_initconfig(option_dict, args)
+    config.slaveinput = slaveinput
+    config.slaveoutput = {}
+    interactor = SlaveInteractor(config, channel)
+    config.hook.pytest_cmdline_main(config=config)

xdist/slavemanage.py

@@ -0,0 +1,311 @@
+import fnmatch
+import os
+
+import py
+import pytest
+import execnet
+import xdist.remote
+
+from _pytest import runner # XXX load dynamically
+
+class NodeManager(object):
+    EXIT_TIMEOUT = 10
+    DEFAULT_IGNORES = ['.*', '*.pyc', '*.pyo', '*~']
+    def __init__(self, config, specs=None, defaultchdir="pyexecnetcache"):
+        self.config = config
+        self._nodesready = py.std.threading.Event()
+        self.trace = self.config.trace.get("nodemanager")
+        self.group = execnet.Group()
+        if specs is None:
+            specs = self._getxspecs()
+        self.specs = []
+        for spec in specs:
+            if not isinstance(spec, execnet.XSpec):
+                spec = execnet.XSpec(spec)
+            if not spec.chdir and not spec.popen:
+                spec.chdir = defaultchdir
+            self.group.allocate_id(spec)
+            self.specs.append(spec)
+        self.roots = self._getrsyncdirs()
+        self.rsyncoptions = self._getrsyncoptions()
+        self._rsynced_specs = py.builtin.set()
+
+    def rsync_roots(self, gateway):
+        """Rsync the set of roots to the node's gateway cwd."""
+        if self.roots:
+            for root in self.roots:
+                self.rsync(gateway, root, **self.rsyncoptions)
+
+    def setup_nodes(self, putevent):
+        self.config.hook.pytest_xdist_setupnodes(config=self.config,
+                                                 specs=self.specs)
+        self.trace("setting up nodes")
+        nodes = []
+        for spec in self.specs:
+            nodes.append(self.setup_node(spec, putevent))
+        return nodes
+
+    def setup_node(self, spec, putevent):
+        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.setup()
+        self.trace("started node %r" % node)
+        return node
+
+    def teardown_nodes(self):
+        self.group.terminate(self.EXIT_TIMEOUT)
+
+    def _getxspecs(self):
+        xspeclist = []
+        for xspec in self.config.getvalue("tx"):
+            i = xspec.find("*")
+            try:
+                num = int(xspec[:i])
+            except ValueError:
+                xspeclist.append(xspec)
+            else:
+                xspeclist.extend([xspec[i+1:]] * num)
+        if not xspeclist:
+            raise pytest.UsageError(
+                "MISSING test execution (tx) nodes: please specify --tx")
+        return [execnet.XSpec(x) for x in xspeclist]
+
+    def _getrsyncdirs(self):
+        for spec in self.specs:
+            if not spec.popen or spec.chdir:
+                break
+        else:
+            return []
+        import pytest, _pytest
+        pytestpath = pytest.__file__.rstrip("co")
+        pytestdir = py.path.local(_pytest.__file__).dirpath()
+        config = self.config
+        candidates = [py._pydir,pytestpath,pytestdir]
+        candidates += config.option.rsyncdir
+        rsyncroots = config.getini("rsyncdirs")
+        if rsyncroots:
+            candidates.extend(rsyncroots)
+        roots = []
+        for root in candidates:
+            root = py.path.local(root).realpath()
+            if not root.check():
+                raise pytest.UsageError("rsyncdir doesn't exist: %r" %(root,))
+            if root not in roots:
+                roots.append(root)
+        return roots
+
+    def _getrsyncoptions(self):
+        """Get options to be passed for rsync."""
+        ignores = list(self.DEFAULT_IGNORES)
+        ignores += self.config.option.rsyncignore
+        ignores += self.config.getini("rsyncignore")
+
+        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."""
+        # XXX This changes the calling behaviour of
+        #     pytest_xdist_rsyncstart and pytest_xdist_rsyncfinish to
+        #     be called once per rsync target.
+        rsync = HostRSync(source, verbose=verbose, ignores=ignores)
+        spec = gateway.spec
+        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("""
+                import sys ; sys.path.insert(0, %r)
+            """ % os.path.dirname(str(source))).waitclose()
+            return
+        if (spec, source) in self._rsynced_specs:
+            return
+        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],
+        )
+        rsync.send()
+        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 = {}
+        ignores= None
+        if 'ignores' in kwargs:
+            ignores = kwargs.pop('ignores')
+        self._ignores = ignores or []
+        super(HostRSync, self).__init__(sourcedir=sourcedir, **kwargs)
+
+    def filter(self, path):
+        path = py.path.local(path)
+        for x in self._ignores:
+            x = getattr(x, 'strpath', x)
+            if fnmatch.fnmatch(path.basename, x) or fnmatch.fnmatch(path.strpath, x):
+                return False
+        else:
+            return True
+
+    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,)
+
+    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))
+
+
+def make_reltoroot(roots, args):
+    # XXX introduce/use public API for splitting py.test args
+    splitcode = "::"
+    l = []
+    for arg in args:
+        parts = arg.split(splitcode)
+        fspath = py.path.local(parts[0])
+        for root in roots:
+            x = fspath.relto(root)
+            if x or fspath == root:
+                parts[0] = root.basename + "/" + x
+                break
+        else:
+            raise ValueError("arg %s not relative to an rsync root" % (arg,))
+        l.append(splitcode.join(parts))
+    return l
+
+class SlaveController(object):
+    ENDMARK = -1
+
+    def __init__(self, nodemanager, gateway, config, putevent):
+        self.nodemanager = nodemanager
+        self.putevent = putevent
+        self.gateway = gateway
+        self.config = config
+        self.slaveinput = {'slaveid': gateway.id}
+        self._down = False
+        self.log = py.log.Producer("slavectl-%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,)
+
+    def setup(self):
+        self.log("setting up slave session")
+        spec = self.gateway.spec
+        args = self.config.args
+        if not spec.popen or spec.chdir:
+            args = make_reltoroot(self.nodemanager.roots, args)
+        option_dict = vars(self.config.option)
+        if spec.popen:
+            name = "popen-%s" % self.gateway.id
+            basetemp = self.config._tmpdirhandler.getbasetemp()
+            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))
+        if self.putevent:
+            self.channel.setcallback(self.process_from_remote,
+                endmarker=self.ENDMARK)
+
+    def ensure_teardown(self):
+        if hasattr(self, 'channel'):
+            if not self.channel.isclosed():
+                self.log("closing", self.channel)
+                self.channel.close()
+            #del self.channel
+        if hasattr(self, 'gateway'):
+            self.log("exiting", self.gateway)
+            self.gateway.exit()
+            #del self.gateway
+
+    def send_runtest_some(self, indices):
+        self.sendcommand("runtests", indices=indices)
+
+    def send_runtest_all(self):
+        self.sendcommand("runtests_all",)
+
+    def shutdown(self):
+        if not self._down:
+            try:
+                self.sendcommand("shutdown")
+            except IOError:
+                pass
+
+    def sendcommand(self, name, **kwargs):
+        """ send a named parametrized command to the other side. """
+        self.log("sending command %s(**%s)" % (name, kwargs))
+        self.channel.send((name, kwargs))
+
+    def notify_inproc(self, eventname, **kwargs):
+        self.log("queuing %s(**%s)" % (eventname, kwargs))
+        self.putevent((eventname, kwargs))
+
+    def process_from_remote(self, eventcall):
+        """ this gets called for each object we receive from
+            the other side and if the channel closes.
+
+            Note that channel callbacks run in the receiver
+            thread of execnet gateways - we need to
+            avoid raising exceptions or doing heavy work.
+        """
+        try:
+            if eventcall == self.ENDMARK:
+                err = self.channel._getremoteerror()
+                if not self._down:
+                    if not err or isinstance(err, EOFError):
+                        err = "Not properly terminated" # lost connection?
+                    self.notify_inproc("errordown", node=self, error=err)
+                    self._down = True
+                return
+            eventname, kwargs = eventcall
+            if eventname in ("collectionstart"):
+                self.log("ignoring %s(%s)" %(eventname, kwargs))
+            elif eventname == "slaveready":
+                self.notify_inproc(eventname, node=self, **kwargs)
+            elif eventname == "slavefinished":
+                self._down = True
+                self.slaveoutput = kwargs['slaveoutput']
+                self.notify_inproc("slavefinished", node=self)
+            elif eventname == "logstart":
+                self.notify_inproc(eventname, node=self, **kwargs)
+            elif eventname in ("testreport", "collectreport", "teardownreport"):
+                item_index = kwargs.pop("item_index", None)
+                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'])
+            else:
+                raise ValueError("unknown event: %s" %(eventname,))
+        except KeyboardInterrupt:
+            # should not land in receiver-thread
+            raise
+        except:
+            excinfo = py.code.ExceptionInfo()
+            py.builtin.print_("!" * 20, excinfo)
+            self.config.pluginmanager.notify_exception(excinfo)
+
+def unserialize_report(name, reportdict):
+    if name == "testreport":
+        return runner.TestReport(**reportdict)
+    elif name == "collectreport":
+        return runner.CollectReport(**reportdict)

xdist/txnode.py

@@ -1,164 +0,0 @@
-"""
-    Manage setup, running and local representation of remote nodes/processes. 
-"""
-import py
-from xdist.mypickle import PickleChannel
-from py._test import outcome
-
-class TXNode(object):
-    """ Represents a Test Execution environment in the controlling process. 
-        - sets up a slave node through an execnet gateway 
-        - manages sending of test-items and receival of results and events
-        - creates events when the remote side crashes 
-    """
-    ENDMARK = -1
-
-    def __init__(self, gateway, config, putevent):
-        self.config = config 
-        self.putevent = putevent 
-        self.gateway = gateway
-        self.channel = install_slave(gateway, config)
-        self.channel.setcallback(self.callback, endmarker=self.ENDMARK)
-        self._down = False
-
-    def __repr__(self):
-        id = self.gateway.id
-        status = self._down and 'true' or 'false'
-        return "<TXNode %r down=%s>" %(id, status)
-
-    def notify(self, eventname, *args, **kwargs):
-        assert not args
-        self.putevent((eventname, args, kwargs))
-      
-    def callback(self, eventcall):
-        """ this gets called for each object we receive from 
-            the other side and if the channel closes. 
-
-            Note that channel callbacks run in the receiver
-            thread of execnet gateways - we need to 
-            avoid raising exceptions or doing heavy work.
-        """
-        try:
-            if eventcall == self.ENDMARK:
-                err = self.channel._getremoteerror()
-                if not self._down:
-                    if not err or isinstance(err, EOFError):
-                        err = "Not properly terminated"
-                    self.notify("pytest_testnodedown", node=self, error=err)
-                    self._down = True
-                return
-            eventname, args, kwargs = eventcall 
-            if eventname == "slaveready":
-                self.notify("pytest_testnodeready", node=self)
-            elif eventname == "slavefinished":
-                self._down = True
-                self.notify("pytest_testnodedown", error=None, node=self)
-            elif eventname in ("pytest_runtest_logreport", 
-                               "pytest__teardown_final_logerror"):
-                kwargs['report'].node = self
-                self.notify(eventname, **kwargs)
-            else:
-                self.notify(eventname, **kwargs)
-        except KeyboardInterrupt: 
-            # should not land in receiver-thread
-            raise 
-        except:
-            excinfo = py.code.ExceptionInfo()
-            py.builtin.print_("!" * 20, excinfo)
-            self.config.pluginmanager.notify_exception(excinfo)
-
-    def send(self, item):
-        assert item is not None
-        self.channel.send(item)
-
-    def sendlist(self, itemlist):
-        self.channel.send(itemlist)
-
-    def shutdown(self, kill=False):
-        if kill:
-            self.gateway.exit()
-        else:
-            self.channel.send(None)
-
-# setting up slave code 
-def install_slave(gateway, config):
-    channel = gateway.remote_exec(source="""
-        import os, sys 
-        sys.path.insert(0, os.getcwd()) 
-        from xdist.mypickle import PickleChannel
-        from xdist.txnode import SlaveNode
-        channel.send("basicimport")
-        channel = PickleChannel(channel)
-        slavenode = SlaveNode(channel)
-        slavenode.run()
-    """)
-    channel.receive()
-    channel = PickleChannel(channel)
-    basetemp = None
-    if gateway.spec.popen:
-        popenbase = config.ensuretemp("popen")
-        basetemp = py.path.local.make_numbered_dir(prefix="slave-", 
-            keep=0, rootdir=popenbase)
-        basetemp = str(basetemp)
-    channel.send((config, basetemp, gateway.id))
-    return channel
-
-class SlaveNode(object):
-    def __init__(self, channel):
-        self.channel = channel
-
-    def __repr__(self):
-        return "<%s channel=%s>" %(self.__class__.__name__, self.channel)
-
-    def sendevent(self, eventname, *args, **kwargs):
-        self.channel.send((eventname, args, kwargs))
-
-    def pytest_runtest_logreport(self, report):
-        self.sendevent("pytest_runtest_logreport", report=report)
-
-    def pytest__teardown_final_logerror(self, report):
-        self.sendevent("pytest__teardown_final_logerror", report=report)
-
-    def run(self):
-        channel = self.channel
-        self.config, basetemp, self.nodeid = channel.receive()
-        if basetemp:
-            self.config.basetemp = py.path.local(basetemp)
-        self.config.pluginmanager.do_configure(self.config)
-        self.config.pluginmanager.register(self)
-        self.runner = self.config.pluginmanager.getplugin("pytest_runner")
-        self.sendevent("slaveready")
-        try:
-            self.config.hook.pytest_sessionstart(session=self)
-            while 1:
-                task = channel.receive()
-                if task is None: 
-                    break
-                if isinstance(task, list):
-                    for item in task:
-                        self.run_single(item=item)
-                else:
-                    self.run_single(item=task)
-            self.config.hook.pytest_sessionfinish(
-                session=self, 
-                exitstatus=outcome.EXIT_OK)
-        except KeyboardInterrupt:
-            raise
-        except:
-            er = py.code.ExceptionInfo().getrepr(funcargs=True, showlocals=True)
-            self.sendevent("pytest_internalerror", excrepr=er)
-            raise
-        else:
-            self.sendevent("slavefinished")
-
-    def run_single(self, item):
-        call = self.runner.CallInfo(item._reraiseunpicklingproblem, when='setup')
-        if call.excinfo:
-            # likely it is not collectable here because of
-            # platform/import-dependency induced skips 
-            # we fake a setup-error report with the obtained exception
-            # and do not care about capturing or non-runner hooks 
-            rep = self.runner.pytest_runtest_makereport(item=item, call=call)
-            self.pytest_runtest_logreport(rep)
-            return
-        item.config.hook.pytest_runtest_protocol(item=item) 

xdist/util.py

@@ -1,53 +0,0 @@
-import py
-
-class StatRecorder:
-    def __init__(self, rootdirlist):
-        self.rootdirlist = rootdirlist
-        self.statcache = {}
-        self.check() # snapshot state
-
-    def fil(self, p): 
-        return p.ext in ('.py', '.txt', '.c', '.h')
-    def rec(self, p):
-        return p.check(dotfile=0)
-
-    def waitonchange(self, checkinterval=1.0):
-        while 1:
-            changed = self.check()
-            if changed:
-                return
-            py.std.time.sleep(checkinterval)
-
-    def check(self, removepycfiles=True):
-        changed = False
-        statcache = self.statcache
-        newstat = {}
-        for rootdir in self.rootdirlist:
-            for path in rootdir.visit(self.fil, self.rec):
-                oldstat = statcache.get(path, None)
-                if oldstat is not None:
-                    del statcache[path]
-                try:
-                    newstat[path] = curstat = path.stat()
-                except py.error.ENOENT:
-                    if oldstat:
-                        del statcache[path]
-                        changed = True
-                else:
-                    if oldstat:
-                       if oldstat.mtime != curstat.mtime or \
-                          oldstat.size != curstat.size:
-                            changed = True
-                            py.builtin.print_("# MODIFIED", path)
-                            if removepycfiles and path.ext == ".py":
-                                pycfile = path + "c"
-                                if pycfile.check():
-                                    pycfile.remove()
-                                
-                    else:
-                        changed = True
-        if statcache:
-            changed = True
-        self.statcache = newstat
-        return changed
-