def create(self, **kwargs):

        # All of the options will be present, even if the user didn't specify
        # them. Their values will be None, which the yum importer is set up
        # to handle.

        # Gather data
        repo_id = kwargs.pop('repo-id')
        description = kwargs.pop('description', None)
        display_name = kwargs.pop('display-name', None)
        auto_publish = kwargs.pop('auto-publish', None)

        if auto_publish:
            auto_publish = arg_to_bool(auto_publish)
            if auto_publish:
                self.context.prompt.render_failure_message(_('Value for auto-publish must be either true or false'))
                return

        try:
            notes = None
            if 'note' in kwargs and kwargs['note'] is not None:
                notes = args_to_notes_dict(kwargs['note'], include_none=False)
            importer_config = args_to_importer_config(kwargs)
            distributor_config = args_to_distributor_config(kwargs)
        except InvalidConfig, e:
            self.context.prompt.render_failure_message(e[0])
            return

    def test_dict_arg(self):
        """
        Tests to make sure that attempting to parse a dict returns the dict
        """
        # Setup
        test_dict = {'key': 'value', 'key2': 'value2'}

        # Test
        result = arg_utils.args_to_notes_dict(test_dict)
        self.assertTrue(test_dict is result)

    def test_include_none_false(self):
        """
        Tests to make sure keys with null values are not returned when include_none=False
        """
        # Setup
        test_list = ['key=value', 'key2=', 'key3=""']

        # Test
        result = arg_utils.args_to_notes_dict(test_list, include_none=False)
        self.assertTrue('key' in result)
        self.assertEqual(result['key'], 'value')
        self.assertFalse('key2' in result)
        self.assertFalse('key3' in result)

    def create(self, **kwargs):

        # Collect input
        id = kwargs['repo-id']
        name = id
        if 'display-name' in kwargs:
            name = kwargs['display-name']
        description = kwargs['description']
        notes = arg_utils.args_to_notes_dict(kwargs['note'], include_none=True)

        # Call the server
        self.context.server.repo.create(id, name, description, notes)
        self.prompt.render_success_message('Repository [%s] successfully created' % id)

    def run(self, **kwargs):
        # Collect input
        id = kwargs[OPTION_REPO_ID.keyword]
        name = id
        if OPTION_NAME.keyword in kwargs:
            name = kwargs[OPTION_NAME.keyword]
        description = kwargs[OPTION_DESCRIPTION.keyword]
        notes = arg_utils.args_to_notes_dict(kwargs[OPTION_NOTES.keyword], include_none=True)

        # Call the server
        self.context.server.repo.create(id, name, description, notes)
        msg = _('Repository [%(r)s] successfully created')
        self.prompt.render_success_message(msg % {'r' : id})

    def update(self, **kwargs):
        # Assemble the delta for all options that were passed in
        delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
        delta.pop('group-id') # not needed in the delta

        if delta.pop('note', None) is not None:
            delta['notes'] = arg_utils.args_to_notes_dict(kwargs['note'], include_none=True)
        try:
            self.context.server.repo_group.update(kwargs['group-id'], delta)
            self.prompt.render_success_message(
                'Repo group [%s] successfully updated' % kwargs['group-id'])
        except NotFoundException:
            self.prompt.write(
                'Repo group [%s] does not exist on the server' % kwargs['group-id'], tag='not-found')

    def run(self, **kwargs):
        # Assemble the delta for all options that were passed in
        delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
        delta.pop(OPTION_GROUP_ID.keyword) # not needed in the delta

        if delta.pop(OPTION_NOTES.keyword, None) is not None:
            delta['notes'] = arg_utils.args_to_notes_dict(kwargs[OPTION_NOTES.keyword], include_none=True)
        try:
            self.context.server.repo_group.update(kwargs[OPTION_GROUP_ID.keyword], delta)
            msg = 'Repo group [%(g)s] successfully updated'
            self.prompt.render_success_message(msg % {'g' : kwargs['group-id']})
        except NotFoundException:
            msg = 'Repo group [%(g)s] does not exist on the server'
            self.prompt.write(msg % {'g' : kwargs['group-id']}, tag='not-found')

    def create(self, **kwargs):
        # Collect input
        consumer_group_id = kwargs['consumer-group-id']
        name = consumer_group_id
        if 'display-name' in kwargs:
            name = kwargs['display-name']
        description = kwargs['description']
        notes = kwargs.get('notes', None)
        if notes:
            notes = arg_utils.args_to_notes_dict(notes, include_none=True)

        # Call the server
        self.context.server.consumer_group.create(consumer_group_id, name, description, notes)
        self.prompt.render_success_message(
            'Consumer Group [%s] successfully created' % consumer_group_id)

    def update(self, **kwargs):

        # Assemble the delta for all options that were passed in
        consumer_id = load_consumer_id(self.context)
        if not consumer_id:
            self.prompt.render_failure_message("This consumer is not registered to the Pulp server.")
            return
        delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
        if 'note' in delta.keys():
            if delta['note']:
                delta['notes'] = args_to_notes_dict(kwargs['note'], include_none=False)
            delta.pop('note')

        try:
            self.context.server.consumer.update(consumer_id, delta)
            self.prompt.render_success_message('Consumer [%s] successfully updated' % consumer_id)
        except NotFoundException:
            self.prompt.write('Consumer [%s] does not exist on the server' % consumer_id, tag='not-found')

    def update(self, **kwargs):

        # Assemble the delta for all options that were passed in
        delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
        delta.pop(OPTION_CONSUMER_ID.keyword) # not needed in the delta
        if OPTION_NOTES.keyword in delta.keys():
            delta['notes'] = args_to_notes_dict(delta['note'])
            delta.pop(OPTION_NOTES.keyword)
        if OPTION_NAME.keyword in delta:
            v = delta.pop(OPTION_NAME.keyword)
            key = OPTION_NAME.keyword.replace('-', '_')
            delta[key] = v

        try:
            self.context.server.consumer.update(kwargs[OPTION_CONSUMER_ID.keyword], delta)
            self.prompt.render_success_message('Consumer [%s] successfully updated' % kwargs[OPTION_CONSUMER_ID.keyword])
        except NotFoundException:
            self.prompt.write('Consumer [%s] does not exist on the server' % kwargs[OPTION_CONSUMER_ID.keyword], tag='not-found')

    def register(self, **kwargs):

        # Get consumer id
        id = kwargs["consumer-id"]

        # Check if this consumer is already registered
        existing_consumer = load_consumer_id(self.context)
        if existing_consumer:
            m = (
                "This system has already been registered as a consumer. Please "
                "use the unregister command to remove the consumer before attempting "
                "to reregister."
            )
            self.prompt.render_failure_message(_(m))
            return

        # Get other consumer parameters
        name = id
        if "display-name" in kwargs:
            name = kwargs["display-name"]
        description = kwargs["description"]
        notes = None
        if "note" in kwargs.keys():
            if kwargs["note"]:
                notes = args_to_notes_dict(kwargs["note"], include_none=False)

        # Check write permissions to cert directory
        id_cert_dir = self.context.config["filesystem"]["id_cert_dir"]
        if not os.access(id_cert_dir, os.W_OK):
            msg = _("Write permission is required for %(d)s to perform this operation.")
            self.prompt.render_failure_message(msg % {"d": id_cert_dir})
            return os.EX_NOPERM

        # Call the server
        consumer = self.context.server.consumer.register(id, name, description, notes).response_body

        # Write consumer cert
        id_cert_name = self.context.config["filesystem"]["id_cert_filename"]
        cert_filename = os.path.join(id_cert_dir, id_cert_name)
        f = open(cert_filename, "w")
        f.write(consumer["certificate"])
        f.close()

        self.prompt.render_success_message("Consumer [%s] successfully registered" % id)

