def test_fetch_reports_by_name(self): owner_id = uuid.uuid1() all_rs = [ Report.insert(owner_id, 'rep%02d' % i) for i in range(10, 20) ] all_rs[:0] = [ Report.insert(owner_id, 'rep%02d' % i) for i in range(10) ] rs = reports.fetch_reports_by_name(owner_id) self.assertEqual(all_rs, rs) rs = reports.fetch_reports_by_name(owner_id, limit=5) self.assertEqual(all_rs[:5], rs) rs = reports.fetch_reports_by_name(owner_id, name_prefix='rep1') self.assertEqual(all_rs[10:], rs) rs = reports.fetch_reports_by_name(owner_id, name_prefix='rep1', after_name='rep15') self.assertEqual(all_rs[16:], rs) rs = reports.fetch_reports_by_name(owner_id, after_name='rep15') self.assertEqual(all_rs[16:], rs) rs = reports.fetch_reports_by_name(owner_id, after_name='x') self.assertFalse(rs) rs = reports.fetch_reports_by_name(uuid.uuid1()) self.assertFalse(rs) rs = reports.fetch_reports_by_name(owner_id, after_name='a', limit=1) self.assertEqual(all_rs[:1], rs)
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_owner_has_reports(self): owner_id = uuid.uuid1() self.assertFalse(reports.owner_has_reports(owner_id)) Report.insert(owner_id, 'a') self.assertTrue(reports.owner_has_reports(owner_id))
def test_counts(self): owner_id = uuid.uuid1() r = Report.insert(owner_id, 'a') r.process_input('1') r.process_input('2') r2 = Report.insert(owner_id, 'b') r.process_input('1') r.process_input('2') self.assertEqual(4, reports.report_instance_count_for_owner(owner_id)) self.assertEqual(4, reports.report_instance_diskspace_for_owner(owner_id))
def test_delete_simple(self): owner_id = uuid.uuid1() r1 = Report.insert(owner_id, 'r1') r1.process_input('1') r2 = Report.insert(owner_id, 'r2') r2.process_input('2') ids = reports.fetch_reports_by_name(owner_id, 'r') self.assertEqual(2, len(ids)) r2.delete() reps = reports.fetch_reports_by_name(owner_id, 'r') self.assertEqual([r1], reps) self.assertIsNone(Report.select(r2.report_id))
def create_multi_day_report(self): owner_id = uuid.uuid4() r = Report.select_or_insert(owner_id, 'pi') def process(val, minus_days, tags): res = r.process_input(str(val), created=datetime.datetime.utcnow() - datetime.timedelta(days=minus_days), tags=tags) self.assertIsNotNone(res.report_instance) process(0, 500, ['t1', 't2']) process(-1, 532, ['t2']) process(1, 432, ['t1', 't2']) process(2, 410, ['t1', 't2']) process(3, 360, ['t1', 't2']) process(4, 330, ['t1']) process(5, 73, ['t1']) process(6, 12, ['t2']) process(7, 11, ['t1']) all_ris = r.fetch_instances( datetime.datetime.utcnow() - datetime.timedelta(days=600), datetime.datetime.utcnow()) self.assertEqual('-1 0 1 2 3 4 5 6 7'.split(), [ri['input_string'] for ri in all_ris]) return r, all_ris
def test_custom_get_parsing_result_desc(self): old = mqeconfig.get_parsing_result_desc try: def get_parsing_result_desc(parsing_result, table): res = {'num_rows': table.num_rows} if parsing_result.input_type == 'single': res['input_is_json'] = True return res mqeconfig.get_parsing_result_desc = get_parsing_result_desc owner_id = uuid.uuid1() r = Report.insert(owner_id, 'r') r.process_input('1\n2\n3\n') ri = r.fetch_instances(order='desc', limit=1)[0] self.assertEqual(3, ri.parsing_result_desc['num_rows']) self.assertEqual(None, ri.parsing_result_desc.get('input_is_json')) r.process_input('1\n2\n', input_type='single') ri = r.fetch_instances(order='desc', limit=1)[0] self.assertEqual(1, ri.parsing_result_desc['num_rows']) self.assertEqual(True, ri.parsing_result_desc.get('input_is_json')) finally: mqeconfig.get_parsing_result_desc = old
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 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_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_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_process_input_invalid_args(self): owner_id = uuid.uuid4() r = Report.select_or_insert(owner_id, 'pi') self.assertRaises(AssertionError, lambda: r.process_input(43)) self.assertRaises( ValueError, lambda: r.process_input( '3', created=datetime.datetime(1990, 3, 4)))
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_process_input_format_spec(self): owner_id = uuid.uuid4() r = Report.select_or_insert(owner_id, 'pi') res = r.process_input('v1:10\nv2:20', input_type='csv', ip_options={'delimiter': ':'}, force_header=[0]) self.assertEqual( EnrichedTable(Table([['v1', '10'], ['v2', '20']], [0])), res.report_instance.table)
def test_tags(self): r, all_ris = self.create_multi_day_report() self.assertTrue(r.has_tags()) self.assertEqual(['t1', 't2'], r.fetch_tags_sample()) self.assertEqual(['t1'], r.fetch_tags_sample('t1')) r2 = Report.insert(uuid.uuid1(), 'r2') self.assertFalse(r2.has_tags()) self.assertFalse(r2.fetch_tags_sample('t'))
def autocomplete_tag_name(): report_id = request.get_json()['report_id'] term = request.get_json()['term'] check_access(lambda: auth.access_report_instances(report_id)) report = Report.select(report_id) tags = report.fetch_tags_sample(term, AUTOCOMPLETE_TAG_NAME_LIMIT) return success(result=dict(data=tags))
def report_instances_days(): report_name = request.get_json()['report_name'] tags = request.get_json().get('tags') check_access(lambda: auth.access_profile()) report = Report.select_by_name(auth.logged_owner_id(), report_name) days_dts = report.fetch_days(tags) days = [dt.strftime('%Y-%m-%d') for dt in days_dts] return success(result=dict(days=days))
def test_fetch_days(self): r, all_ris = self.create_multi_day_report() dts = r.fetch_days() for dt in dts: self.assertIsInstance(dt, datetime.datetime) r2 = Report.insert(uuid.uuid1(), 'r2') self.assertFalse(r2.fetch_days()) ri = r2.process_input('2').report_instance self.assertEqual(datetime.datetime.utcnow().date(), ri.created.date())
def render_series_spec_creator_spec(): report_id = request.get_json()['report_id'] report_instance_id = request.get_json()['report_instance_id'] template_ss = request.get_json()['template_ss'] check_access(lambda: auth.access_report_instances(report_id)) report = Report.select(report_id) report_instance = report.fetch_single_instance(report_instance_id) html = get_template_attribute('m.html', 'series_spec_creator_spec')(template_ss, report_instance) return success(result=dict(html=html))
def test_delete_single_instance_same_created_dt(self): owner_id = uuid.uuid1() r = Report.insert(owner_id, 'r') created_ris = [] for i in xrange(20): res = r.process_input(str(i), created=datetime.datetime(2017, 1, 1)) created_ris.append(res.report_instance) r.delete_single_instance(created_ris[10].report_instance_id) ris = r.fetch_instances() self.assertEqual({str(i) for i in xrange(20) if i != 10}, {ri['input_string'] for ri in ris})
def compute_series_spec(): report_id = request.get_json()['report_id'] report_instance_id = request.get_json()['report_instance_id'] sample = request.get_json()['sample'] check_access(lambda: auth.access_report_instances(report_id)) report = Report.select(report_id) report_instance = report.fetch_single_instance(report_instance_id) series_spec = dataseries.guess_series_spec(report, report_instance, sample['rowno'], sample['colno']) if series_spec is None: return error() series_spec_html = get_template_attribute('m.html', 'series_spec')(series_spec, report_instance) return success(result=dict(series_spec=series_spec, series_spec_html=series_spec_html))
def render_empty_series_spec(): report_id = request.get_json()['report_id'] report_instance_id = request.get_json()['report_instance_id'] check_access(lambda: auth.access_report_instances(report_id)) report = Report.select(report_id) report_instance = report.fetch_single_instance(report_instance_id) if report_instance.table.num_columns > 1: series_spec = dataseries.SeriesSpec(0, 0, {'op': 'eq', 'args': []}) else: series_spec = dataseries.SeriesSpec(0, -1, {'op': 'eq', 'args': ['0']}) series_spec.set_name('') series_spec_html = get_template_attribute('m.html', 'series_spec')(series_spec, report_instance) return success(result=dict(series_spec_html=series_spec_html))
def report_instance_for_viewer(): report_name = request.get_json()['report_name'] tags = request.get_json().get('tags') curr_report_instance_id = request.get_json()['curr_report_instance_id'] direction = request.get_json().get('direction') search_date = request.get_json().get('search_date') check_access(lambda: auth.access_profile()) report = Report.select_by_name(auth.logged_owner_id(), report_name) if not curr_report_instance_id: curr_report_instance_id = report.fetch_latest_instance_id(tags) if not curr_report_instance_id: return error() if not direction: if search_date is not None: ri = report.find_report_instance_by_dt(search_date, tags) else: ri = report.fetch_single_instance(curr_report_instance_id) elif direction == 'next': ri = report.fetch_next_instance(curr_report_instance_id, tags) elif direction == 'prev': ri = report.fetch_prev_instance(curr_report_instance_id, tags) else: return error('Wrong direction') res = {} res['report_id'] = report.report_id res['report_has_tags'] = report.has_tags() if ri: res['html_newest_table'] = get_template_attribute('m.html', 'table_as_html_table')(ri.table) res['created_raw'] = datetime_from_uuid1(ri.report_instance_id) res['created'] = format_datetime(datetime_from_uuid1(ri.report_instance_id)) res['tags'] = Markup(' '.join('<span class="selected-tag-name clickable">%s</span>' % tag for tag in ri.all_tags)) res['curr_report_instance_id'] = ri.report_instance_id res['has_next'] = report.fetch_next_instance(ri.report_instance_id, tags) is not None res['has_prev'] = report.fetch_prev_instance(ri.report_instance_id, tags) is not None else: res['html_newest_table'] = '' res['created_raw'] = '' res['created'] = '' res['tags'] = '' res['curr_report_instance_id'] = None res['has_next'] = False res['has_prev'] = False return success(result=res)
def matching_cell_for_series_spec(): report_id = request.get_json()['report_id'] report_instance_id = request.get_json()['report_instance_id'] series_spec = request.get_json()['series_spec'] check_access(lambda: auth.access_report_instances(report_id)) report = Report.select(report_id) report_instance = report.fetch_single_instance(report_instance_id) if not report_instance: return error('No report instance') cell = series_spec.get_cell(report_instance) if not cell: return success() return success(result=dict(rowno=cell.rowno, colno=cell.colno))
def selected_tags_change(): report_id = request.get_json()['report_id'] tags = request.get_json()['tags'] check_access(lambda: auth.access_report_instances(report_id)) report = Report.select(report_id) latest_instance_id = report.fetch_latest_instance_id(tags) if not latest_instance_id: return error() ri = report.fetch_single_instance(latest_instance_id, tags) if not ri: return error('No report instance %s' % latest_instance_id) res = {} res['html_newest_table'] = get_template_attribute('m.html', 'table_as_html_table')(ri.table) res['latest_instance_id'] = latest_instance_id return success(result=res)
def test_process_input(self): owner_id = uuid.uuid4() r = Report.select_or_insert(owner_id, 'pi') dt = datetime.datetime(2010, 5, 30, 6, 30) res = r.process_input('10 20 30', tags=['t1', 't2', 't3'], created=dt, extra_ri_data=[1, 2, 3]) self.assertEqual(['t1', 't2', 't3'], res.report_instance.all_tags) self.assertEqual(dt, res.report_instance.created) self.assertEqual(EnrichedTable(Table([['10', '20', '30']])), res.report_instance.table) self.assertEqual([1, 2, 3], res.report_instance.fetch_extra_ri_data()) desc = res.report_instance.desc(True, True) self.assertEqual(res.report_instance.report_instance_id.hex, desc['id']) self.assertEqual(1, len(desc['rows'])) self.assertIn(' 20 ', desc['input'])
def test_find_report_instance_by_dt(self): r, all_ris = self.create_multi_day_report() ri = r.find_report_instance_by_dt(all_ris[3].created + datetime.timedelta(hours=1)) self.assertEqual(all_ris[3], ri) ri = r.find_report_instance_by_dt(all_ris[3].created - datetime.timedelta(hours=1)) self.assertEqual(all_ris[3], ri) ri = r.find_report_instance_by_dt(util.MIN_DATETIME) self.assertEqual(all_ris[0], ri) ri = r.find_report_instance_by_dt(util.MAX_DATETIME) self.assertEqual(all_ris[-1], ri) r2 = Report.insert(uuid.uuid1(), 'r2') ri = r2.find_report_instance_by_dt(util.MIN_DATETIME) self.assertIsNone(ri)
def test_insert_and_select(self): owner_id = uuid.uuid4() r1 = Report.insert(owner_id, 'rep') self.assertIsNotNone(r1) r2 = Report.insert(owner_id, 'rep') self.assertIsNone(r2) rs = Report.select_by_name(owner_id, 'rep') self.assertEqual(r1, rs) rs2 = Report.select(rs.report_id) self.assertEqual(rs2, rs) r2 = Report.insert(owner_id, 'rep_2') self.assertIsNotNone(r2) self.assertNotEqual(r2, rs) r3 = Report.select_or_insert(owner_id, 'rep_3') r3_2 = Report.select(r3.report_id) r3_3 = Report.select_or_insert(owner_id, 'rep_3') self.assertEqual(r3, r3_2) self.assertEqual(r3, r3_3)
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)