def test_select_multi(self):
owner_id = uuid.uuid1()
d_id1 = uuid.uuid1()
d_id2 = uuid.uuid1()
r = Report.insert(owner_id, 'r')
res = Layout.select_multi(owner_id, [d_id1, d_id2])
self.assertEqual([], res)
tile_config = {
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
}
t1 = Tile.insert(owner_id, r.report_id, d_id1, tile_config)
place_tile(t1)
res = Layout.select_multi(owner_id, [d_id1, d_id2])
self.assertEqual(1, len(res))
self.assertEqual(
Layout.select(owner_id, d_id1).layout_id, res[0].layout_id)
t2 = Tile.insert(owner_id, r.report_id, d_id2, tile_config)
place_tile(t2)
res = Layout.select_multi(owner_id, [d_id1, d_id2])
self.assertEqual(2, len(res))
self.assertEqual(
Layout.select(owner_id, d_id1).layout_id, res[0].layout_id)
self.assertEqual(
Layout.select(owner_id, d_id2).layout_id, res[1].layout_id)
def test_get_dashboards_by_report_id(self):
od = self.test_inserting()
res = od.get_dashboards_by_report_id()
self.assertEqual({}, res)
r = Report.insert(od.owner_id, 'r')
r2 = Report.insert(od.owner_id, 'r2')
r3 = Report.insert(od.owner_id, 'r3')
tile_config = {
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
}
place_tile(Tile.insert(od.owner_id, r.report_id, od.dashboards[3].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r.report_id, od.dashboards[3].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r.report_id, od.dashboards[0].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r2.report_id, od.dashboards[0].dashboard_id, tile_config))
place_tile(Tile.insert(od.owner_id, r3.report_id, od.dashboards[1].dashboard_id, tile_config))
res = od.get_dashboards_by_report_id()
self.assertEqual(3, len(res))
self.assertEqual([od.dashboards[0], od.dashboards[3]], res[r.report_id])
self.assertEqual([od.dashboards[0]], res[r2.report_id])
self.assertEqual([od.dashboards[1]], res[r3.report_id])
def test_get_dashboards_displaying_report(self):
od = self.test_inserting()
res = od.get_dashboards_displaying_report(uuid.uuid4())
self.assertEqual([], res)
r = Report.insert(od.owner_id, 'r')
tile_config = {
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
}
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual([], res)
t1 = Tile.insert(od.owner_id, r.report_id, od.dashboards[3].dashboard_id, tile_config)
place_tile(t1)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(1, len(res))
self.assertEqual('Dash 4', res[0].dashboard_name)
t2 = Tile.insert(od.owner_id, r.report_id, od.dashboards[1].dashboard_id, tile_config)
place_tile(t2)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(2, len(res))
self.assertEqual('Dash 2', res[0].dashboard_name)
self.assertEqual('Dash 4', res[1].dashboard_name)
t3 = Tile.insert(od.owner_id, r.report_id, od.dashboards[1].dashboard_id, tile_config)
place_tile(t3)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(2, len(res))
self.assertEqual('Dash 2', res[0].dashboard_name)
self.assertEqual('Dash 4', res[1].dashboard_name)
detach_tile(t3)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(2, len(res))
self.assertEqual('Dash 2', res[0].dashboard_name)
self.assertEqual('Dash 4', res[1].dashboard_name)
detach_tile(t2)
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(1, len(res))
self.assertEqual('Dash 4', res[0].dashboard_name)
od.dashboards[3].delete()
res = od.get_dashboards_displaying_report(r.report_id)
self.assertEqual(0, len(res))
def test_filling_default_options(self):
rd = new_report_data('points', tags=['ip:192.168.1.1'])
for tw_type in ('Range', 'Single'):
ss1 = dataseries.SeriesSpec(2, 0, dict(op='eq', args=['mike']))
ss1.promote_colnos_to_headers(rd.instances[-1])
ss1.set_name('mikepoints')
tile_config = {
'tw_type':
tw_type,
'tags': ['ip:192.168.1.1'],
'series_spec_list': [
ss1,
dataseries.SeriesSpec(2, 0, dict(op='eq',
args=['monique'])),
],
'tile_options': {
'colors': ['red', 'blue', 'pink', 'cyan'],
'seconds_back':
600,
'tile_title':
'Points by user',
'sscs':
dataseries.SeriesSpec(2, 0, dict(op='eq',
args=['monique'])),
}
}
tile = Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config)
dataseries.update_default_options(tile)
data = tile.get_tile_data()
self.assertEqual(['red', 'blue'], data['combined_colors'])
tile_config2 = {
'tw_type':
tw_type,
'tags': ['ip:192.168.1.1'],
'series_spec_list': [
dataseries.guess_series_spec(rd.report, rd.instances[-1],
1, 2),
dataseries.SeriesSpec(2, 0, dict(op='eq',
args=['monique'])),
],
}
self.assertEqual('mikepoints',
tile_config2['series_spec_list'][0].name())
tile2 = Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config)
dataseries.update_default_options(tile2)
data2 = tile2.get_tile_data()
self.assertEqual('mikepoints', data2['series_data'][0]['name'])
self.assertEqual(['red', 'blue'], data2['combined_colors'])
def test_promote_first_as_master_losing_sscreated(self):
rd = ReportData('r')
ss = dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0']))
tile_config1 = {
'series_spec_list': [ss],
'tags': ['p1:10'],
'tile_options': {
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['p1:10']),
'sscs': ss
}
}
tile1 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config1)
place_tile(tile1)
ri1 = rd.report.process_input('1\n2\n',
tags=['p1:9'],
handle_tpcreator=False,
handle_sscreator=False).report_instance
ri2 = rd.report.process_input('1\n2\n3\n',
tags=['p1:12'],
handle_tpcreator=False,
handle_sscreator=False).report_instance
tpcreator.handle_tpcreator(rd.owner_id,
rd.report_id,
ri1,
make_first_master=False)
sscreator.handle_sscreator(rd.owner_id, rd.report_id, ri1)
tpcreator.handle_tpcreator(rd.owner_id,
rd.report_id,
ri2,
make_first_master=False)
sscreator.handle_sscreator(rd.owner_id, rd.report_id, ri2)
self.assertEqual(3, len(rd.layout().layout_dict))
self.assertEqual(3, len(rd.get_tile_by_tags(['p1:12']).series_specs()))
ri3 = rd.report.process_input('1\n2\n3\n',
tags=['p1:13'],
handle_tpcreator=False).report_instance
tpcreator.handle_tpcreator(rd.owner_id,
rd.report_id,
ri3,
make_first_master=True)
self.assertEqual(4, len(rd.layout().layout_dict))
master_tile = rd.get_tile_by_tags(['p1:9'])
self.assertTrue(master_tile.is_master_tile())
self.assertEqual(master_tile.tile_id,
rd.get_tile_by_tags(['p1:12']).get_master_tile_id())
self.assertEqual(3, len(rd.get_tile_by_tags(['p1:12']).series_specs()))
self.assertEqual(['0', '1', '2'], [
ss.params['filtering_expr']['args'][0]
for ss in rd.get_tile_by_tags(['p1:12']).series_specs()
])
def test_repack_performance(self):
rd = ReportData('r')
tile_config = {
'tags': ['p1:1'],
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {
'tpcreator_uispec': [{
'tag': 'p1:1',
'prefix': 'p1:'
}],
}
}
tile = Tile.insert(rd.owner_id, rd.report_id, rd.dashboard_id,
tile_config)
place_tile(tile)
start = time()
for i in range(1, 201):
rd.report.process_input('1', tags=['p1:%s' % i])
print 'Tiles created in %.1f' % ((time() - start) * 1000)
start = time()
layouts.repack(rd.owner_id, rd.dashboard_id)
print 'Single repack in %.1f' % ((time() - start) * 1000)
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 _tile_options_of_tpcreated(master_tile, tpcreator_spec, tags):
partial_new_tile = Tile.insert(
master_tile.owner_id,
master_tile.report_id,
master_tile.dashboard_id,
skip_db=True,
tile_config={
'tw_type': master_tile.tile_options['tw_type'],
'tags': tags,
'series_spec_list': master_tile.series_specs(),
'tile_options': {
k: v
for k, v in master_tile.tile_options.items()
if k not in {'series_configs', 'tags', 'tile_title'}
}
})
new_tile_options = partial_new_tile.tile_options
if 'tpcreator_data' not in new_tile_options:
new_tile_options['tpcreator_data'] = {}
tile_title = master_tile.tile_options.get('tile_title')
if tile_title:
postfix = master_tile.tilewidget.generate_tile_title_postfix()
if postfix:
tile_title = tile_title.replace(postfix, '').strip()
new_tile_options['tpcreator_data']['tile_title_base'] = tile_title
new_tile_options.pop('tpcreator_uispec', None)
new_tile_options['tpcreator_data']['master_tile_id'] = master_tile.tile_id
new_tile_options['tpcreator_data'][
'master_tpcreator_uispec'] = copy.deepcopy(
master_tile.tile_options['tpcreator_uispec'])
new_tile_options['tpcreator_data'][
'master_tpcreator_spec'] = tpcreator_spec
return new_tile_options
def test_sscs_override_static_name(self):
tile_config = {
'tags': ['ip:192.168.1.1'],
'tw_type': 'Range',
'series_spec_list': [
SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
SeriesSpec(2, 0, dict(op='eq', args=['john'])),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user'
}
}
tile_config['series_spec_list'][0].params['static_name'] = 'monique_points'
self.assertEqual('monique_points', tile_config['series_spec_list'][0].name())
tile_config['tile_options']['sscs'] = tile_config['series_spec_list'][0]
rd = new_report_data('points')
tile = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id, tile_config)
layouts.place_tile(tile)
d = [OrderedDict([('user_name', 'robert'), ('is_active', True), ('points', 128)]),
OrderedDict([('user_name', 'monique'), ('is_active', True), ('points', 210)])]
res = rd.report.process_input(json.dumps(d), tags=tile_config['tags'])
tile = rd.only_tile_from_layout()
self.assertEqual(3, len(tile.series_specs()))
expected_ss = SeriesSpec(2, 0, dict(op='eq', args=['robert']))
self.assertEqual('robert', expected_ss.name())
self.assertEqual('robert', tile.series_specs()[-1].name())
def main():
owner_id = uuid.uuid4()
report = Report.select_or_insert(owner_id, 'simple_report')
res = report.process_input('1 2 3')
assert res.report_instance
owner_dashboards = OwnerDashboards(
owner_id, insert_if_no_dashboards='Default Dashboard')
assert owner_dashboards.dashboards
tile_config = {
'series_spec_list': [SeriesSpec(0, -1, {
'op': 'eq',
'args': ['0']
})],
}
tile = Tile.insert(owner_id, report.report_id,
owner_dashboards.dashboards[0].dashboard_id,
tile_config)
assert tile
assert tile.get_tile_data()
print 'Successfully created a dashboard with a tile'
owner_dashboards.dashboards[0].delete()
def test_layout_sorting_complex_tag_names_2(self):
owner_id = uuid.uuid4()
dashboard_id = uuid.uuid4()
rep = reports.Report.insert(owner_id, 'r')
tile_config = {
'tags': ['server:web.1'],
'series_spec_list':
[dataseries.SeriesSpec(0, -1, {
'op': 'eq',
'args': '0'
})],
'tile_options': {
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['server:web.1'])
}
}
master_tile = Tile.insert(owner_id, rep.report_id, dashboard_id,
tile_config)
layouts.place_tile(master_tile)
rep.process_input('1', tags=['server:worker.1'])
rep.process_input('1', tags=['server:web.2'])
layout = layouts.Layout.select(owner_id, dashboard_id)
tiles = sorted(
layout.tile_dict,
key=lambda tile:
(layout.tile_dict[tile]['y'], layout.tile_dict[tile]['x']))
tags_lists = [tile.tags for tile in tiles]
self.assertEqual(
[['server:web.1'], ['server:web.2'], ['server:worker.1']],
tags_lists)
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]
def test_sscs_virtual_column(self):
owner_id = uuid.uuid1()
od = dashboards.OwnerDashboards(owner_id)
dashboard_id = od.dashboards[0].dashboard_id
r = Report.insert(owner_id, 'r')
tile_config = {
'tw_type': 'Single',
'series_spec_list': [
SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {}
}
tile_config['tile_options']['sscs'] = tile_config['series_spec_list'][
0]
tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config)
layouts.place_tile(tile)
for inp in ['0', '1', '2\n3', '3\n4\n5\n']:
res = r.process_input(inp)
tile = Tile.select(
dashboard_id,
Layout.select(owner_id, dashboard_id).layout_dict.keys()[0])
self.assertEqual(3, len(tile.series_specs()))
return tile, r
def test_single__text_single_drawer(self):
rd = new_report_data('points', tags=['ip:192.168.1.1'])
tile_config = {
'tw_type':
'Single',
'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'])),
'drawer_type':
'TextSingleDrawer'
}
}
tile_config['tile_options'][
'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec(
tile_config['tags'])
tile = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config)
layouts.place_tile(tile)
self.assertEqual(tile.tile_options['drawer_type'], 'TextSingleDrawer')
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
pr = rd.report.process_input(json.dumps(d),
tags=['ip:192.168.1.1'],
extra_ri_data={'ed': 88})
tile = rd.only_tile_from_layout()
data = tile.get_new_tile_data(pr.report_instance.report_instance_id)
self.assertEqual(2, len(data['series_data']))
self.assertEqual([], data['series_data'][0]['data_points'])
self.assertEqual([], data['series_data'][1]['data_points'])
data = tile.get_new_tile_data(rd.instances[-1].report_instance_id)
self.assertEqual(2, len(data['series_data']))
self.assertEqual([], data['series_data'][0]['data_points'])
self.assertEqual(128, data['series_data'][1]['data_points'][0].value)
data = tile.get_new_tile_data(rd.instances[-3].report_instance_id)
self.assertEqual(2, len(data['series_data']))
self.assertEqual([], data['series_data'][0]['data_points'])
self.assertEqual(128, data['series_data'][1]['data_points'][0].value)
data = tile.get_new_tile_data(None)
self.assertEqual(2, len(data['series_data']))
self.assertEqual([], data['series_data'][0]['data_points'])
self.assertEqual(128, data['series_data'][1]['data_points'][0].value)
return tile
def test_promote_first_as_master_multiple_masters_one_apply_mods_run(self):
rd = self.test_repack_dont_put_master_first()
tile_config = {
'tags': ['q1:10'],
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {
'tpcreator_uispec': [{
'tag': 'q1:10',
'prefix': 'q1:'
}],
}
}
r2 = Report.insert(rd.owner_id, 'r2')
master_tile2 = Tile.insert(rd.owner_id, r2.report_id, rd.dashboard_id,
tile_config)
layouts.place_tile(master_tile2)
ri1 = r2.process_input('0', tags=['q1:8'],
handle_tpcreator=False).report_instance
ri2 = r2.process_input('0', tags=['q1:12'],
handle_tpcreator=False).report_instance
ri3 = r2.process_input('0', tags=['q1:6'],
handle_tpcreator=False).report_instance
ri4 = rd.report.process_input('0',
tags=['p1:2'],
handle_tpcreator=False).report_instance
layout_rows_tpcreator = c.dao.LayoutDAO.select_layout_by_report_multi(
rd.owner_id, rd.report_id, [], 'tpcreator', 100)
mods = [
tpcreator.tpcreator_mod(ri1, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri2, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri3, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri4, layout_rows_tpcreator[0]),
layouts.repack_mod(put_master_first=False),
layouts.promote_first_as_master_mod(),
layouts.if_mod(lambda layout_mod: layout_mod.tile_replacement,
layouts.repack_mod())
]
layouts.apply_mods(mods, rd.owner_id, rd.dashboard_id, None)
self.assertEqual([['p1:2'], ['p1:6'], ['p1:8'], ['p1:10'], ['p1:12'],
['q1:6'], ['q1:8'], ['q1:10'], ['q1:12']],
[tile.tags for tile in rd.tiles_sorted_by_vo()])
master1 = rd.get_tile_by_tags(['p1:2'])
master2 = rd.get_tile_by_tags(['q1:6'])
self.assertTrue(master1.is_master_tile())
self.assertTrue(master2.is_master_tile())
for tile in rd.tiles_sorted_by_vo():
if tile.tags[0].startswith(
'p') and tile.tile_id != master1.tile_id:
self.assertEqual(master1.tile_id, tile.get_master_tile_id())
elif tile.tags[0].startswith(
'q') and tile.tile_id != master2.tile_id:
self.assertEqual(master2.tile_id, tile.get_master_tile_id())
def test_range__chart_range_drawer(self):
rd = new_report_data('points', tags=['ip:192.168.1.1'])
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'])),
}
}
tile_config['tile_options'][
'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec(
tile_config['tags'])
tile = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config)
layouts.place_tile(tile)
self.assertEqual(tile.tile_options['drawer_type'], 'ChartRangeDrawer')
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d),
tags=['ip:192.168.1.1'],
extra_ri_data={'ed': 88})
tile = rd.only_tile_from_layout()
data = tile.get_tile_data()
self.assertEqual('points (monique, robert3)',
data['generated_tile_title'])
self.assertEqual('[ip:192.168.1.1]',
data['generated_tile_title_postfix'])
self.assertEqual(0, data['extra_options']['y_axis_min'])
self.assertIsInstance(data['fetched_from_dt'], datetime.datetime)
self.assertIsInstance(data['fetched_to_dt'], datetime.datetime)
self.assertEqual({'ed': 88}, data['latest_extra_ri_data'])
self.assertEqual('points', data['report_name'])
self.assertEqual(2, len(data['series_data']))
for sd in data['series_data']:
self.assertIsInstance(sd['series_id'], uuid.UUID)
self.assertEqual('points', data['common_header'])
self.assertTrue(sd['data_points'])
for dp in sd['data_points']:
self.assertIsInstance(dp, tilewidgets.DataPoint)
self.assertEqual(mqeconfig.DEFAULT_COLORS[:2], data['combined_colors'])
self.assertEqual('points', data['common_header'])
return tile
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_sscs_different_tag(self):
rd, tile = self.test_sscs()
tile_config = {
'tags': [],
'tw_type':
'Range',
'series_spec_list': [
SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
SeriesSpec(2, 0, dict(op='eq', args=['john'])),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user'
}
}
tile_config['tile_options']['sscs'] = tile_config['series_spec_list'][
1]
tile2 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config)
layouts.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)]),
]
res = rd.report.process_input(json.dumps(d))
tile2 = rd.tile_from_layout(1, 2)
self.assertEqual(7, len(tile2.series_specs()))
self.assertEqual(SeriesSpec(2, 0, dict(op='eq', args=['robert2'])),
tile2.series_specs()[-1])
d = [
OrderedDict([('user_name', 'monique4'), ('is_active', True),
('points', 128)])
]
res = rd.report.process_input(json.dumps(d), tags=['ip:192.168.1.1'])
tile2 = rd.tile_from_layout(0, 2)
self.assertEqual(7, len(tile2.series_specs()))
tile = rd.tile_from_layout(1, 2)
self.assertEqual(6, len(tile.series_specs()))
self.assertEqual(SeriesSpec(2, 0, dict(op='eq', args=['monique4'])),
tile.series_specs()[-1])
def test_insert_invalid_report(self):
tile_config = {
'tags': ['ip:192.168.1.1'],
'series_spec_list': [],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user'
}
}
self.assertRaises(ValueError, lambda: \
Tile.insert(uuid.uuid1(), uuid.uuid1(), uuid.uuid1(), tile_config))
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
SECTION('tags')
cpu_report = Report.select_or_insert(owner_id, 'cpu_usage')
metrics = [
('user', 92.3),
('system', 3.4),
('io', 4.4),
]
cpu_report.process_input(json.dumps(metrics),
tags=['ip:192.168.1.18', 'warning'])
tile_config_1 = {
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_1 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_1)
tile_config_2 = {
'tags': ['ip:192.168.1.18', 'warning'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_2 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_2)
def test_layout_sorting(self):
rd = new_report_data('points', ['p1:10'])
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)])
]
nums = [30, 20, 12, 11, 40, 98]
for num in nums:
rd.report.process_input(json.dumps(d), tags=['p1:%s' % num])
ld = rd.layout()
self.assertEqual(len(nums) + 1, len(ld.layout_dict.keys()))
self.assertEqual(
len(nums) + 1, len(ld.layout_props['by_tile_id'].keys()))
layout_items = sorted(ld.layout_dict.items(),
key=lambda (tile_id, vo): (vo['y'], vo['x']))
layout_tags = [
ld.layout_props['by_tile_id'][tile_id]['tags'][0]
for (tile_id, vo) in layout_items
]
expected_tags = ['p1:10'] + sorted(['p1:%s' % num for num in nums])
self.assertEqual(set(expected_tags), set(layout_tags))
self.assertEqual(expected_tags, layout_tags)
def test_deleting_layout_by_report_row(self):
owner_id = uuid.uuid1()
dashboard_id_1 = uuid.uuid1()
r = reports.Report.insert(owner_id, 'r')
tile_config = {
'tw_type':
'Single',
'tags': ['p1:10'],
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {}
}
tile_config['tile_options'][
'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec(
['p1:10'])
master_tile_1 = Tile.insert(owner_id, r.report_id, dashboard_id_1,
tile_config)
layouts.place_tile(master_tile_1)
r.process_input('1', tags=['p1:11'])
self.assertEqual(
2,
len(
Layout.select(master_tile_1.owner_id,
master_tile_1.dashboard_id).layout_dict))
rows = c.dao.LayoutDAO.select_layout_by_report_multi(
master_tile_1.owner_id, master_tile_1.report_id, [], 'tpcreator',
100)
self.assertTrue(rows)
layouts.detach_tile(master_tile_1)
r.process_input('1', tags=['p1:12'])
self.assertEqual(
1,
len(
Layout.select(master_tile_1.owner_id,
master_tile_1.dashboard_id).layout_dict))
rows = c.dao.LayoutDAO.select_layout_by_report_multi(
master_tile_1.owner_id, master_tile_1.report_id, [], 'tpcreator',
100)
self.assertFalse(rows)
def test_layout_sorting_complex_tag_names(self):
owner_id = uuid.uuid4()
dashboard_id = uuid.uuid4()
rep = reports.Report.insert(owner_id, 'r')
tile_config = {
'tags': ['server0:0', 'service1:search.1'],
'series_spec_list':
[dataseries.SeriesSpec(0, -1, {
'op': 'eq',
'args': '0'
})],
'tile_options': {
'tpcreator_uispec': [{
'tag': 'server0:0',
'prefix': 'server0:0'
}, {
'tag': 'service1:search.1',
'prefix': 'service1:'
}],
}
}
tile_config['tile_options'][
'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec(
tile_config['tags'])
master_tile = Tile.insert(owner_id, rep.report_id, dashboard_id,
tile_config)
layouts.place_tile(master_tile)
for i in range(8, 13):
rep.process_input(str(i),
tags=['server0:0',
'service1:search.%d' % i])
layout = layouts.Layout.select(owner_id, dashboard_id)
tiles = sorted(
layout.tile_dict,
key=lambda tile:
(layout.tile_dict[tile]['y'], layout.tile_dict[tile]['x']))
tags_lists = [tile.tags for tile in tiles]
self.assertEqual([['server0:0', 'service1:search.1'],
['server0:0', 'service1:search.8'],
['server0:0', 'service1:search.9'],
['server0:0', 'service1:search.10'],
['server0:0', 'service1:search.11'],
['server0:0', 'service1:search.12']], tags_lists)
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_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_tpcreator_as_mod_performance(self):
owner_id = uuid.uuid4()
dashboard_id = uuid.uuid4()
tile_config = {
'tags': ['str:sample_string'],
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {
'tpcreator_uispec': [{
'tag': 'str:sample_string',
'prefix': 'str:'
}],
}
}
r = reports.Report.insert(owner_id, 'r')
master_tile = Tile.insert(owner_id, r.report_id, dashboard_id,
tile_config)
layouts.place_tile(master_tile)
strs = [random_string() for _ in xrange(199)]
mods = []
layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(
owner_id, r.report_id, [], 'tpcreator', 100)
start = time()
for str in strs:
res = r.process_input('1',
tags=['str:%s' % str],
handle_tpcreator=False)
mods.append(
tpcreator.tpcreator_mod(res.report_instance, layout_rows[0],
200))
print 'Creating report instances took %.1f' % ((time() - start) * 1000)
start = time()
layouts.apply_mods(mods, owner_id, dashboard_id, None)
print 'Applying tpcreator_mods took %.1f' % ((time() - start) * 1000)
layout = Layout.select(owner_id, dashboard_id)
self.assertEqual(200, len(layout.layout_dict))
tags_set = {tile.tags[0].split(':')[1] for tile in layout.tile_dict}
self.assertEqual(200, len(tags_set))
self.assertEqual(tags_set, set(strs + ['sample_string']))
def test_no_repack(self):
tile_config = {
'tags': ['p1:10'],
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {
'tpcreator_uispec': [{
'tag': 'p1:10',
'prefix': 'p1:'
}],
}
}
rd = ReportData('r')
master_tile = Tile.insert(rd.owner_id, rd.report_id, rd.dashboard_id,
tile_config)
layouts.place_tile(master_tile)
ri1 = rd.report.process_input('0',
tags=['p1:8'],
handle_tpcreator=False).report_instance
ri2 = rd.report.process_input('0',
tags=['p1:12'],
handle_tpcreator=False).report_instance
ri3 = rd.report.process_input('0',
tags=['p1:6'],
handle_tpcreator=False).report_instance
layout_rows_tpcreator = c.dao.LayoutDAO.select_layout_by_report_multi(
rd.owner_id, rd.report_id, [], 'tpcreator', 100)
mods = [
tpcreator.tpcreator_mod(ri1, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri2, layout_rows_tpcreator[0]),
tpcreator.tpcreator_mod(ri3, layout_rows_tpcreator[0]),
]
layouts.apply_mods(mods, rd.owner_id, rd.dashboard_id, None)
self.assertEqual([['p1:10'], ['p1:8'], ['p1:12'], ['p1:6']],
[tile.tags for tile in rd.tiles_sorted_by_vo()])
return rd
def test_tpcreator_as_mod(self):
owner_id = uuid.uuid4()
dashboard_id = uuid.uuid4()
tile_config = {
'tags': ['p1:10'],
'series_spec_list': [
dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {
'tpcreator_uispec': [{
'tag': 'p1:10',
'prefix': 'p1:'
}],
}
}
r = reports.Report.insert(owner_id, 'r')
master_tile = Tile.insert(owner_id, r.report_id, dashboard_id,
tile_config)
layouts.place_tile(master_tile)
ri1 = r.process_input('0', tags=['p1:11'],
handle_tpcreator=False).report_instance
ri2 = r.process_input('0', tags=['p1:12'],
handle_tpcreator=False).report_instance
ri3 = r.process_input('0', tags=['p1:12'],
handle_tpcreator=False).report_instance
layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(
owner_id, r.report_id, [], 'tpcreator', 100)
mods = [
tpcreator.tpcreator_mod(ri1, layout_rows[0]),
tpcreator.tpcreator_mod(ri2, layout_rows[0]),
tpcreator.tpcreator_mod(ri3, layout_rows[0])
]
layouts.apply_mods(mods, owner_id, dashboard_id, None)
layout = Layout.select(owner_id, dashboard_id)
self.assertEqual(3, len(layout.layout_dict))
self.assertEqual([['p1:10'], ['p1:11'], ['p1:12']],
sorted(tile.tags for tile in layout.tile_dict))
def test_expire_tiles_without_data_losing_sscreated(self):
rd = ReportData('r')
ss = dataseries.SeriesSpec(0, -1, dict(op='eq', args=['0']))
tile_config1 = {
'series_spec_list': [ss],
'tags': ['p1:10'],
'tile_options': {
'tpcreator_uispec':
tpcreator.suggested_tpcreator_uispec(['p1:10']),
'sscs': ss
}
}
tile1 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config1)
place_tile(tile1)
#rd.report.process_input('1', tags=['p1:10'])
rd.report.process_input('1\n2\n', tags=['p1:11'])
rd.report.process_input('1\n2\n3\n', tags=['p1:12'])
self.assertEqual(3, len(rd.layout().layout_dict))
self.assertEqual(3, len(rd.get_tile_by_tags(['p1:12']).series_specs()))
tile1_created_ago = datetime.datetime.utcnow(
) - util.datetime_from_uuid1(tile1.tile_id)
tiles.expire_tiles_without_data(
rd.layout().tile_dict.keys(),
tile1_created_ago.total_seconds() - 0.00001,
rd.layout().layout_id)
self.assertEqual(2, len(rd.layout().layout_dict))
self.assertTrue(rd.layout_has_tags([['p1:11'], ['p1:12']]))
master_tile = rd.get_tile_by_tags(['p1:11'])
self.assertTrue(master_tile.is_master_tile())
self.assertEqual(master_tile.tile_id,
rd.get_tile_by_tags(['p1:12']).get_master_tile_id())
self.assertEqual(3, len(rd.get_tile_by_tags(['p1:12']).series_specs()))