def get_unresolved_dependencies(self, repos_data):
"""Gets list of unresolved dependencies for repository(es).
:param repos_data: The list of repository descriptions
:return: list of unresolved dependencies
"""
packages = PackagesTree()
self._load_packages(self._load_repositories(repos_data), packages.add)
return packages.get_unresolved_dependencies()
def get_unresolved_dependencies(self, repos_data):
"""Gets list of unresolved dependencies for repository(es).
:param repos_data: The list of repository descriptions
:return: list of unresolved dependencies
"""
packages = PackagesTree()
self._load_packages(self._load_repositories(repos_data), packages.add)
return packages.get_unresolved_dependencies()
def test_warning_if_unresolved(self):
ptree = PackagesTree()
ptree.add(generator.gen_package(
1, requires=None))
with warnings.catch_warnings(record=True) as log:
ptree.get_minimal_subset(
None, [generator.gen_relation("package2")]
)
self.assertIn("package2", str(log[0]))
def test_get_minimal_subset_with_master(self):
ptree = PackagesTree()
ptree.add(generator.gen_package(1, requires=None))
ptree.add(generator.gen_package(2, requires=None))
ptree.add(generator.gen_package(3, requires=None))
ptree.add(generator.gen_package(
4, requires=[generator.gen_relation("package1")]
))
master = Index()
master.add(generator.gen_package(1, requires=None))
master.add(generator.gen_package(
5,
requires=[generator.gen_relation(
"package10",
alternative=generator.gen_relation("package4")
)]
))
unresolved = set([generator.gen_relation("package3")])
resolved = ptree.get_minimal_subset(master, unresolved)
self.assertItemsEqual(
["package3", "package4"],
(x.name for x in resolved)
)
def test_get_unresolved_dependencies(self):
tree = PackagesTree()
tree.add(generator.gen_package(
1, requires=[generator.gen_relation("unresolved")]))
tree.add(generator.gen_package(2, requires=None))
tree.add(generator.gen_package(
3, requires=[generator.gen_relation("package1")]
))
unresolved = tree.get_unresolved_dependencies()
self.assertItemsEqual(
["unresolved"],
(x.name for x in unresolved)
)
def test_get_unresolved_dependencies(self):
ptree = PackagesTree()
ptree.add(generator.gen_package(
1, requires=[generator.gen_relation("unresolved")]))
ptree.add(generator.gen_package(2, requires=None))
ptree.add(generator.gen_package(
3, requires=[generator.gen_relation("package1")]
))
ptree.add(generator.gen_package(
4,
requires=[generator.gen_relation("loop")],
obsoletes=[generator.gen_relation("loop", ["le", 1])]
))
unresolved = ptree.get_unresolved_dependencies()
self.assertItemsEqual(
["loop", "unresolved"],
(x.name for x in unresolved)
)
def test_find_package(self):
tree = PackagesTree()
p1 = generator.gen_package(idx=1, version=1)
p2 = generator.gen_package(idx=1, version=2)
tree.add(p1)
tree.add(p2)
self.assertIs(p1, tree.find(p1.name, VersionRange("<", p2.version)))
self.assertIs(p2, tree.find(p1.name, VersionRange(">=", p1.version)))
self.assertIsNone(tree.find(p1.name, VersionRange(">", p2.version)))
def _get_packages(self, repositories, master, requirements):
"""Gets the list of packages according to master and requirements."""
if master is None and requirements is None:
packages = set()
self.controller.load_packages(repositories, packages.add)
return packages
packages = PackagesTree()
self.controller.load_packages(repositories, packages.add)
if master is not None:
main_index = Index()
self.controller.load_packages(
self._get_repositories(master),
main_index.add
)
else:
main_index = None
return packages.get_minimal_subset(
main_index,
self._parse_requirements(requirements)
)
def test_get_unresolved_dependencies_with_main(self):
ptree = PackagesTree()
ptree.add(generator.gen_package(
1, requires=[generator.gen_relation("unresolved")]))
ptree.add(generator.gen_package(2, requires=None))
ptree.add(generator.gen_package(
3, requires=[generator.gen_relation("package1")]
))
ptree.add(generator.gen_package(
4,
requires=[generator.gen_relation("package5")]
))
main = Index()
main.add(generator.gen_package(5, requires=[
generator.gen_relation("package6")
]))
unresolved = ptree.get_unresolved_dependencies(main)
self.assertItemsEqual(
["unresolved"],
(x.name for x in unresolved)
)
def get_unresolved_dependencies(self, origin, main=None):
"""Gets list of unresolved dependencies for repository(es).
:param origin: The list of repository`s URLs
:param main: The main repository(es) URL
:return: list of unresolved dependencies
"""
packages = PackagesTree()
self.controller.load_packages(
self._get_repositories(origin),
packages.add
)
if main is not None:
base = Index()
self.controller.load_packages(
self._get_repositories(main),
base.add
)
else:
base = None
return packages.get_unresolved_dependencies(base)
def test_mandatory_packages_always_included(self):
ptree = PackagesTree()
ptree.add(generator.gen_package(1, requires=None, mandatory=True))
ptree.add(generator.gen_package(2, requires=None))
ptree.add(generator.gen_package(3, requires=None))
unresolved = set([generator.gen_relation("package3")])
resolved = ptree.get_minimal_subset(None, unresolved)
self.assertItemsEqual(
["package3", "package1"],
(x.name for x in resolved)
)
def test_add(self):
tree = PackagesTree()
pkg = generator.gen_package(version=1, mandatory=True)
tree.add(pkg)
self.assertIs(pkg, tree.find(pkg.name, VersionRange('=', pkg.version)))
self.assertIs(
pkg.obsoletes[0],
tree.obsoletes[pkg.obsoletes[0].name][(pkg.name, pkg.version)]
)
self.assertIs(
pkg.provides[0],
tree.provides[pkg.provides[0].name][(pkg.name, pkg.version)]
)
tree.add(generator.gen_package(version=1, mandatory=False))
self.assertItemsEqual([pkg], tree.mandatory_packages)
def test_get_minimal_subset_without_master(self):
ptree = PackagesTree()
ptree.add(generator.gen_package(1, requires=None))
ptree.add(generator.gen_package(2, requires=None))
ptree.add(generator.gen_package(
3, requires=[generator.gen_relation("package1")]
))
unresolved = set([generator.gen_relation("package3")])
resolved = ptree.get_minimal_subset(None, unresolved)
self.assertItemsEqual(
["package3", "package1"],
(x.name for x in resolved)
)
def test_find_provides(self):
tree = PackagesTree()
p1 = generator.gen_package(
version=1, obsoletes=[generator.gen_relation('provide', ('<', 2))]
)
tree.add(p1)
self.assertIs(
p1, tree.find("provide", VersionRange("<=", 2))
)
self.assertIsNone(
tree.find("provide", VersionRange(">", 2))
)
def test_find_obsolete(self):
tree = PackagesTree()
p1 = generator.gen_package(
version=1, obsoletes=[generator.gen_relation('obsolete', ('<', 2))]
)
p2 = generator.gen_package(
version=2, obsoletes=[generator.gen_relation('obsolete', ('<', 2))]
)
tree.add(p1)
tree.add(p2)
self.assertEqual(
[p1, p2], tree.find_all("obsolete", VersionRange("<=", 2))
)
self.assertIsNone(
tree.find("obsolete", VersionRange(">", 2))
)
