def test_process_bools(self): test_dict = dictset( complete__bool='false', other_arg=5, ) result_dict = docs.process_bools(test_dict) assert result_dict == dictset(complete=False, other_arg=5)
def test_filter_fields(self, mock_fields): mock_fields.return_value = ('description', 'id', 'complete') params = docs.BaseMixin.filter_fields(dictset( description='nice', name='regular name', id__in__here=[1, 2, 3], )) assert params == dictset( description='nice', id__in__here=[1, 2, 3], )
def test_filter_fields(self): class MyModel(docs.BaseDocument): name = fields.StringField() params = MyModel.filter_fields(dictset( description='nice', name='regular name', id__in__here=[1, 2, 3], )) assert params == dictset( name='regular name', id__in__here=[1, 2, 3], )
def test_filter_fields(self, mock_fields): mock_fields.return_value = ('description', 'id', 'complete') params = docs.BaseMixin.filter_fields( dictset( description='nice', name='regular name', id__in__here=[1, 2, 3], )) assert params == dictset( description='nice', id__in__here=[1, 2, 3], )
def test_process_lists(self): test_dict = dictset( id__in='1, 2, 3', name__all='foo', other__arg='4', yet_other_arg=5, ) result_dict = docs.process_lists(test_dict) expected = dictset( id__in=['1', '2', '3'], name__all=['foo'], other__arg='4', yet_other_arg=5, ) assert result_dict == expected
def test_asdict(self): dset = dictset({'foo': "a:2,b:blabla,c:True,a:'d',a:1"}) assert dset.asdict('foo') == { 'a': ['2', "'d'", '1'], 'b': 'blabla', 'c': 'True' }
def test_process_bool_param(self): dset = dictset({'boo': 'true', 'foo': 'false'}) assert dset.process_bool_param('boo') assert not dset.process_bool_param('foo') assert dset.boo assert not dset.foo assert isinstance(dset.boo, bool) assert isinstance(dset.foo, bool)
def test_pop_by_values(self): dset = dictset({'boo': '1', 'foo': '2'}) dset.pop_by_values('3') assert dict(dset) == {'boo': '1', 'foo': '2'} dset.pop_by_values('1') assert dict(dset) == {'foo': '2'} dset.pop_by_values('2') assert dict(dset) == {}
def test_asbool(self): dset1 = dictset({ 'foo': 'true', 'fruit': 'false', 'baz': True, 'zoo': False}) assert dset1.asbool('foo') assert dset1.asbool('baz') assert isinstance(dset1.asbool('foo'), bool) assert isinstance(dset1.asbool('baz'), bool) assert not dset1.asbool('fruit') assert not dset1.asbool('zoo')
def to_dict(self, **kwargs): _dict = dictset() _keys = kwargs.pop('_keys', []) _depth = kwargs.pop('_depth', 1) data = dictset(self._data).subset(_keys) if _keys else self._data for attr, val in data.items(): _dict[attr] = val if _depth: kw = kwargs.copy() kw['_depth'] = _depth - 1 if hasattr(val, 'to_dict'): _dict[attr] = val.to_dict(**kw) elif isinstance(val, list): _dict[attr] = to_dicts(val, **kw) _dict['_type'] = self.__class__.__name__ return _dict
def test_reserved_params_dropped(self, mock_check, mock_drop, simple_model, memory_db): from nefertari.utils import dictset memory_db() mock_drop.side_effect = lambda x: dictset({'name': 'a'}) try: simple_model.get_collection(_limit=1, _strict=True) except JHTTPBadRequest: raise Exception('Unexpected JHTTPBadRequest exception') mock_drop.assert_called_once_with({}) mock_check.assert_called_once_with(['name'])
def test_reserved_params_dropped( self, mock_check, mock_drop, simple_model, memory_db): from nefertari.utils import dictset memory_db() mock_drop.side_effect = lambda x: dictset({'name': 'a'}) try: simple_model.get_collection(_limit=1, __strict=True) except JHTTPBadRequest: raise Exception('Unexpected JHTTPBadRequest exception') mock_drop.assert_called_once_with({}) mock_check.assert_called_once_with(['name'])
def test_process_datetime_param(self): dset = dictset({'boo': '2014-01-02T03:04:05Z'}) dtime = dset.process_datetime_param('boo') assert dtime is dset.boo assert dtime == dset.boo assert isinstance(dtime, datetime) assert dtime.year == 2014 assert dtime.month == 1 assert dtime.day == 2 assert dtime.hour == 3 assert dtime.minute == 4 assert dtime.second == 5
def test_asbool(self): dset1 = dictset({ 'foo': 'true', 'fruit': 'false', 'baz': True, 'zoo': False }) assert dset1.asbool('foo') assert dset1.asbool('baz') assert isinstance(dset1.asbool('foo'), bool) assert isinstance(dset1.asbool('baz'), bool) assert not dset1.asbool('fruit') assert not dset1.asbool('zoo')
def obj2dict(obj, classkey=None): if isinstance(obj, dict): for k in obj.keys(): obj[k] = obj2dict(obj[k], classkey) return obj elif hasattr(obj, "__iter__"): return [obj2dict(v, classkey) for v in obj] elif hasattr(obj, "__dict__"): data = dictset([(key, obj2dict(value, classkey)) for key, value in obj.__dict__.iteritems() if not callable(value) and not key.startswith('_')]) if classkey is not None and hasattr(obj, "__class__"): data[classkey] = obj.__class__.__name__ return data else: return obj
def obj2dict(obj, classkey=None): if isinstance(obj, dict): for k in obj.keys(): obj[k] = obj2dict(obj[k], classkey) return obj elif issequence(obj): return [obj2dict(v, classkey) for v in obj] elif hasattr(obj, "__dict__"): data = dictset([ (key, obj2dict(value, classkey)) for key, value in obj.__dict__.items() if not six.callable(value) and not key.startswith('_') ]) if classkey is not None and hasattr(obj, "__class__"): data[classkey] = obj.__class__.__name__ return data else: return obj
def test_process_dict_param_pop(self): dset = dictset({'boo': 'a:1'}) assert dset.process_dict_param('boo', pop=True) == {'a': '1'} assert 'boo' not in dset
def test_getattr(self): dset1 = dictset({'foo': 'bar', 'fruit': 'apple'}) assert dset1.foo == 'bar' assert dset1.fruit == 'apple'
def test_asint_set(self): dset = dictset({'foo': '1'}) assert dset.asint('foo', _set=True) == 1 assert dset.foo == 1
def test_aslist_default(self): dset1 = dictset({'foo': '1,2,3'}) assert dset1.aslist('foo1', default=['1']) == ['1'] assert 'foo1' not in dset1
def test_aslist_set(self): dset1 = dictset({'foo': '1,2,3'}) assert dset1.aslist('foo', _set=True) == ['1', '2', '3'] assert dset1.foo == ['1', '2', '3']
def test_asbool_default(self): dset1 = dictset({'foo': 'true'}) assert dset1.asbool('foo1', default=True) assert 'foo1' not in dset1
def __init__(self, data={}): self._data = dictset(data)
def test_asint_default(self): dset = dictset({'foo': '1'}) assert dset.asint('foo1', default=2) == 2 assert 'foo1' not in dset
def test_asbool_set(self): dset1 = dictset({'foo': 'true'}) assert dset1.asbool('foo', _set=True) assert dset1.foo assert dset1.foo != 'true'
def test_asbool_pop(self): dset1 = dictset({'foo': 'true'}) assert dset1.asbool('foo', pop=True) assert 'foo' not in dset1
def test_aslist(self): dset1 = dictset({'foo': '1,2, 3'}) assert dset1.aslist('foo') == ['1', '2', '3']
def test_copy(self): dset1 = dictset({'foo': 'bar'}) dset2 = dset1.copy() assert dset1 is not dset2 assert dset1 == dset2
def test_process_dict_param(self): dset = dictset({'boo': 'a:1'}) assert dset.process_dict_param('boo') == {'a': '1'} assert dset.boo == {'a': '1'}
def test_process_int_param_default(self): dset = dictset({'boo': '1'}) assert dset.process_int_param('foo', default=2) == 2 assert dset.foo == 2
def test_process_dict_param_type(self): dset = dictset({'boo': 'a:1'}) assert dset.process_dict_param('boo', _type=lambda x: int(x)) == { 'a': 1 } assert dset.boo == {'a': 1}
def test_setattr(self): dset1 = dictset() dset1.boo = 1 assert dict(dset1) == {'boo': 1}
def test_asint(self): assert dictset({'foo': '1'}).asint('foo') == 1
def test_remove(self): dset1 = dictset({'foo': 'bar', 'fruit': 'apple'}) dset2 = dset1.remove(['fruit']) assert dict(dset2) == {'foo': 'bar'}
def test_process_dict_param_type(self): dset = dictset({'boo': 'a:1'}) assert dset.process_dict_param('boo', _type=lambda x: int(x)) == { 'a': 1} assert dset.boo == {'a': 1}
def test_asfloat(self): assert dictset({'foo': '1.0'}).asfloat('foo') == 1.0