import json

  import shutil

  import tempfile

  import unittest

  import koji

  import kojihub

  import kojihub.db

          self.db_lock = mock.patch('kojihub.repos.db_lock').start()

          self.db_lock.return_value = True

      def test_nolock(self):

          self.db_lock.return_value = False

          repos.check_repo_queue()

          # 2 maven reqs with free tasks

          reqs = [dict({'id': n, 'task_id': 100 + n}, **basereq) for n in range(2)]

          # plus two more, one maven, one not

          req_b = {'id': 99, 'task_id': None, 'task_state': None, 'opts': {}, 'tries': 1}

          reqs.extend([req_a, req_b])

          self.RepoQueueQuery.return_value.execute.return_value = reqs

          # 1 maven req with free tasks

          reqs.append(dict({'id': 7, 'task_id': 107}, **base2))

          # plus 4 more, two maven, two not

          req_c = {'id': 98, 'task_id': None, 'task_state': None, 'opts': {}, 'tries': 1}

          req_d = {'id': 99, 'task_id': None, 'task_state': None, 'opts': {}, 'tries': 1}

          reqs.extend([req_a, req_b, req_c, req_d])

      def test_check_queue_badrepo1(self):

          req = {'id': 100, 'task_id': 200, 'task_state': koji.TASK_STATES['CLOSED'], 'opts': {},

          self.RepoQueueQuery.return_value.execute.return_value = [req]

          self.get_repo_from_task.return_value = None

          # should retry

      def test_check_queue_badrepo2(self):

          req = {'id': 100, 'task_id': 200, 'task_state': koji.TASK_STATES['CLOSED'], 'opts': {},

          self.RepoQueueQuery.return_value.execute.return_value = [req]

          self.get_repo_from_task.return_value = 'REPO'

          self.valid_repo.return_value = False

      def test_check_queue_goodrepo(self):

          req = {'id': 100, 'task_id': 200, 'task_state': koji.TASK_STATES['CLOSED'], 'opts': {},

          self.RepoQueueQuery.return_value.execute.return_value = [req]

          repo = {'id': 123, 'sentinel': 'hello 123dfs'}

          self.get_repo_from_task.return_value = repo

          # missing opt value

          req2 = req.copy()

          bad = repo.copy()

          bad['opts'] = {'separate_src': False, 'src': False}

          bad['custom_opts'] = {'debuginfo': True}

          # wrong custom opts

          req2 = req.copy()

          bad = repo.copy()

          bad['opts'] = {'debuginfo': True, 'separate_src': False, 'src': False}

          bad['custom_opts'] = {'debuginfo': True}

          # invalid opts

          req2 = req.copy()

          bad = repo.copy()

          bad['opts'] = {}

          # opts field should never be blank

      def test_invalid_repo(self):

          # hook should not process invalid repos

          repos.repo_done_hook(100)

          self.Savepoint.return_value.rollback.assert_not_called()

      def test_no_match(self):

          self.RepoQuery.return_value.executeOne.return_value = repo

          self.RepoQueueQuery.return_value.execute.return_value = []

          repo = {'id': 55, 'dist': False, 'opts': {}, 'custom_opts': {}, 'tag_id': 'TAGID',

                  'create_event': 101010}

          self.RepoQuery.return_value.executeOne.return_value = repo

          self.RepoQueueQuery.return_value.execute.side_effect = [[req], []]

          repos.repo_done_hook(100)

          self.symlink.assert_not_called()

      def test_symlink(self):

          self.RepoQuery.return_value.execute.return_value = []

          self.lexists.return_value = False

          self.unlink.assert_not_called()

      def test_symlink_dist(self):

          self.RepoQuery.return_value.execute.return_value = []

          result = repos.symlink_if_latest(repo)

          self.symlink.assert_called_with('99', expect)

      def test_symlink_replace(self):

          self.RepoQuery.return_value.execute.return_value = []

          self.lexists.return_value = True

          self.symlink.assert_called_with('99', expect)

      def test_symlink_fail(self):

          self.RepoQuery.return_value.execute.return_value = []

          self.symlink.side_effect = OSError('failed')

          repos.do_auto_requests()

      def test_no_tags(self):

          autokeys = []

          repos.do_auto_requests()

      def test_blocked_row(self):

          autokeys = [

          repos.do_auto_requests()

      def test_auto_lag(self):

          # use a trivial window to simplify the lag calculation

          repos.do_auto_requests()

          # with zero lag, getLastEvent should be called with current time

          self.getLastEvent.assert_called_once_with(before=now, strict=False)

          repos.do_auto_requests()

          # with zero lag, getLastEvent should be called with current time

          self.getLastEvent.assert_called_once()

          before = self.getLastEvent.call_args.kwargs['before']

          repos.do_auto_requests()

          self.tag_last_change_event.assert_called_once()

          self.tag_first_change_event.assert_called_once()

          repos.do_auto_requests()

  class TestGetRepo(BaseTest):

      def test_get_repo_simple(self):

      def test_bad_key(self):

          bad = {'XYZ': True, 'src': True}

          opts = repos.convert_repo_opts(bad)

          with self.assertRaises(koji.ParameterError):

              repos.convert_repo_opts(bad, strict=True)

      def test_null_value(self):

          value = {'debuginfo': None, 'src': True}

          opts = repos.convert_repo_opts(value)

  class TestRequestRepo(BaseTest):

          self.context.session.hasPerm.return_value = False

          with self.assertRaises(koji.ActionNotAllowed):

          self.get_repo.assert_not_called()

          self.InsertProcessor.assert_not_called()

          self.set_request_priority.assert_not_called()

          self.get_tag.return_value = {'id': 100, 'name': 'TAG', 'extra': {}}

          ev = 100001

          self.get_repo.return_value = None