parser.add_option("--password", help=_("specify password"))

      parser.add_option("--noauth", action="store_true", default=False,

                        help=_("do not authenticate"))

                        help=_("authenticate even for read-only operations"))

      parser.add_option("--authtype", help=_("force use of a type of authentication, options: "

                                             "noauth, ssl, password, or kerberos"))

  ;timeout of GSSAPI/SSL authentication by seconds, default: 60

  ;auth_timeout = 60

      cutoff_ts = time.time() - options.days * 24 * 3600

      if options.debug:

          print("Cutoff date: %s" % time.asctime(time.localtime(cutoff_ts)))

      if not options.build:

          if options.verbose:

              print("Getting builds...")

      print("Added volume %(name)s with id %(id)i" % volinfo)

      "[info] List storage volumes"

      usage = _("usage: %prog list-volumes")

      parser = OptionParser(usage=get_usage_str(usage))

      (options, args) = parser.parse_args(args)

      for volinfo in session.listVolumes():

          print(volinfo['name'])

              for child_task in child_tasks:

                  save_logs(child_task['id'], match, task_log_dir, recurse)

      for arg in args:

          if suboptions.nvr:

              suboptions.recurse = True

      tag = args[0]

      if suboptions.target:

          target_info = session.getBuildTarget(tag)

          if not target_info:

                   'maven', 'win')

      "[search] Search the system"

      usage = _("usage: %prog search [options] <search_type> <pattern>")

      usage += _('\nAvailable search types: %s') % ', '.join(_search_types)

          matchType = 'regexp'

      elif options.exact:

          matchType = 'exact'

      data = session.search(pattern, type, matchType)

      for row in data:

          print(row['name'])

  def ensure_connection(session, options=None):

      try:

          ret = session.getAPIVersion()

      except requests.exceptions.ConnectionError as ex:

              warn(_("Could not connect to Kerberos authentication service: %s") % e.args[1])

      if not noauth and not session.logged_in:

          error(_("Unable to log in, no authentication methods available"))

      ensure_connection(session)

      if getattr(options, 'debug', None):

          print("successfully connected to hub")

          'debug_xmlrpc': False,

          'pyver': None,

          'plugin_paths': None,

      }

      result = config_defaults.copy()

              # not have a default value set in the option parser.

              if name in result:

                  if name in ('anon_retry', 'offline_retry', 'use_fast_upload',

                      result[name] = config.getboolean(profile_name, name)

                  elif name in ('max_retries', 'retry_interval',

                                'offline_retry_interval', 'poll_interval',

              'koji_cli.commands.list_task_output_all_volumes').start()

          self.ensuredir = mock.patch('koji.ensuredir').start()

          self.download_file = mock.patch('koji_cli.commands.download_file').start()

          self.stdout = mock.patch('sys.stdout', new_callable=six.StringIO).start()

          self.stderr = mock.patch('sys.stderr', new_callable=six.StringIO).start()

          time.tzset()

      @mock.patch('sys.stderr', new_callable=six.StringIO)

      def test_list_targets_error_args(self, ensure_connection_mock, stderr):

          session = mock.MagicMock(getAPIVersion=lambda: koji.API_VERSION,

                                   getBuildTargets=lambda n: [])

          self.assertExitCode(ex, 2)

      @mock.patch('sys.stderr', new_callable=six.StringIO)

      def test_list_targets_error_all_not_found(self, ensure_connection_mock, stderr):

          session = mock.MagicMock(getAPIVersion=lambda: koji.API_VERSION,

                                   getBuildTargets=lambda n: [])

      @mock.patch('optparse.OptionParser.parse_args',

                  return_value=(Values({'quiet': False, 'name': 'f50'}), []))

      @mock.patch('sys.stderr', new_callable=six.StringIO)

      def test_list_targets_error_name_not_found(self, ensure_connection_mock, stderr, opt):

          session = mock.MagicMock(getAPIVersion=lambda: koji.API_VERSION,

                                   getBuildTargets=lambda n: [])

          self.assertTrue('No such build target:' in stderr.getvalue())

      @mock.patch('sys.stdout', new_callable=six.StringIO)

      def test_list_targets_all(self, ensure_connection_mock, stdout):

          session = mock.MagicMock(getAPIVersion=lambda: koji.API_VERSION,

                                   getBuildTargets=lambda n: _mock_targets)

      @mock.patch('optparse.OptionParser.parse_args',

                  return_value=(Values({'quiet': False, 'name': 'f50'}), []))

      @mock.patch('sys.stdout', new_callable=six.StringIO)

      def test_list_targets_one(self, ensure_connection_mock, stdout, opt):

          session = mock.MagicMock(getAPIVersion=lambda: koji.API_VERSION,

                                   getBuildTargets=lambda n: _mock_targets)

  import six

  import unittest

  from . import utils

      maxDiff = None

      @mock.patch('sys.stdout', new_callable=six.StringIO)

              self,

              stdout):

          session = mock.MagicMock()

          options = mock.MagicMock()

          vol_info = [

          expected = "\n".join([v['name'] for v in vol_info]) + "\n"

          session.listVolumes.return_value = vol_info

          self.assert_console_message(stdout, expected)

          self.assert_help(

              """Usage: %s list-volumes

  (Specify the --help global option for a list of other help options)

  %s: error: {message}

  """ % (self.progname, self.progname)

      @mock.patch('sys.stdout', new_callable=six.StringIO)

      def test_anon_handle_search(

              self,

          """Test anon_handle_search function"""

          session = mock.MagicMock()

          options = mock.MagicMock()

      def setUpMocks(self):

          self.activate_session = mock.patch('koji_cli.commands.activate_session').start()

          self.checkForBuilds = mock.patch('koji.util.checkForBuilds').start()

      def tearDown(self):