def test_builder_offset_defaults_to_0():
"""If no offset is given then "from": 0 is used in the query by default."""
builder = query.Builder()
q = builder.build({})
assert q["from"] == 0
def test_builder_offset_string_is_converted_to_int():
"""'offset' arguments should be converted from strings to ints."""
builder = query.Builder()
q = builder.build({"offset": "23"})
assert q["from"] == 23
def test_builder_default_param_action():
"""Other params are added as "match" clauses."""
builder = query.Builder()
q = builder.build({"foo": "bar"})
assert q["query"] == {"bool": {"must": [{"match": {"foo": "bar"}}]}}
def test_builder_limit_defaults_to_20():
"""If no limit is given "size": 20 is used in the query by default."""
builder = query.Builder()
q = builder.build({})
assert q["size"] == 20
def test_builder_with_custom_sort():
"""Custom sorts are returned in the query dict."""
builder = query.Builder()
q = builder.build({"sort": "title"})
assert q["sort"] == [{'title': {'ignore_unmapped': True, 'order': 'desc'}}]
def test_builder_limit_matches_input(lim):
"""Given an integer in the allowed range, it should be passed through."""
builder = query.Builder()
q = builder.build({"limit": str(lim)})
assert q["size"] == lim
def test_builder_sort_includes_ignore_unmapped():
"""'ignore_unmapped': True is used in the sort clause."""
builder = query.Builder()
q = builder.build({})
assert q["sort"][0]["updated"]["ignore_unmapped"] == True
def test_builder_custom_limits_are_passed_in():
"""If a limit is given it's returned in the query dict as "size"."""
builder = query.Builder()
q = builder.build({"limit": 7})
assert q["size"] == 7
def test_builder_limit_strings_are_converted_to_ints():
"""String values for limit should be converted to ints."""
builder = query.Builder()
q = builder.build({"limit": "17"})
assert q["size"] == 17
def test_builder_custom_offsets_are_passed_in():
"""If an offset is given it's returned in the query dict."""
builder = query.Builder()
q = builder.build({"offset": 7})
assert q["from"] == 7
def test_builder_defaults_to_match_all():
"""If no query params are given a "match_all": {} query is returned."""
builder = query.Builder()
q = builder.build({})
assert q["query"] == {"match_all": {}}
def test_builder_with_custom_order():
"""'order' params are returned in the query dict if given."""
builder = query.Builder()
q = builder.build({"order": "asc"})
sort = q["sort"]
assert sort[0]["updated"]["order"] == "asc"
def test_builder_order_defaults_to_desc():
"""'order': "desc" is returned in the q dict by default."""
builder = query.Builder()
q = builder.build({})
sort = q["sort"]
assert sort[0]["updated"]["order"] == "desc"
def test_builder_limit_output_within_bounds_int_input(lim):
"""Given any integer input, output should be in the allowed range."""
builder = query.Builder()
q = builder.build({"limit": str(lim)})
assert isinstance(q["size"], int)
assert 0 <= q["size"] <= LIMIT_MAX
def test_builder_with_invalid_limit():
"""Invalid 'limit' params should be ignored."""
for invalid_limit in ("foo", '', ' ', "-23", "32.7"):
builder = query.Builder()
q = builder.build({"limit": invalid_limit})
assert q["size"] == 20 # (20 is the default value.)
def test_builder_with_invalid_offset():
"""Invalid 'offset' params should be ignored."""
for invalid_offset in ("foo", '', ' ', "-23", "32.7"):
builder = query.Builder()
q = builder.build({"offset": invalid_offset})
assert q["from"] == 0
def test_builder_passes_params_to_matchers():
testmatcher = mock.Mock()
builder = query.Builder()
builder.append_matcher(testmatcher)
builder.build({"foo": "bar"})
testmatcher.assert_called_with({"foo": "bar"})
def test_builder_with_evil_arguments():
builder = query.Builder()
params = {"offset": "3foo", "limit": '\' drop table annotations'}
q = builder.build(params)
assert q["from"] == 0
assert q["size"] == 20
assert q["query"] == {'match_all': {}}
def test_builder_offset(offset, from_):
builder = query.Builder()
if offset is MISSING:
q = builder.build({})
else:
q = builder.build({"offset": offset})
assert q["from"] == from_
def test_builder_sort_is_by_updated():
"""Sort defaults to "updated"."""
builder = query.Builder()
q = builder.build({})
sort = q["sort"]
assert len(sort) == 1
assert sort[0].keys() == ["updated"]
def test_builder_ignores_filters_returning_none():
testfilter = mock.Mock()
testfilter.return_value = None
builder = query.Builder()
builder.append_filter(testfilter)
q = builder.build({})
assert q["query"] == {"match_all": {}}
def make_builder():
builder = query.Builder()
builder.append_filter(query.AuthFilter(request, private=private))
builder.append_filter(query.UriFilter())
builder.append_filter(
lambda _: nipsa.nipsa_filter(request.authenticated_userid))
builder.append_filter(query.GroupFilter())
builder.append_matcher(query.AnyMatcher())
builder.append_matcher(query.TagsMatcher())
return builder
def test_builder_adds_matchers_to_query():
testmatcher = mock.Mock()
testmatcher.return_value = {"match": {"giraffe": "nose"}}
builder = query.Builder()
builder.append_matcher(testmatcher)
q = builder.build({})
assert q["query"] == {
"bool": {"must": [{"match": {"giraffe": "nose"}}]},
}
def default_querybuilder(request, private=True):
builder = query.Builder()
builder.append_filter(query.AuthFilter(request, private=private))
builder.append_filter(query.UriFilter(request))
builder.append_filter(query.GroupFilter())
builder.append_matcher(query.AnyMatcher())
builder.append_matcher(query.TagsMatcher())
for factory in request.registry.get(FILTERS_KEY, []):
builder.append_filter(factory(request))
for factory in request.registry.get(MATCHERS_KEY, []):
builder.append_matcher(factory(request))
return builder
def test_builder_filters_query_by_filter_results():
testfilter = mock.Mock()
testfilter.return_value = {"term": {"giraffe": "nose"}}
builder = query.Builder()
builder.append_filter(testfilter)
q = builder.build({})
assert q["query"] == {
"filtered": {
"filter": {"and": [{"term": {"giraffe": "nose"}}]},
"query": {"match_all": {}},
},
}
def test_builder_default_params_multidict():
"""Multiple params go into multiple "match" dicts."""
builder = query.Builder()
params = multidict.MultiDict()
params.add("user", "fred")
params.add("user", "bob")
q = builder.build(params)
assert q["query"] == {
"bool": {
"must": [
{"match": {"user": "******"}},
{"match": {"user": "******"}}
]
}
}
def test_builder_limit_missing():
builder = query.Builder()
q = builder.build({})
assert q["size"] == LIMIT_DEFAULT
