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_removing_tiles(self):
rd, master_tile = self.test_handle_tpcreator()
tiles = Tile.select_multi(rd.dashboard_id,
_select_tile_ids(rd.dashboard_id)).values()
tpcreated_tile = util.first(t for t in tiles if t.get_master_tile_id())
layouts.detach_tile(tpcreated_tile)
self.assertEqual(1,
len(tpcreator.select_tpcreated_tile_ids(master_tile)))
def test_removing_tiles_by_expiring(self):
rd, master_tile = self.test_handle_tpcreator()
tiles = Tile.select_multi(rd.dashboard_id,
_select_tile_ids(rd.dashboard_id)).values()
#print tpcreator.select_tpcreated_tile_ids(master_tile)
#print select_tile_ids(rd.dashboard_id)
#print rd.layout_data().layout_dict.keys()
#tile = Tile.select(rd.dashboard_id, util.first(tile_id for tile_id in select_tile_ids(rd.dashboard_id) if tile_id not in rd.layout_data().layout_dict.keys()))
#print tile
self.assertTrue(
expire_tiles_without_data(tiles, 0,
rd.layout().layout_id))
self.assertEqual(0,
len(tpcreator.select_tpcreated_tile_ids(master_tile)))
self.assertEqual(1, len(_select_tile_ids(rd.dashboard_id)))
def test_promote_other_master_tile(self):
rd, master_tile = self.test_handle_tpcreator()
tpcreated_ids = tpcreator.select_tpcreated_tile_ids(master_tile)
tpcreated_tiles = Tile.select_multi(rd.dashboard_id,
tpcreated_ids).values()
#print 'tpcreated', [t.tags for t in tpcreated_tiles]
new_master_repl = util.first(t for t in tpcreated_tiles
if t.tile_options['tile_title'] == 'tpc0')
new_master_tile = tpcreator.make_master_from_tpcreated(
master_tile, new_master_repl)
self.assertEqual('tpc0', new_master_tile.tile_options['tile_title'])
self.assertTrue(
layouts.replace_tiles({master_tile: new_master_tile}, None))
self.assertFalse(tpcreator.select_tpcreated_tile_ids(master_tile))
new_tpcreated_ids = tpcreator.select_tpcreated_tile_ids(
new_master_tile)
new_tpcreated_tiles = Tile.select_multi(rd.dashboard_id,
new_tpcreated_ids).values()
self.assertTrue(new_tpcreated_tiles)
self.assertEqual([['p1:20'], ['p1:30']],
sorted([t.tags for t in new_tpcreated_tiles]))
d = [
OrderedDict([('user_name', 'robert10'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d), tags=['p1:15', 'p2:34'])
self.assertEqual(
len(new_tpcreated_ids) + 1,
len(tpcreator.select_tpcreated_tile_ids(new_master_tile)))
latest_tile = Tile.select(rd.dashboard_id,
_select_tile_ids(rd.dashboard_id)[-1])
self.assertEqual(['p1:15'], latest_tile.tags)
self.assertEqual(['monique', 'robert3', 'robert10'], [
ss.params['filtering_expr']['args'][0]
for ss in latest_tile.series_specs()
])
def test_sscreator_as_mod(self):
owner_id = uuid.uuid4()
dashboard_id = uuid.uuid4()
tile_config = {
'series_spec_list': [
SeriesSpec(1, 0, dict(op='eq', args=['label1'])),
],
'tile_options': {
'sscs': SeriesSpec(1, 0, dict(op='eq', args=['label1']))
}
}
r = Report.insert(owner_id, 'r')
tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config)
layouts.place_tile(tile)
ri1 = r.process_input('label1 1',
handle_sscreator=False).report_instance
ri2 = r.process_input('label11 11\nlabel12 12',
handle_sscreator=False).report_instance
ri3 = r.process_input('label21 21\nlabel22 22',
handle_sscreator=False).report_instance
layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(
owner_id, r.report_id, [], 'sscs', 100)
mods = [
sscreator.sscreator_mod(ri1, layout_rows[0]),
sscreator.sscreator_mod(ri2, layout_rows[0]),
sscreator.sscreator_mod(ri3, layout_rows[0])
]
layouts.apply_mods(mods, owner_id, dashboard_id, None)
layout = Layout.select(owner_id, dashboard_id)
tile = layout.tile_dict.keys()[0]
self.assertEqual(5, len(tile.series_specs()))
tile_ids = dashboards._select_tile_ids(dashboard_id)
self.assertEqual(1, len(tile_ids))
def test_handle_tpcreator(self):
rd = new_report_data('points')
tile_config = {
'tw_type':
'Range',
'tags': ['p1:10'],
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back':
600,
'tile_title':
'm0',
'sscs':
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
}
}
tile_config['tile_options'][
'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec(
tile_config['tags'])
master_tile = Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config)
layouts.place_tile(master_tile)
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d), tags=['p1:10'])
master_tile = rd.only_tile_from_layout()
self.assertEqual([], tpcreator.select_tpcreated_tile_ids(master_tile))
self.assertEqual([master_tile.tile_id],
_select_tile_ids(rd.dashboard_id))
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d), tags=['p1:20'])
self.assertEqual(2, len(_select_tile_ids(rd.dashboard_id)))
tiles = Tile.select_multi(rd.dashboard_id,
_select_tile_ids(rd.dashboard_id)).values()
created_tile = util.first(tiles, key=lambda t: not t.is_master_tile())
self.assertEqual(['p1:20'], created_tile.tile_options['tags'])
self.assertEqual(600, created_tile.tile_options['seconds_back'])
self.assertEqual(tile_config['tile_options']['sscs'],
created_tile.tile_options['sscs'])
td = created_tile.get_tile_data()
self.assertEqual('points (monique, robert3)',
td['generated_tile_title'])
self.assertEqual('[p1:20]', td['generated_tile_title_postfix'])
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d), tags=['p1:30', 'p2:30'])
self.assertEqual(3, len(_select_tile_ids(rd.dashboard_id)))
del tile_config['tile_options']['tpcreator_uispec']
tile_config['tile_options']['tile_title'] = 'ot0'
other_tile = Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config)
layouts.place_tile(other_tile)
self.assertEqual(4, len(_select_tile_ids(rd.dashboard_id)))
self.assertEqual(2,
len(tpcreator.select_tpcreated_tile_ids(master_tile)))
for i, tile_id in enumerate(
tpcreator.select_tpcreated_tile_ids(master_tile)):
tile = Tile.select(rd.dashboard_id, tile_id)
tile_config = tile.get_tile_config()
tile_config['tile_options']['tile_title'] = 'tpc%d' % i
new_tile = tile.insert_similar(tile_config)
layouts.replace_tiles({tile: new_tile}, None)
return rd, Tile.select(master_tile.dashboard_id, master_tile.tile_id)
def test_expire_tiles_without_data_two_masters(self):
rd = new_report_data('points', ['p3:30'])
tile_config1 = {
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back': 1000,
'tile_title': 'tile1'
}
}
tile1 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config1)
place_tile(tile1)
tile_config2 = {
'tags': ['p1:10'],
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back':
1000,
'tile_title':
'tile2 [p1:10]',
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['p1:10']),
}
}
tile2 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config2)
place_tile(tile2)
tile_config3 = {
'tags': ['p2:20'],
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back':
1000,
'tile_title':
'tile3',
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['p2:20']),
}
}
tile3 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config3)
place_tile(tile3)
#rd.report.process_input(json.dumps([dict(user_name='monique', is_active=True, points=128)]), tags=['p1:10'])
#rd.report.process_input(json.dumps([dict(user_name='monique', is_active=True, points=128)]), tags=['p2:20'])
time.sleep(1)
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p1:11'])
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p1:12'])
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p1:13'])
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p2:21'])
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p2:22'])
lid = tiles.expire_tiles_without_data(rd.layout().tile_dict.keys(),
2000,
rd.layout().layout_id)
self.assertFalse(lid)
lid = tiles.expire_tiles_without_data(rd.layout().tile_dict.keys(), 1,
rd.layout().layout_id)
self.assertTrue(lid)
self.assertEqual(6, len(rd.layout().layout_dict))
self.assertEqual(6, len(_select_tile_ids(rd.dashboard_id)))
tile_list = rd.layout().tile_dict.keys()
self.assertEqual(
sorted([[], ['p1:11'], ['p1:12'], ['p1:13'], ['p2:21'],
['p2:22']]), sorted([t.tags for t in tile_list]))
master1 = first(
t for t in tile_list
if t.tags and t.tags[0].startswith('p1') and t.is_master_tile())
master2 = first(
t for t in tile_list
if t.tags and t.tags[0].startswith('p2') and t.is_master_tile())
self.assertEqual(
2, len(rd.layout().get_tpcreated_tile_ids(master1.tile_id)))
self.assertEqual(
1, len(rd.layout().get_tpcreated_tile_ids(master2.tile_id)))
self.assertEqual(['p1:11'], master1.tags)
self.assertEqual(['p2:21'], master2.tags)
self.assertEqual('tile2 [p1:11]', master1.tile_options['tile_title'])
self.assertEqual('tile3', master2.tile_options['tile_title'])
def test_expire_tiles_without_data_master(self):
rd = new_report_data('points', ['p1:10'])
tile_config1 = {
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back': 1000,
'tile_title': 'tile1'
}
}
tile1 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config1)
place_tile(tile1)
tile_config2 = {
'tags': ['p1:10'],
'series_spec_list': [
dataseries.SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
],
'tile_options': {
'seconds_back':
1000,
'tile_title':
'tile2',
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['p1:10']),
}
}
tile2 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config2)
place_tile(tile2)
d = [
OrderedDict([('user_name', 'robert'), ('is_active', True),
('points', 128)]),
OrderedDict([('user_name', 'monique2'), ('is_active', True),
('points', 210)]),
OrderedDict([('user_name', 'monique3'), ('is_active', True),
('points', 210)]),
OrderedDict([('user_name', 'monique4'), ('is_active', True),
('points', 210)]),
OrderedDict([('user_name', 'robert2'), ('is_active', True),
('points', 210)]),
]
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p1:11'])
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p1:12'])
rd.report.process_input(json.dumps([
OrderedDict([('user_name', 'monique'), ('is_active', True),
('points', 128)])
]),
tags=['p1:13'])
self.assertEqual(5, len(rd.layout().layout_dict))
lid = tiles.expire_tiles_without_data(rd.layout().tile_dict.keys(),
2000,
rd.layout().layout_id)
self.assertFalse(lid)
self.assertEqual(5, len(rd.layout().layout_dict))
lid = tiles.expire_tiles_without_data(rd.layout().tile_dict.keys(), 0,
rd.layout().layout_id)
self.assertTrue(lid)
self.assertEqual(1, len(rd.layout().layout_dict))
self.assertEqual(1, len(_select_tile_ids(rd.dashboard_id)))
self.assertEqual(tile2.tile_id,
rd.layout().tile_dict.keys()[0].tile_id)
