logging.basicConfig(level=logging.DEBUG)

      from module_build_service.builder.KojiModuleBuilder import KojiModuleBuilder

  def strip_suffixes(s, suffixes):

      def _koji_rpms_in_tag(self, tag):

          """ Return the list of koji rpms in a tag. """

          log.debug("Listing rpms in koji tag %s", tag)

          try:

              rpms, builds = session.listTaggedRPMS(tag, latest=True)

                  }

              }

          }

          # Only add the CG build owner if the user exists in Koji

          if session.getUser(self.owner):

              ret[u'owner'] = self.owner

              reusable_module = get_reusable_module(db_session, module_build)

              if not reusable_module:

                  return filtered_rpms

              # Get all the RPMs and builds of the reusable module in Koji

              rpms, builds = koji_session.listTaggedRPMS(reusable_module.koji_tag, latest=True)

              # Convert the list to a dict where each key is the build_id

      @staticmethod

      @module_build_service.utils.retry(wait_on=(xmlrpclib.ProtocolError, koji.GenericError))

          koji_config = munch.Munch(koji.read_config(

              profile_name=config.koji_profile,

              user_config=config.koji_config,

          koji_config["timeout"] = 60 * 10

          address = koji_config.server

          koji_session = koji.ClientSession(address, opts=koji_config)

                  )

              else:

          return koji_session

          """

          # If the component has not been built before, then None is returned. Instead, let's

          # return 0.0 so the type is consistent

          return koji_session.getAverageBuildDuration(component) or 0.0

      @classmethod

              build = models.ModuleBuild.get_build_from_nsvc(

                  db_session, mmd.get_name(), mmd.get_stream(), mmd.get_version(),

                  mmd.get_context())

              rpms = koji_session.listTaggedRPMS(build.koji_tag, latest=True)[0]

              nvrs = set(kobo.rpmlib.make_nvr(rpm, force_epoch=True) for rpm in rpms)

              return list(nvrs)

          :return: koji tag

          """

          rpm_md = session.getRPM(rpm)

          if not rpm_md:

              return None

          if not self.koji_session:

              # If Koji is not configured on the system, then just return 0.0 for components

              try:

                  # If the component has not been built before, then None is returned. Instead,

                  # let's return 0.0 so the type is consistent

                  return self.koji_session.getAverageBuildDuration(component.package) or 0.0

  import module_build_service.scheduler.consumer

  from module_build_service import conf, models, log

  from module_build_service.builder import GenericBuilder

  class MBSProducer(PollingProducer):

          if conf.system == 'koji':

              # We don't do this on behalf of users

              log.info('Querying tasks for statuses:')

              res = models.ComponentBuild.query.filter_by(

                  state=koji.BUILD_STATES['BUILDING']).options(

          now = datetime.utcnow()

          for target in koji_session.getBuildTargets():

              koji_tag = target["dest_tag_name"]

              module = session.query(models.ModuleBuild).filter_by(

      :rtype: list[Modulemd.Module]

      """

      from module_build_service.builder.KojiModuleBuilder import KojiModuleBuilder

      repos = koji_session.getExternalRepoList(tag)

      build_tags = find_build_tags_from_external_repos(koji_session, repos)

      if not build_tags:

      resolver = GenericResolver.create(conf)

      built_rpms = []

      for nsvc in modules_nsvc:

          name, stream, version, context = nsvc.split(':')

          self.config.koji_repository_url = conf.koji_repository_url

          self.module = module_build_service.models.ModuleBuild.query.filter_by(id=2).one()

      def test_tag_to_repo(self):

          """ Test that when a repo msg hits us and we have no match,

          that we do nothing gracefully.

          expected_calls = [mock.call(1, 'foo'), mock.call(2, 'foo'), mock.call(1, 'bar')]

          assert mock_session.untagBuild.mock_calls == expected_calls

          session.getLoggedInUser.return_value = {"id": 123}

          session.multiCall.side_effect = [

              # getPackageID response

              [[{'1': [], '2': [], '3': [{'weight': 1.0}, {'weight': 1.0}]}],

               [{'1': [], '2': [], '3': [{'weight': 1.0}, {'weight': 1.0}]}]]

          ]

          weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])

          assert weights == {"httpd": 2, "apr": 2}

          expected_calls = [mock.call(456), mock.call(789)]

          assert session.getTaskDescendents.mock_calls == expected_calls

          session.getLoggedInUser.return_value = {"id": 123}

          session.multiCall.side_effect = [

              # getPackageID response

              [[{'1': [], '2': [], '3': [{'weight': 1.0}, {'weight': 1.0}]}]]

          ]

          session.getAverageBuildDuration.return_value = None

          weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])

          assert weights == {"httpd": 2, "apr": 1.5}

          expected_calls = [mock.call(456)]

          assert session.getTaskDescendents.mock_calls == expected_calls

          session.getLoggedInUser.return_value = {"id": 123}

          session.multiCall.side_effect = [

              # getPackageID response

              [[{'1': [], '2': [], '3': [{'weight': 1.0}, {'weight': 1.0}]}]]

          ]

          session.getAverageBuildDuration.return_value = None

          weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])

          assert weights == {"httpd": 2, "apr": 1.5}

          expected_calls = [mock.call(456)]

          assert session.getTaskDescendents.mock_calls == expected_calls

          session.getLoggedInUser.return_value = {"id": 123}

          session.multiCall.side_effect = [[[1], [2]], []]

          session.getAverageBuildDuration.return_value = None

          weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])

          assert weights == {"httpd": 1.5, "apr": 1.5}

                            mock.call(packageID=2, userID=123, state=1,

                                      queryOpts={'limit': 1, 'order': '-build_id'})]

          assert session.listBuilds.mock_calls == expected_calls

          session.getLoggedInUser.return_value = {"id": 123}

          session.multiCall.side_effect = [[], []]

          session.getAverageBuildDuration.return_value = None

          weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])

          assert weights == {"httpd": 1.5, "apr": 1.5}

          expected_calls = [mock.call("httpd"), mock.call("apr")]

          assert session.getPackageID.mock_calls == expected_calls

          session.getAverageBuildDuration.return_value = None

          weights = KojiModuleBuilder.get_build_weights(["httpd", "apr"])

          assert weights == {"httpd": 1.5, "apr": 1.5}

      @patch.object(conf, 'base_module_arches',

                    new={"platform:xx": ["x86_64", "i686"]})

              expected_calls = []

          assert session.packageListBlock.mock_calls == expected_calls

          session.listTaggedRPMS.return_value = ([

              {'build_id': 735939, 'name': 'tar', 'extra': None, 'arch': 'ppc64le',

               'buildtime': 1533299221, 'id': 6021394, 'epoch': 2, 'version': '1.30',

               'metadata_only': False, 'release': '4.el8+1308+551bfa71',

               'buildroot_id': 4321122, 'payloadhash': '0621ab2091256d21c47dcac868e7fc2a',

               'size': 878684}], [])

          # Module builds generated by init_data uses generic modulemd file and

          # the module's name/stream/version/context does not have to match it.

          ret = KojiModuleBuilder.get_built_rpms_in_module_build(mmd)

          assert set(ret) == set(

              ['bar-2:1.30-4.el8+1308+551bfa71', 'tar-2:1.30-4.el8+1308+551bfa71'])

      @pytest.mark.parametrize('br_filtered_rpms,expected', (

          (

              []

          ),

      ))

          session.listTaggedRPMS.return_value = (

              [

                  {

                  }

              ]

          )

          reuse_component_init_data()

          current_module = module_build_service.models.ModuleBuild.query.get(3)

          rv = KojiModuleBuilder._get_filtered_rpms_on_self_dep(current_module, br_filtered_rpms)

          assert set(rv) == set(expected)

      @pytest.mark.parametrize('cg_enabled,cg_devel_enabled', [

          (False, False),

          else:

              mock_koji_cg.koji_import.assert_not_called()

  class TestGetDistTagSRPM:

      """Test KojiModuleBuilder.get_disttag_srpm"""

  import module_build_service.scheduler.handlers.repos # noqa

  from module_build_service import models, conf, build_logs, Modulemd, glib

  import kobo.rpmlib

  from tests import init_data

          module.cg_build_koji_tag = "f27-module-candidate"

          self.cg = KojiContentGenerator(module, conf)

          # Ensure that there is no build log from other tests

          try:

              file_path = build_logs.path(self.cg.module)

              pass

      def teardown_method(self, test_method):

          # Necessary to restart the twisted reactor for the next test.

          import sys

          del sys.modules['twisted.internet.reactor']

          except OSError:

              pass

      @patch("subprocess.Popen")

      @patch("subprocess.check_output", return_value='1.4')

      @patch("pkg_resources.get_distribution")

             "_koji_rpms_in_tag"))

      @pytest.mark.parametrize("devel", (False, True))

      def test_get_generator_json(self, rpms_in_tag, machine, distro, pkg_res, coutput, popen,

          """ Test generation of content generator json """

          koji_session.getUser.return_value = GET_USER_RV

          koji_session.getTag.return_value = {"arches": ""}

          distro.return_value = ("Fedora", "25", "Twenty Five")

          machine.return_value = "i686"

          pkg_res.return_value = Mock()

              assert ret["build"]["name"] == "nginx-devel"

              assert ret["build"]["extra"]["typeinfo"]["module"]["name"] == "nginx-devel"

      @patch("subprocess.Popen")

      @patch("subprocess.check_output", return_value='1.4')

      @patch("pkg_resources.get_distribution")

      @patch(("module_build_service.builder.KojiContentGenerator.KojiContentGenerator."

             "_koji_rpms_in_tag"))

      def test_get_generator_json_no_log(self, rpms_in_tag, machine, distro, pkg_res, coutput, popen,

          """ Test generation of content generator json """

          koji_session.getUser.return_value = GET_USER_RV

          koji_session.getTag.return_value = {"arches": ""}

          distro.return_value = ("Fedora", "25", "Twenty Five")

          machine.return_value = "i686"

          pkg_res.return_value = Mock()

          rpms_in_tag.assert_called_once()

          assert expected_output == ret

      def test_prepare_file_directory(self):

          """ Test preparation of directory with output files """

          dir_path = self.cg._prepare_file_directory()

          with open(path.join(dir_path, "modulemd.i686.txt")) as mmd:

              assert len(mmd.read()) == 255

          """ Test that the CG build is tagged. """

          koji_session.getUser.return_value = GET_USER_RV

          koji_session.getTag.return_value = {'id': 123}

          self.cg._tag_cg_build()

          koji_session.getTag.assert_called_once_with(self.cg.module.cg_build_koji_tag)

          koji_session.tagBuild.assert_called_once_with(123, "nginx-0-2.10e50d06")

          """ Test that the CG build is tagged to default tag. """

          koji_session.getUser.return_value = GET_USER_RV

          koji_session.getTag.side_effect = [{}, {'id': 123}]

          self.cg._tag_cg_build()

              call(conf.koji_cg_default_build_tag)]

          koji_session.tagBuild.assert_called_once_with(123, "nginx-0-2.10e50d06")

          """ Test that the CG build is not tagged when no tag set. """

          koji_session.getUser.return_value = GET_USER_RV

          koji_session.getTag.side_effect = [{}, {'id': 123}]

          self.cg.module.cg_build_koji_tag = None

          self.cg._tag_cg_build()

          koji_session.tagBuild.assert_not_called()

          """ Test that the CG build is not tagged when no tag available. """

          koji_session.getUser.return_value = GET_USER_RV

          koji_session.getTag.side_effect = [{}, {}]

          self.cg._tag_cg_build()

          koji_session.tagBuild.assert_not_called()

      @patch("module_build_service.builder.KojiContentGenerator.open", create=True)

      def test_get_arch_mmd_output(self, patched_open):

              'type': 'file'

          }

          koji_session.getUser.return_value = GET_USER_RV

          koji_session.getTag.return_value = {"arches": "x86_64"}

               [{'license': 'MIT'}],

               [{'license': 'GPL'}]]

          ]

          rpms = self.cg._koji_rpms_in_tag("tag")

          for rpm in rpms:

                  assert rpm["exclusivearch"] == ["x86_64"]

                  assert rpm["license"] == "GPL"

      def _add_test_rpm(self, nevra, srpm_name=None, multilib=None,

                        koji_srpm_name=None, excludearch=None, exclusivearch=None,

                        license=None):

      @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",

             return_value={'build': [], 'srpm-build': []})

      @patch("module_build_service.builder.GenericBuilder.create_from_module")

      @patch('module_build_service.resolver.DBResolver')

      @patch('module_build_service.resolver.GenericResolver')

      def test_new_repo_called_when_macros_reused(

          """

          Test that newRepo is called when module-build-macros build is reused.

          """

              scheduler_init_data()

              koji_session = mock.MagicMock()

              koji_session.newRepo.return_value = 123456

              builder = mock.MagicMock()

              builder.koji_session = koji_session

      @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",

             return_value={'build': [], 'srpm-build': []})

      @patch("module_build_service.builder.GenericBuilder.create_from_module")

      @patch('module_build_service.resolver.DBResolver')

      @patch('module_build_service.resolver.GenericResolver')

      def test_new_repo_not_called_when_macros_not_reused(

          """

          Test that newRepo is called everytime for module-build-macros

          """

              scheduler_init_data()

              koji_session = mock.MagicMock()

              koji_session.newRepo.return_value = 123456

              builder = mock.MagicMock()

              builder.koji_session = koji_session

      @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",

             return_value={'build': [], 'srpm-build': []})

      @patch("module_build_service.builder.GenericBuilder.create_from_module")

      @patch('module_build_service.resolver.DBResolver')

      @patch('module_build_service.resolver.GenericResolver')

      def test_set_cg_build_koji_tag_fallback_to_default(

          """

          Test that build.cg_build_koji_tag fallbacks to default tag.

          """

              scheduler_init_data()

              koji_session = mock.MagicMock()

              koji_session.newRepo.return_value = 123456

              builder = mock.MagicMock()

              builder.koji_session = koji_session

      ])

      @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",

             return_value={'build': [], 'srpm-build': []})

      @patch("module_build_service.builder.GenericBuilder.create_from_module")

      @patch('module_build_service.resolver.DBResolver')

      @patch('module_build_service.resolver.GenericResolver')

      @patch("module_build_service.config.Config.base_module_names",

             new_callable=mock.PropertyMock, return_value=set(["base-runtime", "platform"]))

      def test_set_cg_build_koji_tag(

              koji_cg_tag_build, expected_cg_koji_build_tag):

          """

          Test that build.cg_build_koji_tag is set.

              scheduler_init_data()

              koji_session = mock.MagicMock()

              koji_session.newRepo.return_value = 123456

              builder = mock.MagicMock()

              builder.koji_session = koji_session

  @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",

         return_value={'build': [], 'srpm-build': []})

  @patch("module_build_service.scheduler.consumer.get_global_consumer")

  @patch("module_build_service.builder.GenericBuilder.create_from_module")

  class TestPoller:

      def setup_method(self, test_method):

          reuse_component_init_data()

      def teardown_method(self, test_method):

          clean_database()

      @pytest.mark.parametrize('fresh', [True, False])

      @patch('module_build_service.utils.batches.start_build_component')

      def test_process_paused_module_builds(self, start_build_component, create_builder,

          """

          Tests general use-case of process_paused_module_builds.

          """

          consumer.incoming = queue.Queue()

          global_consumer.return_value = consumer

          builder = mock.MagicMock()

          create_builder.return_value = builder

          assert len(start_build_component.mock_calls) == expected_build_calls

          """

          Tests that we call koji_sesion.newRepo when newRepo task failed.

          """

          consumer.incoming = queue.Queue()

          global_consumer.return_value = consumer

          koji_session.getTag = lambda tag_name: {'name': tag_name}

          koji_session.getTaskInfo.return_value = {'state': koji.TASK_STATES['FAILED']}

          koji_session.newRepo.return_value = 123456

          builder = mock.MagicMock()

          builder.buildroot_ready.return_value = False

          koji_session.newRepo.assert_called_once_with(

              "module-testmodule-master-20170219191323-c40c156c-build")

          """

          Tests that we do not call koji_sesion.newRepo when newRepo task

          succeeded.

          consumer.incoming = queue.Queue()

          global_consumer.return_value = consumer

          koji_session.getTag = lambda tag_name: {'name': tag_name}

          koji_session.getTaskInfo.return_value = {'state': koji.TASK_STATES['CLOSED']}

          koji_session.newRepo.return_value = 123456

          builder = mock.MagicMock()

          builder.buildroot_ready.return_value = False

          assert module_build.new_repo_task_id == 0

      def test_process_paused_module_builds_waiting_for_repo(

          """

          Tests that process_paused_module_builds does not start new batch

          when we are waiting for repo.

          consumer.incoming = queue.Queue()

          global_consumer.return_value = consumer

          builder = mock.MagicMock()

          create_builder.return_value = builder

          for component in components:

              assert component.state is None

          consumer = mock.MagicMock()

          consumer.incoming = queue.Queue()

          global_consumer.return_value = consumer