def test_get_build_batches(self):
pkg1 = Modulemd.ComponentRpm(name="pkg1", rationale="rationale")
pkg2 = Modulemd.ComponentRpm(name="pkg2", rationale="rationale")
pkg3 = Modulemd.ComponentRpm(name="pkg3", rationale="rationale", buildorder=1)
pkg4 = Modulemd.ComponentRpm(name="pkg4", rationale="rationale")
pkg4.set_buildorder(-20) # https://github.com/fedora-modularity/libmodulemd/issues/77#issuecomment-418198410
pkg5 = Modulemd.ComponentRpm(name="pkg5", rationale="rationale", buildorder=50)
# Test trivial usage
assert ModuleBuildFacade.get_build_batches({}) == []
# Test multiple components with same buildorder
rpms = {"pkg1": pkg1, "pkg2": pkg2}
expected_batches = [{"pkg1": pkg1, "pkg2": pkg2}]
assert ModuleBuildFacade.get_build_batches(rpms) == expected_batches
# Test component with buildorder
rpms = {"pkg3": pkg3, "pkg1": pkg1, "pkg2": pkg2}
expected_batches = [{"pkg1": pkg1, "pkg2": pkg2}, {"pkg3": pkg3}]
assert ModuleBuildFacade.get_build_batches(rpms) == expected_batches
# Test negative buildorder
rpms = {"pkg1": pkg1, "pkg2": pkg2, "pkg4": pkg4}
expected_batches = [{"pkg4": pkg4}, {"pkg1": pkg1, "pkg2": pkg2}]
assert ModuleBuildFacade.get_build_batches(rpms) == expected_batches
# Test various buildorders at once
rpms = {"pkg5": pkg5, "pkg3": pkg3, "pkg2": pkg2, "pkg4": pkg4, "pkg1":pkg1}
expected_batches = [{"pkg4": pkg4}, {"pkg1": pkg1, "pkg2": pkg2}, {"pkg3": pkg3}, {"pkg5": pkg5}]
assert ModuleBuildFacade.get_build_batches(rpms) == expected_batches
def copr_build_module(copr):
form = forms.ModuleBuildForm(meta={'csrf': False})
if not form.validate_on_submit():
raise LegacyApiError(form.errors)
facade = None
try:
mod_info = ModuleProvider.from_input(form.modulemd.data
or form.scmurl.data)
facade = ModuleBuildFacade(flask.g.user, copr, mod_info.yaml,
mod_info.filename)
module = facade.submit_build()
db.session.commit()
return flask.jsonify({
"output": "ok",
"message": "Created module {}".format(module.nsv),
})
except (ValidationError, RequestException, InvalidSchema) as ex:
raise LegacyApiError(str(ex))
except sqlalchemy.exc.IntegrityError:
raise LegacyApiError("Module {}-{}-{} already exists".format(
facade.modulemd.name, facade.modulemd.stream,
facade.modulemd.version))
def test_add_builds_batches(self, f_users, f_coprs, f_mock_chroots, f_builds, f_modules, f_db):
pkg1 = Modulemd.ComponentRpm(name="foo", rationale="foo package")
pkg2 = Modulemd.ComponentRpm(name="bar", rationale="bar package", buildorder=10)
pkg3 = Modulemd.ComponentRpm(name="baz", rationale="baz package", buildorder=10)
generator = ModulemdGenerator(name="testmodule", stream="master", version=123, summary="some summary")
facade = ModuleBuildFacade(self.u1, self.c1, generator.generate(), "testmodule.yaml")
facade.add_builds({"foo": pkg1, "bar": pkg2, "baz": pkg3}, self.m1)
b1, b2, b3 = self.m1.builds
assert b1.batch != b2.batch == b3.batch
assert b2.batch.blocked_by == b1.batch
def test_buildorder_issue_599(self):
pkg1 = Modulemd.ComponentRpm(name="jss", rationale="JSS packages")
pkg2 = Modulemd.ComponentRpm(name="tomcatjss",
rationale="TomcatJSS packages",
buildorder=10)
pkg3 = Modulemd.ComponentRpm(name="ldapjdk",
rationale="LDAP JDK packages",
buildorder=10)
pkg4 = Modulemd.ComponentRpm(name="pki-core",
rationale="PKI Core packages",
buildorder=20)
pkg5 = Modulemd.ComponentRpm(name="dogtag-pki",
rationale="Dogtag PKI packages",
buildorder=20)
rpms = {
"jss": pkg1,
"tomcatjss": pkg2,
"ldapjdk": pkg3,
"pki-core": pkg4,
"dogtag-pki": pkg5
}
batches = ModuleBuildFacade.get_build_batches(rpms)
assert len(batches) == 3
assert batches[0] == {"jss": pkg1}
assert batches[1] == {"tomcatjss": pkg2, "ldapjdk": pkg3}
assert batches[2] == {"pki-core": pkg4, "dogtag-pki": pkg5}
def build_module(copr, form):
if not form.validate_on_submit():
# WORKAROUND append those which are not in min_entries
for i in range(2, len(form.profile_names)):
form.profile_pkgs.append_entry()
return render_create_module(copr,
form,
profiles=len(form.profile_names))
summary = "Module from Copr repository: {}".format(copr.full_name)
generator = ModulemdGenerator(str(copr.name),
summary=summary,
config=app.config)
generator.add_filter(form.filter.data)
generator.add_api(form.api.data)
generator.add_profiles(
enumerate(zip(form.profile_names.data, form.profile_pkgs.data)))
generator.add_components(form.packages.data, form.filter.data,
form.builds.data)
yaml = generator.generate()
facade = None
try:
facade = ModuleBuildFacade(flask.g.user, copr, yaml)
module = facade.submit_build()
db.session.commit()
flask.flash(
"Modulemd yaml file successfully generated and submitted to be build as {}"
.format(module.nsv), "success")
return flask.redirect(url_for_copr_details(copr))
except ValidationError as ex:
flask.flash(ex.message, "error")
return render_create_module(copr, form, len(form.profile_names))
except sqlalchemy.exc.IntegrityError:
flask.flash(
"Module {}-{}-{} already exists".format(facade.modulemd.name,
facade.modulemd.stream,
facade.modulemd.version),
"error")
db.session.rollback()
return render_create_module(copr, form, len(form.profile_names))
def test_platform_chroots(self, f_users, f_coprs, f_mock_chroots_many, f_builds, f_modules, f_db):
fedora_chroots = [chroot.name for chroot in self.c1.mock_chroots if chroot.name.startswith("fedora")]
# Test excluding platform chroots
CoprChrootsLogic.update_from_names(self.u1, self.c1, fedora_chroots)
generator = ModulemdGenerator(name="testmodule", stream="master", version=123, summary="some summary")
generator.mmd.set_buildrequires({"platform": "-f22"})
facade = ModuleBuildFacade(self.u1, self.c1, generator.generate(), "testmodule.yaml")
assert {chroot.name for chroot in self.c1.active_chroots} == set(fedora_chroots)
assert ("fedora-22-i386" not in facade.platform_chroots) and ("fedora-22-x86_64" in fedora_chroots)
assert ("fedora-22-x86_64" not in facade.platform_chroots) and ("fedora-22-x86_64" in fedora_chroots)
# Test setting platform chroots from scratch
CoprChrootsLogic.update_from_names(self.u1, self.c1, fedora_chroots)
generator = ModulemdGenerator(name="testmodule", stream="master", version=123, summary="some summary")
generator.mmd.set_buildrequires({"platform": "f22"})
facade = ModuleBuildFacade(self.u1, self.c1, generator.generate(), "testmodule.yaml")
assert {chroot.name for chroot in self.c1.active_chroots} == set(fedora_chroots)
assert set(facade.platform_chroots) == {"fedora-22-i386", "fedora-22-x86_64"}
def build_module(ownername, projectname):
copr = get_copr(ownername, projectname)
form = forms.ModuleBuildForm(meta={'csrf': False})
if not form.validate_on_submit():
raise BadRequest(form.errors)
facade = None
try:
mod_info = ModuleProvider.from_input(form.modulemd.data
or form.scmurl.data)
facade = ModuleBuildFacade(flask.g.user, copr, mod_info.yaml,
mod_info.filename)
module = facade.submit_build()
db.session.commit()
return flask.jsonify(to_dict(module))
except (ValidationError, RequestException, InvalidSchema) as ex:
raise BadRequest(str(ex))
except sqlalchemy.exc.IntegrityError:
raise DuplicateException("Module {}-{}-{} already exists".format(
facade.modulemd.get_name(), facade.modulemd.get_stream(),
facade.modulemd.get_version()))