def parse_notes(value):
    """
    Returns a value suitable to send to the server for a notes value on a
    repository. The given value will actually be a list of values regardless
    of whether or not the user specified multiple notes.

    :param value: list of user entered values or empty list if unspecified
    :type  value: list
    :return: dictionary representation of all user entered notes
    :rtype: dict
    """

    if value is None:
        return None

    try:
        return arg_utils.args_to_notes_dict(value)
    except arg_utils.InvalidConfig:
        raise ValueError(_('invalid syntax for specifying notes'))

    def run(self, **kwargs):
        # Assemble the delta for all options that were passed in
        delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
        delta.pop(OPTION_REPO_ID.keyword) # not needed in the delta

        # Translate the argument to key name
        if delta.pop(OPTION_NAME.keyword, None) is not None:
            delta['display_name'] = kwargs[OPTION_NAME.keyword]

        if delta.pop(OPTION_NOTES.keyword, None) is not None:
            delta['notes'] = arg_utils.args_to_notes_dict(kwargs[OPTION_NOTES.keyword], include_none=True)

        try:
            self.context.server.repo.update(kwargs[OPTION_REPO_ID.keyword], delta)
            msg = _('Repository [%(r)s] successfully updated')
            self.prompt.render_success_message(msg % {'r' : kwargs[OPTION_REPO_ID.keyword]})
        except NotFoundException:
            msg = _('Repository [%(r)s] does not exist on the server')
            self.prompt.write(msg % {'r' : kwargs[OPTION_REPO_ID.keyword]}, tag='not-found')

    def register(self, **kwargs):

        # Get consumer id
        id = kwargs['consumer-id']

        # Check if this consumer is already registered
        existing_consumer = load_consumer_id(self.context)
        if existing_consumer:
            m = _('This system has already been registered as a consumer. Please '
                  'use the unregister command to remove the consumer before attempting '
                  'to re-register.')
            self.prompt.render_failure_message(m)
            return

        # Get other consumer parameters
        name = id
        if 'display-name' in kwargs:
            name = kwargs['display-name']
        description = kwargs['description']
        notes = None
        if 'note' in kwargs.keys():
            if kwargs['note']:
                notes = args_to_notes_dict(kwargs['note'], include_none=False)

        # Check write permissions to cert directory
        id_cert_dir = self.context.config['filesystem']['id_cert_dir']
        if not os.access(id_cert_dir, os.W_OK):
            msg = _("Write permission is required for %(d)s to perform this operation.")
            self.prompt.render_failure_message(msg % {'d': id_cert_dir})
            return exceptions.CODE_PERMISSIONS_EXCEPTION

        # Call the server
        consumer = self.context.server.consumer.register(id, name, description, notes).response_body

        # Write consumer cert
        id_cert_name = self.context.config['filesystem']['id_cert_filename']
        cert_filename = os.path.join(id_cert_dir, id_cert_name)
        f = open(cert_filename, 'w')
        f.write(consumer['certificate'])
        f.close()

        self.prompt.render_success_message('Consumer [%s] successfully registered' % id)

    def run(self, **kwargs):
        # -- repository metadata --
        repo_id = kwargs.pop(options.OPTION_REPO_ID.keyword)
        description = kwargs.pop(options.OPTION_DESCRIPTION.keyword, None)
        name = kwargs.pop(options.OPTION_NAME.keyword, None)

        notes = None
        if options.OPTION_NOTES.keyword in kwargs and kwargs[options.OPTION_NOTES.keyword] is not None:
            notes = arg_utils.args_to_notes_dict(kwargs[options.OPTION_NOTES.keyword], include_none=True)

            # Make sure the note indicating it's a puppet repository is still present
            notes[constants.REPO_NOTE_KEY] = constants.REPO_NOTE_PUPPET

        # -- importer metadata --
        importer_config = {
            constants.CONFIG_FEED : kwargs.pop(OPTION_FEED.keyword, None),
            constants.CONFIG_QUERIES : kwargs.pop(OPTION_QUERY.keyword, None),
        }
        arg_utils.convert_removed_options(importer_config)

        # -- distributor metadata --
        distributor_config = {
            constants.CONFIG_SERVE_HTTP : kwargs.pop(OPTION_HTTP.keyword, None),
            constants.CONFIG_SERVE_HTTPS : kwargs.pop(OPTION_HTTPS.keyword, None),
        }
        arg_utils.convert_removed_options(distributor_config)
        arg_utils.convert_boolean_arguments((constants.CONFIG_SERVE_HTTP, constants.CONFIG_SERVE_HTTPS), distributor_config)

        distributor_configs = {constants.DISTRIBUTOR_ID : distributor_config}

        # -- server update --
        response = self.context.server.repo.update_repo_and_plugins(repo_id, name,
                        description, notes, importer_config, distributor_configs)

        if not response.is_async():
            msg = _('Repository [%(r)s] successfully updated')
            self.context.prompt.render_success_message(msg % {'r' : repo_id})
        else:
            d = _('Repository update postponed due to another operation. Progress '
                'on this task can be viewed using the commands under "repo tasks".')
            self.context.prompt.render_paragraph(d, tag='postponed')
            self.context.prompt.render_reasons(response.response_body.reasons)

    def update(self, **kwargs):
        consumer_id = load_consumer_id(self.context)
        if not consumer_id:
            self.prompt.render_failure_message("This consumer is not registered to the Pulp "
                                               "server.")
            return

        delta = dict([(k, v) for k, v in kwargs.items() if v is not None])
        if 'note' in delta.keys():
            if delta['note']:
                delta['notes'] = args_to_notes_dict(kwargs['note'], include_none=False)
            delta.pop('note')
        # convert display-name to display_name
        key = 'display-name'
        if key in delta:
            v = delta.pop(key)
            key = key.replace('-', '_')
            delta[key] = v

        if kwargs.get(OPTION_EXCHANGE_KEYS.keyword):
            path = self.context.config['authentication']['rsa_pub']
            fp = open(path)
            try:
                delta['rsa_pub'] = fp.read()
            finally:
                fp.close()

        try:
            self.context.server.consumer.update(consumer_id, delta)
            self.prompt.render_success_message('Consumer [%s] successfully updated' % consumer_id)
            if not kwargs.get(OPTION_EXCHANGE_KEYS.keyword):
                return
            try:
                update_server_key(self.context.config)
            except Exception, e:
                msg = _('Download server RSA key failed [%(e)s]' % {'e': e})
                self.prompt.render_failure_message(msg)
        except NotFoundException:
            self.prompt.write('Consumer [%s] does not exist on the server' % consumer_id,
                              tag='not-found')

    def run(self, **kwargs):

        # -- repository metadata --
        repo_id = kwargs[options.OPTION_REPO_ID.keyword]
        description = kwargs[options.OPTION_DESCRIPTION.keyword]
        notes = {}
        if kwargs[options.OPTION_NOTES.keyword]:
            notes = arg_utils.args_to_notes_dict(kwargs[options.OPTION_NOTES.keyword], include_none=True)
        name = repo_id
        if options.OPTION_NAME.keyword in kwargs:
            name = kwargs[options.OPTION_NAME.keyword]

        # Add a note to indicate this is a Puppet repository
        notes[constants.REPO_NOTE_KEY] = constants.REPO_NOTE_PUPPET

        # -- importer metadata --
        importer_config = {
            constants.CONFIG_FEED : kwargs[OPTION_FEED.keyword],
            constants.CONFIG_QUERIES : kwargs[OPTION_QUERY.keyword],
        }
        arg_utils.convert_removed_options(importer_config)

        # -- distributor metadata --
        distributor_config = {
            constants.CONFIG_SERVE_HTTP : kwargs[OPTION_HTTP.keyword],
            constants.CONFIG_SERVE_HTTPS : kwargs[OPTION_HTTPS.keyword],
        }
        arg_utils.convert_removed_options(distributor_config)
        arg_utils.convert_boolean_arguments((constants.CONFIG_SERVE_HTTP, constants.CONFIG_SERVE_HTTPS), distributor_config)

        distributors = [(constants.DISTRIBUTOR_TYPE_ID, distributor_config, True, constants.DISTRIBUTOR_ID)]

        # Create the repository
        self.context.server.repo.create_and_configure(repo_id, name, description,
            notes, constants.IMPORTER_TYPE_ID, importer_config, distributors)

        msg = _('Successfully created repository [%(r)s]')
        self.context.prompt.render_success_message(msg % {'r' : repo_id})

    def update(self, **kwargs):

        # Gather data
        repo_id = kwargs.pop('repo-id')
        description = kwargs.pop('description', None)
        display_name = kwargs.pop('display-name', None)
        auto_publish = kwargs.pop('auto-publish', None)

        if auto_publish:
            auto_publish = arg_to_bool(auto_publish)
            if auto_publish is None:
                self.context.prompt.render_failure_message(_('Value for auto-publish must be either true or false'))
                return

        try:
            notes = None
            if 'note' in kwargs and kwargs['note'] is not None:
                notes = args_to_notes_dict(kwargs['note'], include_none=True)

            importer_config = args_to_importer_config(kwargs)
        except InvalidConfig, e:
            self.context.prompt.render_failure_message(e[0])
            return

    def run(self, **kwargs):
        consumer_id = self.get_consumer_id(kwargs)
        delta = dict((k, v) for k, v in kwargs.items() if v is not None)

        if OPTION_NOTES.keyword in delta:
            notes_args = delta.pop(OPTION_NOTES.keyword)
            delta["notes"] = args_to_notes_dict(notes_args)

        if OPTION_NAME.keyword in delta:
            name = delta.pop(OPTION_NAME.keyword)
            delta[OPTION_NAME.keyword.replace("-", "_")] = name

        try:
            self.context.server.consumer.update(consumer_id, delta)

        except NotFoundException:
            msg = _("Consumer [ %(c)s ] does not exist on server") % {"c": consumer_id}
            self.context.prompt.render_failure_message(msg)
            return os.EX_DATAERR

        else:
            msg = _("Consumer [ %(c)s ] successfully updated") % {"c": consumer_id}
            self.context.prompt.render_success_message(msg)

    def _parse_basic_options(self, kwargs):
        """
        Parse the options known by this class

        :param kwargs:  user input as provided by okaara
        :type  kwargs:  dict

        :return:    tuple of repo_id, name, description, notes
        :rtype:     tuple
        """

        # Collect input
        repo_id = kwargs[OPTION_REPO_ID.keyword]
        name = repo_id
        if OPTION_NAME.keyword in kwargs:
            name = kwargs[OPTION_NAME.keyword]
        description = kwargs[OPTION_DESCRIPTION.keyword]
        if kwargs[OPTION_NOTES.keyword]:
            notes = arg_utils.args_to_notes_dict(kwargs[OPTION_NOTES.keyword], include_none=True)
        else:
            notes = {}
        notes.update(self.default_notes)

        return repo_id, name, description, notes