def all(self, cond):
"""
Checks if a condition is met by any element in a list,
where a condition can also be a sequence (e.g. list).
>>> Query('f1').all(Query('f2') == 1)
Matches::
{'f1': [{'f2': 1}, {'f2': 1}]}
>>> Query('f1').all([1, 2, 3])
# Match f1 that contains any element from [1, 2, 3]
Matches::
{'f1': [1, 2, 3, 4, 5]}
:param cond: Either a query that all elements have to match or a list
which has to be contained in the tested element.
"""
if callable(cond):
def _cmp(value):
return is_sequence(value) and all(cond(e) for e in value)
else:
def _cmp(value):
return is_sequence(value) and all(e in value for e in cond)
return self._generate_test(lambda value: _cmp(value),
('all', tuple(self._path), freeze(cond)))
def __eq__(self, rhs):
"""
Test a dict value for equality.
>>> Query('f1') == 42
:param rhs: The value to compare against
"""
if sys.version_info <= (3, 0): # pragma: no cover
# Special UTF-8 handling on Python 2
def test(value):
with catch_warning(UnicodeWarning):
try:
return value == rhs
except UnicodeWarning:
# Dealing with a case, where 'value' or 'rhs'
# is unicode and the other is a byte string.
if isinstance(value, str):
return value.decode('utf-8') == rhs
elif isinstance(rhs, str):
return value == rhs.decode('utf-8')
else: # pragma: no cover
def test(value):
return value == rhs
return self._generate_test(lambda value: test(value),
('==', tuple(self._path), freeze(rhs)))
def all(self, cond):
"""
Checks if a condition is met by any element in a list,
where a condition can also be a sequence (e.g. list).
>>> Query().f1.all(Query().f2 == 1)
Matches::
{'f1': [{'f2': 1}, {'f2': 1}]}
>>> Query().f1.all([1, 2, 3])
# Match f1 that contains any element from [1, 2, 3]
Matches::
{'f1': [1, 2, 3, 4, 5]}
:param cond: Either a query that all elements have to match or a list
which has to be contained in the tested element.
"""
if callable(cond):
def _cmp(value):
return is_sequence(value) and all(cond(e) for e in value)
else:
def _cmp(value):
return is_sequence(value) and all(e in value for e in cond)
return self._generate_test(lambda value: _cmp(value),
('all', tuple(self._path), freeze(cond)))
def __eq__(self, rhs):
"""
Test a dict value for equality.
>>> Query().f1 == 42
:param rhs: The value to compare against
"""
if sys.version_info <= (3, 0): # pragma: no cover
# Special UTF-8 handling on Python 2
def test(value):
with catch_warning(UnicodeWarning):
try:
return value == rhs
except UnicodeWarning:
# Dealing with a case, where 'value' or 'rhs'
# is unicode and the other is a byte string.
if isinstance(value, str):
return value.decode('utf-8') == rhs
elif isinstance(rhs, str):
return value == rhs.decode('utf-8')
else: # pragma: no cover
def test(value):
return value == rhs
return self._generate_test(lambda value: test(value),
('==', tuple(self._path), freeze(rhs)))
def any(self, cond):
"""
Checks if a condition is met by any element in a list,
where a condition can also be a sequence (e.g. list).
>>> Query('f1').any(Query('f2') == 1)
Matches::
{'f1': [{'f2': 1}, {'f2': 0}]}
>>> Query('f1').any([1, 2, 3])
# Match f1 that contains any element from [1, 2, 3]
Matches::
{'f1': [1, 2]}
{'f1': [3, 4, 5]}
:param cond: Either a query that at least one element has to match or
a list of which at least one element has to be contained
in the tested element.
- """
if callable(cond):
def _cmp(value):
return is_sequence(value) and any(cond(e) for e in value)
else:
def _cmp(value):
return is_sequence(value) and any(e in cond for e in value)
return self._generate_test(lambda value: _cmp(value),
('any', tuple(self._path), freeze(cond)))
def __ne__(self, rhs):
"""
Test a dict value for inequality.
>>> Query('f1') != 42
:param rhs: The value to compare against
"""
return self._generate_test(lambda value: value != rhs,
('!=', tuple(self._path), freeze(rhs)))
def __ne__(self, rhs):
"""
Test a dict value for inequality.
>>> Query().f1 != 42
:param rhs: The value to compare against
"""
return self._generate_test(lambda value: value != rhs,
('!=', tuple(self._path), freeze(rhs)))
def all(self, cond):
if callable(cond):
def _cmp(value):
return is_sequence(value) and all(cond(e) for e in value)
else:
def _cmp(value):
return is_sequence(value) and all(e in value for e in cond)
return self._generate_test(lambda value: _cmp(value),
('all', tuple(self.path), freeze(cond)))
def test_freeze():
frozen = freeze([0, 1, 2, {'a': [1, 2, 3]}])
assert isinstance(frozen, tuple)
assert isinstance(frozen[3], FrozenDict)
assert isinstance(frozen[3]['a'], tuple)
with pytest.raises(TypeError):
frozen[0] = 10
with pytest.raises(TypeError):
frozen[3]['a'] = 10
def test_freeze():
frozen = freeze([0, 1, 2, {'a': [1, 2, 3]}, {1, 2}])
assert isinstance(frozen, tuple)
assert isinstance(frozen[3], FrozenDict)
assert isinstance(frozen[3]['a'], tuple)
assert isinstance(frozen[4], frozenset)
with pytest.raises(TypeError):
frozen[0] = 10
with pytest.raises(TypeError):
frozen[3]['a'] = 10
with pytest.raises(TypeError):
frozen[3].pop('a')
with pytest.raises(TypeError):
frozen[3].update({'a': 9})
def __ne__(self, rhs):
return self._generate_test(lambda value: value != rhs,
('!=', tuple(self.path), freeze(rhs)))
