def search(request):
"""Search the database for annotations matching with the given query."""
schema = SearchParamsSchema()
params = validate_query_params(schema, request.params)
separate_replies = params.pop("_separate_replies", False)
stats = getattr(request, "stats", None)
search = search_lib.Search(request,
separate_replies=separate_replies,
stats=stats)
result = search.run(params)
svc = request.find_service(name="annotation_json_presentation")
out = {
"total": result.total,
"rows": svc.present_all(result.annotation_ids)
}
if separate_replies:
out["replies"] = svc.present_all(result.reply_ids)
return out
def search(request):
"""Search the database for annotations matching with the given query."""
schema = SearchParamsSchema()
params = validate_query_params(schema, request.params)
_record_search_api_usage_metrics(params)
separate_replies = params.pop('_separate_replies', False)
stats = getattr(request, 'stats', None)
search = search_lib.Search(request,
separate_replies=separate_replies,
stats=stats)
search.append_modifier(
UriCombinedWildcardFilter(request, separate_keys=True))
result = search.run(params)
svc = request.find_service(name='annotation_json_presentation')
out = {
'total': result.total,
'rows': svc.present_all(result.annotation_ids)
}
if separate_replies:
out['replies'] = svc.present_all(result.reply_ids)
return out
def test_passes_validation_if_valid_search_after(self, schema, search_after, sort):
input_params = NestedMultiDict(
MultiDict({"search_after": search_after, "sort": sort})
)
params = validate_query_params(schema, input_params)
assert params["search_after"] == search_after
def test_a_list_field_can_have_a_single_value(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first"]
def test_passes_validation_if_valid_search_after(self, schema, search_after, sort):
input_params = NestedMultiDict(
MultiDict({"search_after": search_after, "sort": sort})
)
params = validate_query_params(schema, input_params)
assert params["search_after"] == search_after
def test_a_list_field_can_have_a_single_value(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first"]
def test_sets_offset_to_0_if_search_after(self, schema):
input_params = NestedMultiDict(
MultiDict({"search_after": "2009-02-16", "offset": 5})
)
params = validate_query_params(schema, input_params)
assert not params["offset"]
assert params["search_after"] == "2009-02-16"
def test_it_keeps_all_values_for_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
params.add("list_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first", "second"]
def test_sets_offset_to_0_if_search_after(self, schema):
input_params = NestedMultiDict(
MultiDict({"search_after": "2009-02-16", "offset": 5})
)
params = validate_query_params(schema, input_params)
assert params["offset"] == 0
assert params["search_after"] == "2009-02-16"
def test_it_keeps_only_last_value_for_non_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "first")
params.add("string_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("string_field") == ["second"]
def test_it_does_not_include_unknown_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "include_me")
params.add("unknown_field", "ignore_me")
parsed = validate_query_params(schema, params)
assert "unknown_field" not in parsed
def test_it_keeps_all_values_for_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("list_field", "first")
params.add("list_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("list_field") == ["first", "second"]
def test_it_keeps_only_last_value_for_non_sequence_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "first")
params.add("string_field", "second")
parsed = validate_query_params(schema, params)
assert parsed.getall("string_field") == ["second"]
def test_it_does_not_include_unknown_fields(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "include_me")
params.add("unknown_field", "ignore_me")
parsed = validate_query_params(schema, params)
assert "unknown_field" not in parsed
def test_it_handles_duplicate_keys(self, schema):
expected_params = MultiDict([("url", "http://foobar"),
("url", "http://foobat")])
input_params = deepcopy(expected_params)
input_params.add("unknownparam", "foo")
input_params.add("unknownparam", "bar")
params = validate_query_params(schema, NestedMultiDict(input_params))
assert params.getall("url") == ["http://foobar", "http://foobat"]
assert "unknownparam" not in params
def test_it_returns_only_known_params(self, schema):
expected_params = MultiDict(
{
"_separate_replies": True,
"group": "group1",
"quote": "quote me",
"references": "3456TA12",
"tag": "tagme",
"tags": "tagme2",
"text": "text me",
"uri": "foobar.com",
"uri.parts": "bbc",
"wildcard_uri": "http://foo.com/*",
"url": "https://foobar.com",
"any": "foo",
"user": "******",
"sort": "created",
"limit": 10,
"order": "asc",
"offset": 0,
"search_after": "2018-01-01",
}
)
input_params = NestedMultiDict(
MultiDict(
{
"_separate_replies": "1",
"group": "group1",
"quote": "quote me",
"references": "3456TA12",
"tag": "tagme",
"tags": "tagme2",
"text": "text me",
"uri": "foobar.com",
"uri.parts": "bbc",
"wildcard_uri": "http://foo.com/*",
"url": "https://foobar.com",
"any": "foo",
"user": "******",
"sort": "created",
"limit": "10",
"order": "asc",
"offset": "0",
"unknown": "no_exist",
"no_exist": "unknown",
"search_after": "2018-01-01",
}
)
)
params = validate_query_params(schema, input_params)
assert params == expected_params
def test_it_returns_only_known_params(self, schema):
expected_params = MultiDict(
{
"_separate_replies": True,
"group": "group1",
"quote": "quote me",
"references": "3456TA12",
"tag": "tagme",
"tags": "tagme2",
"text": "text me",
"uri": "foobar.com",
"uri.parts": "bbc",
"wildcard_uri": "http://foo.com/*",
"url": "https://foobar.com",
"any": "foo",
"user": "******",
"sort": "created",
"limit": 10,
"order": "asc",
"offset": 0,
"search_after": "2018-01-01",
}
)
input_params = NestedMultiDict(
MultiDict(
{
"_separate_replies": "1",
"group": "group1",
"quote": "quote me",
"references": "3456TA12",
"tag": "tagme",
"tags": "tagme2",
"text": "text me",
"uri": "foobar.com",
"uri.parts": "bbc",
"wildcard_uri": "http://foo.com/*",
"url": "https://foobar.com",
"any": "foo",
"user": "******",
"sort": "created",
"limit": "10",
"order": "asc",
"offset": "0",
"unknown": "no_exist",
"no_exist": "unknown",
"search_after": "2018-01-01",
}
)
)
params = validate_query_params(schema, input_params)
assert params == expected_params
def test_it_handles_duplicate_keys(self, schema):
expected_params = MultiDict(
[("url", "http://foobar"), ("url", "http://foobat")]
)
input_params = deepcopy(expected_params)
input_params.add("unknownparam", "foo")
input_params.add("unknownparam", "bar")
params = validate_query_params(schema, NestedMultiDict(input_params))
assert params.getall("url") == ["http://foobar", "http://foobat"]
assert "unknownparam" not in params
def test_it_deserializes_params(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "test")
parsed = validate_query_params(schema, params)
assert parsed == {
"int_field": 0,
"string_field": "test",
"list_field": None,
"enum_field": "up",
}
def test_it_deserializes_params(self):
schema = QueryParamSchema()
params = MultiDict()
params.add("string_field", "test")
parsed = validate_query_params(schema, params)
assert parsed == {
"int_field": 0,
"string_field": "test",
"list_field": None,
"enum_field": "up",
}
def test_it_returns_only_known_params(self, schema):
expected_params = MultiDict({
'_separate_replies': True,
'group': "group1",
'quote': "quote me",
'references': "3456TA12",
'tag': "tagme",
'tags': "tagme2",
'text': "text me",
'uri': "foobar.com",
'uri.parts': "bbc",
'wildcard_uri': "http://foo.com/*",
'url': "https://foobar.com",
'any': "foo",
'user': "******",
'sort': "created",
'limit': 10,
'order': "asc",
'offset': 0,
'search_after': "2018-01-01",
})
input_params = NestedMultiDict(
MultiDict({
'_separate_replies': '1',
'group': "group1",
'quote': "quote me",
'references': "3456TA12",
'tag': "tagme",
'tags': "tagme2",
'text': "text me",
'uri': "foobar.com",
'uri.parts': "bbc",
'wildcard_uri': "http://foo.com/*",
'url': "https://foobar.com",
'any': "foo",
'user': "******",
'sort': "created",
'limit': "10",
'order': "asc",
'offset': "0",
'unknown': "no_exist",
'no_exist': "unknown",
'search_after': "2018-01-01",
}))
params = validate_query_params(schema, input_params)
assert params == expected_params
def search(request):
"""Search the database for annotations matching with the given query."""
schema = SearchParamsSchema()
params = validate_query_params(schema, request.params)
separate_replies = params.pop("_separate_replies", False)
stats = getattr(request, "stats", None)
search = search_lib.Search(request, separate_replies=separate_replies, stats=stats)
result = search.run(params)
svc = request.find_service(name="annotation_json_presentation")
out = {"total": result.total, "rows": svc.present_all(result.annotation_ids)}
if separate_replies:
out["replies"] = svc.present_all(result.reply_ids)
return out
def test_it_defaults_offset(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["offset"] == 0
def test_raises_if_invalid_search_after_date(self, schema):
input_params = NestedMultiDict(
MultiDict({"search_after": "invalid_date"}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_raises_if_invalid_limit(self, schema, limit):
input_params = NestedMultiDict(MultiDict({"limit": limit}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_it_defaults_order(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["order"] == "desc"
def test_it_defaults_offset(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["offset"] == 0
def test_raises_if_invalid_offset(self, schema, offset):
input_params = NestedMultiDict(MultiDict({"offset": offset}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_raises_if_invalid_search_after_date(self, schema):
input_params = NestedMultiDict(MultiDict({"search_after": "invalid_date"}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_raises_if_wildcards_are_in_domain(self, schema, wildcard_uri):
input_params = NestedMultiDict(MultiDict({"wildcard_uri": wildcard_uri}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_it_raises_if_params_invalid(self):
schema = QueryParamSchema()
params = MultiDict({"int_field": "not-an-int"})
with pytest.raises(ValidationError):
validate_query_params(schema, params)
def test_it_defaults_limit(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["limit"] == LIMIT_DEFAULT
def test_it_defaults_limit(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["limit"] == LIMIT_DEFAULT
def test_it_raises_if_params_invalid(self):
schema = QueryParamSchema()
params = MultiDict({"int_field": "not-an-int"})
with pytest.raises(ValidationError):
validate_query_params(schema, params)
def test_it_defaults_sort(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["sort"] == "updated"
def test_raises_if_invalid_limit(self, schema, limit):
input_params = NestedMultiDict(MultiDict({"limit": limit}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_raises_if_invalid_sort(self, schema):
input_params = NestedMultiDict(MultiDict({"sort": "notrecognized"}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_raises_if_invalid_sort(self, schema):
input_params = NestedMultiDict(MultiDict({"sort": "notrecognized"}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_raises_if_invalid_offset(self, schema, offset):
input_params = NestedMultiDict(MultiDict({"offset": offset}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_it_defaults_order(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["order"] == "desc"
def test_raises_if_wildcards_are_in_domain(self, schema, wildcard_uri):
input_params = NestedMultiDict(
MultiDict({"wildcard_uri": wildcard_uri}))
with pytest.raises(ValidationError):
validate_query_params(schema, input_params)
def test_it_defaults_sort(self, schema):
params = validate_query_params(schema, NestedMultiDict())
assert params["sort"] == "updated"
