def test__aggregation_few_arguments(self):
with pytest.raises(IndexError) as e:
bodyBuilder().aggregation().build()
assert "Too Few arguments for aggregation query" in str(e.value)
with pytest.raises(IndexError) as e:
bodyBuilder().aggregation("a").build()
assert "Too Few arguments for aggregation query" in str(e.value)
def test__percentiles_scripit(self):
result = bodyBuilder() \
.aggregation('percentiles',
{
'script': {
'inline': "doc['load_time'].value / timeUnit",
'params': {
'timeUnit': 100
}
}
}, 'load_time_script') \
.getAggregations()
expected_query = {
'load_time_script': {
'percentiles': {
'script': {
'inline': "doc['load_time'].value / timeUnit",
'params': {
'timeUnit': 100
}
}
}
}
}
assert result == expected_query
def test__nested_aggregations(self):
result = bodyBuilder() \
.aggregation(
"a", "b", {"c": "d"}, "e",
lambda x: x.aggregation(
"f", "g",
lambda y: y.aggregation("h", "i", "j"))) \
.build()
expected_query = {
"aggs": {
"e": {
"a": {
"field": "b",
"c": "d"
},
"aggs": {
"agg_f_g": {
"f": {
"field": "g"
},
"aggs": {
"j": {
"h": {
"field": "i"
}
}
}
}
}
}
}
}
assert result == expected_query
def test__minimum_should_match(self):
result = bodyBuilder() \
.orFilter('term', 'user', 'kimchy') \
.orFilter('term', 'user', 'tony') \
.filterMinimumShouldMatch(2) \
.build()
expected_query = {
"query": {
"bool": {
"should": [{
"term": {
"user": "******"
}
}, {
"term": {
"user": "******"
}
}],
"minimum_should_match": 2
}
}
}
assert result == expected_query
def test__multiple_filters(self):
result = bodyBuilder() \
.filter('range', 'count', {'gt': 5}) \
.filter('term', 'a') \
.build()
expected_query = {
'query': {
'bool': {
'filter': [
{
'range': {
'count': {
'gt': 5
}
}
},
{
'term': {
'field': "a"
}
}
]
}
}
}
assert expected_query == result
def test__dynamic_filter(self):
result = bodyBuilder() \
.filter('constant_score',
lambda f: f.filter('term', 'user', 'kimchy')) \
.filter('term', 'message', 'this is a test') \
.build()
expected_query = {
"query": {
"bool": {
"filter": [
{
"constant_score": {
"filter": {
"term": {
"user": "******"
}
}
}
},
{
"term": {
"message": "this is a test"
}
}
]
}
}
}
assert result == expected_query
def test__query_no_field(self):
result = bodyBuilder().query('match_all')
expected_query = {
'match_all': {}
}
assert result.getQuery() == expected_query
def test__query_key_value(self):
result = bodyBuilder().query('term', 'user', 'kimchy')
expected_query = {
'term': {
'user': '******'
}
}
assert result.getQuery() == expected_query
def test__exist_user(self):
result = bodyBuilder().query('exists', 'user')
expected_query = {
'exists': {
'field': 'user'
}
}
assert result.getQuery() == expected_query
def test__from(self):
result = bodyBuilder() \
.from_(10) \
.build()
expected_query = {
"from": 10
}
assert result == expected_query
def test__size(self):
result = bodyBuilder() \
.size(10) \
.build()
expected_query = {
"size": 10
}
assert result == expected_query
def test__rawOption(self):
result = bodyBuilder() \
.rawOption('a', {'b': 'c'}) \
.build()
expected_query = {
'a': {
'b': 'c'
}
}
assert result == expected_query
def test__basic_sort(self):
result = bodyBuilder().sort('timestamp').build()
expected_query = {
"sort": [
{
'timestamp': {
"order": 'asc'
}
}
]
}
assert result == expected_query
def test__aggs_cardinality(self):
result = bodyBuilder() \
.aggregation('cardinality', 'author')
expected_query = {
'agg_cardinality_author': {
'cardinality': {
'field': 'author'
}
}
}
assert result.getAggregations() == expected_query
def test__query_field_object(self):
result = bodyBuilder() \
.query('range', 'date', {'gt': 'now-1d'})
expected_query = {
'range': {
'date': {
'gt': 'now-1d'
}
}
}
assert result.getQuery() == expected_query
def test__aggs_avg(self):
result = bodyBuilder() \
.aggregation('avg', 'grade')
expected_query = {
'agg_avg_grade': {
'avg': {
'field': 'grade'
}
}
}
assert result.getAggregations() == expected_query
def test__query_filter_aggs(self):
result = bodyBuilder() \
.query('match', 'message', 'this is a test') \
.filter('term', 'user', 'kimchy') \
.filter('term', 'user', 'herald') \
.orFilter('term', 'user', 'johnny') \
.notFilter('term', 'user', 'cassie') \
.aggregation('terms', 'user') \
.build()
expected_query = {
"query": {
"bool": {
"must": {
"match": {
"message": "this is a test"
}
},
"filter": [{
"term": {
"user": "******"
}
}, {
"term": {
"user": "******"
}
}],
"should": [{
"term": {
"user": "******"
}
}],
"must_not": [{
"term": {
"user": "******"
}
}]
}
},
"aggs": {
"agg_terms_user": {
"terms": {
"field": "user"
}
}
}
}
assert result == expected_query
def test__chained_nested(self):
result = bodyBuilder() \
.query('match', 'title', 'eggs') \
.query('nested', 'path', 'comments',
{
'score_mode': 'max'
},
lambda q: q
.query('match', 'comments.name', 'john')
.query('match', 'comments.age', 28)
)
expected_query = {
'bool': {
'must': [
{
'match': {
'title': 'eggs'
}
},
{
'nested': {
'path': 'comments',
'score_mode': 'max',
'query': {
'bool': {
'must': [
{
'match': {
'comments.name': 'john'
}
},
{
'match': {
'comments.age': 28
}
}
]
}
}
}
}
]
}
}
assert result.getQuery() == expected_query
def test__constant_score(self):
result = bodyBuilder() \
.filter('constant_score',
lambda f: f.filter('term', 'field', 'value')
)
expected_query = {
'constant_score': {
'filter': {
'term': {
'field': 'value'
}
}
}
}
assert result.getFilter() == expected_query
def test__percentiles_aggregation(self):
result = bodyBuilder() \
.aggregation('percentiles', 'load_time',
{
'percents': [1, 50, 99]
})
expected_query = {
'agg_percentiles_load_time': {
'percentiles': {
'field': 'load_time',
'percents': [1, 50, 99]
}
}
}
assert result.getAggregations() == expected_query
def test__basic_filter(self):
result = bodyBuilder() \
.filter('term', 'user', 'kimchy') \
.build()
expected_query = {
'query': {
'bool': {
'filter': {
'term': {
'user': '******'
}
}
}
}
}
assert result == expected_query
def test__query_and_filter(self):
result = bodyBuilder() \
.query('exists', 'user') \
.filter('term', 'user', 'kimchy')
expected_query = {
'exists': {
'field': 'user'
}
}
expected_filter = {
"term": {
"user": '******'
}
}
assert result.build()['query']['bool']['must'] == expected_query
assert result.build()['query']['bool']['filter'] == expected_filter
def test__not_filter(self):
result = bodyBuilder() \
.notFilter('term', 'user', 'kimchy') \
.build()
expected_query = {
'query': {
'bool': {
'must_not': [{
'term': {
'user': '******'
}
}]
}
}
}
assert result == expected_query
def test__nested_queries(self):
result = bodyBuilder() \
.query('nested', 'path', 'obj1',
lambda q: q.query('match', 'obj1.color', 'blue')
)
expected_query = {
'nested': {
'path': 'obj1',
'query': {
'match': {
'obj1.color': 'blue'
}
}
}
}
assert result.getQuery() == expected_query
def test__nest_bool_merged_queries(self):
result = bodyBuilder() \
.query('nested', 'path', 'obj1',
{
'score_mode': 'avg'
},
lambda q: q
.query('match', 'obj1.name', 'blue')
.query('range', 'obj1.count',
{
'gt': 5
}
)
)
expected_query = {
'nested': {
'path': 'obj1',
'score_mode': 'avg',
'query': {
'bool': {
'must': [
{
'match': {
'obj1.name': 'blue'
}
},
{
'range': {
'obj1.count': {
'gt': 5
}
}
}
]
}
}
}
}
assert result.getQuery() == expected_query
def test__advanced_sort(self):
result = bodyBuilder() \
.sort('A', 'desc') \
.sort('B', 'desc') \
.sort('A') \
.build()
expected_query = {
"sort": [
{
"A": {
"order": "asc"
}
},
{
"B": {
"order": "desc"
}
}
]
}
assert result == expected_query
def test__query_with_more_options(self):
result = bodyBuilder() \
.query('geo_distance',
'point',
{
'lat': 40,
'lon': 20
},
{
'distance': '12km'
}
)
expected_query = {
'geo_distance': {
'point': {
'lat': 40,
'lon': 20
},
'distance': '12km'
}
}
assert result.getQuery() == expected_query
def test__filtered_query(self):
result = bodyBuilder() \
.query('match', 'message', 'this is a test') \
.filter('term', 'user', 'kimchy') \
.build()
expected_query = {
'query': {
'bool': {
'must': {
'match': {
'message': 'this is a test'
}
},
'filter': {
'term': {
'user': '******'
}
}
}
}
}
assert result == expected_query
def test__bigass_query(self):
result = bodyBuilder() \
.query('constant_score',
lambda q: q
.orFilter('term', 'created_by.user_id', 'abc')
.orFilter(
'nested', 'path', 'doc_meta',
lambda q1: q1.
query(
'constant_score',
lambda q2: q2
.filter('term',
'doc_meta.user_id',
'abc')
)
)
.orFilter('nested', 'path', 'tests',
lambda q1: q1
.query('constant_score',
lambda q2: q2
.filter(
'term',
'tests.created_by.user_id',
'abc')
)
)
)
expected_query = {
"constant_score": {
"query": { # originally filter?
"bool": {
"should": [
{
"term": {
"created_by.user_id": "abc"
}
},
{
"nested": {
"path": "doc_meta",
"query": {
"constant_score": {
"filter": {
"term": {
"doc_meta.user_id": "abc"
}
}
}
}
}
},
{
"nested": {
"path": "tests",
"query": {
"constant_score": {
"filter": {
"term": {
"tests.created_by.user_id": "abc" # noqa 501
}
}
}
}
}
}
]
}
}
}
}
assert result.getQuery() == expected_query
def test__complex_dynamic_filter(self):
result = bodyBuilder() \
.orFilter('bool',
lambda f: f
.filter('terms', 'tags', ['Popular'])
.filter('terms', 'brands', ['A', 'B'])
) \
.orFilter('bool',
lambda f: f
.filter('terms', 'tags', ['Emerging'])
.filter('terms', 'brands', ['C'])
) \
.orFilter('bool',
lambda f: f
.filter('terms', 'tags', ['Rumor'])
.filter('terms', 'companies', ['A', 'C', 'D'])
) \
.build()
expected_query = {
"query": {
"bool": {
"should": [
{
"bool": {
"filter": [{
"terms": {
"tags": ["Popular"]
}
}, {
"terms": {
"brands": ["A", "B"]
}
}]
}
},
{
"bool": {
"filter": [{
"terms": {
"tags": ["Emerging"]
}
}, {
"terms": {
"brands": ["C"]
}
}]
}
},
{
"bool": {
"filter": [
{
"terms": {
"tags": ["Rumor"]
}
},
{
"terms": {
"companies": ["A", "C", "D"]
}
}
]
}
}
]
}
}
}
assert result == expected_query
