def __init__(self, cpvstr, mtime, data=None, shared=None, repo=None):
if data is None:
data = {}
cpv = VersionedCPV(cpvstr)
super().__init__(shared, factory(repo), cpv.category, cpv.package, cpv.fullver)
object.__setattr__(self, "data", data)
object.__setattr__(self, "_mtime_", mtime)
def test_iter(self):
expected = sorted(
VersionedCPV(x)
for x in ("dev-util/diffball-1.0", "dev-util/diffball-0.7",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert sorted(self.repo) == expected
def test_notify_add(self):
pkg = VersionedCPV("dev-util/diffball-1.2")
self.repo.notify_add_package(pkg)
assert sorted(self.repo.versions[(pkg.category, pkg.package)]) == \
sorted(["1.0", "1.2", "0.7"])
pkg = VersionedCPV("foo/bar-1.0")
self.repo.notify_add_package(pkg)
assert pkg.category in self.repo.categories
assert pkg.category in self.repo.packages
ver_key = (pkg.category, pkg.package)
assert ver_key in self.repo.versions
assert list(self.repo.versions[ver_key]) == ["1.0"]
pkg = VersionedCPV("foo/cows-1.0")
self.repo.notify_add_package(pkg)
assert (pkg.category, pkg.package) in self.repo.versions
def __init__(self, cpvstr, repo, data=None, shared=None):
if data is None:
data = {}
cpv = VersionedCPV(cpvstr)
super().__init__(shared, factory(repo), cpv.category, cpv.package, cpv.fullver)
object.__setattr__(self, "data", data)
object.__setattr__(self, "path", pjoin(
repo.location, cpv.category, cpv.package, f'{cpv.package}-{cpv.fullver}.ebuild'))
def test_iter(self):
self.assertEqual(
sorted(self.repo),
sorted(
VersionedCPV(x)
for x in ("dev-util/diffball-1.0", "dev-util/diffball-0.7",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1")))
def test_notify_add(self):
pkg = VersionedCPV("dev-util/diffball-1.2")
self.repo.notify_add_package(pkg)
self.assertEqual(
sorted(self.repo.versions[(pkg.category, pkg.package)]),
sorted(["1.0", "1.2", "0.7"]))
pkg = VersionedCPV("foo/bar-1.0")
self.repo.notify_add_package(pkg)
self.assertIn(pkg.category, self.repo.categories)
self.assertIn(pkg.category, self.repo.packages)
ver_key = (pkg.category, pkg.package)
self.assertIn(ver_key, self.repo.versions)
self.assertEqual(list(self.repo.versions[ver_key]), ["1.0"])
pkg = VersionedCPV("foo/cows-1.0")
self.repo.notify_add_package(pkg)
self.assertIn((pkg.category, pkg.package), self.repo.versions)
def test_notify_remove(self):
pkg = VersionedCPV("dev-util/diffball-1.0")
self.repo.notify_remove_package(pkg)
assert list(self.repo.versions[(pkg.category, pkg.package)]) == ["0.7"]
# test version being emptied, and package updated
pkg = VersionedCPV("dev-util/diffball-0.7")
self.repo.notify_remove_package(pkg)
assert (pkg.category, pkg.package) not in self.repo.versions
assert pkg.package not in self.repo.packages[pkg.category]
# test no remaining packages, category updated
pkg = VersionedCPV("dev-util/bsdiff-0.4.1")
self.repo.notify_remove_package(pkg)
pkg = VersionedCPV("dev-util/bsdiff-0.4.2")
self.repo.notify_remove_package(pkg)
assert (pkg.category, pkg.package) not in self.repo.versions
assert pkg.category not in self.repo.packages
assert pkg.category not in self.repo.categories
def test_notify_remove(self):
pkg = VersionedCPV("dev-util/diffball-1.0")
self.repo.notify_remove_package(pkg)
self.assertEqual(list(self.repo.versions[(pkg.category, pkg.package)]),
["0.7"])
# test version being emptied, and package updated
pkg = VersionedCPV("dev-util/diffball-0.7")
self.repo.notify_remove_package(pkg)
self.assertNotIn((pkg.category, pkg.package), self.repo.versions)
self.assertNotIn(pkg.package, self.repo.packages[pkg.category])
# test no remaining packages, category updated
pkg = VersionedCPV("dev-util/bsdiff-0.4.1")
self.repo.notify_remove_package(pkg)
pkg = VersionedCPV("dev-util/bsdiff-0.4.2")
self.repo.notify_remove_package(pkg)
self.assertNotIn((pkg.category, pkg.package), self.repo.versions)
self.assertNotIn(pkg.category, self.repo.packages)
self.assertNotIn(pkg.category, self.repo.categories)
def __init__(self, cpvstr, data=None, parent=None, ebuild='', **kwargs):
if data is None:
data = {}
for x in ("DEPEND", "RDEPEND", "PDEPEND", "IUSE", "LICENSE"):
data.setdefault(x, "")
cpv = VersionedCPV(cpvstr)
# TODO: make pkgcore generate empty shared pkg data when None is passed
mxml = repo_objs.LocalMetadataXml('')
shared = repo_objs.SharedPkgData(metadata_xml=mxml, manifest=None)
super().__init__(shared, parent, cpv.category, cpv.package, cpv.fullver)
object.__setattr__(self, "data", data)
object.__setattr__(self, "_ebuild", ebuild)
# custom attributes
for attr, value in kwargs.items():
object.__setattr__(self, attr, value)
def _get_packages(self, category):
cpath = pjoin(self.location, category.lstrip(os.path.sep))
l = set()
d = {}
bad = False
try:
for x in listdir_dirs(cpath):
if x.startswith(".tmp.") or x.endswith(".lockfile") \
or x.startswith("-MERGING-"):
continue
try:
pkg = VersionedCPV(f'{category}/{x}')
except InvalidCPV:
bad = True
if bad or not pkg.fullver:
if '-scm' in x:
bad = 'scm'
elif '-try' in x:
bad = 'try'
else:
raise InvalidCPV(f'{category}/{x}', 'no version component')
logger.error(
f'merged -{bad} pkg detected: {category}/{x}. '
f'throwing exception due to -{bad} not being a valid'
' version component. Silently ignoring that '
'specific version is not viable either since it '
'would result in pkgcore stomping whatever it was '
f'that -{bad} version merged. '
'Use the offending pkg manager that merged it to '
'unmerge it.')
raise InvalidCPV(
f'{category}/{x}', f'{bad} version component is not standard.')
l.add(pkg.package)
d.setdefault((category, pkg.package), []).append(pkg.fullver)
except EnvironmentError as e:
category = pjoin(self.location, category.lstrip(os.path.sep))
raise KeyError(f'failed fetching packages for category {category}: {e}') from e
self._versions_tmp_cache.update(d)
return tuple(l)
def _simple_redirect_test(self,
attr,
arg1='=dev-util/diffball-1.0',
arg2=None):
l = []
uniq_obj = object()
def f(*a, **kw):
a = a[1:-1]
l.extend((a, kw))
return uniq_obj
# if replace, override _replace since replace reflects to it
class my_ops(operations):
locals()[f'_cmd_implementation_{attr}'] = f
self.repo.operations_kls = my_ops
args = [self.repo.match(atom(arg1))]
if arg2:
args.append(VersionedCPV(arg2))
self.repo.frozen = False
op = getattr(self.repo.operations, attr)
def simple_check(op, args, **kw):
l[:] = []
assert op(*args, **kw) == uniq_obj
assert len(l) == 2
assert list(l[0]) == args
assert l
assert self.repo.operations.supports(attr)
simple_check(op, args)
assert not l[1]
simple_check(op, args)
assert 'force' not in l[1]
self.repo.frozen = True
assert not self.repo.operations.supports(attr)
assert not hasattr(self.repo.operations, attr)
def test_filtering(self):
repo, vrepo = self.setup_repos()
a = atom("dev-lib/fake")
a2 = atom("dev-util/diffball")
assert sorted(vrepo.itermatch(a)) == sorted(repo.itermatch(a))
assert sorted(vrepo.itermatch(a2)) == []
repo, vrepo = self.setup_repos(atom("=dev-util/diffball-1.0"))
assert sorted(vrepo.itermatch(a)) == sorted(repo.itermatch(a))
assert sorted(vrepo.itermatch(a2)) == sorted(
[VersionedCPV("dev-util/diffball-0.7")])
repo, vrepo = self.setup_repos(
packages.PackageRestriction(
"package",
values.OrRestriction(
*[values.StrExactMatch(x) for x in ("diffball", "fake")])))
assert sorted(vrepo.itermatch(packages.AlwaysTrue)) == \
sorted(repo.itermatch(atom("dev-util/bsdiff")))
# check sentinel value handling.
vrepo = filtered.tree(repo, a2, sentinel_val=True)
assert sorted(x.cpvstr for x in vrepo) == \
sorted(['dev-util/diffball-0.7', 'dev-util/diffball-1.0'])
def _simple_redirect_test(self,
attr,
arg1='=dev-util/diffball-1.0',
arg2=None):
l = []
uniq_obj = object()
def f(*a, **kw):
a = a[1:-1]
l.extend((a, kw))
return uniq_obj
# if replace, override _replace since replace reflects to it
class my_ops(operations):
locals()[f'_cmd_implementation_{attr}'] = f
self.repo.operations_kls = my_ops
args = [self.repo.match(atom(arg1))]
if arg2:
args.append(VersionedCPV(arg2))
self.repo.frozen = False
op = getattr(self.repo.operations, attr)
def simple_check(op, args, **kw):
l[:] = []
self.assertEqual(op(*args, **kw), uniq_obj)
self.assertEqual(len(l), 2)
self.assertEqual(list(l[0]), args)
self.assertTrue(l)
self.assertTrue(self.repo.operations.supports(attr))
simple_check(op, args)
self.assertFalse(l[1])
simple_check(op, args)
self.assertNotIn('force', l[1])
self.repo.frozen = True
self.assertFalse(self.repo.operations.supports(attr))
self.assertFalse(hasattr(self.repo.operations, attr))
def _get_packages(self, category):
cpath = pjoin(self.base, category.lstrip(os.path.sep))
l = set()
d = {}
lext = len(self.extension)
bad = False
try:
for x in listdir_files(cpath):
# don't use lstat; symlinks may exist
if (x.endswith(".lockfile")
or not x[-lext:].lower() == self.extension
or x.startswith(".tmp.")):
continue
pv = x[:-lext]
pkg = VersionedCPV(f'{category}/{pv}')
l.add(pkg.package)
d.setdefault((category, pkg.package), []).append(pkg.fullver)
except EnvironmentError as e:
raise KeyError(
"failed fetching packages for category %s: %s" % (pjoin(
self.base, category.lstrip(os.path.sep)), str(e))) from e
self._versions_tmp_cache.update(d)
return tuple(l)
def test_identify_candidates(self):
with pytest.raises(TypeError):
self.repo.match("asdf")
rc = packages.PackageRestriction("category",
values.StrExactMatch("dev-util"))
assert \
sorted(set(x.package for x in self.repo.itermatch(rc))) == \
sorted(["diffball", "bsdiff"])
rp = packages.PackageRestriction("package",
values.StrExactMatch("diffball"))
assert list(
x.version
for x in self.repo.itermatch(rp, sorter=sorted)) == ["0.7", "1.0"]
assert \
self.repo.match(packages.OrRestriction(rc, rp), sorter=sorted) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2"))
assert \
sorted(self.repo.itermatch(packages.AndRestriction(rc, rp))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0"))
assert sorted(self.repo) == self.repo.match(packages.AlwaysTrue,
sorter=sorted)
# mix/match cat/pkg to check that it handles that corner case
# properly for sorting.
assert \
sorted(self.repo, reverse=True) == \
self.repo.match(packages.OrRestriction(
rc, rp, packages.AlwaysTrue),
sorter=partial(sorted, reverse=True))
rc2 = packages.PackageRestriction("category",
values.StrExactMatch("dev-lib"))
assert sorted(self.repo.itermatch(packages.AndRestriction(rp,
rc2))) == []
# note this mixes a category level match, and a pkg level
# match. they *must* be treated as an or.
assert \
sorted(self.repo.itermatch(packages.OrRestriction(rp, rc2))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
# this is similar to the test above, but mixes a cat/pkg
# candidate with a pkg candidate
rp2 = packages.PackageRestriction("package",
values.StrExactMatch("fake"))
r = packages.OrRestriction(atom("dev-util/diffball"), rp2)
assert \
sorted(self.repo.itermatch(r)) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(
packages.OrRestriction(packages.AlwaysTrue, rp2))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-util', negate=True)))) == \
sorted(VersionedCPV(x) for x in ("dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
obj = malleable_obj(livefs=False)
pkg_cls = post_curry(MutatedPkg, {'repo': obj})
assert \
sorted(self.repo.itermatch(boolean.AndRestriction(boolean.OrRestriction(
packages.PackageRestriction(
"repo.livefs", values.EqualityMatch(False)),
packages.PackageRestriction(
"category", values.StrExactMatch("virtual"))),
atom("dev-lib/fake")),
pkg_cls=pkg_cls)) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-lib', negate=True),
negate=True))) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-lib', negate=True), negate=True))) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))