def mk_python(basename, prefix=None, base_prefix=None, executable=True, content=None, folder=None, version=None): if version is None: m = RE_VERSION.match(basename) if m: if not folder: folder = os.path.join(".pyenv/versions", basename) version = m.group(2) basename = "python" if not folder: folder = ".pyenv/versions" path = runez.resolved_path(folder) if not prefix: prefix = path if not base_prefix: base_prefix = prefix path = os.path.join(path, "bin", basename) if not content: content = [version, prefix, base_prefix] content = "#!/bin/bash\n%s\n" % "\n".join("echo %s" % s for s in content) runez.write(path, content, logger=None) if executable: runez.make_executable(path, logger=None)
def test_ensure_freeze(_, __, temp_base): # Test edge case for _installed_module() with SoftLock(temp_base) as lock: fake_pex = os.path.join(temp_base, "bin/pex") runez.touch(fake_pex) runez.make_executable(fake_pex) v = SharedVenv(lock, None) assert v._installed_module("pex")
def __init__(self, cfg, name, version): self.cfg = cfg self.name = name self.version = version self.entry_points = {name: name} self.pspec = PackageSpec(cfg, name, version=version) self.pspec.save_manifest(self.entry_points) self.venv = PythonVenv(self.pspec, create=False) self.venv_exe = os.path.join(self.pspec.install_path, "bin", name) runez.write(self.venv_exe, "#!/bin/bash\necho %s" % version) runez.make_executable(self.venv_exe)
def _install(self, target, source): wrapper = PICKLEY_WRAPPER if self.package_name == system.PICKLEY else GENERIC_WRAPPER contents = wrapper.lstrip().format( hook=self.hook, bg=self.bg, name=runez.quoted(self.package_name), pickley=runez.quoted(system.SETTINGS.base.full_path( system.PICKLEY)), source=runez.quoted(source), ) runez.write(target, contents) runez.make_executable(target)
def test_executable(temp_folder): with runez.CaptureOutput(dryrun=True) as logged: assert runez.make_executable("some-file") == 1 assert "Would make some-file executable" in logged assert runez.touch("some-file") == 1 assert runez.make_executable("some-file") == 1 assert runez.is_executable("some-file") assert runez.make_executable("some-file") == 0 assert runez.delete("some-file") == 1 assert not runez.is_executable("some-file") with runez.CaptureOutput() as logged: assert runez.make_executable("/dev/null/some-file", fatal=False) == -1 assert "does not exist, can't make it executable" in logged
def test_wrapper(temp_base): repeater = os.path.join(temp_base, "repeat.sh") target = os.path.join(temp_base, system.PICKLEY) runez.write(repeater, "#!/bin/bash\n\necho :: $*\n") runez.make_executable(repeater) # Actual wrapper d = DeliveryMethodWrap(system.PackageSpec(system.PICKLEY)) d.install(target, repeater) assert runez.run(target, "auto-upgrade", "foo") == RunResult(":: auto-upgrade foo", "", 0) assert runez.run(target, "--debug", "auto-upgrade", "foo") == RunResult(":: --debug auto-upgrade foo", "", 0) assert runez.run(target, "settings", "-d") == RunResult(":: settings -d", "", 0) # Verify that we're triggering background auto-upgrade as expected d.hook = "echo " d.bg = "" d.install(target, repeater) result = runez.run(target, "settings", "-d") assert "nohup" in result.output assert "repeat.sh settings -d" in result.output result = runez.run(target, "auto-upgrade", "foo") assert "nohup" not in result.output assert "repeat.sh auto-upgrade foo" in result.output result = runez.run(target, "--debug", "auto-upgrade", "foo") assert "nohup" not in result.output assert "repeat.sh --debug auto-upgrade foo" in result.output runez.delete(repeater) result = runez.run(target, "foo", fatal=False) assert result.failed assert "Please reinstall with" in result.full_output assert os.path.exists(target) assert uninstall_existing(target, fatal=False) == 1 assert not os.path.exists(target)
def _install(self, pspec, target, source): pickley = pspec.cfg.base.full_path(PICKLEY) if pspec.dashed == PICKLEY: wrapper = PICKLEY_WRAPPER else: wrapper = GENERIC_WRAPPER if runez.DEV.project_folder and not os.path.exists(pickley): # We're running from development venv pickley = pspec.cfg.program_path contents = wrapper.lstrip().format( hook=self.hook, bg=self.bg, name=runez.quoted(pspec.dashed, adapter=None), pickley=runez.quoted(pickley, adapter=None), source=runez.quoted(source, adapter=None), ) runez.delete(target, logger=False) runez.write(target, contents, logger=False) runez.make_executable(target, logger=False)
def test_capture(temp_folder, logged): chatter = runez.resolved_path("chatter") assert runez.write(chatter, CHATTER.strip(), fatal=False) == 1 assert runez.make_executable(chatter, fatal=False) == 1 assert runez.run(chatter, fatal=False) == "chatter" r = runez.run(chatter, include_error=True, fatal=False) assert r.startswith("chatter") assert "No such file" in r assert "Running: chatter" in logged
def test_failed_read(*_): with runez.CaptureOutput() as logged: assert runez.get_lines("bar", fatal=False) is None assert "Can't read" in logged.pop() assert runez.write("bar", "some content", fatal=False) assert "Can't write" in logged.pop() assert runez.copy("some-file", "bar", fatal=False) == -1 assert "Can't delete" in logged assert "Can't copy" in logged.pop() assert runez.make_executable("some-file", fatal=False) == -1 assert "Can't chmod" in logged.pop()
def test_facultative(cli): runez.save_json({"pinned": { "virtualenv": { "facultative": True } }}, dot_meta("config.json")) # Empty file -> proceed with install as if it wasn't there runez.touch("virtualenv") cli.expect_success("-n install virtualenv", "Would state: Installed virtualenv") # Simulate pickley wrapper runez.write("virtualenv", "echo installed by pickley") runez.make_executable("virtualenv") cli.expect_success("-n install virtualenv", "Would state: Installed virtualenv") # Unknown executable -> skip pickley installation (since facultative) runez.write("virtualenv", "echo foo") runez.make_executable("virtualenv") cli.expect_success( "-n install virtualenv", "Skipping installation of virtualenv: not installed by pickley") cli.expect_success("-n check virtualenv", "skipped, not installed by pickley") # --force ignores 'facultative' setting cli.expect_failure("-n install --force virtualenv", "Can't automatically uninstall virtualenv") # Simulate pickley symlink delivery dummy_target = dot_meta("foo") runez.touch(dummy_target) runez.symlink(dummy_target, "virtualenv") cli.expect_success("-n install virtualenv", "Would state: Installed virtualenv")
def test_failure(monkeypatch): monkeypatch.setattr(io, "open", runez.conftest.exception_raiser()) monkeypatch.setattr(os, "unlink", runez.conftest.exception_raiser("bad unlink")) monkeypatch.setattr(shutil, "copy", runez.conftest.exception_raiser()) monkeypatch.setattr(os.path, "exists", lambda _: True) monkeypatch.setattr(os.path, "isfile", lambda _: True) monkeypatch.setattr(os.path, "getsize", lambda _: 10) with runez.CaptureOutput() as logged: with patch("runez.file._do_delete"): with patch("pathlib.Path.exists", return_value=True): assert runez.copy("some-file", "bar", fatal=False) == -1 assert "Can't copy" in logged.pop() assert runez.delete("some-file", fatal=False) == -1 assert "Can't delete" in logged assert "bad unlink" in logged.pop() assert runez.write("bar", "some content", fatal=False) assert "Can't write" in logged.pop() if not runez.SYS_INFO.platform_id.is_windows: assert runez.make_executable("some-file", fatal=False) == -1 assert "Can't chmod" in logged.pop()
def test_relocate_venv_successfully(temp_base): with runez.CaptureOutput() as logged: original = "line 1: source\nline 2\n" runez.write("foo/bar/bin/baz", original, logger=logging.debug) runez.write("foo/bar/bin/empty", "", logger=logging.debug) runez.write("foo/bar/bin/python", "", logger=logging.debug) runez.make_executable("foo/bar/bin/baz") runez.make_executable("foo/bar/bin/empty") runez.make_executable("foo/bar/bin/python") assert "Created" in logged.pop() # Simulate already seen expected = ["line 1: source\n", "line 2\n"] assert system.relocate_venv("foo", "source", "dest", fatal=False, _seen={"foo"}) == 0 assert runez.get_lines("foo/bar/bin/baz") == expected assert not logged # Simulate failure to write with patch("runez.write", return_value=-1): assert system.relocate_venv("foo", "source", "dest", fatal=False) == -1 assert runez.get_lines("foo/bar/bin/baz") == expected assert not logged # Simulate effective relocation, by folder expected = ["line 1: dest\n", "line 2\n"] assert system.relocate_venv("foo", "source", "dest", fatal=False) == 1 assert runez.get_lines("foo/bar/bin/baz") == expected assert "Relocated " in logged # Second relocation is a no-op assert system.relocate_venv("foo", "source", "dest", fatal=False) == 0 # Test relocating a single file runez.write("foo/bar/bin/baz", original, logger=logging.debug) assert system.relocate_venv("foo/bar/bin/baz", "source", "dest", fatal=False) == 1 assert "Relocated " in logged
def test_executable(temp_folder): with runez.CaptureOutput(dryrun=True) as logged: assert runez.make_executable("some-file") == 1 assert "Would make some-file executable" in logged.pop() assert runez.make_executable("some-file", logger=False) == 1 assert not logged with runez.CaptureOutput() as logged: assert runez.touch("some-file") == 1 assert "Touched some-file" in logged.pop() assert runez.delete("some-file") == 1 assert "Deleted some-file" in logged.pop() assert runez.touch("some-file", logger=logging.debug) == 1 assert "Touched some-file" in logged.pop() assert runez.make_executable("some-file", logger=logging.debug) == 1 assert "Made 'some-file' executable" in logged.pop() assert runez.is_executable("some-file") assert runez.make_executable("some-file") == 0 assert not logged assert runez.touch("some-file", logger=False) == 1 assert runez.delete("some-file", logger=False) == 1 assert not runez.is_executable("some-file") assert not logged assert runez.make_executable("/dev/null/some-file", fatal=False) == -1 assert "does not exist, can't make it executable" in logged.pop() assert runez.make_executable("/dev/null/some-file", fatal=False, logger=None) == -1 # Don't log anything assert not logged assert runez.make_executable("/dev/null/some-file", fatal=False, logger=False) == -1 # Log errors only assert "does not exist, can't make it executable" in logged.pop()
def test_python_installation(_, __, ___, ____, temp_base): system.DESIRED_PYTHON = "/dev/null/foo" p = system.target_python(fatal=False) assert not p.is_valid assert p.shebang() == "/dev/null/foo" system.DESIRED_PYTHON = None assert system.target_python(fatal=False).is_valid assert not system.PythonInstallation("").is_valid p = system.PythonInstallation("foo") assert str(p) == "python 'foo'" assert not p.is_valid assert p.problem == "No python installation 'foo' found" assert p.program_name == "python 'foo'" p = system.PythonInstallation("pythonx") assert not p.is_valid # assert p.problem == "pythonx is not installed" assert p.program_name == "pythonx" p = system.PythonInstallation("/usr/bin/python") assert str(p) == "/usr/bin/python [2.7]" assert p.is_valid assert p.problem is None assert p.program_name == "python2.7" assert p.short_name == "py27" assert p.executable == "/usr/bin/python" assert p.shebang(universal=True) == "/usr/bin/env python" assert p.shebang() == "/usr/bin/python" p = system.PythonInstallation("3.6") assert str(p) == "/test/python3.6/bin/python [3.6]" assert p.is_valid assert p.problem is None assert p.program_name == "python3.6" assert p.short_name == "py36" assert p.executable == "/test/python3.6/bin/python" assert p.shebang() == "/usr/bin/env python3.6" system.SETTINGS.cli.contents["python_installs"] = temp_base runez.touch("foo") runez.touch("python3.5") runez.touch("python3.7") p = system.PythonInstallation("python3") assert not p.is_valid assert p.problem == "'/test/python3' is not a valid python installation" assert p.program_name == "python3" p = system.PythonInstallation("py3.7") assert not p.is_valid assert p.problem == "python3.7 is not installed" runez.delete("python3.7") runez.touch("3.7.0/bin/python") runez.make_executable("3.7.0/bin/python") p = system.PythonInstallation("3.7") assert p.is_valid assert p.short_name == "py37" assert p.executable == os.path.join(temp_base, "3.7.0/bin/python")
def test_bootstrap(cli, monkeypatch): with patch("pickley.bstrap.which", side_effect=mocked_which): with patch("pickley.bstrap.os.path.expanduser", side_effect=mocked_expanduser): runez.write( ".local/bin/pickley", "#!/bin/sh\necho 0.1") # Pretend we have an old pickley runez.make_executable(".local/bin/pickley") with patch("pickley.bstrap.get_python_version", return_value=(3, 6)): # urllib fails monkeypatch.setenv("__PYVENV_LAUNCHER__", "oh apple, why?" ) # macos oddity env var, should be removed cli.run("-n", main=bstrap.main) assert cli.succeeded assert "__PYVENV_LAUNCHER__" not in os.environ assert "Replacing older pickley 0.1" in cli.logged assert "Would run: python virtualenv.pyz" in cli.logged assert "Would run: .local/bin/.pickley/pickley/pickley-" in cli.logged # Simulate multiple base candidates given cli.run("-n", "-b", "~/.local/bin:foo/bar", main=bstrap.main) assert cli.failed assert "not suitable: ~/.local/bin, foo/bar" in cli.logged # Simulate seeding cli.run("0.1", "-b", "~/.local/bin", "-m", "my-mirror", "-c", '{"pyenv":"~/.pyenv"}', main=bstrap.main) assert cli.succeeded assert "Seeding .local/bin/.pickley/config.json with {'pyenv': '~/.pyenv'}" in cli.logged assert "Seeding .config/pip/pip.conf with my-mirror" in cli.logged assert "pickley version 0.1 is already installed" in cli.logged assert list(runez.readlines(".config/pip/pip.conf")) == [ "[global]", "index-url = my-mirror" ] assert list( runez.readlines(".local/bin/.pickley/config.json")) == [ "{", ' "pyenv": "~/.pyenv"', "}" ] monkeypatch.setenv("PATH", "foo/bar:%s" % os.environ["PATH"]) runez.ensure_folder("foo/bar", logger=None) cli.run("-n", "-b", "~/.local/bin:foo/bar", main=bstrap.main) assert cli.succeeded assert "base: foo/bar" in cli.logged with patch("pickley.bstrap.which", return_value=None): with patch("pickley.bstrap.is_executable", return_value=False): # Simulate no python 3 cli.run("-n", main=bstrap.main) assert cli.failed assert "Could not find python3 on this machine" in cli.logged with patch("pickley.bstrap.get_python_version", return_value=(3, 9)): # urllib fails cli.run("-n", main=bstrap.main) assert cli.succeeded assert " -mvenv " in cli.logged