def _generate_packages(self, forest):
packages1 = [
generator.gen_package(
name="package1", version=1, mandatory=True,
requires=None
),
generator.gen_package(
name="package2", version=1,
requires=None
),
generator.gen_package(
name="package3", version=1,
requires=[generator.gen_relation("package5")]
)
]
packages2 = [
generator.gen_package(
name="package4", version=1, mandatory=True,
requires=None
),
generator.gen_package(
name="package5", version=1,
requires=[generator.gen_relation("package2")]
),
]
self._add_packages(forest.add_tree(priority=10), packages1)
self._add_packages(forest.add_tree(priority=10), packages2)
def _generate_packages(self):
self.packages = [
[
generator.gen_package(
name='{0}_1'.format(r.name), repository=r, requires=None
),
generator.gen_package(
name='{0}_2'.format(r.name), repository=r, requires=None
),
generator.gen_package(
name='{0}_3'.format(r.name), repository=r, mandatory=True,
requires=[generator.gen_relation("{0}_2".format(r.name))]
),
generator.gen_package(
name='{0}_4'.format(r.name), repository=r, mandatory=False,
requires=[generator.gen_relation("{0}_1".format(r.name))]
),
generator.gen_package(
name='{0}_5'.format(r.name), repository=r,
requires=[generator.gen_relation("unresolved")]
),
generator.gen_package(
name='package10', repository=r, mandatory=True,
requires=None, version=counter + 10
)
]
for counter, r in enumerate(self.repos)
]
self.controller.load_packages.side_effect = self.packages
def _generate_packages(self):
self.packages = [[
generator.gen_package(name='{0}_1'.format(r.name),
repository=r,
requires=None),
generator.gen_package(name='{0}_2'.format(r.name),
repository=r,
requires=None),
generator.gen_package(
name='{0}_3'.format(r.name),
repository=r,
mandatory=True,
requires=[generator.gen_relation("{0}_2".format(r.name))]),
generator.gen_package(
name='{0}_4'.format(r.name),
repository=r,
mandatory=False,
requires=[generator.gen_relation("{0}_1".format(r.name))]),
generator.gen_package(
name='{0}_5'.format(r.name),
repository=r,
requires=[generator.gen_relation("unresolved")]),
generator.gen_package(name='package10',
repository=r,
mandatory=True,
requires=None,
version=counter + 10)
] for counter, r in enumerate(self.repos)]
self.controller.load_packages.side_effect = self.packages
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_copy_minimal_subset_of_repository(self):
controller = CallbacksAdapter()
repo1 = generator.gen_repository(name="repo1")
repo2 = generator.gen_repository(name="repo2")
repo3 = generator.gen_repository(name="repo3")
mirror1 = generator.gen_repository(name="mirror1")
mirror2 = generator.gen_repository(name="mirror2")
pkg_group1 = [
generator.gen_package(
idx=1, requires=None, repository=repo1
),
generator.gen_package(
idx=1, version=2, requires=None, repository=repo1
),
generator.gen_package(
idx=2, requires=None, repository=repo1
)
]
pkg_group2 = [
generator.gen_package(
idx=4,
requires=[generator.gen_relation("package1")],
repository=repo2,
mandatory=True,
)
]
pkg_group3 = [
generator.gen_package(
idx=3, requires=None, repository=repo1
)
]
controller.load_repositories.side_effect = [[repo1, repo2], repo3]
controller.load_packages.side_effect = [
pkg_group1 + pkg_group2 + pkg_group3,
generator.gen_package(
idx=6,
repository=repo3,
requires=[generator.gen_relation("package2")]
)
]
controller.clone_repositories.return_value = {
repo1: mirror1, repo2: mirror2
}
controller.copy_packages.return_value = 1
api = RepositoryApi(controller)
api.clone_repositories(
["file:///repo1", "file:///repo2"], "/mirror",
["file:///repo3"],
keep_existing=True
)
controller.copy_packages.assert_any_call(
mirror1, set(pkg_group1), True
)
controller.copy_packages.assert_any_call(
mirror2, set(pkg_group2), True
)
self.assertEqual(2, controller.copy_packages.call_count)
def test_load_requirements(self, jsonschema_mock):
expected = {
generator.gen_relation("test1"),
generator.gen_relation("test2", ["<", "3"]),
generator.gen_relation("test2", [">", "1"]),
}
actual = set(self.api._load_requirements(self.requirements_data))
self.assertEqual(expected, actual)
self.assertIsNone(self.api._load_requirements(None))
jsonschema_mock.validate.assert_called_once_with(
self.requirements_data, PACKAGES_SCHEMA)
def test_load_package_relations(self):
data = [{"name": "test1"}, {"name": "test2", "versions": ["> 1", "< 3"]}]
expected = [
str(generator.gen_relation("test1")),
str(generator.gen_relation("test2", ["<", "3"])),
str(generator.gen_relation("test2", [">", "1"])),
]
actual = []
loaders.load_package_relations(data, lambda x: actual.append(str(x)))
self.assertItemsEqual(expected, actual)
actual = []
loaders.load_package_relations(None, actual.append)
self.assertEqual([], actual)
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_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_load_requirements(self, jsonschema_mock):
expected = {
generator.gen_relation("test1"),
generator.gen_relation("test2", ["<", "3"]),
generator.gen_relation("test2", [">", "1"]),
}
actual = set(self.api._load_requirements(
self.requirements_data
))
self.assertEqual(expected, actual)
self.assertIsNone(self.api._load_requirements(None))
jsonschema_mock.validate.assert_called_once_with(
self.requirements_data,
PACKAGES_SCHEMA
)
def _generate_packages(self):
self.packages = [
generator.gen_package(idx=1, repository=self.repo, requires=None),
generator.gen_package(idx=2, repository=self.repo, requires=None),
generator.gen_package(
idx=3, repository=self.repo, mandatory=True,
requires=[generator.gen_relation("package2")]
),
generator.gen_package(
idx=4, repository=self.repo, mandatory=False,
requires=[generator.gen_relation("package1")]
),
generator.gen_package(
idx=5, repository=self.repo,
requires=[generator.gen_relation("package6")])
]
self.controller.load_packages.return_value = self.packages
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))
)
def test_find(self):
forest = PackagesForest()
p11 = generator.gen_package(name="package1", version=1)
p12 = generator.gen_package(name="package1", version=2)
p21 = generator.gen_package(name="package2", version=1)
p22 = generator.gen_package(name="package2", version=2)
self._add_packages(forest.add_tree(), [p11, p22])
self._add_packages(forest.add_tree(), [p12, p21])
self.assertEqual(
p11, forest.find(generator.gen_relation("package1", [">=", 1]))
)
self.assertEqual(
p12, forest.find(generator.gen_relation("package1", [">", 1]))
)
self.assertEqual(p22, forest.find(generator.gen_relation("package2")))
self.assertEqual(
p21, forest.find(generator.gen_relation("package2", ["<", 2]))
)
def test_get_packages(self):
forest = PackagesForest()
self._generate_packages(forest)
packages = forest.get_packages(
[generator.gen_relation("package3")]
)
self.assertItemsEqual(
["package2", "package3", "package5"],
(x.name for x in packages)
)
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_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_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 _generate_packages(self):
self.packages = [
generator.gen_package(idx=1, repository=self.repo, requires=None),
generator.gen_package(idx=2, repository=self.repo, requires=None),
generator.gen_package(
idx=3,
repository=self.repo,
mandatory=True,
requires=[generator.gen_relation("package2")]),
generator.gen_package(
idx=4,
repository=self.repo,
mandatory=False,
requires=[generator.gen_relation("package1")]),
generator.gen_package(
idx=5,
repository=self.repo,
requires=[generator.gen_relation("package6")])
]
self.controller.load_packages.return_value = self.packages
def test_load_package_relations(self):
data = [
{
'name': 'test1'
},
{
'name': 'test2',
'versions': ['> 1', '< 3']
},
]
expected = [
str(generator.gen_relation('test1')),
str(generator.gen_relation('test2', ['<', '3'])),
str(generator.gen_relation('test2', ['>', '1'])),
]
actual = []
loaders.load_package_relations(data, lambda x: actual.append(str(x)))
self.assertItemsEqual(expected, actual)
actual = []
loaders.load_package_relations(None, actual.append)
self.assertEqual([], actual)
def test_find(self):
forest = PackagesForest()
p11 = generator.gen_package(name="package1", version=1)
p12 = generator.gen_package(name="package1", version=2)
p21 = generator.gen_package(name="package2", version=1)
p22 = generator.gen_package(name="package2", version=2)
p33 = generator.gen_package(name="package2", version=10)
self._add_packages(forest.add_tree(priority=10), [p11, p22])
self._add_packages(forest.add_tree(priority=10), [p12, p21])
self._add_packages(forest.add_tree(priority=20), [p33])
self.assertEqual(
p11, forest.find(generator.gen_relation("package1", ["=", 1]))
)
self.assertEqual(
p12, forest.find(generator.gen_relation("package1", [">=", 1]))
)
self.assertEqual(
p12, forest.find(generator.gen_relation("package1", [">", 1]))
)
self.assertEqual(p22, forest.find(generator.gen_relation("package2")))
self.assertEqual(
p21, forest.find(generator.gen_relation("package2", ["<", 2]))
)
# select package from the repo with highest priority
# p33 has version 10, but in the repo with lower priority
self.assertEqual(
p22, forest.find(generator.gen_relation("package2", [">=", 2]))
)
def test_parse_requirements(self):
requirements = RepositoryApi._parse_requirements(
["p1 le 2 | p2 | p3 ge 2"]
)
expected = generator.gen_relation(
"p1",
["le", '2'],
generator.gen_relation(
"p2",
None,
generator.gen_relation(
"p3",
["ge", '2']
)
)
)
self.assertEqual(1, len(requirements))
self.assertEqual(
list(expected),
list(requirements.pop())
)
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_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 test_get_unresolved_with_main(self):
controller = CallbacksAdapter()
pkg1 = generator.gen_package(
name="test1", requires=[
generator.gen_relation("test2"),
generator.gen_relation("test3")
]
)
pkg2 = generator.gen_package(
name="test2", requires=[generator.gen_relation("test4")]
)
controller.load_packages.side_effect = [
pkg1, pkg2
]
api = RepositoryApi(controller)
r = api.get_unresolved_dependencies("file:///repo1", "file:///repo2")
controller.load_repositories.assert_any_call("file:///repo1")
controller.load_repositories.assert_any_call("file:///repo2")
self.assertItemsEqual(
["test3"],
(x.name for x in r)
)
def test_get_packages_with_depends_resolving(self):
controller = CallbacksAdapter()
controller.load_packages.side_effect = [
[
generator.gen_package(idx=1, requires=None),
generator.gen_package(
idx=2, requires=[generator.gen_relation("package1")]
),
generator.gen_package(
idx=3, requires=[generator.gen_relation("package1")]
),
generator.gen_package(idx=4, requires=None),
generator.gen_package(idx=5, requires=None),
],
generator.gen_package(
idx=6, requires=[generator.gen_relation("package2")]
),
]
api = RepositoryApi(controller)
packages = api.get_packages([
"file:///repo1", "file:///repo2"
],
"file:///repo3", ["package4"]
)
self.assertEqual(3, len(packages))
self.assertItemsEqual(
["package1", "package4", "package2"],
(x.name for x in packages)
)
controller.load_repositories.assert_any_call(
["file:///repo1", "file:///repo2"]
)
controller.load_repositories.assert_any_call(
"file:///repo3"
)
def test_get_unresolved(self):
controller = CallbacksAdapter()
pkg = generator.gen_package(
name="test", requires=[generator.gen_relation("test2")]
)
controller.load_packages.side_effect = [
pkg
]
api = RepositoryApi(controller)
r = api.get_unresolved_dependencies("file:///repo1")
controller.load_repositories.assert_called_once_with("file:///repo1")
self.assertItemsEqual(
["test2"],
(x.name for x in r)
)
def _generate_packages(self, forest):
packages1 = [
generator.gen_package(name="package1",
version=1,
mandatory=True,
requires=None),
generator.gen_package(name="package2", version=1, requires=None),
generator.gen_package(
name="package3",
version=1,
requires=[generator.gen_relation("package5")])
]
packages2 = [
generator.gen_package(name="package4",
version=1,
mandatory=True,
requires=None),
generator.gen_package(
name="package5",
version=1,
requires=[generator.gen_relation("package2")]),
]
self._add_packages(forest.add_tree(priority=10), packages1)
self._add_packages(forest.add_tree(priority=10), packages2)
def test_get_unresolved_cmd(self, api_mock, read_file_mock, stdout_mock):
read_file_mock.return_value = [{"name": "repo"}]
api_instance = self.get_api_instance_mock(api_mock)
api_instance.get_unresolved_dependencies.return_value = [
gen_relation(name="test")
]
self.start_cmd(unresolved, self.unresolved_argv)
api_mock.create.assert_called_once_with(mock.ANY, "deb", "x86_64")
self.check_common_config(api_mock.create.call_args[0][0])
api_instance.get_unresolved_dependencies.assert_called_once_with([{
"name":
"repo"
}])
self.assertIn("test; any; -",
stdout_mock.write.call_args_list[3][0][0])
def test_find_newest_package(self):
index = Index()
p1 = gen_package(idx=1, version=2)
p2 = gen_package(idx=2, version=2)
p2.obsoletes.append(
gen_relation(p1.name, ["lt", p1.version])
)
index.add(p1)
index.add(p2)
self.assertIs(
p1, index.find(p1.name, objects.VersionRange("eq", p1.version))
)
self.assertIs(
p2, index.find(p1.name, objects.VersionRange("eq", 1))
)
def test_get_packages_traverse(self):
data = [{"name": "r1", "excludes": [{"name": "p1"}]}]
repo = generator.gen_repository(name="r1")
repo2 = generator.gen_repository(name="r2")
packages = [
generator.gen_package(name="p1", version=1, repository=repo),
generator.gen_package(name="p2", version=2, repository=repo),
generator.gen_package(name="p3", version=2, repository=repo2),
generator.gen_package(name="p4", version=2, repository=repo2),
]
actual = []
traverse = loaders.get_packages_traverse(data, lambda x: actual.append(str(x)))
for p in packages:
traverse(p)
expected = [str(generator.gen_relation("p2", ["=", "2"]))]
self.assertItemsEqual(expected, actual)
def test_get_packages_traverse(self):
data = [{'name': 'r1', 'excludes': [{'name': 'p1'}]}]
repo = generator.gen_repository(name='r1')
repo2 = generator.gen_repository(name='r2')
packages = [
generator.gen_package(name='p1', version=1, repository=repo),
generator.gen_package(name='p2', version=2, repository=repo),
generator.gen_package(name='p3', version=2, repository=repo2),
generator.gen_package(name='p4', version=2, repository=repo2)
]
actual = []
traverse = loaders.get_packages_traverse(
data, lambda x: actual.append(str(x)))
for p in packages:
traverse(p)
expected = [str(generator.gen_relation('p2', ['=', '2']))]
self.assertItemsEqual(expected, actual)
def test_get_unresolved_cmd(self, stdout, RepositoryController, **kwargs):
ctrl = RepositoryController.load()
ctrl.load_packages = CallbacksAdapter()
ctrl.load_packages.return_value = gen_package(
name="test1",
requires=[gen_relation("test2")]
)
self.start_cmd(unresolved, self.unresolved_argv)
RepositoryController.load.assert_called_with(
mock.ANY, "deb", "x86_64"
)
self.check_context(
RepositoryController.load.call_args[0][0], **kwargs
)
self.assertIn(
"test2; any; -",
stdout.write.call_args_list[3][0][0]
)
def test_get_unresolved_cmd(self, api_mock, read_file_mock, stdout_mock):
read_file_mock.return_value = [{"name": "repo"}]
api_instance = self.get_api_instance_mock(api_mock)
api_instance.get_unresolved_dependencies.return_value = [
gen_relation(name="test")
]
self.start_cmd(unresolved, self.unresolved_argv)
api_mock.create.assert_called_once_with(
mock.ANY, "deb", "x86_64"
)
self.check_common_config(api_mock.create.call_args[0][0])
api_instance.get_unresolved_dependencies.assert_called_once_with(
[{"name": "repo"}]
)
self.assertIn(
"test; any; -",
stdout_mock.write.call_args_list[3][0][0]
)
def test_find(self):
forest = PackagesForest()
p11 = generator.gen_package(name="package1", version=1)
p12 = generator.gen_package(name="package1", version=2)
p21 = generator.gen_package(name="package2", version=1)
p22 = generator.gen_package(name="package2", version=2)
p33 = generator.gen_package(name="package2", version=10)
self._add_packages(forest.add_tree(priority=10), [p11, p22])
self._add_packages(forest.add_tree(priority=10), [p12, p21])
self._add_packages(forest.add_tree(priority=20), [p33])
self.assertEqual(
p11, forest.find(generator.gen_relation("package1", ["=", 1])))
self.assertEqual(
p12, forest.find(generator.gen_relation("package1", [">=", 1])))
self.assertEqual(
p12, forest.find(generator.gen_relation("package1", [">", 1])))
self.assertEqual(p22, forest.find(generator.gen_relation("package2")))
self.assertEqual(
p21, forest.find(generator.gen_relation("package2", ["<", 2])))
# select package from the repo with highest priority
# p33 has version 10, but in the repo with lower priority
self.assertEqual(
p22, forest.find(generator.gen_relation("package2", [">=", 2])))
def test_get_packages(self):
forest = PackagesForest()
self._generate_packages(forest)
packages = forest.get_packages([generator.gen_relation("package3")])
self.assertItemsEqual(["package2", "package3", "package5"],
(x.name for x in packages))
def test_equal(self):
self.check_equal(
generator.gen_relation(name="test1"),
generator.gen_relation(name="test1"),
generator.gen_relation(name="test2")
)
def test_hashable(self):
self.check_hashable(
generator.gen_relation(name="test1"),
generator.gen_relation(name="test1", version=["<=", 1])
)
