def test_pre_filter_between_operator(self):
column = Mock()
column.name = 'dob_field'
column.between.return_value = 'foo'
table = Mock()
table.c = [column]
value = {
'operator': 'between',
'operand': ['2017-03-13', '2017-04-11']
}
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'dob_field',
'slug': 'dob_slug',
'datatype': 'date',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
filter_value = PreFilterValue(filter_, value)
self.assertEqual(filter_value.to_sql_values(), {
'dob_slug_0': '2017-03-13',
'dob_slug_1': '2017-04-11'
})
self.assertEqual(filter_value.to_sql_filter().build_expression(table),
'foo')
def test_pre_filter_dyn_operator(self):
from corehq.apps.reports.daterange import get_daterange_start_end_dates
column = Mock()
column.name = 'dob_field'
column.between.return_value = 'foo'
table = Mock()
table.c = [column]
start_date, end_date = get_daterange_start_end_dates('lastmonth')
value = {'operator': 'lastmonth', 'operand': [None]}
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'dob_field',
'slug': 'dob_slug',
'datatype': 'array',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
filter_value = PreFilterValue(filter_, value)
self.assertEqual(filter_value.to_sql_values(), {
'dob_slug_0': str(start_date),
'dob_slug_1': str(end_date),
})
self.assertEqual(filter_value.to_sql_filter().build_expression(table),
'foo')
def test_pre_filter_dyn_operator(self):
from corehq.apps.reports.daterange import get_daterange_start_end_dates
column = Mock()
column.name = 'dob_field'
column.between.return_value = 'foo'
table = Mock()
table.c = [column]
start_date, end_date = get_daterange_start_end_dates('lastmonth')
value = {'operator': 'lastmonth', 'operand': [None]}
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'dob_field',
'slug': 'dob_slug',
'datatype': 'array',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
filter_value = PreFilterValue(filter_, value)
self.assertEqual(filter_value.to_sql_values(), {
'dob_slug_0': str(start_date),
'dob_slug_1': str(end_date),
})
self.assertEqual(filter_value.to_sql_filter().build_expression(table), 'foo')
def test_filter_value(self):
filter = ReportFilter.wrap({
"type": "location_drilldown",
"field": "block_id",
"slug": "block_id_drill",
"display": "Drilldown by Location",
})
filter_value = LocationDrilldownFilterValue(filter, ['Middlesex'])
self.assertDictEqual(filter_value.to_sql_values(), {'block_id_drill_0': 'Middlesex'})
def from_spec(cls, spec):
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
return ConfigurableReportDataSource(
domain=spec.domain,
config_or_config_id=spec.config_id,
filters=[ReportFilter.wrap(f) for f in spec.filters],
aggregation_columns=spec.aggregation_columns,
columns=spec.report_columns,
)
def from_spec(cls, spec):
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
order_by = [(o['field'], o['order']) for o in spec.sort_expression]
return ConfigurableReportDataSource(
domain=spec.domain,
config_or_config_id=spec.config_id,
filters=[ReportFilter.wrap(f) for f in spec.filters],
aggregation_columns=spec.aggregation_columns,
columns=spec.report_columns,
order_by=order_by,
)
def test_numeric_filter_value(self):
filter = ReportFilter.wrap({
"type": "numeric",
"field": "number_of_children_field",
"slug": "number_of_children_slug",
"display": "Number of Children",
})
NumericFilterValue(filter, None)
NumericFilterValue(filter, {'operator': '<', 'operand': 3})
with self.assertRaises(AssertionError):
NumericFilterValue(filter, {'operator': 'sql injection', 'operand': 3})
def test_numeric_filter_value(self):
filter = ReportFilter.wrap({
"type": "numeric",
"field": "number_of_children_field",
"slug": "number_of_children_slug",
"display": "Number of Children",
})
NumericFilterValue(filter, None)
NumericFilterValue(filter, {'operator': '<', 'operand': 3})
with self.assertRaises(AssertionError):
NumericFilterValue(filter, {'operator': 'sql injection', 'operand': 3})
def test_pre_filter_value(self):
pre_value = 'yes'
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': pre_value
})
filter_value = PreFilterValue(filter_, {'operand': pre_value})
self.assertEqual(filter_value.to_sql_values(), {'at_risk_slug': 'yes'})
def test_pre_filter_value(self):
pre_value = 'yes'
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': pre_value
})
filter_value = PreFilterValue(filter_, {'operand': pre_value})
self.assertEqual(filter_value.to_sql_values(), {'at_risk_slug': 'yes'})
def _computed_dates(self, actual_startdate, actual_enddate):
filter = ReportFilter(compare_as_string=False,
field=u'submission_date',
slug=u'submitted_on',
type=u'date',
required=False)
value = DateSpan(actual_startdate, actual_enddate)
filter_value = DateFilterValue(filter, value)
computed_values = filter_value.to_sql_values()
startdate = computed_values['%s_startdate' % filter.slug]
enddate = computed_values['%s_enddate' % filter.slug]
return startdate, enddate
def from_spec(cls, spec, include_prefilters=False):
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
order_by = [(o['field'], o['order']) for o in spec.sort_expression]
filters = spec.filters if include_prefilters else spec.filters_without_prefilters
return ConfigurableReportDataSource(
domain=spec.domain,
config_or_config_id=spec.config_id,
filters=[ReportFilter.wrap(f) for f in filters],
aggregation_columns=spec.aggregation_columns,
columns=spec.report_columns,
order_by=order_by,
)
def test_pre_filter_invalid_operator(self):
value = {'operator': 'in', 'operand': 'no'} # "in" is invalid for scalar operand
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
filter_value = PreFilterValue(filter_, value)
with self.assertRaises(TypeError):
filter_value.to_sql_filter()
def from_spec(cls, spec, include_prefilters=False, backend=None):
from corehq.apps.userreports.reports.data_source import ConfigurableReportDataSource
order_by = [(o['field'], o['order']) for o in spec.sort_expression]
filters = spec.filters if include_prefilters else spec.filters_without_prefilters
return ConfigurableReportDataSource(
domain=spec.domain,
config_or_config_id=spec.config_id,
filters=[ReportFilter.wrap(f) for f in filters],
aggregation_columns=spec.aggregation_columns,
columns=spec.report_columns,
order_by=order_by,
backend=backend,
)
def test_pre_filter_invalid_operator(self):
value = {'operator': 'in', 'operand': 'no'} # "in" is invalid for scalar operand
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
filter_value = PreFilterValue(filter_, value)
with self.assertRaises(TypeError):
filter_value.to_sql_filter()
def get_query_value(year, quarter):
spec = {
"type": "quarter",
"field": "modified_on_field",
"slug": "my_slug",
"display": "date Modified",
}
reports_core_filter = ReportFilterFactory.from_spec(spec)
reports_core_value = reports_core_filter.get_value({
"my_slug-year": year,
"my_slug-quarter": quarter
})
filter = ReportFilter.wrap(spec)
return filter.create_filter_value(reports_core_value).to_sql_values()
def get_query_value(year, quarter):
spec = {
"type": "quarter",
"field": "modified_on_field",
"slug": "my_slug",
"display": "date Modified",
}
reports_core_filter = ReportFilterFactory.from_spec(spec)
reports_core_value = reports_core_filter.get_value({
"my_slug-year": year,
"my_slug-quarter": quarter
})
filter = ReportFilter.wrap(spec)
return filter.create_filter_value(reports_core_value).to_sql_values()
def get_query_value(compare_as_string):
spec = {
"type": "date",
"field": "modified_on_field",
"slug": "my_slug",
"display": "date Modified",
"compare_as_string": compare_as_string,
}
reports_core_filter = ReportFilterFactory.from_spec(spec)
reports_core_value = reports_core_filter.get_value({
"my_slug-start": "2015-06-07",
"my_slug-end": "2015-06-08",
})
filter = ReportFilter.wrap(spec)
return filter.create_filter_value(reports_core_value).to_sql_values()
def test_pre_filter_value_null(self):
column = Mock()
column.name = 'at_risk_field'
column.is_.return_value = 'foo'
table = Mock()
table.c = [column]
pre_value = None
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': pre_value
})
filter_value = PreFilterValue(filter_, {'operand': pre_value})
self.assertEqual(filter_value.to_sql_values(), {})
self.assertEqual(filter_value.to_sql_filter().build_expression(table), 'foo')
def test_pre_filter_value_array(self):
column = Mock()
column.name = 'at_risk_field'
column.in_.return_value = 'foo'
table = Mock()
table.c = [column]
pre_value = ['yes', 'maybe']
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'array',
'pre_value': pre_value
})
filter_value = PreFilterValue(filter_, {'operand': pre_value})
self.assertEqual(filter_value.to_sql_values(), {'at_risk_slug_0': 'yes', 'at_risk_slug_1': 'maybe'})
self.assertEqual(filter_value.to_sql_filter().build_expression(table), 'foo')
def test_pre_filter_value_null(self):
column = Mock()
column.name = 'at_risk_field'
column.is_.return_value = 'foo'
table = Mock()
table.c = [column]
pre_value = None
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': pre_value
})
filter_value = PreFilterValue(filter_, {'operand': pre_value})
self.assertEqual(filter_value.to_sql_values(), {})
self.assertEqual(filter_value.to_sql_filter().build_expression(table), 'foo')
def test_pre_filter_value_array(self):
column = Mock()
column.name = 'at_risk_field'
column.in_.return_value = 'foo'
table = Mock()
table.c = [column]
pre_value = ['yes', 'maybe']
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'array',
'pre_value': pre_value
})
filter_value = PreFilterValue(filter_, {'operand': pre_value})
self.assertEqual(filter_value.to_sql_values(), {'at_risk_slug_0': 'yes', 'at_risk_slug_1': 'maybe'})
self.assertEqual(filter_value.to_sql_filter().build_expression(table), 'foo')
def get_query_value(compare_as_string):
spec = {
"type": "date",
"field": "modified_on_field",
"slug": "my_slug",
"display": "date Modified",
"compare_as_string": compare_as_string,
}
reports_core_filter = ReportFilterFactory.from_spec(spec)
reports_core_value = reports_core_filter.get_value({
"my_slug-start": "2015-06-07",
"my_slug-end": "2015-06-08",
"date_range_inclusive": True,
})
filter = ReportFilter.wrap(spec)
return filter.create_filter_value(reports_core_value).to_sql_values()
def test_pre_filter_distinct_from_operator(self):
column = Mock()
column.name = 'at_risk_field'
column.is_distinct_from.return_value = 'foo'
table = Mock()
table.c = [column]
value = {'operator': 'distinct from', 'operand': 'test'}
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
filter_value = PreFilterValue(filter_, value)
self.assertEqual(filter_value.to_sql_values(), {'at_risk_slug': 'test'})
self.assertEqual(filter_value.to_sql_filter().build_expression(table), 'foo')
def test_pre_filter_between_operator(self):
column = Mock()
column.name = 'dob_field'
column.between.return_value = 'foo'
table = Mock()
table.c = [column]
value = {'operator': 'between', 'operand': ['2017-03-13', '2017-04-11']}
filter_ = ReportFilter.wrap({
'type': 'pre',
'field': 'dob_field',
'slug': 'dob_slug',
'datatype': 'date',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
filter_value = PreFilterValue(filter_, value)
self.assertEqual(filter_value.to_sql_values(), {'dob_slug_0': '2017-03-13', 'dob_slug_1': '2017-04-11'})
self.assertEqual(filter_value.to_sql_filter().build_expression(table), 'foo')
