def test_list_charts(self):
req = dummy_request(self.session)
dashboard = Dashboard(title='Dashboard Title')
self.session.add(dashboard)
dashboard2 = Dashboard(title='Dashboard Title 2')
self.session.add(dashboard2)
data_source = DataSource(name='Datasource')
self.session.add(data_source)
self.session.flush()
req.json_body = {
'title': 'Title',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'unit': 'U'
}
chart = create_chart_view(req)
req.json_body = {
'title': 'Title 2',
'dashboard_id': dashboard2.id,
'data_source_id': data_source.id,
'unit': 'U'
}
create_chart_view(req)
req = dummy_request(self.session)
req.params = {}
charts = list_charts_view(req)
self.assertEqual(len(charts), 2)
req.params = {'dashboard_id': dashboard.id}
charts = list_charts_view(req)
self.assertEqual(len(charts), 1)
self.assertEqual(charts[0]['id'], chart['id'])
def test_list_single_stats(self):
req = dummy_request(self.session)
dashboard = Dashboard(title='Dashboard Title')
self.session.add(dashboard)
dashboard2 = Dashboard(title='Dashboard Title 2')
self.session.add(dashboard2)
data_source = DataSource(name='Data source')
self.session.add(data_source)
self.session.flush()
req.json_body = {
'title': 'Title 1',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'query': 'query',
'colors': '#eee,#000',
'thresholds': '1'
}
single_stat = create_single_stat_view(req)
req.json_body = {
'title': 'Title 2',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'query': 'query',
'colors': '#eee,#000',
'thresholds': '1'
}
create_single_stat_view(req)
req.json_body = {
'title': 'Title 3',
'dashboard_id': dashboard2.id,
'data_source_id': data_source.id,
'query': 'query',
'colors': '#eee,#000',
'thresholds': '1'
}
create_single_stat_view(req)
req = dummy_request(self.session)
req.params = {}
single_stats = list_single_stats_view(req)
self.assertEqual(len(single_stats), 3)
req.params = {'dashboard_id': dashboard.id}
single_stats = list_single_stats_view(req)
self.assertEqual(len(single_stats), 2)
self.assertEqual(single_stats[0]['id'], single_stat['id'])
def test_create_dashboard_in_collection(self):
collection = Collection(title='Title')
self.session.add(collection)
self.session.flush()
user = add_user(self.session)
req = dummy_request(self.session)
req.json_body = {
'title': 'Title',
'description': 'Description',
'collection_id': collection.id,
'users': [user.as_dict()]
}
resp = create_dashboard_view(req)
self.assertEqual(resp['title'], 'Title')
self.assertEqual(resp['collection_id'], collection.id)
self.assertEqual(resp['index'], 0)
self.assertEqual(resp['users'][0], user.as_dict())
req.json_body = {
'title': 'Title',
'description': 'Description',
'collection_id': collection.id
}
resp = create_dashboard_view(req)
self.assertEqual(resp['index'], 1)
def test_edit_dashboard_view(self):
collection = Collection(title='Title')
self.session.add(collection)
self.session.flush()
user = add_user(self.session)
dashboard = add_dashboard(self.session, title='Test title')
req = dummy_request(self.session)
with self.assertRaises(exc.HTTPBadRequest):
edit_dashboard_view(req)
req.matchdict = {'id': dashboard.id}
req.json_body = {
'title': 'Edit title',
'description': 'Description',
'collection_id': collection.id,
'type': 'new',
'content': '<h1>Hello world!</h1>',
'users': [user.as_dict()]
}
dashboard = edit_dashboard_view(req)
self.assertEqual(dashboard['title'], 'Edit title')
self.assertEqual(dashboard['description'], 'Description')
self.assertEqual(dashboard['type'], 'new')
self.assertEqual(dashboard['content'], '<h1>Hello world!</h1>')
self.assertEqual(dashboard['users'][0], user.as_dict())
def test_list_dashboards_view(self):
user = add_user(self.session)
self.config.testing_securitypolicy(userid=user.id, permissive=True)
add_dashboard(self.session, title='Dashboard 1')
add_dashboard(self.session, title='Dashboard 2')
add_dashboard(self.session, title='Dashboard 3', users=[user])
collection = Collection(title='Title')
self.session.add(collection)
self.session.flush()
add_dashboard(self.session,
title='Dashboard 4',
collection_id=collection.id)
add_dashboard(self.session,
title='Dashboard 5',
collection_id=collection.id,
users=[user])
req = dummy_request(self.session)
req.params = {}
dashboards = list_dashboards_view(req)
self.assertEqual(len(dashboards), 5)
req.params = {'collection_id': None}
dashboards = list_dashboards_view(req)
self.assertEqual(len(dashboards), 3)
req.params = {'collection_id': collection.id}
dashboards = list_dashboards_view(req)
self.assertEqual(len(dashboards), 2)
req.params = {'user_id': True}
dashboards = list_dashboards_view(req)
self.assertEqual(len(dashboards), 2)
def test_get_chart(self):
req = dummy_request(self.session)
dashboard = Dashboard(title='Dashboard Title')
self.session.add(dashboard)
data_source = DataSource(name='Datasource')
self.session.add(data_source)
self.session.flush()
with self.assertRaises(exc.HTTPBadRequest):
get_chart_view(req)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict = {'id': 100}
get_chart_view(req)
req.json_body = {
'title': 'Title',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'unit': 'U'
}
chart = create_chart_view(req)
chart_id = chart['id']
req.matchdict = {'id': chart_id}
chart = get_chart_view(req)
self.assertEqual(chart_id, chart['id'])
def test_get_single_stat(self):
req = dummy_request(self.session)
dashboard = Dashboard(title='Dashboard Title')
self.session.add(dashboard)
data_source = DataSource(name='Data source')
self.session.add(data_source)
self.session.flush()
with self.assertRaises(exc.HTTPBadRequest):
get_single_stat_view(req)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict = {'id': 100}
get_single_stat_view(req)
req.json_body = {
'title': 'Title',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'query': 'query',
'colors': '#eee,#000',
'thresholds': '1'
}
single_stat = create_single_stat_view(req)
single_stat_id = single_stat['id']
req.matchdict = {'id': single_stat_id}
single_stat = get_single_stat_view(req)
self.assertEqual(single_stat_id, single_stat['id'])
def test_delete_chart(self):
req = dummy_request(self.session)
dashboard = Dashboard(title='Dashboard Title')
self.session.add(dashboard)
data_source = DataSource(name='Datasource')
self.session.add(data_source)
self.session.flush()
req.json_body = {
'title': 'Title',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'unit': 'U'
}
chart = create_chart_view(req)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict = {'id': 0}
delete_chart(req)
req.matchdict = {"id": chart['id']}
delete_chart(req)
with self.assertRaises(exc.HTTPNotFound):
get_chart_view(req)
def test_list_queries(self):
datasource = DataSource(name='datasource')
self.session.add(datasource)
dash = add_dashboard(self.session, 'Dash', 'Dashboard')
dash2 = add_dashboard(self.session, 'Dash2', 'Dashboard')
self.session.add(
Query(name='Query',
query='query string',
dashboard_id=dash.id,
data_source_id=datasource.id))
self.session.add(
Query(name='Query2',
query='query string',
dashboard_id=dash.id,
data_source_id=datasource.id))
self.session.add(
Query(name='Query3',
query='query',
dashboard_id=dash2.id,
data_source_id=datasource.id))
req = dummy_request(self.session)
req.params = {}
resp = list_queries_view(req)
self.assertEqual(len(resp), 3)
req.matchdict = {'dashboard_id': dash.id}
resp = list_queries_view(req)
self.assertEqual(len(resp), 2)
def test_get_query(self):
datasource = DataSource(name='datasource')
self.session.add(datasource)
dash = add_dashboard(self.session, 'Dash', 'Dashboard')
query = Query(name='Query',
query='query string',
dashboard_id=dash.id,
data_source_id=datasource.id)
self.session.add(query)
self.session.flush()
req = dummy_request(self.session)
req.matchdict = {}
with self.assertRaises(exc.HTTPBadRequest):
get_query_view(req)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict['id'] = 100
get_query_view(req)
req.matchdict['id'] = query.id
resp = get_query_view(req)
self.assertEqual(resp['id'], query.id)
self.assertEqual(resp['name'], 'Query')
def test_edit_collection(self):
user1 = add_user(self.session, role=User, email='*****@*****.**', firstname='User1')
user2 = add_user(self.session, role=User, email='*****@*****.**', firstname='User2')
collection = add_collection(self.session, 'Collection', 'Description', users=[user1])
self.assertEqual(collection.users[0], user1)
req = dummy_request(self.session)
req.matchdict = {}
with self.assertRaises(exc.HTTPBadRequest):
req.json_body = {}
edit_collection(req)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict['id'] = 100
req.json_body = {'title': 'Edited title', 'description': 'Edited description', 'users': [user2.as_dict()]}
edit_collection(req)
with self.assertRaises(exc.HTTPBadRequest):
req.matchdict['id'] = collection.id
req.json_body = {'description': 'Description'}
edit_collection(req)
req.json_body = {'title': 'Edited title', 'description': 'Edited description', 'users': [user2.as_dict()]}
resp = edit_collection(req)
self.assertEqual(resp['title'], 'Edited title')
self.assertEqual(resp['users'][0], user2.as_dict())
def test_get_user(self):
user = add_user(self.session,
role=UserRole,
email='*****@*****.**',
firstname='User')
user2 = add_user(self.session,
role=UserRole,
email='*****@*****.**',
firstname='User')
admin = add_user(self.session,
role=Administrator,
email='*****@*****.**',
firstname='Admin')
req = dummy_request(self.session)
req.matchdict = {}
with self.assertRaises(exc.HTTPBadRequest):
get_user_view(req)
req.matchdict['id'] = user.id
self.config.testing_securitypolicy(userid=user2.id, permissive=True)
with self.assertRaises(exc.HTTPForbidden):
get_user_view(req)
self.config.testing_securitypolicy(userid=admin.id, permissive=True)
req.matchdict['id'] = 100
with self.assertRaises(exc.HTTPNotFound):
get_user_view(req)
req.matchdict['id'] = user.id
resp = get_user_view(req)
self.assertEqual(resp, user.as_dict())
def test_create_user(self):
req = dummy_request(self.session)
req.json_body = {}
with self.assertRaises(exc.HTTPBadRequest):
create_user(req)
req.json_body = {'email': 'user@email'}
with self.assertRaises(exc.HTTPBadRequest):
create_user(req)
req.json_body = {
'email': 'user@email',
'firstname': 'Name',
'surname': 'Surname'
}
with self.assertRaises(exc.HTTPBadRequest):
create_user(req)
req.json_body = {
'email': 'user@email',
'firstname': 'Name',
'surname': 'Surname',
'role': 'User',
'telephone': '01235456',
'address': 'address',
'password': '******'
}
resp = create_user(req)
self.assertIsNotNone(resp['id'])
self.assertEqual(resp['email'], 'user@email')
self.assertEqual(resp['role'], 'User')
def setUp(self):
super(TestResetPassword, self).setUp()
self.config = pyramid_testing.setUp()
self.config.include('pyramid_mailer.testing')
self.config.include('pyramid_jinja2')
self.request = dummy_request(self.session)
self.request.registry.settings['izinto.app.secret'] = 'testsecret'
add_roles_and_permissions(self.session)
def test_paste_dashboard_view(self):
collection = Collection(title='Collection 1')
self.session.add(collection)
self.session.flush()
collection_id = collection.id
collection2 = Collection(title='Collection 2')
self.session.add(collection2)
self.session.flush()
collection2_id = collection2.id
data_source = DataSource(name='Data source')
self.session.add(data_source)
self.session.flush()
user = add_user(self.session)
dashboard = add_dashboard(self.session,
title='Test title',
collection_id=collection.id,
users=[user])
dashboard_id = dashboard.id
self.session.add(
Variable(name='Variable', value='V', dashboard_id=dashboard.id))
self.session.add(
Chart(title='Chart',
data_source_id=data_source.id,
dashboard_id=dashboard.id))
self.session.add(
Chart(title='Chart',
data_source_id=data_source.id,
dashboard_id=dashboard.id))
self.session.add(
SingleStat(title='Single stat',
data_source_id=data_source.id,
dashboard_id=dashboard_id))
self.session.add(
Query(name="Query",
query="query",
dashboard_id=dashboard.id,
data_source_id=data_source.id))
self.session.flush()
req = dummy_request(self.session)
req.json_body = {}
with self.assertRaises(exc.HTTPBadRequest):
paste_dashboard_view(req)
req.matchdict = {'id': dashboard_id}
req.json_body = {'collection_id': collection_id}
dashboard = paste_dashboard_view(req)
self.assertEqual(dashboard['title'], 'Copy of Test title')
self.assertEqual(len(dashboard['variables']), 1)
req.matchdict = {'id': dashboard_id}
req.json_body = {'collection_id': collection2_id}
dashboard = paste_dashboard_view(req)
self.assertEqual(dashboard['title'], 'Test title')
dashboard = self.session.query(Dashboard).get(dashboard['id'])
self.assertEqual(dashboard.queries[0].name, "Query")
def test_delete_dashboard_view(self):
dashboard = add_dashboard(self.session, title='Dashboard')
req = dummy_request(self.session)
req.matchdict = {'id': dashboard.id}
delete_dashboard_view(req)
with self.assertRaises(exc.HTTPNotFound):
get_dashboard_view(req)
def test_get_content_view(self):
content = b'<html>hello content!</html>'
dashboard = Dashboard(title='Get Dashboard Content', content=content)
self.session.add(dashboard)
self.session.flush()
req = dummy_request(self.session)
req.matchdict = {'id': dashboard.id}
response = get_content_view(req)
self.assertEqual(response.body, content)
def test_get_dashboard_view(self):
dashboard = add_dashboard(self.session, title='Test title')
req = dummy_request(self.session)
with self.assertRaises(exc.HTTPBadRequest):
get_dashboard_view(req)
req.matchdict = {'id': dashboard.id}
dashboard = get_dashboard_view(req)
self.assertEqual(dashboard['title'], 'Test title')
def test_edit_content_view(self):
dashboard = Dashboard(title='New Dashboard Content')
self.session.add(dashboard)
self.session.flush()
req = dummy_request(self.session)
req.matchdict = {'id': dashboard.id}
content = b'<html>hello content!</html>'
req.json_body = {'content': content}
response = edit_content_view(req)
self.assertEqual(response.body, content)
def test_list_dashboard_view_view(self):
self.session.add(DashboardView(name='Day', icon='day'))
self.session.add(DashboardView(name='Month', icon='month'))
self.session.add(DashboardView(name='Year', icon='year'))
self.session.flush()
req = dummy_request(self.session)
req.params = {}
dashboard_views = list_dashboard_view_items(req)
self.assertEqual(len(dashboard_views), 3)
self.assertEqual(dashboard_views[0]['name'], 'Day')
def test_reorder_charts(self):
req = dummy_request(self.session)
dashboard = Dashboard(title='Dashboard Title')
self.session.add(dashboard)
data_source = DataSource(name='Datasource')
self.session.add(data_source)
self.session.flush()
req.json_body = {
'title': 'Title',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'unit': 'U'
}
chart = create_chart_view(req)
req.json_body = {
'title': 'Title 2',
'dashboard_id': dashboard.id,
'data_source_id': data_source.id,
'unit': 'U'
}
create_chart_view(req)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict = {'id': 100}
req.json_body = {'dashboard_id': dashboard.id, 'index': 1}
reorder_chart_view(req)
req = dummy_request(self.session)
req.params = {}
charts = list_charts_view(req)
self.assertEqual(charts[0]['id'], chart['id'])
req.matchdict = {'id': chart['id']}
req.json_body = {'dashboard_id': dashboard.id, 'index': 1}
reorder_chart_view(req)
charts = list_charts_view(req)
self.assertEqual(charts[1]['id'], chart['id'])
self.assertEqual(charts[1]['index'], 1)
self.assertEqual(charts[0]['index'], 0)
def test_reorder_dashboards_view(self):
req = dummy_request(self.session)
collection = Collection(title='Collection')
self.session.add(collection)
self.session.flush()
collection_id = collection.id
req.json_body = {
'title': 'Dashboard 1',
'collection_id': collection_id
}
dashboard = create_dashboard_view(req)
req.json_body = {
'title': 'Dashboard 2',
'collection_id': collection_id
}
create_dashboard_view(req)
req.json_body = {
'title': 'Dashboard 3',
'collection_id': collection_id
}
create_dashboard_view(req)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict = {'id': 100}
req.json_body = {'collection_id': collection_id, 'index': 1}
reorder_dashboard_view(req)
req = dummy_request(self.session)
req.params = {'collection_id': collection_id}
dashboards = list_dashboards_view(req)
self.assertEqual(dashboards[0]['index'], 0)
self.assertEqual(dashboards[0]['id'], dashboard['id'])
req.matchdict = {'id': dashboard['id']}
req.json_body = {'collection_id': collection_id, 'index': 1}
reorder_dashboard_view(req)
dashboards = list_dashboards_view(req)
self.assertEqual(dashboards[1]['index'], 1)
self.assertEqual(dashboards[1]['id'], dashboard['id'])
def test_delete_collection(self):
collection = add_collection(self.session, 'Collection', 'Description')
collection_id = collection.id
req = dummy_request(self.session)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict = {}
delete_collection(req)
req.matchdict['id'] = collection_id
delete_collection(req)
with self.assertRaises(exc.HTTPNotFound):
get_collection_view(req)
def test_delete_variable(self):
dash = add_dashboard(self.session, 'Dash', 'Dashboard')
variable = Variable(name='Variable', value='5', dashboard_id=dash.id)
self.session.add(variable)
req = dummy_request(self.session)
with self.assertRaises(exc.HTTPNotFound):
req.matchdict = {'id': 100}
delete_variable_view(req)
req.matchdict['id'] = variable.id
delete_variable_view(req)
with self.assertRaises(exc.HTTPNotFound):
delete_variable_view(req)
def test_edit_query(self):
datasource = DataSource(name='datasource')
self.session.add(datasource)
dash = add_dashboard(self.session, 'Dash', 'Dashboard')
query = Query(name='Query',
query='query string',
dashboard_id=dash.id,
data_source_id=datasource.id)
self.session.add(
Query(name='Query2',
query='query string 2',
dashboard_id=dash.id,
data_source_id=datasource.id))
self.session.add(query)
self.session.flush()
req = dummy_request(self.session)
req.matchdict = {}
req.json_body = {}
with self.assertRaises(exc.HTTPBadRequest):
edit_query_view(req)
req.matchdict['id'] = 100
req.json_body = {'name': 'Edited name'}
with self.assertRaises(exc.HTTPNotFound):
edit_query_view(req)
req.matchdict['id'] = query.id
with self.assertRaises(exc.HTTPBadRequest):
edit_query_view(req)
req.json_body = {'query': 'query string'}
with self.assertRaises(exc.HTTPBadRequest):
edit_query_view(req)
req.json_body = {
'name': 'Query2',
'query': 'query string',
'dashboard_id': dash.id
}
with self.assertRaises(exc.HTTPBadRequest):
edit_query_view(req)
req.json_body = {
'name': 'Edited name',
'query': 'query string',
'dashboard_id': dash.id,
'data_source_id': datasource.id
}
resp = edit_query_view(req)
self.assertEqual(resp['name'], 'Edited name')
self.assertEqual(resp['dashboard_id'], dash.id)
def test_list_variables(self):
dash = add_dashboard(self.session, 'Dash', 'Dashboard')
self.session.add(
Variable(name='Variable', value='1', dashboard_id=dash.id))
self.session.add(
Variable(name='Variable2', value='2', dashboard_id=dash.id))
self.session.add(
Variable(name='Variable3', value='3', dashboard_id=dash.id))
req = dummy_request(self.session)
req.params = {}
resp = list_variables_view(req)
self.assertEqual(len(resp), 3)
req.params = {'value': '1'}
resp = list_variables_view(req)
self.assertEqual(len(resp), 1)
def test_create_variable(self):
dash = add_dashboard(self.session, 'Dash', 'Dashboard')
req = dummy_request(self.session)
req.json_body = {}
with self.assertRaises(exc.HTTPBadRequest):
create_variable_view(req)
req.json_body = {
'name': 'Variable',
'value': '5',
'dashboard_id': dash.id
}
variable = create_variable_view(req)
self.assertIsNotNone(variable['id'])
self.assertEqual(variable['name'], 'Variable')
self.assertEqual(variable['dashboard_id'], dash.id)
def test_copy_chart(self):
req = dummy_request(self.session)
dashboard_view = DashboardView(name='Dashboard View', icon='icon')
self.session.add(dashboard_view)
dashboard1 = Dashboard(title='Dashboard Title 1')
self.session.add(dashboard1)
dashboard2 = Dashboard(title='Dashboard Title 2')
self.session.add(dashboard2)
data_source = DataSource(name='Datasource')
self.session.add(data_source)
self.session.flush()
req.json_body = {
'title': 'Title',
'dashboard_id': dashboard1.id,
'data_source_id': data_source.id,
'unit': 'U',
'group_by': [{
'dashboard_view_id': dashboard_view.id,
'value': 1
}]
}
chart = create_chart_view(req)
chart_id = chart['id']
req.json_body = {}
with self.assertRaises(exc.HTTPBadRequest):
paste_chart_view(req)
req.matchdict = {'id': chart_id}
req.json_body = {'dashboard_id': dashboard1.id}
chart = paste_chart_view(req)
req.matchdict = {'id': chart['id']}
chart = get_chart_view(req)
self.assertEqual(chart['title'], 'Copy of Title')
req.matchdict = {'id': chart_id}
req.json_body = {'dashboard_id': dashboard2.id}
chart = paste_chart_view(req)
req.matchdict = {'id': chart['id']}
chart = get_chart_view(req)
self.assertEqual(chart['title'], 'Title')
def test_create_collection(self):
admin = add_user(self.session, role=Administrator, firstname='Admin')
user1 = add_user(self.session, role=User, email='*****@*****.**', firstname='User1')
self.config.testing_securitypolicy(userid=admin.id, permissive=True)
req = dummy_request(self.session)
req.json_body = {}
with self.assertRaises(exc.HTTPBadRequest):
create_collection(req)
req.json_body = {'title': 'Collection',
'description': 'Description',
'users': [user1.as_dict()]}
collection = create_collection(req)
self.assertIsNotNone(collection['id'])
self.assertEqual(collection['title'], 'Collection')
self.assertEqual(len(collection['users']), 2)
def test_create_dashboard(self):
req = dummy_request(self.session)
req.json_body = {'description': 'Description'}
with self.assertRaises(exc.HTTPBadRequest):
create_dashboard_view(req)
req.json_body = {
'title': 'Title',
'description': 'Description',
'type': 'new',
'content': '<h1>Hello world!</h1>'
}
resp = create_dashboard_view(req)
self.assertEqual(resp['title'], 'Title')
self.assertEqual(resp['description'], 'Description')
self.assertEqual(resp['type'], 'new')
self.assertEqual(resp['content'], '<h1>Hello world!</h1>')
