def test_expire_tiles_without_data(self):
rd1 = new_report_data('points')
rd2 = new_report_data('points')
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(rd1.owner_id, rd1.report.report_id,
rd1.dashboard_id, tile_config_1)
place_tile(tile1)
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=['john20'])),
],
'tile_options': {
'seconds_back': 86400,
}
}
tile2 = tiles.Tile.insert(rd2.owner_id, rd2.report.report_id,
rd2.dashboard_id, tile_config_2)
place_tile(tile2)
self.assertFalse(
tile2.get_tile_data()['series_data'][0]['data_points'])
res = tiles.expire_tiles_without_data([tile1, tile2],
3600,
Layout.select(
rd1.owner_id,
rd1.dashboard_id).layout_id,
optimize_check=True)
self.assertIsNone(res)
time.sleep(0.5)
rd2.report.process_input('0')
res = tiles.expire_tiles_without_data([tile1, tile2],
0.5,
Layout.select(
rd1.owner_id,
rd1.dashboard_id).layout_id,
optimize_check=True)
self.assertTrue(res)
self.assertFalse(Tile.select(rd1.dashboard_id, tile1.tile_id))
self.assertTrue(Tile.select(rd2.dashboard_id, tile2.tile_id))
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 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_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_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_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_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_handle_tpcreator_multiple_masters(self):
rd = new_report_data('points')
tile_config_1 = {
'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_1['tile_options'][
'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec(
tile_config_1['tags'])
master_tile_1 = Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config_1)
layouts.place_tile(master_tile_1)
tile_config_2 = {
'tw_type':
'Range',
'tags': ['p2:20'],
'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_2['tile_options'][
'tpcreator_uispec'] = tpcreator.suggested_tpcreator_uispec(
tile_config_2['tags'])
master_tile_2 = Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config_2)
layouts.place_tile(master_tile_2)
# tile config of 2.
master_tile_3 = Tile.insert(rd.owner_id, rd.report.report_id,
rd.dashboard_id, tile_config_2)
layouts.place_tile(master_tile_3)
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d), tags=['p1:11'])
rd.report.process_input(json.dumps(d), tags=['p1:12'])
rd.report.process_input(json.dumps(d), tags=['p2:21'])
rd.report.process_input(json.dumps(d), tags=['p2:22'])
rd.report.process_input(json.dumps(d), tags=['p2:23'])
layout = layouts.Layout.select(rd.owner_id, rd.dashboard_id)
self.assertEqual(
2, len(layout.get_tpcreated_tile_ids(master_tile_1.tile_id)))
self.assertEqual(
3, len(layout.get_tpcreated_tile_ids(master_tile_2.tile_id)))
self.assertEqual(
3, len(layout.get_tpcreated_tile_ids(master_tile_3.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)
def test_tpcreator_creation_empty(self):
rd = new_report_data('points')
tile = self.test_insert(rd=rd)
place_tile(tile)
self.assertFalse(self._select_tpcreator_rows(tile))
def test_layout_modification_by_tpcreator(self):
data = {}
@signals.layout_modified.connect
def on_tiles_replaced(c, **kwargs):
if kwargs['reason'] != 'tpcreator':
return
data.clear()
data.update(kwargs)
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'])
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d), tags=['p1:20'])
d = [
OrderedDict([('user_name', 'robert3'), ('is_active', True),
('points', 128)])
]
rd.report.process_input(json.dumps(d), tags=['p1:30', 'p2:30'])
tile = util.first(tile for tile in rd.layout().tile_dict if tile.tags == \
['p1:30'])
self.assertIsNotNone(tile)
self.assertEqual(
tile, data['layout_modification_result'].new_tiles.keys()[0])
self.assertEqual(rd.layout().layout_id, data['layout_modification_result']. \
new_layout.layout_id)
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=['mike'])),
dataseries.SeriesSpec(2, 0, dict(op='eq',
args=['nonexisting'])),
],
'tile_options': {
'drawer_type':
'TextSingleDrawer',
'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'], 'TextSingleDrawer')
d = [
OrderedDict([('user_name', 'mike'), ('is_active', True),
('points', 32)]),
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 (mike, nonexisting, robert3)',
data['generated_tile_title'])
self.assertEqual('[ip:192.168.1.1]',
data['generated_tile_title_postfix'])
self.assertNotIn('extra_options', data)
self.assertNotIn('fetched_from_dt', data)
self.assertEqual({'ed': 88}, data['latest_extra_ri_data'])
self.assertEqual('points', data['report_name'])
self.assertEqual(3, len(data['series_data']))
for i, sd in enumerate(data['series_data']):
self.assertIsInstance(sd['series_id'], uuid.UUID)
self.assertEqual('points', data['common_header'])
if i == 1:
self.assertFalse(sd['data_points'])
else:
self.assertEqual(1, len(sd['data_points']))
for dp in sd['data_points']:
self.assertIsInstance(dp, tilewidgets.DataPoint)
self.assertEqual(3, len(data['combined_colors']))
self.assertEqual('points', data['common_header'])
return tile
