def test_flatten_metadata_response(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.query.add_series(self.field) self.query.flatten_metadata_response() flat_meta = self.query.run()['meta'][1] other_query = Query() other_query.add_series(self.field) meta = other_query.run()['meta'][1] for key in meta: for in_key in meta[key]: self.assertEqual(meta[key][in_key], flat_meta['{}_{}'.format(key, in_key)])
def setupQueryWithSeriesWithDifferentRepresentationModes(self): query = Query() field = Field.objects.get(identifier=self.single_series) query.add_series(field, rep_mode='change') query.add_series(field, rep_mode='percent_change') query.add_series(field, rep_mode='change_a_year_ago') query.add_series(field, rep_mode='percent_change_a_year_ago') return query
def test_full_metadata_flat_response(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.field.save() self.query.add_series(self.single_series, self.field) self.query.set_metadata_config('full') self.query.flatten_metadata_response() self.query.run() flat_meta = self.query.get_metadata()[1] other_query = Query(index=settings.TEST_INDEX) other_query.add_series(self.single_series, self.field) other_query.set_metadata_config('full') other_query.run() meta = other_query.get_metadata()[1] for key in meta: for in_key in meta[key]: self.assertEqual(meta[key][in_key], flat_meta['{}_{}'.format(key, in_key)])
def test_global_rep_mode(self): self.cmd.run(self.query, {'ids': self.single_series}) self.query.sort('asc') data = self.query.run()['data'] other_query = Query(index=settings.TEST_INDEX) self.cmd.run(other_query, {'ids': self.single_series, 'representation_mode': 'change'}) other_query.sort('asc') other_data = other_query.run()['data'] for index, row in enumerate(other_data): change = data[index + 1][1] - data[index][1] # La resta anterior trae pérdida de precisión si los números de 'data' son grandes self.assertAlmostEqual(row[1], change, places=5)
def setUpClass(cls): cls.query = Query(index=settings.TEST_INDEX) field = Field.objects.get(identifier=cls.single_series) cls.query.add_series(cls.single_series, field) cls.series_name = field.title cls.series_desc = json.loads(field.metadata)['description'] super(ResponseTests, cls).setUpClass()
def test_start(self): self.query.add_series(self.field, 'value') params = {'ids': self.single_series, 'limit': self.limit} # Query sin offset other_query = Query() other_query.add_series(self.field, 'value') self.cmd.run(other_query, params) other_data = other_query.run()['data'] # Query con un offset de 'start' params_start = params.copy() params_start['start'] = self.start self.cmd.run(self.query, params_start) data = self.query.run()['data'] # Los datos del primer query empiezan en un offset de start en el otro self.assertEqual(data[0], other_data[self.start])
def test_end_of_period_with_rep_mode(self): self.query.add_series(self.field, 'percent_change', 'end_of_period') self.query.update_collapse('year') self.query.sort('asc') data = self.query.run()['data'] orig_eop = Query(index=settings.TS_INDEX) orig_eop.add_series(self.field, collapse_agg='end_of_period') orig_eop.update_collapse('year') orig_eop.sort('asc') end_of_period = orig_eop.run()['data'] for i, row in enumerate(data): # El primero es nulo en pct change value = end_of_period[i + 1][1] / end_of_period[i][1] - 1 self.assertAlmostEqual(value, row[1])
class DelimiterTests(TestCase): single_series = get_series_id('month') @classmethod def setUpClass(cls): cls.field = Field.objects.get(identifier=cls.single_series) super(cls, DelimiterTests).setUpClass() def setUp(self): self.query = Query() self.cmd = Delimiter() def test_delimiter(self): self.query.add_series(self.field, 'value') self.cmd.run(self.query, {'sep': '|'}) self.assertFalse(self.cmd.errors) def test_multiple_delimiters(self): self.query.add_series(self.field, 'value') self.cmd.run(self.query, {'sep': '|;'}) self.assertTrue(self.cmd.errors)
class DecimalCharTests(TestCase): single_series = get_series_id('month') @classmethod def setUpClass(cls): cls.field = Field.objects.get(identifier=cls.single_series) super(cls, DecimalCharTests).setUpClass() def setUp(self): self.query = Query(index=settings.TEST_INDEX) self.cmd = DecimalChar() def test_decimal_char(self): self.query.add_series(self.single_series, self.field, 'value') self.cmd.run(self.query, {'decimal': ','}) self.assertFalse(self.cmd.errors) def test_multiple_decimal_chars(self): self.query.add_series(self.single_series, self.field, 'value') self.cmd.run(self.query, {'decimal': ',;'}) self.assertTrue(self.cmd.errors)
def test_last_cmd(self): self.query.add_series(self.field) self.cmd.run(self.query, {'last': '10'}) orig_query = Query() orig_query.add_series(self.field) orig_query.sort('desc') data = orig_query.run()['data'] data.reverse() reverse_data = self.query.run()['data'] self.assertListEqual(data[-10:], reverse_data)
def test_csv_different_decimal_empty_rows(self): query = Query() field = Field.objects.get(identifier=self.single_series) query.add_series(field) query.add_series(field, rep_mode='percent_change_a_year_ago') generator = ResponseFormatterGenerator('csv').get_formatter() response = generator.run(query, {'decimal': ','}) self.assertFalse("None" in str(response.content))
def run(self, args): query = Query() for cmd in self.commands: cmd_instance = cmd() cmd_instance.run(query, args) if cmd_instance.errors: return self.generate_error_response_from_cmd(cmd_instance) _format = args.get(constants.PARAM_FORMAT, constants.API_DEFAULT_VALUES[constants.PARAM_FORMAT]) formatter = self.get_formatter(_format) try: return formatter.run(query, args) except TransportError: return self.generate_error_response([strings.ELASTICSEARCH_ERROR]) except EndOfPeriodError as e: return self.generate_error_response([e.message])
def run(self, query: Query, args): last = args.get(constants.PARAM_LAST) if last is None: return self.validate(last, args) if self.errors: return query.add_pagination(start=0, limit=int(last)) query.sort(constants.SORT_DESCENDING) query.reverse()
def test_last_cmd_with_start_date(self): rows = 100 self.query.add_series(self.field) self.cmd.run(self.query, {'last': str(rows)}) orig_query = Query() orig_query.add_series(self.field) orig_query.sort('desc') data = orig_query.run()['data'] last_date = iso8601.parse_date(data[-1][0]) start_date = last_date - relativedelta(years=1) self.query.add_filter(start_date=start_date, end_date=None) data = self.query.run()['data'] self.assertTrue(len(data), 12)
def test_collapse_aggregation_series_order_different_periodicity(self): year_series = get_series_id('day') year_field = Field.objects.get(identifier=year_series) self.query.add_series(self.field, collapse_agg='sum') self.query.add_series(year_field) data = self.query.run()['data'] other_query = Query() other_query.add_series(year_field) other_query.add_series(self.field, collapse_agg='sum') other_data = other_query.run()['data'] for row1, row2 in zip(data, other_data): self.assertEqual(row1[0], row2[0]) self.assertEqual(row1[1], row2[2]) self.assertEqual(row1[2], row2[1])
def test_global_rep_mode(self): self.cmd.run(self.query, {'ids': self.single_series}) self.query.sort('asc') data = self.query.run()['data'] change_query = Query() self.cmd.run(change_query, {'ids': self.single_series, 'representation_mode': 'change'}) change_query.sort('asc') # Un valor menos que la query original, 99 variaciones para 100 valores change_query.add_pagination(start=0, limit=99) change_data = change_query.run()['data'] for index, row in enumerate(change_data): change = data[index + 1][1] - data[index][1] # La resta anterior trae pérdida de precisión si los números de 'data' son grandes self.assertAlmostEqual(row[1], change, places=5)
def test_partial_end_date_is_inclusive(self): field = Field.objects.get(identifier=self.single_series) query = Query(index=settings.TEST_INDEX) query.add_series(self.single_series, self.field, 'value') query.sort('asc') first_date = query.run()['data'][0][0] end_date = iso8601.parse_date(first_date) + relativedelta(years=10) self.query.add_series(self.single_series, field, 'value') self.cmd.run(self.query, {'end_date': str(end_date)}) # Me aseguro de traer suficientes resultados self.query.add_pagination(start=0, limit=1000) self.query.sort('asc') data = self.query.run()['data'] last_date = iso8601.parse_date(data[-1][0]) self.assertEqual(last_date.year, end_date.year) self.assertGreaterEqual(last_date.month, end_date.month)
def setUp(self): self.query = Query() self.cmd = Pagination()
class PaginationTests(TestCase): single_series = SERIES_NAME limit = 75 start = 50 @classmethod def setUpClass(cls): cls.field = Field.objects.get(identifier=cls.single_series) super(cls, PaginationTests).setUpClass() def setUp(self): self.query = Query() self.cmd = Pagination() def test_start(self): self.query.add_series(self.field, 'value') params = {'ids': self.single_series, 'limit': self.limit} # Query sin offset other_query = Query() other_query.add_series(self.field, 'value') self.cmd.run(other_query, params) other_data = other_query.run()['data'] # Query con un offset de 'start' params_start = params.copy() params_start['start'] = self.start self.cmd.run(self.query, params_start) data = self.query.run()['data'] # Los datos del primer query empiezan en un offset de start en el otro self.assertEqual(data[0], other_data[self.start]) def test_limit(self): self.query.add_series(self.field, 'value') self.cmd.run(self.query, { 'ids': self.single_series, 'limit': self.limit }) self.query.sort(how='asc') data = self.query.run()['data'] self.assertEqual(len(data), self.limit) def test_invalid_start_parameter(self): self.query.add_series(self.field, 'value') self.cmd.run(self.query, { 'ids': self.single_series, 'start': 'not a number' }) self.query.run() self.assertTrue(self.cmd.errors) def test_invalid_limit_parameter(self): self.cmd.run(self.query, { 'ids': self.single_series, 'limit': 'not a number' }) self.assertTrue(self.cmd.errors) def test_start_over_limit(self): self.cmd.run(self.query, { 'ids': self.single_series, 'start': '99999999' }) self.assertTrue(self.cmd.errors) def start_limit_over_limit(self): self.cmd.run(self.query, { 'ids': self.single_series, 'limit': '99999999' }) self.assertTrue(self.cmd.errors)
def setUp(self): self.query = Query(index=settings.TEST_INDEX) self.cmd = DateFilter()
class DateFilterTests(TestCase): single_series = SERIES_NAME start_date = '1980-01-01' end_date = '1985-01-01' def setUp(self): self.query = Query(index=settings.TEST_INDEX) self.cmd = DateFilter() @classmethod def setUpTestData(cls): if not Catalog.objects.count(): setup_database() cls.field = Field.objects.get(identifier=cls.single_series) def test_start_date(self): self.query.add_series(self.single_series, self.field, 'value') self.cmd.run(self.query, {'start_date': self.start_date}) self.query.sort('asc') data = self.query.run()['data'] first_timestamp = data[0][0] self.assertEqual(self.start_date, first_timestamp) def test_end_date(self): self.query.add_series(self.single_series, self.field, 'value') self.cmd.run(self.query, {'end_date': self.end_date}) self.query.sort('asc') # Me aseguro que haya suficientes resultados self.query.add_pagination(start=0, limit=1000) data = self.query.run()['data'] last_timestamp = data[-1][0] self.assertEqual(self.end_date, last_timestamp) def test_invalid_start_date(self): self.cmd.run(self.query, {'start_date': 'not a date'}) self.assertTrue(self.cmd.errors) def test_invalid_end_date(self): self.cmd.run(self.query, {'end_date': 'not a date'}) self.assertTrue(self.cmd.errors) def test_non_iso_end_date(self): self.cmd.run(self.query, {'end_date': '04-01-2010'}) self.assertTrue(self.cmd.errors) self.cmd.run(self.query, {'end_date': '2010/04/01'}) self.assertTrue(self.cmd.errors) def test_non_iso_start_date(self): self.cmd.run(self.query, {'start_date': '04-01-2010'}) self.assertTrue(self.cmd.errors) self.cmd.run(self.query, {'start_date': '2010/04/01'}) self.assertTrue(self.cmd.errors) def test_partial_end_date_is_inclusive(self): field = Field.objects.get(identifier=self.single_series) query = Query(index=settings.TEST_INDEX) query.add_series(self.single_series, self.field, 'value') query.sort('asc') first_date = query.run()['data'][0][0] end_date = iso8601.parse_date(first_date) + relativedelta(years=10) self.query.add_series(self.single_series, field, 'value') self.cmd.run(self.query, {'end_date': str(end_date)}) # Me aseguro de traer suficientes resultados self.query.add_pagination(start=0, limit=1000) self.query.sort('asc') data = self.query.run()['data'] last_date = iso8601.parse_date(data[-1][0]) self.assertEqual(last_date.year, end_date.year) self.assertGreaterEqual(last_date.month, end_date.month)
def setUp(self): self.query = Query(index=settings.TEST_INDEX)
class QueryTests(TestCase): single_series = SERIES_NAME @classmethod def setUpClass(cls): cls.field = Field.objects.get(identifier=cls.single_series) super(cls, QueryTests).setUpClass() def setUp(self): self.query = Query(index=settings.TEST_INDEX) def test_index_metadata_frequency(self): self.query.add_series(self.single_series, self.field) self.query.run() index_frequency = self.query.get_metadata()[0]['frequency'] self.assertEqual(index_frequency, 'month') def test_index_metadata_start_end_dates(self): self.query.add_series(self.single_series, self.field) data = self.query.run()['data'] index_meta = self.query.get_metadata()[0] self.assertEqual(data[0][0], index_meta['start_date']) self.assertEqual(data[-1][0], index_meta['end_date']) def test_collapse_index_metadata_frequency(self): collapse_interval = 'quarter' self.query.add_series(self.single_series, self.field) self.query.add_collapse(collapse=collapse_interval) self.query.run() index_frequency = self.query.get_metadata()[0]['frequency'] self.assertEqual(index_frequency, collapse_interval) def test_collapse_index_metadata_start_end_dates(self): collapse_interval = 'quarter' self.query.add_series(self.single_series, self.field) self.query.add_collapse(collapse=collapse_interval) data = self.query.run()['data'] index_meta = self.query.get_metadata()[0] self.assertEqual(data[0][0], index_meta['start_date']) self.assertEqual(data[-1][0], index_meta['end_date']) @raises(CollapseError) def test_invalid_collapse(self): collapse_interval = 'day' # Serie cargada es mensual self.query.add_series(self.single_series, self.field) self.query.add_collapse(collapse=collapse_interval) def test_identifiers(self): self.query.add_series(self.single_series, self.field) # Devuelve lista de ids, una por serie. Me quedo con la primera (única) ids = self.query.get_series_identifiers()[0] field = Field.objects.get(identifier=self.single_series) self.assertEqual(ids['id'], field.identifier) self.assertEqual(ids['distribution'], field.distribution.identifier) self.assertEqual(ids['dataset'], field.distribution.dataset.identifier) def test_weekly_collapse(self): day_series_name = settings.TEST_SERIES_NAME.format('day') field = Field.objects.get(identifier=day_series_name) self.query.add_series(day_series_name, field) self.query.add_collapse(collapse='week') self.query.sort(how='asc') data = self.query.run()['data'] first_date = iso8601.parse_date(data[0][0]) second_date = iso8601.parse_date(data[1][0]) delta = second_date - first_date self.assertEqual(delta.days, 7) def add_series_with_aggregation(self): # Aggregation sin haber definido collapse NO HACE NADA! self.query.add_series(self.single_series, self.field, collapse_agg='sum') self.assertTrue(self.query.series_models) def test_simple_metadata_remove_catalog(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() self.query.add_series(self.single_series, self.field) self.query.run() index_meta = self.query.get_metadata()[1]['catalog'] self.assertNotIn('extra_field', index_meta) self.assertIn('title', index_meta) def test_simple_metadata_remove_dataset(self): dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() self.query.add_series(self.single_series, self.field) self.query.run() index_meta = self.query.get_metadata()[1]['dataset'] self.assertNotIn('extra_field', index_meta) self.assertIn('title', index_meta) def test_simple_metadata_remove_distribution(self): dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.query.add_series(self.single_series, self.field) self.query.run() index_meta = self.query.get_metadata()[1]['distribution'] self.assertNotIn('extra_field', index_meta) self.assertIn('title', index_meta) def test_simple_metadata_remove_field(self): self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.field.save() self.query.add_series(self.single_series, self.field) self.query.run() index_meta = self.query.get_metadata()[1]['field'] self.assertNotIn('extra_field', index_meta) self.assertIn('id', index_meta) def test_flatten_metadata_response(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.field.save() self.query.add_series(self.single_series, self.field) self.query.flatten_metadata_response() self.query.run() flat_meta = self.query.get_metadata()[1] other_query = Query(index=settings.TEST_INDEX) other_query.add_series(self.single_series, self.field) other_query.run() meta = other_query.get_metadata()[1] for key in meta: for in_key in meta[key]: self.assertEqual(meta[key][in_key], flat_meta['{}_{}'.format(key, in_key)]) def test_full_metadata_flat_response(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.field.save() self.query.add_series(self.single_series, self.field) self.query.set_metadata_config('full') self.query.flatten_metadata_response() self.query.run() flat_meta = self.query.get_metadata()[1] other_query = Query(index=settings.TEST_INDEX) other_query.add_series(self.single_series, self.field) other_query.set_metadata_config('full') other_query.run() meta = other_query.get_metadata()[1] for key in meta: for in_key in meta[key]: self.assertEqual(meta[key][in_key], flat_meta['{}_{}'.format(key, in_key)]) def test_full_metadata_includes_enhanced_meta(self): self.query.add_series(self.single_series, self.field) self.query.set_metadata_config('full') meta = self.query.get_metadata() for enhanced_meta in self.field.enhanced_meta.all(): self.assertEqual(meta[1]['field'][enhanced_meta.key], enhanced_meta.value) def test_full_metadata_periodicty_with_collapse(self): self.query.add_series(self.single_series, self.field) self.query.add_collapse('year') self.query.set_metadata_config('full') resp = self.query.run() self.assertEqual(resp['meta'][0]['frequency'], 'year') self.assertEqual(resp['meta'][1]['field'][meta_keys.PERIODICITY], meta_keys.get(self.field, meta_keys.PERIODICITY)) def test_query_count(self): self.query.add_series(self.single_series, self.field) resp = self.query.run() # Longitud de la serie pedida. Ver support/generate_data.py self.assertEqual(resp['count'], 1000) def test_day_series_length_with_limit_and_rep_mode(self): day_series_name = settings.TEST_SERIES_NAME.format('day') field = Field.objects.get(identifier=day_series_name) self.query.add_series(day_series_name, field, rep_mode='percent_change_a_year_ago') self.query.add_pagination(start=0, limit=2) result = self.query.run() self.assertEqual(len(result['data']), 2) def test_response_rep_mode_units(self): self.query.add_series(self.single_series, self.field) meta = self.query.get_metadata() field_meta = meta[1]['field'] self.assertEqual(field_meta['representation_mode'], 'value') self.assertEqual(field_meta['representation_mode_units'], meta[1]['field'].get('units')) def test_response_rep_mode_units_pct_change(self): rep_mode = constants.PCT_CHANGE self.query.add_series(self.single_series, self.field, rep_mode=rep_mode) meta = self.query.get_metadata() field_meta = meta[1]['field'] self.assertEqual(field_meta['representation_mode'], rep_mode) self.assertEqual(field_meta['representation_mode_units'], constants.VERBOSE_REP_MODES[rep_mode])
def setUp(self): self.query = Query() self.cmd = Collapse()
def setUp(self): self.query = Query(index=settings.TEST_INDEX) self.cmd = Collapse()
class QueryTests(TestCase): single_series = SERIES_NAME def setUp(self): self.field = Field.objects.get(identifier=self.single_series) self.query = Query() def test_index_metadata_frequency(self): self.query.add_series(self.field) meta = self.query.run()['meta'] index_frequency = meta[0]['frequency'] self.assertEqual(index_frequency, 'month') def test_index_metadata_start_end_dates(self): self.query.add_series(self.field) res = self.query.run() index_meta = res['meta'][0] self.assertEqual(res['data'][0][0], index_meta['start_date']) self.assertEqual(res['data'][-1][0], index_meta['end_date']) def test_collapse_index_metadata_frequency(self): collapse_interval = 'quarter' self.query.add_series(self.field) self.query.update_collapse(collapse=collapse_interval) meta = self.query.run()['meta'] index_frequency = meta[0]['frequency'] self.assertEqual(index_frequency, collapse_interval) def test_collapse_index_metadata_start_end_dates(self): collapse_interval = 'quarter' self.query.add_series(self.field) self.query.update_collapse(collapse=collapse_interval) res = self.query.run() data = res['data'] index_meta = res['meta'][0] self.assertEqual(data[0][0], index_meta['start_date']) self.assertEqual(data[-1][0], index_meta['end_date']) @raises(CollapseError) def test_invalid_collapse(self): collapse_interval = 'day' # Serie cargada es mensual self.query.add_series(self.field) self.query.update_collapse(collapse=collapse_interval) def test_identifiers(self): self.query.add_series(self.field) # Devuelve lista de ids, una por serie. Me quedo con la primera (única) ids = self.query.get_series_identifiers()[0] field = Field.objects.get(identifier=self.single_series) self.assertEqual(ids['id'], field.identifier) self.assertEqual(ids['distribution'], field.distribution.identifier) self.assertEqual(ids['dataset'], field.distribution.dataset.identifier) def test_weekly_collapse(self): day_series_name = settings.TEST_SERIES_NAME.format('day') field = Field.objects.get(identifier=day_series_name) self.query.add_series(field) self.query.update_collapse(collapse='week') self.query.sort(how='asc') data = self.query.run()['data'] first_date = iso8601.parse_date(data[0][0]) second_date = iso8601.parse_date(data[1][0]) delta = second_date - first_date self.assertEqual(delta.days, 7) def test_simple_metadata_remove_catalog(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() self.query.add_series(self.field) meta = self.query.run()['meta'] index_meta = meta[1]['catalog'] self.assertNotIn('extra_field', index_meta) self.assertIn('title', index_meta) def test_simple_metadata_remove_dataset(self): dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() self.query.add_series(self.field) meta = self.query.run()['meta'] index_meta = meta[1]['dataset'] self.assertNotIn('extra_field', index_meta) self.assertIn('title', index_meta) def test_simple_metadata_remove_distribution(self): dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.query.add_series(self.field) meta = self.query.run()['meta'] index_meta = meta[1]['distribution'] self.assertNotIn('extra_field', index_meta) self.assertIn('title', index_meta) def test_simple_metadata_remove_field(self): self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.query.add_series(self.field) meta = self.query.run()['meta'] index_meta = meta[1]['field'] self.assertNotIn('extra_field', index_meta) self.assertIn('id', index_meta) def test_flatten_metadata_response(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.query.add_series(self.field) self.query.flatten_metadata_response() flat_meta = self.query.run()['meta'][1] other_query = Query() other_query.add_series(self.field) meta = other_query.run()['meta'][1] for key in meta: for in_key in meta[key]: self.assertEqual(meta[key][in_key], flat_meta['{}_{}'.format(key, in_key)]) def test_full_metadata_flat_response(self): catalog = self.field.distribution.dataset.catalog catalog.metadata = '{"title": "test_title", "extra_field": "extra"}' catalog.save() dataset = self.field.distribution.dataset dataset.metadata = '{"title": "test_title", "extra_field": "extra"}' dataset.save() dist = self.field.distribution dist.metadata = '{"title": "test_title", "extra_field": "extra"}' dist.save() self.field.metadata = '{"id": "test_title", "extra_field": "extra"}' self.query.add_series(self.field) self.query.set_metadata_config('full') self.query.flatten_metadata_response() flat_meta = self.query.run()['meta'][1] other_query = Query() other_query.add_series(self.field) other_query.set_metadata_config('full') meta = other_query.run()['meta'][1] for key in meta: for in_key in meta[key]: self.assertEqual(meta[key][in_key], flat_meta['{}_{}'.format(key, in_key)]) def test_full_metadata_includes_enhanced_meta(self): self.query.add_series(self.field) self.query.set_metadata_config('full') meta = self.query.run()['meta'] for enhanced_meta in self.field.enhanced_meta.all(): self.assertEqual(meta[1]['field'][enhanced_meta.key], enhanced_meta.value) def test_full_metadata_periodicty_with_collapse(self): self.query.add_series(self.field) self.query.update_collapse('year') self.query.set_metadata_config('full') resp = self.query.run() self.assertEqual(resp['meta'][0]['frequency'], 'year') self.assertEqual(resp['meta'][1]['field'][meta_keys.PERIODICITY], meta_keys.get(self.field, meta_keys.PERIODICITY)) def test_query_count(self): self.query.add_series(self.field) resp = self.query.run() # Longitud de la serie pedida. Ver support/generate_data.py self.assertEqual(resp['count'], 12 * 10) def test_day_series_length_with_limit_and_rep_mode(self): day_series_name = settings.TEST_SERIES_NAME.format('day') field = Field.objects.get(identifier=day_series_name) self.query.add_series(field, rep_mode='percent_change_a_year_ago') self.query.add_pagination(start=0, limit=2) result = self.query.run() self.assertEqual(len(result['data']), 2) def test_response_rep_mode_units(self): self.query.add_series(self.field) meta = self.query.run()['meta'] field_meta = meta[1]['field'] self.assertEqual(field_meta['representation_mode'], 'value') self.assertEqual(field_meta['representation_mode_units'], meta[1]['field'].get('units')) def test_response_rep_mode_units_pct_change(self): rep_mode = constants.PCT_CHANGE self.query.add_series(self.field, rep_mode=rep_mode) meta = self.query.run()['meta'] field_meta = meta[1]['field'] self.assertEqual(field_meta['representation_mode'], rep_mode) self.assertEqual(field_meta['representation_mode_units'], constants.VERBOSE_REP_MODES[rep_mode]) def test_aggregation_on_yearly_series(self): """Esperado: Valores de la serie con y sin agregación son iguales, no hay valores que colapsar""" year_series = get_series_id('year') field = Field.objects.get(identifier=year_series) self.query.add_series(field) self.query.add_series(field, collapse_agg='end_of_period') data = self.query.run()['data'] for row in data: self.assertEqual(row[1], row[2]) def test_aggregation_on_monthly_series(self): """Esperado: Valores de la serie con y sin agregación son iguales, no hay valores que colapsar""" self.query.add_series(self.field) self.query.add_series(self.field, collapse_agg='end_of_period') data = self.query.run()['data'] for row in data: self.assertEqual(row[1], row[2]) def test_same_series_multiple_times_different_rep_mode(self): self.query.add_series(self.field) self.query.add_series(self.field, rep_mode='percent_change') self.query.set_metadata_config(how=constants.METADATA_ONLY) meta = self.query.run()['meta'] self.assertEqual(meta[1]['field']['representation_mode'], 'value') self.assertEqual(meta[2]['field']['representation_mode'], 'percent_change') def test_is_percentage(self): SeriesUnits.objects.create(name=json.loads( self.field.metadata)['units'], percentage=True) self.query.add_series(self.field) self.query.set_metadata_config(how=constants.METADATA_ONLY) meta = self.query.run()['meta'] self.assertTrue(meta[1]['field']['is_percentage']) def test_is_percentage_units_false(self): SeriesUnits.objects.create(name=json.loads( self.field.metadata)['units'], percentage=False) self.query.add_series(self.field) self.query.set_metadata_config(how=constants.METADATA_ONLY) meta = self.query.run()['meta'] self.assertFalse(meta[1]['field']['is_percentage']) def test_is_percentage_with_percentage_rep_mode(self): self.query.add_series(self.field, rep_mode=constants.PCT_CHANGE) self.query.set_metadata_config(how=constants.METADATA_ONLY) meta = self.query.run()['meta'] self.assertTrue(meta[1]['field']['is_percentage']) def test_is_percentage_with_non_percentage_rep_mode(self): self.query.add_series(self.field, rep_mode=constants.CHANGE) self.query.set_metadata_config(how=constants.METADATA_ONLY) meta = self.query.run()['meta'] self.assertFalse(meta[1]['field']['is_percentage']) def test_add_query_aggregation(self): self.query.add_series(self.field) self.query.add_series(self.field, collapse_agg='sum') self.query.update_collapse('year') data = self.query.run()['data'] for _, avg_value, sum_value in data: # Suma debe ser siempre mayor que el promedio self.assertGreater(sum_value, avg_value) def test_collapse_aggregation_series_order_different_periodicity(self): year_series = get_series_id('day') year_field = Field.objects.get(identifier=year_series) self.query.add_series(self.field, collapse_agg='sum') self.query.add_series(year_field) data = self.query.run()['data'] other_query = Query() other_query.add_series(year_field) other_query.add_series(self.field, collapse_agg='sum') other_data = other_query.run()['data'] for row1, row2 in zip(data, other_data): self.assertEqual(row1[0], row2[0]) self.assertEqual(row1[1], row2[2]) self.assertEqual(row1[2], row2[1]) def test_add_two_collapses(self): """Esperado: El segundo collapse overridea el primero""" self.query.add_series(self.field) self.query.update_collapse('quarter') self.query.update_collapse('year') self.query.sort(how='asc') data = self.query.run()['data'] prev_timestamp = None for row in data: timestamp = row[0] parsed_timestamp = iso8601.parse_date(timestamp) if not prev_timestamp: prev_timestamp = parsed_timestamp continue delta = relativedelta(parsed_timestamp, prev_timestamp) self.assertTrue(delta.years == 1, timestamp) prev_timestamp = parsed_timestamp def test_end_of_period_with_rep_mode(self): self.query.add_series(self.field, 'percent_change', 'end_of_period') self.query.update_collapse('year') self.query.sort('asc') data = self.query.run()['data'] orig_eop = Query(index=settings.TS_INDEX) orig_eop.add_series(self.field, collapse_agg='end_of_period') orig_eop.update_collapse('year') orig_eop.sort('asc') end_of_period = orig_eop.run()['data'] for i, row in enumerate(data): # El primero es nulo en pct change value = end_of_period[i + 1][1] / end_of_period[i][1] - 1 self.assertAlmostEqual(value, row[1])
def setUp(self): self.cmd = IdsField() self.query = Query()
def setUp(self): self.field = Field.objects.get(identifier=self.single_series) self.query = Query()
def setUp(self): self.query = Query(index=settings.TEST_INDEX) self.cmd = DecimalChar()
def setUp(self): self.query = Query(index=settings.TEST_INDEX) self.cmd = Pagination()