def test_upgrade(self):
# select the installed "fool":
pkg = hawkey.Query(self.sack).filter(name="walrus")[0]
# without checking versioning, the update is accepted:
self.assertIsNone(
hawkey.Goal(self.sack).upgrade_to(pkg, check_installed=False))
# with the check it is not:
goal = hawkey.Goal(self.sack)
self.assertRaises(hawkey.Exception,
goal.upgrade_to,
package=pkg,
check_installed=True)
# default value for check_installed is False:
self.assertIsNone(hawkey.Goal(self.sack).upgrade_to(pkg))
def _parse_repository_non_modular(package_sack, repo_info, modpkgset):
"""
Simple routine to go through a repo, and figure out which packages
are not in any module. Add the file locations for those packages
so we can link to them.
Returns a set of file locations.
"""
sack = package_sack
pkgs = set()
for pkg in hawkey.Query(sack):
if pkg.location in modpkgset:
continue
pkgs.add(pkg.location)
return pkgs
def compute_dependency_distances(self, srpm, deps):
dep_map = {dep.name: dep for dep in deps}
visited = set()
level = 1
reldeps = srpm.requires
while level < 5 and reldeps:
pkgs_on_level = set(hawkey.Query(self.sack).filter(provides=reldeps))
reldeps = {req for pkg in pkgs_on_level if pkg not in visited
for req in pkg.requires}
visited.update(pkgs_on_level)
for pkg in pkgs_on_level:
dep = dep_map.get(pkg.name)
if dep and dep.distance is None:
dep.distance = level
level += 1
def by_file(sack, patterns, ignore_case=False, get_query=False):
if type(patterns) in types.StringTypes:
patterns = [patterns]
glob = len(filter(_is_glob_pattern, patterns)) > 0
flags = []
q = hawkey.Query(sack)
if ignore_case:
flags = [hawkey.ICASE]
if glob:
q.filter(*flags, file__glob=patterns)
else:
q.filter(*flags, file=patterns)
if get_query:
return q
return q.run()
def test_req(self):
goal = hawkey.Goal(self.sack)
self.assertEqual(goal.req_length(), 0)
self.assertFalse(goal.req_has_erase())
sltr = hawkey.Selector(self.sack).set(name="jay")
goal.erase(select=sltr)
self.assertEqual(goal.req_length(), 1)
self.assertTrue(goal.req_has_erase())
goal = hawkey.Goal(self.sack)
goal.upgrade(select=sltr)
self.assertFalse(goal.req_has_erase())
goal = hawkey.Goal(self.sack)
pkg = hawkey.Query(self.sack).filter(name="dog")[0]
goal.erase(pkg, clean_deps=True)
self.assertTrue(goal.req_has_erase())
def _construct_result(sack,
patterns,
ignore_case,
include_repo=None,
exclude_repo=None,
downgrades_only=False,
updates_only=False,
latest_only=False,
get_query=False):
""" Generic query builder.
patterns can be:
:: a string pattern we will use to match against package names
:: a list of strings representing patterns that are ORed together
:: None in which case we query over all names.
If 'get_query' is False the built query is evaluated and matching
packages returned. Otherwise the query itself is returned (for instance
to be further specified and then evaluated).
"""
if type(patterns) in types.StringTypes:
patterns = [patterns]
elif patterns is None:
patterns = []
glob = len(filter(_is_glob_pattern, patterns)) > 0
flags = []
q = hawkey.Query(sack)
if ignore_case:
flags = [hawkey.ICASE]
if len(patterns) == 0:
pass
elif glob:
q.filter(*flags, name__glob=patterns)
else:
q.filter(*flags, name=patterns)
if include_repo:
q.filter(repo__eq=include_repo)
if exclude_repo:
q.filter(repo__neq=exclude_repo)
q.filter(downgrades=downgrades_only)
q.filter(upgrades=updates_only)
q.filter(latest__eq=latest_only)
if get_query:
return q
return q.run()
def compute_dependency_distances(sack, br, deps):
"""
Computes dependency distance of given dependencies.
Dependency distance is the length of the shortest path from any of the first-level
dependencies (BuildRequires) to the dependency node in the dependency graph.
The algorithm is only a best-effort approximation that uses hawkey queries.
It is a variant of depth-limited BFS (depth limit is hardcoded to 5).
Dependency objects are mutated in place. Objects that weren't reached keep their
original distance (None).
:param sack: hawkey.Sack used for dependency queries
:param br: List of BuildRequires -- first-level dependencies. Build group should not
be included.
:param deps: List of DependencyWithDistance objects for all dependencies that were
marked to be installed.
"""
dep_map = {dep.name: dep for dep in deps}
visited = set()
level = 1
# pylint:disable=E1103
pkgs_on_level = {
x
for r in br for x in _get_builddep_selector(sack, r).matches()
}
while pkgs_on_level:
for pkg in pkgs_on_level:
dep = dep_map.get(pkg.name)
if dep and dep.distance is None:
dep.distance = level
level += 1
if level >= 5:
break
reldeps = {
req
for pkg in pkgs_on_level if pkg not in visited
for req in pkg.requires
}
visited.update(pkgs_on_level)
pkgs_on_level = set(hawkey.Query(sack).filter(provides=reldeps))
def compute_dependency_distances(sack, br, deps):
dep_map = {dep.name: dep for dep in deps}
visited = set()
level = 1
# pylint:disable=E1103
pkgs_on_level = {
x
for r in br for x in _get_best_selector(sack, r).matches()
}
while pkgs_on_level:
for pkg in pkgs_on_level:
dep = dep_map.get(pkg.name)
if dep and dep.distance is None:
dep.distance = level
level += 1
if level >= 5:
break
reldeps = {
req
for pkg in pkgs_on_level if pkg not in visited
for req in pkg.requires
}
visited.update(pkgs_on_level)
pkgs_on_level = set(hawkey.Query(sack).filter(provides=reldeps))
def test_custom_querying(self):
reldep = hawkey.Reldep(self.sack, "P-lib = 3-3")
q = hawkey.Query(self.sack).filter(provides=reldep)
self.assertLength(q, 1)
reldep = hawkey.Reldep(self.sack, "P-lib >= 3")
q = hawkey.Query(self.sack).filter(provides=reldep)
self.assertLength(q, 1)
reldep = hawkey.Reldep(self.sack, "(foo or P-lib)")
q = hawkey.Query(self.sack).filter(provides=reldep)
self.assertLength(q, 1)
reldep = hawkey.Reldep(self.sack, "P-lib < 3-3")
q = hawkey.Query(self.sack).filter(provides=reldep)
self.assertLength(q, 0)
reldep = hawkey.Reldep(self.sack, u"\u0159 >= 3")
q = hawkey.Query(self.sack).filter(provides=reldep)
self.assertLength(q, 0)
reldep = hawkey.Reldep(self.sack, "foo >= 1.0-1.fc20")
q = hawkey.Query(self.sack).filter(provides=reldep)
self.assertLength(q, 0)
def test_in_set(self):
q = hawkey.Query(self.sack)
q.filterm(name__substr=set(["ool", "enny-li"]))
self.assertEqual(q.count(), 2)
def setUp(self):
self.sack = base.TestSack(repo_dir=self.repo_dir)
self.sack.load_system_repo()
self.q = hawkey.Query(self.sack)
self.q1 = self.q.filter(version="4")
self.q2 = self.q.filter(name__glob="p*")
def test_advisory_bug(self):
pkgs = hawkey.Query(self.sack).filter(advisory_bug="0#paul").run()
self.assertEqual(pkgs, self.expected_pkgs)
def test_advisory(self):
pkgs = hawkey.Query(
self.sack).filter(advisory="BEATLES-1967-1127").run()
self.assertEqual(pkgs, self.expected_pkgs)
def test_exception(self):
q = hawkey.Query(self.sack)
self.assertRaises(hawkey.ValueException, q.filter, flying__eq="name")
self.assertRaises(hawkey.ValueException, q.filter, flying="name")
def test_creation_empty_sack(self):
s = hawkey.Sack(make_cache_dir=True)
q = hawkey.Query(s)
def test_updates_noarch(self):
q = hawkey.Query(self.sack)
q.filterm(name="flying", upgrades=1)
self.assertEqual(q.count(), 3)
def test_updates_arch(self):
q = hawkey.Query(self.sack)
pilchard = q.filter(name="dog", upgrades=True)
self.assertItemsEqual(list(map(str, pilchard.run())),
["dog-1-2.x86_64"])
def test_reldep_list(self):
self.sack.load_test_repo("updates", "updates.repo")
fool = base.by_name_repo(self.sack, "fool", "updates")
q = hawkey.Query(self.sack).filter(provides=fool.obsoletes)
self.assertEqual(str(q.run()[0]), "penny-4-1.noarch")
def test_latest(self):
q = hawkey.Query(self.sack).filter(latest=True)
self.assertEqual(len(q), 1)
q = hawkey.Query(self.sack).filter(latest_per_arch=True)
self.assertEqual(len(q), 1)
def test_multiple_flags(self):
q = hawkey.Query(self.sack).filter(name__glob__not=["p*", "j*"])
self.assertItemsEqual(list(map(lambda p: p.name, q.run())),
["baby", "dog", "flying", "fool", "gun", "tour"])
def setUp(self):
"""Prepare the test fixture."""
self.sack = base.TestSack(repo_dir=self.repo_dir)
self.sack.load_repo(load_updateinfo=True)
self.expected_pkgs = hawkey.Query(self.sack).filter(
nevra=["mystery-devel-19.67-1.noarch", "tour-4-6.noarch"]).run()
def test_apply(self):
q = hawkey.Query(self.sack).filter(name__glob__not="p*").apply()
res = q.filter(name__glob__not="j*").run()
self.assertItemsEqual(list(map(lambda p: p.name, res)),
["baby", "dog", "flying", "fool", "gun", "tour"])
def test_advisory_type(self):
pkgs = hawkey.Query(self.sack).filter(advisory_type="security").run()
self.assertEqual(pkgs, self.expected_pkgs)
def test_provides_glob_should_not_work(self):
q = hawkey.Query(self.sack).filter(provides="*")
self.assertLength(q, 0)
q = hawkey.Query(self.sack).filter(provides__glob="nomatch*")
self.assertLength(q, 0)
def test_advisory_cve(self):
pkgs = hawkey.Query(
self.sack).filter(advisory_cve="CVE-1967-BEATLES").run()
self.assertEqual(pkgs, self.expected_pkgs)
def test_obsoletes(self):
reldep = hawkey.Reldep(self.sack, "penny < 4-0")
q = hawkey.Query(self.sack).filter(obsoletes=reldep)
self.assertItemsEqual(list(map(str, q.run())), ["fool-1-5.noarch"])
def test_kwargs_check(self):
q = hawkey.Query(self.sack)
self.assertRaises(hawkey.ValueException,
q.filter,
name="flying",
upgrades="maracas")
def test_downgradable(self):
query = hawkey.Query(self.sack).filter(downgradable=True)
self.assertEqual({str(pkg)
for pkg in query},
{"baby-6:5.0-11.x86_64", "jay-5.0-0.x86_64"})
def test_iteration(self):
q = hawkey.Query(self.sack)
q.filterm(name__substr=["penny"])
self.assertEqual(q.count(), 2)
self.assertNotEqual(q[0], q[1])
def test_sanity(self):
q = hawkey.Query(self.sack)
q.filterm(name__eq="flying")
self.assertEqual(q.count(), 1)
