How to use passenv method in tox

Best Python code snippet using tox_python

test_config.py

Source:test_config.py

1import sys2from textwrap import dedent3import py4import pytest5import tox6import tox.config7from tox.config import *  # noqa8from tox.venv import VirtualEnv9class TestVenvConfig:10    def test_config_parsing_minimal(self, tmpdir, newconfig):11        config = newconfig([], """12            [testenv:py1]13        """)14        assert len(config.envconfigs) == 115        assert config.toxworkdir.realpath() == tmpdir.join(".tox").realpath()16        assert config.envconfigs['py1'].basepython == sys.executable17        assert config.envconfigs['py1'].deps == []18        assert config.envconfigs['py1'].platform == ".*"19    def test_config_parsing_multienv(self, tmpdir, newconfig):20        config = newconfig([], """21            [tox]22            toxworkdir = %s23            indexserver =24                xyz = xyz_repo25            [testenv:py1]26            deps=hello27            [testenv:py2]28            deps=29                world130                :xyz:http://hello/world31        """ % (tmpdir, ))32        assert config.toxworkdir == tmpdir33        assert len(config.envconfigs) == 234        assert config.envconfigs['py1'].envdir == tmpdir.join("py1")35        dep = config.envconfigs['py1'].deps[0]36        assert dep.name == "hello"37        assert dep.indexserver is None38        assert config.envconfigs['py2'].envdir == tmpdir.join("py2")39        dep1, dep2 = config.envconfigs['py2'].deps40        assert dep1.name == "world1"41        assert dep2.name == "http://hello/world"42        assert dep2.indexserver.name == "xyz"43        assert dep2.indexserver.url == "xyz_repo"44    def test_envdir_set_manually(self, tmpdir, newconfig):45        config = newconfig([], """46            [testenv:devenv]47            envdir = devenv48        """)49        envconfig = config.envconfigs['devenv']50        assert envconfig.envdir == tmpdir.join('devenv')51    def test_envdir_set_manually_with_substitutions(self, tmpdir, newconfig):52        config = newconfig([], """53            [testenv:devenv]54            envdir = {toxworkdir}/foobar55        """)56        envconfig = config.envconfigs['devenv']57        assert envconfig.envdir == config.toxworkdir.join('foobar')58    def test_force_dep_version(self, initproj):59        """60        Make sure we can override dependencies configured in tox.ini when using the command line61        option --force-dep.62        """63        initproj("example123-0.5", filedefs={64            'tox.ini': '''65            [tox]66            [testenv]67            deps=68                dep1==1.069                dep2>=2.070                dep371                dep4==4.072            '''73        })74        config = parseconfig(75            ['--force-dep=dep1==1.5', '--force-dep=dep2==2.1',76             '--force-dep=dep3==3.0'])77        assert config.option.force_dep == [78            'dep1==1.5', 'dep2==2.1', 'dep3==3.0']79        assert [str(x) for x in config.envconfigs['python'].deps] == [80            'dep1==1.5', 'dep2==2.1', 'dep3==3.0', 'dep4==4.0',81        ]82    def test_force_dep_with_url(self, initproj):83        initproj("example123-0.5", filedefs={84            'tox.ini': '''85            [tox]86            [testenv]87            deps=88                dep1==1.089                https://pypi.python.org/xyz/pkg1.tar.gz90            '''91        })92        config = parseconfig(93            ['--force-dep=dep1==1.5'])94        assert config.option.force_dep == [95            'dep1==1.5'96        ]97        assert [str(x) for x in config.envconfigs['python'].deps] == [98            'dep1==1.5', 'https://pypi.python.org/xyz/pkg1.tar.gz'99        ]100    def test_is_same_dep(self):101        """102        Ensure correct parseini._is_same_dep is working with a few samples.103        """104        assert DepOption._is_same_dep('pkg_hello-world3==1.0', 'pkg_hello-world3')105        assert DepOption._is_same_dep('pkg_hello-world3==1.0', 'pkg_hello-world3>=2.0')106        assert DepOption._is_same_dep('pkg_hello-world3==1.0', 'pkg_hello-world3>2.0')107        assert DepOption._is_same_dep('pkg_hello-world3==1.0', 'pkg_hello-world3<2.0')108        assert DepOption._is_same_dep('pkg_hello-world3==1.0', 'pkg_hello-world3<=2.0')109        assert not DepOption._is_same_dep('pkg_hello-world3==1.0', 'otherpkg>=2.0')110class TestConfigPlatform:111    def test_config_parse_platform(self, newconfig):112        config = newconfig([], """113            [testenv:py1]114            platform = linux2115        """)116        assert len(config.envconfigs) == 1117        assert config.envconfigs['py1'].platform == "linux2"118    def test_config_parse_platform_rex(self, newconfig, mocksession, monkeypatch):119        config = newconfig([], """120            [testenv:py1]121            platform = a123|b123122        """)123        assert len(config.envconfigs) == 1124        envconfig = config.envconfigs['py1']125        venv = VirtualEnv(envconfig, session=mocksession)126        assert not venv.matching_platform()127        monkeypatch.setattr(sys, "platform", "a123")128        assert venv.matching_platform()129        monkeypatch.setattr(sys, "platform", "b123")130        assert venv.matching_platform()131        monkeypatch.undo()132        assert not venv.matching_platform()133    @pytest.mark.parametrize("plat", ["win", "lin", ])134    def test_config_parse_platform_with_factors(self, newconfig, plat, monkeypatch):135        monkeypatch.setattr(sys, "platform", "win32")136        config = newconfig([], """137            [tox]138            envlist = py27-{win,lin,osx}139            [testenv]140            platform =141                win: win32142                lin: linux2143        """)144        assert len(config.envconfigs) == 3145        platform = config.envconfigs['py27-' + plat].platform146        expected = {"win": "win32", "lin": "linux2"}.get(plat)147        assert platform == expected148class TestConfigPackage:149    def test_defaults(self, tmpdir, newconfig):150        config = newconfig([], "")151        assert config.setupdir.realpath() == tmpdir.realpath()152        assert config.toxworkdir.realpath() == tmpdir.join(".tox").realpath()153        envconfig = config.envconfigs['python']154        assert envconfig.args_are_paths155        assert not envconfig.recreate156        assert not envconfig.pip_pre157    def test_defaults_distshare(self, tmpdir, newconfig):158        config = newconfig([], "")159        assert config.distshare == config.homedir.join(".tox", "distshare")160    def test_defaults_changed_dir(self, tmpdir, newconfig):161        tmpdir.mkdir("abc").chdir()162        config = newconfig([], "")163        assert config.setupdir.realpath() == tmpdir.realpath()164        assert config.toxworkdir.realpath() == tmpdir.join(".tox").realpath()165    def test_project_paths(self, tmpdir, newconfig):166        config = newconfig("""167            [tox]168            toxworkdir=%s169        """ % tmpdir)170        assert config.toxworkdir == tmpdir171class TestParseconfig:172    def test_search_parents(self, tmpdir):173        b = tmpdir.mkdir("a").mkdir("b")174        toxinipath = tmpdir.ensure("tox.ini")175        old = b.chdir()176        try:177            config = parseconfig([])178        finally:179            old.chdir()180        assert config.toxinipath == toxinipath181def test_get_homedir(monkeypatch):182    monkeypatch.setattr(py.path.local, "_gethomedir",183                        classmethod(lambda x: {}[1]))184    assert not get_homedir()185    monkeypatch.setattr(py.path.local, "_gethomedir",186                        classmethod(lambda x: 0 / 0))187    assert not get_homedir()188    monkeypatch.setattr(py.path.local, "_gethomedir",189                        classmethod(lambda x: "123"))190    assert get_homedir() == "123"191class TestGetcontextname:192    def test_blank(self, monkeypatch):193        monkeypatch.setattr(os, "environ", {})194        assert getcontextname() is None195    def test_jenkins(self, monkeypatch):196        monkeypatch.setattr(os, "environ", {"JENKINS_URL": "xyz"})197        assert getcontextname() == "jenkins"198    def test_hudson_legacy(self, monkeypatch):199        monkeypatch.setattr(os, "environ", {"HUDSON_URL": "xyz"})200        assert getcontextname() == "jenkins"201class TestIniParserAgainstCommandsKey:202    """Test parsing commands with substitutions"""203    def test_command_substitution_from_other_section(self, newconfig):204        config = newconfig("""205            [section]206            key = whatever207            [testenv]208            commands =209                echo {[section]key}210            """)211        reader = SectionReader("testenv", config._cfg)212        x = reader.getargvlist("commands")213        assert x == [["echo", "whatever"]]214    def test_command_substitution_from_other_section_multiline(self, newconfig):215        """Ensure referenced multiline commands form from other section injected216        as multiple commands."""217        config = newconfig("""218            [section]219            commands =220                      cmd1 param11 param12221                      # comment is omitted222                      cmd2 param21 \223                           param22224            [base]225            commands = cmd 1 \226                           2 3 4227                       cmd 2228            [testenv]229            commands =230                {[section]commands}231                {[section]commands}232                # comment is omitted233                echo {[base]commands}234            """)235        reader = SectionReader("testenv", config._cfg)236        x = reader.getargvlist("commands")237        assert x == [238            "cmd1 param11 param12".split(),239            "cmd2 param21 param22".split(),240            "cmd1 param11 param12".split(),241            "cmd2 param21 param22".split(),242            ["echo", "cmd", "1", "2", "3", "4", "cmd", "2"],243        ]244    def test_command_substitution_from_other_section_posargs(self, newconfig):245        """Ensure subsitition from other section with posargs succeeds"""246        config = newconfig("""247            [section]248            key = thing {posargs} arg2249            [testenv]250            commands =251                {[section]key}252            """)253        reader = SectionReader("testenv", config._cfg)254        reader.addsubstitutions([r"argpos"])255        x = reader.getargvlist("commands")256        assert x == [['thing', 'argpos', 'arg2']]257    def test_command_section_and_posargs_substitution(self, newconfig):258        """Ensure subsitition from other section with posargs succeeds"""259        config = newconfig("""260            [section]261            key = thing arg1262            [testenv]263            commands =264                {[section]key} {posargs} endarg265            """)266        reader = SectionReader("testenv", config._cfg)267        reader.addsubstitutions([r"argpos"])268        x = reader.getargvlist("commands")269        assert x == [['thing', 'arg1', 'argpos', 'endarg']]270    def test_command_env_substitution(self, newconfig):271        """Ensure referenced {env:key:default} values are substituted correctly."""272        config = newconfig("""273           [testenv:py27]274           setenv =275             TEST=testvalue276           commands =277             ls {env:TEST}278        """)279        envconfig = config.envconfigs["py27"]280        assert envconfig.commands == [["ls", "testvalue"]]281        assert envconfig.setenv["TEST"] == "testvalue"282class TestIniParser:283    def test_getstring_single(self, tmpdir, newconfig):284        config = newconfig("""285            [section]286            key=value287        """)288        reader = SectionReader("section", config._cfg)289        x = reader.getstring("key")290        assert x == "value"291        assert not reader.getstring("hello")292        x = reader.getstring("hello", "world")293        assert x == "world"294    def test_missing_substitution(self, tmpdir, newconfig):295        config = newconfig("""296            [mydefault]297            key2={xyz}298        """)299        reader = SectionReader("mydefault", config._cfg, fallbacksections=['mydefault'])300        assert reader is not None301        with py.test.raises(tox.exception.ConfigError):302            reader.getstring("key2")303    def test_getstring_fallback_sections(self, tmpdir, newconfig):304        config = newconfig("""305            [mydefault]306            key2=value2307            [section]308            key=value309        """)310        reader = SectionReader("section", config._cfg, fallbacksections=['mydefault'])311        x = reader.getstring("key2")312        assert x == "value2"313        x = reader.getstring("key3")314        assert not x315        x = reader.getstring("key3", "world")316        assert x == "world"317    def test_getstring_substitution(self, tmpdir, newconfig):318        config = newconfig("""319            [mydefault]320            key2={value2}321            [section]322            key={value}323        """)324        reader = SectionReader("section", config._cfg, fallbacksections=['mydefault'])325        reader.addsubstitutions(value="newvalue", value2="newvalue2")326        x = reader.getstring("key2")327        assert x == "newvalue2"328        x = reader.getstring("key3")329        assert not x330        x = reader.getstring("key3", "{value2}")331        assert x == "newvalue2"332    def test_getlist(self, tmpdir, newconfig):333        config = newconfig("""334            [section]335            key2=336                item1337                {item2}338        """)339        reader = SectionReader("section", config._cfg)340        reader.addsubstitutions(item1="not", item2="grr")341        x = reader.getlist("key2")342        assert x == ['item1', 'grr']343    def test_getdict(self, tmpdir, newconfig):344        config = newconfig("""345            [section]346            key2=347                key1=item1348                key2={item2}349        """)350        reader = SectionReader("section", config._cfg)351        reader.addsubstitutions(item1="not", item2="grr")352        x = reader.getdict("key2")353        assert 'key1' in x354        assert 'key2' in x355        assert x['key1'] == 'item1'356        assert x['key2'] == 'grr'357        x = reader.getdict("key3", {1: 2})358        assert x == {1: 2}359    def test_getstring_environment_substitution(self, monkeypatch, newconfig):360        monkeypatch.setenv("KEY1", "hello")361        config = newconfig("""362            [section]363            key1={env:KEY1}364            key2={env:KEY2}365        """)366        reader = SectionReader("section", config._cfg)367        x = reader.getstring("key1")368        assert x == "hello"369        with py.test.raises(tox.exception.ConfigError):370            reader.getstring("key2")371    def test_getstring_environment_substitution_with_default(self, monkeypatch, newconfig):372        monkeypatch.setenv("KEY1", "hello")373        config = newconfig("""374            [section]375            key1={env:KEY1:DEFAULT_VALUE}376            key2={env:KEY2:DEFAULT_VALUE}377            key3={env:KEY3:}378        """)379        reader = SectionReader("section", config._cfg)380        x = reader.getstring("key1")381        assert x == "hello"382        x = reader.getstring("key2")383        assert x == "DEFAULT_VALUE"384        x = reader.getstring("key3")385        assert x == ""386    def test_value_matches_section_substituion(self):387        assert is_section_substitution("{[setup]commands}")388    def test_value_doesn_match_section_substitution(self):389        assert is_section_substitution("{[ ]commands}") is None390        assert is_section_substitution("{[setup]}") is None391        assert is_section_substitution("{[setup] commands}") is None392    def test_getstring_other_section_substitution(self, newconfig):393        config = newconfig("""394            [section]395            key = rue396            [testenv]397            key = t{[section]key}398            """)399        reader = SectionReader("testenv", config._cfg)400        x = reader.getstring("key")401        assert x == "true"402    def test_argvlist(self, tmpdir, newconfig):403        config = newconfig("""404            [section]405            key2=406                cmd1 {item1} {item2}407                cmd2 {item2}408        """)409        reader = SectionReader("section", config._cfg)410        reader.addsubstitutions(item1="with space", item2="grr")411        # py.test.raises(tox.exception.ConfigError,412        #    "reader.getargvlist('key1')")413        assert reader.getargvlist('key1') == []414        x = reader.getargvlist("key2")415        assert x == [["cmd1", "with", "space", "grr"],416                     ["cmd2", "grr"]]417    def test_argvlist_windows_escaping(self, tmpdir, newconfig):418        config = newconfig("""419            [section]420            comm = py.test {posargs}421        """)422        reader = SectionReader("section", config._cfg)423        reader.addsubstitutions([r"hello\this"])424        argv = reader.getargv("comm")425        assert argv == ["py.test", "hello\\this"]426    def test_argvlist_multiline(self, tmpdir, newconfig):427        config = newconfig("""428            [section]429            key2=430                cmd1 {item1} \431                     {item2}432        """)433        reader = SectionReader("section", config._cfg)434        reader.addsubstitutions(item1="with space", item2="grr")435        # py.test.raises(tox.exception.ConfigError,436        #    "reader.getargvlist('key1')")437        assert reader.getargvlist('key1') == []438        x = reader.getargvlist("key2")439        assert x == [["cmd1", "with", "space", "grr"]]440    def test_argvlist_quoting_in_command(self, tmpdir, newconfig):441        config = newconfig("""442            [section]443            key1=444                cmd1 'part one' \445                     'part two'446        """)447        reader = SectionReader("section", config._cfg)448        x = reader.getargvlist("key1")449        assert x == [["cmd1", "part one", "part two"]]450    def test_argvlist_comment_after_command(self, tmpdir, newconfig):451        config = newconfig("""452            [section]453            key1=454                cmd1 --flag  # run the flag on the command455        """)456        reader = SectionReader("section", config._cfg)457        x = reader.getargvlist("key1")458        assert x == [["cmd1", "--flag"]]459    def test_argvlist_command_contains_hash(self, tmpdir, newconfig):460        config = newconfig("""461            [section]462            key1=463                cmd1 --re  "use the # symbol for an arg"464        """)465        reader = SectionReader("section", config._cfg)466        x = reader.getargvlist("key1")467        assert x == [["cmd1", "--re", "use the # symbol for an arg"]]468    def test_argvlist_positional_substitution(self, tmpdir, newconfig):469        config = newconfig("""470            [section]471            key2=472                cmd1 []473                cmd2 {posargs:{item2} \474                     other}475        """)476        reader = SectionReader("section", config._cfg)477        posargs = ['hello', 'world']478        reader.addsubstitutions(posargs, item2="value2")479        # py.test.raises(tox.exception.ConfigError,480        #    "reader.getargvlist('key1')")481        assert reader.getargvlist('key1') == []482        argvlist = reader.getargvlist("key2")483        assert argvlist[0] == ["cmd1"] + posargs484        assert argvlist[1] == ["cmd2"] + posargs485        reader = SectionReader("section", config._cfg)486        reader.addsubstitutions([], item2="value2")487        # py.test.raises(tox.exception.ConfigError,488        #    "reader.getargvlist('key1')")489        assert reader.getargvlist('key1') == []490        argvlist = reader.getargvlist("key2")491        assert argvlist[0] == ["cmd1"]492        assert argvlist[1] == ["cmd2", "value2", "other"]493    def test_argvlist_quoted_posargs(self, tmpdir, newconfig):494        config = newconfig("""495            [section]496            key2=497                cmd1 --foo-args='{posargs}'498                cmd2 -f '{posargs}'499                cmd3 -f {posargs}500        """)501        reader = SectionReader("section", config._cfg)502        reader.addsubstitutions(["foo", "bar"])503        assert reader.getargvlist('key1') == []504        x = reader.getargvlist("key2")505        assert x == [["cmd1", "--foo-args=foo bar"],506                     ["cmd2", "-f", "foo bar"],507                     ["cmd3", "-f", "foo", "bar"]]508    def test_argvlist_posargs_with_quotes(self, tmpdir, newconfig):509        config = newconfig("""510            [section]511            key2=512                cmd1 -f {posargs}513        """)514        reader = SectionReader("section", config._cfg)515        reader.addsubstitutions(["foo", "'bar", "baz'"])516        assert reader.getargvlist('key1') == []517        x = reader.getargvlist("key2")518        assert x == [["cmd1", "-f", "foo", "bar baz"]]519    def test_positional_arguments_are_only_replaced_when_standing_alone(self, tmpdir, newconfig):520        config = newconfig("""521            [section]522            key=523                cmd0 []524                cmd1 -m '[abc]'525                cmd2 -m '\'something\'' []526                cmd3 something[]else527        """)528        reader = SectionReader("section", config._cfg)529        posargs = ['hello', 'world']530        reader.addsubstitutions(posargs)531        argvlist = reader.getargvlist('key')532        assert argvlist[0] == ['cmd0'] + posargs533        assert argvlist[1] == ['cmd1', '-m', '[abc]']534        assert argvlist[2] == ['cmd2', '-m', "something"] + posargs535        assert argvlist[3] == ['cmd3', 'something[]else']536    def test_substitution_with_multiple_words(self, newconfig):537        inisource = """538            [section]539            key = py.test -n5 --junitxml={envlogdir}/junit-{envname}.xml []540            """541        config = newconfig(inisource)542        reader = SectionReader("section", config._cfg)543        posargs = ['hello', 'world']544        reader.addsubstitutions(posargs, envlogdir='ENV_LOG_DIR', envname='ENV_NAME')545        expected = [546            'py.test', '-n5', '--junitxml=ENV_LOG_DIR/junit-ENV_NAME.xml', 'hello', 'world'547        ]548        assert reader.getargvlist('key')[0] == expected549    def test_getargv(self, newconfig):550        config = newconfig("""551            [section]552            key=some command "with quoting"553        """)554        reader = SectionReader("section", config._cfg)555        expected = ['some', 'command', 'with quoting']556        assert reader.getargv('key') == expected557    def test_getpath(self, tmpdir, newconfig):558        config = newconfig("""559            [section]560            path1={HELLO}561        """)562        reader = SectionReader("section", config._cfg)563        reader.addsubstitutions(toxinidir=tmpdir, HELLO="mypath")564        x = reader.getpath("path1", tmpdir)565        assert x == tmpdir.join("mypath")566    def test_getbool(self, tmpdir, newconfig):567        config = newconfig("""568            [section]569            key1=True570            key2=False571            key1a=true572            key2a=falsE573            key5=yes574        """)575        reader = SectionReader("section", config._cfg)576        assert reader.getbool("key1") is True577        assert reader.getbool("key1a") is True578        assert reader.getbool("key2") is False579        assert reader.getbool("key2a") is False580        py.test.raises(KeyError, 'reader.getbool("key3")')581        py.test.raises(tox.exception.ConfigError, 'reader.getbool("key5")')582class TestIniParserPrefix:583    def test_basic_section_access(self, tmpdir, newconfig):584        config = newconfig("""585            [p:section]586            key=value587        """)588        reader = SectionReader("section", config._cfg, prefix="p")589        x = reader.getstring("key")590        assert x == "value"591        assert not reader.getstring("hello")592        x = reader.getstring("hello", "world")593        assert x == "world"594    def test_fallback_sections(self, tmpdir, newconfig):595        config = newconfig("""596            [p:mydefault]597            key2=value2598            [p:section]599            key=value600        """)601        reader = SectionReader("section", config._cfg, prefix="p",602                               fallbacksections=['p:mydefault'])603        x = reader.getstring("key2")604        assert x == "value2"605        x = reader.getstring("key3")606        assert not x607        x = reader.getstring("key3", "world")608        assert x == "world"609    def test_value_matches_prefixed_section_substituion(self):610        assert is_section_substitution("{[p:setup]commands}")611    def test_value_doesn_match_prefixed_section_substitution(self):612        assert is_section_substitution("{[p: ]commands}") is None613        assert is_section_substitution("{[p:setup]}") is None614        assert is_section_substitution("{[p:setup] commands}") is None615    def test_other_section_substitution(self, newconfig):616        config = newconfig("""617            [p:section]618            key = rue619            [p:testenv]620            key = t{[p:section]key}621            """)622        reader = SectionReader("testenv", config._cfg, prefix="p")623        x = reader.getstring("key")624        assert x == "true"625class TestConfigTestEnv:626    def test_commentchars_issue33(self, tmpdir, newconfig):627        config = newconfig("""628            [testenv] # hello629            deps = http://abc#123630            commands=631                python -c "x ; y"632        """)633        envconfig = config.envconfigs["python"]634        assert envconfig.deps[0].name == "http://abc#123"635        assert envconfig.commands[0] == ["python", "-c", "x ; y"]636    def test_defaults(self, tmpdir, newconfig):637        config = newconfig("""638            [testenv]639            commands=640                xyz --abc641        """)642        assert len(config.envconfigs) == 1643        envconfig = config.envconfigs['python']644        assert envconfig.commands == [["xyz", "--abc"]]645        assert envconfig.changedir == config.setupdir646        assert envconfig.sitepackages is False647        assert envconfig.usedevelop is False648        assert envconfig.ignore_errors is False649        assert envconfig.envlogdir == envconfig.envdir.join("log")650        assert list(envconfig.setenv.definitions.keys()) == ['PYTHONHASHSEED']651        hashseed = envconfig.setenv['PYTHONHASHSEED']652        assert isinstance(hashseed, str)653        # The following line checks that hashseed parses to an integer.654        int_hashseed = int(hashseed)655        # hashseed is random by default, so we can't assert a specific value.656        assert int_hashseed > 0657        assert envconfig.ignore_outcome is False658    def test_sitepackages_switch(self, tmpdir, newconfig):659        config = newconfig(["--sitepackages"], "")660        envconfig = config.envconfigs['python']661        assert envconfig.sitepackages is True662    def test_installpkg_tops_develop(self, newconfig):663        config = newconfig(["--installpkg=abc"], """664            [testenv]665            usedevelop = True666        """)667        assert not config.envconfigs["python"].usedevelop668    def test_specific_command_overrides(self, tmpdir, newconfig):669        config = newconfig("""670            [testenv]671            commands=xyz672            [testenv:py]673            commands=abc674        """)675        assert len(config.envconfigs) == 1676        envconfig = config.envconfigs['py']677        assert envconfig.commands == [["abc"]]678    def test_whitelist_externals(self, tmpdir, newconfig):679        config = newconfig("""680            [testenv]681            whitelist_externals = xyz682            commands=xyz683            [testenv:x]684            [testenv:py]685            whitelist_externals = xyz2686            commands=abc687        """)688        assert len(config.envconfigs) == 2689        envconfig = config.envconfigs['py']690        assert envconfig.commands == [["abc"]]691        assert envconfig.whitelist_externals == ["xyz2"]692        envconfig = config.envconfigs['x']693        assert envconfig.whitelist_externals == ["xyz"]694    def test_changedir(self, tmpdir, newconfig):695        config = newconfig("""696            [testenv]697            changedir=xyz698        """)699        assert len(config.envconfigs) == 1700        envconfig = config.envconfigs['python']701        assert envconfig.changedir.basename == "xyz"702        assert envconfig.changedir == config.toxinidir.join("xyz")703    def test_ignore_errors(self, tmpdir, newconfig):704        config = newconfig("""705            [testenv]706            ignore_errors=True707        """)708        assert len(config.envconfigs) == 1709        envconfig = config.envconfigs['python']710        assert envconfig.ignore_errors is True711    def test_envbindir(self, tmpdir, newconfig):712        config = newconfig("""713            [testenv]714            basepython=python715        """)716        assert len(config.envconfigs) == 1717        envconfig = config.envconfigs['python']718        assert envconfig.envpython == envconfig.envbindir.join("python")719    @pytest.mark.parametrize("bp", ["jython", "pypy", "pypy3"])720    def test_envbindir_jython(self, tmpdir, newconfig, bp):721        config = newconfig("""722            [testenv]723            basepython=%s724        """ % bp)725        assert len(config.envconfigs) == 1726        envconfig = config.envconfigs['python']727        # on win32 and linux virtualenv uses "bin" for pypy/jython728        assert envconfig.envbindir.basename == "bin"729        if bp == "jython":730            assert envconfig.envpython == envconfig.envbindir.join(bp)731    @pytest.mark.parametrize("plat", ["win32", "linux2"])732    def test_passenv_as_multiline_list(self, tmpdir, newconfig, monkeypatch, plat):733        monkeypatch.setattr(sys, "platform", plat)734        monkeypatch.setenv("A123A", "a")735        monkeypatch.setenv("A123B", "b")736        monkeypatch.setenv("BX23", "0")737        config = newconfig("""738            [testenv]739            passenv =740                      A123*741                      # isolated comment742                      B?23743        """)744        assert len(config.envconfigs) == 1745        envconfig = config.envconfigs['python']746        if plat == "win32":747            assert "PATHEXT" in envconfig.passenv748            assert "SYSTEMDRIVE" in envconfig.passenv749            assert "SYSTEMROOT" in envconfig.passenv750            assert "TEMP" in envconfig.passenv751            assert "TMP" in envconfig.passenv752        else:753            assert "TMPDIR" in envconfig.passenv754        assert "PATH" in envconfig.passenv755        assert "PIP_INDEX_URL" in envconfig.passenv756        assert "LANG" in envconfig.passenv757        assert "LD_LIBRARY_PATH" in envconfig.passenv758        assert "A123A" in envconfig.passenv759        assert "A123B" in envconfig.passenv760    @pytest.mark.parametrize("plat", ["win32", "linux2"])761    def test_passenv_as_space_separated_list(self, tmpdir, newconfig, monkeypatch, plat):762        monkeypatch.setattr(sys, "platform", plat)763        monkeypatch.setenv("A123A", "a")764        monkeypatch.setenv("A123B", "b")765        monkeypatch.setenv("BX23", "0")766        config = newconfig("""767            [testenv]768            passenv =769                      # comment770                      A123*  B?23771        """)772        assert len(config.envconfigs) == 1773        envconfig = config.envconfigs['python']774        if plat == "win32":775            assert "PATHEXT" in envconfig.passenv776            assert "SYSTEMDRIVE" in envconfig.passenv777            assert "SYSTEMROOT" in envconfig.passenv778            assert "TEMP" in envconfig.passenv779            assert "TMP" in envconfig.passenv780        else:781            assert "TMPDIR" in envconfig.passenv782        assert "PATH" in envconfig.passenv783        assert "PIP_INDEX_URL" in envconfig.passenv784        assert "LANG" in envconfig.passenv785        assert "A123A" in envconfig.passenv786        assert "A123B" in envconfig.passenv787    def test_passenv_with_factor(self, tmpdir, newconfig, monkeypatch):788        monkeypatch.setenv("A123A", "a")789        monkeypatch.setenv("A123B", "b")790        monkeypatch.setenv("A123C", "c")791        monkeypatch.setenv("A123D", "d")792        monkeypatch.setenv("BX23", "0")793        monkeypatch.setenv("CCA43", "3")794        monkeypatch.setenv("CB21", "4")795        config = newconfig("""796            [tox]797            envlist = {x1,x2}798            [testenv]799            passenv =800                x1: A123A CC*801                x1: CB21802                # passed to both environments803                A123C804                x2: A123B A123D805        """)806        assert len(config.envconfigs) == 2807        assert "A123A" in config.envconfigs["x1"].passenv808        assert "A123C" in config.envconfigs["x1"].passenv809        assert "CCA43" in config.envconfigs["x1"].passenv810        assert "CB21" in config.envconfigs["x1"].passenv811        assert "A123B" not in config.envconfigs["x1"].passenv812        assert "A123D" not in config.envconfigs["x1"].passenv813        assert "BX23" not in config.envconfigs["x1"].passenv814        assert "A123B" in config.envconfigs["x2"].passenv815        assert "A123D" in config.envconfigs["x2"].passenv816        assert "A123A" not in config.envconfigs["x2"].passenv817        assert "A123C" in config.envconfigs["x2"].passenv818        assert "CCA43" not in config.envconfigs["x2"].passenv819        assert "CB21" not in config.envconfigs["x2"].passenv820        assert "BX23" not in config.envconfigs["x2"].passenv821    def test_passenv_from_global_env(self, tmpdir, newconfig, monkeypatch):822        monkeypatch.setenv("A1", "a1")823        monkeypatch.setenv("A2", "a2")824        monkeypatch.setenv("TOX_TESTENV_PASSENV", "A1")825        config = newconfig("""826            [testenv]827            passenv = A2828        """)829        env = config.envconfigs["python"]830        assert "A1" in env.passenv831        assert "A2" in env.passenv832    def test_changedir_override(self, tmpdir, newconfig):833        config = newconfig("""834            [testenv]835            changedir=xyz836            [testenv:python]837            changedir=abc838            basepython=python2.6839        """)840        assert len(config.envconfigs) == 1841        envconfig = config.envconfigs['python']842        assert envconfig.changedir.basename == "abc"843        assert envconfig.changedir == config.setupdir.join("abc")844    def test_install_command_setting(self, newconfig):845        config = newconfig("""846            [testenv]847            install_command=some_install {packages}848        """)849        envconfig = config.envconfigs['python']850        assert envconfig.install_command == [851            'some_install', '{packages}']852    def test_install_command_must_contain_packages(self, newconfig):853        py.test.raises(tox.exception.ConfigError, newconfig, """854            [testenv]855            install_command=pip install856        """)857    def test_install_command_substitutions(self, newconfig):858        config = newconfig("""859            [testenv]860            install_command=some_install --arg={toxinidir}/foo \861                {envname} {opts} {packages}862        """)863        envconfig = config.envconfigs['python']864        assert envconfig.install_command == [865            'some_install', '--arg=%s/foo' % config.toxinidir, 'python',866            '{opts}', '{packages}']867    def test_pip_pre(self, newconfig):868        config = newconfig("""869            [testenv]870            pip_pre=true871        """)872        envconfig = config.envconfigs['python']873        assert envconfig.pip_pre874    def test_pip_pre_cmdline_override(self, newconfig):875        config = newconfig(876            ['--pre'],877            """878            [testenv]879            pip_pre=false880        """)881        envconfig = config.envconfigs['python']882        assert envconfig.pip_pre883    def test_downloadcache(self, newconfig, monkeypatch):884        monkeypatch.delenv("PIP_DOWNLOAD_CACHE", raising=False)885        config = newconfig("""886            [testenv]887            downloadcache=thecache888        """)889        envconfig = config.envconfigs['python']890        assert envconfig.downloadcache.basename == 'thecache'891    def test_downloadcache_env_override(self, newconfig, monkeypatch):892        monkeypatch.setenv("PIP_DOWNLOAD_CACHE", 'fromenv')893        config = newconfig("""894            [testenv]895            downloadcache=somepath896        """)897        envconfig = config.envconfigs['python']898        assert envconfig.downloadcache.basename == "fromenv"899    def test_downloadcache_only_if_in_config(self, newconfig, tmpdir,900                                             monkeypatch):901        monkeypatch.setenv("PIP_DOWNLOAD_CACHE", tmpdir)902        config = newconfig('')903        envconfig = config.envconfigs['python']904        assert not envconfig.downloadcache905    def test_simple(tmpdir, newconfig):906        config = newconfig("""907            [testenv:py26]908            basepython=python2.6909            [testenv:py27]910            basepython=python2.7911        """)912        assert len(config.envconfigs) == 2913        assert "py26" in config.envconfigs914        assert "py27" in config.envconfigs915    def test_substitution_error(tmpdir, newconfig):916        py.test.raises(tox.exception.ConfigError, newconfig, """917            [testenv:py27]918            basepython={xyz}919        """)920    def test_substitution_defaults(tmpdir, newconfig):921        config = newconfig("""922            [testenv:py27]923            commands =924                {toxinidir}925                {toxworkdir}926                {envdir}927                {envbindir}928                {envtmpdir}929                {envpython}930                {homedir}931                {distshare}932                {envlogdir}933        """)934        conf = config.envconfigs['py27']935        argv = conf.commands936        assert argv[0][0] == config.toxinidir937        assert argv[1][0] == config.toxworkdir938        assert argv[2][0] == conf.envdir939        assert argv[3][0] == conf.envbindir940        assert argv[4][0] == conf.envtmpdir941        assert argv[5][0] == conf.envpython942        assert argv[6][0] == str(config.homedir)943        assert argv[7][0] == config.homedir.join(".tox", "distshare")944        assert argv[8][0] == conf.envlogdir945    def test_substitution_notfound_issue246(tmpdir, newconfig):946        config = newconfig("""947            [testenv:py27]948            setenv =949                FOO={envbindir}950                BAR={envsitepackagesdir}951        """)952        conf = config.envconfigs['py27']953        env = conf.setenv954        assert 'FOO' in env955        assert 'BAR' in env956    def test_substitution_positional(self, newconfig):957        inisource = """958            [testenv:py27]959            commands =960                cmd1 [hello] \961                     world962                cmd1 {posargs:hello} \963                     world964        """965        conf = newconfig([], inisource).envconfigs['py27']966        argv = conf.commands967        assert argv[0] == ["cmd1", "[hello]", "world"]968        assert argv[1] == ["cmd1", "hello", "world"]969        conf = newconfig(['brave', 'new'], inisource).envconfigs['py27']970        argv = conf.commands971        assert argv[0] == ["cmd1", "[hello]", "world"]972        assert argv[1] == ["cmd1", "brave", "new", "world"]973    def test_substitution_noargs_issue240(self, newconfig):974        inisource = """975            [testenv]976            commands = echo {posargs:foo}977        """978        conf = newconfig([""], inisource).envconfigs['python']979        argv = conf.commands980        assert argv[0] == ["echo"]981    def test_substitution_double(self, newconfig):982        inisource = """983            [params]984            foo = bah985            foo2 = [params]foo986            [testenv:py27]987            commands =988                echo {{[params]foo2}}989        """990        conf = newconfig([], inisource).envconfigs['py27']991        argv = conf.commands992        assert argv[0] == ['echo', 'bah']993    def test_posargs_backslashed_or_quoted(self, tmpdir, newconfig):994        inisource = """995            [testenv:py27]996            commands =997                echo "\{posargs\}" = {posargs}998                echo "posargs = " "{posargs}"999        """1000        conf = newconfig([], inisource).envconfigs['py27']1001        argv = conf.commands1002        assert argv[0] == ['echo', '{posargs}', '=']1003        assert argv[1] == ['echo', 'posargs = ', ""]1004        conf = newconfig(['dog', 'cat'], inisource).envconfigs['py27']1005        argv = conf.commands1006        assert argv[0] == ['echo', '{posargs}', '=', 'dog', 'cat']1007        assert argv[1] == ['echo', 'posargs = ', 'dog cat']1008    def test_rewrite_posargs(self, tmpdir, newconfig):1009        inisource = """1010            [testenv:py27]1011            args_are_paths = True1012            changedir = tests1013            commands = cmd1 {posargs:hello}1014        """1015        conf = newconfig([], inisource).envconfigs['py27']1016        argv = conf.commands1017        assert argv[0] == ["cmd1", "hello"]1018        conf = newconfig(["tests/hello"], inisource).envconfigs['py27']1019        argv = conf.commands1020        assert argv[0] == ["cmd1", "tests/hello"]1021        tmpdir.ensure("tests", "hello")1022        conf = newconfig(["tests/hello"], inisource).envconfigs['py27']1023        argv = conf.commands1024        assert argv[0] == ["cmd1", "hello"]1025    def test_rewrite_simple_posargs(self, tmpdir, newconfig):1026        inisource = """1027            [testenv:py27]1028            args_are_paths = True1029            changedir = tests1030            commands = cmd1 {posargs}1031        """1032        conf = newconfig([], inisource).envconfigs['py27']1033        argv = conf.commands1034        assert argv[0] == ["cmd1"]1035        conf = newconfig(["tests/hello"], inisource).envconfigs['py27']1036        argv = conf.commands1037        assert argv[0] == ["cmd1", "tests/hello"]1038        tmpdir.ensure("tests", "hello")1039        conf = newconfig(["tests/hello"], inisource).envconfigs['py27']1040        argv = conf.commands1041        assert argv[0] == ["cmd1", "hello"]1042    def test_take_dependencies_from_other_testenv(self, newconfig):1043        inisource = """1044            [testenv]1045            deps=1046                pytest1047                pytest-cov1048            [testenv:py27]1049            deps=1050                {[testenv]deps}1051                fun1052        """1053        conf = newconfig([], inisource).envconfigs['py27']1054        packages = [dep.name for dep in conf.deps]1055        assert packages == ['pytest', 'pytest-cov', 'fun']1056    def test_take_dependencies_from_other_section(self, newconfig):1057        inisource = """1058            [testing:pytest]1059            deps=1060                pytest1061                pytest-cov1062            [testing:mock]1063            deps=1064                mock1065            [testenv]1066            deps=1067                {[testing:pytest]deps}1068                {[testing:mock]deps}1069                fun1070        """1071        conf = newconfig([], inisource)1072        env = conf.envconfigs['python']1073        packages = [dep.name for dep in env.deps]1074        assert packages == ['pytest', 'pytest-cov', 'mock', 'fun']1075    def test_multilevel_substitution(self, newconfig):1076        inisource = """1077            [testing:pytest]1078            deps=1079                pytest1080                pytest-cov1081            [testing:mock]1082            deps=1083                mock1084            [testing]1085            deps=1086                {[testing:pytest]deps}1087                {[testing:mock]deps}1088            [testenv]1089            deps=1090                {[testing]deps}1091                fun1092        """1093        conf = newconfig([], inisource)1094        env = conf.envconfigs['python']1095        packages = [dep.name for dep in env.deps]1096        assert packages == ['pytest', 'pytest-cov', 'mock', 'fun']1097    def test_recursive_substitution_cycle_fails(self, newconfig):1098        inisource = """1099            [testing:pytest]1100            deps=1101                {[testing:mock]deps}1102            [testing:mock]1103            deps=1104                {[testing:pytest]deps}1105            [testenv]1106            deps=1107                {[testing:pytest]deps}1108        """1109        py.test.raises(ValueError, newconfig, [], inisource)1110    def test_single_value_from_other_secton(self, newconfig, tmpdir):1111        inisource = """1112            [common]1113            changedir = testing1114            [testenv]1115            changedir = {[common]changedir}1116        """1117        conf = newconfig([], inisource).envconfigs['python']1118        assert conf.changedir.basename == 'testing'1119        assert conf.changedir.dirpath().realpath() == tmpdir.realpath()1120    def test_factors(self, newconfig):1121        inisource = """1122            [tox]1123            envlist = a-x,b1124            [testenv]1125            deps=1126                dep-all1127                a: dep-a1128                b: dep-b1129                x: dep-x1130        """1131        conf = newconfig([], inisource)1132        configs = conf.envconfigs1133        assert [dep.name for dep in configs['a-x'].deps] == \1134            ["dep-all", "dep-a", "dep-x"]1135        assert [dep.name for dep in configs['b'].deps] == ["dep-all", "dep-b"]1136    def test_factor_ops(self, newconfig):1137        inisource = """1138            [tox]1139            envlist = {a,b}-{x,y}1140            [testenv]1141            deps=1142                a,b: dep-a-or-b1143                a-x: dep-a-and-x1144                {a,b}-y: dep-ab-and-y1145        """1146        configs = newconfig([], inisource).envconfigs1147        get_deps = lambda env: [dep.name for dep in configs[env].deps]1148        assert get_deps("a-x") == ["dep-a-or-b", "dep-a-and-x"]1149        assert get_deps("a-y") == ["dep-a-or-b", "dep-ab-and-y"]1150        assert get_deps("b-x") == ["dep-a-or-b"]1151        assert get_deps("b-y") == ["dep-a-or-b", "dep-ab-and-y"]1152    def test_default_factors(self, newconfig):1153        inisource = """1154            [tox]1155            envlist = py{26,27,33,34}-dep1156            [testenv]1157            deps=1158                dep: dep1159        """1160        conf = newconfig([], inisource)1161        configs = conf.envconfigs1162        for name, config in configs.items():1163            assert config.basepython == 'python%s.%s' % (name[2], name[3])1164    @pytest.mark.issue1881165    def test_factors_in_boolean(self, newconfig):1166        inisource = """1167            [tox]1168            envlist = py{27,33}1169            [testenv]1170            recreate =1171                py27: True1172        """1173        configs = newconfig([], inisource).envconfigs1174        assert configs["py27"].recreate1175        assert not configs["py33"].recreate1176    @pytest.mark.issue1901177    def test_factors_in_setenv(self, newconfig):1178        inisource = """1179            [tox]1180            envlist = py27,py261181            [testenv]1182            setenv =1183                py27: X = 11184        """1185        configs = newconfig([], inisource).envconfigs1186        assert configs["py27"].setenv["X"] == "1"1187        assert "X" not in configs["py26"].setenv1188    @pytest.mark.issue1911189    def test_factor_use_not_checked(self, newconfig):1190        inisource = """1191            [tox]1192            envlist = py27-{a,b}1193            [testenv]1194            deps = b: test1195        """1196        configs = newconfig([], inisource).envconfigs1197        assert set(configs.keys()) == set(['py27-a', 'py27-b'])1198    @pytest.mark.issue1981199    def test_factors_groups_touch(self, newconfig):1200        inisource = """1201            [tox]1202            envlist = {a,b}{-x,}1203            [testenv]1204            deps=1205                a,b,x,y: dep1206        """1207        configs = newconfig([], inisource).envconfigs1208        assert set(configs.keys()) == set(['a', 'a-x', 'b', 'b-x'])1209    def test_period_in_factor(self, newconfig):1210        inisource = """1211            [tox]1212            envlist = py27-{django1.6,django1.7}1213            [testenv]1214            deps =1215                django1.6: Django==1.61216                django1.7: Django==1.71217        """1218        configs = newconfig([], inisource).envconfigs1219        assert sorted(configs) == ["py27-django1.6", "py27-django1.7"]1220        assert [d.name for d in configs["py27-django1.6"].deps] \1221            == ["Django==1.6"]1222    def test_ignore_outcome(self, newconfig):1223        inisource = """1224            [testenv]1225            ignore_outcome=True1226        """1227        config = newconfig([], inisource).envconfigs1228        assert config["python"].ignore_outcome is True1229class TestGlobalOptions:1230    def test_notest(self, newconfig):1231        config = newconfig([], "")1232        assert not config.option.notest1233        config = newconfig(["--notest"], "")1234        assert config.option.notest1235    def test_verbosity(self, newconfig):1236        config = newconfig([], "")1237        assert config.option.verbosity == 01238        config = newconfig(["-v"], "")1239        assert config.option.verbosity == 11240        config = newconfig(["-vv"], "")1241        assert config.option.verbosity == 21242    def test_substitution_jenkins_default(self, tmpdir,1243                                          monkeypatch, newconfig):1244        monkeypatch.setenv("HUDSON_URL", "xyz")1245        config = newconfig("""1246            [testenv:py27]1247            commands =1248                {distshare}1249        """)1250        conf = config.envconfigs['py27']1251        argv = conf.commands1252        expect_path = config.toxworkdir.join("distshare")1253        assert argv[0][0] == expect_path1254    def test_substitution_jenkins_context(self, tmpdir, monkeypatch, newconfig):1255        monkeypatch.setenv("HUDSON_URL", "xyz")1256        monkeypatch.setenv("WORKSPACE", tmpdir)1257        config = newconfig("""1258            [tox:jenkins]1259            distshare = {env:WORKSPACE}/hello1260            [testenv:py27]1261            commands =1262                {distshare}1263        """)1264        conf = config.envconfigs['py27']1265        argv = conf.commands1266        assert argv[0][0] == config.distshare1267        assert config.distshare == tmpdir.join("hello")1268    def test_sdist_specification(self, tmpdir, newconfig):1269        config = newconfig("""1270            [tox]1271            sdistsrc = {distshare}/xyz.zip1272        """)1273        assert config.sdistsrc == config.distshare.join("xyz.zip")1274        config = newconfig([], "")1275        assert not config.sdistsrc1276    def test_env_selection(self, tmpdir, newconfig, monkeypatch):1277        inisource = """1278            [tox]1279            envlist = py261280            [testenv:py26]1281            basepython=python2.61282            [testenv:py31]1283            basepython=python3.11284            [testenv:py27]1285            basepython=python2.71286        """1287        # py.test.raises(tox.exception.ConfigError,1288        #    "newconfig(['-exyz'], inisource)")1289        config = newconfig([], inisource)1290        assert config.envlist == ["py26"]1291        config = newconfig(["-epy31"], inisource)1292        assert config.envlist == ["py31"]1293        monkeypatch.setenv("TOXENV", "py31,py26")1294        config = newconfig([], inisource)1295        assert config.envlist == ["py31", "py26"]1296        monkeypatch.setenv("TOXENV", "ALL")1297        config = newconfig([], inisource)1298        assert config.envlist == ['py26', 'py27', 'py31']1299        config = newconfig(["-eALL"], inisource)1300        assert config.envlist == ['py26', 'py27', 'py31']1301    def test_py_venv(self, tmpdir, newconfig, monkeypatch):1302        config = newconfig(["-epy"], "")1303        env = config.envconfigs['py']1304        assert str(env.basepython) == sys.executable1305    def test_default_environments(self, tmpdir, newconfig, monkeypatch):1306        envs = "py26,py27,py32,py33,py34,py35,py36,jython,pypy,pypy3"1307        inisource = """1308            [tox]1309            envlist = %s1310        """ % envs1311        config = newconfig([], inisource)1312        envlist = envs.split(",")1313        assert config.envlist == envlist1314        for name in config.envlist:1315            env = config.envconfigs[name]1316            if name == "jython":1317                assert env.basepython == "jython"1318            elif name.startswith("pypy"):1319                assert env.basepython == name1320            else:1321                assert name.startswith("py")1322                bp = "python%s.%s" % (name[2], name[3])1323                assert env.basepython == bp1324    def test_envlist_expansion(self, newconfig):1325        inisource = """1326            [tox]1327            envlist = py{26,27},docs1328        """1329        config = newconfig([], inisource)1330        assert config.envlist == ["py26", "py27", "docs"]1331    def test_envlist_cross_product(self, newconfig):1332        inisource = """1333            [tox]1334            envlist = py{26,27}-dep{1,2}1335        """1336        config = newconfig([], inisource)1337        assert config.envlist == \1338            ["py26-dep1", "py26-dep2", "py27-dep1", "py27-dep2"]1339    def test_envlist_multiline(self, newconfig):1340        inisource = """1341            [tox]1342            envlist =1343              py271344              py341345        """1346        config = newconfig([], inisource)1347        assert config.envlist == \1348            ["py27", "py34"]1349    def test_minversion(self, tmpdir, newconfig, monkeypatch):1350        inisource = """1351            [tox]1352            minversion = 10.01353        """1354        with py.test.raises(tox.exception.MinVersionError):1355            newconfig([], inisource)1356    def test_skip_missing_interpreters_true(self, tmpdir, newconfig, monkeypatch):1357        inisource = """1358            [tox]1359            skip_missing_interpreters = True1360        """1361        config = newconfig([], inisource)1362        assert config.option.skip_missing_interpreters1363    def test_skip_missing_interpreters_false(self, tmpdir, newconfig, monkeypatch):1364        inisource = """1365            [tox]1366            skip_missing_interpreters = False1367        """1368        config = newconfig([], inisource)1369        assert not config.option.skip_missing_interpreters1370    def test_defaultenv_commandline(self, tmpdir, newconfig, monkeypatch):1371        config = newconfig(["-epy27"], "")1372        env = config.envconfigs['py27']1373        assert env.basepython == "python2.7"1374        assert not env.commands1375    def test_defaultenv_partial_override(self, tmpdir, newconfig, monkeypatch):1376        inisource = """1377            [tox]1378            envlist = py271379            [testenv:py27]1380            commands= xyz1381        """1382        config = newconfig([], inisource)1383        env = config.envconfigs['py27']1384        assert env.basepython == "python2.7"1385        assert env.commands == [['xyz']]1386class TestHashseedOption:1387    def _get_envconfigs(self, newconfig, args=None, tox_ini=None,1388                        make_hashseed=None):1389        if args is None:1390            args = []1391        if tox_ini is None:1392            tox_ini = """1393                [testenv]1394            """1395        if make_hashseed is None:1396            make_hashseed = lambda: '123456789'1397        original_make_hashseed = tox.config.make_hashseed1398        tox.config.make_hashseed = make_hashseed1399        try:1400            config = newconfig(args, tox_ini)1401        finally:1402            tox.config.make_hashseed = original_make_hashseed1403        return config.envconfigs1404    def _get_envconfig(self, newconfig, args=None, tox_ini=None):1405        envconfigs = self._get_envconfigs(newconfig, args=args,1406                                          tox_ini=tox_ini)1407        return envconfigs["python"]1408    def _check_hashseed(self, envconfig, expected):1409        assert envconfig.setenv['PYTHONHASHSEED'] == expected1410    def _check_testenv(self, newconfig, expected, args=None, tox_ini=None):1411        envconfig = self._get_envconfig(newconfig, args=args, tox_ini=tox_ini)1412        self._check_hashseed(envconfig, expected)1413    def test_default(self, tmpdir, newconfig):1414        self._check_testenv(newconfig, '123456789')1415    def test_passing_integer(self, tmpdir, newconfig):1416        args = ['--hashseed', '1']1417        self._check_testenv(newconfig, '1', args=args)1418    def test_passing_string(self, tmpdir, newconfig):1419        args = ['--hashseed', 'random']1420        self._check_testenv(newconfig, 'random', args=args)1421    def test_passing_empty_string(self, tmpdir, newconfig):1422        args = ['--hashseed', '']1423        self._check_testenv(newconfig, '', args=args)1424    @pytest.mark.xfail(sys.version_info >= (3, 2),1425                       reason="at least Debian python 3.2/3.3 have a bug: "1426                              "http://bugs.python.org/issue11884")1427    def test_passing_no_argument(self, tmpdir, newconfig):1428        """Test that passing no arguments to --hashseed is not allowed."""1429        args = ['--hashseed']1430        try:1431            self._check_testenv(newconfig, '', args=args)1432        except SystemExit:1433            e = sys.exc_info()[1]1434            assert e.code == 21435            return1436        assert False  # getting here means we failed the test.1437    def test_setenv(self, tmpdir, newconfig):1438        """Check that setenv takes precedence."""1439        tox_ini = """1440            [testenv]1441            setenv =1442                PYTHONHASHSEED = 21443        """1444        self._check_testenv(newconfig, '2', tox_ini=tox_ini)1445        args = ['--hashseed', '1']1446        self._check_testenv(newconfig, '2', args=args, tox_ini=tox_ini)1447    def test_noset(self, tmpdir, newconfig):1448        args = ['--hashseed', 'noset']1449        envconfig = self._get_envconfig(newconfig, args=args)1450        assert not envconfig.setenv.definitions1451    def test_noset_with_setenv(self, tmpdir, newconfig):1452        tox_ini = """1453            [testenv]1454            setenv =1455                PYTHONHASHSEED = 21456        """1457        args = ['--hashseed', 'noset']1458        self._check_testenv(newconfig, '2', args=args, tox_ini=tox_ini)1459    def test_one_random_hashseed(self, tmpdir, newconfig):1460        """Check that different testenvs use the same random seed."""1461        tox_ini = """1462            [testenv:hash1]1463            [testenv:hash2]1464        """1465        next_seed = [1000]1466        # This function is guaranteed to generate a different value each time.1467        def make_hashseed():1468            next_seed[0] += 11469            return str(next_seed[0])1470        # Check that make_hashseed() works.1471        assert make_hashseed() == '1001'1472        envconfigs = self._get_envconfigs(newconfig, tox_ini=tox_ini,1473                                          make_hashseed=make_hashseed)1474        self._check_hashseed(envconfigs["hash1"], '1002')1475        # Check that hash2's value is not '1003', for example.1476        self._check_hashseed(envconfigs["hash2"], '1002')1477    def test_setenv_in_one_testenv(self, tmpdir, newconfig):1478        """Check using setenv in one of multiple testenvs."""1479        tox_ini = """1480            [testenv:hash1]1481            setenv =1482                PYTHONHASHSEED = 21483            [testenv:hash2]1484        """1485        envconfigs = self._get_envconfigs(newconfig, tox_ini=tox_ini)1486        self._check_hashseed(envconfigs["hash1"], '2')1487        self._check_hashseed(envconfigs["hash2"], '123456789')1488class TestSetenv:1489    def test_getdict_lazy(self, tmpdir, newconfig, monkeypatch):1490        monkeypatch.setenv("X", "2")1491        config = newconfig("""1492            [testenv:X]1493            key0 =1494                key1 = {env:X}1495                key2 = {env:Y:1}1496        """)1497        envconfig = config.envconfigs["X"]1498        val = envconfig._reader.getdict_setenv("key0")1499        assert val["key1"] == "2"1500        assert val["key2"] == "1"1501    def test_getdict_lazy_update(self, tmpdir, newconfig, monkeypatch):1502        monkeypatch.setenv("X", "2")1503        config = newconfig("""1504            [testenv:X]1505            key0 =1506                key1 = {env:X}1507                key2 = {env:Y:1}1508        """)1509        envconfig = config.envconfigs["X"]1510        val = envconfig._reader.getdict_setenv("key0")1511        d = {}1512        d.update(val)1513        assert d == {"key1": "2", "key2": "1"}1514    def test_setenv_uses_os_environ(self, tmpdir, newconfig, monkeypatch):1515        monkeypatch.setenv("X", "1")1516        config = newconfig("""1517            [testenv:env1]1518            setenv =1519                X = {env:X}1520        """)1521        assert config.envconfigs["env1"].setenv["X"] == "1"1522    def test_setenv_default_os_environ(self, tmpdir, newconfig, monkeypatch):1523        monkeypatch.delenv("X", raising=False)1524        config = newconfig("""1525            [testenv:env1]1526            setenv =1527                X = {env:X:2}1528        """)1529        assert config.envconfigs["env1"].setenv["X"] == "2"1530    def test_setenv_uses_other_setenv(self, tmpdir, newconfig):1531        config = newconfig("""1532            [testenv:env1]1533            setenv =1534                Y = 51535                X = {env:Y}1536        """)1537        assert config.envconfigs["env1"].setenv["X"] == "5"1538    def test_setenv_recursive_direct(self, tmpdir, newconfig):1539        config = newconfig("""1540            [testenv:env1]1541            setenv =1542                X = {env:X:3}1543        """)1544        assert config.envconfigs["env1"].setenv["X"] == "3"1545    def test_setenv_overrides(self, tmpdir, newconfig):1546        config = newconfig("""1547            [testenv]1548            setenv =1549                PYTHONPATH = something1550                ANOTHER_VAL=else1551        """)1552        assert len(config.envconfigs) == 11553        envconfig = config.envconfigs['python']1554        assert 'PYTHONPATH' in envconfig.setenv1555        assert 'ANOTHER_VAL' in envconfig.setenv1556        assert envconfig.setenv['PYTHONPATH'] == 'something'1557        assert envconfig.setenv['ANOTHER_VAL'] == 'else'1558    def test_setenv_with_envdir_and_basepython(self, tmpdir, newconfig):1559        config = newconfig("""1560            [testenv]1561            setenv =1562                VAL = {envdir}1563            basepython = {env:VAL}1564        """)1565        assert len(config.envconfigs) == 11566        envconfig = config.envconfigs['python']1567        assert 'VAL' in envconfig.setenv1568        assert envconfig.setenv['VAL'] == envconfig.envdir1569        assert envconfig.basepython == envconfig.envdir1570    def test_setenv_ordering_1(self, tmpdir, newconfig):1571        config = newconfig("""1572            [testenv]1573            setenv=1574                VAL={envdir}1575            commands=echo {env:VAL}1576        """)1577        assert len(config.envconfigs) == 11578        envconfig = config.envconfigs['python']1579        assert 'VAL' in envconfig.setenv1580        assert envconfig.setenv['VAL'] == envconfig.envdir1581        assert str(envconfig.envdir) in envconfig.commands[0]1582    def test_setenv_cross_section_subst_issue294(self, monkeypatch, newconfig):1583        """test that we can do cross-section substitution with setenv"""1584        monkeypatch.delenv('TEST', raising=False)1585        config = newconfig("""1586            [section]1587            x =1588              NOT_TEST={env:TEST:defaultvalue}1589            [testenv]1590            setenv = {[section]x}1591        """)1592        envconfig = config.envconfigs["python"]1593        assert envconfig.setenv["NOT_TEST"] == "defaultvalue"1594    def test_setenv_cross_section_subst_twice(self, monkeypatch, newconfig):1595        """test that we can do cross-section substitution with setenv"""1596        monkeypatch.delenv('TEST', raising=False)1597        config = newconfig("""1598            [section]1599            x = NOT_TEST={env:TEST:defaultvalue}1600            [section1]1601            y = {[section]x}1602            [testenv]1603            setenv = {[section1]y}1604        """)1605        envconfig = config.envconfigs["python"]1606        assert envconfig.setenv["NOT_TEST"] == "defaultvalue"1607    def test_setenv_cross_section_mixed(self, monkeypatch, newconfig):1608        """test that we can do cross-section substitution with setenv"""1609        monkeypatch.delenv('TEST', raising=False)1610        config = newconfig("""1611            [section]1612            x = NOT_TEST={env:TEST:defaultvalue}1613            [testenv]1614            setenv = {[section]x}1615                     y = 71616        """)1617        envconfig = config.envconfigs["python"]1618        assert envconfig.setenv["NOT_TEST"] == "defaultvalue"1619        assert envconfig.setenv["y"] == "7"1620class TestIndexServer:1621    def test_indexserver(self, tmpdir, newconfig):1622        config = newconfig("""1623            [tox]1624            indexserver =1625                name1 = XYZ1626                name2 = ABC1627        """)1628        assert config.indexserver['default'].url is None1629        assert config.indexserver['name1'].url == "XYZ"1630        assert config.indexserver['name2'].url == "ABC"1631    def test_parse_indexserver(self, newconfig):1632        inisource = """1633            [tox]1634            indexserver =1635                default = http://pypi.testrun.org1636                name1 = whatever1637        """1638        config = newconfig([], inisource)1639        assert config.indexserver['default'].url == "http://pypi.testrun.org"1640        assert config.indexserver['name1'].url == "whatever"1641        config = newconfig(['-i', 'qwe'], inisource)1642        assert config.indexserver['default'].url == "qwe"1643        assert config.indexserver['name1'].url == "whatever"1644        config = newconfig(['-i', 'name1=abc', '-i', 'qwe2'], inisource)1645        assert config.indexserver['default'].url == "qwe2"1646        assert config.indexserver['name1'].url == "abc"1647        config = newconfig(["-i", "ALL=xzy"], inisource)1648        assert len(config.indexserver) == 21649        assert config.indexserver["default"].url == "xzy"1650        assert config.indexserver["name1"].url == "xzy"1651    def test_multiple_homedir_relative_local_indexservers(self, newconfig):1652        inisource = """1653            [tox]1654            indexserver =1655                default = file://{homedir}/.pip/downloads/simple1656                local1  = file://{homedir}/.pip/downloads/simple1657                local2  = file://{toxinidir}/downloads/simple1658                pypi    = http://pypi.python.org/simple1659        """1660        config = newconfig([], inisource)1661        expected = "file://%s/.pip/downloads/simple" % config.homedir1662        assert config.indexserver['default'].url == expected1663        assert config.indexserver['local1'].url == config.indexserver['default'].url1664class TestParseEnv:1665    def test_parse_recreate(self, newconfig):1666        inisource = ""1667        config = newconfig([], inisource)1668        assert not config.envconfigs['python'].recreate1669        config = newconfig(['--recreate'], inisource)1670        assert config.envconfigs['python'].recreate1671        config = newconfig(['-r'], inisource)1672        assert config.envconfigs['python'].recreate1673        inisource = """1674            [testenv:hello]1675            recreate = True1676        """1677        config = newconfig([], inisource)1678        assert config.envconfigs['hello'].recreate1679class TestCmdInvocation:1680    def test_help(self, cmd):1681        result = cmd.run("tox", "-h")1682        assert not result.ret1683        result.stdout.fnmatch_lines([1684            "*help*",1685        ])1686    def test_version(self, cmd):1687        result = cmd.run("tox", "--version")1688        assert not result.ret1689        stdout = result.stdout.str()1690        assert tox.__version__ in stdout1691        assert "imported from" in stdout1692    def test_listenvs(self, cmd, initproj):1693        initproj('listenvs', filedefs={1694            'tox.ini': '''1695            [tox]1696            envlist=py26,py27,py33,pypy,docs1697            [testenv:notincluded]1698            changedir = whatever1699            [testenv:docs]1700            changedir = docs1701            ''',1702        })1703        result = cmd.run("tox", "-l")1704        result.stdout.fnmatch_lines("""1705            *py26*1706            *py27*1707            *py33*1708            *pypy*1709            *docs*1710        """)1711    def test_config_specific_ini(self, tmpdir, cmd):1712        ini = tmpdir.ensure("hello.ini")1713        result = cmd.run("tox", "-c", ini, "--showconfig")1714        assert not result.ret1715        result.stdout.fnmatch_lines([1716            "*config-file*hello.ini*",1717        ])1718    def test_no_tox_ini(self, cmd, initproj):1719        initproj("noini-0.5", )1720        result = cmd.run("tox")1721        assert result.ret1722        result.stderr.fnmatch_lines([1723            "*ERROR*tox.ini*not*found*",1724        ])1725    def test_override_workdir(self, tmpdir, cmd, initproj):1726        baddir = "badworkdir-123"1727        gooddir = "overridden-234"1728        initproj("overrideworkdir-0.5", filedefs={1729            'tox.ini': '''1730            [tox]1731            toxworkdir=%s1732            ''' % baddir,1733        })1734        result = cmd.run("tox", "--workdir", gooddir, "--showconfig")1735        assert not result.ret1736        stdout = result.stdout.str()1737        assert gooddir in stdout1738        assert baddir not in stdout1739        assert py.path.local(gooddir).check()1740        assert not py.path.local(baddir).check()1741    def test_showconfig_with_force_dep_version(self, cmd, initproj):1742        initproj('force_dep_version', filedefs={1743            'tox.ini': '''1744            [tox]1745            [testenv]1746            deps=1747                dep1==2.31748                dep21749            ''',1750        })1751        result = cmd.run("tox", "--showconfig")1752        assert result.ret == 01753        result.stdout.fnmatch_lines([1754            r'*deps*dep1==2.3, dep2*',1755        ])1756        # override dep1 specific version, and force version for dep21757        result = cmd.run("tox", "--showconfig", "--force-dep=dep1",1758                         "--force-dep=dep2==5.0")1759        assert result.ret == 01760        result.stdout.fnmatch_lines([1761            r'*deps*dep1, dep2==5.0*',1762        ])1763@pytest.mark.parametrize("cmdline,envlist", [1764    ("-e py26", ['py26']),1765    ("-e py26,py33", ['py26', 'py33']),1766    ("-e py26,py26", ['py26', 'py26']),1767    ("-e py26,py33 -e py33,py27", ['py26', 'py33', 'py33', 'py27'])1768])1769def test_env_spec(cmdline, envlist):1770    args = cmdline.split()1771    config = parseconfig(args)1772    assert config.envlist == envlist1773class TestCommandParser:1774    def test_command_parser_for_word(self):1775        p = CommandParser('word')1776        # import pytest; pytest.set_trace()1777        assert list(p.words()) == ['word']1778    def test_command_parser_for_posargs(self):1779        p = CommandParser('[]')1780        assert list(p.words()) == ['[]']1781    def test_command_parser_for_multiple_words(self):1782        p = CommandParser('w1 w2 w3 ')1783        assert list(p.words()) == ['w1', ' ', 'w2', ' ', 'w3']1784    def test_command_parser_for_substitution_with_spaces(self):1785        p = CommandParser('{sub:something with spaces}')1786        assert list(p.words()) == ['{sub:something with spaces}']1787    def test_command_parser_with_complex_word_set(self):1788        complex_case = (1789            'word [] [literal] {something} {some:other thing} w{ord} w{or}d w{ord} '1790            'w{o:rd} w{o:r}d {w:or}d w[]ord {posargs:{a key}}')1791        p = CommandParser(complex_case)1792        parsed = list(p.words())1793        expected = [1794            'word', ' ', '[]', ' ', '[literal]', ' ', '{something}', ' ', '{some:other thing}',1795            ' ', 'w', '{ord}', ' ', 'w', '{or}', 'd', ' ', 'w', '{ord}', ' ', 'w', '{o:rd}', ' ',1796            'w', '{o:r}', 'd', ' ', '{w:or}', 'd',1797            ' ', 'w[]ord', ' ', '{posargs:{a key}}',1798        ]1799        assert parsed == expected1800    def test_command_with_runs_of_whitespace(self):1801        cmd = "cmd1 {item1}\n  {item2}"1802        p = CommandParser(cmd)1803        parsed = list(p.words())1804        assert parsed == ['cmd1', ' ', '{item1}', '\n  ', '{item2}']1805    def test_command_with_split_line_in_subst_arguments(self):1806        cmd = dedent(""" cmd2 {posargs:{item2}1807                         other}""")1808        p = CommandParser(cmd)1809        parsed = list(p.words())1810        assert parsed == ['cmd2', ' ', '{posargs:{item2}\n                        other}']1811    def test_command_parsing_for_issue_10(self):1812        cmd = "nosetests -v -a !deferred --with-doctest []"1813        p = CommandParser(cmd)1814        parsed = list(p.words())1815        assert parsed == [1816            'nosetests', ' ', '-v', ' ', '-a', ' ', '!deferred', ' ',1817            '--with-doctest', ' ', '[]'1818        ]1819    @pytest.mark.skipif("sys.platform != 'win32'")1820    def test_commands_with_backslash(self, newconfig):1821        config = newconfig([r"hello\world"], """1822            [testenv:py26]1823            commands = some {posargs}1824        """)1825        envconfig = config.envconfigs["py26"]...

