def test_get_cell_promote(self):
rd = report_data('points')
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss.promote_colnos_to_headers(rd.instances[0])
self.assertEqual(2, ss.actual_data_colno(rd.instances[0]))
self.assertEqual(0, ss.actual_filtering_colno(rd.instances[0]))
self.assertEqual(210, ss.get_cell(rd.instances[0]).value)
self.assertEqual(220, ss.get_cell(rd.instances[1]).value)
self.assertEqual(265, ss.get_cell(rd.instances[2]).value)
self.assertIsNone(ss.get_cell(rd.instances[3]))
rep2 = reports.Report.insert(
report_data('points').owner_id, 'points_colchange')
res2 = rep2.process_input(
json.dumps([
dict(points=300, user_name='john'),
dict(points=400, user_name='monique'),
]))
self.assertEqual(0, ss.actual_data_colno(res2.report_instance))
self.assertEqual(1, ss.actual_filtering_colno(res2.report_instance))
self.assertEqual(400, ss.get_cell(res2.report_instance).value)
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
self.assertIsNone(ss.get_cell(res2.report_instance))
def test_get_tile_config(self):
tile_config = {
'tw_type':
'Range',
'tags': ['ip:192.168.1.1'],
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back':
600,
'tile_title':
'Points by user',
'sscs':
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['ip:192.168.1.1'])
}
}
owner_id = uuid.uuid1()
report_id = report_data('points').report.report_id
dashboard_id = report_data('points').dashboard_id
tile = Tile.insert(owner_id, report_id, dashboard_id, tile_config)
res = tile.get_tile_config()
self.assertDictContainsSubset(dictwithout(tile_config, 'tile_options'),
dictwithout(res, 'tile_options'))
self.assertDictContainsSubset(tile_config['tile_options'],
res['tile_options'])
def test_delete(self):
tile_config = {
'tw_type':
'Range',
'tags': ['ip:192.168.1.1'],
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back':
600,
'tile_title':
'Points by user',
'sscs':
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['ip:192.168.1.1'])
}
}
owner_id = uuid.uuid1()
report_id = report_data('points').report.report_id
dashboard_id = report_data('points').dashboard_id
tile = Tile.insert(owner_id, report_id, dashboard_id, tile_config)
place_tile(tile)
self.assertTrue(self._select_tpcreator_rows(tile))
self.assertTrue(self._select_sscs_rows(tile))
tile = tile.select(tile.dashboard_id, tile.tile_id)
detach_tile(tile)
deleted_tile = tile.select(tile.dashboard_id, tile.tile_id)
self.assertIsNone(deleted_tile)
def test_series_def_select_or_insert(self):
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss.promote_colnos_to_headers(report_data('points').instances[-1])
sd_id = dataseries.SeriesDef.select_id_or_insert(
report_data('points').report.report_id, [], ss)
sd = dataseries.SeriesDef.select(
report_data('points').report.report_id, [], sd_id)
self.assertEqual([], sd.tags)
sd2_id = dataseries.SeriesDef.select_id_or_insert(
report_data('points').report.report_id, [], ss)
sd2 = dataseries.SeriesDef.select(
report_data('points').report.report_id, [], sd2_id)
self.assertEqual(sd, sd2)
return sd
def test_name_virtual(self):
ri = report_data('points').instances[-1]
ss = SeriesSpec(2, -1, dict(op='eq', args=['1']))
self.assertEqual('col. 2 (1)', ss.name())
ss.promote_colnos_to_headers(ri)
self.assertEqual('points (1)', ss.name())
def test_select_multi(self):
tiles = [self.test_insert() for _ in range(3)]
tile_ids = [t.tile_id for t in tiles]
selected_tiles = Tile.select_multi(
report_data('points').dashboard_id, tile_ids)
self.assertItemsEqual(tile_ids, selected_tiles.keys())
self.assertItemsEqual(tiles, selected_tiles.values())
def test_select_tile_ids(self):
dashboard_id = uuid.uuid1()
self.assertEqual([], dashboards._select_tile_ids(dashboard_id))
dashboard_id = report_data('points').dashboard_id
tile1 = call(tiles_test.TileTest.test_insert)
tile2 = call(tiles_test.TileTest.test_insert)
self.assertIn(tile1.tile_id, dashboards._select_tile_ids(dashboard_id))
self.assertIn(tile2.tile_id, dashboards._select_tile_ids(dashboard_id))
def test_insert_no_tags(self):
owner_id = uuid.uuid1()
report_id = report_data('points').report.report_id
dashboard_id = report_data('points').dashboard_id
tile_config = {
'tw_type':
'Range',
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['john'])),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user'
}
}
tile = Tile.insert(owner_id, report_id, dashboard_id, tile_config)
self.assertEqual(tile.tile_options['tags'], [])
def test_tile_options_validation(self):
rd = report_data('points')
tile_config = {
'tags': ['1', '2', '3', '4'],
'series_spec_list': [],
}
self.assertRaises(
ValueError, lambda: Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config))
def test_get_cell_nopromote(self):
rd = report_data('points')
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
self.assertEqual(2, ss.actual_data_colno(rd.instances[0]))
self.assertEqual(0, ss.actual_filtering_colno(rd.instances[0]))
self.assertEqual(210, ss.get_cell(rd.instances[0]).value)
self.assertEqual(220, ss.get_cell(rd.instances[1]).value)
self.assertEqual(265, ss.get_cell(rd.instances[2]).value)
self.assertIsNone(ss.get_cell(rd.instances[3]))
def test_get_series_values(self):
sd = self.test_series_def_select_or_insert()
res = dataseries.get_series_values(
sd,
report_data('points').report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 1000)
self.assertEqual([210, 220, 265], [sv.value for sv in res])
self.assertEqual(['points', 'points', 'points'],
[sv.header for sv in res])
res = dataseries.get_series_values(
sd,
report_data('points').report, datetime.datetime.utcnow(),
datetime.datetime.utcnow() + datetime.timedelta(seconds=1), 1000)
self.assertEqual([], res)
res = dataseries.get_series_values(
sd,
report_data('points').report,
datetime.datetime.utcnow() - datetime.timedelta(days=1),
datetime.datetime.utcnow(), 2)
self.assertEqual([220, 265], [sv.value for sv in res])
self.assertEqual(['points', 'points'], [sv.header for sv in res])
def test_tile_options_default_tw(self):
rd = report_data('points')
tile_config = {
'tags': ['ip:192.168.1.1'],
'series_spec_list': [],
}
tile = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config)
self.assertEqual('Range', tile.tile_options['tw_type'])
self.assertIsInstance(tile.tilewidget, tilewidgets.TilewidgetForRange)
tile_config['tw_type'] = 'Single'
tile = tile.insert_similar(tile_config)
self.assertEqual('Single', tile.tile_options['tw_type'])
del tile_config['tw_type']
tile = tile.insert_similar(tile_config)
self.assertEqual('Range', tile.tile_options['tw_type'])
def test_insert(self,
tile_config_ext={},
tile_options_ext={},
dashboard_id=None,
rd=None):
rd = rd or report_data('points')
owner_id = rd.owner_id
report_id = rd.report.report_id
dashboard_id = dashboard_id or rd.dashboard_id
tile_config = {
'tags': ['ip:192.168.1.1'],
'tw_type':
'Range',
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['john'])),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user'
}
}
tile_config.update(tile_config_ext)
tile_config['tile_options'].update(tile_options_ext)
tile = Tile.insert(owner_id, report_id, dashboard_id, tile_config)
self.assertEqual(tile.owner_id, owner_id)
self.assertEqual(tile.report_id, report_id)
self.assertEqual(tile.report.report_id, report_id)
self.assertEqual(dashboard_id, tile.dashboard_id)
self.assertEqual(tile.tile_options['tags'], ['ip:192.168.1.1'])
self.assertEqual(tile.tile_options['seconds_back'], 86400)
self.assertEqual(tile_config['series_spec_list'], tile.series_specs())
self.assertIsNone(tile.get_master_tile_id())
self.assertIsInstance(tile.tilewidget, tilewidgets.TilewidgetForRange)
return tile
def test_guess_series_spec(self):
ss = guess_series_spec(
report_data('points').report,
report_data('points').instances[0], 2, 2)
ss_expected = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss_expected.promote_colnos_to_headers(
report_data('points').instances[0])
self.series_specs_equal(ss_expected, ss)
ss = guess_series_spec(
report_data('points').report,
report_data('points').instances[0], 2, 0)
ss_expected = SeriesSpec(0, -1, dict(op='eq', args=['2']))
ss_expected.promote_colnos_to_headers(
report_data('points').instances[0])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([10, 20])
ss = guess_series_spec(cd.report, cd.instances[-1], 0, 0)
ss_expected = SeriesSpec(0, -1, dict(op='eq', args=['0']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([[1, 2, 3], [4, 5, 6]])
ss = guess_series_spec(cd.report, cd.instances[-1], 2, 0)
ss_expected = SeriesSpec(0, -1, dict(op='eq', args=['2']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([[["aaa", 10], ["bbb", 20]]])
ss = guess_series_spec(cd.report, cd.instances[-1], 1, 1)
ss_expected = SeriesSpec(1, 0, dict(op='eq', args=['bbb']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([[["aaa", 10]]])
ss = guess_series_spec(cd.report, cd.instances[-1], 0, 1)
ss_expected = SeriesSpec(1, 0, dict(op='eq', args=['aaa']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
def test_expire_tiles_without_data_optimize_check(self):
owner_id = report_data('points').report.owner_id
report_id = report_data('points').report.report_id
dashboard_id = report_data('points').dashboard_id
report_data('points').report.process_input(
json.dumps([
OrderedDict([('user_name', 'xxx'), ('is_active', True),
('points', 1000)]),
OrderedDict([('user_name', 'yy'), ('is_active', True),
('points', 2000)]),
]),
created=datetime.datetime.utcnow() - datetime.timedelta(hours=8))
tile_config_1 = {
'tw_type':
'Range',
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back': 86400,
}
}
tile1 = tiles.Tile.insert(owner_id, report_id, dashboard_id,
tile_config_1)
self.assertTrue(tile1.get_tile_data()['series_data'][0]['data_points'])
tile_config_2 = {
'tw_type':
'Range',
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['john'])),
],
'tile_options': {
'seconds_back': 86400,
}
}
tile2 = tiles.Tile.insert(owner_id, report_id, dashboard_id,
tile_config_2)
self.assertTrue(tile2.get_tile_data()['series_data'][0]['data_points'])
tile_config_3 = {
'tw_type':
'Range',
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['xxx'])),
],
'tile_options': {
'seconds_back': 86400,
}
}
tile3 = tiles.Tile.insert(owner_id, report_id, dashboard_id,
tile_config_3)
self.assertTrue(tile3.get_tile_data()['series_data'][0]['data_points'])
place_tile(tile1)
place_tile(tile2)
place_tile(tile3)
res = tiles.expire_tiles_without_data([tile1, tile2, tile3], 3600,
Layout.select(
owner_id,
dashboard_id).layout_id)
self.assertTrue(res)
tile1 = tiles.Tile.select(tile1.dashboard_id, tile1.tile_id)
self.assertIsNotNone(tile1)
tile2 = tiles.Tile.select(tile2.dashboard_id, tile2.tile_id)
self.assertIsNotNone(tile2)
tile3 = tiles.Tile.select(tile3.dashboard_id, tile3.tile_id)
self.assertIsNone(tile3)
res = tiles.expire_tiles_without_data([tile1, tile2], 3600,
Layout.select(
owner_id,
dashboard_id).layout_id)
self.assertFalse(res)
