def test_invalid_query_args(self):
ref = db.Reference(path='foo')
with pytest.raises(ValueError):
db.Query(order_by='$key',
client=ref._client,
pathurl=ref._add_suffix(),
foo='bar')
def initquery(request):
ref = db.Reference(path='foo')
if request.param == '$key':
return ref.order_by_key(), request.param
elif request.param == '$value':
return ref.order_by_value(), request.param
else:
return ref.order_by_child(request.param), request.param
def test_valid_path(self, path, expected):
ref = db.Reference(path=path)
fullstr, key, parent = expected
assert ref.path == fullstr
assert ref.key == key
if parent is None:
assert ref.parent is None
else:
assert ref.parent.path == parent
class TestQuery(object):
"""Test cases for db.Query class."""
valid_paths = {
'foo' : 'foo',
'foo/bar' : 'foo/bar',
'foo/bar/' : 'foo/bar'
}
ref = db.Reference(path='foo')
@pytest.mark.parametrize('path', [
'', None, '/', '/foo', 0, 1, True, False, dict(), list(), tuple(), _Object(),
'$foo', '.foo', '#foo', '[foo', 'foo]', '$key', '$value', '$priority'
])
def test_invalid_path(self, path):
with pytest.raises(ValueError):
self.ref.order_by_child(path)
@pytest.mark.parametrize('path, expected', valid_paths.items())
def test_order_by_valid_path(self, path, expected):
query = self.ref.order_by_child(path)
assert query._querystr == 'orderBy="{0}"'.format(expected)
@pytest.mark.parametrize('path, expected', valid_paths.items())
def test_filter_by_valid_path(self, path, expected):
query = self.ref.order_by_child(path)
query.equal_to(10)
assert query._querystr == 'equalTo=10&orderBy="{0}"'.format(expected)
def test_order_by_key(self):
query = self.ref.order_by_key()
assert query._querystr == 'orderBy="$key"'
def test_key_filter(self):
query = self.ref.order_by_key()
query.equal_to(10)
assert query._querystr == 'equalTo=10&orderBy="$key"'
def test_order_by_value(self):
query = self.ref.order_by_value()
assert query._querystr == 'orderBy="$value"'
def test_value_filter(self):
query = self.ref.order_by_value()
query.equal_to(10)
assert query._querystr == 'equalTo=10&orderBy="$value"'
def test_multiple_limits(self):
query = self.ref.order_by_child('foo')
query.limit_to_first(1)
with pytest.raises(ValueError):
query.limit_to_last(2)
query = self.ref.order_by_child('foo')
query.limit_to_last(2)
with pytest.raises(ValueError):
query.limit_to_first(1)
@pytest.mark.parametrize('limit', [None, -1, 'foo', 1.2, list(), dict(), tuple(), _Object()])
def test_invalid_limit(self, limit):
query = self.ref.order_by_child('foo')
with pytest.raises(ValueError):
query.limit_to_first(limit)
with pytest.raises(ValueError):
query.limit_to_last(limit)
def test_start_at_none(self):
query = self.ref.order_by_child('foo')
with pytest.raises(ValueError):
query.start_at(None)
@pytest.mark.parametrize('arg', ['', 'foo', True, False, 0, 1, dict()])
def test_valid_start_at(self, arg):
query = self.ref.order_by_child('foo').start_at(arg)
assert query._querystr == 'orderBy="foo"&startAt={0}'.format(json.dumps(arg))
def test_end_at_none(self):
query = self.ref.order_by_child('foo')
with pytest.raises(ValueError):
query.end_at(None)
@pytest.mark.parametrize('arg', ['', 'foo', True, False, 0, 1, dict()])
def test_valid_end_at(self, arg):
query = self.ref.order_by_child('foo').end_at(arg)
assert query._querystr == 'endAt={0}&orderBy="foo"'.format(json.dumps(arg))
def test_equal_to_none(self):
query = self.ref.order_by_child('foo')
with pytest.raises(ValueError):
query.equal_to(None)
@pytest.mark.parametrize('arg', ['', 'foo', True, False, 0, 1, dict()])
def test_valid_equal_to(self, arg):
query = self.ref.order_by_child('foo').equal_to(arg)
assert query._querystr == 'equalTo={0}&orderBy="foo"'.format(json.dumps(arg))
def test_range_query(self, initquery):
query, order_by = initquery
query.start_at(1)
query.equal_to(2)
query.end_at(3)
assert query._querystr == 'endAt=3&equalTo=2&orderBy="{0}"&startAt=1'.format(order_by)
def test_limit_first_query(self, initquery):
query, order_by = initquery
query.limit_to_first(1)
assert query._querystr == 'limitToFirst=1&orderBy="{0}"'.format(order_by)
def test_limit_last_query(self, initquery):
query, order_by = initquery
query.limit_to_last(1)
assert query._querystr == 'limitToLast=1&orderBy="{0}"'.format(order_by)
def test_all_in(self, initquery):
query, order_by = initquery
query.start_at(1)
query.equal_to(2)
query.end_at(3)
query.limit_to_first(10)
expected = 'endAt=3&equalTo=2&limitToFirst=10&orderBy="{0}"&startAt=1'.format(order_by)
assert query._querystr == expected
def test_invalid_query_args(self):
ref = db.Reference(path='foo')
with pytest.raises(ValueError):
db.Query(order_by='$key', client=ref._client, pathurl=ref._add_suffix(), foo='bar')
def test_invalid_child(self, child):
parent = db.Reference(path='/test')
with pytest.raises(ValueError):
parent.child(child)
def test_valid_child(self, child, expected):
fullstr, key, parent = expected
childref = db.Reference(path='/test').child(child)
assert childref.path == fullstr
assert childref.key == key
assert childref.parent.path == parent
def test_invalid_key(self, path):
with pytest.raises(ValueError):
db.Reference(path=path)
