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(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(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 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]