return env

  @pytest.fixture(scope="function")

  def scenario(request, test_env):

      """Configuration data for the scenario

    no_components:

      module: testmodule

      branch: test-no-components-branch

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

  # SPDX-License-Identifier: MIT

      """

      Run the build with "rebuild_strategy=all".

        * Check that any other components in the same batch as the failed component are

          cancelled, if not completed.

      """

      repo.bump()

          "--optional",

          "rebuild_strategy=all",

          reuse=scenario.get("build_id"),

      )

      assert build.state_name == "failed"

      batch = scenario["batch"]

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

  # SPDX-License-Identifier: MIT

      """

      Submit the testmodule build with `fedpkg module-build`

      * Verify that the testmodule build succeeds

      """

      repo.bump()

      assert build.state_name == "ready"

      assert not build.data["component_builds"]

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

  # SPDX-License-Identifier: MIT

      """

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

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

          if a Platform stream is representing a GA RHEL release.

      """

      repo.bump()

          "--optional",

          "rebuild_strategy=all",

          reuse=scenario.get("build_id"),

      )

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

      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

      modulemd = koji.get_modulemd(cg_build)

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

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

  # SPDX-License-Identifier: MIT

  import time

      """

      Run the  build with "rebuild_strategy=all".

      Wait until the module-build-macros build is submitted to Koji.

        * Check that the testmodule build succeeded

      """

      repo.bump()

          "--optional",

          "rebuild_strategy=all",

      )

      build.wait_for_koji_task_id(package="module-build-macros", batch=1)

      # Behave like a human: restarting the build too quickly would lead to an error.

      time.sleep(10)

      assert build.state_name == "ready"

      assert build.was_cancelled()

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

  # SPDX-License-Identifier: MIT

      """Rebuild the test module again, without changing any of the components with:

      `fedpkg module-build -w --optional rebuild_strategy=only-changed`

      * Verify that all the components are reused from the first build.

      * Verify that module-build-macros is not built in the second build.

      """

      repo.bump()

          "--watch",

          "--optional",

          "rebuild_strategy=all",

          reuse=scenario.get("build_id"),

      )

      task_ids = build.component_task_ids()

      task_ids.pop("module-build-macros")

      repo.bump()

          "-w",

          "--optional",

          "rebuild_strategy=only-changed",

          reuse=scenario.get("build_id_reused"))

      reused_task_ids = build.component_task_ids()

      assert not build.components(package="module-build-macros")

  import utils

      """

      Bump the commit of one of the components that MBS uses.

      Bump the commit of the same testmodule that was mentioned in the preconditions.

      * Verify that the component with the changed commit was rebuilt.

      """

      repo.bump()

          "--watch",

          "--optional",

          "rebuild_strategy=all",

          reuse=scenario.get("baseline_build_id"),

      )

      package = scenario.get("package")

      component = utils.Component(

          package,

      component.bump()

      repo.bump()

          "--watch",

          "--optional",

          "rebuild_strategy=only-changed",

          reuse=scenario.get("build_id"),

      )

      comp_task_ids_base = baseline_build.component_task_ids()

      comp_task_ids = build.component_task_ids()

      comp_task_ids_base.pop('module-build-macros')

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

  # SPDX-License-Identifier: MIT

      """

      Run a scratch build with "rebuild_strategy=all".

        (as opposed to the "ready" state)

      * no content generator builds are created in Koji

      """

          "--scratch",

          "--optional",

          "rebuild_strategy=all",

          reuse=scenario.get("build_id"),

      )

      assert build.state_name == "done"

      assert sorted(build.component_names(state="COMPLETE")) == sorted(

          git("push")

      :attribute sh.Command _packaging_utility: packaging utility command used to

          kick off this build

      :attribute string _mbs_api: URL of the MBS API (including trailing '/')

      """

      def __init__(self, packaging_utility, mbs_api):

              _out=sys.stdout, _err=sys.stderr, _tee=True

          )

          self._mbs_api = mbs_api

      def run(self, *args, reuse=None):

          :param args: Options and arguments for the build command

              Intended to be used while developing the tests.

          """

          if reuse is not None:

          else:

              stdout = self._packaging_utility("module-build", *args).stdout.decode("utf-8")

          stdout = self._packaging_utility(

          ).stdout.decode("utf-8")

          return stdout

          """Cancel the module build

          :return: Standard output of the "module-build-cancel <build id=""> command

          :rtype: str

          """

              "utf-8")

          return stdout

      @property

      def data(self):

          """Module build data cache for this build fetched from MBS"""