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'