def test_no_type(self):
with self.assertRaises(BadSpecError):
ReportFilterFactory.from_spec({
"field": "some_field",
"slug": "some_slug",
"display": "Some display name"
})
def test_missing_slug(self):
with self.assertRaises(BadSpecError):
ReportFilterFactory.from_spec({
"type": "date",
"field": "some_field",
"display": "Some display name"
})
def test_ancestor_expression_missing_location_type(self):
with self.assertRaises(BadSpecError):
ReportFilterFactory.from_spec({
"type": "location_drilldown",
"field": "block_id",
"slug": "block_id_drill",
"display": "Drilldown by Location",
"ancestor_expression": {
'field': 'state_id',
# missing 'location_type': 'state',
}
})
def test_filter(self):
report = ReportConfiguration(domain=self.domain)
ui_filter = ReportFilterFactory.from_spec({
"slug": "block_id_drill",
"type": "location_drilldown",
"field": "block_id",
"display": "Drilldown by Location",
"include_descendants": False,
}, report)
self.assertEqual(type(ui_filter), LocationDrilldownFilter)
# test filter_context
filter_context_expected = {
'input_name': 'block_id_drill',
'loc_id': None,
'hierarchy': location_hierarchy_config(self.domain),
'locations': load_locs_json(self.domain),
'loc_url': '/a/{}/api/v0.5/location_internal/'.format(self.domain),
'max_drilldown_levels': 99
}
self.assertDictEqual(ui_filter.filter_context(self.user), filter_context_expected)
# test include_descendants=False
self.assertListEqual(
ui_filter.value(
**{ui_filter.name: self.locations.get('Middlesex').location_id, REQUEST_USER_KEY: self.user}
),
[self.locations.get('Middlesex').location_id]
)
# test include_descendants=True
ui_filter = ReportFilterFactory.from_spec({
"slug": "block_id_drill",
"type": "location_drilldown",
"field": "block_id",
"display": "Drilldown by Location",
"include_descendants": True,
}, report)
self.assertListEqual(
ui_filter.value(
**{ui_filter.name: self.locations.get('Middlesex').location_id, REQUEST_USER_KEY: self.user}
),
[self.locations.get(name).location_id
for name in ['Middlesex', 'Cambridge', 'Somerville']]
)
def test_ancestor_expression(self):
filter = {
"type": "dynamic_choice_list",
"slug": "dynoslug",
"field": "dynofield",
"display": "Dynamic choice list",
"show_all": False,
"choice_provider": {"type": "user"},
"ancestor_expression": {
"field": "state_id",
"location_type": "state",
}
}
with self.assertRaises(BadSpecError):
ReportFilterFactory.from_spec(filter)
filter['choice_provider']['type'] = 'location'
ReportFilterFactory.from_spec(filter)
def test_date_filter(self):
filter = ReportFilterFactory.from_spec({
"type": "date",
"field": "modified_on_field",
"slug": "modified_on_slug",
"display": "Date Modified"
})
self.assertEqual(DatespanFilter, type(filter))
self.assertEqual('modified_on_slug', filter.name)
self.assertEqual('Date Modified', filter.label)
def test_numeric_filter(self):
filter = ReportFilterFactory.from_spec({
"type": "numeric",
"field": "number_of_children_field",
"slug": "number_of_children_slug",
"display": "Number of Children",
})
self.assertEqual(NumericFilter, type(filter))
self.assertEqual("number_of_children_slug", filter.name)
self.assertEqual("Number of Children", filter.label)
def test_pre_filter(self):
filter_ = ReportFilterFactory.from_spec({
'type': 'pre',
'field': 'at_risk_field',
'slug': 'at_risk_slug',
'datatype': 'string',
'pre_value': 'true'
})
self.assertEqual(type(filter_), PreFilter)
self.assertEqual(filter_.name, 'at_risk_slug')
self.assertEqual(filter_.default_value(), {'operator': '=', 'operand': 'true'})
def test_pre_filter_operator(self):
value = {'operator': '<=', 'operand': '99'}
filter_ = ReportFilterFactory.from_spec({
'type': 'pre',
'field': 'risk_indicator_field',
'slug': 'risk_indicator_slug',
'datatype': 'integer',
'pre_value': value['operand'],
'pre_operator': value['operator'],
})
self.assertEqual(type(filter_), PreFilter)
self.assertEqual(filter_.default_value(), {'operator': '<=', 'operand': 99}) # operand will be coerced
def test_translation(self):
shared_conf = {
"type": "date",
"field": "some_field",
"slug": "some_slug",
}
# Plain string
conf = {"display": "foo"}
conf.update(shared_conf)
filter = ReportFilterFactory.from_spec(conf)
self.assertEqual(filter.context(None, lang=None)['label'], "foo")
self.assertEqual(filter.context(None, lang="fr")['label'], "foo")
# Translation
conf = {"display": {"en": "english", "fr": "french"}}
conf.update(shared_conf)
filter = ReportFilterFactory.from_spec(conf)
self.assertEqual(filter.context(None, lang=None)['label'], "english")
self.assertEqual(filter.context(None, lang="fr")['label'], "french")
self.assertEqual(filter.context(None, lang="en")['label'], "english")
self.assertEqual(filter.context(None, lang="es")['label'], "english")
def test_integer_datatype(self):
self.filter_spec['datatype'] = 'integer'
filter = ReportFilterFactory.from_spec(self.filter_spec)
tests = (
('1', 1),
('1.2', 1),
('hello', None),
)
for input, expected in tests:
choices = filter.value(dynoslug=input)
self.assertEqual(len(choices), 1)
self.assertEqual(expected, choices[0].value)
self.assertEqual(input, choices[0].display)
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
})
return create_filter_value(spec, reports_core_value).to_sql_values()
def report_config_to_v2_fixture(report_config, restore_user):
domain = restore_user.domain
report, data_source = BaseReportFixturesProvider._get_report_and_data_source(
report_config.report_id, domain)
# apply filters specified in report module
all_filter_values = {
filter_slug: restore_user.get_ucr_filter_value(filter, report.get_ui_filter(filter_slug))
for filter_slug, filter in report_config.filters.items()
}
# apply all prefilters
prefilters = [ReportFilterFactory.from_spec(p, report) for p in report.prefilters]
prefilter_values = {prefilter.name: prefilter.value() for prefilter in prefilters}
all_filter_values.update(prefilter_values)
# filter out nulls
filter_values = {
filter_slug: filter_value for filter_slug, filter_value in all_filter_values.items()
if filter_value is not None
}
defer_filters = [
report.get_ui_filter(filter_slug)
for filter_slug, filter_value in all_filter_values.items()
if filter_value is None and is_valid_mobile_select_filter_type(report.get_ui_filter(filter_slug))
]
data_source.set_filter_values(filter_values)
data_source.set_defer_fields([f.field for f in defer_filters])
filter_options_by_field = defaultdict(set)
rows_elem = ReportFixturesProviderV2._get_v2_report_elem(
data_source,
{f.field for f in defer_filters},
filter_options_by_field,
_last_sync_time(domain, restore_user.user_id),
)
filters_elem = BaseReportFixturesProvider._get_filters_elem(
defer_filters, filter_options_by_field, restore_user._couch_user)
report_filter_elem = E.fixture(id=ReportFixturesProviderV2._report_filter_id(report_config.uuid))
report_filter_elem.append(filters_elem)
if (report_config.report_id in settings.UCR_COMPARISONS and
random.randint(0, UCR_COMPARISONS_THRESHOLD) == UCR_COMPARISONS_THRESHOLD):
compare_ucr_dbs.delay(domain, report_config.report_id, filter_values)
report_elem = E.fixture(
id=ReportFixturesProviderV2._report_fixture_id(report_config.uuid), user_id=restore_user.user_id,
report_id=report_config.report_id, indexed='true'
)
report_elem.append(rows_elem)
return [report_filter_elem, report_elem]
def test_multiple_selections(self):
self.filter_spec["datatype"] = "string"
filter = ReportFilterFactory.from_spec(self.filter_spec)
test_strings = (
u'apple',
u'apple{s}banana'.format(s=CHOICE_DELIMITER),
u'apple{s}banana{s}carrot'.format(s=CHOICE_DELIMITER)
)
choices = [
Choice('apple', 'apple'),
Choice('banana', 'banana'),
Choice('carrot', 'carrot')
]
for i, s in enumerate(test_strings):
self.assertListEqual(choices[0:i + 1], filter.value(dynoslug=s))
def test_choice_list_filter_with_integers(self):
choices = [
{
"value": 0,
"display": "negative"
},
{
"value": 1,
"display": "positive"
}
]
filter = ReportFilterFactory.from_spec({
"type": "choice_list",
"slug": "diagnosis_slug",
"field": "diagnosis_field",
"datatype": "integer",
"display": "Diagnosis",
"choices": choices,
"show_all": True,
})
self.assertEqual(ChoiceListFilter, type(filter))
self.assertEqual('diagnosis_slug', filter.name)
self.assertEqual('Diagnosis', filter.label)
self.assertEqual(3, len(filter.choices))
non_all_choices = filter.choices[1:]
for i, choice in enumerate(choices):
self.assertEqual(non_all_choices[i].value, choice['value'])
self.assertEqual(non_all_choices[i].display, choice['display'])
# ensure integer values work
self.assertEqual('positive', filter.value(diagnosis_slug=1).display)
# ensure 0 integer value works
self.assertEqual('negative', filter.value(diagnosis_slug=0).display)
# check string to int coercion
self.assertEqual('positive', filter.value(diagnosis_slug='1').display)
# ensure 0 string to int works
self.assertEqual('negative', filter.value(diagnosis_slug='0').display)
# check missing values raise errors
with self.assertRaises(FilterValueException):
filter.value(diagnosis_slug='4')
# check non-integers raise errors
with self.assertRaises(FilterValueException):
filter.value(diagnosis_slug='foo')
# check that all still works
self.assertEqual('Show all', filter.value(diagnosis_slug=SHOW_ALL_CHOICE).display)
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
})
return create_filter_value(spec,
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_choice_list_filter_with_integers(self):
choices = [{
"value": 0,
"display": "negative"
}, {
"value": 1,
"display": "positive"
}]
filter = ReportFilterFactory.from_spec({
"type": "choice_list",
"slug": "diagnosis_slug",
"field": "diagnosis_field",
"datatype": "integer",
"display": "Diagnosis",
"choices": choices,
"show_all": True,
})
self.assertEqual(ChoiceListFilter, type(filter))
self.assertEqual('diagnosis_slug', filter.name)
self.assertEqual('Diagnosis', filter.label)
self.assertEqual(3, len(filter.choices))
non_all_choices = filter.choices[1:]
for i, choice in enumerate(choices):
self.assertEqual(non_all_choices[i].value, choice['value'])
self.assertEqual(non_all_choices[i].display, choice['display'])
# ensure integer values work
self.assertEqual('positive', filter.value(diagnosis_slug=1).display)
# ensure 0 integer value works
self.assertEqual('negative', filter.value(diagnosis_slug=0).display)
# check string to int coercion
self.assertEqual('positive', filter.value(diagnosis_slug='1').display)
# ensure 0 string to int works
self.assertEqual('negative', filter.value(diagnosis_slug='0').display)
# check missing values raise errors
with self.assertRaises(FilterValueException):
filter.value(diagnosis_slug='4')
# check non-integers raise errors
with self.assertRaises(FilterValueException):
filter.value(diagnosis_slug='foo')
# check that all still works
self.assertEqual('Show all',
filter.value(diagnosis_slug=SHOW_ALL_CHOICE).display)
def report_config_to_v1_fixture(report_config, restore_user):
domain = restore_user.domain
report, data_source = BaseReportFixturesProvider._get_report_and_data_source(
report_config.report_id, domain
)
# apply filters specified in report module
all_filter_values = {
filter_slug: restore_user.get_ucr_filter_value(filter, report.get_ui_filter(filter_slug))
for filter_slug, filter in report_config.filters.items()
}
# apply all prefilters
prefilters = [ReportFilterFactory.from_spec(p, report) for p in report.prefilters]
prefilter_values = {prefilter.name: prefilter.value() for prefilter in prefilters}
all_filter_values.update(prefilter_values)
# filter out nulls
filter_values = {
filter_slug: filter_value for filter_slug, filter_value in all_filter_values.items()
if filter_value is not None
}
defer_filters = [
report.get_ui_filter(filter_slug)
for filter_slug, filter_value in all_filter_values.items()
if filter_value is None and is_valid_mobile_select_filter_type(report.get_ui_filter(filter_slug))
]
data_source.set_filter_values(filter_values)
data_source.set_defer_fields([f.field for f in defer_filters])
filter_options_by_field = defaultdict(set)
rows_elem = ReportFixturesProvider._get_v1_report_elem(
data_source,
{ui_filter.field for ui_filter in defer_filters},
filter_options_by_field
)
filters_elem = BaseReportFixturesProvider._get_filters_elem(
defer_filters, filter_options_by_field, restore_user._couch_user)
if (report_config.report_id in settings.UCR_COMPARISONS and
random.randint(0, UCR_COMPARISONS_THRESHOLD) == UCR_COMPARISONS_THRESHOLD):
compare_ucr_dbs.delay(domain, report_config.report_id, filter_values)
report_elem = E.report(id=report_config.uuid, report_id=report_config.report_id)
report_elem.append(filters_elem)
report_elem.append(rows_elem)
return report_elem
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_choice_list_filter_show_all(self):
filter = ReportFilterFactory.from_spec({
"type": "choice_list",
"slug": "diagnosis_slug",
"field": "diagnosis_field",
"display": "Diagnosis",
"choices": self.CHOICES,
"show_all": True,
})
self.assertEqual(3, len(filter.choices))
self.assertEqual(SHOW_ALL_CHOICE, filter.choices[0].value)
for i, choice in enumerate(self.CHOICES):
self.assertEqual(filter.choices[i + 1].value, choice['value'])
self.assertEqual(filter.choices[i + 1].display, choice['display'])
# check all value
self.assertEqual('Show all', filter.value(diagnosis_slug=SHOW_ALL_CHOICE).display)
def test_choice_list_filter_show_all(self):
filter = ReportFilterFactory.from_spec({
"type": "choice_list",
"slug": "diagnosis_slug",
"field": "diagnosis_field",
"display": "Diagnosis",
"choices": self.CHOICES,
"show_all": True,
})
self.assertEqual(3, len(filter.choices))
self.assertEqual(SHOW_ALL_CHOICE, filter.choices[0].value)
for i, choice in enumerate(self.CHOICES):
self.assertEqual(filter.choices[i + 1].value, choice['value'])
self.assertEqual(filter.choices[i + 1].display, choice['display'])
# check all value
self.assertEqual('Show all', filter.value(diagnosis_slug=SHOW_ALL_CHOICE).display)
def test_choice_list_filter(self):
filter = ReportFilterFactory.from_spec({
"type": "choice_list",
"slug": "diagnosis_slug",
"field": "diagnosis_field",
"display": "Diagnosis",
"choices": self.CHOICES,
"show_all": False,
})
self.assertEqual(ChoiceListFilter, type(filter))
self.assertEqual('diagnosis_slug', filter.name)
self.assertEqual('Diagnosis', filter.label)
self.assertEqual(2, len(filter.choices))
for i, choice in enumerate(self.CHOICES):
self.assertEqual(filter.choices[i].value, choice['value'])
self.assertEqual(filter.choices[i].display, choice['display'])
# check values
self.assertEqual('positive', filter.value(diagnosis_slug='POSITIVE').display)
def test_choice_list_filter(self):
filter = ReportFilterFactory.from_spec({
"type": "choice_list",
"slug": "diagnosis_slug",
"field": "diagnosis_field",
"display": "Diagnosis",
"choices": self.CHOICES,
"show_all": False,
})
self.assertEqual(ChoiceListFilter, type(filter))
self.assertEqual('diagnosis_slug', filter.name)
self.assertEqual('Diagnosis', filter.label)
self.assertEqual(2, len(filter.choices))
for i, choice in enumerate(self.CHOICES):
self.assertEqual(filter.choices[i].value, choice['value'])
self.assertEqual(filter.choices[i].display, choice['display'])
# check values
self.assertEqual('positive', filter.value(diagnosis_slug='POSITIVE').display)
def test_pre_filter_operator(self):
value = {'operator': '<=', 'operand': '99'}
filter_ = ReportFilterFactory.from_spec({
'type':
'pre',
'field':
'risk_indicator_field',
'slug':
'risk_indicator_slug',
'datatype':
'integer',
'pre_value':
value['operand'],
'pre_operator':
value['operator'],
})
self.assertEqual(type(filter_), PreFilter)
self.assertEqual(filter_.default_value(), {
'operator': '<=',
'operand': 99
}) # operand will be coerced
def test_filter(self):
report = ReportConfiguration(domain=self.domain)
filter = ReportFilterFactory.from_spec(
{
"slug": "block_id_drill",
"type": "location_drilldown",
"field": "block_id",
"display": "Drilldown by Location",
}, report)
self.assertEqual(type(filter), LocationDrilldownFilter)
filter_context_expected = {
'input_name': 'block_id_drill',
'loc_id': None,
'hierarchy': location_hierarchy_config(self.domain),
'locations': load_locs_json(self.domain),
'loc_url': '/a/{}/api/v0.5/location_internal/'.format(self.domain)
}
self.assertDictEqual(filter.filter_context(), filter_context_expected)
def _report_config_to_fixture(report_config, restore_user):
report, data_source = ReportFixturesProvider._get_report_and_data_source(
report_config.report_id, restore_user.domain
)
# TODO: Convert to be compatible with restore_user
# apply filters specified in report module
all_filter_values = {
filter_slug: restore_user.get_ucr_filter_value(filter, report.get_ui_filter(filter_slug))
for filter_slug, filter in report_config.filters.items()
}
# apply all prefilters
prefilters = [ReportFilterFactory.from_spec(p, report) for p in report.prefilters]
prefilter_values = {prefilter.name: prefilter.value() for prefilter in prefilters}
all_filter_values.update(prefilter_values)
# filter out nulls
filter_values = {
filter_slug: filter_value for filter_slug, filter_value in all_filter_values.items()
if filter_value is not None
}
defer_filters = {
filter_slug: report.get_ui_filter(filter_slug)
for filter_slug, filter_value in all_filter_values.items()
if filter_value is None
}
data_source.set_filter_values(filter_values)
data_source.defer_filters(defer_filters)
filter_options_by_field = defaultdict(set)
rows_elem = ReportFixturesProvider._get_report_elem(
data_source,
{ui_filter.field for ui_filter in defer_filters.values()},
filter_options_by_field
)
filters_elem = ReportFixturesProvider._get_filters_elem(defer_filters, filter_options_by_field)
report_elem = E.report(id=report_config.uuid)
report_elem.append(filters_elem)
report_elem.append(rows_elem)
return report_elem
def _report_config_to_fixture(report_config, restore_user):
report, data_source = ReportFixturesProvider._get_report_and_data_source(
report_config.report_id, restore_user.domain
)
# TODO: Convert to be compatible with restore_user
# apply filters specified in report module
all_filter_values = {
filter_slug: restore_user.get_ucr_filter_value(filter, report.get_ui_filter(filter_slug))
for filter_slug, filter in report_config.filters.items()
}
# apply all prefilters
prefilters = [ReportFilterFactory.from_spec(p, report) for p in report.prefilters]
prefilter_values = {prefilter.name: prefilter.value() for prefilter in prefilters}
all_filter_values.update(prefilter_values)
# filter out nulls
filter_values = {
filter_slug: filter_value for filter_slug, filter_value in all_filter_values.items()
if filter_value is not None
}
defer_filters = {
filter_slug: report.get_ui_filter(filter_slug)
for filter_slug, filter_value in all_filter_values.items()
if filter_value is None and is_valid_mobile_select_filter_type(report.get_ui_filter(filter_slug))
}
data_source.set_filter_values(filter_values)
data_source.defer_filters(defer_filters)
filter_options_by_field = defaultdict(set)
rows_elem = ReportFixturesProvider._get_report_elem(
data_source,
{ui_filter.field for ui_filter in defer_filters.values()},
filter_options_by_field
)
filters_elem = ReportFixturesProvider._get_filters_elem(defer_filters, filter_options_by_field)
report_elem = E.report(id=report_config.uuid)
report_elem.append(filters_elem)
report_elem.append(rows_elem)
return report_elem
def ui_filters(self):
return [ReportFilterFactory.from_spec(f, self) for f in self.filters]
def ui_filters(self):
return [ReportFilterFactory.from_spec(f, self) for f in self.filters]
def test_choice_list_filter(self):
filter = ReportFilterFactory.from_spec(self.filter_spec)
self.assertEqual(DynamicChoiceListFilter, type(filter))
self.assertEqual('dynoslug', filter.name)
self.assertEqual('Dynamic choice list', filter.label)
def report_config_to_v2_fixture(report_config, restore_user):
domain = restore_user.domain
report, data_source = BaseReportFixturesProvider._get_report_and_data_source(
report_config.report_id, domain)
report_fixture_id = 'commcare-reports:' + report_config.uuid
report_filter_id = 'commcare-reports-filters:' + report_config.uuid
# TODO: Convert to be compatible with restore_user
# apply filters specified in report module
all_filter_values = {
filter_slug: restore_user.get_ucr_filter_value(
filter, report.get_ui_filter(filter_slug))
for filter_slug, filter in report_config.filters.items()
}
# apply all prefilters
prefilters = [
ReportFilterFactory.from_spec(p, report) for p in report.prefilters
]
prefilter_values = {
prefilter.name: prefilter.value()
for prefilter in prefilters
}
all_filter_values.update(prefilter_values)
# filter out nulls
filter_values = {
filter_slug: filter_value
for filter_slug, filter_value in all_filter_values.items()
if filter_value is not None
}
defer_filters = {
filter_slug: report.get_ui_filter(filter_slug)
for filter_slug, filter_value in all_filter_values.items()
if filter_value is None and is_valid_mobile_select_filter_type(
report.get_ui_filter(filter_slug))
}
data_source.set_filter_values(filter_values)
data_source.defer_filters(defer_filters)
filter_options_by_field = defaultdict(set)
rows_elem = ReportFixturesProviderV2._get_v2_report_elem(
data_source,
{ui_filter.field
for ui_filter in defer_filters.values()}, filter_options_by_field)
filters_elem = BaseReportFixturesProvider._get_filters_elem(
defer_filters, filter_options_by_field, restore_user._couch_user)
report_filter_elem = E.fixture(id=report_filter_id)
report_filter_elem.append(filters_elem)
if (data_source.config.backend_id in UCR_SUPPORT_BOTH_BACKENDS
and random.randint(0, MOBILE_UCR_RANDOM_THRESHOLD)
== MOBILE_UCR_RANDOM_THRESHOLD):
compare_ucr_dbs.delay(domain, report_config.report_id,
filter_values)
report_elem = E.fixture(id=report_fixture_id,
user_id=restore_user.user_id,
report_id=report_config.report_id,
last_sync=_utcnow().isoformat(),
indexed='true')
report_elem.append(rows_elem)
return [report_filter_elem, report_elem]
def report_config_to_v2_fixture(report_config, restore_user):
domain = restore_user.domain
report, data_source = BaseReportFixturesProvider._get_report_and_data_source(
report_config.report_id, domain)
# apply filters specified in report module
all_filter_values = {
filter_slug: restore_user.get_ucr_filter_value(
filter, report.get_ui_filter(filter_slug))
for filter_slug, filter in report_config.filters.items()
}
# apply all prefilters
prefilters = [
ReportFilterFactory.from_spec(p, report) for p in report.prefilters
]
prefilter_values = {
prefilter.name: prefilter.value()
for prefilter in prefilters
}
all_filter_values.update(prefilter_values)
# filter out nulls
filter_values = {
filter_slug: filter_value
for filter_slug, filter_value in all_filter_values.items()
if filter_value is not None
}
defer_filters = [
report.get_ui_filter(filter_slug)
for filter_slug, filter_value in all_filter_values.items()
if filter_value is None and is_valid_mobile_select_filter_type(
report.get_ui_filter(filter_slug))
]
data_source.set_filter_values(filter_values)
data_source.set_defer_fields([f.field for f in defer_filters])
filter_options_by_field = defaultdict(set)
rows_elem = ReportFixturesProviderV2._get_v2_report_elem(
data_source,
{f.field
for f in defer_filters},
filter_options_by_field,
_last_sync_time(domain, restore_user.user_id),
)
filters_elem = BaseReportFixturesProvider._get_filters_elem(
defer_filters, filter_options_by_field, restore_user._couch_user)
report_filter_elem = E.fixture(
id=ReportFixturesProviderV2._report_filter_id(report_config.uuid))
report_filter_elem.append(filters_elem)
if (report_config.report_id in settings.UCR_COMPARISONS
and COMPARE_UCR_REPORTS.enabled(uuid.uuid4().hex,
NAMESPACE_OTHER)):
compare_ucr_dbs.delay(domain, report_config.report_id,
filter_values)
report_elem = E.fixture(id=ReportFixturesProviderV2._report_fixture_id(
report_config.uuid),
user_id=restore_user.user_id,
report_id=report_config.report_id,
indexed='true')
report_elem.append(rows_elem)
return [report_filter_elem, report_elem]
def test_choice_list_filter(self):
filter = ReportFilterFactory.from_spec(self.filter_spec)
self.assertEqual(DynamicChoiceListFilter, type(filter))
self.assertEqual('dynoslug', filter.name)
self.assertEqual('Dynamic choice list', filter.label)
