def test_nesting_aggregations(self):
json_output = {
"query": {
"filtered": {
"filter": {
"and": [{
"match_all": {}
}]
},
"query": {
"match_all": {}
}
}
},
"aggs": {
"users": {
"terms": {
"field": "user_id",
"size": SIZE_LIMIT
},
"aggs": {
"closed": {
"filter": {
"term": {
"closed": True
}
}
}
}
},
"total_by_status": {
"filters": {
"filters": {
"closed": {
"term": {
"closed": True
}
},
"open": {
"term": {
"closed": False
}
}
}
}
}
},
"size": SIZE_LIMIT
}
query = HQESQuery('cases').aggregations([
TermsAggregation("users", 'user_id').aggregation(
FilterAggregation('closed', filters.term('closed', True))),
FiltersAggregation('total_by_status').add_filter(
'closed',
filters.term('closed',
True)).add_filter('open',
filters.term('closed', False))
])
self.checkQuery(query, json_output)
def aggregation(self):
if self.expand_value is None:
return MissingAggregation(
self.es_alias, self.data_source_field
)
return FilterAggregation(
self.es_alias, filters.term(self.data_source_field, self.expand_value)
)
def test_result_parsing_basic(self):
query = HQESQuery('cases').aggregations([
FilterAggregation('closed', filters.term('closed', True)),
FilterAggregation('open', filters.term('closed', False))
])
raw_result = {
"aggregations": {
"closed": {
"doc_count": 1
},
"open": {
"doc_count": 2
}
}
}
queryset = ESQuerySet(raw_result, deepcopy(query))
self.assertEqual(queryset.aggregations.closed.doc_count, 1)
self.assertEqual(queryset.aggregations.open.doc_count, 2)
def expand_column(report_column, distinct_values, lang):
columns = []
for index, val in enumerate(distinct_values):
es_alias = u"{}_dash_{}".format(report_column.column_id, index)
ui_alias = u"{}-{}".format(report_column.column_id, index)
# todo aggregation only supports # of matches
columns.append(
UCRExpandEsDatabaseSubcolumn(
u"{}-{}".format(report_column.get_header(lang), val),
expand_value=val,
aggregation=FilterAggregation(
es_alias, filters.term(report_column.field, val)),
es_alias=es_alias,
ui_alias=ui_alias,
sortable=False,
data_slug=u"{}-{}".format(report_column.column_id, index),
format_fn=report_column.get_format_fn(),
help_text=report_column.description))
return columns
def test_result_parsing_complex(self):
query = HQESQuery('cases').aggregation(
TermsAggregation("users", 'user_id').aggregation(
FilterAggregation('closed', filters.term(
'closed', True))).aggregation(
FilterAggregation('open', filters.term(
'closed', False)))).aggregation(
RangeAggregation('by_date', 'name', [
AggregationRange(end='c'),
AggregationRange(start='f'),
AggregationRange(start='k', end='p')
]))
raw_result = {
"aggregations": {
"users": {
"buckets": [{
"closed": {
"doc_count": 0
},
"doc_count": 2,
"key": "user1",
"open": {
"doc_count": 2
}
}],
"doc_count_error_upper_bound":
0,
"sum_other_doc_count":
0
},
"by_date": {
"buckets": {
"*-c": {
"to": "c",
"doc_count": 3
},
"f-*": {
"from": "f",
"doc_count": 8
},
"k-p": {
"from": "k",
"to": "p",
"doc_count": 6
}
}
}
},
}
queryset = ESQuerySet(raw_result, deepcopy(query))
self.assertEqual(queryset.aggregations.users.buckets.user1.key,
'user1')
self.assertEqual(queryset.aggregations.users.buckets.user1.doc_count,
2)
self.assertEqual(
queryset.aggregations.users.buckets.user1.closed.doc_count, 0)
self.assertEqual(
queryset.aggregations.users.buckets.user1.open.doc_count, 2)
self.assertEqual(
queryset.aggregations.users.buckets_dict['user1'].open.doc_count,
2)
self.assertEqual(queryset.aggregations.users.counts_by_bucket(),
{'user1': 2})
self.assertEqual(queryset.aggregations.by_date.counts_by_bucket(), {
'*-c': 3,
'f-*': 8,
'k-p': 6,
})
