self.channel_id = 1

          self.options = mock.MagicMock()

          self.session = mock.MagicMock()

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

          self.session.addChannel.return_value = self.channel_id

          rv = handle_add_channel(self.options, self.session,

                                  ['--description', self.description, self.channel_name])

          actual = stdout.getvalue()

          expected = '%s added: id %s\n' % (self.channel_name, self.channel_id)

          self.assertMultiLineEqual(actual, expected)

          self.session.addChannel.assert_called_once_with(self.channel_name,

                                                          description=self.description)

          self.assertNotEqual(rv, 1)

          expected_api = 'channel %s already exists (id=%s)' % (self.channel_name, self.channel_id)

          expected = 'channel %s already exists\n' % self.channel_name

          self.session.addChannel.side_effect = koji.GenericError(expected_api)

          self.session.addChannel.assert_called_once_with(self.channel_name,

                                                          description=self.description)

          expected_api = 'Invalid method: addChannel'

          expected = 'addChannel is available on hub from Koji 1.26 version, your version ' \

                     'is 1.25.1\n'

          self.session.getKojiVersion.return_value = '1.25.1'

          self.session.addChannel.side_effect = koji.GenericError(expected_api)

          self.session.addChannel.assert_called_once_with(self.channel_name,

                                                          description=self.description)

          channel_2 = 'channel-2'

      def test_handle_add_channel_help(self):

          self.assert_help(

  from koji_cli.commands import handle_add_group

  from . import utils

  class TestAddGroup(utils.CliTestCase):

      # Show long diffs in error output...

      maxDiff = None

      def setUp(self):

          self.error_format = """Usage: %s add-group <tag> <group>

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

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

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

          tag = 'tag'

          group = 'group'

          arguments = [tag, group]

          self.assertMultiLineEqual(actual, expected)

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

          session.hasPerm.assert_called_once_with('admin')

          session.getTag.assert_called_once_with(tag)

          session.getTagGroups.assert_called_once_with(tag, inherit=False)

          session.groupListAdd.assert_called_once_with(tag, group)

          self.assertNotEqual(rv, 1)

          tag = 'tag'

          group = 'group'

          arguments = [tag, group]

              {'name': 'group', 'group_id': 'groupId'}]

          # Run it and check immediate output

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

          session.hasPerm.assert_called_once_with('admin')

          session.getTag.assert_called_once_with(tag)

          session.getTagGroups.assert_called_once_with(tag, inherit=False)

          session.groupListAdd.assert_not_called()

          arguments = []

          options = mock.MagicMock()

              activate_session=None)

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

          session.hasPerm.assert_not_called()

          session.getTag.assert_not_called()

          session.getTagGroups.assert_not_called()

          session.groupListAdd.assert_not_called()

          tag = 'tag'

          group = 'group'

          arguments = [tag, group]

              exit_code=2)

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

          session.hasPerm.assert_has_calls([mock.call('admin'),

                                            mock.call('tag')])

          session.getTag.assert_not_called()

          session.getTagGroups.assert_not_called()

          session.groupListAdd.assert_not_called()

          tag = 'tag'

          group = 'group'

          arguments = [tag, group]

          session.getTag.return_value = None

          # Run it and check immediate output

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

          session.hasPerm.assert_called_once_with('admin')

          session.getTag.assert_called_once_with(tag)

          session.getTagGroups.assert_not_called()

  from __future__ import absolute_import

  import mock

  import six

  class TestAddHost(utils.CliTestCase):

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

          host = 'host'

          host_id = 1

          arches = ['arch1', 'arch2']

          expected = 'host added: id 1\n'

          self.assertMultiLineEqual(actual, expected)

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

          session.getHost.assert_called_once_with(host)

          session.addHost.assert_called_once_with(host, arches, **kwargs)

          self.assertNotEqual(rv, 1)

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

          host = 'host'

          host_id = 1

          arches = ['arch1', 'arch2']

          expected = 'host added: id 1\n'

          self.assertMultiLineEqual(actual, expected)

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

          session.getHost.assert_called_once_with(host)

          session.addHost.assert_called_once_with(host, arches, force=False)

          self.assertNotEqual(rv, 1)

          host = 'host'

          host_id = 1

          arches = ['arch1', 'arch2']

          # Run it and check immediate output

          # args: host, arch1, arch2, --krb-principal=krb

          # expected: failed, host already exists

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

          session.getHost.assert_called_once_with(host)

          session.addHost.assert_not_called()

          arguments = []

          options = mock.MagicMock()

          # Mock out the xmlrpc server

          session = mock.MagicMock()

          # Run it and check immediate output

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

          session.hasHost.assert_not_called()

          session.addHost.assert_not_called()

  """ % self.progname)

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

          host = 'host'

          arches = ['arch1', 'arch2']

          krb_principal = '--krb-principal=krb'

          expected = ''

          self.assertMultiLineEqual(actual, expected)

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

          session.getHost.assert_called_once_with(host)

          session.addHost.assert_called_once_with(host, arches, **kwargs)

  from __future__ import absolute_import

  import mock

  import six

  import unittest

  from koji_cli.commands import handle_add_host_to_channel

  class TestAddHostToChannel(utils.CliTestCase):

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

          host = 'host'

          host_info = mock.ANY

          channel = 'channel'

          expected = ''

          self.assertMultiLineEqual(actual, expected)

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

          session.getChannel.assert_called_once_with(channel)

          session.getHost.assert_called_once_with(host)

          session.addHostToChannel.assert_called_once_with(host, channel)

          self.assertNotEqual(rv, 1)

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

          list_arg = '--list'

          args = [list_arg]

          channel_infos = [{'name': 'channel1'}, {'name': 'channel2'}]

          expected = 'channel1\nchannel2\n'

          self.assertMultiLineEqual(actual, expected)

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

          session.listChannels.assert_called_once()

          session.getChannel.assert_not_called()

          session.getHost.assert_not_called()

          self.assertNotEqual(rv, 1)

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

          host = 'host'

          host_info = mock.ANY

          channel = 'channel'

          expected = ''

          self.assertMultiLineEqual(actual, expected)

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

          session.getChannel.assert_not_called()

          session.getHost.assert_called_once_with(host)

          session.addHostToChannel.assert_called_once_with(host, channel, create=True, force=True)

          self.assertNotEqual(rv, 1)

          host = 'host'

          channel = 'channel'

          channel_info = None

          options = mock.MagicMock()

          # Mock out the xmlrpc server

          # Run it and check immediate output

          # args: host, channel

          # expected: failed, channel not found

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

          session.getChannel.assert_called_once_with(channel)

          session.getHost.assert_not_called()

          session.addHostToChannel.assert_not_called()

          host = 'host'

          host_info = None

          channel = 'channel'

          channel_info = mock.ANY

          options = mock.MagicMock()

          # Mock out the xmlrpc server

          # Run it and check immediate output

          # args: host, channel

          # expected: success

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

          session.getChannel.assert_called_once_with(channel)

          session.getHost.assert_called_once_with(host)

          session.addHostToChannel.assert_not_called()

      @mock.patch('koji_cli.commands.activate_session')

      def test_handle_add_host_to_channel_help(

              self, activate_session_mock, stderr, stdout):

          options = mock.MagicMock()

          # Mock out the xmlrpc server

          session = mock.MagicMock()

          # Run it and check immediate output

          # args: _empty_

          # expected: failed, help msg shows

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

          activate_session_mock.assert_not_called()

  from koji_cli.commands import handle_add_notification

  from . import utils

  class TestAddNotification(utils.CliTestCase):

      def setUp(self):

          self.options = mock.MagicMock()

          self.options.debug = False

          self.session = mock.MagicMock()

          self.session.getAPIVersion.return_value = koji.API_VERSION

          self.session.getPackageID.return_value = 1234

          self.session.getTagID.return_value = 4321

          self.session.getLoggedInUser.return_value = {'id': 678}

          self.session.getPackageID.assert_called_once_with('pkg_a')

          self.session.getTagID.assert_called_once_with('tag_a', strict=True)

          self.session.getLoggedInUser.assert_called_once_with()

          self.session.getUser.assert_not_called()

          self.session.createNotification.assert_called_once_with(678, 1234, 4321, True)

          self.session.getTagID.return_value = 4321

          self.session.getLoggedInUser.return_value = {'id': 678}

          self.session.getLoggedInUser.assert_called_once_with()

          self.session.getUser.assert_not_called()

          self.session.createNotification.assert_called_once_with(678, None, 4321, True)

          self.session.getPackageID.return_value = 1234

          self.session.getLoggedInUser.return_value = {'id': 678}

          self.session.getLoggedInUser.assert_called_once_with()

          self.session.getUser.assert_not_called()

          self.session.createNotification.assert_called_once_with(678, 1234, None, False)

      @mock.patch('sys.exit')

          sys_exit.side_effect = SystemExit()

          self.session.getPackageID.assert_not_called()

          self.session.getTagID.assert_not_called()

          self.session.getLoggedInUser.assert_not_called()

          self.session.getUser.assert_not_called()

          self.session.createNotification.assert_not_called()

      @mock.patch('sys.exit')

          sys_exit.side_effect = SystemExit()

          self.session.hasPerm.return_value = False

          self.session.getPackageID.assert_not_called()

          self.session.getTagID.assert_not_called()

          self.session.getLoggedInUser.assert_not_called()

          self.session.getUser.assert_not_called()

          self.session.createNotification.assert_not_called()

          self.session.hasPerm.return_value = True

          self.session.getPackageID.return_value = 1234

          self.session.getUser.return_value = {'id': 789}

          self.session.getPackageID.assert_called_once_with('pkg_a')

          self.session.getTagID.assert_not_called()

          self.session.getLoggedInUser.assert_not_called()

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

          self.session.createNotification.assert_called_once_with(789, 1234, None, False)

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

          sys_exit.side_effect = SystemExit()

          self.session.createNotification.assert_not_called()

          tag = 'tag_a'

          self.session.getTagID.side_effect = koji.GenericError

          pkg = 'pkg_a'

          self.session.getPackageID.return_value = None

  from __future__ import absolute_import

  import mock

  import unittest

  from koji_cli.commands import handle_add_tag

  class TestAddTag(utils.CliTestCase):

      def setUp(self):

          self.error_format = """Usage: %s add-tag [options] <name>

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

  %s: error: {message}

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

          """Test handle_add_tag function"""

          # Case 1. no argument error