LogoopenSUSE Build Service > Projects
Sign Up | Log In

View File tox-disable-env-tests.patch of Package python-tox (Project home:tbechtold:branches:devel:languages:python)

Index: b/tests/test_config.py
===================================================================
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -88,26 +88,6 @@ class TestVenvConfig:
             'dep1==1.5', 'dep2==2.1', 'dep3==3.0', 'dep4==4.0',
         ]
 
-    def test_force_dep_with_url(self, initproj):
-        initproj("example123-0.5", filedefs={
-            'tox.ini': '''
-            [tox]
-
-            [testenv]
-            deps=
-                dep1==1.0
-                https://pypi.python.org/xyz/pkg1.tar.gz
-            '''
-        })
-        config = parseconfig(
-            ['--force-dep=dep1==1.5'])
-        assert config.option.force_dep == [
-            'dep1==1.5'
-        ]
-        assert [str(x) for x in config.envconfigs['python'].deps] == [
-            'dep1==1.5', 'https://pypi.python.org/xyz/pkg1.tar.gz'
-        ]
-
     def test_is_same_dep(self):
         """
         Ensure correct parseini._is_same_dep is working with a few samples.
@@ -1784,84 +1764,6 @@ class TestParseEnv:
         assert config.envconfigs['hello'].recreate
 
 
-class TestCmdInvocation:
-    def test_help(self, cmd):
-        result = cmd.run("tox", "-h")
-        assert not result.ret
-        result.stdout.fnmatch_lines([
-            "*help*",
-        ])
-
-    def test_version(self, cmd):
-        result = cmd.run("tox", "--version")
-        assert not result.ret
-        stdout = result.stdout.str()
-        assert tox.__version__ in stdout
-        assert "imported from" in stdout
-
-    def test_listenvs(self, cmd, initproj):
-        initproj('listenvs', filedefs={
-            'tox.ini': '''
-            [tox]
-            envlist=py26,py27,py33,pypy,docs
-
-            [testenv:notincluded]
-            changedir = whatever
-
-            [testenv:docs]
-            changedir = docs
-            ''',
-        })
-        result = cmd.run("tox", "-l")
-        result.stdout.fnmatch_lines("""
-            *py26*
-            *py27*
-            *py33*
-            *pypy*
-            *docs*
-        """)
-
-    def test_config_specific_ini(self, tmpdir, cmd):
-        ini = tmpdir.ensure("hello.ini")
-        result = cmd.run("tox", "-c", ini, "--showconfig")
-        assert not result.ret
-        result.stdout.fnmatch_lines([
-            "*config-file*hello.ini*",
-        ])
-
-    def test_no_tox_ini(self, cmd, initproj):
-        initproj("noini-0.5", )
-        result = cmd.run("tox")
-        assert result.ret
-        result.stderr.fnmatch_lines([
-            "*ERROR*tox.ini*not*found*",
-        ])
-
-    def test_showconfig_with_force_dep_version(self, cmd, initproj):
-        initproj('force_dep_version', filedefs={
-            'tox.ini': '''
-            [tox]
-
-            [testenv]
-            deps=
-                dep1==2.3
-                dep2
-            ''',
-        })
-        result = cmd.run("tox", "--showconfig")
-        assert result.ret == 0
-        result.stdout.fnmatch_lines([
-            r'*deps*dep1==2.3, dep2*',
-        ])
-        # override dep1 specific version, and force version for dep2
-        result = cmd.run("tox", "--showconfig", "--force-dep=dep1",
-                         "--force-dep=dep2==5.0")
-        assert result.ret == 0
-        result.stdout.fnmatch_lines([
-            r'*deps*dep1, dep2==5.0*',
-        ])
-
-
 @pytest.mark.parametrize("cmdline,envlist", [
     ("-e py26", ['py26']),
     ("-e py26,py33", ['py26', 'py33']),
Index: b/tests/test_z_cmdline.py
===================================================================
--- a/tests/test_z_cmdline.py
+++ b/tests/test_z_cmdline.py
@@ -1,760 +0,0 @@
-import tox
-import py
-import pytest
-from tox._pytestplugin import ReportExpectMock
-try:
-    import json
-except ImportError:
-    import simplejson as json
-
-pytest_plugins = "pytester"
-
-from tox.session import Session
-from tox.config import parseconfig
-
-
-def test_report_protocol(newconfig):
-    config = newconfig([], """
-            [testenv:mypython]
-            deps=xy
-    """)
-
-    class Popen:
-        def __init__(self, *args, **kwargs):
-            pass
-
-        def communicate(self):
-            return "", ""
-
-        def wait(self):
-            pass
-
-    session = Session(config, popen=Popen,
-                      Report=ReportExpectMock)
-    report = session.report
-    report.expect("using")
-    venv = session.getvenv("mypython")
-    action = session.newaction(venv, "update")
-    venv.update(action)
-    report.expect("logpopen")
-
-
-def test__resolve_pkg(tmpdir, mocksession):
-    distshare = tmpdir.join("distshare")
-    spec = distshare.join("pkg123-*")
-    py.test.raises(tox.exception.MissingDirectory,
-                   'mocksession._resolve_pkg(spec)')
-    distshare.ensure(dir=1)
-    py.test.raises(tox.exception.MissingDependency,
-                   'mocksession._resolve_pkg(spec)')
-    distshare.ensure("pkg123-1.3.5.zip")
-    p = distshare.ensure("pkg123-1.4.5.zip")
-
-    mocksession.report.clear()
-    result = mocksession._resolve_pkg(spec)
-    assert result == p
-    mocksession.report.expect("info", "determin*pkg123*")
-    distshare.ensure("pkg123-1.4.7dev.zip")
-    mocksession._clearmocks()
-    result = mocksession._resolve_pkg(spec)
-    mocksession.report.expect("warning", "*1.4.7*")
-    assert result == p
-    mocksession._clearmocks()
-    distshare.ensure("pkg123-1.4.5a1.tar.gz")
-    result = mocksession._resolve_pkg(spec)
-    assert result == p
-
-
-def test__resolve_pkg_doubledash(tmpdir, mocksession):
-    distshare = tmpdir.join("distshare")
-    p = distshare.ensure("pkg-mine-1.3.0.zip")
-    res = mocksession._resolve_pkg(distshare.join("pkg-mine*"))
-    assert res == p
-    distshare.ensure("pkg-mine-1.3.0a1.zip")
-    res = mocksession._resolve_pkg(distshare.join("pkg-mine*"))
-    assert res == p
-
-
-class TestSession:
-    def test_make_sdist(self, initproj):
-        initproj("example123-0.5", filedefs={
-            'tests': {'test_hello.py': "def test_hello(): pass"},
-            'tox.ini': '''
-            '''
-        })
-        config = parseconfig([])
-        session = Session(config)
-        sdist = session.get_installpkg_path()
-        assert sdist.check()
-        assert sdist.ext == ".zip"
-        assert sdist == config.distdir.join(sdist.basename)
-        sdist2 = session.get_installpkg_path()
-        assert sdist2 == sdist
-        sdist.write("hello")
-        assert sdist.stat().size < 10
-        sdist_new = Session(config).get_installpkg_path()
-        assert sdist_new == sdist
-        assert sdist_new.stat().size > 10
-
-    def test_make_sdist_distshare(self, tmpdir, initproj):
-        distshare = tmpdir.join("distshare")
-        initproj("example123-0.6", filedefs={
-            'tests': {'test_hello.py': "def test_hello(): pass"},
-            'tox.ini': '''
-            [tox]
-            distshare=%s
-            ''' % distshare
-        })
-        config = parseconfig([])
-        session = Session(config)
-        sdist = session.get_installpkg_path()
-        assert sdist.check()
-        assert sdist.ext == ".zip"
-        assert sdist == config.distdir.join(sdist.basename)
-        sdist_share = config.distshare.join(sdist.basename)
-        assert sdist_share.check()
-        assert sdist_share.read("rb") == sdist.read("rb"), (sdist_share, sdist)
-
-    def test_log_pcall(self, mocksession):
-        mocksession.config.logdir.ensure(dir=1)
-        assert not mocksession.config.logdir.listdir()
-        action = mocksession.newaction(None, "something")
-        action.popen(["echo", ])
-        match = mocksession.report.getnext("logpopen")
-        assert match[1].outpath.relto(mocksession.config.logdir)
-        assert match[1].shell is False
-
-    def test_summary_status(self, initproj, capfd):
-        initproj("logexample123-0.5", filedefs={
-            'tests': {'test_hello.py': "def test_hello(): pass"},
-            'tox.ini': '''
-            [testenv:hello]
-            [testenv:world]
-            '''
-        })
-        config = parseconfig([])
-        session = Session(config)
-        envs = session.venvlist
-        assert len(envs) == 2
-        env1, env2 = envs
-        env1.status = "FAIL XYZ"
-        assert env1.status
-        env2.status = 0
-        assert not env2.status
-        session._summary()
-        out, err = capfd.readouterr()
-        exp = "%s: FAIL XYZ" % env1.envconfig.envname
-        assert exp in out
-        exp = "%s: commands succeeded" % env2.envconfig.envname
-        assert exp in out
-
-    def test_getvenv(self, initproj, capfd):
-        initproj("logexample123-0.5", filedefs={
-            'tests': {'test_hello.py': "def test_hello(): pass"},
-            'tox.ini': '''
-            [testenv:hello]
-            [testenv:world]
-            '''
-        })
-        config = parseconfig([])
-        session = Session(config)
-        venv1 = session.getvenv("hello")
-        venv2 = session.getvenv("hello")
-        assert venv1 is venv2
-        venv1 = session.getvenv("world")
-        venv2 = session.getvenv("world")
-        assert venv1 is venv2
-        pytest.raises(LookupError, lambda: session.getvenv("qwe"))
-
-
-# not sure we want this option ATM
-def XXX_test_package(cmd, initproj):
-    initproj("myproj-0.6", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'MANIFEST.in': """
-            include doc
-            include myproj
-            """,
-        'tox.ini': ''
-    })
-    result = cmd.run("tox", "package")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*created sdist package at*",
-    ])
-
-
-def test_minversion(cmd, initproj):
-    initproj("interp123-0.5", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'tox.ini': '''
-            [tox]
-            minversion = 6.0
-        '''
-    })
-    result = cmd.run("tox", "-v")
-    result.stdout.fnmatch_lines([
-        "*ERROR*tox version is * required is at least 6.0*"
-    ])
-    assert result.ret
-
-
-def test_run_custom_install_command_error(cmd, initproj):
-    initproj("interp123-0.5", filedefs={
-        'tox.ini': '''
-            [testenv]
-            install_command=./tox.ini {opts} {packages}
-        '''
-    })
-    result = cmd.run("tox")
-    result.stdout.fnmatch_lines([
-        "ERROR: invocation failed (errno *), args: ['*/tox.ini*",
-    ])
-    assert result.ret
-
-
-def test_unknown_interpreter_and_env(cmd, initproj):
-    initproj("interp123-0.5", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'tox.ini': '''
-            [testenv:python]
-            basepython=xyz_unknown_interpreter
-            [testenv]
-            changedir=tests
-        '''
-    })
-    result = cmd.run("tox")
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*ERROR*InterpreterNotFound*xyz_unknown_interpreter*",
-    ])
-
-    result = cmd.run("tox", "-exyz")
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*ERROR*unknown*",
-    ])
-
-
-def test_unknown_interpreter(cmd, initproj):
-    initproj("interp123-0.5", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'tox.ini': '''
-            [testenv:python]
-            basepython=xyz_unknown_interpreter
-            [testenv]
-            changedir=tests
-        '''
-    })
-    result = cmd.run("tox")
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*ERROR*InterpreterNotFound*xyz_unknown_interpreter*",
-    ])
-
-
-def test_skip_platform_mismatch(cmd, initproj):
-    initproj("interp123-0.5", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'tox.ini': '''
-            [testenv]
-            changedir=tests
-            platform=x123
-        '''
-    })
-    result = cmd.run("tox")
-    assert not result.ret
-    result.stdout.fnmatch_lines("""
-        SKIPPED*platform mismatch*
-    """)
-
-
-def test_skip_unknown_interpreter(cmd, initproj):
-    initproj("interp123-0.5", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'tox.ini': '''
-            [testenv:python]
-            basepython=xyz_unknown_interpreter
-            [testenv]
-            changedir=tests
-        '''
-    })
-    result = cmd.run("tox", "--skip-missing-interpreters")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*SKIPPED*InterpreterNotFound*xyz_unknown_interpreter*",
-    ])
-
-
-def test_unknown_dep(cmd, initproj):
-    initproj("dep123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'tox.ini': '''
-            [testenv]
-            deps=qweqwe123
-            changedir=tests
-        '''
-    })
-    result = cmd.run("tox", )
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*ERROR*could not install*qweqwe123*",
-    ])
-
-
-def test_venv_special_chars_issue252(cmd, initproj):
-    initproj("pkg123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'tox.ini': '''
-            [tox]
-            envlist = special&&1
-            [testenv:special&&1]
-            changedir=tests
-        '''
-    })
-    result = cmd.run("tox", )
-    assert result.ret == 0
-    result.stdout.fnmatch_lines([
-        "*installed*pkg123*"
-    ])
-
-
-def test_unknown_environment(cmd, initproj):
-    initproj("env123-0.7", filedefs={
-        'tox.ini': ''
-    })
-    result = cmd.run("tox", "-e", "qpwoei")
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*ERROR*unknown*environment*qpwoei*",
-    ])
-
-
-def test_skip_sdist(cmd, initproj):
-    initproj("pkg123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'setup.py': """
-            syntax error
-        """,
-        'tox.ini': '''
-            [tox]
-            skipsdist=True
-            [testenv]
-            commands=python -c "print('done')"
-        '''
-    })
-    result = cmd.run("tox", )
-    assert result.ret == 0
-
-
-def test_minimal_setup_py_empty(cmd, initproj):
-    initproj("pkg123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'setup.py': """
-        """,
-        'tox.ini': ''
-
-    })
-    result = cmd.run("tox", )
-    assert result.ret == 1
-    result.stdout.fnmatch_lines([
-        "*ERROR*empty*",
-    ])
-
-
-def test_minimal_setup_py_comment_only(cmd, initproj):
-    initproj("pkg123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'setup.py': """\n# some comment
-
-        """,
-        'tox.ini': ''
-
-    })
-    result = cmd.run("tox", )
-    assert result.ret == 1
-    result.stdout.fnmatch_lines([
-        "*ERROR*empty*",
-    ])
-
-
-def test_minimal_setup_py_non_functional(cmd, initproj):
-    initproj("pkg123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'setup.py': """
-        import sys
-
-        """,
-        'tox.ini': ''
-
-    })
-    result = cmd.run("tox", )
-    assert result.ret == 1
-    result.stdout.fnmatch_lines([
-        "*ERROR*check setup.py*",
-    ])
-
-
-def test_sdist_fails(cmd, initproj):
-    initproj("pkg123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'setup.py': """
-            syntax error
-        """,
-        'tox.ini': '',
-    })
-    result = cmd.run("tox", )
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*FAIL*could not package project*",
-    ])
-
-
-def test_package_install_fails(cmd, initproj):
-    initproj("pkg123-0.7", filedefs={
-        'tests': {'test_hello.py': "def test_hello(): pass"},
-        'setup.py': """
-            from setuptools import setup
-            setup(
-                name='pkg123',
-                description='pkg123 project',
-                version='0.7',
-                license='MIT',
-                platforms=['unix', 'win32'],
-                packages=['pkg123',],
-                install_requires=['qweqwe123'],
-                )
-            """,
-        'tox.ini': '',
-    })
-    result = cmd.run("tox", )
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*InvocationError*",
-    ])
-
-
-class TestToxRun:
-    @pytest.fixture
-    def example123(self, initproj):
-        initproj("example123-0.5", filedefs={
-            'tests': {
-                'test_hello.py': """
-                    def test_hello(pytestconfig):
-                        pass
-                """,
-            },
-            'tox.ini': '''
-                [testenv]
-                changedir=tests
-                commands= py.test --basetemp={envtmpdir} \
-                                  --junitxml=junit-{envname}.xml
-                deps=pytest
-            '''
-        })
-
-    def test_toxuone_env(self, cmd, example123):
-        result = cmd.run("tox")
-        assert not result.ret
-        result.stdout.fnmatch_lines([
-            "*junit-python.xml*",
-            "*1 passed*",
-        ])
-        result = cmd.run("tox", "-epython", )
-        assert not result.ret
-        result.stdout.fnmatch_lines([
-            "*1 passed*",
-            "*summary*",
-            "*python: commands succeeded"
-        ])
-
-    def test_different_config_cwd(self, cmd, example123, monkeypatch):
-        # see that things work with a different CWD
-        monkeypatch.chdir(cmd.tmpdir)
-        result = cmd.run("tox", "-c", "example123/tox.ini")
-        assert not result.ret
-        result.stdout.fnmatch_lines([
-            "*1 passed*",
-            "*summary*",
-            "*python: commands succeeded"
-        ])
-
-    def test_json(self, cmd, example123):
-        # see that tests can also fail and retcode is correct
-        testfile = py.path.local("tests").join("test_hello.py")
-        assert testfile.check()
-        testfile.write("def test_fail(): assert 0")
-        jsonpath = cmd.tmpdir.join("res.json")
-        result = cmd.run("tox", "--result-json", jsonpath)
-        assert result.ret == 1
-        data = json.load(jsonpath.open("r"))
-        verify_json_report_format(data)
-        result.stdout.fnmatch_lines([
-            "*1 failed*",
-            "*summary*",
-            "*python: *failed*",
-        ])
-
-
-def test_develop(initproj, cmd):
-    initproj("example123", filedefs={'tox.ini': """
-    """})
-    result = cmd.run("tox", "-vv", "--develop")
-    assert not result.ret
-    assert "sdist-make" not in result.stdout.str()
-
-
-def test_usedevelop(initproj, cmd):
-    initproj("example123", filedefs={'tox.ini': """
-            [testenv]
-            usedevelop=True
-    """})
-    result = cmd.run("tox", "-vv")
-    assert not result.ret
-    assert "sdist-make" not in result.stdout.str()
-
-
-def test_usedevelop_mixed(initproj, cmd):
-    initproj("example123", filedefs={'tox.ini': """
-            [testenv:devenv]
-            usedevelop=True
-            [testenv:nondev]
-            usedevelop=False
-    """})
-
-    # running only 'devenv' should not do sdist
-    result = cmd.run("tox", "-vv", "-e", "devenv")
-    assert not result.ret
-    assert "sdist-make" not in result.stdout.str()
-
-    # running all envs should do sdist
-    result = cmd.run("tox", "-vv")
-    assert not result.ret
-    assert "sdist-make" in result.stdout.str()
-
-
-def test_test_usedevelop(cmd, initproj):
-    initproj("example123-0.5", filedefs={
-        'tests': {
-            'test_hello.py': """
-                def test_hello(pytestconfig):
-                    pass
-            """,
-        },
-        'tox.ini': '''
-            [testenv]
-            usedevelop=True
-            changedir=tests
-            commands=
-                py.test --basetemp={envtmpdir} --junitxml=junit-{envname}.xml []
-            deps=pytest
-        '''
-    })
-    result = cmd.run("tox", "-v")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*junit-python.xml*",
-        "*1 passed*",
-    ])
-    assert "sdist-make" not in result.stdout.str()
-    result = cmd.run("tox", "-epython", )
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*1 passed*",
-        "*summary*",
-        "*python: commands succeeded"
-    ])
-    # see that things work with a different CWD
-    old = cmd.tmpdir.chdir()
-    result = cmd.run("tox", "-c", "example123/tox.ini")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*1 passed*",
-        "*summary*",
-        "*python: commands succeeded"
-    ])
-    old.chdir()
-    # see that tests can also fail and retcode is correct
-    testfile = py.path.local("tests").join("test_hello.py")
-    assert testfile.check()
-    testfile.write("def test_fail(): assert 0")
-    result = cmd.run("tox", )
-    assert result.ret
-    result.stdout.fnmatch_lines([
-        "*1 failed*",
-        "*summary*",
-        "*python: *failed*",
-    ])
-
-
-def test_test_piphelp(initproj, cmd):
-    initproj("example123", filedefs={'tox.ini': """
-        # content of: tox.ini
-        [testenv]
-        commands=pip -h
-        [testenv:py26]
-        basepython=python
-        [testenv:py27]
-        basepython=python
-    """})
-    result = cmd.run("tox")
-    assert not result.ret
-
-
-def test_notest(initproj, cmd):
-    initproj("example123", filedefs={'tox.ini': """
-        # content of: tox.ini
-        [testenv:py26]
-        basepython=python
-    """})
-    result = cmd.run("tox", "-v", "--notest")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*summary*",
-        "*py26*skipped tests*",
-    ])
-    result = cmd.run("tox", "-v", "--notest", "-epy26")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*py26*reusing*",
-    ])
-
-
-def test_PYC(initproj, cmd, monkeypatch):
-    initproj("example123", filedefs={'tox.ini': ''})
-    monkeypatch.setenv("PYTHONDOWNWRITEBYTECODE", 1)
-    result = cmd.run("tox", "-v", "--notest")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*create*",
-    ])
-
-
-def test_env_VIRTUALENV_PYTHON(initproj, cmd, monkeypatch):
-    initproj("example123", filedefs={'tox.ini': ''})
-    monkeypatch.setenv("VIRTUALENV_PYTHON", '/FOO')
-    result = cmd.run("tox", "-v", "--notest")
-    assert not result.ret, result.stdout.lines
-    result.stdout.fnmatch_lines([
-        "*create*",
-    ])
-
-
-def test_sdistonly(initproj, cmd):
-    initproj("example123", filedefs={'tox.ini': """
-    """})
-    result = cmd.run("tox", "-v", "--sdistonly")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*sdist-make*setup.py*",
-    ])
-    assert "-mvirtualenv" not in result.stdout.str()
-
-
-def test_separate_sdist_no_sdistfile(cmd, initproj):
-    distshare = cmd.tmpdir.join("distshare")
-    initproj(("pkg123-foo", "0.7"), filedefs={
-        'tox.ini': """
-            [tox]
-            distshare=%s
-        """ % distshare
-    })
-    result = cmd.run("tox", "--sdistonly")
-    assert not result.ret
-    l = distshare.listdir()
-    assert len(l) == 1
-    sdistfile = l[0]
-    assert 'pkg123-foo-0.7.zip' in str(sdistfile)
-
-
-def test_separate_sdist(cmd, initproj):
-    distshare = cmd.tmpdir.join("distshare")
-    initproj("pkg123-0.7", filedefs={
-        'tox.ini': """
-            [tox]
-            distshare=%s
-            sdistsrc={distshare}/pkg123-0.7.zip
-        """ % distshare
-    })
-    result = cmd.run("tox", "--sdistonly")
-    assert not result.ret
-    l = distshare.listdir()
-    assert len(l) == 1
-    sdistfile = l[0]
-    result = cmd.run("tox", "-v", "--notest")
-    assert not result.ret
-    result.stdout.fnmatch_lines([
-        "*inst*%s*" % sdistfile,
-    ])
-
-
-def test_sdist_latest(tmpdir, newconfig):
-    distshare = tmpdir.join("distshare")
-    config = newconfig([], """
-            [tox]
-            distshare=%s
-            sdistsrc={distshare}/pkg123-*
-    """ % distshare)
-    p = distshare.ensure("pkg123-1.4.5.zip")
-    distshare.ensure("pkg123-1.4.5a1.zip")
-    session = Session(config)
-    sdist_path = session.get_installpkg_path()
-    assert sdist_path == p
-
-
-def test_installpkg(tmpdir, newconfig):
-    p = tmpdir.ensure("pkg123-1.0.zip")
-    config = newconfig(["--installpkg=%s" % p], "")
-    session = Session(config)
-    sdist_path = session.get_installpkg_path()
-    assert sdist_path == p
-
-
-@pytest.mark.xfail("sys.platform == 'win32'", reason="test needs better impl")
-def test_envsitepackagesdir(cmd, initproj):
-    initproj("pkg512-0.0.5", filedefs={
-        'tox.ini': """
-        [testenv]
-        commands=
-            python -c "print(r'X:{envsitepackagesdir}')"
-    """})
-    result = cmd.run("tox")
-    assert result.ret == 0
-    result.stdout.fnmatch_lines("""
-        X:*tox*site-packages*
-    """)
-
-
-@pytest.mark.xfail("sys.platform == 'win32'", reason="test needs better impl")
-def test_envsitepackagesdir_skip_missing_issue280(cmd, initproj):
-    initproj("pkg513-0.0.5", filedefs={
-        'tox.ini': """
-        [testenv]
-        basepython=/usr/bin/qwelkjqwle
-        commands=
-            {envsitepackagesdir}
-    """})
-    result = cmd.run("tox", "--skip-missing-interpreters")
-    assert result.ret == 0
-    result.stdout.fnmatch_lines("""
-        SKIPPED:*qwelkj*
-    """)
-
-
-def verify_json_report_format(data, testenvs=True):
-    assert data["reportversion"] == "1"
-    assert data["toxversion"] == tox.__version__
-    if testenvs:
-        for envname, envdata in data["testenvs"].items():
-            for commandtype in ("setup", "test"):
-                if commandtype not in envdata:
-                    continue
-                for command in envdata[commandtype]:
-                    assert command["output"]
-                    assert command["retcode"]
-            if envname != "GLOB":
-                assert isinstance(envdata["installed_packages"], list)
-                pyinfo = envdata["python"]
-                assert isinstance(pyinfo["version_info"], list)
-                assert pyinfo["version"]
-                assert pyinfo["executable"]