commands.py

Source:commands.py

1"""2    lager.exec.commands3    Run commands in a docker container4"""5import subprocess6import platform7import os8import click9from ..config import (10    write_config_file,11    get_global_config_file_path,12    add_devenv_command,13    get_devenv_config,14    DEVENV_SECTION_NAME,15    LAGER_CONFIG_FILE_NAME,16)17from ..context import get_ci_environment, CIEnvironment, is_container_ci18from ..paramtypes import EnvVarType19def _run_command_host(section, path, cmd_to_run, mount, extra_args, debug, interactive, tty, user, group, macaddr, hostname, env, passenv):20    """21        Run a command from the host (which means, run it in a docker container)22    """23    full_command = ' '.join((cmd_to_run, *extra_args)).strip()24    image = section.get('image')25    source_dir = os.path.dirname(path)26    mount_dir = section.get('mount_dir')27    shell = section.get('shell')28    if debug:29        click.echo(full_command, err=True)30    env_vars = [var for var in os.environ if var.startswith('LAGER')]31    env_strings = [f'--env={var}={os.environ[var]}' for var in env_vars]32    base_command = ['docker', 'run', '--rm']33    if interactive:34        base_command.append('-i')35    if tty:36        base_command.append('-t')37    base_command.extend(env_strings)38    user_group_string = ''39    if user:40        user_group_string += user41    if group:42        user_group_string += f':{group}'43    if user_group_string:44        base_command.extend(['-u', user_group_string])45    global_config_path = get_global_config_file_path()46    if os.path.exists(global_config_path):47        base_command.extend([48            '--env=LAGER_CONFIG_FILE_DIR=/lager',49            '-v',50            f'{global_config_path}:/lager/{LAGER_CONFIG_FILE_NAME}'51        ])52    if mount:53        base_command.extend([54            '--mount',55            f'source={mount},target={mount_dir}',56        ])57    else:58        base_command.extend([59            '-v',60            f'{source_dir}:{mount_dir}',61        ])62    if macaddr:63        base_command.append(f'--mac-address={macaddr}')64    if hostname:65        base_command.append(f'--hostname={hostname}')66    for env_var in env:67        base_command.append(f'--env={env_var}')68    for var_name in passenv:69        if var_name in os.environ:70            base_command.append(f'--env={var_name}={os.environ[var_name]}')71    base_command.extend([72        '-w',73        mount_dir,74        image,75        shell,76        '-c',77        full_command78    ])79    proc = subprocess.run(base_command, check=False)80    return proc.returncode81def _run_command_container(section, cmd_to_run, extra_args, debug):82    """83        Run a command directly - assume we are in a container with all necessary software84        installed already.85    """86    shell = section.get('shell')87    full_command = ' '.join((cmd_to_run, *extra_args))88    if debug:89        click.echo(full_command, err=True)90    proc = subprocess.run([shell, '-c', full_command], check=False)91    return proc.returncode92def _run_command(section, path, cmd_to_run, mount, extra_args, debug, interactive, tty, user, group, macaddr, hostname, env, passenv):93    ci_env = get_ci_environment()94    if is_container_ci(ci_env):95        return _run_command_container(section, cmd_to_run, extra_args, debug)96    if ci_env in (CIEnvironment.HOST, CIEnvironment.JENKINS):97        return _run_command_host(section, path, cmd_to_run, mount, extra_args, debug, interactive, tty, user, group, macaddr, hostname, env, passenv)98    raise ValueError(f'Unknown CI environment {ci_env}')99@click.command(name='exec', context_settings={"ignore_unknown_options": True})100@click.pass_context101@click.argument('cmd_name', required=False, metavar='COMMAND')102@click.argument('extra_args', required=False, nargs=-1, metavar='EXTRA_ARGS')103@click.option('--command', help='Raw commandline to execute in docker container', metavar='\'<cmdline>\'')104@click.option('--save-as', default=None, help='Alias under which to save command specified with --command', metavar='<alias>', show_default=True)105@click.option('--warn/--no-warn', default=True, help='Whether to print a warning if overwriting an existing command.', show_default=True)106@click.option(107    '--env',108    multiple=True, type=EnvVarType(), help='Environment variables to set for the python script. '109    'Format is `--env FOO=BAR` - this will set an environment varialbe named `FOO` to the value `BAR`')110@click.option(111    '--passenv',112    multiple=True, help='Environment variables to inherit from the current environment and pass to the python script. '113    'This option is useful for secrets, tokens, passwords, or any other values that you do not want to appear on the '114    'command line. Example: `--passenv FOO` will set an environment variable named `FOO` in the python script to the value'115    'of `FOO` in the current environment.')116@click.option('--mount', '-m', help='Name of volume to mount', required=False)117@click.option('--interactive/--no-interactive', '-i', is_flag=True, help='Keep STDIN open even if not attached', default=True, show_default=True)118@click.option('--tty/--no-tty', '-t', is_flag=True, help='Allocate a pseudo-TTY', default=True, show_default=True)119@click.option('--user', '-u', help='User to run as in container', default=None)120@click.option('--group', '-g', help='Group to run as in container', default=None)121def exec_(ctx, cmd_name, extra_args, command, save_as, warn, env, passenv, mount, interactive, tty, user, group):122    """123        Execute COMMAND in a docker container. COMMAND is a named command which was previously saved using `--save-as`.124        If COMMAND is not provided, execute the command specified by --command. If --save-as is also provided,125        save the command under that name for later use with COMMAND. If EXTRA_ARGS are provided they will be appended126        to the command at runtime127    """128    if not cmd_name and not command:129        click.echo(exec_.get_help(ctx))130        ctx.exit(0)131    if user is None:132        try:133            user = str(os.getuid())134        except AttributeError:135            pass136    if group is None:137        try:138            group = str(os.getgid())139        except AttributeError:140            pass141    path, config = get_devenv_config()142    section = config[DEVENV_SECTION_NAME]143    if 'user' in section:144        user = section['user']145    if 'group' in section:146        group = section['group']147    macaddr = None148    if 'macaddr' in section:149        macaddr = section['macaddr']150    hostname = None151    if 'hostname' in section:152        hostname = section['hostname']153    if cmd_name and command:154        osname = platform.system()155        if osname == 'Windows':156            msg = 'If the command contains spaces, please wrap it in double quotes e.g. lager exec --command "ls -la"'157        else:158            msg = 'If the command contains spaces, please wrap it in single quotes e.g. lager exec --command \'ls -la\''159        raise click.UsageError(160            f'Cannot specify a command name and a command\n{msg}'161        )162    if cmd_name:163        key = f'cmd.{cmd_name}'164        if key not in section:165            raise click.UsageError(166                f'Command `{cmd_name}` not found',167            )168        cmd_to_run = section.get(key)169    else:170        cmd_to_run = command171        if save_as:172            add_devenv_command(section, save_as, cmd_to_run, warn)173            write_config_file(config, path)174    returncode = _run_command(section, path, cmd_to_run, mount, extra_args, ctx.obj.debug, interactive, tty, user, group, macaddr, hostname, env, passenv)...

