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_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 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 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_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 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_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 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 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 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 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_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_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)
self.cmd = DateFilter()
def setUp(self):
self.query = Query(index=settings.TEST_INDEX)
def setUp(self):
self.query = Query()
self.cmd = DecimalChar()
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 = Collapse()
def setUp(self):
self.query = Query()
self.cmd = Last()
def setUp(self):
self.query = Query()
self.cmd = Sort()
def setUp(self):
self.query = Query()
self.cmd = DateFilter()
def setUp(self):
self.field = Field.objects.get(identifier=self.single_series)
self.query = Query()
def setUp(self):
self.cmd = IdsField()
self.query = Query(index=settings.TEST_INDEX)
def setUp(self):
self.query = Query()
self.cmd = Delimiter()
def setUp(self):
self.cmd = IdsField()
self.query = Query()
def setUp(self):
self.query = Query()
self.cmd = Pagination()
def setUp(self):
self.query = Query(index=settings.TEST_INDEX)
self.cmd = Pagination()
def setUp(self):
self.query = Query()
self.cmd = Collapse()
def setUp(self):
self.field = Field.objects.get(identifier=self.single_series)
self.query = Query(index=settings.TEST_INDEX)