if dup_check:

          raise koji.GenericError("channel %(name)s already exists (id=%(id)i)" % dup_check)

      table = 'channels'

      insert = InsertProcessor(table)

      insert.set(id=channel_id, name=channel_name, description=description)

      insert.execute()

              if arch in ['src', 'noarch']:

                  continue

              repo_arches[arch] = 1

      if event is None:

          event_id = _singleValue("SELECT get_event()")

      else:

          if strict:

              raise koji.GenericError("Package already exists [id %d]" % pkg_id)

      else:

          q = """INSERT INTO package (id,name) VALUES (%(pkg_id)s,%(name)s)"""

          context.commit_pending = True

          c.execute(q, locals())

                                  'extra'])

      if 'cg_id' in data:

          insert_data['cg_id'] = data['cg_id']

      insert = InsertProcessor('build', data=insert_data)

      insert.execute()

      new_binfo = get_build(data['id'], strict=True)

      new_typed_build(buildinfo, 'rpm')

      # add rpminfo entry

      rpminfo['build_id'] = buildinfo['id']

      rpminfo['size'] = os.path.getsize(fn)

      rpminfo['payloadhash'] = koji.hex_string(koji.get_header_field(hdr, 'sigmd5'))

              userID = context.session.createUser(hostname, usertype=koji.USERTYPES['HOST'],

                                                  krb_principal=krb_principal)

          # host entry

          insert = "INSERT INTO host (id, user_id, name) VALUES (%(hostID)i, %(userID)i, " \

                   "%(hostname)s)"

          _dml(insert, dslice(locals(), ('hostID', 'userID', 'hostname')))

      def new(self, host, repo, arch, task_id=None, ctype='chroot'):

          arch = koji.parse_arches(arch, strict=True, allow_none=True)

          state = koji.BR_STATES['INIT']

          insert = InsertProcessor('buildroot', data={'id': br_id})

          insert.set(container_arch=arch, container_type=ctype)

          insert.set(br_type=koji.BR_TYPES['STANDARD'])

                  raise koji.GenericError("Buildroot field %s not specified" % key)

          if data['extra'] is not None:

              data['extra'] = json.dumps(data['extra']),

          insert = InsertProcessor('buildroot')

          insert.set(id=br_id, **data)

          insert.execute()

          self.insert_execute = mock.MagicMock()

          self.verify_name_internal = mock.patch('kojihub.verify_name_internal').start()

          self.get_channel = mock.patch('kojihub.get_channel').start()

      def tearDown(self):

          mock.patch.stopall()

          with self.assertRaises(koji.GenericError):

              self.exports.addChannel(self.channel_name)

          self.get_channel.assert_called_once_with(self.channel_name, strict=False)

          self.assertEqual(len(self.inserts), 0)

      def test_add_channel_valid(self):

          self.get_channel.return_value = {}

          self.verify_name_internal.return_value = None

          r = self.exports.addChannel(self.channel_name, description=self.description)

          self.context.session.assertPerm.assert_called_once_with('admin')

          self.get_channel.assert_called_once_with(self.channel_name, strict=False)

      def test_add_channel_wrong_name(self):

          # name is longer as expected

          self._dml = mock.patch('kojihub._dml').start()

          self.get_host = mock.patch('kojihub.get_host').start()

          self._singleValue = mock.patch('kojihub._singleValue').start()

          self.get_user = mock.patch('kojihub.get_user').start()

      def tearDown(self):

      def test_add_host_valid(self):

          self.verify_host_name.return_value = None

          self.get_host.return_value = {}

          self.context.session.createUser.return_value = 456

          self.get_user.return_value = None

          kojihub.get_host.assert_called_once_with('hostname')

          self.context.session.createUser.assert_called_once_with(

              'hostname', usertype=koji.USERTYPES['HOST'], krb_principal='-hostname-')

          self.assertEqual(self._dml.call_count, 1)

          self._dml.assert_called_once_with("INSERT INTO host (id, user_id, name) "

                                            "VALUES (%(hostID)i, %(userID)i, %(hostname)s)",

      def test_valid(self):

          self.get_build.return_value = None

          self.new_package.return_value = 54

          self.get_user.return_value = {'id': 123}

          data = {