krbV = None

  try:

  except ImportError:  # pragma: no cover

  try:

      import librepo

              quit("Error: Unable to log in. Bad credentials?")

          except requests.exceptions.ConnectionError:

              quit("Error: Unable to connect to server %s" % (options.server))

          krb_principal = options.krb_principal

          if krb_principal is None:

              krb_principal = options.host_principal_format % socket.getfqdn()

  %endif

  Requires: python%{python3_pkgversion}-pyOpenSSL

  Requires: python%{python3_pkgversion}-requests

  Requires: python%{python3_pkgversion}-requests-kerberos

  Requires: python%{python3_pkgversion}-dateutil

  Requires: python%{python3_pkgversion}-six

      # we ignore it here

      pass

  try:

  except ImportError:  # pragma: no cover

  try:

      import rpm

  except ImportError:

          return host

      def gssapi_login(self, principal=None, keytab=None, ccache=None, proxyuser=None):

              raise PythonImportError(

              )

          # force https

          old_baseurl = self.baseurl

                  old_env['KRB5CCNAME'] = os.environ.get('KRB5CCNAME')

                  os.environ['KRB5CCNAME'] = ccache

              if principal:

                      raise PythonImportError(

                          'keytab auth'

                      )

                  else:

                      kwargs['principal'] = principal

              try:

                  # Depending on the server configuration, we might not be able to

                  # connect without client certificate, which means that the conn

      requires = [

          'python-dateutil',

          'requests',

          'six',

          # 'libcomps',

          # 'rpm-py-installer', # it is optional feature

      maxDiff = None

      def test_gssapi_disabled(self):

          with self.assertRaises(ImportError):

              self.session.gssapi_login()

                                                           retry=False)

          self.assertEqual(old_environ, dict(**os.environ))

      def test_gssapi_login_keytab(self, HTTPKerberosAuth_mock):

          principal = 'user@EXAMPLE.COM'

          keytab = '/path/to/keytab'

          ccache = '/path/to/cache'

          old_environ = dict(**os.environ)

          accepted_versions = ['0.12.0.beta1',

                               '0.12.0dev',

                               '0.12.0a1',

                               '0.10.0',

                               '0.9.0']

          for accepted_version in accepted_versions:

              rv = self.session.gssapi_login(principal, keytab, ccache)

              self.session._callMethod.assert_called_once_with('sslLogin',

                                                               [None],

              self.assertEqual(old_environ, dict(**os.environ))

              self.assertTrue(rv)

              self.session._callMethod.reset_mock()

          principal = 'user@EXAMPLE.COM'

          keytab = '/path/to/keytab'

          ccache = '/path/to/cache'

          old_environ = dict(**os.environ)

          old_versions = ['0.8.0',

                          '0.7.0',

                          '0.6.1',

                          '0.2',

                          '0.1']

          for old_version in old_versions:

              with self.assertRaises(koji.PythonImportError) as cm:

                  self.session.gssapi_login(principal, keytab, ccache)

              self.assertEqual(cm.exception.args[0],

                               'keytab auth')

              self.session._callMethod.assert_not_called()

              self.assertEqual(old_environ, dict(**os.environ))

      def test_gssapi_login_error(self):

          old_environ = dict(**os.environ)

  class KrbVTestCase(unittest.TestCase):

      @mock.patch('koji.krbV', new=None)

      def test_krbv_disabled(self):

          """Test that when krbV and gssapi are absent, we behave rationally"""

          self.assertEquals(koji.krbV, None)

      # this case should work on python3, but skipped still

      @unittest.skipIf(six.PY3, "skipped on python3 since missing of python-krbV")

      @mock.patch('koji.krbV', create=True)

      @mock.patch('koji.ClientSession._serverPrincipal')

      def test_krbv_old_requests_kerberos(self, _serverPrincipal_mock, krbV_mock):

          self.assertIsNotNone(koji.krbV)

      elif options.user:

          # authenticate using user/password

          session.login()

          session.gssapi_login(principal=options.principal, keytab=options.keytab,

                               proxyuser=options.runas)

      if not options.noauth and not session.logged_in:

      elif options.user:

          # authenticate using user/password

          session.login()

          session.krb_login(options.principal, options.keytab, options.ccache)

      else:

          quit("No username/password/certificate supplied and Kerberos missing or not configured")