if prev['payloadhash'] == koji.hex_string(data['sigmd5']):

                  print(_("RPM already imported: %s") % path)

              else:

                      prev['payloadhash'], koji.hex_string(data['sigmd5'])))

              print(_("Skipping import"))

              return

                  print(_("Signature already imported: %s") % path)

                  continue

              else:

                  continue

          print(_("Importing signature [key %s] from %s...") % (sigkey, path))

          if not options.test:

                      except OSError as e:

                          print("Error removing %s: %s" % (signedpath, e))

              elif len(sigdirs) > 1:

          if build_files:

              total_files += build_files

              total_space += build_space

          if event_id != other[0]:

              bad_edit = "non-matching"

          if bad_edit:

              # we'll simply treat them as separate events

              pprint.pprint(entry)

              pprint.pprint(edit)

                  write_fail_log(task_log_dir, task_id)

                  count += 1

          elif state not in ['CLOSED', 'CANCELED']:

          for log_filename, log_volume in logs:

              download_log(task_log_dir, task_id, log_filename, volume=log_volume)

      for nvr in builds:

          data = session.getLatestBuilds(tag_id, package=nvr["name"])

          if len(data) == 0:

          else:

              present_nvr = [x["nvr"] for x in data][0]

              if present_nvr != "%s-%s-%s" % (nvr["name"], nvr["version"], nvr["release"]):

      last_repo = None

      repo = session.getRepo(tag_id)

          tag = info['name']

          targets = session.getBuildTargets(buildTagID=info['id'])

          if not targets:

      if not info['arches']:

      if suboptions.debuginfo:

          repo_opts['debuginfo'] = True

      if suboptions.source:

              parser.error(_('No arches given and no arches associated with tag'))

      else:

          for a in task_opts.arch:

      if task_opts.multilib:

          if not os.path.exists(task_opts.multilib):

              parser.error(_('could not find %s') % task_opts.multilib)

      def tearDown(self):

          mock.patch.stopall()

          expected = expected + "Creating dist repo for tag " + self.tag_name + "\n"

          self.assert_console_message(stdout, expected)

          self.activate_session.assert_called_with(self.session, self.options)

      def test_handle_dist_repo(self):

          arguments = [self.tag_name, self.fake_key]

          self.watch_tasks.assert_called_with(

              self.session,

              [self.task_id],

      def test_handle_dist_repo_nowait(self):

          arguments = [self.tag_name, self.fake_key, '--nowait']

          self.activate_session.assert_called_with(self.session, self.options)

          self.watch_tasks.assert_not_called()

          self.session.uploadWrapper = lambda *args, **kwargs: print('uploadWrapper ...')

          expected = 'uploadWrapper ...\n\n'

          with mock.patch('os.path.exists', return_value=True):

      def test_handle_dist_repo_with_multiarch_opt(self):

          arches = ['i386', 'x86_64', 'ppc', 'src']

          for a in arches:

              arguments += ['--arch', a]

      @mock.patch('os.path.exists')

      def test_handle_dist_repo_with_multilib_opt(self, path_mock):

          path_mock.return_value = True

          arches = [('x86_64', 'i686'), ('s390x', 's390'), ('ppc64', 'ppc')]

          for arch in arches:

                  'The multilib arch (%s) must be included' % arch[1])

              self.assert_system_exit(

                  handle_dist_repo,

          self.session.getTag.return_value.update({'arches': 'x86_64, i686'})

          expected = 'uploadWrapper ...\n\n'

          arguments += ['--arch', 'x86_64', '--arch', 'i686']

      def test_handle_dist_repo_with_delta_rpms_opt(self):

          repos = ['test-repo1', 'test-repo2', '3']

              None,

              {'id': 2, 'name': 'test-repo2'},   # state is exprired repo

          ]

      def test_handle_dist_repo_help(self):

          """Test handle_dist_repo help message"""

          session.getRPM.reset_mock()

          session.importRPM.reset_mock()

          expected = kwargs.get('expected', None)

          rpm_header = kwargs.get('rpm_header', {})

          with mock.patch('koji.get_header_fields') as get_header_fields_mock:

          # check output message

          self.assert_console_message(stdout, expected)

          # check mock calls

          activate_session_mock.assert_called_with(session, options)

          # Case 2: build exists and status is 'COMPLETE', md5 mismatched

          # reseult: import skipped

          session.getRPM.return_value['payloadhash'] = false_md5

          self.__skip_import_test(

              options, session, arguments,

              rpm_header=self.srpm_header,

          # Case 3: build exists and status is 'COMPLETE', has external_repo_id

          # reseult: import will be performed

  %s: error: {message}

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

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

      @mock.patch('koji.rip_rpm_sighdr')

      @mock.patch('koji.get_sigpacket_key_id')

              get_header_fields_mock,

              get_sigpacket_key_id_mock,

              rip_rpm_sighdr_mock,

          """Test handle_import_sig function"""

          arguments = ['/path/to/bash', '/path/to/less', '/path/to/sed']

          options = mock.MagicMock()

                  expected += "Signature already imported: %s" % pkg + "\n"

              else:

                  sigRpm.append([{'sighash': self.md5sum('wrong-sig-case')}])

          rinfo = copy.deepcopy(self.rpm_headers)

          for i, data in enumerate(rinfo):

          handle_import_sig(options, session, arguments)

          self.assert_console_message(stdout, expected)

          # Case 5, --test options test

          # result: everything works fine and addRPMSig/writeSignedRPM should

      def tearDown(self):

          mock.patch.stopall()

          expected += "Regenerating repo for tag: %s" % self.tag_name + "\n"

          expected += "Created task: %d" % self.task_id + "\n"

          expected += "Task info: %s/taskinfo?taskID=%s" % (self.options.weburl, self.task_id) + "\n"

          self.assert_console_message(stdout, expected)

          self.activate_session.assert_called_with(self.session, self.options)

      def test_handle_regen_repo(self):

          # show warning if tag is not a build tag

          self.session.getTag.return_value = copy.copy(self.TAG)

          self.session.getBuildTargets.return_value = []

          self.resetMocks()

          # show warning message if arch is empty

          noarch_tag = copy.copy(self.TAG)

          noarch_tag.update({'arches': ''})

          self.session.getTag.return_value = noarch_tag

      def test_handle_regen_repo_with_target_opt(self):

          """Test handle_regen_repo function with --target option"""

          self.resetMocks()

          self.session.getBuildTarget.return_value = {'build_tag_name': self.tag_name}

      def test_handle_regen_repo_with_other_opts(self):

          """Test handle_regen_repo function with options"""

          # --nowait

          self.resetMocks()

          # --source && --debuginfo

          self.session.newRepo.assert_called_with(self.tag_name, **{'debuginfo': True, 'src': True})

      def test_handle_regen_repo_errors(self):

      @mock.patch('time.time')

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

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

          self.options.quiet = False

          time_mock.side_effect = [0, 1, 2, 3]

          if ret_code:

          else:

              rv = anon_handle_wait_repo(self.options, self.session, args)

              self.assert_console_message(stdout, expected)

              self.assertIn(rv, [0, None])

      @mock.patch('time.time')

          self.session.getRepo.side_effect = [

              {}, {}, {'id': 1, 'name': 'DEFAULT', 'create_event': 1}

          ]

                     (builds[0], self.tag_name, self.tag_name, new_ver) + "\n"

                      '%s repo\n' % (pkgs, self.tag_name)

      def test_anon_handle_wait_repo_with_build_timeout(self):

          """Test anon_handle_wait_repo function with --build options on timeout cases"""