+   weburl: https://brewweb.stage.engineering.redhat.com/brewroot

+   normal_build:

+     module: testmodule

+     branch: normal-build-branch

+     # List of components in order they should be build in. One set represents one batch.

+     buildorder: [{"module-build-macros"}, {"attr"}, {"acl"}]

+     # True if buildrequire a Platform stream representing a GA RHEL release

+     platform_is_ga: true

+ # -*- coding: utf-8 -*-

+ # SPDX-License-Identifier: MIT

+ 

+ import utils

+ 

+ 

+ def test_normal_build(test_env, repo, koji):

+     """

+     Run build with `rhpkg-stage module-build --optional rebuild_strategy=all`

+ 

+     Checks:

+     * Check that MBS will submit all the component builds

+     * Check that buildorder of components is respected

+     * Check that MBS will create two content generator builds representing the module:

+         - [module]

+         - [module]-devel

+     * Check that MBS changed the buildrequired platform to have a suffix of “z”

+         if a Platform stream is representing a GA RHEL release.

+     """

+     build = utils.Build(test_env["packaging_utility"], test_env["mbs_api"])

+     build_id = build.run(

+         "--watch",

+         "--scratch",

+         "--optional",

+         "rebuild_strategy=all",

+         reuse=test_env["testdata"]["normal_build"].get("build_id"),

+     )

+     assert sorted(build.components()) == sorted(repo.components + ["module-build-macros"])

+ 

+     expected_buildorder = test_env["testdata"]["normal_build"]["buildorder"]

+     expected_buildorder = [set(batch) for batch in expected_buildorder]

+     actual_buildorder = build.batches()

+     assert actual_buildorder == expected_buildorder

+ 

+     cg_build = koji.get_build(build.nvr())

+     cg_devel_build = koji.get_build(build.nvr(name_suffix="-devel"))

+     assert cg_build and cg_devel_build

+     assert cg_devel_build['extra']['typeinfo']['module']['module_build_service_id'] == int(build_id)

+ 

+     modulemd = koji.get_modulemd(cg_build)

+     actual_platforms = modulemd["data"]["dependencies"][0]["buildrequires"]["platform"]

+     expected_platforms = repo.platform

+     platform_ga = test_env["testdata"]["normal_build"].get("platform_is_ga")

+     if platform_ga:

+         expected_platforms = [f"{pf}.z" for pf in expected_platforms]

+     assert expected_platforms == actual_platforms

+     :attribute string _weburl: URL of the web interface

+     :attribute koji.PathInfo _pathinfo: Koji path

+     def __init__(self, server, topurl, weburl):

+         self._weburl = weburl

+         self._pathinfo = koji.PathInfo(self._weburl)

+     def get_modulemd(self, cg_build):

+         """Modulemd file of the build from koji archive

+ 

+         :param cg_build: koji build object

+         :return: Modulemd file

+         :rtype: dict

+         """

+         url = self._pathinfo.typedir(cg_build, 'module')

+         r = requests.get(f"{url}/modulemd.txt")

+         r.raise_for_status()

+         return yaml.safe_load(r.content)

+ 

+         self._version = None

+     @property

+     def platform(self):

+         """

+         List of platforms in the modulemd file, obtaining values differs on version

+ 

+         :return: List of platforms in the modulemd file

+         :rtype: list of strings

+         """

+         if self._version is None:

+             self._version = self._modulemd["version"]

+         if self._version == 1:

+             return [self._modulemd["data"]["dependencies"]["buildrequires"].get("platform")]

+         elif self._version == 2:

+             return self._modulemd["data"]["dependencies"][0]["buildrequires"].get("platform")

+ 

+     def batches(self):

+         """

+         Components of the module build separated in sets according to batches

+ 

+         :return: list of components according to batches

+         :rtype: list of sets

+         """

+         comps_data = sorted(self.component_data["items"], key=lambda x: x["batch"])

+         batch_count = comps_data[-1]["batch"]

+         batches = batch_count * [set()]

+         for data in comps_data:

+             batch = data["batch"]

+             package = data["package"]

+             batches[batch - 1] = batches[batch - 1].union({package})

+ 

+         return batches

+