def setup_columns(self, info, parsed_args):
        _columns = len(info) > 0 and sorted(info[0].keys()) or []
        if not _columns:
            # clean the parsed_args.columns so that cliff will not break
            parsed_args.columns = []
        elif parsed_args.columns:
            _columns = [x for x in parsed_args.columns if x in _columns]
        elif self.list_columns:
            # if no -c(s) by user and list_columns, we use columns in
            # both list_columns and returned resource.
            # Also Keep their order the same as in list_columns
            _columns = self._setup_columns_with_tenant_id(self.list_columns,
                                                          _columns)

        if parsed_args.formatter == 'table':
            formatters = self._formatters
        elif (parsed_args.formatter == 'csv'
              and hasattr(self, '_formatters_csv')):
            formatters = self._formatters_csv
        else:
            # For other formatters, we use raw value returned from neutron
            formatters = {}

        return (_columns, (utils.get_item_properties(
            s, _columns, formatters=formatters, )
            for s in info), )

 def take_action(self, parsed_args):
     debug_agent = self.get_debug_agent()
     info = debug_agent.list_probes()
     columns = sorted(info[0].keys()) if info else []
     return (columns, (utils.get_item_properties(
         s, columns, formatters=self._formatters, )
         for s in info), )

    def get_data(self, parsed_args):

        debug_agent = self.get_debug_agent()
        info = debug_agent.list_probes()
        columns = len(info) > 0 and sorted(info[0].keys()) or []
        return (columns, (utils.get_item_properties(
            s, columns, formatters=self._formatters, )
            for s in info), )

    def test_get_object_item_desired_fields_is_empty(self):
        class Fake(object):
            def __init__(self):
                self.id = 'test_id_1'
                self.name = 'test_name'
                self.test_user = 'test'

        fields = []
        item = Fake()
        actual = utils.get_item_properties(item, fields)
        self.assertEqual((), actual)

    def test_get_object_item_desired_fields_differ_from_item(self):
        class Fake(object):
            def __init__(self):
                self.id = 'test_id_1'
                self.name = 'test_name'
                self.test_user = 'test'

        fields = ('name', 'id', 'test user')
        item = Fake()
        actual = utils.get_item_properties(item, fields)
        self.assertNotEqual(('test_name', 'test_id', 'test'), actual)

    def test_get_object_item_properties_mixed_case_fields(self):
        class Fake(object):
            def __init__(self):
                self.id = 'test_id'
                self.name = 'test_name'
                self.test_user = 'test'

        fields = ('name', 'id', 'test user')
        mixed_fields = ('test user', 'ID')
        item = Fake()
        actual = utils.get_item_properties(item, fields, mixed_fields)
        self.assertEqual(('test_name', 'test_id', 'test'), actual)

 def take_action(self, parsed_args):
     self.log.debug("run(%s)", parsed_args)
     neutron_client = self.get_client()
     search_opts = {}
     self.log.debug("search options: %s", search_opts)
     obj_lister = getattr(neutron_client, "list_%ss" % self.resource)
     data = obj_lister(**search_opts)
     info = []
     collection = self.resource + "s"
     if collection in data:
         info = data[collection]
     _columns = len(info) > 0 and sorted(info[0].keys()) or []
     return (_columns, (utils.get_item_properties(s, _columns) for s in info))

 def setup_columns(self, info, parsed_args):
     _columns = len(info) > 0 and sorted(info[0].keys()) or []
     if not _columns:
         # clean the parsed_args.columns so that cliff will not break
         parsed_args.columns = []
     elif parsed_args.columns:
         _columns = [x for x in parsed_args.columns if x in _columns]
     elif self.list_columns:
         # if no -c(s) by user and list_columns, we use columns in
         # both list_columns and returned resource.
         # Also Keep their order the same as in list_columns
         _columns = [x for x in self.list_columns if x in _columns]
     return (_columns, (utils.get_item_properties(s, _columns, formatters=self._formatters) for s in info))

    def test_get_object_item_with_formatters(self):
        class Fake(object):
            def __init__(self):
                self.id = 'test_id'
                self.name = 'test_name'
                self.test_user = 'test'

        class FakeCallable(object):
            def __call__(self, *args, **kwargs):
                return 'pass'

        fields = ('name', 'id', 'test user', 'is_public')
        formatters = {'is_public': FakeCallable()}
        item = Fake()
        act = utils.get_item_properties(item, fields, formatters=formatters)
        self.assertEqual(('test_name', 'test_id', 'test', 'pass'), act)

 def test_get_dict_item_properties(self):
     item = {'name': 'test_name', 'id': 'test_id'}
     fields = ('name', 'id')
     actual = utils.get_item_properties(item=item, fields=fields)
     self.assertEqual(('test_name', 'test_id'), actual)