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