def _locked(self):
"""
:return bool: True if lock is held by another process
"""
if not runez.is_younger(self.lock, self.invalid):
# Lock file does not exist or invalidation age reached
return False
# Consider locked if pid stated in lock file is still valid
pid = runez.to_int(runez.first_line(self.lock))
return runez.check_pid(pid)
def validate_sanity_check(exe, sanity_check):
if not exe or not sanity_check:
return None
r = runez.run(exe, sanity_check, fatal=False)
if r.failed:
if does_not_implement_cli_flag(r.output, r.error):
return "does not respond to %s" % sanity_check
abort("'%s' failed %s sanity check: %s" %
(exe, sanity_check, r.full_output))
return runez.first_line(r.output or r.error)
def test_package(cli):
pickley = system.SETTINGS.base.full_path("dist", "pickley", "bin",
"pickley")
expected_version = system.run_python(os.path.join(PROJECT, "setup.py"),
"--version")
# Package pickley as venv
cli.expect_success(["package", "-d", "dist", PROJECT],
"Packaged %s successfully" % short(PROJECT))
# Verify that it packaged OK, and is relocatable
assert runez.is_executable(pickley)
assert run_program(pickley, "--version") == expected_version
assert runez.first_line(pickley).startswith("#!/usr/bin/env python")
def test_paths(temp_folder):
assert runez.resolved_path(None) is None
assert runez.resolved_path("some-file") == os.path.join(temp_folder, "some-file")
assert runez.resolved_path("some-file", base="bar") == os.path.join(temp_folder, "bar", "some-file")
assert runez.short(None) is None
assert runez.short("") == ""
assert runez.short(temp_folder) == temp_folder
assert runez.short(temp_folder + "/some-file") == "some-file"
assert runez.short(temp_folder + "/some-file") == "some-file"
assert runez.parent_folder(None) is None
assert runez.parent_folder(temp_folder + "/some-file") == temp_folder
assert runez.represented_args(["ls", temp_folder + "/some-file bar", "-a"]) == 'ls "some-file bar" -a'
# Don't crash for no-ops
assert runez.ensure_folder(None) == 0
assert runez.ensure_folder("") == 0
assert runez.copy(None, None) == 0
assert runez.move(None, None) == 0
assert runez.symlink(None, None) == 0
assert runez.copy("some-file", "some-file") == 0
assert runez.move("some-file", "some-file") == 0
assert runez.symlink("some-file", "some-file") == 0
assert runez.ensure_folder("some-folder") == 0 # 'some-folder' would be in temp_folder, which already exists
with runez.CaptureOutput(dryrun=True) as logged:
assert runez.ensure_folder("some-folder", folder=True, fatal=False) == 1
assert "Would create" in logged.pop()
assert runez.touch("some-file", logger=logging.debug) == 1
assert "Would touch some-file" in logged.pop()
assert runez.copy("some-file", "bar") == 1
assert "Would copy some-file -> bar" in logged.pop()
assert runez.move("some-file", "bar") == 1
assert "Would move some-file -> bar" in logged.pop()
assert runez.symlink("some-file", "bar") == 1
assert "Would symlink some-file <- bar" in logged.pop()
assert runez.delete(temp_folder) == 1
assert "Would delete" in logged.pop()
assert runez.copy("some-folder/bar/baz", "some-folder", fatal=False) == -1
assert "source contained in destination" in logged.pop()
assert runez.move("some-folder/bar/baz", "some-folder", fatal=False) == -1
assert "source contained in destination" in logged.pop()
assert runez.symlink("some-folder/bar/baz", "some-folder", fatal=False) == -1
assert "source contained in destination" in logged.pop()
with runez.CaptureOutput():
assert runez.touch("sample") == 1
assert "Can't create folder" in runez.verify_abort(runez.ensure_folder, "sample", folder=True)
custom = runez.verify_abort(runez.ensure_folder, "sample", folder=True, fatal=SystemExit, expected_exception=SystemExit)
assert "Can't create folder" in custom
with pytest.raises(AssertionError):
assert runez.verify_abort(runez.ensure_folder, None)
assert runez.delete("sample") == 1
assert runez.ensure_folder("sample", folder=True) == 1
assert os.getcwd() == temp_folder
with runez.CurrentFolder("sample", anchor=False):
cwd = os.getcwd()
sample = os.path.join(temp_folder, "sample")
assert cwd == sample
assert runez.short(os.path.join(cwd, "some-file")) == "sample/some-file"
with runez.CurrentFolder("sample", anchor=True):
cwd = os.getcwd()
sample = os.path.join(temp_folder, "sample")
assert cwd == sample
assert runez.short(os.path.join(cwd, "some-file")) == "some-file"
assert os.getcwd() == temp_folder
assert runez.delete("sample") == 1
with runez.CaptureOutput() as logged:
sample = os.path.join(os.path.dirname(__file__), "sample.txt")
content = runez.get_lines(sample)
assert runez.write("sample", "".join(content), fatal=False, logger=logging.debug) == 1
assert runez.get_lines("sample") == content
assert "Writing 13 bytes" in logged.pop()
assert runez.first_line("sample") == "Fred"
assert runez.is_younger("sample", age=10)
assert not runez.is_younger("sample", age=-1)
assert runez.copy("bar", "baz", fatal=False) == -1
assert "does not exist" in logged.pop()
assert runez.move("bar", "baz", fatal=False) == -1
assert "does not exist" in logged.pop()
assert runez.symlink("bar", "baz", fatal=False) == -1
assert "does not exist" in logged.pop()
# Creating dangling symlinks is possible
assert runez.symlink("bar", "baz", fatal=False, must_exist=False) == 1
assert "Symlink bar <- baz" in logged.pop()
assert os.path.islink("baz")
assert not os.path.exists("baz")
assert runez.copy("sample", "x/y/sample") == 1
assert runez.symlink("sample", "x/y/sample3", fatal=False) == 1
assert os.path.exists("sample")
assert runez.move("sample", "x/y/sample2") == 1
assert not os.path.exists("sample")
assert runez.copy("x/y", "x/z") == 1
assert os.path.exists("x/z/sample")
assert os.path.exists("x/z/sample2")
assert os.path.exists("x/z/sample3")
assert os.path.islink("x/z/sample3")
assert runez.touch(None) == 0
assert not runez.is_younger(None, 1)
assert not runez.is_younger("/dev/null/not-there", 1)
assert runez.first_line("/dev/null/not-there") is None
assert runez.get_lines(None) is None
def test_first_line():
assert runez.first_line(None) is None
assert runez.first_line("") is None
assert runez.first_line("\n \n\n") is None
assert runez.first_line("\n \n\n", default="foo") == "foo"
assert runez.first_line(" \n\n", keep_empty=True) == " "
assert runez.first_line(" \n\n", keep_empty=True, default="foo") == " "
assert runez.first_line("\n \n\n", keep_empty=True) == ""
assert runez.first_line("\n\n\n foo \n\bar") == "foo"
assert runez.first_line("\n\n\n foo \n\bar", keep_empty=True) == ""
assert runez.first_line([]) is None
assert runez.first_line([], keep_empty=True) is None
assert runez.first_line([], default="foo") == "foo"
assert runez.first_line([], keep_empty=True, default="foo") == "foo"
assert runez.first_line([" "]) is None
assert runez.first_line([" "], default="foo") == "foo"
assert runez.first_line([" "], keep_empty=True, default="foo") == " "
assert runez.first_line([" ", "b"]) == "b"
assert runez.first_line([" ", "b"], default="foo") == "b"
assert runez.first_line([" ", "b"], keep_empty=True) == " "
assert runez.first_line([" ", "b"], keep_empty=True, default="foo") == " "
def test_install(cli):
tox = system.SETTINGS.base.full_path("tox")
p = PACKAGERS.resolved("tox")
p.refresh_desired()
tox_version = p.desired.version
assert not os.path.exists(tox)
assert runez.first_line(tox) is None
cli.expect_success("--dryrun -b{base} --delivery wrap install tox",
"Would wrap",
"Would install tox",
base=cli.context)
cli.expect_success("--dryrun -b{base} --delivery symlink install tox",
"Would symlink",
"Would install tox",
base=cli.context)
cli.expect_failure("--dryrun -b{base} --delivery foo install tox",
"invalid choice: foo",
base=cli.context)
cli.expect_success("--dryrun uninstall /dev/null --force",
"Nothing to uninstall")
runez.touch("foo")
assert os.path.exists("foo")
cli.expect_failure("uninstall foo", "foo was not installed with pickley")
cli.expect_success("uninstall foo --force", "Uninstalled foo")
assert not os.path.exists("foo")
assert runez.ensure_folder("foo", folder=True) == 1
cli.expect_failure("uninstall foo --force",
"Can't automatically uninstall")
cli.expect_failure("-b{base} check tox foo/bar",
"is not installed",
"can't determine latest version",
base=cli.context)
cli.expect_failure("-b{base} install six",
"'six' is not a CLI",
base=cli.context)
# Install tox, but add a few files + a bogus previous entry point to test cleanup
wep1 = system.SETTINGS.base.full_path("tox-old-entrypoint1")
tep10 = system.SETTINGS.meta.full_path("tox", "tox-old-entrypoint1-1.0")
tep11 = system.SETTINGS.meta.full_path("tox", "tox-old-entrypoint1-1.1")
t00 = system.SETTINGS.meta.full_path("tox", "tox-0.0.0")
tfoo = system.SETTINGS.meta.full_path("tox", "tox-foo")
runez.touch(wep1)
runez.touch(tep10)
runez.touch(tep11)
runez.touch(t00)
runez.touch(tfoo)
eppath = system.SETTINGS.meta.full_path("tox", ".entry-points.json")
runez.write(eppath, '["tox-old-entrypoint1", "tox-old-entrypoint2"]\n')
cli.expect_success("-b{base} --delivery wrap install tox",
"Installed tox",
base=cli.context)
# Old entry point removed immediately
assert not os.path.exists(wep1)
# Only 1 cleaned up immediately (latest + 1 kept)
assert not os.path.exists(tep10)
assert os.path.exists(tep11)
assert not os.path.exists(t00)
assert os.path.exists(tfoo)
assert runez.is_executable(tox)
output = run_program(tox, "--version")
assert "tox" in output
assert tox_version in output
cli.expect_success("-b{base} auto-upgrade tox",
"Skipping auto-upgrade",
base=cli.context)
runez.delete(system.SETTINGS.meta.full_path("tox", ".ping"))
cli.expect_success("-b{base} auto-upgrade tox",
"already installed",
base=cli.context)
version = output.partition(" ")[0]
cli.expect_success("copy .pickley/tox/tox-%s tox-copy" % version, "Copied")
cli.expect_success("move tox-copy tox-relocated", "Moved")
# Verify that older versions and removed entry-points do get cleaned up
runez.save_json({"install_timeout": 0}, "custom-timeout.json")
cli.expect_success("-b{base} -ccustom-timeout.json install tox",
"already installed",
base=cli.context)
# All cleaned up when enough time went by
assert not os.path.exists(tep10)
assert not os.path.exists(tep11)
assert not os.path.exists(t00)
assert not os.path.exists(tfoo)
cli.expect_success("-b{base} check",
"tox",
"is installed",
base=cli.context)
cli.expect_success(
"-b{base} check --verbose",
"tox",
"is installed (as %s wrap, channel: " % system.VENV_PACKAGER,
base=cli.context,
)
p = PACKAGERS.get(system.VENV_PACKAGER)("tox")
p.refresh_latest()
p.latest.version = "10000.0"
p.latest.save()
cli.expect_failure("-b{base} check",
"tox",
"can be upgraded to 10000.0",
base=cli.context)
cli.expect_success("-b{base} -ppex install twine",
"Installed twine",
base=cli.context)
cli.expect_success("-b{base} list", "tox", "twine", base=cli.context)
cli.expect_success("-b{base} list --verbose",
"tox",
"twine",
base=cli.context)
tmp = os.path.realpath(cli.context)
assert find_uninstaller(os.path.join(tmp, "tox"))
assert find_uninstaller(os.path.join(tmp, "twine"))
cli.expect_success("-b{base} uninstall twine",
"Uninstalled twine",
base=cli.context)
runez.delete(p.current._path)
runez.touch(p.current._path)
cli.expect_failure("-b{base} check",
"tox",
"Couldn't read",
"is not installed",
base=cli.context)
cli.expect_success("-b{base} uninstall tox",
"Uninstalled tox",
"entry points",
base=cli.context)