364d7f5229
With this patch the gather_source option is no longer used. Instead, all sources are always used. If they return at least some input packages, then a configured method is used and the returned lists of packages from all sources are merged. The method used for gathering can be configured for each variant and gather source separately. Additional packages are only added to the comps source. Each gathering step is logged separately. All the logs are preserved for later inspection. Signed-off-by: Lubomír Sedlář <lsedlar@redhat.com>
904 lines
41 KiB
Python
904 lines
41 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import copy
|
|
import mock
|
|
import os
|
|
import sys
|
|
|
|
try:
|
|
import unittest2 as unittest
|
|
except ImportError:
|
|
import unittest
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
|
|
|
|
from pungi.phases import gather
|
|
from pungi.phases.gather import _mk_pkg_map
|
|
from tests import helpers
|
|
|
|
|
|
class MockPackageSet(dict):
|
|
def __init__(self, *args):
|
|
for pkg in args:
|
|
self[pkg.path] = pkg
|
|
|
|
|
|
class MockPkg(object):
|
|
def __init__(self, path, is_system_release=False):
|
|
self.path = path
|
|
self.is_system_release = is_system_release
|
|
filename = os.path.basename(path)
|
|
self.nvr, self.arch, _ = filename.rsplit('.', 2)
|
|
self.name, self.version, self.release = self.nvr.rsplit('-', 2)
|
|
|
|
def __repr__(self):
|
|
return self.nvr
|
|
|
|
def __lt__(self, another):
|
|
return self.nvr < another.nvr
|
|
|
|
|
|
def _join(a, *rest):
|
|
res = copy.deepcopy(a)
|
|
for b in rest:
|
|
for key in res:
|
|
res[key].extend(b[key])
|
|
return res
|
|
|
|
|
|
class TestGatherWrapper(helpers.PungiTestCase):
|
|
|
|
def setUp(self):
|
|
super(TestGatherWrapper, self).setUp()
|
|
self.compose = helpers.DummyCompose(self.topdir, {})
|
|
self.package_set = mock.Mock()
|
|
self.variant = helpers.MockVariant(
|
|
uid='Server', arches=['x86_64'], type='variant')
|
|
self.optional = helpers.MockVariant(
|
|
uid='Server-optional', arches=['x86_64'], type='optional', parent=self.variant)
|
|
self.addon = helpers.MockVariant(
|
|
uid='Server-HA', arches=['x86_64'], type='addon', parent=self.variant)
|
|
self.lp = helpers.MockVariant(
|
|
uid='Server-LP', arches=['x86_64'], type='layered-product', parent=self.variant)
|
|
self.server_packages = {
|
|
"rpm": [{'path': '/build/foo-1.0-1.x86_64.rpm', 'flags': ['input']}],
|
|
"srpm": [{'path': '/build/foo-1.0-1.src.rpm', 'flags': []}],
|
|
"debuginfo": [{'path': '/build/foo-debuginfo-1.0-1.x86_64.rpm', 'flags': []}],
|
|
}
|
|
self.maxDiff = None
|
|
|
|
def _dummy_gather(self, compose, arch, variant, package_sets, **kwargs):
|
|
self.assertEqual(
|
|
package_sets, self.package_set,
|
|
'Called gather_packages on %s.%s with bad package sets' % (variant.uid, arch))
|
|
if variant.uid == 'Server':
|
|
return self.server_packages
|
|
if variant.uid == 'Server-optional':
|
|
return self.optional_packages
|
|
if variant.uid == 'Server-HA':
|
|
return self.addon_packages
|
|
if variant.uid == 'Server-LP':
|
|
return self.lp_packages
|
|
self.assertFalse('This should not be reached - variant %s' % variant.uid)
|
|
|
|
@mock.patch('pungi.phases.gather.write_packages')
|
|
@mock.patch('pungi.phases.gather.gather_packages')
|
|
def test_single_variant(self, gather_packages, write_packages):
|
|
# There is only one variant: exactly the packages returned by gather
|
|
# method should be returned without modifications.
|
|
self.compose.all_variants = {'Server': self.variant}
|
|
|
|
expected_server_packages = copy.deepcopy(self.server_packages)
|
|
|
|
gather_packages.side_effect = self._dummy_gather
|
|
|
|
result = gather.gather_wrapper(self.compose, self.package_set, '/build')
|
|
|
|
self.assertEqual(result, {'x86_64': {'Server': expected_server_packages}})
|
|
self.assertEqual(
|
|
write_packages.call_args_list,
|
|
[mock.call(self.compose, 'x86_64', self.variant,
|
|
expected_server_packages, path_prefix='/build')])
|
|
|
|
@mock.patch('pungi.phases.gather.write_packages')
|
|
@mock.patch('pungi.phases.gather.gather_packages')
|
|
def test_addon(self, gather_packages, write_packages):
|
|
# Addon has all packages that parent has, plus one extra input package
|
|
# and one fulltree-exclude package. Only the input one should remain in
|
|
# addon, and the fulltree one should move to parent.
|
|
self.compose.all_variants = {'Server': self.variant, 'Server-HA': self.addon}
|
|
|
|
move_to_parent = {'path': '/build/foo-common-1.0-1.x86_64.rpm', 'flags': ['fulltree-exclude']}
|
|
keep_in_addon = {'path': '/build/bar-1.0-1.x86_64.rpm', 'flags': ['input']}
|
|
expected_server_packages = _join(self.server_packages, _mk_pkg_map([move_to_parent]))
|
|
self.addon_packages = _join(self.server_packages, _mk_pkg_map([keep_in_addon, move_to_parent]))
|
|
expected_addon_packages = _mk_pkg_map(
|
|
[{'path': '/build/bar-1.0-1.x86_64.rpm', 'flags': ['input']}])
|
|
|
|
gather_packages.side_effect = self._dummy_gather
|
|
|
|
result = gather.gather_wrapper(self.compose, self.package_set, '/build')
|
|
|
|
self.assertEqual(result, {'x86_64': {'Server': expected_server_packages,
|
|
'Server-HA': expected_addon_packages}})
|
|
self.assertItemsEqual(
|
|
write_packages.call_args_list,
|
|
[mock.call(self.compose, 'x86_64', self.variant,
|
|
expected_server_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.addon,
|
|
expected_addon_packages, path_prefix='/build')])
|
|
|
|
@mock.patch('pungi.phases.gather.write_packages')
|
|
@mock.patch('pungi.phases.gather.gather_packages')
|
|
def test_layered_product(self, gather_packages, write_packages):
|
|
# This test is pretty much identical to the one for addon.
|
|
self.compose.all_variants = {'Server': self.variant, 'Server-LP': self.lp}
|
|
|
|
move_to_parent = {'path': '/build/foo-common-1.0-1.x86_64.rpm', 'flags': ['fulltree-exclude']}
|
|
keep_in_lp = {'path': '/build/bar-1.0-1.x86_64.rpm', 'flags': ['input']}
|
|
expected_server_packages = copy.deepcopy(self.server_packages)
|
|
expected_server_packages['rpm'].append(move_to_parent)
|
|
self.lp_packages = _join(self.server_packages, _mk_pkg_map([keep_in_lp, move_to_parent]))
|
|
expected_lp_packages = _mk_pkg_map(
|
|
[{'path': '/build/bar-1.0-1.x86_64.rpm', 'flags': ['input']}])
|
|
|
|
gather_packages.side_effect = self._dummy_gather
|
|
|
|
result = gather.gather_wrapper(self.compose, self.package_set, '/build')
|
|
|
|
self.assertEqual(result, {'x86_64': {'Server': expected_server_packages,
|
|
'Server-LP': expected_lp_packages}})
|
|
self.assertItemsEqual(
|
|
write_packages.call_args_list,
|
|
[mock.call(self.compose, 'x86_64', self.variant,
|
|
expected_server_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.lp,
|
|
expected_lp_packages, path_prefix='/build')])
|
|
|
|
@mock.patch('pungi.phases.gather.write_packages')
|
|
@mock.patch('pungi.phases.gather.gather_packages')
|
|
def test_optional(self, gather_packages, write_packages):
|
|
# All packages in optional that are present in parent should be removed
|
|
# from optional. There is no move to parent here.
|
|
self.compose.all_variants = {'Server': self.variant, 'Server-optional': self.optional}
|
|
|
|
expected_server_packages = copy.deepcopy(self.server_packages)
|
|
self.optional_packages = _join(self.server_packages, _mk_pkg_map(
|
|
[{'path': '/build/bar-1.0-1.x86_64.rpm', 'flags': ['input']},
|
|
{'path': '/build/foo-common-1.0-1.x86_64.rpm', 'flags': ['fulltree-exclude']}]))
|
|
expected_optional_packages = _mk_pkg_map(
|
|
[{'path': '/build/bar-1.0-1.x86_64.rpm', 'flags': ['input']}])
|
|
|
|
gather_packages.side_effect = self._dummy_gather
|
|
|
|
result = gather.gather_wrapper(self.compose, self.package_set, '/build')
|
|
|
|
self.assertEqual(result, {'x86_64': {'Server': expected_server_packages,
|
|
'Server-optional': expected_optional_packages}})
|
|
self.assertItemsEqual(
|
|
write_packages.call_args_list,
|
|
[mock.call(self.compose, 'x86_64', self.variant,
|
|
expected_server_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.optional,
|
|
expected_optional_packages, path_prefix='/build')])
|
|
|
|
@mock.patch('pungi.phases.gather.write_packages')
|
|
@mock.patch('pungi.phases.gather.gather_packages')
|
|
def test_all(self, gather_packages, write_packages):
|
|
# Addon contains an extra package compared to parent. Layered product
|
|
# contains an extra package compared to addon. Optional has one extra
|
|
# package on it's own compared to addon. Only the one extra package
|
|
# should remain in all non-parent variants.
|
|
#
|
|
# There are also two packages that should move to parent variant. Addon
|
|
# has one of them, layered product has both.
|
|
self.compose.all_variants = {'Server': self.variant, 'Server-optional': self.optional,
|
|
'Server-HA': self.addon, 'Server-LP': self.lp}
|
|
|
|
addon_extra_package = {'path': '/build/foo-addon-1.0.1-1.noarch.rpm', 'flags': []}
|
|
lp_extra_package = {'path': '/build/foo-layer-1.0.1-1.noarch.rpm', 'flags': []}
|
|
optional_extra_package = {'path': '/build/foo-optional-1.0.1-1.noarch.rpm', 'flags': []}
|
|
move_from_addon = {'path': '/build/foo-addon-contrib-1.0-1.noarch.rpm', 'flags': ['fulltree-exclude']}
|
|
move_from_lp = {'path': '/build/foo-layer-contrib-1.0-1.noarch.rpm', 'flags': ['fulltree-exclude']}
|
|
|
|
self.addon_packages = _join(self.server_packages, _mk_pkg_map(
|
|
[addon_extra_package, move_from_addon]))
|
|
self.lp_packages = _join(self.addon_packages, _mk_pkg_map(
|
|
[lp_extra_package, move_from_lp]))
|
|
self.optional_packages = _join(self.lp_packages, _mk_pkg_map(
|
|
[optional_extra_package]))
|
|
|
|
expected_server_packages = _join(self.server_packages, _mk_pkg_map(
|
|
[move_from_addon, move_from_lp]))
|
|
expected_addon_packages = _mk_pkg_map([addon_extra_package])
|
|
expected_lp_packages = _mk_pkg_map([lp_extra_package])
|
|
expected_optional_packages = _mk_pkg_map([optional_extra_package])
|
|
|
|
gather_packages.side_effect = self._dummy_gather
|
|
|
|
result = gather.gather_wrapper(self.compose, self.package_set, '/build')
|
|
|
|
self.assertEqual(result, {'x86_64': {'Server': expected_server_packages,
|
|
'Server-optional': expected_optional_packages,
|
|
'Server-HA': expected_addon_packages,
|
|
'Server-LP': expected_lp_packages}})
|
|
self.assertItemsEqual(
|
|
write_packages.call_args_list,
|
|
[mock.call(self.compose, 'x86_64', self.compose.all_variants['Server'],
|
|
expected_server_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.compose.all_variants['Server-optional'],
|
|
expected_optional_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.compose.all_variants['Server-HA'],
|
|
expected_addon_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.compose.all_variants['Server-LP'],
|
|
expected_lp_packages, path_prefix='/build')])
|
|
|
|
@mock.patch('pungi.phases.gather.write_packages')
|
|
@mock.patch('pungi.phases.gather.gather_packages')
|
|
def test_keep_srpm_in_lp(self, gather_packages, write_packages):
|
|
# There is one binary and source package in addon and lp but not in
|
|
# parent. Addon should remain unchanged and the binary package should
|
|
# disappear from lp.
|
|
# This seems peculiar and may not be correct.
|
|
self.compose.all_variants = {'Server': self.variant,
|
|
'Server-HA': self.addon,
|
|
'Server-LP': self.lp}
|
|
|
|
addon_extra_package = {'path': '/build/foo-addon-1.0.1-1.noarch.rpm', 'flags': []}
|
|
addon_extra_source = {'path': '/build/foo-addon-1.0.1-1.src.rpm', 'flags': []}
|
|
|
|
self.addon_packages = _join(self.server_packages, _mk_pkg_map(
|
|
[addon_extra_package], [addon_extra_source]))
|
|
self.lp_packages = _join(self.addon_packages)
|
|
|
|
expected_server_packages = _join(self.server_packages)
|
|
expected_addon_packages = _mk_pkg_map([addon_extra_package], [addon_extra_source])
|
|
expected_lp_packages = _mk_pkg_map([], [addon_extra_source])
|
|
|
|
gather_packages.side_effect = self._dummy_gather
|
|
|
|
result = gather.gather_wrapper(self.compose, self.package_set, '/build')
|
|
|
|
self.assertEqual(result, {'x86_64': {'Server': expected_server_packages,
|
|
'Server-HA': expected_addon_packages,
|
|
'Server-LP': expected_lp_packages}})
|
|
self.assertItemsEqual(
|
|
write_packages.call_args_list,
|
|
[mock.call(self.compose, 'x86_64', self.compose.all_variants['Server'],
|
|
expected_server_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.compose.all_variants['Server-HA'],
|
|
expected_addon_packages, path_prefix='/build'),
|
|
mock.call(self.compose, 'x86_64', self.compose.all_variants['Server-LP'],
|
|
expected_lp_packages, path_prefix='/build')])
|
|
|
|
|
|
class TestGetSystemRelease(unittest.TestCase):
|
|
def setUp(self):
|
|
self.compose = mock.Mock()
|
|
self.variant = helpers.MockVariant(uid='Server', arches=['x86_64'],
|
|
type='variant')
|
|
self.addon = helpers.MockVariant(uid='Server-HA', arches=['x86_64'],
|
|
type='addon', parent=self.variant)
|
|
|
|
def test_no_package_set(self):
|
|
self.assertEqual(
|
|
gather.get_system_release_packages(self.compose, 'x86_64',
|
|
self.variant, None),
|
|
(set(), set())
|
|
)
|
|
|
|
def test_no_arch_in_package_set(self):
|
|
self.assertEqual(
|
|
gather.get_system_release_packages(self.compose, 'x86_64',
|
|
self.variant, {}),
|
|
(set(), set())
|
|
)
|
|
|
|
def test_no_system_release_package(self):
|
|
pkgset = MockPackageSet(MockPkg('/build/bash-1.0.0-1.x86_64.rpm'))
|
|
packages, filter_packages = gather.get_system_release_packages(
|
|
self.compose, 'x86_64', self.variant, {'x86_64': pkgset})
|
|
|
|
self.assertItemsEqual(packages, [])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
def test_picks_single(self):
|
|
pkgset = MockPackageSet(
|
|
MockPkg('/build/dummy-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
)
|
|
packages, filter_packages = gather.get_system_release_packages(
|
|
self.compose, 'x86_64', self.variant, {'x86_64': pkgset})
|
|
|
|
self.assertItemsEqual(packages, [('dummy', None)])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
def test_prefers_variant(self):
|
|
pkgset = MockPackageSet(
|
|
MockPkg('/build/system-release-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
MockPkg('/build/system-release-server-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
)
|
|
packages, filter_packages = gather.get_system_release_packages(
|
|
self.compose, 'x86_64', self.variant, {'x86_64': pkgset})
|
|
|
|
self.assertItemsEqual(packages, [('system-release-server', None)])
|
|
self.assertItemsEqual(filter_packages, [('system-release', None)])
|
|
|
|
def test_no_best_match(self):
|
|
pkgset = MockPackageSet(
|
|
MockPkg('/build/system-release-foo-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
MockPkg('/build/system-release-bar-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
)
|
|
packages, filter_packages = gather.get_system_release_packages(
|
|
self.compose, 'x86_64', self.variant, {'x86_64': pkgset})
|
|
|
|
# In this case a random package is picked, so let's check that both
|
|
# list contain one package and that they are different.
|
|
self.assertEqual(len(packages), 1)
|
|
self.assertEqual(len(filter_packages), 1)
|
|
self.assertNotEqual(packages, filter_packages)
|
|
|
|
def test_optional_picks_parent(self):
|
|
pkgset = MockPackageSet(
|
|
MockPkg('/build/system-release-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
MockPkg('/build/system-release-server-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
MockPkg('/build/system-release-client-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
)
|
|
packages, filter_packages = gather.get_system_release_packages(
|
|
self.compose, 'x86_64', self.addon, {'x86_64': pkgset})
|
|
|
|
self.assertItemsEqual(packages, [('system-release-server', None)])
|
|
self.assertItemsEqual(filter_packages,
|
|
[('system-release-client', None),
|
|
('system-release', None)])
|
|
|
|
|
|
class TestTrimPackages(unittest.TestCase):
|
|
def setUp(self):
|
|
self.compose = mock.Mock()
|
|
self.variant = helpers.MockVariant(uid='Server', arches=['x86_64'],
|
|
type='variant')
|
|
self.addon = helpers.MockVariant(uid='Server-HA', arches=['x86_64'],
|
|
type='addon', parent=self.variant)
|
|
|
|
def test_trim_toplevel(self):
|
|
self.assertIsNone(gather.trim_packages(self.compose, 'x86_64', self.variant, {}))
|
|
|
|
def test_remove_package_explicitly(self):
|
|
to_remove = {'path': '/build/required-1.0.0-1.x86_64.rpm', 'flags': ['input']}
|
|
to_keep = {'path': '/build/empty-1.0.0-1.x86_64.rpm', 'flags': []}
|
|
pkg_map = _mk_pkg_map([to_remove, to_keep])
|
|
addon_pkgs, moved_to_parent, removed_pkgs = gather.trim_packages(
|
|
self.compose, 'x86_64', self.addon, pkg_map, remove_pkgs={'rpm': ['required']})
|
|
|
|
self.assertEqual(removed_pkgs, _mk_pkg_map([to_remove]))
|
|
self.assertEqual(addon_pkgs, _mk_pkg_map(set(['empty']), iterable_class=set))
|
|
self.assertEqual(moved_to_parent, _mk_pkg_map())
|
|
self.assertEqual(pkg_map, _mk_pkg_map([to_keep]))
|
|
|
|
def test_remove_package_present_in_parent(self):
|
|
# packages present in parent will be removed from addon
|
|
parent_pkgs = {
|
|
'rpm': [
|
|
('wanted', 'x86_64'),
|
|
]
|
|
}
|
|
to_remove = {'path': '/build/wanted-1.0.0-1.x86_64.rpm', 'flags': []}
|
|
pkg_map = _mk_pkg_map([to_remove])
|
|
addon_pkgs, moved_to_parent, removed_pkgs = gather.trim_packages(
|
|
self.compose, 'x86_64', self.addon, pkg_map, parent_pkgs=parent_pkgs)
|
|
|
|
self.assertEqual(removed_pkgs, _mk_pkg_map([to_remove]))
|
|
self.assertEqual(addon_pkgs, _mk_pkg_map(iterable_class=set))
|
|
self.assertEqual(moved_to_parent, _mk_pkg_map())
|
|
self.assertEqual(pkg_map, _mk_pkg_map())
|
|
|
|
def test_move_package_to_parent(self):
|
|
# fulltree-exclude packages in addon only will move to parent
|
|
to_move = {'path': '/build/wanted-1.0.0-1.x86_64.rpm', 'flags': ['fulltree-exclude']}
|
|
pkg_map = _mk_pkg_map([to_move])
|
|
addon_pkgs, moved_to_parent, removed_pkgs = gather.trim_packages(
|
|
self.compose, 'x86_64', self.addon, pkg_map, parent_pkgs={'rpm': []})
|
|
|
|
self.assertEqual(removed_pkgs, _mk_pkg_map())
|
|
self.assertEqual(addon_pkgs, _mk_pkg_map(iterable_class=set))
|
|
self.assertEqual(moved_to_parent, _mk_pkg_map([to_move]))
|
|
self.assertEqual(pkg_map, _mk_pkg_map())
|
|
|
|
def test_keep_explicit_input_in_addon(self):
|
|
# fulltree-exclude packages explictly in addon will be kept in addon
|
|
parent_pkgs = {'rpm': []}
|
|
pkg = {'path': '/build/wanted-1.0.0-1.x86_64.rpm', 'flags': ['fulltree-exclude', 'input']}
|
|
pkg_map = _mk_pkg_map([pkg])
|
|
addon_pkgs, moved_to_parent, removed_pkgs = gather.trim_packages(
|
|
self.compose, 'x86_64', self.addon, pkg_map, parent_pkgs=parent_pkgs)
|
|
|
|
self.assertEqual(removed_pkgs, _mk_pkg_map())
|
|
self.assertEqual(addon_pkgs, _mk_pkg_map(set(['wanted']), iterable_class=set))
|
|
self.assertEqual(moved_to_parent, _mk_pkg_map())
|
|
self.assertEqual(pkg_map, _mk_pkg_map([pkg]))
|
|
|
|
|
|
class TestWritePackages(helpers.PungiTestCase):
|
|
def test_write_packages(self):
|
|
self.compose = helpers.DummyCompose(self.topdir, {})
|
|
pkg_map = {
|
|
'rpm': [
|
|
{'path': '/build/foo-1.0-1.x86_64.rpm', 'flags': []},
|
|
{'path': '/build/foo-common-1.0-1.x86_64.rpm', 'flags': []},
|
|
{'path': '/alt/build/bar-1.0-1.noarch.rpm', 'flags': []},
|
|
],
|
|
'srpm': [
|
|
{'path': '/build/foo-1.0-1.src.rpm', 'flags': []},
|
|
{'path': '/alt/build/bar-1.0-1.src.rpm', 'flags': []},
|
|
],
|
|
'debuginfo': [
|
|
{'path': '/build/foo-debuginfo-1.0-1.x86_64.rpm', 'flags': []},
|
|
],
|
|
}
|
|
gather.write_packages(self.compose, 'x86_64', self.compose.variants['Server'], pkg_map, '/alt')
|
|
|
|
with open(os.path.join(self.topdir, 'work', 'x86_64', 'package_list',
|
|
'Server.x86_64.rpm.conf')) as f:
|
|
self.assertItemsEqual(f.read().strip().split('\n'),
|
|
['/build/foo-1.0-1.x86_64.rpm',
|
|
'/build/foo-common-1.0-1.x86_64.rpm',
|
|
'/build/bar-1.0-1.noarch.rpm'])
|
|
|
|
with open(os.path.join(self.topdir, 'work', 'x86_64', 'package_list',
|
|
'Server.x86_64.srpm.conf')) as f:
|
|
self.assertItemsEqual(f.read().strip().split('\n'),
|
|
['/build/foo-1.0-1.src.rpm',
|
|
'/build/bar-1.0-1.src.rpm'])
|
|
|
|
with open(os.path.join(self.topdir, 'work', 'x86_64', 'package_list',
|
|
'Server.x86_64.debuginfo.conf')) as f:
|
|
self.assertItemsEqual(f.read().strip().split('\n'),
|
|
['/build/foo-debuginfo-1.0-1.x86_64.rpm'])
|
|
|
|
|
|
class TestGetVariantPackages(helpers.PungiTestCase):
|
|
def test_no_variant(self):
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', None, 'comps')
|
|
self.assertItemsEqual(packages, [])
|
|
self.assertItemsEqual(groups, [])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_just_source(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set(['foo']), set(['core'])))
|
|
)
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', compose.variants['Server'], 'comps')
|
|
self.assertItemsEqual(packages, ['foo'])
|
|
self.assertItemsEqual(groups, ['core'])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_filter_system_release(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set(), set()))
|
|
)
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
pkgset = MockPackageSet(
|
|
MockPkg('/build/system-release-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
MockPkg('/build/system-release-server-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
)
|
|
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', compose.variants['Server'], 'comps', package_sets={'x86_64': pkgset})
|
|
self.assertItemsEqual(packages, [('system-release-server', None)])
|
|
self.assertItemsEqual(groups, [])
|
|
self.assertItemsEqual(filter_packages, [('system-release', None)])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_disable_filter_system_release(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set([]), set([])))
|
|
)
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'filter_system_release_packages': False
|
|
})
|
|
pkgset = MockPackageSet(
|
|
MockPkg('/build/system-release-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
MockPkg('/build/system-release-server-1.0.0-1.x86_64.rpm', is_system_release=True),
|
|
)
|
|
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', compose.variants['Server'], 'comps', package_sets={'x86_64': pkgset})
|
|
self.assertItemsEqual(packages, [])
|
|
self.assertItemsEqual(groups, [])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_optional_gets_parent_and_addon(self, get_gather_source):
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
compose.setup_optional()
|
|
compose.setup_addon()
|
|
|
|
def dummy_source(arch, variant):
|
|
if variant.uid == 'Server':
|
|
return (set(['server-pkg']), set(['server-group']))
|
|
if variant.uid == 'Server-HA':
|
|
return (set(['addon-pkg']), set(['addon-group']))
|
|
if variant.uid == 'Server-optional':
|
|
return (set(['opt-pkg']), set(['opt-group']))
|
|
self.assertFalse('This should not be reached')
|
|
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(side_effect=dummy_source)
|
|
)
|
|
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', compose.all_variants['Server-optional'], 'comps')
|
|
self.assertItemsEqual(packages, ['server-pkg', 'addon-pkg', 'opt-pkg'])
|
|
self.assertItemsEqual(groups, ['server-group', 'addon-group', 'opt-group'])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_optional_does_not_inherit_filters(self, get_gather_source):
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'filter_packages': [
|
|
('^Server(-HA)?$', {'*': ['filter-me']}),
|
|
]
|
|
})
|
|
compose.setup_optional()
|
|
compose.setup_addon()
|
|
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set(), set()))
|
|
)
|
|
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', compose.all_variants['Server-optional'], 'comps')
|
|
self.assertItemsEqual(packages, [])
|
|
self.assertItemsEqual(groups, [])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_additional_packages(self, get_gather_source):
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'additional_packages': [
|
|
('.*', {'*': ['pkg', 'foo.x86_64']}),
|
|
]
|
|
})
|
|
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set(), set()))
|
|
)
|
|
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', compose.all_variants['Server'], 'comps')
|
|
self.assertItemsEqual(packages, [('pkg', None), ('foo', 'x86_64')])
|
|
self.assertItemsEqual(groups, [])
|
|
self.assertItemsEqual(filter_packages, [])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_additional_packages_incompatible_arch(self, get_gather_source):
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'additional_packages': [
|
|
('.*', {'*': ['foo.ppc64']}),
|
|
]
|
|
})
|
|
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set(), set()))
|
|
)
|
|
|
|
with self.assertRaises(ValueError) as ctx:
|
|
packages, groups, filter_packages = gather.get_variant_packages(
|
|
compose, 'x86_64', compose.all_variants['Server'], 'comps')
|
|
|
|
self.assertIn('Incompatible package arch', str(ctx.exception))
|
|
|
|
|
|
class TestGetParentPkgs(unittest.TestCase):
|
|
def setUp(self):
|
|
self.variant = helpers.MockVariant(uid='Server', arches=['x86_64'],
|
|
type='variant')
|
|
self.addon = helpers.MockVariant(uid='Server-HA', arches=['x86_64'],
|
|
type='addon', parent=self.variant)
|
|
|
|
def test_returns_empty_for_toplevel(self):
|
|
pkg_map = mock.Mock()
|
|
result = gather.get_parent_pkgs('x86_64', self.variant, pkg_map)
|
|
self.assertEqual(result, _mk_pkg_map(iterable_class=set))
|
|
|
|
def test_on_addon(self):
|
|
pkg_map = {
|
|
'x86_64': {
|
|
'Server': {
|
|
'rpm': [
|
|
{'path': '/build/foo-1.0-1.x86_64.rpm', 'flags': []},
|
|
],
|
|
'srpm': [
|
|
{'path': '/build/foo-1.0-1.src.rpm', 'flags': []},
|
|
],
|
|
'debuginfo': [
|
|
{'path': '/build/foo-debuginfo-1.0-1.x86_64.rpm', 'flags': []},
|
|
],
|
|
}
|
|
}
|
|
}
|
|
result = gather.get_parent_pkgs('x86_64', self.addon, pkg_map)
|
|
self.assertEqual(result,
|
|
{'rpm': set([('foo', 'x86_64')]),
|
|
'srpm': set([('foo', 'src')]),
|
|
'debuginfo': set([('foo-debuginfo', 'x86_64')])})
|
|
|
|
|
|
class TestGatherPackages(helpers.PungiTestCase):
|
|
@mock.patch('pungi.phases.gather.get_variant_packages')
|
|
@mock.patch('pungi.phases.gather.get_gather_method')
|
|
def test_no_extra_options(self, get_gather_method, get_variant_packages):
|
|
packages, groups, filters = mock.Mock(), mock.Mock(), mock.Mock()
|
|
get_variant_packages.return_value = (packages, groups, filters)
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
pkg_set = mock.Mock()
|
|
self.assertEqual(
|
|
gather.gather_packages(compose, 'x86_64', compose.variants['Server'], pkg_set),
|
|
{'rpm': [], 'srpm': [], 'debuginfo': []}
|
|
)
|
|
self.assertEqual(get_gather_method.call_args_list,
|
|
[mock.call(compose.conf['gather_method'])] * 3)
|
|
self.assertEqual(get_variant_packages.call_args_list,
|
|
[mock.call(compose, 'x86_64', compose.variants['Server'], 'module', pkg_set),
|
|
mock.call(compose, 'x86_64', compose.variants['Server'], 'comps', pkg_set),
|
|
mock.call(compose, 'x86_64', compose.variants['Server'], 'json', pkg_set)])
|
|
self.assertEqual(
|
|
get_gather_method.return_value.return_value.call_args_list,
|
|
[mock.call('x86_64', compose.variants['Server'], packages, groups,
|
|
filters, set(), set(), pkg_set, fulltree_excludes=set(),
|
|
prepopulate=set())] * 3
|
|
)
|
|
|
|
@mock.patch('pungi.phases.gather.get_variant_packages')
|
|
def test_empty_variant(self, get_variant_packages):
|
|
packages, groups, filters = mock.Mock(), mock.Mock(), mock.Mock()
|
|
get_variant_packages.return_value = (packages, groups, filters)
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
compose.variants['Server'].is_empty = True
|
|
pkg_set = mock.Mock()
|
|
self.assertEqual(
|
|
gather.gather_packages(compose, 'x86_64', compose.variants['Server'], pkg_set),
|
|
_mk_pkg_map()
|
|
)
|
|
self.assertEqual(get_variant_packages.call_args_list, [])
|
|
|
|
@mock.patch('pungi.phases.gather.get_variant_packages')
|
|
@mock.patch('pungi.phases.gather.get_gather_method')
|
|
def test_multilib_white_black_list(self, get_gather_method, get_variant_packages):
|
|
packages, groups, filters = mock.Mock(), mock.Mock(), mock.Mock()
|
|
get_variant_packages.return_value = (packages, groups, filters)
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'multilib_whitelist': {'*': ['white']},
|
|
'multilib_blacklist': {'*': ['black']},
|
|
})
|
|
pkg_set = mock.Mock()
|
|
self.assertEqual(
|
|
gather.gather_packages(compose, 'x86_64', compose.variants['Server'], pkg_set),
|
|
{'rpm': [], 'srpm': [], 'debuginfo': []}
|
|
)
|
|
self.assertEqual(get_gather_method.call_args_list,
|
|
[mock.call(compose.conf['gather_method'])] * 3)
|
|
self.assertEqual(get_variant_packages.call_args_list,
|
|
[mock.call(compose, 'x86_64', compose.variants['Server'], 'module', pkg_set),
|
|
mock.call(compose, 'x86_64', compose.variants['Server'], 'comps', pkg_set),
|
|
mock.call(compose, 'x86_64', compose.variants['Server'], 'json', pkg_set)])
|
|
self.assertEqual(
|
|
get_gather_method.return_value.return_value.call_args_list,
|
|
[mock.call('x86_64', compose.variants['Server'], packages, groups,
|
|
filters, set(['white']), set(['black']), pkg_set,
|
|
fulltree_excludes=set(), prepopulate=set())] * 3
|
|
)
|
|
|
|
@mock.patch('pungi.phases.gather.get_variant_packages')
|
|
@mock.patch('pungi.phases.gather.get_gather_method')
|
|
def test_per_source_method(self, get_gather_method, get_variant_packages):
|
|
packages, groups, filters = mock.Mock(), mock.Mock(), mock.Mock()
|
|
get_variant_packages.return_value = (packages, groups, filters)
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'multilib_whitelist': {'*': ['white']},
|
|
'multilib_blacklist': {'*': ['black']},
|
|
'gather_method': {'^Server$': {'comps': 'deps', 'module': 'nodeps', 'json': 'deps'}},
|
|
})
|
|
pkg_set = mock.Mock()
|
|
gather.gather_packages(compose, 'x86_64', compose.variants['Server'], pkg_set),
|
|
self.assertEqual(get_gather_method.call_args_list,
|
|
[mock.call('nodeps'), mock.call('deps'), mock.call('deps')])
|
|
|
|
|
|
class TestWritePrepopulate(helpers.PungiTestCase):
|
|
def test_without_config(self):
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
gather.write_prepopulate_file(compose)
|
|
self.assertFalse(os.path.isfile(os.path.join(self.topdir, 'work', 'global', 'prepopulate.json')))
|
|
|
|
def test_copy_by_filename(self):
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'gather_prepopulate': 'input-prepopulate.json',
|
|
})
|
|
compose.DEBUG = False
|
|
compose.config_dir = self.topdir
|
|
helpers.copy_fixture('prepopulate.json', os.path.join(self.topdir, 'input-prepopulate.json'))
|
|
|
|
gather.write_prepopulate_file(compose)
|
|
self.assertTrue(os.path.isfile(os.path.join(self.topdir, 'work', 'global', 'prepopulate.json')))
|
|
|
|
def test_copy_local_by_scm_dict(self):
|
|
compose = helpers.DummyCompose(self.topdir, {
|
|
'gather_prepopulate': {
|
|
'file': 'input-prepopulate.json',
|
|
'scm': 'file',
|
|
'repo': None,
|
|
}
|
|
})
|
|
compose.DEBUG = False
|
|
compose.config_dir = self.topdir
|
|
helpers.copy_fixture('prepopulate.json', os.path.join(self.topdir, 'input-prepopulate.json'))
|
|
|
|
gather.write_prepopulate_file(compose)
|
|
self.assertTrue(os.path.isfile(os.path.join(self.topdir, 'work', 'global', 'prepopulate.json')))
|
|
|
|
|
|
class TestGetPrepopulate(helpers.PungiTestCase):
|
|
def setUp(self):
|
|
super(TestGetPrepopulate, self).setUp()
|
|
self.compose = helpers.DummyCompose(self.topdir, {})
|
|
|
|
def test_no_file(self):
|
|
self.assertEqual(
|
|
gather.get_prepopulate_packages(self.compose, 'x86_64', self.compose.variants['Server']),
|
|
set()
|
|
)
|
|
|
|
def test_for_one_variant(self):
|
|
helpers.copy_fixture('prepopulate.json',
|
|
os.path.join(self.topdir, 'work', 'global', 'prepopulate.json'))
|
|
self.assertItemsEqual(
|
|
gather.get_prepopulate_packages(self.compose, 'x86_64', self.compose.variants['Server']),
|
|
["foo-common.noarch",
|
|
"foo.i686",
|
|
"foo.x86_64"]
|
|
)
|
|
|
|
def test_for_all_variants(self):
|
|
helpers.copy_fixture('prepopulate.json',
|
|
os.path.join(self.topdir, 'work', 'global', 'prepopulate.json'))
|
|
self.assertItemsEqual(
|
|
gather.get_prepopulate_packages(self.compose, 'x86_64', None),
|
|
["foo-common.noarch",
|
|
"foo.i686",
|
|
"foo.x86_64",
|
|
"bar.x86_64"]
|
|
)
|
|
|
|
def test_for_all_variants_include_arch_set_to_false(self):
|
|
helpers.copy_fixture('prepopulate.json',
|
|
os.path.join(self.topdir, 'work', 'global', 'prepopulate.json'))
|
|
self.assertItemsEqual(
|
|
gather.get_prepopulate_packages(self.compose, 'x86_64', None,
|
|
include_arch=False),
|
|
["foo-common",
|
|
"foo",
|
|
"bar"]
|
|
)
|
|
|
|
|
|
class TestGatherPhase(helpers.PungiTestCase):
|
|
@mock.patch('pungi.phases.gather.link_files')
|
|
@mock.patch('pungi.phases.gather.gather_wrapper')
|
|
def test_run(self, gather_wrapper, link_files):
|
|
pkgset_phase = mock.Mock()
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
compose.notifier = mock.Mock()
|
|
compose.all_variants['Client'].is_empty = True
|
|
pkg_map = gather_wrapper.return_value
|
|
|
|
def _mk_link_call(arch, variant):
|
|
return mock.call(compose, arch, compose.all_variants[variant],
|
|
pkg_map[arch][variant],
|
|
pkgset_phase.package_sets, manifest=phase.manifest)
|
|
|
|
phase = gather.GatherPhase(compose, pkgset_phase)
|
|
phase.run()
|
|
phase.stop()
|
|
|
|
self.assertEqual(gather_wrapper.call_args_list,
|
|
[mock.call(compose, pkgset_phase.package_sets, pkgset_phase.path_prefix)])
|
|
self.assertItemsEqual(
|
|
link_files.call_args_list,
|
|
[_mk_link_call('x86_64', 'Server'),
|
|
_mk_link_call('amd64', 'Server'),
|
|
_mk_link_call('amd64', 'Everything'),
|
|
_mk_link_call('x86_64', 'Everything')])
|
|
self.assertTrue(os.path.isfile(os.path.join(self.topdir, 'compose', 'metadata', 'rpms.json')))
|
|
|
|
@mock.patch('pungi.phases.gather.link_files')
|
|
@mock.patch('pungi.phases.gather.gather_wrapper')
|
|
def test_writes_manifest_when_skipped(self, gather_wrapper, link_files):
|
|
pkgset_phase = mock.Mock()
|
|
compose = helpers.DummyCompose(self.topdir, {})
|
|
compose.notifier = mock.Mock()
|
|
|
|
phase = gather.GatherPhase(compose, pkgset_phase)
|
|
phase.stop()
|
|
|
|
self.assertEqual(gather_wrapper.call_args_list, [])
|
|
self.assertTrue(os.path.isfile(os.path.join(self.topdir, 'compose', 'metadata', 'rpms.json')))
|
|
|
|
|
|
class TestGetPackagesToGather(helpers.PungiTestCase):
|
|
def setUp(self):
|
|
super(TestGetPackagesToGather, self).setUp()
|
|
self.compose = helpers.DummyCompose(self.topdir, {
|
|
'additional_packages': [
|
|
('.*', {'*': ['pkg', 'foo2.x86_64']}),
|
|
]
|
|
})
|
|
helpers.copy_fixture('prepopulate.json',
|
|
os.path.join(self.topdir, 'work', 'global', 'prepopulate.json'))
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_all_arches(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set([('foo', None)]), set(['core'])))
|
|
)
|
|
|
|
packages, groups = gather.get_packages_to_gather(self.compose)
|
|
|
|
self.assertItemsEqual(packages, ["foo", "foo2.x86_64", "pkg"])
|
|
self.assertItemsEqual(groups, ["core"])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_all_include_arch_set_to_false(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set([('foo', None)]), set(['core'])))
|
|
)
|
|
|
|
packages, groups = gather.get_packages_to_gather(self.compose, include_arch=False)
|
|
|
|
self.assertItemsEqual(packages, ["foo", "foo2", "pkg"])
|
|
self.assertItemsEqual(groups, ["core"])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_all_include_prepopulated(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set([('foo', None)]), set(['core'])))
|
|
)
|
|
|
|
packages, groups = gather.get_packages_to_gather(self.compose, include_prepopulated=True)
|
|
|
|
self.assertItemsEqual(packages, ["foo", "pkg", "foo-common.noarch",
|
|
"foo.x86_64", "foo.i686", "foo2.x86_64",
|
|
"bar.x86_64"])
|
|
self.assertItemsEqual(groups, ["core"])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_all_include_prepopulated_no_include_arch(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set([('foo', None)]), set(['core'])))
|
|
)
|
|
|
|
packages, groups = gather.get_packages_to_gather(self.compose, include_prepopulated=True,
|
|
include_arch=False)
|
|
|
|
self.assertItemsEqual(packages, ["foo", "pkg", "foo-common",
|
|
"foo2", "bar"])
|
|
self.assertItemsEqual(groups, ["core"])
|
|
|
|
@mock.patch('pungi.phases.gather.get_gather_source')
|
|
def test_all_one_arch(self, get_gather_source):
|
|
get_gather_source.return_value = mock.Mock(
|
|
return_value=mock.Mock(return_value=(set([('foo', None)]), set(['core'])))
|
|
)
|
|
|
|
packages, groups = gather.get_packages_to_gather(self.compose, "x86_64")
|
|
|
|
self.assertItemsEqual(packages, ["foo", "pkg", "foo2.x86_64"])
|
|
self.assertItemsEqual(groups, ["core"])
|