"""

  import pkg_resources

  from flask import Flask, has_app_context, url_for

  from flask_sqlalchemy import SQLAlchemy

  from sqlalchemy.pool import StaticPool

  conf = init_config(app)

  class MBSSQLAlchemy(SQLAlchemy):

      """

  import module_build_service.scm

  import module_build_service.utils

  from module_build_service.builder.utils import execute_cmd

  from module_build_service.errors import ProgrammingError

  from module_build_service.builder.base import GenericBuilder

          address = koji_config.server

          log.info("Connecting to koji %r.", address)

          if not login:

              return koji_session

          authtype = koji_config.authtype

          log.info("Authenticate session with %r.", authtype)

          if authtype == "kerberos":

              keytab = getattr(config, "krb_keytab", None)

              principal = getattr(config, "krb_principal", None)

              if not keytab and principal:

                  raise ValueError(

                      "The Kerberos keytab and principal aren't set for Koji authentication")

              log.debug("  keytab: %r, principal: %r" % (keytab, principal))

          elif authtype == "ssl":

              koji_session.ssl_login(

                  os.path.expanduser(koji_config.cert),

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

          assert mock_session.untagBuild.mock_calls == expected_calls

      def test_get_build_weights(self, ClientSession):

          session = ClientSession.return_value

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

          # getLoggedInUser requires to a logged-in session

          session.krb_login.assert_called_once()

      def test_get_build_weights_no_task_id(self, ClientSession):

          session = ClientSession.return_value

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

          assert session.getTaskDescendents.mock_calls == expected_calls

          session.krb_login.assert_called_once()

      def test_get_build_weights_no_build(self, ClientSession):

          session = ClientSession.return_value

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

          assert session.getTaskDescendents.mock_calls == expected_calls

          session.krb_login.assert_called_once()

      def test_get_build_weights_listBuilds_failed(self, ClientSession):

          session = ClientSession.return_value

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

          assert session.listBuilds.mock_calls == expected_calls

          session.krb_login.assert_called_once()

      def test_get_build_weights_getPackageID_failed(self, ClientSession):

          session = ClientSession.return_value

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

          session.krb_login.assert_called_once()

      def test_get_build_weights_getLoggedInUser_failed(self, ClientSession):

          session = ClientSession.return_value

          session.getAverageBuildDuration.return_value = None

              expected_calls = []

          assert session.packageListBlock.mock_calls == expected_calls

      def test_get_built_rpms_in_module_build(self, ClientSession):

          session = ClientSession.return_value

          session.listTaggedRPMS.return_value = ([

              []

          ),

      ))

      def test_get_filtered_rpms_on_self_dep(self, ClientSession, br_filtered_rpms, expected):

          session = ClientSession.return_value

          session.listTaggedRPMS.return_value = (

          else:

              mock_koji_cg.koji_import.assert_not_called()

      def test_get_anonymous_session(self, ClientSession):

          mbs_config = mock.Mock(koji_profile='koji', koji_config='conf/koji.conf')

          session = KojiModuleBuilder.get_session(mbs_config, login=False)

          assert ClientSession.return_value == session

          assert ClientSession.return_value.krb_login.assert_not_called

      def test_ensure_builder_use_a_logged_in_koji_session(self, ClientSession):

          builder = KojiModuleBuilder('owner', MagicMock(), conf, 'module-tag', [])

          builder.koji_session.krb_login.assert_called_once()

          except OSError:

              pass

      @patch("subprocess.Popen")

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

      @patch("pkg_resources.get_distribution")

          # Ensure an anonymous Koji session works

          koji_session.krb_login.assert_not_called()

      @patch("subprocess.Popen")

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

      @patch("pkg_resources.get_distribution")

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

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

      def test_tag_cg_build(self, ClientSession):

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

          koji_session = ClientSession.return_value

          # tagBuild requires logging into a session in advance.

          koji_session.krb_login.assert_called_once()

      def test_tag_cg_build_fallback_to_default_tag(self, ClientSession):

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

          koji_session = ClientSession.return_value

          # tagBuild requires logging into a session in advance.

          koji_session.krb_login.assert_called_once()

      def test_tag_cg_build_no_tag_set(self, ClientSession):

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

          koji_session = ClientSession.return_value

          # tagBuild requires logging into a session in advance.

          koji_session.krb_login.assert_called_once()

      def test_tag_cg_build_no_tag_available(self, ClientSession):

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

          koji_session = ClientSession.return_value

              'type': 'file'

          }

      def test_koji_rpms_in_tag(self, ClientSession):

          koji_session = ClientSession.return_value

          koji_session.getUser.return_value = GET_USER_RV

          # Listing tagged RPMs does not require to log into a session

          koji_session.krb_login.assert_not_called()

      def test_koji_rpms_in_tag_empty_tag(self, ClientSession):

          koji_session = ClientSession.return_value

          koji_session.getUser.return_value = GET_USER_RV

          assert rpms == []

          koji_session.multiCall.assert_not_called()

      def test_koji_rpms_in_tag_empty_headers(self, ClientSession):

          koji_session = ClientSession.return_value

          koji_session.getUser.return_value = GET_USER_RV

          assert len(start_build_component.mock_calls) == expected_build_calls

      def test_trigger_new_repo_when_failed(

              self, ClientSession, create_builder, global_consumer, dbg):

          """

          koji_session.newRepo.assert_called_once_with(

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

      def test_trigger_new_repo_when_succeeded(

              self, ClientSession, create_builder, global_consumer, dbg):

          """

          for component in components:

              assert component.state is None

      def test_old_build_targets_are_not_associated_with_any_module_builds(

              self, ClientSession, create_builder, global_consumer, dbg):

          consumer = mock.MagicMock()

          koji_session.deleteBuildTarget.assert_not_called()

      def test_dont_delete_base_module_build_target(

              self, ClientSession, create_builder, global_consumer, dbg):

          module_build = models.ModuleBuild.query.filter_by(id=3).one()

              koji_session.deleteBuildTarget.assert_not_called()

      def test_dont_delete_build_target_for_unfinished_module_builds(

              self, ClientSession, create_builder, global_consumer, dbg):

          module_build = models.ModuleBuild.query.filter_by(id=3).one()

              koji_session.deleteBuildTarget.assert_not_called()

      def test_only_delete_build_target_with_allowed_koji_tag_prefix(

              self, ClientSession, create_builder, global_consumer, dbg):

          module_build_2 = models.ModuleBuild.query.filter_by(id=2).one()

              koji_session.deleteBuildTarget.assert_called_once_with(1)

              koji_session.krb_login.assert_called_once()

      def test_cant_delete_build_target_if_not_reach_delete_time(

              self, ClientSession, create_builder, global_consumer, dbg):

          module_build_2 = models.ModuleBuild.query.filter_by(id=2).one()

      def teardown_method(self, test_method):

          clean_database()

      def test_return_empty_if_no_ursine_build_tag_is_found(self, ClientSession):

          session = ClientSession.return_value

          assert [] == modulemds

      @patch.object(conf, 'koji_tag_prefixes', new=['module'])

      def test_get_modulemds(self, ClientSession):

          session = ClientSession.return_value

      @patch.object(conf, 'base_module_names', new=['platform', 'project-platform'])

      @patch('module_build_service.utils.ursine.get_modulemds_from_ursine_content')

      @patch('module_build_service.resolver.GenericResolver.create')

      def test_add_collision_modules(self, ClientSession, resolver_create,

                                     get_modulemds_from_ursine_content):

          xmd = {

                  for key, part in zip(nsvc_keys, nsvc_parts):

                      assert item[key] == part

      def test_query_builds_with_binary_rpm(self, ClientSession):

          """

          Test for querying MBS with the binary rpm filename. MBS should return all the modules,