def update_from_query_string(request, Model, query, adapter):
headers = request.response.headers
if request.params:
# TODO: Implement schema validation to use request.validated
querystring = QueryString(request, Model, adapter=adapter)
total_query = querystring.from_filter_by(query)
total_query = querystring.from_tags(total_query)
query = querystring.from_order_by(total_query)
query = querystring.from_limit(query)
query = querystring.from_offset(query)
# TODO: Advanced pagination with Link Header
# Link: '<https://api.github.com/user/repos?page=3&per_page=100>;
# rel="next",
# <https://api.github.com/user/repos?page=50&per_page=100>;
# rel="last"'
headers['X-Count-Records'] = str(query.count())
headers['X-Total-Records'] = str(total_query.count())
# TODO: Etag / timestamp / 304 if no changes
# TODO: Cache headers
return query
else:
# no querystring, returns all records (maybe we will want to apply
# some default filters values
headers['X-Count-Records'] = str(query.count())
headers['X-Total-Records'] = str(query.count())
return query
def test_querystring_get_remote_model_for(self, registry_blok_with_m2o):
registry = registry_blok_with_m2o
request = MockRequest(self)
model = registry.System.Blok
qs = QueryString(request, model)
Model = qs.get_remote_model_for(registry.Test2, 'test')
assert Model is registry.Test
def test_querystring_get_remote_model_for_unknown(self):
registry = self.init_registry(add_many2one_class)
request = MockRequest(self)
model = registry.System.Blok
qs = QueryString(request, model)
Model = qs.get_remote_model_for(registry.Test, 'test')
self.assertIsNone(Model)
def test_querystring_update_sqlalchemy_query(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
qs = QueryString(request, model)
qs.update_sqlalchemy_query(query)
def test_querystring_get_remote_model_for_without_relationship(
self, registry_blok_with_m2o):
registry = registry_blok_with_m2o
request = MockRequest(self)
model = registry.System.Blok
qs = QueryString(request, model)
Model = qs.get_remote_model_for(registry.Test, 'name')
assert Model is None
def test_querystring_get_model_and_key_from_relationship_1(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model, ['name'])
self.assertIs(res[1], model)
self.assertEqual(res[2], 'name')
def test_querystring_from_offset_without_offset(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
qs = QueryString(request, model)
qs.offset = None
Q = qs.from_offset(query)
self.assertEqual(len(Q.all()), len(query.all()))
def test_querystring_from_limit(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
qs = QueryString(request, model)
qs.limit = 1
Q = qs.from_limit(query)
self.assertEqual(len(Q.all()), 1)
def test_querystring_from_limit(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
qs = QueryString(request, model)
qs.limit = 1
Q = qs.from_limit(query)
assert len(Q.all()) == 1
def test_querystring_update_filter_or_without_value(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
key = 'name'
op = 'or-ilike'
value = None
qs = QueryString(request, model)
self.assertIsNone(qs.update_or_filter(model, key, op, value))
def test_querystring_from_offset_without_offset(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
qs = QueryString(request, model)
qs.offset = None
Q = qs.from_offset(query)
assert len(Q.all()) == len(query.all())
def test_querystring_update_filter_or_without_value(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
key = 'name'
op = 'or-ilike'
value = None
qs = QueryString(request, model)
assert qs.update_or_filter(model, key, op, value) is None
def test_querystring_get_model_and_key_from_relationship_1(
self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model, ['name'])
assert res[1] is model
assert res[2] == 'name'
def test_querystring_get_model_and_key_from_relationship_2(self):
registry = self.init_registry(add_many2one_class)
request = MockRequest(self)
model = registry.Test2
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model,
['test', 'name'])
self.assertIs(res[1], registry.Test)
self.assertEqual(res[2], 'name')
def test_querystring_get_model_and_key_from_relationship_3(self):
registry = self.init_registry(add_many2one_class)
request = MockRequest(self)
model = registry.Test2
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model,
['test', 'number'])
self.assertEqual(
res, "'number' does not exist in model <class 'anyblok.model."
"ModelTest'>.")
def test_querystring_from_order_by_without_key(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = None
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
assert len(request.errors.messages) == 1
def test_querystring_from_order_by_ok(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
Q = qs.from_order_by(query)
assert Q.all().name == query.order_by(model.name.asc()).all().name
def test_querystring_from_order_by_without_key(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = None
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
self.assertEqual(len(request.errors.messages), 1)
def test_querystring_get_model_and_key_from_relationship_4(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Column
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model,
['model', 'name'])
self.assertEqual(
"'model' in model <class 'anyblok.model.ModelSystemColumn'> is not "
"a relationship.", res)
def test_querystring_get_model_and_key_from_relationship_2(
self, registry_blok_with_m2o):
registry = registry_blok_with_m2o
request = MockRequest(self)
model = registry.Test2
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model,
['test', 'name'])
assert res[1] is registry.Test
assert res[2] == 'name'
def test_querystring_update_filter_in_3(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
key = 'name'
op = 'in'
value = ''
qs = QueryString(request, model)
qs.update_filter(model, key, op, value)
assert ("Filter 'in' except a comma separated string value"
in request.errors.messages)
def test_querystring_from_order_by_ok(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
Q = qs.from_order_by(query)
self.assertEqual(Q.all().name,
query.order_by(model.name.asc()).all().name)
def test_querystring_update_filter_ilike(self):
registry = self.init_registry(None)
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'ilike'
value = 'yBlOk-c'
qs = QueryString(request, model)
Q = query.filter(qs.update_filter(model, key, op, value))
obj = Q.one()
self.assertEqual(obj.name, 'anyblok-core')
def test_querystring_get_model_and_key_from_relationship_4(
self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Column
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model,
['model', 'name'])
assert ("'model' in model "
"<class 'anyblok.model.factory.ModelSystemColumn'> is not "
"a relationship." == res)
def test_querystring_get_model_and_key_from_relationship_3(
self, registry_blok_with_m2o):
registry = registry_blok_with_m2o
request = MockRequest(self)
model = registry.Test2
query = model.query()
qs = QueryString(request, model)
res = qs.get_model_and_key_from_relationship(query, model,
['test', 'number'])
waiting = ("'number' does not exist in model <class 'anyblok.model."
"factory.ModelTest'>.")
assert res == waiting
def test_querystring_from_filter_by_without_key(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = None
op = 'eq'
value = 'anyblok-core'
qs = QueryString(request, model)
qs.filter_by = [dict(key=key, op=op, value=value)]
qs.from_filter_by(query)
assert len(request.errors.messages) == 1
def test_querystring_from_order_by_ko_bad_op(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'unknown'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
assert ("ORDER_by operator 'unknown' does not exist."
in request.errors.messages)
def test_querystring_update_filter_ilike(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'ilike'
value = 'yBlOk-c'
qs = QueryString(request, model)
Q = query.filter(qs.update_filter(model, key, op, value))
obj = Q.one()
assert obj.name == 'anyblok-core'
def test_querystring_from_filter_by_ko_bad_op(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'name'
op = 'unknown'
value = 'anyblok-core'
qs = QueryString(request, model)
qs.filter_by = [dict(key=key, op=op, value=value)]
qs.from_filter_by(query)
assert ("Filter 'unknown' does not exist." in request.errors.messages)
def test_querystring_from_order_by_bad_key(self, registry_blok):
registry = registry_blok
request = MockRequest(self)
model = registry.System.Blok
query = model.query()
key = 'badkey'
op = 'asc'
qs = QueryString(request, model)
qs.order_by = [dict(key=key, op=op)]
qs.from_order_by(query)
assert ("Order 'badkey': 'badkey' does not exist in model "
"<class 'anyblok.model.factory.ModelSystemBlok'>."
in request.errors.messages)
