def test_solve_requires_any_platform(self,):
"""
Tests that MMDResolver finds out the buildrequired module `foo` even if
it was built on newer platform stream, but can run on any platform stream.
"""
modules = (
("platform:f28:0:c0", [], {}),
("platform:f29:0:c0", [], {}),
("platform:f30:0:c0", [], {}),
(
"foo:1:0:c8",
[{"requires": {"platform": []}}],
{"platform": {"stream": "f29"}}
),
)
for nsvc, deps, xmd_mbs_brs in modules:
mmd = make_module(nsvc, dependencies=deps, xmd={
"mbs": {"buildrequires": xmd_mbs_brs}
})
self.mmd_resolver.add_modules(mmd)
app = make_module("app:1:0", [
{"buildrequires": {"platform": ["f28"], "foo": ["1"]}}
])
expanded = self.mmd_resolver.solve(app)
expected = {
frozenset(["foo:1:0:c8:x86_64", "app:1:0:0:src", "platform:f28:0:c0:x86_64"]),
}
assert expanded == expected
def test_solve(self, dependencies, expected):
modules = (
("platform:f28:0:c0", []),
("platform:f29:0:c0", []),
("gtk:3:0:c8", [{"requires": {"platform": ["f28"]}}]),
("gtk:3:0:c9", [{"requires": {"platform": ["f29"]}}]),
("gtk:4:0:c8", [{"requires": {"platform": ["f28"]}}]),
("gtk:4:0:c9", [{"requires": {"platform": ["f29"]}}]),
("qt:4:0:c8", [{"requires": {"platform": ["f28"]}}]),
("qt:4:0:c9", [{"requires": {"platform": ["f29"]}}]),
("qt:5:0:c8", [{"requires": {"platform": ["f28"]}}]),
("qt:5:0:c9", [{"requires": {"platform": ["f29"]}}]),
(
"mess:1:0:c0",
[
{"requires": {"gtk": ["3"], "platform": ["f28"]}},
{"requires": {"gtk": ["4"], "platform": ["f29"]}},
],
),
)
for nsvc, deps in modules:
self.mmd_resolver.add_modules(
make_module(nsvc, dependencies=deps))
app = make_module("app:1:0", dependencies=dependencies)
expanded = self.mmd_resolver.solve(app)
expected = set(
frozenset(["app:1:0:%d:src" % c] + e) for c, exp in enumerate(expected) for e in exp
)
assert expanded == expected
def test_solve_new_platform(self,):
"""
Tests that MMDResolver works in case we add new platform and there is
modular dependency of input module which is built only against old
platforms and in the same time the input module wants to be built
with all available platforms.
"""
modules = (
("platform:f28:0:c0", []),
("platform:f29:0:c0", []),
("platform:f30:0:c0", []),
("gtk:3:0:c8", [{"requires": {"platform": ["f28"]}}]),
("gtk:3:0:c9", [{"requires": {"platform": ["f29"]}}]),
)
for nsvc, deps in modules:
self.mmd_resolver.add_modules(
make_module(nsvc, dependencies=deps))
app = make_module("app:1:0", dependencies=[
{"buildrequires": {"platform": [], "gtk": ["3"]}}
])
expanded = self.mmd_resolver.solve(app)
# Build only against f28 and f29, because "gtk:3" is not built against f30.
expected = {
frozenset(["gtk:3:0:c8:x86_64", "app:1:0:0:src", "platform:f28:0:c0:x86_64"]),
frozenset(["gtk:3:0:c9:x86_64", "app:1:0:0:src", "platform:f29:0:c0:x86_64"]),
}
assert expanded == expected
def test_solve_stream_conflicts(self, dependencies, modules, err_msg_regex):
for nsvc, deps in modules:
self.mmd_resolver.add_modules(
make_module(nsvc, dependencies=deps))
app = make_module("app:1:0", dependencies=dependencies)
with pytest.raises(RuntimeError, match=err_msg_regex):
self.mmd_resolver.solve(app)
def mock_get_ursine_modulemds(koji_tag):
if koji_tag == "module-rhel-8.0-build":
return [
# This is the one
make_module("modulea:10:20180813041838:5ea3b708"),
make_module("moduleb:1.0:20180113042038:6ea3b105"),
]
if koji_tag == "module-project-1.0-build":
return [
# Both of them are the collided modules
make_module("bar:6:20181013041838:817fa3a8"),
make_module("foo:2:20180113041838:95f078a1"),
]
def test_no_collisions_found(self, get_modulemds_from_ursine_content):
xmd_mbs_buildrequires = {
"modulea": {
"stream": "master"
},
"moduleb": {
"stream": "10"
}
}
get_modulemds_from_ursine_content.return_value = [
make_module("moduler:1:1:c1"),
make_module("modules:2:1:c2"),
make_module("modulet:3:1:c3"),
]
assert [] == ursine.find_stream_collision_modules(
xmd_mbs_buildrequires, "koji_tag")
def test_mark_handled_even_if_no_modules_in_ursine_content(
self, get_modulemds_from_ursine_content):
xmd = {
"mbs": {
"buildrequires": {
"modulea": {
"stream": "master"
},
"platform": {
"stream": "master",
"koji_tag": "module-rhel-8.0-build"
},
}
}
}
fake_mmd = make_module("name1:s:2020:c", xmd=xmd)
expected_xmd = fake_mmd.get_xmd()
get_modulemds_from_ursine_content.return_value = []
with patch.object(ursine, "log") as log:
ursine.handle_stream_collision_modules(fake_mmd)
assert 2 == log.info.call_count
# Ensure stream_collision_modules is set.
expected_xmd["mbs"]["buildrequires"]["platform"][
"stream_collision_modules"] = ""
expected_xmd["mbs"]["buildrequires"]["platform"]["ursine_rpms"] = ""
assert expected_xmd == fake_mmd.get_xmd()
def test_get_buildrequired_modulemds(self):
mmd = load_mmd(tests.read_staged_data("platform"))
mmd = mmd.copy(mmd.get_module_name(), "f30.1.3")
import_mmd(db_session, mmd)
platform_f300103 = db_session.query(ModuleBuild).filter_by(stream="f30.1.3").one()
mmd = tests.make_module("testmodule:master:20170109091357:123")
build = ModuleBuild(
name="testmodule",
stream="master",
version=20170109091357,
state=5,
build_context="dd4de1c346dcf09ce77d38cd4e75094ec1c08ec3",
runtime_context="ec4de1c346dcf09ce77d38cd4e75094ec1c08ef7",
context="7c29193d",
koji_tag="module-testmodule-master-20170109091357-7c29193d",
scmurl="https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79",
batch=3,
owner="Dr. Pepper",
time_submitted=datetime(2018, 11, 15, 16, 8, 18),
time_modified=datetime(2018, 11, 15, 16, 19, 35),
rebuild_strategy="changed-and-after",
modulemd=mmd_to_str(mmd),
)
build.buildrequires.append(platform_f300103)
db_session.add(build)
db_session.commit()
resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="db")
result = resolver.get_buildrequired_modulemds(
"testmodule", "master", platform_f300103.mmd())
nsvcs = {m.get_nsvc() for m in result}
assert nsvcs == {"testmodule:master:20170109091357:123"}
def test_get_buildrequired_modulemds_kojiresolver(self, mock_session):
"""
Test that MBSResolver uses KojiResolver as input when KojiResolver is enabled for
the base module.
"""
mock_session.get.return_value = Mock(ok=True)
mock_session.get.return_value.json.return_value = {
"items": [
{
"name": "nodejs",
"stream": "10",
"version": 2,
"context": "c1",
"modulemd":
mmd_to_str(tests.make_module("nodejs:10:2:c1"), ),
},
],
"meta": {
"next": None
},
}
resolver = mbs_resolver.GenericResolver.create(db_session,
conf,
backend="mbs")
platform = db_session.query(
module_build_service.common.models.ModuleBuild).filter_by(
id=1).one()
platform_mmd = platform.mmd()
platform_xmd = platform_mmd.get_xmd()
platform_xmd["mbs"]["koji_tag_with_modules"] = "module-f29-build"
platform_mmd.set_xmd(platform_xmd)
with patch.object(resolver, "get_buildrequired_koji_builds"
) as get_buildrequired_koji_builds:
get_buildrequired_koji_builds.return_value = [{
"build_id":
124,
"name":
"nodejs",
"version":
"10",
"release":
"2.c1",
"tag_name":
"foo-test"
}]
result = resolver.get_buildrequired_modulemds(
"nodejs", "10", platform_mmd)
get_buildrequired_koji_builds.assert_called_once()
assert 1 == len(result)
mmd = result[0]
assert "nodejs" == mmd.get_module_name()
assert "10" == mmd.get_stream_name()
assert 2 == mmd.get_version()
assert "c1" == mmd.get_context()
def test_solve_virtual_streams(self, dependencies, expected):
modules = (
# (nsvc, dependencies, xmd_mbs_buildrequires, virtual_streams)
("platform:el8.0.0:0:c0", [], {}, ["el8"]),
("platform:el8.1.0:0:c0", [], {}, ["el8"]),
("platform:el8.2.0.z:0:c0", [], {}, ["el8"]),
("platform:el7.6.0:0:c0", [], {}, ["el7"]),
(
"gtk:3:0:c8",
[{"requires": {"platform": ["el8"]}}],
{"platform": {"stream": "el8.0.0"}},
None
),
(
"gtk:3:1:c8",
[{"requires": {"platform": ["el8"]}}],
{"platform": {"stream": "el8.2.0.z"}},
None
),
(
"mess:1:0:c0",
[{"requires": {"gtk": ["3"], "platform": ["el8"]}}],
{"platform": {"stream": "el8.1.0"}},
None
),
)
for nsvc, deps, xmd_mbs_brs, virtual_streams in modules:
xmd = {"mbs": {"buildrequires": xmd_mbs_brs}}
if virtual_streams:
xmd["mbs"]["virtual_streams"] = virtual_streams
self.mmd_resolver.add_modules(
make_module(nsvc, dependencies=deps, xmd=xmd))
app = make_module("app:1:0", dependencies=dependencies)
if not expected:
with pytest.raises(RuntimeError):
self.mmd_resolver.solve(app)
return
else:
expanded = self.mmd_resolver.solve(app)
expected = set(
frozenset(["app:1:0:%d:src" % c] + e) for c, exp in enumerate(expected) for e in exp)
assert expanded == expected
def test_base_module_stream_version(self, nsvc, dependencies, expected):
"""
Tests that add_base_module_provides returns True for base modules with stream versions
"""
mmd = make_module(nsvc, dependencies=dependencies)
solvable = self.mmd_resolver.available_repo.add_solvable()
solvable.name = nsvc
solvable.evr = str(mmd.get_version())
solvable.arch = "x86_64"
assert self.mmd_resolver._add_base_module_provides(solvable, mmd) is expected
def test_collision_modules_are_found(self,
get_modulemds_from_ursine_content):
xmd_mbs_buildrequires = {
"modulea": {
"stream": "master"
},
"moduleb": {
"stream": "10"
}
}
fake_modules = [
make_module("moduler:1:1:c1"),
make_module("moduleb:6:1:c2"),
make_module("modulet:3:1:c3"),
]
get_modulemds_from_ursine_content.return_value = fake_modules
modules = ursine.find_stream_collision_modules(xmd_mbs_buildrequires,
"koji_tag")
assert [fake_modules[1].get_nsvc()] == modules
def test_get_buildrequired_modulemds(self, mock_session):
resolver = mbs_resolver.GenericResolver.create(db_session,
conf,
backend="mbs")
mock_session.get.return_value = Mock(ok=True)
mock_session.get.return_value.json.return_value = {
"items": [
{
"name": "nodejs",
"stream": "10",
"version": 1,
"context": "c1",
"modulemd":
mmd_to_str(tests.make_module("nodejs:10:1:c1"), ),
},
{
"name": "nodejs",
"stream": "10",
"version": 2,
"context": "c1",
"modulemd":
mmd_to_str(tests.make_module("nodejs:10:2:c1"), ),
},
],
"meta": {
"next": None
},
}
platform = db_session.query(
module_build_service.common.models.ModuleBuild).filter_by(
id=1).one()
result = resolver.get_buildrequired_modulemds("nodejs", "10",
platform.mmd())
assert 1 == len(result)
mmd = result[0]
assert "nodejs" == mmd.get_module_name()
assert "10" == mmd.get_stream_name()
assert 1 == mmd.get_version()
assert "c1" == mmd.get_context()
def test_nothing_changed_if_no_base_module_is_in_buildrequires(
self, find_stream_collision_modules):
xmd = {"mbs": {"buildrequires": {"modulea": {"stream": "master"}}}}
fake_mmd = make_module("name1:s:2020:c", xmd=xmd)
original_xmd = fake_mmd.get_xmd()
with patch.object(ursine, "log") as log:
ursine.handle_stream_collision_modules(fake_mmd)
assert 2 == log.info.call_count
find_stream_collision_modules.assert_not_called()
assert original_xmd == fake_mmd.get_xmd()
def test_submit_build_scratch_build_only_branches(self, cfg, generate_expanded_mmds):
"""
Tests the "scratch_build_only_branches" config option.
"""
mmd = make_module("foo:stream:0:c1")
generate_expanded_mmds.return_value = [mmd]
# Create a copy of mmd1 without xmd.mbs, since that will cause validate_mmd to fail
mmd_copy = mmd.copy()
mmd_copy.set_xmd({})
with pytest.raises(
ValidationError,
match="Only scratch module builds can be built from this branch.",
):
submit_module_build(db_session, "foo", mmd_copy, {"branch": "private-foo"})
submit_module_build(db_session, "foo", mmd_copy, {"branch": "otherbranch"})
def _create_test_modules(self, koji_tag_with_modules="foo-test"):
mmd = load_mmd(tests.read_staged_data("platform"))
mmd = mmd.copy(mmd.get_module_name(), "f30.1.3")
import_mmd(db_session, mmd)
platform = db_session.query(ModuleBuild).filter_by(
stream="f30.1.3").one()
if koji_tag_with_modules:
platform = db_session.query(ModuleBuild).filter_by(
stream="f30.1.3").one()
platform_mmd = platform.mmd()
platform_xmd = platform_mmd.get_xmd()
platform_xmd["mbs"][
"koji_tag_with_modules"] = koji_tag_with_modules
platform_mmd.set_xmd(platform_xmd)
platform.modulemd = mmd_to_str(platform_mmd)
for context in ["7c29193d", "7c29193e"]:
mmd = tests.make_module("testmodule:master:20170109091357:" +
context)
build = ModuleBuild(
name="testmodule",
stream="master",
version=20170109091357,
state=5,
build_context="dd4de1c346dcf09ce77d38cd4e75094ec1c08ec3",
runtime_context="ec4de1c346dcf09ce77d38cd4e75094ec1c08ef7",
context=context,
koji_tag="module-testmodule-master-20170109091357-" + context,
scmurl=
"https://src.stg.fedoraproject.org/modules/testmodule.git?#ff1ea79",
batch=3,
owner="Dr. Pepper",
time_submitted=datetime(2018, 11, 15, 16, 8, 18),
time_modified=datetime(2018, 11, 15, 16, 19, 35),
rebuild_strategy="changed-and-after",
modulemd=mmd_to_str(mmd),
)
build.buildrequires.append(platform)
db_session.add(build)
db_session.commit()
def test_base_module_provides(self, nsvc, expected):
self.mmd_resolver.add_modules(make_module(nsvc))
ns = nsvc.rsplit(":", 2)[0]
provides = self.mmd_resolver.solvables[ns][0].lookup_deparray(solv.SOLVABLE_PROVIDES)
assert {str(provide) for provide in provides} == expected
def test_add_collision_modules(self, ClientSession, resolver_create,
get_modulemds_from_ursine_content):
xmd = {
"mbs": {
"buildrequires": {
"modulea": {
"stream": "master"
},
"foo": {
"stream": "1"
},
"bar": {
"stream": "2"
},
"platform": {
"stream": "master",
"koji_tag": "module-rhel-8.0-build"
},
"project-platform": {
"stream": "master",
"koji_tag": "module-project-1.0-build",
},
}
}
}
fake_mmd = make_module("name1:s:2020:c", xmd=xmd)
def mock_get_ursine_modulemds(koji_tag):
if koji_tag == "module-rhel-8.0-build":
return [
# This is the one
make_module("modulea:10:20180813041838:5ea3b708"),
make_module("moduleb:1.0:20180113042038:6ea3b105"),
]
if koji_tag == "module-project-1.0-build":
return [
# Both of them are the collided modules
make_module("bar:6:20181013041838:817fa3a8"),
make_module("foo:2:20180113041838:95f078a1"),
]
get_modulemds_from_ursine_content.side_effect = mock_get_ursine_modulemds
# Mock for finding out built rpms
def mock_get_module(name, stream, version, context, strict=True):
return {
"modulea:10:20180813041838:5ea3b708": {
"koji_tag": "module-modulea-10-20180813041838-5ea3b708"
},
"bar:6:20181013041838:817fa3a8": {
"koji_tag": "module-bar-6-20181013041838-817fa3a8"
},
"foo:2:20180113041838:95f078a1": {
"koji_tag": "module-foo-2-20180113041838-95f078a1"
},
}["{}:{}:{}:{}".format(name, stream, version, context)]
resolver = resolver_create.return_value
resolver.get_module.side_effect = mock_get_module
def mock_listTaggedRPMS(tag, latest):
return {
"module-modulea-10-20180813041838-5ea3b708": [[{
"name": "pkg1",
"version": "1.0",
"release": "1.fc28",
"epoch": None
}]],
"module-bar-6-20181013041838-817fa3a8": [[{
"name": "pkg2",
"version": "2.0",
"release": "1.fc28",
"epoch": None
}]],
"module-foo-2-20180113041838-95f078a1": [[{
"name": "pkg3",
"version": "3.0",
"release": "1.fc28",
"epoch": None
}]],
}[tag]
koji_session = ClientSession.return_value
koji_session.listTaggedRPMS.side_effect = mock_listTaggedRPMS
ursine.handle_stream_collision_modules(fake_mmd)
xmd = fake_mmd.get_xmd()
buildrequires = xmd["mbs"]["buildrequires"]
modules = buildrequires["platform"]["stream_collision_modules"]
assert ["modulea:10:20180813041838:5ea3b708"] == modules
assert ["pkg1-0:1.0-1.fc28"
] == buildrequires["platform"]["ursine_rpms"]
modules = sorted(
buildrequires["project-platform"]["stream_collision_modules"])
expected_modules = [
"bar:6:20181013041838:817fa3a8", "foo:2:20180113041838:95f078a1"
]
assert expected_modules == modules
rpms = sorted(buildrequires["project-platform"]["ursine_rpms"])
assert ["pkg2-0:2.0-1.fc28", "pkg3-0:3.0-1.fc28"] == rpms
