def test_release_update_temporary_sources_list(self, ucr, u, http):
"""Test temporary sources list for update with one enabled component."""
ucr({
'repository/online/component/a': 'yes',
'repository/online/component/b': 'no',
})
http({
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR + 1, 'a', 'all'):
DATA,
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR + 1, 'a', ARCH):
DATA,
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR + 1, 'b', 'all'):
DATA,
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR + 1, 'b', ARCH):
DATA,
RJSON:
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR + 1, 0)])
})
tmp = u.release_update_temporary_sources_list(
U.UCS_Version((MAJOR, MINOR + 1, 0)))
assert {
'deb https://updates.software-univention.de/ ucs%d%d%d main' % (
MAJOR,
MINOR + 1,
0,
),
'deb https://updates.software-univention.de/%d.%d/maintained/component/ %s/%s/'
% (MAJOR, MINOR + 1, 'a', 'all'),
'deb https://updates.software-univention.de/%d.%d/maintained/component/ %s/%s/'
% (MAJOR, MINOR + 1, 'a', ARCH),
} == set(tmp)
def test_get_sh_files_bug27149(self, ucr, u, http):
"""Test preup.sh / postup.sh download for non-architecture component."""
ucr({
'repository/online/component/a': 'yes',
'repository/online/component/a/layout': 'flat',
})
struct = U.UCSRepoPoolNoArch(major=MAJOR,
minor=MINOR,
part='maintained/component',
patch='a')
preup_path = struct.path('preup.sh')
postup_path = struct.path('postup.sh')
http({
preup_path: b'#!preup_content',
postup_path: b'#!postup_content',
RJSON: gen_releases([(MAJOR, MINOR, PATCH)]),
})
gen = u.get_sh_files(u.current_version, u.current_version)
assert (u.server, struct, 'preup', preup_path,
b'#!preup_content') == next(gen)
assert (u.server, struct, 'postup', postup_path,
b'#!postup_content') == next(gen)
with pytest.raises(StopIteration):
next(gen)
def test_get_next_version_PATCH(self, u, http):
"""Test next patch version."""
http({
RJSON:
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR, PATCH + 1)])
})
ver = u.get_next_version(version=U.UCS_Version((MAJOR, MINOR, PATCH)))
assert U.UCS_Version((MAJOR, MINOR, PATCH + 1)) == ver
def test__releases_in_range_current(self):
"""Test getting releases in range."""
self._uri({
'releases.json': gen_releases([(MAJOR, MINOR, PATCH)]),
})
ver = U.UCS_Version((MAJOR, MINOR, PATCH))
versions = self.u._releases_in_range()
self.assertEqual([ver], versions)
def test_get_next_version_MINOR99(self):
"""Test next minor version after 99."""
self._uri({
'releases.json':
gen_releases([(MAJOR + 1, 0, 0), (MAJOR, 100, 0)])
})
ver = self.u.get_next_version(version=U.UCS_Version((MAJOR, 99, 0)))
self.assertEqual('%d.%d-%d' % (MAJOR + 1, 0, 0), ver)
def test_get_next_version_MINOR(self, u, http):
"""Test next minor version."""
http({
RJSON:
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR + 1, 0)])
})
ver = u.get_next_version(version=U.UCS_Version((MAJOR, MINOR, PATCH)))
assert U.UCS_Version((MAJOR, MINOR + 1, 0)) == ver
def test_release_update_available_NO(self):
"""Test no update available."""
self._uri({
'releases.json':
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR - 1, 0, 0)])
})
next = self.u.release_update_available()
self.assertEqual(None, next)
def test_release_update_available_MINOR(self, u, http):
"""Test next minor update."""
NEXT_u = U.UCS_Version((MAJOR, MINOR + 1, 0))
http({
RJSON:
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR + 1, 0)])
})
next_u = u.release_update_available()
assert NEXT_u == next_u
def test_release_update_available_PATCH(self, u, http):
"""Test next patch-level update."""
NEXT_u = U.UCS_Version((MAJOR, MINOR, PATCH + 1))
http({
RJSON:
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR, PATCH + 1)])
})
next_u = u.release_update_available()
assert NEXT_u == next_u
def test__releases_in_range_first(self):
"""Test getting first releases in range."""
self._uri({
'releases.json': gen_releases([(MAJOR, 1, 0)]),
})
start = U.UCS_Version((MAJOR, 0, 0))
end = U.UCS_Version((MAJOR, 1, 0))
versions = self.u._releases_in_range(start, end)
self.assertEqual([end], versions)
def test_release_update_available_PATCH(self):
"""Test next patch-level update."""
NEXT = '%d.%d-%d' % (MAJOR, MINOR, PATCH + 1)
self._uri({
'releases.json':
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR, PATCH + 1)])
})
next = self.u.release_update_available()
self.assertEqual(NEXT, next)
def test_release_update_available_MAJOR(self):
"""Test next major update."""
NEXT = '%d.%d-%d' % (MAJOR + 1, 0, 0)
self._uri({
'releases.json':
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR + 1, 0, 0)])
})
next = self.u.release_update_available()
self.assertEqual(NEXT, next)
def test_get_next_version_PATCH(self):
"""Test next patch version."""
self._uri({
'releases.json':
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR, PATCH + 1)])
})
ver = self.u.get_next_version(version=U.UCS_Version((MAJOR, MINOR,
PATCH)))
self.assertEqual('%d.%d-%d' % (MAJOR, MINOR, PATCH + 1), ver)
def test__get_component_version_empty(self, ucr, u, http):
"""Test getting component empty versions in range from MAJOR.MINOR-PATCH."""
ucr({'repository/online/component/a/version': ''})
http({
RJSON: gen_releases([(MAJOR, MINOR, 0)]),
})
ver = U.UCS_Version((MAJOR, MINOR, 0)) # component.erratalevel!
comp_ver = u.component('a')._versions(start=ver, end=ver)
assert {ver} == set(comp_ver)
def test_release_update_available_CURRENT(self, ucr, u, http):
"""Test next update block because of missing current component."""
ucr({
'repository/online/component/a': 'yes',
'repository/online/component/a/version': 'current',
})
http({
RJSON:
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR + 1, 0)])
})
assert u.release_update_available() is None
def test_mirror_update_scripts(self, tmpdir, ucr, http, m):
ucr({
'repository/online/component/a': 'yes',
'repository/online/component/b': 'yes',
'repository/online/component/b/layout': 'flat',
'repository/mirror/version/start': '%d.%d-%d' % (MAJOR, 0, 0),
'repository/mirror/version/end': '%d.%d-%d' % (MAJOR, 0, 0),
})
uris = {
'/dists/ucs%d%d%d/preup.sh' % (
MAJOR,
MINOR,
0,
):
b'#!r_pre',
'/dists/ucs%d%d%d/postup.sh' % (
MAJOR,
MINOR,
0,
):
b'#!r_post',
'/dists/ucs%d%d%d/main/binary-%s/Packages.gz' % (MAJOR, MINOR, 0, ARCH):
DATA,
'/%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, 0, 'a', 'all'):
DATA,
'/%d.%d/maintained/component/%s/%s/preup.sh' % (MAJOR, 0, 'a', 'all'):
b'#!a_pre',
'/%d.%d/maintained/component/%s/%s/postup.sh' % (MAJOR, 0, 'a', 'all'):
b'#!a_post',
'/%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, 0, 'a', ARCH):
DATA,
'/%d.%d/maintained/component/%s/Packages.gz' % (MAJOR, 0, 'b'):
DATA,
'/%d.%d/maintained/component/%s/preup.sh' % (MAJOR, 0, 'b'):
b'#!b_pre',
'/%d.%d/maintained/component/%s/postup.sh' % (MAJOR, 0, 'b'):
b'#!b_post',
RJSON:
gen_releases([
(MAJOR, MINOR, 0),
])
}
http(uris)
m._get_releases()
del uris[RJSON]
m.mirror_update_scripts()
for key, value in uris.items():
if value == DATA:
continue
# "base_dir+mock" for the mock_open redirector
# "base_dir+repo+mirror" as the configured repository_root
# "mock+key" from the remote host prefix and struct
filename = tmpdir / "repo" / 'mirror' / key
assert filename.read_binary() == value
def test__get_component_version_full(self, ucr, u, http):
"""Test getting component versions in range from MAJOR.MINOR-PATCH."""
ucr({
'repository/online/component/a/version':
'%d.%d-%d' % (MAJOR, MINOR, PATCH)
})
http({
RJSON: gen_releases([(MAJOR, MINOR, PATCH)]),
})
comp_ver = u.component('a')._versions(None, None)
assert set() == set(comp_ver)
def test__get_component_version_short(self, ucr, u, http):
"""Test getting component versions in range from MAJOR.MINOR."""
ucr({
'repository/online/component/a/version': '%d.%d' % (MAJOR, MINOR)
})
http({
RJSON: gen_releases([(MAJOR, MINOR, PATCH)]),
})
ver = U.UCS_Version((MAJOR, MINOR, 0))
comp_ver = u.component('a')._versions(None, None)
assert {ver} == set(comp_ver)
def test_write_releases_json(self):
self._uri({
'releases.json':
gen_releases([(MAJOR, MINOR, 0), (MAJOR, MINOR, 1)])
})
expected = '{"releases": [{"major": 3, "minors": [{"patchlevels": [{"status": "maintained", "patchlevel": 0}, {"status": "maintained", "patchlevel": 1}], "minor": 0}]}]}'
self.m.write_releases_json()
releases_json_path = os.path.join(self.base_dir, 'mock',
self.m.repository_path.lstrip('/'),
'mirror', 'releases.json')
with open(releases_json_path, 'r') as releases_json:
self.assertEqual(expected, releases_json.read())
def test__get_component_version_empty(self):
"""Test getting component empty versions in range from MAJOR.MINOR-PATCH."""
self._ucr({'repository/online/component/a/version': ''})
self._uri({
'%d.%d/maintained/%d.%d-%d/' % (MAJOR, MINOR, MAJOR, MINOR, PATCH):
'',
'releases.json':
gen_releases([(MAJOR, MINOR, PATCH)]),
})
ver = U.UCS_Version((MAJOR, MINOR, PATCH)) # component.erratalevel!
comp_ver = self.u._get_component_versions('a', start=ver, end=ver)
self.assertEqual(set((ver, )), comp_ver)
def test_get_releases(self, u, http):
http({
RJSON:
gen_releases([(MAJOR, minor, patch) for minor in range(3)
for patch in range(3)]),
})
expected = [(U.UCS_Version((MAJOR, 1, patch)),
dict(major=MAJOR,
minor=1,
patchlevel=patch,
status="maintained")) for patch in range(3)]
found = list(u.get_releases(start=expected[0][0], end=expected[-1][0]))
assert expected == found
def test_release_update_available_CURRENT(self):
"""Test next update block because of missing current component."""
self._ucr({
'repository/online/component/a': 'yes',
'repository/online/component/a/version': 'current',
})
self._uri({
'releases.json':
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR + 1, 0)])
})
self.assertRaises(U.RequiredComponentError,
self.u.release_update_available,
errorsto='exception')
class TestFilter(object):
"""Unit test for univention.updater.mirror.filter_releases_json"""
RELEASES = json.loads(gen_releases([(5, 0, 0), (5, 0, 1), (5, 0, 2)]))
VER4, VER5, VER6 = (UCS_Version((major, 0, 0)) for major in [4, 5, 6])
def test_filter_releases_json(self, testdir):
with open(join(testdir, 'mockup_upstream_releases.json'),
'r') as upstream_releases_fp:
upstream_releases = json.load(upstream_releases_fp)
with open(join(testdir, 'mockup_mirror_releases.json'),
'r') as mirror_releases_fp:
expected_mirror_releases = json.load(mirror_releases_fp)
mirrored_releases = deepcopy(upstream_releases)
M.filter_releases_json(mirrored_releases,
start=UCS_Version((3, 1, 1)),
end=UCS_Version((4, 1, 0)))
assert mirrored_releases == expected_mirror_releases
def test_unchanged(self):
data = deepcopy(self.RELEASES)
M.filter_releases_json(data, start=self.VER4, end=self.VER6)
assert data == self.RELEASES
def test_same(self):
data = deepcopy(self.RELEASES)
M.filter_releases_json(data,
start=self.VER5,
end=UCS_Version((5, 0, 2)))
assert data == self.RELEASES
def test_before(self):
data = deepcopy(self.RELEASES)
M.filter_releases_json(data, start=self.VER4, end=self.VER4)
assert data == {"releases": []}
def test_after(self):
data = deepcopy(self.RELEASES)
M.filter_releases_json(data, start=self.VER6, end=self.VER6)
assert data == {"releases": []}
def test_empty(self):
data = deepcopy(self.RELEASES)
M.filter_releases_json(data,
start=UCS_Version((5, 0, 3)),
end=self.VER6)
assert data == {"releases": []}
def test_get_component_repositories_NOARCH(self, ucr, http, u):
"""Test component repositories without architecture sub directories."""
ucr({
'repository/online/component/a': 'yes',
'repository/online/component/a/layout': 'flat',
})
http({
'%d.%d/maintained/component/a/Packages.gz' % (MAJOR, MINOR): DATA,
RJSON: gen_releases(patches=[PATCH, PATCH + 1]),
})
ver = U.UCS_Version((MAJOR, MINOR, PATCH))
a_repo = u.component('a').repositories(ver, ver)
assert {
'deb https://updates.software-univention.de/%d.%d/maintained/component/a/ ./'
% (MAJOR, MINOR),
} == set(a_repo)
def test_get_all_available_release_updates(self):
"""Test next updates until blocked by missing current component."""
self._ucr({
'repository/online/component/a': 'yes',
'repository/online/component/a/version': 'current',
})
self._uri({
'releases.json':
gen_releases([(MAJOR, MINOR + 1, 0), (MAJOR + 1, 0, 0)])
})
self._uri({
'%d.%d/maintained/component/%s/all/Packages.gz' % (MAJOR, MINOR + 1, 'a'):
DATA,
})
versions, components = self.u.get_all_available_release_updates()
self.assertEqual(['%d.%d-%d' % (MAJOR, MINOR + 1, 0)], versions)
self.assertEqual(set(('a', )), components)
def test_get_all_available_release_updates(self, ucr, u, http):
"""Test next updates until blocked by missing current component."""
ucr({
'repository/online/component/a': 'yes',
'repository/online/component/a/version': 'current',
})
http({
RJSON:
gen_releases([(MAJOR, MINOR, PATCH), (MAJOR, MINOR + 1, 0),
(MAJOR + 1, 0, 0)]),
'/%d.%d/maintained/component/%s/all/Packages.gz' % (MAJOR, MINOR + 1, 'a'):
DATA,
'/%d.%d/maintained/component/%s/amd64/Packages.gz' % (MAJOR, MINOR + 1, 'a'):
DATA,
})
versions, components = u.get_all_available_release_updates()
assert [U.UCS_Version((MAJOR, MINOR + 1, 0))] == versions
assert {'a'} == components
def test_print_component_repositories(self, ucr, http, u):
"""Test printing component repositories."""
ucr({
'repository/online/component/a': 'yes',
})
http({
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR, 'a', 'all'):
DATA,
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR, 'a', ARCH):
DATA,
RJSON:
gen_releases(patches=[PATCH, PATCH + 1]),
})
tmp = u.print_component_repositories()
assert {
'deb https://updates.software-univention.de/%d.%d/maintained/component/ %s/%s/'
% (MAJOR, MINOR, 'a', 'all'),
'deb https://updates.software-univention.de/%d.%d/maintained/component/ %s/%s/'
% (MAJOR, MINOR, 'a', ARCH),
} == set(tmp.splitlines())
def test_print_component_repositories(self):
"""Test printing component repositories."""
self._ucr({
'repository/online/component/a': 'yes',
})
self._uri({
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR, 'a', 'all'):
DATA,
'%d.%d/maintained/component/%s/%s/Packages.gz' % (MAJOR, MINOR, 'a', ARCH):
DATA,
'releases.json':
gen_releases([(MAJOR, MINOR, PATCH)]),
})
tmp = self.u.print_component_repositories()
self.assertEqual(
set((
'deb file:///mock/%d.%d/maintained/component/ %s/%s/' %
(MAJOR, MINOR, 'a', 'all'),
'deb file:///mock/%d.%d/maintained/component/ %s/%s/' %
(MAJOR, MINOR, 'a', ARCH),
)), set(tmp.splitlines()))
def test_get_sh_files(self, u, http):
"""Test preup.sh / postup.sh download."""
struct = U.UCSRepoPool5(major=MAJOR,
minor=MINOR,
patchlevel=PATCH,
arch=ARCH)
preup_path = struct.path('preup.sh')
postup_path = struct.path('postup.sh')
http({
preup_path: b'#!preup_content',
postup_path: b'#!postup_content',
RJSON: gen_releases([(MAJOR, MINOR, PATCH)]),
})
gen = u.get_sh_files(u.current_version, u.current_version)
assert (u.server, struct, 'preup', preup_path,
b'#!preup_content') == next(gen)
assert (u.server, struct, 'postup', postup_path,
b'#!postup_content') == next(gen)
with pytest.raises(StopIteration):
next(gen)
def test_get_next_version_MAJOR99(self):
"""Test next major version after 99."""
self._uri({'releases.json': gen_releases([(99, 0, 0), (100, 0, 0)])})
ver = self.u.get_next_version(version=U.UCS_Version((99, MINOR,
PATCH)))
self.assertEqual(None, ver)
