def test_ambiguous(self):
repo = SimpleTree({
'spork': {'foon': ('1',)},
'spork2': {'foon': ('2',)}})
installed_repos = SimpleTree({'foo': {'bar': ('1',)}})
with pytest.raises(pmerge.AmbiguousQuery):
pmerge.parse_target(parse_match("foon"), repo, installed_repos)
def test_globbing(self):
repo = SimpleTree({
'spork': {'foon': ('1',)},
'spork2': {'foon': ('2',)}})
installed_repos = SimpleTree({'foo': {'bar': ('1',)}})
a = pmerge.parse_target(parse_match('*/foon'), repo, installed_repos)
assert len(a) == 2
def test_no_matches(self):
repo = SimpleTree({
'spork': {'foon': ('1',)},
'spork2': {'foon': ('2',)}})
installed_repos = SimpleTree({'foo': {'bar': ('1',)}})
with pytest.raises(pmerge.NoMatches):
pmerge.parse_target(parse_match("foo"), repo, installed_repos)
def test_collision_livefs(self):
# test pkg name collision between real and virtual pkgs on livefs
# repos, the real pkg will be selected over the virtual
installed_repos = SimpleTree({'foo': {'bar': ('1',)}, 'virtual': {'bar': ('0',)}})
repo = SimpleTree({'foo': {'bar': ('1',)}, 'virtual': {'bar': ('1',)}})
a = pmerge.parse_target(parse_match("bar"), repo, installed_repos)
assert len(a) == 1
assert a[0].key == 'foo/bar'
assert [x.key for x in repo.match(a[0])] == ['foo/bar']
def test_base_targets(self):
repo = SimpleTree({'spork': {'foon': ('1', '1.0.1', '2')}})
installed_repos = SimpleTree({'foo': {'bar': ('1',)}})
for cat in ('', 'spork/'):
a = pmerge.parse_target(parse_match(f'={cat}foon-1'), repo, installed_repos)
assert len(a) == 1
assert a[0].key == 'spork/foon'
assert [x.fullver for x in repo.itermatch(a[0])] == ['1']
a = pmerge.parse_target(parse_match(f'{cat}foon'), repo, installed_repos)
assert len(a) == 1
assert a[0].key == 'spork/foon'
assert (
sorted(x.fullver for x in repo.itermatch(a[0])) ==
sorted(['1', '1.0.1', '2'])
)
def setUp(self):
self.d1, self.d2 = {}, {}
for key, ver in self.tree1_pkgs:
cat, pkg = key.rsplit("/", 1)
self.d1.setdefault(cat, {}).setdefault(pkg, []).extend(ver)
for key, ver in self.tree2_pkgs:
cat, pkg = key.rsplit("/", 1)
self.d2.setdefault(cat, {}).setdefault(pkg, []).extend(ver)
self.d1 = OrderedDict((k, OrderedDict(self.d1[k].items()))
for k in sorted(self.d1, reverse=True))
self.d2 = OrderedDict((k, OrderedDict(self.d2[k].items()))
for k in sorted(self.d2, reverse=True))
self.tree1 = SimpleTree(self.d1)
self.tree2 = SimpleTree(self.d2)
self.ctree = self.kls(self.tree1, self.tree2)
def __init__(self, masked_use={}, forced_use={},
provides={}, masks=[], virtuals={}, arch='x86', name='none'):
self.provides_repo = SimpleTree(provides)
self.masked_use = {atom(k): v for k,v in masked_use.iteritems()}
self.forced_use = {atom(k): v for k,v in forced_use.iteritems()}
self.masks = tuple(map(atom, masks))
self.virtuals = SimpleTree(virtuals)
self.arch = arch
self.name = name
self.forced_data = collapsed_restrict_to_data(
[(AlwaysTrue, (self.arch,))],
self.forced_use.iteritems())
self.masked_data = collapsed_restrict_to_data(
[(AlwaysTrue, default_arches)],
self.masked_use.iteritems())
def setUp(self):
# we use an OrderedDict here specifically to trigger any sorter
# related bugs
d = {
"dev-util": {"diffball": ["1.0", "0.7"], "bsdiff": ["0.4.1", "0.4.2"]},
"dev-lib": {"fake": ["1.0", "1.0-r1"]}}
self.repo = SimpleTree(
OrderedDict((k, d[k]) for k in sorted(d, reverse=True)))
def setup_repos(self, restrictions=None):
repo = SimpleTree({
"dev-util": {"diffball": ["1.0", "0.7"], "bsdiff": ["0.4.1", "0.4.2"]},
"dev-lib": {"fake": ["1.0", "1.0-r1"]}})
if restrictions is None:
restrictions = atom("dev-util/diffball")
vrepo = filtered.tree(repo, restrictions)
return repo, vrepo
def test_iter(self):
fake_vdb = SimpleTree({"dev-util": {"diffball":["1.0"],
"bsdiff":["1.2", "1.3"]}}, pkg_klass=FakePkg)
ipkgset = installed.Installed([fake_vdb])
self.assertEqual(sorted(["dev-util/diffball",
"dev-util/bsdiff", "dev-util/bsdiff"]),
sorted(ipkgset))
vpkgset = installed.VersionedInstalled([fake_vdb])
self.assertEqual(sorted(["dev-util/diffball-1.0",
"dev-util/bsdiff-1.2", "dev-util/bsdiff-1.3"]),
sorted(vpkgset))
def __init__(self,
masked_use={},
stable_masked_use={},
forced_use={},
stable_forced_use={},
pkg_use={},
provides={},
iuse_effective=[],
use=[],
masks=[],
unmasks=[],
arch='x86',
name='none'):
self.provides_repo = SimpleTree(provides)
self.masked_use = ChunkedDataDict()
self.masked_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in masked_use.items())
self.masked_use.freeze()
self.stable_masked_use = ChunkedDataDict()
self.stable_masked_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in stable_masked_use.items())
self.stable_masked_use.freeze()
self.forced_use = ChunkedDataDict()
self.forced_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in forced_use.items())
self.forced_use.freeze()
self.stable_forced_use = ChunkedDataDict()
self.stable_forced_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in stable_forced_use.items())
self.stable_forced_use.freeze()
self.pkg_use = ChunkedDataDict()
self.pkg_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in pkg_use.items())
self.pkg_use.freeze()
self.masks = tuple(map(atom, masks))
self.unmasks = tuple(map(atom, unmasks))
self.iuse_effective = set(iuse_effective)
self.use = set(use)
self.key = arch
self.name = name
vfilter = domain.generate_filter(self.masks, self.unmasks)
self.visible = vfilter.match
def _tmp_validate_args(parser, namespace):
tmpdir = namespace.domain.pm_tmpdir
dirs = ()
files = ()
if namespace.restrict and not namespace.wipe_all:
# create a fake repo from tmpdir entries and pull matches from it
pkg_map = {}
for pkg_build_dir in glob.glob(pjoin(tmpdir, '*', '*')):
try:
pkg = atom_mod.atom(
'=' + pkg_build_dir[len(tmpdir):].lstrip(os.path.sep))
except atom_mod.MalformedAtom:
continue
pkg_map.setdefault(pkg.category,
{}).setdefault(pkg.package,
[]).append(pkg.fullver)
repo = SimpleTree(pkg_map)
def _remove_dir_and_empty_parent(d):
"""Remove a given directory tree and its parent directory, if empty."""
shutil.rmtree(d)
try:
os.rmdir(os.path.dirname(d))
except OSError as e:
# POSIX specifies either ENOTEMPTY or EEXIST for non-empty dir
# in particular, Solaris uses EEXIST in that case.
if e.errno not in (errno.ENOTEMPTY, errno.EEXIST):
raise
removal_func = partial(_remove_dir_and_empty_parent)
dirs = ((removal_func, pjoin(tmpdir, pkg.cpvstr))
for pkg in repo.itermatch(namespace.restrict))
else:
# not in a configured repo dir, remove all tmpdir entries
dir_removal_func = partial(shutil.rmtree)
dirs = ((dir_removal_func, pjoin(tmpdir, d))
for d in listdir_dirs(tmpdir))
file_removal_func = partial(os.remove)
files = ((file_removal_func, pjoin(tmpdir, f))
for f in listdir_files(tmpdir))
namespace.remove = chain(dirs, files)
def __init__(self,
masked_use={},
stable_masked_use={},
forced_use={},
stable_forced_use={},
provides={},
iuse_effective=[],
masks=[],
unmasks=[],
arch='x86',
name='none'):
self.provides_repo = SimpleTree(provides)
self.masked_use = ChunkedDataDict()
self.masked_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in masked_use.iteritems())
self.masked_use.freeze()
self.stable_masked_use = ChunkedDataDict()
self.stable_masked_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in stable_masked_use.iteritems())
self.stable_masked_use.freeze()
self.forced_use = ChunkedDataDict()
self.forced_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in forced_use.iteritems())
self.forced_use.freeze()
self.stable_forced_use = ChunkedDataDict()
self.stable_forced_use.update_from_stream(
chunked_data(atom(k), *split_negations(v))
for k, v in stable_forced_use.iteritems())
self.stable_forced_use.freeze()
self.masks = tuple(map(atom, masks))
self.unmasks = tuple(map(atom, unmasks))
self.iuse_effective = tuple(iuse_effective)
self.arch = arch
self.name = name