private_registry.py

Source:private_registry.py

1import os2import re3import base644import subprocess as sp5import requests as req6from pandas import DataFrame7from getpass import getpass8# import kivy9# kivy.require('1.0.6') # replace with your current kivy version !10# from kivy.app import App11# from kivy.uix.label import Label12# TODO: setup GUI to get input and display table of results; 13# See kivy for GUI: https://kivy.org/doc/stable/14# TODO: install password store and configure client environment to use password store15# TODO: install docker credentials helper in password store16class registry(object):17    #####################################################################18    def __init__(self, raw_url=None or str,username=None or str,passenv=None or str,passwd=None or str) -> None:19        """20        ## Docker Private Registry Tool:21        Interact with your private docker registry using this tool.  22        - access registry23        - print contents of private registry24        #### Create 3 environmentals in on your system for 25        - the private registry url environment variable26        - the private registry username environment variable27        - the private registry password store token environment variable28        :param raw_url: the private registry url environment variable29        :param username: the private registry username environment variable30        :param passenv: the private registry password store token environment variable31        :param passwd: the base64 encoded password string32        """33        try:34            raw_url = os.environ[raw_url]35            username = os.environ[username]36            passenv = os.environ[passenv]37            # print('URL: {}\nUSER: {}\nPASSENV: {}\n'.format(raw_url,username,passenv))38            self.raw_url = raw_url39            self.username = username40            self.passenv = passenv41            self.passwd = passwd42            # print('password: {}'.format(passwd))43            # super().__init__()44        except OSError as err:45            print('\nTheir was an error in your environment variable; parameter 2. \n{}'.format(err))46        except Exception as err: # last line of defense47            print('\nAn exception has occured.\n{}'.format(err))48    #####################################################################    49    def get_registry(self,raw_url=None,username=None,passenv=None) -> DataFrame:50        """51        Gets the contents of your private container registry and organizes them into a table.52        This function uses "pass" as its password store. It takes your password store path to user password and accesses your password store securely.53        54        :param raw_url: the private registry url environment variable55        :param username: the private registry username environment variable56        :param passenv: the private registry password store token environment variable57        """58        tbl = []59        raw_url = self.raw_url if raw_url is None else os.environ[raw_url]60        username = self.username if username is None else os.environ[username]61        passenv = self.passenv if passenv is None else os.environ[passenv]62        try:63            ##############################################################64            url = raw_url if re.search('/v2', raw_url) else '{}/v2'.format(raw_url)65            # rauth = passenv if os.environ[passenv] is None else os.environ[passenv]66            rauth = passenv if re.search('docker-credential-helpers',passenv) else os.environ[passenv]67            # print('Docker Credential Token: {}\n'.format(rauth))68            # we are using a password store to access passwords on needed69            passwd = sp.check_output(["pass", rauth])70            passwd = passwd.decode("utf-8")71            # username = input("Enter Username: ")72            # passw = getpass("Enter Password: ")73            # print(passwd)74            uauth = (username,passwd)75            catelog = '{}/_catalog/'.format(url)76            # print(catelog)77            catelog = req.get(catelog, auth=uauth,timeout=(5, 10))   78            # print(catelog.json())79            for a in catelog.json()['repositories']:80                # print(a)81                item_details = '{0}/{1}/tags/list/'.format(url,a)82                rsp = req.get(item_details, auth=uauth)83                json_rsp = rsp.json()84                # print(json_rsp)85                tbl.append(json_rsp)86                # print('[{} => {}]'.format(json_rsp['name'], json_rsp['tags']))87            # print(tbl)88            df = DataFrame(data=tbl)89            print('\n{}\n'.format(df))90            return df91        except req.exceptions.TooManyRedirects as err:92            print('{}'.format(err))93        except req.exceptions.ConnectionError as err:94            print('\nSorry, unable to connect to {}.\n\n{}'.format(raw_url,err))     95        except req.exceptions.URLRequired as err:96            print('{}'.format(err))97        except req.exceptions.StreamConsumedError as err:98            print('{}'.format(err))99        except req.exceptions.ConnectTimeout as err:100            print('{}'.format(err))101        except req.exceptions.HTTPError as err:102            print('{}'.format(err))103        except req.exceptions.RequestException as err:104            print('{}'.format(err))105        except req.exceptions.Timeout as err:106            print('\nI\'m so sorry but the server request timed out...\n\n{}'.format(err))107        except OSError as err:108            print('\nTheir was an error in your environment variable; parameter 2. \n{}'.format(err))109        except KeyError as err:110            print(f'\nThe environment variable {err} does not match any found in our system.\n')111        except Exception as err: # last line of defense112            print('\nAn exception has occured.\n\n{}'.format(err))113    #####################################################################114#########################################################################115if __name__ == '__main__':116    # Create 3 environmentals in on your system for 117    # - the private registry url118    # - the private registry username119    # - the private registry password store token120    # Gets a table of your private registry objects121    url = 'PRIVATE_REGISTRY_URL'122    usr = 'PRIVATE_REGISTRY_USER'123    envpass = 'PRIVATE_REGISTRY_AUTH'124    reg = registry(url,usr,envpass)...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.