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_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_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_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_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_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 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_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_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_asfloat(self):
     assert dictset({'foo': '1.0'}).asfloat('foo') == 1.0

 def test_asint_default(self):
     dset = dictset({'foo': '1'})
     assert dset.asint('foo1', default=2) == 2
     assert 'foo1' not in dset

 def test_setattr(self):
     dset1 = dictset()
     dset1.boo = 1
     assert dict(dset1) == {'boo': 1}

 def test_copy(self):
     dset1 = dictset({'foo': 'bar'})
     dset2 = dset1.copy()
     assert dset1 is not dset2
     assert dset1 == dset2

 def test_asbool_default(self):
     dset1 = dictset({'foo': 'true'})
     assert dset1.asbool('foo1', default=True)
     assert 'foo1' not in dset1

 def test_aslist(self):
     dset1 = dictset({'foo': '1,2, 3'})
     assert dset1.aslist('foo') == ['1', '2', '3']

 def test_asbool_pop(self):
     dset1 = dictset({'foo': 'true'})
     assert dset1.asbool('foo', pop=True)
     assert 'foo' not in dset1