parser.add_option("--yum-proxy", help=_("Specify a yum proxy"))

      parser.add_option("-o", metavar="FILE", dest="ofile", help=_("Output to a file"))

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

      if args:

          # for historical reasons, we also accept buildroot name as first arg

          if not options.name:

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

      if len(args) == 0:

          parser.error(_("A tag name must be specified"))

      if options.all:

          if len(args) > 1:

              parser.error(_("A package name may not be combined with --all"))

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

      if len(args) != 0:

          parser.error(_("This command takes no arguments"))

      for x in sorted(session._listapi(), key=lambda x: x['name']):

          if 'argdesc' in x:

              args = x['argdesc']

          parser.error(_("A tag name must be specified"))

      elif len(args) > 2:

          parser.error(_("Only one package name may be specified"))

      pathinfo = koji.PathInfo()

      package = None

      if len(args) > 1:

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

      if len(args) != 1:

          parser.error(_("Incorrect number of arguments"))

      buildrootID = int(args[0])

      opts = {}

      if options.built:

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

      if len(args) > 1:

          parser.error(_("Only one package name may be specified"))

      package = None

      if len(args) > 0:

          package = args[0]

      opts = {}

      if options.incl_blocked:

          opts['incl_blocked'] = True

      event = koji.util.eventFromOpts(session, options)

      if event:

          opts['event'] = event['id']

      parser.add_option("--quiet", action="store_true", default=goptions.quiet,

                        help=_("Do not print header information"))

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

      channels = session.listChannels()

      channels = sorted(channels, key=lambda x: x['name'])

      session.multicall = True

      parser.add_option("--description", action="store_true", help=_("Show descriptions"))

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

      opts = {}

      if options.arch:

          opts['arches'] = options.arch

      if options.channel:

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

      if len(args) != 0:

          parser.error(_("This command takes no arguments"))

      opts = {}

      if options.owner:

          user = session.getUser(options.owner)

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

      if len(args) != 0:

          parser.error(_("This command takes no arguments"))

      opts = {}

      for key in ('type', 'prefix', 'pattern'):

          value = getattr(options, key)

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

      if len(args) < 1:

          parser.error(_("Please specify an RPM"))

      for rpm in args:

          info = session.getRPM(rpm)

          if info is None:

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

      if len(args) < 1:

          parser.error(_("Please specify a build"))

      for build in args:

          if build.isdigit():

              build = int(build)

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

      if len(args) < 1:

          parser.error(_("Please specify a host"))

      for host in args:

          if host.isdigit():

              host = int(host)

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

      if len(args) != 0:

          parser.error(_("This command takes no arguments"))

      fmt = "%(name)-30s %(build_tag_name)-30s %(dest_tag_name)-30s"

      if not options.quiet:

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

      if len(args) != 1:

          parser.error(_("This command takes exactly one argument: a tag name or ID"))

      event = koji.util.eventFromOpts(session, options)

      if event:

          event['timestr'] = time.asctime(time.localtime(event['ts']))

      parser.add_option("--build", help=_("Show tags associated with a build"))

      parser.add_option("--package", help=_("Show tags associated with a package"))

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

      pkginfo = {}

      buildinfo = {}

      if not limited and not options.all:

          parser.error(_("Please specify an option to limit the query"))

      if options.watch:

          if not kwargs.get('afterEvent') and not kwargs.get('after'):

      if len(args) < 1:

          parser.error(_("You must specify at least one task ID"))

      for arg in args:

          task_id = int(arg)

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

      if len(args) < 1:

          parser.error(_("Please specify a tag"))

      event = koji.util.eventFromOpts(session, options)

      event_opts = {}

      if event:

          parser.error(_("Incorrect number of arguments"))

      if options.incl_blocked and (options.comps or options.spec):

          parser.error(_("--show-blocked doesn't make sense for comps/spec output"))

      tag = args[0]

      callopts = {}

      if options.incl_blocked:

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

      if len(args) > 0:

          parser.error(_("This command takes no arguments"))

      opts = {}

      event = koji.util.eventFromOpts(session, options)

      if event:

      if options.mine:

          activate_session(session, goptions)

      else:

      if selection:

          tasks = [task['id'] for task in _list_tasks(options, session)]

          if not tasks:

              print(_("You've no active tasks."))

              return

      else:

          tasks = []

          for task in args:

              try:

      elif len(args) > 1:

          parser.error(_("Only a single package N-V-R or build ID may be specified"))

      build = args[0]

      if build.isdigit():

      if len(suboptions.arches) > 0:

          suboptions.arches = ",".join(suboptions.arches).split(",")

      # get downloadable tasks

          parser.error(_("Use --user or --mine."))

      if options.user:

          user = session.getUser(options.user)

          if not user:

              error("User %s does not exist" % options.user)

  def handle_version(goptions, session, args):

      """Report client and hub versions"""

      print('Client: %s' % koji.__version__)

      try:

          version = session.getKojiVersion()

      return usage + _("\n(Specify the --help global option for a list of other help options)")

      try:

          ret = session.getAPIVersion()

      if ret != koji.API_VERSION:

          warn(_("WARNING: The server is at API version %d and "

                 "the client is at %d" % (ret, koji.API_VERSION)))

              except Exception:

                  return offline_reply(start_response, msg="database outage")

              h = ModXMLRPCRequestHandler(registry)

              if environ.get('CONTENT_TYPE') == 'application/octet-stream':

                  response = h._wrap_handler(h.handle_upload, environ)

              else:

          expected = ''

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_not_called()

          self.list_task_output_all_volumes.assert_called_once_with(self.session, task_id)

          expected = 'No such task: #123333\n'

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_not_called()

          expected = ''

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_called_once_with(task_id)

          self.assertEqual(self.list_task_output_all_volumes.mock_calls, [

          expected = ''

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_not_called()

          self.list_task_output_all_volumes.assert_called_once_with(self.session, task_id)

          expected = 'No files for download found.\n'

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_not_called()

          self.list_task_output_all_volumes.assert_called_once_with(self.session, task_id)

          expected = 'Task 123333 has not finished yet.\n'

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_not_called()

          self.list_task_output_all_volumes.assert_called_once_with(self.session, task_id)

          expected = 'Child task 22222 has not finished yet.\n'

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_called_once_with(task_id)

          self.list_task_output_all_volumes.assert_called_once_with(self.session, 22222)

          expected = 'Invalid file name: somerpm..src.rpm\n'

          self.assertMultiLineEqual(actual, expected)

          # Finally, assert that things were called as we expected.

          self.session.getTaskInfo.assert_called_once_with(task_id)

          self.session.getTaskChildren.assert_not_called()

          self.list_task_output_all_volumes.assert_called_once_with(self.session, task_id)

  test                 2      2      1      1      6     28%

  """

          self.assertMultiLineEqual(actual, expected)

          self.maxDiff=None

          self.assertMultiLineEqual(actual, expected)

          self.session.getTag.assert_has_calls([mock.call(1), mock.call(1)])

          self.session.getPackage.assert_has_calls([mock.call(11), mock.call(11)])

          self.session.getUser.assert_called_once_with('random_name')

          args = ['tag', 'pkg', '--latest', '--inherit', '--event=1000']

          anon_handle_list_tagged(self.options, self.session, args)

          self.session.getTag.assert_called_once_with('tag', event=1000)

          self.session.listTagged.assert_called_once_with('tag',

                                                          event=1000,

                  '--arch=x86_64', '--arch=noarch']

          anon_handle_list_tagged(self.options, self.session, args)

          self.session.getTag.assert_called_once_with('tag', event=None)

          self.session.listTaggedRPMS.assert_called_once_with('tag',

                                                              package='pkg',

                                                   'maven_artifact_id': 'artifact'}]

          anon_handle_list_tagged(self.options, self.session, args)

          self.session.getTag.assert_called_once_with('tag', event=None)

          self.session.listTagged.assert_called_once_with('tag',

                                                          package='pkg',