def test_prereq(self):
self.pm.install_packages(PackageIdentifier.parse_list(["pkg-with-prereq_1.0"]))
self.check_content(self.pm.list_installed_packages(), ["pkg-with-prereq_1.0", "prereq-A_1.0", "prereq-B_1.0"])
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-A_1.0" / "install.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-A_1.0" / "sync.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_1.0" / "install.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_1.0" / "sync.log")))
self.pm.install_packages(PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]))
self.check_content(self.pm.list_installed_packages(), ["pkg-with-prereq_2.0", "pkg-with-prereq_1.0", "prereq-A_1.0", "prereq-B_1.0", "prereq-B_2.0"])
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-A_1.0" / "install.log")))
self.assertEqual(2, len(get_lines(self.install_folder / "prereq-A_1.0" / "sync.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_1.0" / "install.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_1.0" / "sync.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_2.0" / "install.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_2.0" / "sync.log")))
self.pm.uninstall_packages(PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]))
self.pm.install_packages(PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-A_1.0" / "install.log")))
self.assertEqual(3, len(get_lines(self.install_folder / "prereq-A_1.0" / "sync.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_1.0" / "install.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_1.0" / "sync.log")))
self.assertEqual(1, len(get_lines(self.install_folder / "prereq-B_2.0" / "install.log")))
self.assertEqual(2, len(get_lines(self.install_folder / "prereq-B_2.0" / "sync.log")))
def test_conditional_install(self):
self.pm.install_packages(PackageIdentifier.parse_list(["condition_1.0"]))
self.check_content(self.pm.list_installed_packages(), ["condition_1.0", "condition-B_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0"])
self.pm.install_packages(PackageIdentifier.parse_list(["condition_1.0"]), env=Environment("test", {"FOO": "BAR"}))
self.check_content(
self.pm.list_installed_packages(),
["condition_1.0", "condition-A_1.0", "condition-B_1.0", "condition-C_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0"],
)
self.pm.update_user_environment(set_map={"FOO2": "BAR2", "HELLO": "WoRld"})
env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("test", {"FOO": "BAR"}))
self.pm.install_packages(PackageIdentifier.parse_list(["condition_1.0"]), env=env)
self.check_content(
self.pm.list_installed_packages(),
[
"condition_1.0",
"condition-A_1.0",
"condition-B_1.0",
"condition-C_1.0",
"condition-D_1.0",
"condition-E_1.0",
"condition-F_1.0",
"condition-G_1.0",
"condition-H_1.0",
],
)
self.pm.uninstall_packages(PackageIdentifier.parse_list(["condition_1.0"]))
self.check_content(self.pm.list_installed_packages(), [])
def test_steps(self):
self.pm.install_packages(PackageIdentifier.parse_list(["install_1.0"]))
self.check_content(self.pm.list_installed_packages(), ["install_1.0"])
folder = self.install_folder / "install_1.0"
self.assertTrue(folder.is_dir())
self.assertTrue((folder / "data1").is_file())
self.assertTrue((folder / "folder").is_dir())
self.assertTrue((folder / "folder" / "data2").is_file())
self.assertTrue((folder / "folder" / "data1-symlink").is_symlink())
self.assertFalse((self.install_folder / "uninstall.log").is_file())
self.assertTrue((folder / "postinstall.log").is_file())
self.assertTrue((folder / "targetFileFromEnv").is_file())
self.assertTrue((folder / "dump.env").is_file())
self.assertTrue((folder / "folder2").is_dir())
with (folder / "targetFileFromEnv").open() as fp:
content = fp.read().splitlines()
self.assertEqual(1, len(content))
self.assertEqual(str(folder), content[0])
self.pm.uninstall_packages(PackageIdentifier.parse_list(["install_1.0"]))
self.check_content(self.pm.list_installed_packages(), [])
self.assertTrue((self.install_folder / "uninstall.log").is_file())
def test_silent_fail(self):
with self.assertRaises(Exception):
self.pm.install_packages(PackageIdentifier.parse_list(["failure-postinstall-exec_1.0"]))
self.check_content(self.pm.list_installed_packages(), [])
self.pm.install_packages(PackageIdentifier.parse_list(["failure-postinstall-exec-silent_1.0"]))
self.check_content(self.pm.list_installed_packages(), ["failure-postinstall-exec-silent_1.0"])
def test_container(self):
self.pm.install_packages(
PackageIdentifier.parse_list(["container-A_1.0"]))
self.check_content(self.pm.list_installed_packages(), [
"container-A_1.0", "container-B_1.0", "container-C_1.0",
"container-E_1.0"
])
self.pm.install_packages(
PackageIdentifier.parse_list(["container-A_2.0"]))
self.check_content(
self.pm.list_installed_packages(),
[
"container-A_1.0", "container-B_1.0", "container-C_1.0",
"container-E_1.0", "container-A_2.0", "container-D_1.0"
],
)
self.pm.uninstall_packages(
PackageIdentifier.parse_list(["container-A_1.0"]))
self.check_content(
self.pm.list_installed_packages(),
["container-A_2.0", "container-C_1.0", "container-D_1.0"])
self.pm.uninstall_packages(
PackageIdentifier.parse_list(["container-A_2.0"]))
self.check_content(self.pm.list_installed_packages(), [])
def test_resolve_latest(self):
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["testlatest_1.0"]), APMAP, {})
self.assertEqual(["version_2.0", "testlatest_1.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["testlatest_1.0"]), APMAP,
filtermap(IPMAP, "version_1.0"))
self.assertEqual(["version_2.0", "testlatest_1.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["testlatest_1.0"]), APMAP,
filtermap(IPMAP, "version_2.0"))
self.assertEqual(["testlatest_1.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["testlatest_2.0"]), APMAP, {})
self.assertEqual(["version_2.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["testlatest_2.0", "testlatest_2.1"]),
APMAP, {})
self.assertEqual(["version_2.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
def test_free_space_issue(self):
with self.assertRaises(NotEnoughSpaceException):
self.pm.install_packages(
PackageIdentifier.parse_list(["failure-large-ap_1.0"]))
with self.assertRaises(NotEnoughSpaceException):
self.pm.install_packages(
PackageIdentifier.parse_list(["failure-large-extracted_1.0"]))
def test_prereq_failure(self):
with self.assertRaises(PrereqException):
self.pm.install_packages(
PackageIdentifier.parse_list(["pkg-with-prereq_0.1"]))
self.check_content(self.pm.list_installed_packages(),
["prereq-A_0.1-fail"])
self.assertEqual(
1,
len(
get_lines(self.install_folder / "prereq-A_0.1-fail" /
"install.log")))
self.assertEqual(
1,
len(
get_lines(self.install_folder / "prereq-A_0.1-fail" /
"sync.log")))
with self.assertRaises(PrereqException):
self.pm.install_packages(
PackageIdentifier.parse_list(["pkg-with-prereq_0.1"]))
self.check_content(self.pm.list_installed_packages(),
["prereq-A_0.1-fail"])
self.assertEqual(
1,
len(
get_lines(self.install_folder / "prereq-A_0.1-fail" /
"install.log")))
self.assertEqual(
2,
len(
get_lines(self.install_folder / "prereq-A_0.1-fail" /
"sync.log")))
def test_depends_install(self):
deps = DependencyUtils.install(PackageIdentifier.parse_list([]),
self.pm.list_available_packages(),
self.pm.list_installed_packages())
self.__assert_deps(deps, [], AvailablePackage)
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["container-A_1.0"]),
self.pm.list_available_packages(),
self.pm.list_installed_packages())
self.__assert_deps(deps, [
"container-E_1.0", "container-B_1.0", "container-C_1.0",
"container-A_1.0"
], AvailablePackage)
self.pm.install_packages(
PackageIdentifier.parse_list(["container-A_1.0"]))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["container-A_1.0"]),
self.pm.list_available_packages(),
self.pm.list_installed_packages())
self.__assert_deps(deps, [], AvailablePackage)
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["container-A_2.0"]),
self.pm.list_available_packages(),
self.pm.list_installed_packages())
self.__assert_deps(deps, ["container-D_1.0", "container-A_2.0"],
AvailablePackage)
def test_install_unknown_package(self):
with self.assertRaises(InvalidPackageNameException):
self.pm.install_packages(PackageIdentifier.parse_list(["unknwonPackage"]))
with self.assertRaises(InvalidPackageNameException):
self.pm.install_packages(PackageIdentifier.parse_list(["container-A"]))
with self.assertRaises(InvalidPackageNameException):
self.pm.install_packages(PackageIdentifier.parse_list(["unknwonPackage_1.0"]))
def test_env(self):
self.pm.install_packages(PackageIdentifier.parse_list(["env-A_1.0"]))
self.check_content(self.pm.list_installed_packages(), ["env-A_1.0", "env-B_1.0"])
env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["env-A_1.0"]))
self.assertEqual(3, len(env_tolist(env)))
self.assertEqual(
[
("LEAF_ENV_A", "FOO"),
("LEAF_ENV_A2", "Hello"),
("LEAF_PATH_A", "$PATH:{folder}/env-A_1.0:{folder}/env-B_1.0".format(folder=self.install_folder)),
],
env_tolist(env),
)
env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["env-B_1.0", "env-A_1.0"]))
self.assertEqual(5, len(env_tolist(env)))
self.assertEqual(
[
("LEAF_ENV_B", "BAR"),
("LEAF_PATH_B", "$PATH:{folder}/env-B_1.0".format(folder=self.install_folder)),
("LEAF_ENV_A", "FOO"),
("LEAF_ENV_A2", "Hello"),
("LEAF_PATH_A", "$PATH:{folder}/env-A_1.0:{folder}/env-B_1.0".format(folder=self.install_folder)),
],
env_tolist(env),
)
self.assertFileContentEquals(self.install_folder / "env-A_1.0" / "dump.out", "dump.out")
def test_depends_installed(self):
deps = DependencyUtils.installed(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_installed_packages(), ignore_unknown=True)
self.__assert_deps(deps, [], InstalledPackage)
self.pm.install_packages(PackageIdentifier.parse_list(["container-A_1.0"]))
deps = DependencyUtils.installed(PackageIdentifier.parse_list(["container-A_1.0"]), self.pm.list_installed_packages())
self.__assert_deps(deps, ["container-E_1.0", "container-B_1.0", "container-C_1.0", "container-A_1.0"], InstalledPackage)
def test_cannot_uninstall_to_keep_dependencies(self):
self.pm.install_packages(
PackageIdentifier.parse_list(["container-A_2.0"]))
self.check_content(
self.pm.list_installed_packages(),
["container-A_2.0", "container-C_1.0", "container-D_1.0"])
self.pm.uninstall_packages(
PackageIdentifier.parse_list(["container-C_1.0"]))
self.check_content(
self.pm.list_installed_packages(),
["container-A_2.0", "container-C_1.0", "container-D_1.0"])
def test_depends_prereq(self):
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages()
)
self.__assert_deps(deps, ["prereq-A_1.0", "prereq-B_2.0"], AvailablePackage)
self.pm.install_packages(PackageIdentifier.parse_list(["pkg-with-prereq_1.0"]))
deps = DependencyUtils.prereq(
PackageIdentifier.parse_list(["pkg-with-prereq_2.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages()
)
self.__assert_deps(deps, ["prereq-A_1.0", "prereq-B_2.0"], None)
self.assertIsInstance(deps[0], InstalledPackage)
self.assertIsInstance(deps[1], AvailablePackage)
def test_updatet_profile(self):
self.wm.init_ws()
profile = self.wm.create_profile("foo")
self.assertEqual([], profile.packages)
self.assertEqual(OrderedDict(), profile._getenvmap())
profile.add_packages(PackageIdentifier.parse_list(["container-A_1.0"]))
profile.update_environment(OrderedDict([("FOO", "BAR"), ("FOO2", "BAR2")]))
self.wm.update_profile(profile)
self.assertEqual(PackageIdentifier.parse_list(["container-A_1.0"]), profile.packages)
self.assertEqual(OrderedDict([("FOO", "BAR"), ("FOO2", "BAR2")]), profile._getenvmap())
profile.add_packages(PackageIdentifier.parse_list(["container-A_2.1"]))
self.wm.update_profile(profile)
self.assertEqual(PackageIdentifier.parse_list(["container-A_2.1"]), profile.packages)
profile.add_packages(PackageIdentifier.parse_list(["env-A_1.0"]))
self.wm.update_profile(profile)
self.assertEqual(PackageIdentifier.parse_list(["container-A_2.1", "env-A_1.0"]), profile.packages)
profile.remove_packages(PackageIdentifier.parse_list(["container-A_2.1"]))
self.wm.update_profile(profile)
self.assertEqual(PackageIdentifier.parse_list(["env-A_1.0"]), profile.packages)
with self.assertRaises(Exception):
profile.name = "fooooooo"
self.wm.update_profile(profile)
def test_rename_profile(self):
self.wm.init_ws()
self.wm.create_profile("foo")
with self.assertRaises(NoProfileSelected):
self.wm.current_profile_name
profile = self.wm.get_profile("foo")
self.wm.switch_profile(profile)
self.assertEqual("foo", self.wm.current_profile_name)
profile.add_packages(PackageIdentifier.parse_list(["container-A_2.1"]))
profile.update_environment({"FOO": "BAR"})
self.wm.update_profile(profile)
self.wm.provision_profile(profile)
self.assertEqual("foo", self.wm.current_profile_name)
self.check_profile_content("foo", ["container-A", "container-C", "container-D"])
profile = self.wm.rename_profile("foo", "bar")
self.assertEqual(1, len(self.wm.list_profiles()))
self.assertEqual("bar", profile.name)
self.assertEqual("bar", self.wm.get_profile("bar").name)
self.assertEqual("bar", self.wm.current_profile_name)
self.check_profile_content("bar", ["container-A", "container-C", "container-D"])
self.wm.build_full_environment(profile)
with self.assertRaises(ProfileNameAlreadyExistException):
self.wm.rename_profile("bar", "bar")
with self.assertRaises(InvalidProfileNameException):
self.wm.rename_profile("foo", "bar")
def test_compression(self):
pislist = [
"compress-bz2_1.0", "compress-gz_1.0", "compress-tar_1.0",
"compress-xz_1.0"
]
self.pm.install_packages(PackageIdentifier.parse_list(pislist))
self.check_content(self.pm.list_installed_packages(), pislist)
def test_prereq_env(self):
motifs = ["prereq-env_1.0"]
errors = self.pm.install_prereq(PackageIdentifier.parse_list(motifs), self.alt_workspace_folder, raise_on_error=False)
self.assertEqual(0, errors)
dump = self.alt_workspace_folder / "prereq-env_1.0" / "dump.env"
self.assertTrue(dump.exists())
env = env_file_to_map(dump)
self.assertEqual(env["LEAF_PREREQ_ROOT"], str(self.alt_workspace_folder))
def test_resolve_latest(self):
self.pm.install_packages(PackageIdentifier.parse_list(["version_1.0"]))
self.check_content(self.pm.list_installed_packages(), ["version_1.0"])
self.check_installed_packages(["version_1.0"])
self.pm.install_packages(PackageIdentifier.parse_list(["version_1.1"]))
self.check_content(self.pm.list_installed_packages(), ["version_1.0", "version_1.1"])
self.check_installed_packages(["version_1.0", "version_1.1"])
env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["version_latest"]))
self.assertEqual("1.1", env.find_value("TEST_VERSION"))
self.pm.install_packages(PackageIdentifier.parse_list(["version_latest"]))
self.check_content(self.pm.list_installed_packages(), ["version_1.0", "version_1.1", "version_2.0"])
self.check_installed_packages(["version_1.0", "version_1.1", "version_2.0"])
env = self.pm.build_packages_environment(PackageIdentifier.parse_list(["version_latest"]))
self.assertEqual("2.0", env.find_value("TEST_VERSION"))
def test_prereq_order(self):
pi = "prereq-D_1.0"
prereqs = APMAP[PackageIdentifier.parse(pi)].requires_packages
self.assertEqual(["prereq-true_1.0", "prereq-false_1.0"], prereqs)
prereqs = DependencyUtils.prereq(PackageIdentifier.parse_list([pi]),
APMAP, {})
self.assertEqual(["prereq-false_1.0", "prereq-true_1.0"],
list(map(str, map(IDENTIFIER_GETTER, prereqs))))
def test_uninstall(self):
ipmap = OrderedDict()
for ap in DependencyUtils.install(
PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]), APMAP, {}):
ipmap[ap.identifier] = IPMAP[ap.identifier]
self.assertEqual([
"container-E_1.0", "container-B_1.0", "container-C_1.0",
"container-A_1.0", "container-D_1.0", "container-A_2.0"
], deps2strlist(ipmap.values()))
deps = DependencyUtils.uninstall(
PackageIdentifier.parse_list(["container-A_1.0"]), ipmap)
self.assertEqual(
["container-A_1.0", "container-B_1.0", "container-E_1.0"],
deps2strlist(deps))
def test_install(self):
deps = DependencyUtils.install(PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]),
APMAP, {},
env=Environment())
self.assertEqual([
"container-E_1.0", "container-B_1.0", "container-C_1.0",
"container-A_1.0", "container-D_1.0", "container-A_2.0"
], deps2strlist(deps))
deps = DependencyUtils.install(PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]),
APMAP,
filtermap(IPMAP, "container-E_1.0"),
env=Environment())
self.assertEqual([
"container-B_1.0", "container-C_1.0", "container-A_1.0",
"container-D_1.0", "container-A_2.0"
], deps2strlist(deps))
def test_postinstall_error(self):
with self.assertRaises(Exception):
self.pm.install_packages(PackageIdentifier.parse_list(["failure-postinstall-exec_1.0"]), keep_folder_on_error=True)
found = False
for folder in self.install_folder.iterdir():
if folder.name.startswith("failure-postinstall-exec_1.0"):
self.assertTrue(is_folder_ignored(folder))
found = True
break
self.assertTrue(found)
def test_latest_strategy(self):
deps = DependencyUtils.installed(
PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]), IPMAP)
self.assertEqual(
[
"container-E_1.0", "container-B_1.0", "container-C_1.0",
"container-A_1.0", "container-D_1.0", "container-A_2.0"
],
list(map(str, map(IDENTIFIER_GETTER, deps))),
)
deps = DependencyUtils.installed(PackageIdentifier.parse_list(
["container-A_1.0", "container-A_2.0"]),
IPMAP,
only_keep_latest=True)
self.assertEqual(
["container-C_1.0", "container-D_1.0", "container-A_2.0"],
list(map(str, map(IDENTIFIER_GETTER, deps))))
def test_package_override(self):
self.wm.init_ws()
profile = self.wm.create_profile("myprofile")
profile.add_packages(PackageIdentifier.parse_list(["container-A_1.0"]))
self.wm.update_profile(profile)
self.wm.provision_profile(profile)
self.check_installed_packages(["container-A_1.0", "container-B_1.0", "container-C_1.0", "container-E_1.0"])
self.check_profile_content("myprofile", ["container-A", "container-B", "container-C", "container-E"])
profile.add_packages(PackageIdentifier.parse_list(["container-E_1.1"]))
self.wm.update_profile(profile)
self.wm.provision_profile(profile)
self.check_installed_packages(["container-A_1.0", "container-B_1.0", "container-C_1.0", "container-E_1.0", "container-E_1.1"])
self.check_profile_content("myprofile", ["container-A", "container-B", "container-C", "container-E"])
self.assertEqual(
PackageIdentifier.parse_list(["container-E_1.1", "container-B_1.0", "container-C_1.0", "container-A_1.0"]),
list(map(IDENTIFIER_GETTER, self.wm.get_profile_dependencies(profile))),
)
def test_sync(self):
self.pm.install_packages(PackageIdentifier.parse_list(["sync_1.0"]))
self.check_content(self.pm.list_installed_packages(), ["sync_1.0"])
self.check_installed_packages(["sync_1.0"])
sync_file = self.install_folder / "sync_1.0" / "sync.log"
self.assertFalse(sync_file.exists())
self.pm.sync_packages(PackageIdentifier.parse_list(["sync_1.0"]))
self.assertTrue(sync_file.exists())
self.assertEqual(["MYVALUE"], get_lines(sync_file))
self.pm.sync_packages(PackageIdentifier.parse_list(["sync_1.0"]))
self.assertTrue(sync_file.exists())
self.assertEqual(["MYVALUE", "MYVALUE"], get_lines(sync_file))
self.pm.update_user_environment({"MYVAR2": "MYOTHERVALUE"})
self.pm.sync_packages(PackageIdentifier.parse_list(["sync_1.0"]))
self.assertTrue(sync_file.exists())
self.assertEqual(["MYVALUE", "MYVALUE", "MYVALUE MYOTHERVALUE"], get_lines(sync_file))
def test_depends_with_custom_env(self):
env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("Custom env", {}))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["condition_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages(), env=env
)
self.__assert_deps(deps, ["condition-B_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0", "condition_1.0"], AvailablePackage)
self.pm.update_user_environment(set_map={"FOO": "HELLO"})
env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("Custom env", {}))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["condition_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages(), env=env
)
self.__assert_deps(deps, ["condition-A_1.0", "condition-D_1.0", "condition-F_1.0", "condition-H_1.0", "condition_1.0"], AvailablePackage)
self.pm.update_user_environment(set_map={"FOO": "HELLO"})
env = Environment.build(self.pm.build_builtin_environment(), self.pm.build_user_environment(), Environment("Custom env", {"FOO": "BAR"}))
deps = DependencyUtils.install(
PackageIdentifier.parse_list(["condition_1.0"]), self.pm.list_available_packages(), self.pm.list_installed_packages(), env=env
)
self.__assert_deps(deps, ["condition-A_1.0", "condition-C_1.0", "condition-F_1.0", "condition_1.0"], AvailablePackage)
def test_rdepends(self):
for mfmap in (IPMAP, APMAP):
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-A_1.0"]), mfmap)
self.assertEqual(["condition_1.0"], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(PackageIdentifier.parse_list(
["condition-A_1.0"]),
mfmap,
env=Environment(None, {}))
self.assertEqual([], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-A_1.0"]),
mfmap,
env=Environment(None, {"FOO": "BAR"}))
self.assertEqual(["condition_1.0"], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(PackageIdentifier.parse_list(
["condition-B_1.0"]),
mfmap,
env=Environment(None, {}))
self.assertEqual(["condition_1.0"], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-B_1.0"]),
mfmap,
env=Environment(None, {"FOO": "BAR"}))
self.assertEqual([], list(map(str, pilist)))
pilist = DependencyUtils.rdepends(
PackageIdentifier.parse_list(["condition-B_1.0"]), {})
self.assertEqual([], list(map(str, pilist)))
def update_packages_map(ws_config):
node_root = ws_config.json
if JsonConstants.WS_PROFILES in node_root:
for node_profile in node_root[JsonConstants.WS_PROFILES].values():
if JsonConstants.WS_PROFILE_PACKAGES in node_profile:
node_packages = node_profile[JsonConstants.WS_PROFILE_PACKAGES]
if isinstance(node_packages, list):
# Proceed migration list -> map
packages_map = OrderedDict()
for pi in PackageIdentifier.parse_list(node_packages):
packages_map[pi.name] = pi.version
node_profile[
JsonConstants.WS_PROFILE_PACKAGES] = packages_map
def execute(self, args, uargs):
pm = PackageManager()
tmp_install_folder = args.tmp_install_folder
if tmp_install_folder is None:
tmp_install_folder = mkdir_tmp_leaf_dir()
pm.logger.print_quiet(
"Prereq root folder: {folder}".format(folder=tmp_install_folder))
errors = pm.install_prereq(PackageIdentifier.parse_list(args.packages),
tmp_install_folder,
raise_on_error=False)
pm.logger.print_quiet(
"Prereq installed with {count} error(s)".format(count=errors))
return errors