def test_nested_filtered_aggregator(self):
filter1 = filters.Filter(dimension='dim1', value='val')
filter2 = filters.Filter(dimension='dim2', value='val')
agg = aggregators.filtered(filter1,
aggregators.filtered(filter2, aggregators.count('metric1')))
actual = aggregators.build_aggregators({'agg_name': agg})
# the innermost aggregation must have 'agg_name'
expected = [{
'type': 'filtered',
'aggregator': {
'type': 'filtered',
'aggregator': {'fieldName': 'metric1', 'type': 'count', 'name': 'agg_name'},
'filter': {'dimension': 'dim2', 'value': 'val', 'type': 'selector'}},
'filter': {'dimension': 'dim1', 'value': 'val', 'type': 'selector'}
}]
assert expected == actual
def test_and_filter(self):
f1 = filters.Filter(dimension='dim1', value='val1')
f2 = filters.Filter(dimension='dim2', value='val2')
actual = filters.Filter.build_filter(f1 & f2)
expected = {
'type':
'and',
'fields': [{
'type': 'selector',
'dimension': 'dim1',
'value': 'val1'
}, {
'type': 'selector',
'dimension': 'dim2',
'value': 'val2'
}]
}
assert actual == expected
def test_in_filter(self):
actual = filters.Filter.build_filter(
filters.Filter(type='in',
dimension='dim',
values=['val1', 'val2', 'val3']))
expected = {
'type': 'in',
'dimension': 'dim',
'values': ['val1', 'val2', 'val3']
}
assert actual == expected
def test_javascript_filter(self):
actual = filters.Filter.build_filter(
filters.Filter(type='javascript',
dimension='dim',
function='function(x){return true}'))
expected = {
'type': 'javascript',
'dimension': 'dim',
'function': 'function(x){return true}'
}
assert actual == expected
def test_nested_not_or_filter(self):
f1 = filters.Filter(dimension='dim1', value='val1')
f2 = filters.Filter(dimension='dim2', value='val2')
actual = filters.Filter.build_filter(~(f1 | f2))
expected = {
'type': 'not',
'field': {
'type':
'or',
'fields': [{
'type': 'selector',
'dimension': 'dim1',
'value': 'val1'
}, {
'type': 'selector',
'dimension': 'dim2',
'value': 'val2'
}]
}
}
assert actual == expected
def test_build_filtered_aggregator(self):
filter_ = filters.Filter(dimension='dim', value='val')
agg_input = {
'agg1': aggregators.filtered(filter_,
aggregators.count('metric1')),
'agg2': aggregators.filtered(filter_,
aggregators.longsum('metric2')),
'agg3': aggregators.filtered(filter_,
aggregators.doublesum('metric3')),
'agg4': aggregators.filtered(filter_,
aggregators.min('metric4')),
'agg5': aggregators.filtered(filter_,
aggregators.max('metric5')),
'agg6': aggregators.filtered(filter_,
aggregators.hyperunique('metric6')),
'agg7': aggregators.filtered(filter_,
aggregators.cardinality('dim1')),
'agg8': aggregators.filtered(filter_,
aggregators.cardinality(['dim1', 'dim2'], by_row=True)),
}
base = {
'type': 'filtered',
'filter': {
'type': 'selector',
'dimension': 'dim',
'value': 'val'
}
}
aggs = [
{'name': 'agg1', 'type': 'count', 'fieldName': 'metric1'},
{'name': 'agg2', 'type': 'longSum', 'fieldName': 'metric2'},
{'name': 'agg3', 'type': 'doubleSum', 'fieldName': 'metric3'},
{'name': 'agg4', 'type': 'min', 'fieldName': 'metric4'},
{'name': 'agg5', 'type': 'max', 'fieldName': 'metric5'},
{'name': 'agg6', 'type': 'hyperUnique', 'fieldName': 'metric6'},
{'name': 'agg7', 'type': 'cardinality', 'fieldNames': ['dim1'], 'byRow': False},
{'name': 'agg8', 'type': 'cardinality', 'fieldNames': ['dim1', 'dim2'], 'byRow': True},
]
expected = []
for agg in aggs:
exp = deepcopy(base)
exp.update({'aggregator': agg})
expected.append(exp)
built_agg = aggregators.build_aggregators(agg_input)
expected = sorted(built_agg, key=lambda k: itemgetter('name')(
itemgetter('aggregator')(k)))
actual = sorted(expected, key=lambda k: itemgetter('name')(
itemgetter('aggregator')(k)))
assert expected == actual
def test_and_filter_multiple(self):
f1 = filters.Filter(dimension='dim1', value='val1')
f2 = filters.Filter(dimension='dim2', value='val2')
f3 = filters.Filter(dimension='dim3', value='val3')
filter = filters.Filter(type='and', fields=[f1, f2, f3])
actual = filters.Filter.build_filter(filter)
expected = {
'type':
'and',
'fields': [{
'type': 'selector',
'dimension': 'dim1',
'value': 'val1'
}, {
'type': 'selector',
'dimension': 'dim2',
'value': 'val2'
}, {
'type': 'selector',
'dimension': 'dim3',
'value': 'val3'
}]
}
assert actual == expected
def test_not_filter(self):
f = ~filters.Filter(dimension='dim', value='val')
actual = filters.Filter.build_filter(f)
# Call `build_filter` twice to make sure it does not
# change the passed filter object argument `f`.
actual = filters.Filter.build_filter(f)
expected = {
'type': 'not',
'field': {
'type': 'selector',
'dimension': 'dim',
'value': 'val'
}
}
assert actual == expected
def test_filtered_aggregator(self):
filter_ = filters.Filter(dimension='dim', value='val')
aggs = [aggregators.count('metric1'),
aggregators.longsum('metric2'),
aggregators.doublesum('metric3'),
aggregators.min('metric4'),
aggregators.max('metric5'),
aggregators.hyperunique('metric6'),
aggregators.cardinality('dim1'),
aggregators.cardinality(['dim1', 'dim2'], by_row=True)]
for agg in aggs:
expected = {
'type': 'filtered',
'filter': {
'type': 'selector',
'dimension': 'dim',
'value': 'val'
},
'aggregator': agg
}
actual = aggregators.filtered(filter_, agg)
assert actual == expected
def test_selector_filter(self):
actual = filters.Filter.build_filter(
filters.Filter(dimension='dim', value='val'))
expected = {'type': 'selector', 'dimension': 'dim', 'value': 'val'}
assert actual == expected
def test_invalid_filter(self):
with pytest.raises(NotImplementedError):
filters.Filter(type='invalid', dimension='dim', value='val')
def test_nested_mix_filter(self):
f1 = filters.Filter(dimension='dim1', value='val1')
f2 = filters.Filter(dimension='dim2', value='val2')
f3 = filters.Filter(dimension='dim3', value='val3')
f4 = filters.Filter(dimension='dim4', value='val4')
f5 = filters.Filter(dimension='dim5', value='val5')
f6 = filters.Filter(dimension='dim6', value='val6')
f7 = filters.Filter(dimension='dim7', value='val7')
f8 = filters.Filter(dimension='dim8', value='val8')
actual = filters.Filter.build_filter(f1 & ~f2 & f3
& (f4 | ~f5 | f6 | (f7 & ~f8)))
expected = {
'fields': [{
'dimension': 'dim1',
'type': 'selector',
'value': 'val1'
}, {
'field': {
'dimension': 'dim2',
'type': 'selector',
'value': 'val2'
},
'type': 'not'
}, {
'dimension': 'dim3',
'type': 'selector',
'value': 'val3'
}, {
'fields': [{
'dimension': 'dim4',
'type': 'selector',
'value': 'val4'
}, {
'field': {
'dimension': 'dim5',
'type': 'selector',
'value': 'val5'
},
'type': 'not'
}, {
'dimension': 'dim6',
'type': 'selector',
'value': 'val6'
}, {
'fields': [{
'dimension': 'dim7',
'type': 'selector',
'value': 'val7'
}, {
'field': {
'dimension': 'dim8',
'type': 'selector',
'value': 'val8'
},
'type': 'not'
}],
'type':
'and'
}],
'type':
'or'
}],
'type':
'and'
}
assert actual == expected