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