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)