fix: format all code with black
and from now on should not deviate from that...
This commit is contained in:
parent
8a09fb1a3c
commit
4d0693862d
68 changed files with 6693 additions and 5659 deletions
File diff suppressed because it is too large
Load diff
|
|
@ -21,24 +21,24 @@ class TestGridFilter(WebTestCase):
|
|||
|
||||
model = self.app.model
|
||||
self.sample_data = [
|
||||
{'name': 'foo1', 'value': 'ONE'},
|
||||
{'name': 'foo2', 'value': 'two'},
|
||||
{'name': 'foo3', 'value': 'ggg'},
|
||||
{'name': 'foo4', 'value': 'ggg'},
|
||||
{'name': 'foo5', 'value': 'ggg'},
|
||||
{'name': 'foo6', 'value': 'six'},
|
||||
{'name': 'foo7', 'value': 'seven'},
|
||||
{'name': 'foo8', 'value': 'eight'},
|
||||
{'name': 'foo9', 'value': 'nine'},
|
||||
{"name": "foo1", "value": "ONE"},
|
||||
{"name": "foo2", "value": "two"},
|
||||
{"name": "foo3", "value": "ggg"},
|
||||
{"name": "foo4", "value": "ggg"},
|
||||
{"name": "foo5", "value": "ggg"},
|
||||
{"name": "foo6", "value": "six"},
|
||||
{"name": "foo7", "value": "seven"},
|
||||
{"name": "foo8", "value": "eight"},
|
||||
{"name": "foo9", "value": "nine"},
|
||||
]
|
||||
for setting in self.sample_data:
|
||||
self.app.save_setting(self.session, setting['name'], setting['value'])
|
||||
self.app.save_setting(self.session, setting["name"], setting["value"])
|
||||
self.session.commit()
|
||||
self.sample_query = self.session.query(model.Setting)
|
||||
|
||||
def make_filter(self, model_property, **kwargs):
|
||||
factory = kwargs.pop('factory', mod.GridFilter)
|
||||
kwargs['model_property'] = model_property
|
||||
factory = kwargs.pop("factory", mod.GridFilter)
|
||||
kwargs["model_property"] = model_property
|
||||
return factory(self.request, model_property.key, **kwargs)
|
||||
|
||||
def test_constructor(self):
|
||||
|
|
@ -46,158 +46,193 @@ class TestGridFilter(WebTestCase):
|
|||
|
||||
# verbs is not set by default, but can be set
|
||||
filtr = self.make_filter(model.Setting.name)
|
||||
self.assertFalse(hasattr(filtr, 'verbs'))
|
||||
filtr = self.make_filter(model.Setting.name, verbs=['foo', 'bar'])
|
||||
self.assertEqual(filtr.verbs, ['foo', 'bar'])
|
||||
self.assertFalse(hasattr(filtr, "verbs"))
|
||||
filtr = self.make_filter(model.Setting.name, verbs=["foo", "bar"])
|
||||
self.assertEqual(filtr.verbs, ["foo", "bar"])
|
||||
|
||||
# verb is not set by default, but can be set
|
||||
filtr = self.make_filter(model.Setting.name)
|
||||
self.assertFalse(hasattr(filtr, 'verb'))
|
||||
filtr = self.make_filter(model.Setting.name, verb='foo')
|
||||
self.assertEqual(filtr.verb, 'foo')
|
||||
self.assertFalse(hasattr(filtr, "verb"))
|
||||
filtr = self.make_filter(model.Setting.name, verb="foo")
|
||||
self.assertEqual(filtr.verb, "foo")
|
||||
|
||||
# default verb is not set by default, but can be set
|
||||
filtr = self.make_filter(model.Setting.name)
|
||||
self.assertFalse(hasattr(filtr, 'default_verb'))
|
||||
filtr = self.make_filter(model.Setting.name, default_verb='foo')
|
||||
self.assertEqual(filtr.default_verb, 'foo')
|
||||
self.assertFalse(hasattr(filtr, "default_verb"))
|
||||
filtr = self.make_filter(model.Setting.name, default_verb="foo")
|
||||
self.assertEqual(filtr.default_verb, "foo")
|
||||
|
||||
def test_repr(self):
|
||||
model = self.app.model
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.GridFilter)
|
||||
self.assertEqual(repr(filtr), "GridFilter(key='name', active=False, verb=None, value=None)")
|
||||
self.assertEqual(
|
||||
repr(filtr), "GridFilter(key='name', active=False, verb=None, value=None)"
|
||||
)
|
||||
|
||||
def test_get_verbs(self):
|
||||
model = self.app.model
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.AlchemyFilter)
|
||||
self.assertFalse(hasattr(filtr, 'verbs'))
|
||||
self.assertEqual(filtr.default_verbs, ['equal', 'not_equal'])
|
||||
self.assertFalse(hasattr(filtr, "verbs"))
|
||||
self.assertEqual(filtr.default_verbs, ["equal", "not_equal"])
|
||||
|
||||
# by default, returns default verbs (plus 'is_any')
|
||||
self.assertEqual(filtr.get_verbs(), ['equal', 'not_equal', 'is_any'])
|
||||
self.assertEqual(filtr.get_verbs(), ["equal", "not_equal", "is_any"])
|
||||
|
||||
# default verbs can be a callable
|
||||
filtr.default_verbs = lambda: ['foo', 'bar']
|
||||
self.assertEqual(filtr.get_verbs(), ['foo', 'bar', 'is_any'])
|
||||
filtr.default_verbs = lambda: ["foo", "bar"]
|
||||
self.assertEqual(filtr.get_verbs(), ["foo", "bar", "is_any"])
|
||||
|
||||
# uses filtr.verbs if set
|
||||
filtr.verbs = ['is_true', 'is_false']
|
||||
self.assertEqual(filtr.get_verbs(), ['is_true', 'is_false', 'is_any'])
|
||||
filtr.verbs = ["is_true", "is_false"]
|
||||
self.assertEqual(filtr.get_verbs(), ["is_true", "is_false", "is_any"])
|
||||
|
||||
# may add is/null verbs
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.AlchemyFilter,
|
||||
nullable=True)
|
||||
self.assertEqual(filtr.get_verbs(), ['equal', 'not_equal',
|
||||
'is_null', 'is_not_null',
|
||||
'is_any'])
|
||||
filtr = self.make_filter(
|
||||
model.Setting.name, factory=mod.AlchemyFilter, nullable=True
|
||||
)
|
||||
self.assertEqual(
|
||||
filtr.get_verbs(),
|
||||
["equal", "not_equal", "is_null", "is_not_null", "is_any"],
|
||||
)
|
||||
|
||||
# filtr.verbs can be a callable
|
||||
filtr.nullable = False
|
||||
filtr.verbs = lambda: ['baz', 'blarg']
|
||||
self.assertEqual(filtr.get_verbs(), ['baz', 'blarg', 'is_any'])
|
||||
filtr.verbs = lambda: ["baz", "blarg"]
|
||||
self.assertEqual(filtr.get_verbs(), ["baz", "blarg", "is_any"])
|
||||
|
||||
def test_get_default_verb(self):
|
||||
model = self.app.model
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.AlchemyFilter)
|
||||
self.assertFalse(hasattr(filtr, 'verbs'))
|
||||
self.assertEqual(filtr.default_verbs, ['equal', 'not_equal'])
|
||||
self.assertEqual(filtr.get_verbs(), ['equal', 'not_equal', 'is_any'])
|
||||
self.assertFalse(hasattr(filtr, "verbs"))
|
||||
self.assertEqual(filtr.default_verbs, ["equal", "not_equal"])
|
||||
self.assertEqual(filtr.get_verbs(), ["equal", "not_equal", "is_any"])
|
||||
|
||||
# returns first verb by default
|
||||
self.assertEqual(filtr.get_default_verb(), 'equal')
|
||||
self.assertEqual(filtr.get_default_verb(), "equal")
|
||||
|
||||
# returns filtr.verb if set
|
||||
filtr.verb = 'foo'
|
||||
self.assertEqual(filtr.get_default_verb(), 'foo')
|
||||
filtr.verb = "foo"
|
||||
self.assertEqual(filtr.get_default_verb(), "foo")
|
||||
|
||||
# returns filtr.default_verb if set
|
||||
# (nb. this overrides filtr.verb since the point of this
|
||||
# method is to return the *default* verb)
|
||||
filtr.default_verb = 'bar'
|
||||
self.assertEqual(filtr.get_default_verb(), 'bar')
|
||||
filtr.default_verb = "bar"
|
||||
self.assertEqual(filtr.get_default_verb(), "bar")
|
||||
|
||||
def test_get_verb_labels(self):
|
||||
model = self.app.model
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.AlchemyFilter)
|
||||
self.assertFalse(hasattr(filtr, 'verbs'))
|
||||
self.assertEqual(filtr.get_verbs(), ['equal', 'not_equal', 'is_any'])
|
||||
self.assertFalse(hasattr(filtr, "verbs"))
|
||||
self.assertEqual(filtr.get_verbs(), ["equal", "not_equal", "is_any"])
|
||||
|
||||
labels = filtr.get_verb_labels()
|
||||
self.assertIsInstance(labels, dict)
|
||||
self.assertEqual(labels['equal'], "equal to")
|
||||
self.assertEqual(labels['not_equal'], "not equal to")
|
||||
self.assertEqual(labels['is_any'], "is any")
|
||||
self.assertEqual(labels["equal"], "equal to")
|
||||
self.assertEqual(labels["not_equal"], "not equal to")
|
||||
self.assertEqual(labels["is_any"], "is any")
|
||||
|
||||
def test_get_valueless_verbs(self):
|
||||
model = self.app.model
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.AlchemyFilter)
|
||||
self.assertFalse(hasattr(filtr, 'verbs'))
|
||||
self.assertEqual(filtr.get_verbs(), ['equal', 'not_equal', 'is_any'])
|
||||
self.assertFalse(hasattr(filtr, "verbs"))
|
||||
self.assertEqual(filtr.get_verbs(), ["equal", "not_equal", "is_any"])
|
||||
|
||||
verbs = filtr.get_valueless_verbs()
|
||||
self.assertIsInstance(verbs, list)
|
||||
self.assertIn('is_any', verbs)
|
||||
self.assertIn("is_any", verbs)
|
||||
|
||||
def test_set_choices(self):
|
||||
model = self.app.model
|
||||
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.AlchemyFilter)
|
||||
self.assertEqual(filtr.choices, {})
|
||||
self.assertEqual(filtr.data_type, 'string')
|
||||
self.assertEqual(filtr.data_type, "string")
|
||||
|
||||
class MockEnum(Enum):
|
||||
FOO = 'foo'
|
||||
BAR = 'bar'
|
||||
FOO = "foo"
|
||||
BAR = "bar"
|
||||
|
||||
filtr.set_choices(MockEnum)
|
||||
self.assertEqual(filtr.choices, OrderedDict([
|
||||
('FOO', 'foo'),
|
||||
('BAR', 'bar'),
|
||||
]))
|
||||
self.assertEqual(filtr.data_type, 'choice')
|
||||
self.assertEqual(
|
||||
filtr.choices,
|
||||
OrderedDict(
|
||||
[
|
||||
("FOO", "foo"),
|
||||
("BAR", "bar"),
|
||||
]
|
||||
),
|
||||
)
|
||||
self.assertEqual(filtr.data_type, "choice")
|
||||
|
||||
filtr.set_choices(None)
|
||||
self.assertEqual(filtr.choices, {})
|
||||
self.assertEqual(filtr.data_type, 'string')
|
||||
self.assertEqual(filtr.data_type, "string")
|
||||
|
||||
def test_normalize_choices(self):
|
||||
model = self.app.model
|
||||
filtr = self.make_filter(model.Setting.name, factory=mod.AlchemyFilter)
|
||||
|
||||
class MockEnum(Enum):
|
||||
FOO = 'foo'
|
||||
BAR = 'bar'
|
||||
FOO = "foo"
|
||||
BAR = "bar"
|
||||
|
||||
choices = filtr.normalize_choices(MockEnum)
|
||||
self.assertEqual(choices, OrderedDict([
|
||||
('FOO', 'foo'),
|
||||
('BAR', 'bar'),
|
||||
]))
|
||||
self.assertEqual(
|
||||
choices,
|
||||
OrderedDict(
|
||||
[
|
||||
("FOO", "foo"),
|
||||
("BAR", "bar"),
|
||||
]
|
||||
),
|
||||
)
|
||||
|
||||
choices = filtr.normalize_choices(OrderedDict([
|
||||
('first', '1'),
|
||||
('second', '2'),
|
||||
]))
|
||||
self.assertEqual(choices, OrderedDict([
|
||||
('first', '1'),
|
||||
('second', '2'),
|
||||
]))
|
||||
choices = filtr.normalize_choices(
|
||||
OrderedDict(
|
||||
[
|
||||
("first", "1"),
|
||||
("second", "2"),
|
||||
]
|
||||
)
|
||||
)
|
||||
self.assertEqual(
|
||||
choices,
|
||||
OrderedDict(
|
||||
[
|
||||
("first", "1"),
|
||||
("second", "2"),
|
||||
]
|
||||
),
|
||||
)
|
||||
|
||||
choices = filtr.normalize_choices({
|
||||
'bbb': 'b',
|
||||
'aaa': 'a',
|
||||
})
|
||||
self.assertEqual(choices, OrderedDict([
|
||||
('aaa', 'a'),
|
||||
('bbb', 'b'),
|
||||
]))
|
||||
choices = filtr.normalize_choices(
|
||||
{
|
||||
"bbb": "b",
|
||||
"aaa": "a",
|
||||
}
|
||||
)
|
||||
self.assertEqual(
|
||||
choices,
|
||||
OrderedDict(
|
||||
[
|
||||
("aaa", "a"),
|
||||
("bbb", "b"),
|
||||
]
|
||||
),
|
||||
)
|
||||
|
||||
choices = filtr.normalize_choices(['one', 'two', 'three'])
|
||||
self.assertEqual(choices, OrderedDict([
|
||||
('one', 'one'),
|
||||
('two', 'two'),
|
||||
('three', 'three'),
|
||||
]))
|
||||
choices = filtr.normalize_choices(["one", "two", "three"])
|
||||
self.assertEqual(
|
||||
choices,
|
||||
OrderedDict(
|
||||
[
|
||||
("one", "one"),
|
||||
("two", "two"),
|
||||
("three", "three"),
|
||||
]
|
||||
),
|
||||
)
|
||||
|
||||
def test_apply_filter(self):
|
||||
model = self.app.model
|
||||
|
|
@ -205,32 +240,46 @@ class TestGridFilter(WebTestCase):
|
|||
|
||||
# default verb used as fallback
|
||||
# self.assertEqual(filtr.default_verb, 'contains')
|
||||
filtr.default_verb = 'contains'
|
||||
filtr.default_verb = "contains"
|
||||
filtr.verb = None
|
||||
with patch.object(filtr, 'filter_contains', side_effect=lambda q, v: q) as filter_contains:
|
||||
filtered_query = filtr.apply_filter(self.sample_query, value='foo')
|
||||
filter_contains.assert_called_once_with(self.sample_query, 'foo')
|
||||
with patch.object(
|
||||
filtr, "filter_contains", side_effect=lambda q, v: q
|
||||
) as filter_contains:
|
||||
filtered_query = filtr.apply_filter(self.sample_query, value="foo")
|
||||
filter_contains.assert_called_once_with(self.sample_query, "foo")
|
||||
self.assertIsNone(filtr.verb)
|
||||
|
||||
# filter verb used as fallback
|
||||
filtr.verb = 'equal'
|
||||
with patch.object(filtr, 'filter_equal', create=True, side_effect=lambda q, v: q) as filter_equal:
|
||||
filtered_query = filtr.apply_filter(self.sample_query, value='foo')
|
||||
filter_equal.assert_called_once_with(self.sample_query, 'foo')
|
||||
filtr.verb = "equal"
|
||||
with patch.object(
|
||||
filtr, "filter_equal", create=True, side_effect=lambda q, v: q
|
||||
) as filter_equal:
|
||||
filtered_query = filtr.apply_filter(self.sample_query, value="foo")
|
||||
filter_equal.assert_called_once_with(self.sample_query, "foo")
|
||||
|
||||
# filter value used as fallback
|
||||
filtr.verb = 'contains'
|
||||
filtr.value = 'blarg'
|
||||
with patch.object(filtr, 'filter_contains', side_effect=lambda q, v: q) as filter_contains:
|
||||
filtr.verb = "contains"
|
||||
filtr.value = "blarg"
|
||||
with patch.object(
|
||||
filtr, "filter_contains", side_effect=lambda q, v: q
|
||||
) as filter_contains:
|
||||
filtered_query = filtr.apply_filter(self.sample_query)
|
||||
filter_contains.assert_called_once_with(self.sample_query, 'blarg')
|
||||
filter_contains.assert_called_once_with(self.sample_query, "blarg")
|
||||
|
||||
# error if invalid verb
|
||||
self.assertRaises(mod.VerbNotSupported, filtr.apply_filter,
|
||||
self.sample_query, verb='doesnotexist')
|
||||
filtr.verbs = ['doesnotexist']
|
||||
self.assertRaises(mod.VerbNotSupported, filtr.apply_filter,
|
||||
self.sample_query, verb='doesnotexist')
|
||||
self.assertRaises(
|
||||
mod.VerbNotSupported,
|
||||
filtr.apply_filter,
|
||||
self.sample_query,
|
||||
verb="doesnotexist",
|
||||
)
|
||||
filtr.verbs = ["doesnotexist"]
|
||||
self.assertRaises(
|
||||
mod.VerbNotSupported,
|
||||
filtr.apply_filter,
|
||||
self.sample_query,
|
||||
verb="doesnotexist",
|
||||
)
|
||||
|
||||
def test_filter_is_any(self):
|
||||
model = self.app.model
|
||||
|
|
@ -250,24 +299,24 @@ class TestAlchemyFilter(WebTestCase):
|
|||
|
||||
model = self.app.model
|
||||
self.sample_data = [
|
||||
{'name': 'foo1', 'value': 'ONE'},
|
||||
{'name': 'foo2', 'value': 'two'},
|
||||
{'name': 'foo3', 'value': 'ggg'},
|
||||
{'name': 'foo4', 'value': 'ggg'},
|
||||
{'name': 'foo5', 'value': 'ggg'},
|
||||
{'name': 'foo6', 'value': 'six'},
|
||||
{'name': 'foo7', 'value': 'seven'},
|
||||
{'name': 'foo8', 'value': 'eight'},
|
||||
{'name': 'foo9', 'value': None},
|
||||
{"name": "foo1", "value": "ONE"},
|
||||
{"name": "foo2", "value": "two"},
|
||||
{"name": "foo3", "value": "ggg"},
|
||||
{"name": "foo4", "value": "ggg"},
|
||||
{"name": "foo5", "value": "ggg"},
|
||||
{"name": "foo6", "value": "six"},
|
||||
{"name": "foo7", "value": "seven"},
|
||||
{"name": "foo8", "value": "eight"},
|
||||
{"name": "foo9", "value": None},
|
||||
]
|
||||
for setting in self.sample_data:
|
||||
self.app.save_setting(self.session, setting['name'], setting['value'])
|
||||
self.app.save_setting(self.session, setting["name"], setting["value"])
|
||||
self.session.commit()
|
||||
self.sample_query = self.session.query(model.Setting)
|
||||
|
||||
def make_filter(self, model_property, **kwargs):
|
||||
factory = kwargs.pop('factory', mod.AlchemyFilter)
|
||||
kwargs['model_property'] = model_property
|
||||
factory = kwargs.pop("factory", mod.AlchemyFilter)
|
||||
kwargs["model_property"] = model_property
|
||||
return factory(self.request, model_property.key, **kwargs)
|
||||
|
||||
def test_filter_equal(self):
|
||||
|
|
@ -280,12 +329,12 @@ class TestAlchemyFilter(WebTestCase):
|
|||
self.assertIs(filtered_query, self.sample_query)
|
||||
|
||||
# nb. by default, *is filtered* by empty string
|
||||
filtered_query = filtr.filter_equal(self.sample_query, '')
|
||||
filtered_query = filtr.filter_equal(self.sample_query, "")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 0)
|
||||
|
||||
# filtered by value
|
||||
filtered_query = filtr.filter_equal(self.sample_query, 'ggg')
|
||||
filtered_query = filtr.filter_equal(self.sample_query, "ggg")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 3)
|
||||
|
||||
|
|
@ -299,12 +348,12 @@ class TestAlchemyFilter(WebTestCase):
|
|||
self.assertIs(filtered_query, self.sample_query)
|
||||
|
||||
# nb. by default, *is filtered* by empty string
|
||||
filtered_query = filtr.filter_not_equal(self.sample_query, '')
|
||||
filtered_query = filtr.filter_not_equal(self.sample_query, "")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 9)
|
||||
|
||||
# filtered by value
|
||||
filtered_query = filtr.filter_not_equal(self.sample_query, 'ggg')
|
||||
filtered_query = filtr.filter_not_equal(self.sample_query, "ggg")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 6)
|
||||
|
||||
|
|
@ -336,24 +385,24 @@ class TestStringAlchemyFilter(WebTestCase):
|
|||
|
||||
model = self.app.model
|
||||
self.sample_data = [
|
||||
{'name': 'foo1', 'value': 'ONE'},
|
||||
{'name': 'foo2', 'value': 'two'},
|
||||
{'name': 'foo3', 'value': 'ggg'},
|
||||
{'name': 'foo4', 'value': 'ggg'},
|
||||
{'name': 'foo5', 'value': 'ggg'},
|
||||
{'name': 'foo6', 'value': 'six'},
|
||||
{'name': 'foo7', 'value': 'seven'},
|
||||
{'name': 'foo8', 'value': 'eight'},
|
||||
{'name': 'foo9', 'value': 'nine'},
|
||||
{"name": "foo1", "value": "ONE"},
|
||||
{"name": "foo2", "value": "two"},
|
||||
{"name": "foo3", "value": "ggg"},
|
||||
{"name": "foo4", "value": "ggg"},
|
||||
{"name": "foo5", "value": "ggg"},
|
||||
{"name": "foo6", "value": "six"},
|
||||
{"name": "foo7", "value": "seven"},
|
||||
{"name": "foo8", "value": "eight"},
|
||||
{"name": "foo9", "value": "nine"},
|
||||
]
|
||||
for setting in self.sample_data:
|
||||
self.app.save_setting(self.session, setting['name'], setting['value'])
|
||||
self.app.save_setting(self.session, setting["name"], setting["value"])
|
||||
self.session.commit()
|
||||
self.sample_query = self.session.query(model.Setting)
|
||||
|
||||
def make_filter(self, model_property, **kwargs):
|
||||
factory = kwargs.pop('factory', mod.StringAlchemyFilter)
|
||||
kwargs['model_property'] = model_property
|
||||
factory = kwargs.pop("factory", mod.StringAlchemyFilter)
|
||||
kwargs["model_property"] = model_property
|
||||
return factory(self.request, model_property.key, **kwargs)
|
||||
|
||||
def test_filter_contains(self):
|
||||
|
|
@ -364,11 +413,11 @@ class TestStringAlchemyFilter(WebTestCase):
|
|||
# not filtered for empty value
|
||||
filtered_query = filtr.filter_contains(self.sample_query, None)
|
||||
self.assertIs(filtered_query, self.sample_query)
|
||||
filtered_query = filtr.filter_contains(self.sample_query, '')
|
||||
filtered_query = filtr.filter_contains(self.sample_query, "")
|
||||
self.assertIs(filtered_query, self.sample_query)
|
||||
|
||||
# filtered by value
|
||||
filtered_query = filtr.filter_contains(self.sample_query, 'ggg')
|
||||
filtered_query = filtr.filter_contains(self.sample_query, "ggg")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 3)
|
||||
|
||||
|
|
@ -380,11 +429,11 @@ class TestStringAlchemyFilter(WebTestCase):
|
|||
# not filtered for empty value
|
||||
filtered_query = filtr.filter_does_not_contain(self.sample_query, None)
|
||||
self.assertIs(filtered_query, self.sample_query)
|
||||
filtered_query = filtr.filter_does_not_contain(self.sample_query, '')
|
||||
filtered_query = filtr.filter_does_not_contain(self.sample_query, "")
|
||||
self.assertIs(filtered_query, self.sample_query)
|
||||
|
||||
# filtered by value
|
||||
filtered_query = filtr.filter_does_not_contain(self.sample_query, 'ggg')
|
||||
filtered_query = filtr.filter_does_not_contain(self.sample_query, "ggg")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 6)
|
||||
|
||||
|
|
@ -392,8 +441,8 @@ class TestStringAlchemyFilter(WebTestCase):
|
|||
class TestIntegerAlchemyFilter(WebTestCase):
|
||||
|
||||
def make_filter(self, model_property, **kwargs):
|
||||
factory = kwargs.pop('factory', mod.IntegerAlchemyFilter)
|
||||
kwargs['model_property'] = model_property
|
||||
factory = kwargs.pop("factory", mod.IntegerAlchemyFilter)
|
||||
kwargs["model_property"] = model_property
|
||||
return factory(self.request, model_property.key, **kwargs)
|
||||
|
||||
def test_coerce_value(self):
|
||||
|
|
@ -402,15 +451,15 @@ class TestIntegerAlchemyFilter(WebTestCase):
|
|||
|
||||
# null
|
||||
self.assertIsNone(filtr.coerce_value(None))
|
||||
self.assertIsNone(filtr.coerce_value(''))
|
||||
self.assertIsNone(filtr.coerce_value(""))
|
||||
|
||||
# typical
|
||||
self.assertEqual(filtr.coerce_value('42'), 42)
|
||||
self.assertEqual(filtr.coerce_value('-42'), -42)
|
||||
self.assertEqual(filtr.coerce_value("42"), 42)
|
||||
self.assertEqual(filtr.coerce_value("-42"), -42)
|
||||
|
||||
# invalid
|
||||
self.assertIsNone(filtr.coerce_value('42.12'))
|
||||
self.assertIsNone(filtr.coerce_value('bogus'))
|
||||
self.assertIsNone(filtr.coerce_value("42.12"))
|
||||
self.assertIsNone(filtr.coerce_value("bogus"))
|
||||
|
||||
|
||||
class TestBooleanAlchemyFilter(WebTestCase):
|
||||
|
|
@ -420,15 +469,9 @@ class TestBooleanAlchemyFilter(WebTestCase):
|
|||
|
||||
model = self.app.model
|
||||
self.sample_data = [
|
||||
{'username': 'alice',
|
||||
'prevent_edit': False,
|
||||
'active': True},
|
||||
{'username': 'bob',
|
||||
'prevent_edit': True,
|
||||
'active': True},
|
||||
{'username': 'charlie',
|
||||
'active': False,
|
||||
'prevent_edit': None},
|
||||
{"username": "alice", "prevent_edit": False, "active": True},
|
||||
{"username": "bob", "prevent_edit": True, "active": True},
|
||||
{"username": "charlie", "active": False, "prevent_edit": None},
|
||||
]
|
||||
for user in self.sample_data:
|
||||
user = model.User(**user)
|
||||
|
|
@ -437,37 +480,46 @@ class TestBooleanAlchemyFilter(WebTestCase):
|
|||
self.sample_query = self.session.query(model.User)
|
||||
|
||||
def make_filter(self, model_property, **kwargs):
|
||||
factory = kwargs.pop('factory', mod.BooleanAlchemyFilter)
|
||||
kwargs['model_property'] = model_property
|
||||
factory = kwargs.pop("factory", mod.BooleanAlchemyFilter)
|
||||
kwargs["model_property"] = model_property
|
||||
return factory(self.request, model_property.key, **kwargs)
|
||||
|
||||
def test_get_verbs(self):
|
||||
model = self.app.model
|
||||
|
||||
# bool field, not nullable
|
||||
filtr = self.make_filter(model.User.active,
|
||||
factory=mod.BooleanAlchemyFilter,
|
||||
nullable=False)
|
||||
self.assertFalse(hasattr(filtr, 'verbs'))
|
||||
self.assertEqual(filtr.default_verbs, ['is_true', 'is_false'])
|
||||
filtr = self.make_filter(
|
||||
model.User.active, factory=mod.BooleanAlchemyFilter, nullable=False
|
||||
)
|
||||
self.assertFalse(hasattr(filtr, "verbs"))
|
||||
self.assertEqual(filtr.default_verbs, ["is_true", "is_false"])
|
||||
|
||||
# by default, returns default verbs (plus 'is_any')
|
||||
self.assertEqual(filtr.get_verbs(), ['is_true', 'is_false', 'is_any'])
|
||||
self.assertEqual(filtr.get_verbs(), ["is_true", "is_false", "is_any"])
|
||||
|
||||
# default verbs can be a callable
|
||||
filtr.default_verbs = lambda: ['foo', 'bar']
|
||||
self.assertEqual(filtr.get_verbs(), ['foo', 'bar', 'is_any'])
|
||||
filtr.default_verbs = lambda: ["foo", "bar"]
|
||||
self.assertEqual(filtr.get_verbs(), ["foo", "bar", "is_any"])
|
||||
|
||||
# bool field, *nullable*
|
||||
filtr = self.make_filter(model.User.active,
|
||||
factory=mod.BooleanAlchemyFilter,
|
||||
nullable=True)
|
||||
self.assertFalse(hasattr(filtr, 'verbs'))
|
||||
self.assertEqual(filtr.default_verbs, ['is_true', 'is_false'])
|
||||
filtr = self.make_filter(
|
||||
model.User.active, factory=mod.BooleanAlchemyFilter, nullable=True
|
||||
)
|
||||
self.assertFalse(hasattr(filtr, "verbs"))
|
||||
self.assertEqual(filtr.default_verbs, ["is_true", "is_false"])
|
||||
|
||||
# effective verbs also include is_false_null
|
||||
self.assertEqual(filtr.get_verbs(), ['is_true', 'is_false', 'is_false_null',
|
||||
'is_null', 'is_not_null', 'is_any'])
|
||||
self.assertEqual(
|
||||
filtr.get_verbs(),
|
||||
[
|
||||
"is_true",
|
||||
"is_false",
|
||||
"is_false_null",
|
||||
"is_null",
|
||||
"is_not_null",
|
||||
"is_any",
|
||||
],
|
||||
)
|
||||
|
||||
def test_coerce_value(self):
|
||||
model = self.app.model
|
||||
|
|
@ -477,11 +529,11 @@ class TestBooleanAlchemyFilter(WebTestCase):
|
|||
|
||||
self.assertTrue(filtr.coerce_value(True))
|
||||
self.assertTrue(filtr.coerce_value(1))
|
||||
self.assertTrue(filtr.coerce_value('1'))
|
||||
self.assertTrue(filtr.coerce_value("1"))
|
||||
|
||||
self.assertFalse(filtr.coerce_value(False))
|
||||
self.assertFalse(filtr.coerce_value(0))
|
||||
self.assertFalse(filtr.coerce_value(''))
|
||||
self.assertFalse(filtr.coerce_value(""))
|
||||
|
||||
def test_filter_is_true(self):
|
||||
model = self.app.model
|
||||
|
|
@ -515,7 +567,7 @@ class TestBooleanAlchemyFilter(WebTestCase):
|
|||
|
||||
|
||||
class TheLocalThing(Base):
|
||||
__tablename__ = 'the_local_thing'
|
||||
__tablename__ = "the_local_thing"
|
||||
id = sa.Column(sa.Integer(), primary_key=True, autoincrement=False)
|
||||
date = sa.Column(sa.DateTime(timezone=True), nullable=True)
|
||||
|
||||
|
|
@ -530,12 +582,12 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
model.Base.metadata.create_all(bind=self.session.bind)
|
||||
|
||||
self.sample_data = [
|
||||
{'id': 1, 'date': datetime.date(2024, 1, 1)},
|
||||
{'id': 2, 'date': datetime.date(2024, 1, 1)},
|
||||
{'id': 3, 'date': datetime.date(2024, 3, 1)},
|
||||
{'id': 4, 'date': datetime.date(2024, 3, 1)},
|
||||
{'id': 5, 'date': None},
|
||||
{'id': 6, 'date': None},
|
||||
{"id": 1, "date": datetime.date(2024, 1, 1)},
|
||||
{"id": 2, "date": datetime.date(2024, 1, 1)},
|
||||
{"id": 3, "date": datetime.date(2024, 3, 1)},
|
||||
{"id": 4, "date": datetime.date(2024, 3, 1)},
|
||||
{"id": 5, "date": None},
|
||||
{"id": 6, "date": None},
|
||||
]
|
||||
|
||||
for thing in self.sample_data:
|
||||
|
|
@ -546,8 +598,8 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
self.sample_query = self.session.query(TheLocalThing)
|
||||
|
||||
def make_filter(self, model_property, **kwargs):
|
||||
factory = kwargs.pop('factory', mod.DateAlchemyFilter)
|
||||
kwargs['model_property'] = model_property
|
||||
factory = kwargs.pop("factory", mod.DateAlchemyFilter)
|
||||
kwargs["model_property"] = model_property
|
||||
return factory(self.request, model_property.key, **kwargs)
|
||||
|
||||
def test_coerce_value(self):
|
||||
|
|
@ -562,12 +614,12 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
self.assertIs(value, result)
|
||||
|
||||
# value as string
|
||||
result = filtr.coerce_value('2024-04-01')
|
||||
result = filtr.coerce_value("2024-04-01")
|
||||
self.assertIsInstance(result, datetime.date)
|
||||
self.assertEqual(result, datetime.date(2024, 4, 1))
|
||||
|
||||
# invalid
|
||||
result = filtr.coerce_value('thisinputisbad')
|
||||
result = filtr.coerce_value("thisinputisbad")
|
||||
self.assertIsNone(result)
|
||||
|
||||
def test_greater_than(self):
|
||||
|
|
@ -582,12 +634,14 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
self.assertEqual(filtered_query.count(), 6)
|
||||
|
||||
# value as date
|
||||
filtered_query = filtr.filter_greater_than(self.sample_query, datetime.date(2024, 2, 1))
|
||||
filtered_query = filtr.filter_greater_than(
|
||||
self.sample_query, datetime.date(2024, 2, 1)
|
||||
)
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 2)
|
||||
|
||||
# value as string
|
||||
filtered_query = filtr.filter_greater_than(self.sample_query, '2024-02-01')
|
||||
filtered_query = filtr.filter_greater_than(self.sample_query, "2024-02-01")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 2)
|
||||
|
||||
|
|
@ -603,17 +657,21 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
self.assertEqual(filtered_query.count(), 6)
|
||||
|
||||
# value as date (clear of boundary)
|
||||
filtered_query = filtr.filter_greater_equal(self.sample_query, datetime.date(2024, 2, 1))
|
||||
filtered_query = filtr.filter_greater_equal(
|
||||
self.sample_query, datetime.date(2024, 2, 1)
|
||||
)
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 2)
|
||||
|
||||
# value as date (at boundary)
|
||||
filtered_query = filtr.filter_greater_equal(self.sample_query, datetime.date(2024, 3, 1))
|
||||
filtered_query = filtr.filter_greater_equal(
|
||||
self.sample_query, datetime.date(2024, 3, 1)
|
||||
)
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 2)
|
||||
|
||||
# value as string
|
||||
filtered_query = filtr.filter_greater_equal(self.sample_query, '2024-01-01')
|
||||
filtered_query = filtr.filter_greater_equal(self.sample_query, "2024-01-01")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 4)
|
||||
|
||||
|
|
@ -629,12 +687,14 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
self.assertEqual(filtered_query.count(), 6)
|
||||
|
||||
# value as date
|
||||
filtered_query = filtr.filter_less_than(self.sample_query, datetime.date(2024, 2, 1))
|
||||
filtered_query = filtr.filter_less_than(
|
||||
self.sample_query, datetime.date(2024, 2, 1)
|
||||
)
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 2)
|
||||
|
||||
# value as string
|
||||
filtered_query = filtr.filter_less_than(self.sample_query, '2024-04-01')
|
||||
filtered_query = filtr.filter_less_than(self.sample_query, "2024-04-01")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 4)
|
||||
|
||||
|
|
@ -650,17 +710,21 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
self.assertEqual(filtered_query.count(), 6)
|
||||
|
||||
# value as date (clear of boundary)
|
||||
filtered_query = filtr.filter_less_equal(self.sample_query, datetime.date(2024, 2, 1))
|
||||
filtered_query = filtr.filter_less_equal(
|
||||
self.sample_query, datetime.date(2024, 2, 1)
|
||||
)
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 2)
|
||||
|
||||
# value as date (at boundary)
|
||||
filtered_query = filtr.filter_less_equal(self.sample_query, datetime.date(2024, 3, 1))
|
||||
filtered_query = filtr.filter_less_equal(
|
||||
self.sample_query, datetime.date(2024, 3, 1)
|
||||
)
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 2)
|
||||
|
||||
# value as string
|
||||
filtered_query = filtr.filter_less_equal(self.sample_query, '2024-04-01')
|
||||
filtered_query = filtr.filter_less_equal(self.sample_query, "2024-04-01")
|
||||
self.assertIsNot(filtered_query, self.sample_query)
|
||||
self.assertEqual(filtered_query.count(), 4)
|
||||
|
||||
|
|
@ -668,5 +732,5 @@ class TestDateAlchemyFilter(WebTestCase):
|
|||
class TestVerbNotSupported(TestCase):
|
||||
|
||||
def test_basic(self):
|
||||
error = mod.VerbNotSupported('equal')
|
||||
error = mod.VerbNotSupported("equal")
|
||||
self.assertEqual(str(error), "unknown filter verb not supported: equal")
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue