def test_no_lookup_same_source_and_dest(self):
filter = Filter('field', lookups=[None])
expected = [
('field', 'field'),
]
actual = list(filter.source_dest_pairs())
assert expected == actual
def test_no_lookup_differing_source_and_dest(self):
filter = Filter(source='something', dest='field', lookups=[None])
expected = [
('something', 'field'),
]
actual = list(filter.source_dest_pairs())
assert expected == actual
def test_parse_simple_source(self):
filter = Filter('word')
data = {'word': 'a_value', 'unrelated_key': ''}
filter.parse(data)
assert not filter.errors
assert 'word' in filter._filters
assert filter._filters['word'] == 'a_value'
def test_other_lookups_ignored_when_default_used(self):
filters = Filter('count', lookups=['lte', 'gte'], default=3)
filters.parse({}) # no value for 'count'
keys = dict(flatten_qobj(filters.Q)).keys()
assert 'lte' not in keys
assert 'gte' not in keys
def test_kwarg_instantiation(self):
f = Filter(dest='fieldname')
assert f.source == 'fieldname'
assert f.dest == 'fieldname'
f = Filter(source='sourcename', dest='fieldname')
assert f.source == 'sourcename'
assert f.dest == 'fieldname'
def test_default_value_used_if_no_sourcedata_found(self):
filters = Filter('count', lookups=['lte', 'gte'], default=3)
filters.parse({}) # no value for 'count'
expected = {'count__exact': 3}
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_many_sources_one_dest(self):
filters = (Filter(source='nominee_1', dest='field')
| Filter(source='nominee_2', dest='field')
| Filter(source='nominee_3', dest='field'))
filters.parse(dict(nominee_1='one', nominee_2='two',
nominee_3='three'))
expected = dict(field='three') # last one wins
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_one_source_to_many_dests(self):
filters = (Filter(source='search', dest='username')
| Filter(source='search', dest='email')
| Filter(source='search', dest='name'))
filters.parse(dict(search='mynbaev-scheiner'))
expected = dict(username='******',
email='mynbaev-scheiner',
name='mynbaev-scheiner')
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_multivaluedict_as_source_when_many_values_required(self):
"""
Having a dest ending in '__in' /does/ constitute explicit instruction
to pull multiple values from a source.
"""
filters = Filter('field', lookups=['in'])
data = MultiValueDict(dict(field=['foo', 'bar']))
filters.parse(data)
expected = dict(field__in=['foo', 'bar'])
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_multivaluedict_as_source(self):
"""
We don't expect multiple values to be pulled from a multi-value source
without explicit instruction
"""
filters = Filter('name')
data = MultiValueDict(dict(name=['foo', 'bar']))
filters.parse(data)
expected = dict(name='bar') # last one wins
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_default_lookup_type_can_be_changed(self):
filters = Filter('count',
lookups=['lte', 'gte'],
default=3,
default_lookup='gt')
filters.parse({}) # no value for 'count'
expected = {'count__gt': 3}
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_required_filter_requires_at_least_one_key(self):
"""
One filter can have many possible sources due to the different lookup
affixes. One of them being present should be enough to satisfy a
'required' field.
"""
f = Filter('fieldname', required=True, lookups=['contains'])
data = {'fieldname__gte': 'foo', 'fieldname__lte': 'bar'}
f.parse(data)
assert f.errors
assert 'fieldname' in f.errors
def test_default_ignored_if_sourcedata_found(self):
filters = Filter('count',
lookups=['lte', 'gte'],
default=3,
default_lookup='foobarbaz')
filters.parse({'count__gte': 4})
expected = {'count__gte': 4}
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_parse_source_with_lookups(self):
filter = Filter('word', lookups=['gte', 'gt', 'lte', 'lt'])
data = {'word__gte': 1, 'word__gt': 2, 'word__lte': 3, 'word__lt': 4}
filter.parse(data)
assert not filter.errors
for key in data:
assert key in filter._filters
for key, value in data.items():
assert filter._filters[key] == value
assert filter.valid
def test_negating_filters(self):
f = Filter('fieldname')
assert f.negate is False
f = ~f
assert f.negate is True
f = ~f
assert f.negate is False
def test_validity_from_filtertree(self):
"""
FilterTree's validity should be a proxy to the validities of the
filters it contains.
"""
filters = Filter('one') | Filter('two') | Filter('three')
filters.parse(dict())
assert filters.valid
def test_more_extensive_parsing(self):
filters = (Filter('field_1', lookups=['contains', 'icontains'])
| Filter(source='field_2', dest='field_2a')
| Filter(source='field_3', dest='f3', lookups=['lt', 'gt'])
| Filter(source='id', dest='relationship__spanning__id'))
data = {
'field_1__contains': 'first',
'field_2': 'second',
'field_3__lt': 'third',
'field_3__gt': 'fourth',
'id': 'fifth'
}
expected = {
'field_1__contains': 'first',
'field_2a': 'second',
'f3__lt': 'third',
'f3__gt': 'fourth',
'relationship__spanning__id': 'fifth'
}
filters.parse(data)
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
assert filters.valid
def test_multivaluedict_not_used_for_nonlisty_filtering(self):
filters = Filter('field', lookups=['exact', 'in'])
data = MultiValueDict(dict(field=['foo', 'bar']))
filters.parse(data)
expected = dict(field='bar') # last one wins
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
data = MultiValueDict(dict(field__in=['foo', 'bar']))
filters.parse(data)
expected = dict(field__in=['foo', 'bar'])
actual = dict(flatten_qobj(filters.Q))
assert expected == actual
def test_lookups_can_be_provided_as_a_comma_separated_string(self):
f = Filter('fieldname', lookups='lt,lte,gt,gte')
assert f.lookups == ['lt', 'lte', 'gt', 'gte']
def test_lookups_can_be_provided_as_a_string(self):
f = Filter('fieldname', lookups='contains')
assert f.lookups == ['contains']
def test_required_filter_is_satisfied_by_one_key_being_present(self):
f = Filter('fieldname', required=True, lookups=['gte'])
data = {'fieldname__gte': 'foo', 'fieldname__lte': 'bar'}
f.parse(data)
assert not f.errors
def test_getsourcevalue_raises_keyerrors(self):
f = Filter('fieldname')
with self.assertRaises(KeyError):
f.get_source_value('legume', {'foo': 'bar'})
def test_lte_lookup_differing_source_and_dest(self):
filter = Filter(source='something', dest='field', lookups=['lte'])
expected = [('something__lte', 'field__lte'),
('something', 'field__lte')]
actual = list(filter.source_dest_pairs())
assert sorted(expected) == sorted(actual)
def test_default_lookup_is_exact(self):
f = Filter('count', default=3)
assert f.default_lookup == 'exact'
def test_getsourcevalue_does_what_it_says_on_the_tin(self):
f = Filter('fieldname')
bar = f.get_source_value('foo', {'foo': 'bar'})
assert bar == 'bar'
def test_gte_lookup_same_source_and_dest(self):
filter = Filter('field', lookups=['gte'])
expected = [('field__gte', 'field__gte'), ('field', 'field__gte')]
actual = list(filter.source_dest_pairs())
assert sorted(expected) == sorted(actual)
def setUp(self):
self.filters = Optional(Filter('one', required=True), Filter('two'),
Filter('three', required=True))
self.unrelated = Filter('ten') & (Filter('eleven') | Filter('twelve'))
def test_filters_AND_into_filtersets(self):
filters = Filter('afield') & Filter('anotherfield')
assert isinstance(filters, FilterTree)
def test_kwargless_simple_instantiation(self):
f = Filter('fieldname')
assert f.source == 'fieldname'
assert f.dest == 'fieldname'
