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_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 execute(self, args, uargs):
wm = self.get_workspacemanager()
profile = wm.get_profile(self._find_profile_name(args, wm=wm))
if args.pkg_add_list is not None:
valid_pilist = list(wm.list_available_packages().keys()) + list(
wm.list_installed_packages().keys())
pilist = []
for motif in args.pkg_add_list:
if PackageIdentifier.is_valid_identifier(motif):
pilist.append(PackageIdentifier.parse(motif))
else:
pilist.append(find_latest_version(motif, valid_pilist))
profile.add_packages(pilist)
if args.pkg_rm_list is not None:
valid_pilist = profile.packages
pilist = []
for motif in args.pkg_rm_list:
if PackageIdentifier.is_valid_identifier(motif):
pilist.append(PackageIdentifier.parse(motif))
else:
pilist.append(find_latest_version(motif, valid_pilist))
profile.remove_packages(pilist)
wm.update_profile(profile)
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_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 resolve_latest(motif_list, pm):
out = []
grouped_packages = {}
group_package_identifiers_by_name(pm.list_installed_packages().keys(),
pkgmap=grouped_packages)
group_package_identifiers_by_name(pm.list_available_packages().keys(),
pkgmap=grouped_packages)
for motif in motif_list:
pi = None
if PackageIdentifier.is_valid_identifier(motif):
pi = PackageIdentifier.parse(motif)
if pi.name not in grouped_packages or pi not in grouped_packages[
pi.name]:
# Unknwon package
pi = None
elif motif in grouped_packages:
# Get latest of the sorted list
pi = grouped_packages[motif][-1]
# Check if package identifier has been found
if pi is None:
raise InvalidPackageNameException(motif)
out.append(pi)
return out
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_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_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_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_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_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_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_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_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_prereq(self):
self.assertEqual(
APMAP[PackageIdentifier.parse("prereq-A_1.0")].requires_packages,
["prereq-true_1.0"])
self.assertEqual(
APMAP[PackageIdentifier.parse("prereq-C_1.0")].requires_packages,
["prereq-A_1.0", "prereq-B_1.0"])
self.assertEqual(
APMAP[PackageIdentifier.parse("prereq-D_1.0")].requires_packages,
["prereq-true_1.0", "prereq-false_1.0"])
def get_latest_ap(motif, pilist):
if PackageIdentifier.is_valid_identifier(motif):
pi = PackageIdentifier.parse(motif)
return pi if pi in pilist else None
out = None
for pi in pilist:
if pi.name == motif:
if out is None or pi > out:
out = pi
return out
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 execute(self, args, uargs):
wm = self.get_workspacemanager()
logger = wm.logger
pfname = wm.current_profile_name
profile = wm.get_profile(pfname)
profile_pkg_map = profile.pkg_map
grouped_packagesmap = group_package_identifiers_by_name(wm.list_installed_packages())
grouped_packagesmap = group_package_identifiers_by_name(wm.list_available_packages(), pkgmap=grouped_packagesmap)
update_pilist = []
motiflist = args.packages if args.packages is not None else profile_pkg_map.keys()
for motif in motiflist:
pi = None
if PackageIdentifier.is_valid_identifier(motif):
# User force specific version
candidate = PackageIdentifier.parse(motif)
if candidate.name in grouped_packagesmap:
if candidate in grouped_packagesmap[candidate.name]:
pi = candidate
elif motif in grouped_packagesmap:
# Get latest version
pi = grouped_packagesmap[motif][-1]
if pi is None:
# Unknown package identifier
raise InvalidPackageNameException(motif)
if pi is not None and pi not in update_pilist:
# Get PI in profile
previous_pi = PackageIdentifier(pi.name, profile_pkg_map[pi.name]) if pi.name in profile_pkg_map else None
if previous_pi is None:
# Package not in profile yet, add it
if wm.print_with_confirm("Do you want to add package {pi}?".format(pi=pi)):
update_pilist.append(pi)
elif previous_pi != pi:
# Package already in profile with a different version, update it
if wm.print_with_confirm("Do you want to update package {pi.name} from {oldpi.version} to {pi.version}?".format(pi=pi, oldpi=previous_pi)):
update_pilist.append(pi)
else:
# Package already in profile with same version, do nothing
pass
if len(update_pilist) == 0:
logger.print_default("Nothing to do")
else:
profile.add_packages(update_pilist)
wm.update_profile(profile)
wm.provision_profile(profile)
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 prereq(pilist: list,
apmap: dict,
ipmap: dict,
env: Environment = None):
"""
Return the list of prereq packages to install
Packages are sorted in alpha order.
Returns a list of AvailablePackages
"""
# All available packages
mfmap = reduce(lambda a, b: a.update(b) or a,
[apmap or {}, ipmap or {}], {})
# Get the list of prereq
prereq_pilist = []
for pi in pilist:
mf = find_manifest(pi, mfmap)
for pis in mf.requires_packages:
prereq_pi = PackageIdentifier.parse(pis)
if prereq_pi not in prereq_pilist:
prereq_pilist.append(prereq_pi)
# Compute prereq dependencies
out = []
DependencyUtils.__build_tree(prereq_pilist, mfmap, out, env=env)
return out
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_multiple_volatile_tags(self):
def toggle_remote(name, enabled):
remote = self.pm.list_remotes()[name]
remote.enabled = enabled
self.pm.update_remote(remote)
pi = PackageIdentifier.parse("multitags_1.0")
toggle_remote("other", False)
self.assertEqual(
["staticTag1", "staticTag2", "volatileTag1", "volatileTag2"],
self.pm.list_available_packages()[pi].tags)
toggle_remote("other", True)
toggle_remote("default", False)
self.assertEqual(
["staticTag1", "staticTag2", "volatileTag3", "volatileTag4"],
self.pm.list_available_packages()[pi].tags)
toggle_remote("default", True)
self.assertEqual([
"staticTag1", "staticTag2", "volatileTag1", "volatileTag2",
"volatileTag3", "volatileTag4"
],
self.pm.list_available_packages()[pi].tags)
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_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_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_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))))
