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_names(self):
tile = call(tiles_test.TileTest.test_insert)
self.assertNotIn(
'name',
select_default_series_spec_options(tile.report_id,
tile.series_specs())[0])
tile_config = tile.get_tile_config()
for i, ss in enumerate(tile_config['series_spec_list']):
ss.set_name('serie%d' % i)
tile = tile.insert_similar(tile_config)
update_default_options(tile)
self.assertEqual(
'serie0',
select_default_series_spec_options(tile.report_id,
tile.series_specs())[0]['name'])
self.assertEqual(
'serie1',
select_default_series_spec_options(tile.report_id,
tile.series_specs())[1]['name'])
tile_config = tile.get_tile_config()
for i, ss in enumerate(tile_config['series_spec_list']):
ss.set_name('s%d' % i)
tile = tile.insert_similar(tile_config)
update_default_options(tile)
self.assertEqual(
's0',
select_default_series_spec_options(tile.report_id,
tile.series_specs())[0]['name'])
self.assertEqual(
's1',
select_default_series_spec_options(tile.report_id,
tile.series_specs())[1]['name'])
def test_update_dashboard_name(self):
od = call(OwnerDashboardsTest.test_inserting)
db = od.dashboards[3]
db.update(dashboard_name='ABC', dashboard_options={'x': 20})
db_u = Dashboard.select(db['owner_id'], db.dashboard_id)
self.assertEqual('ABC', db_u.dashboard_name)
self.assertEqual({'x': 20}, db_u.dashboard_options)
def test_select(self):
od = call(OwnerDashboardsTest.test_inserting)
db = Dashboard.select(od.dashboards[0]['owner_id'],
od.dashboards[0].dashboard_id)
self.assertEqual(od.dashboards[0], db)
self.assertNotEqual(od.dashboards[1], db)
self.assertEqual(od.dashboards[0].dashboard_name, db.dashboard_name)
def place(self, dashboard_id, **kwargs):
from mqe.tests import tiles_test
tile = call(tiles_test.TileTest.test_insert, dashboard_id=dashboard_id)
res = place_tile(tile, **kwargs)
self.assertIsNotNone(res)
return tile
def test_place_wrong_id(self):
dashboard_id = uuid.uuid1()
tile = self.place(dashboard_id)
layout = Layout.select(tile.owner_id, tile.dashboard_id)
tile = self.place(dashboard_id)
tile = call(tiles_test.TileTest.test_insert, dashboard_id=dashboard_id)
res = place_tile(tile, for_layout_id=layout.layout_id)
self.assertIsNone(res)
def test_place(self):
tile = call(tiles_test.TileTest.test_insert, dashboard_id=uuid.uuid1())
res = place_tile(tile)
self.assertIsNotNone(res)
vo = {'width': 4, 'height': 4, 'x': 0, 'y': 0}
self.assertEqual(vo, res.new_tiles[tile])
layout = Layout.select(tile.owner_id, tile.dashboard_id)
self.assertEqual(res.new_layout.layout_id, layout.layout_id)
self.assertEqual({tile.tile_id: vo}, layout.layout_dict)
def test_colors(self):
from mqe.tests import tiles_test
tile = call(tiles_test.TileTest.test_insert,
tile_options_ext={'colors': ['red', 'blue']})
update_default_options(tile)
default_options = select_default_series_spec_options(
tile.report_id, tile.series_specs())
self.assertEqual([{
'color': 'red'
}, {
'color': 'blue'
}], default_options)
tile2 = call(tiles_test.TileTest.test_insert)
default_options = select_default_series_spec_options(
tile2.report_id, tile2.series_specs())
self.assertEqual([{
'color': 'red'
}, {
'color': 'blue'
}], default_options)
tile3 = call(tiles_test.TileTest.test_insert,
tile_options_ext={'colors': ['pink']})
update_default_options(tile3)
default_options = select_default_series_spec_options(
tile3.report_id, tile3.series_specs())
self.assertEqual([{
'color': 'pink'
}, {
'color': 'blue'
}], default_options)
tile4 = call(tiles_test.TileTest.test_insert)
update_default_options(tile4)
default_options = select_default_series_spec_options(
tile4.report_id, tile4.series_specs())
self.assertEqual([{
'color': 'pink'
}, {
'color': 'blue'
}], default_options)
def test_detach_all_and_attach(self):
tiles = self.test_place_multiple()
dashboard_id = tiles[0].dashboard_id
for t in tiles:
detach_tile(t)
tile = call(tiles_test.TileTest.test_insert, dashboard_id=dashboard_id)
res = place_tile(tile)
vo = {'width': 4, 'height': 4, 'x': 0, 'y': 0}
self.assertEqual(vo, res.new_tiles[tile])
layout = Layout.select(tile.owner_id, tile.dashboard_id)
self.assertEqual(res.new_layout.layout_id, layout.layout_id)
self.assertEqual({tile.tile_id: vo}, layout.layout_dict)
def test_layout_mod_nop_single_try(self):
def nop(layout_mod):
return
tiles = call(TilePlacingDetachingTest.test_place_multiple)
orig_layout = layouts.Layout.select(tiles[0].owner_id,
tiles[0].dashboard_id)
lmr = layouts.apply_mods([nop], tiles[0].owner_id,
tiles[0].dashboard_id, orig_layout.layout_id)
self.assertTrue(lmr)
self.assertEqual(orig_layout.layout_dict, lmr.old_layout.layout_dict)
self.assertEqual(orig_layout.layout_dict, lmr.new_layout.layout_dict)
self.assertEqual(orig_layout.layout_id, lmr.old_layout.layout_id)
self.assertEqual(orig_layout.layout_id, lmr.new_layout.layout_id)
def test_layout_mod_modify_vo_single_try(self):
def modify_vo(layout_mod):
layout_mod.layout.layout_dict.items()[0][1]['x'] = 100
tiles = call(TilePlacingDetachingTest.test_place_multiple)
orig_layout = layouts.Layout.select(tiles[0].owner_id,
tiles[0].dashboard_id)
lmr = layouts.apply_mods([modify_vo], tiles[0].owner_id,
tiles[0].dashboard_id, orig_layout.layout_id)
self.assertTrue(lmr)
self.assertEqual(orig_layout.layout_dict, lmr.old_layout.layout_dict)
self.assertNotEqual(orig_layout.layout_dict,
lmr.new_layout.layout_dict)
self.assertEqual(orig_layout.layout_id, lmr.old_layout.layout_id)
self.assertNotEqual(orig_layout.layout_id, lmr.new_layout.layout_id)
def test_layout_modification_by_sscs(self):
data = {}
@signals.layout_modified.connect
def on_tiles_replaced(c, **kwargs):
if kwargs['reason'] != 'sscreator':
return
lmr = kwargs['layout_modification_result']
self.assertNotEqual(lmr.old_layout.layout_id,
lmr.new_layout.layout_id)
data.clear()
data.update(kwargs)
rd, tile = call(SSCSTest.test_sscs)
self.assertEqual(
tile,
data['layout_modification_result'].tile_replacement.values()[0])
self.assertEqual(rd.layout().layout_id, data['layout_modification_result'].\
new_layout.layout_id)
def test_replace_wrong(self):
tiles = call(TilePlacingDetachingTest.test_place_multiple)
tile_other = tiles[0].insert_similar(tiles[0].get_tile_config())
tile_other2 = tiles[0].insert_similar(tiles[0].get_tile_config())
res = layouts.replace_tiles({tile_other: tile_other2}, None)
self.assertIsNone(res)
