def test_usernames_are_unique(self):
test_utils.create_user(username='******')
try:
test_utils.create_user(username='******')
raise Exception('username must be unique.')
except (exc.IntegrityError, AssertionError):
pass
def test_only_admin_make_other_users_inactive(self):
user_id = 42
test_utils.create_user(user_id=user_id)
response = self.patch_to_edit_user(user_id=user_id,
token_type='writer',
is_active=False)
user = helpers.get_record_from_id(User, user_id)
assert response.status_code == 401
assert user.is_active is True
def test_admin_can_make_user_inactive(self):
user_id = 42
test_utils.create_user(user_id=user_id)
response = self.patch_to_edit_user(user_id=user_id,
token_type='admin',
is_active=False)
user = helpers.get_record_from_id(User, user_id)
assert response.status_code == 200
assert user.is_active is False
def test_inactive_user_cannot_log_in(self):
username = '******'
password = '******'
test_utils.create_user(is_active=False,
username=username,
password=password)
response = test_utils.login(client=self.client,
username=username,
password=password)
assert response.status_code == 401
def test_post_to_delete_user_without_admin_privileges(self):
user_id = 42
username = '******'
test_utils.create_user(user_id=user_id, username=username)
response = self.post_to_delete_user(user_id=user_id,
token_type='writer')
response_dict = json.loads(response.data)
user = helpers.get_record_from_id(User, user_id)
assert user
assert response.status_code == 401
def test_get_members(self):
user1 = test_utils.create_user(username='******')
user2 = test_utils.create_user(username='******')
usergroup = Usergroup(label='group1')
usergroup.members.append(user1)
usergroup.members.append(user2)
members = usergroup.get_members()
assert len(members) == 2
assert isinstance(members[0], dict)
assert members[0]['username'] == 'samson'
def test_edit_user_cant_remove_personal_usergroup(self):
user_id = 42
username = '******'
test_utils.create_user(username=username, user_id=user_id)
usergroup_ids = [99]
test_utils.create_usergroup(label='test_ug',
usergroup_id=usergroup_ids[0])
self.patch_to_edit_user(user_id=user_id, usergroup_ids=usergroup_ids)
user = User.query.filter(User.id == user_id).first()
assert user.get_personal_usergroup()
def test_edit_user_with_invalid_usergroups(self):
user_id = 42
test_utils.create_user(username='******',
email='*****@*****.**',
role='viewer',
user_id=user_id)
usergroup_ids = [99999, 888888]
response = self.patch_to_edit_user(user_id=user_id,
usergroup_ids=usergroup_ids)
edited_user = User.query.filter(User.id == user_id).first()
edited_usergroup_ids = edited_user.get_usergroup_ids()
assert response.status_code == 400
assert usergroup_ids[0] not in edited_usergroup_ids
def test_get_contacts(self):
user1 = test_utils.create_user(username='******')
user2 = test_utils.create_user(username='******')
contact1 = Contact(first_name='bartlett', creator=user2, public=True)
contact2 = Contact(first_name='toby', creator=user1, public=False)
db.session.add(contact1)
db.session.add(contact2)
db.session.add(user1)
db.session.add(user2)
db.session.commit()
contacts = user1.get_contacts()
assert len(contacts) == 2
assert contacts[0]['first_name'] == 'bartlett'
assert contacts[0]['creator']['username'] == 'joshua'
def test_appending_to_usergroups(self):
usergroup1 = Usergroup(label="group1")
user = test_utils.create_user(username='******')
usergroup_length_start = len(user.usergroups)
user.usergroups.append(usergroup1)
usergroup_length_end = len(user.usergroups)
assert usergroup1 in user.usergroups
assert usergroup_length_end == usergroup_length_start + 1
def test_get_dict_returns_dict(self):
user = test_utils.create_user(username='******')
usergroup = test_utils.create_usergroup(label='group1')
usergroup.members.append(user)
db.session.commit()
usergroup_dict = usergroup.get_dict()
assert isinstance(usergroup_dict, dict)
assert usergroup_dict['usergroup_id']
assert usergroup_dict['label'] == "group1"
assert usergroup_dict['members'][0]['username'] == 'samson'
def test_get_dict_returns_dict(self):
user = test_utils.create_user(username='******',
email="*****@*****.**",
role="admin")
user_dict = user.get_dict()
assert isinstance(user_dict, dict)
assert user_dict['user_id']
assert user_dict['username'] == 'samson'
assert user_dict['email'] == "*****@*****.**"
assert user_dict['role'] == "admin"
def test_password_encrypt_and_decrypt(self):
user = test_utils.create_user(username='******')
password = '******'
connection = Connection(label='con1', creator=user, password=password)
db.session.add(connection)
db.session.commit()
connection_dict = connection.get_dict()
assert connection.password != password
assert connection_dict['password'] == password
def test_get_dict_returns_dict(self):
user = test_utils.create_user(username='******')
report = Report(label='report1', creator=user)
db.session.add(report)
db.session.commit()
report_dict = report.get_dict()
assert isinstance(report_dict, dict)
assert report_dict['report_id']
assert report_dict['label'] == "report1"
assert report_dict['creator']['username'] == 'samson'
def test_get_dict_returns_dict(self):
user = test_utils.create_user(username='******')
connection = Connection(label='con1', creator=user)
db.session.add(connection)
db.session.commit()
connection_dict = connection.get_dict()
assert isinstance(connection_dict, dict)
assert connection_dict['connection_id']
assert connection_dict['label'] == "con1"
assert connection_dict['creator']['username'] == 'samson'
def test_edit_user_with_valid_data(self):
starting_user_count = len(User.query.all())
user_id = 42
test_utils.create_user(username='******',
email='*****@*****.**',
role='viewer',
user_id=user_id)
response = self.patch_to_edit_user(username='******',
email='*****@*****.**',
role='writer',
user_id=user_id)
edited_user = User.query.filter(User.id == user_id).first()
edited_user_dict = edited_user.get_dict()
number_of_users = len(User.query.all())
assert response.status_code == 200
assert edited_user_dict['username'] == 'edit2'
assert number_of_users == starting_user_count + 1
def test_get_dict_returns_dict(self):
user = test_utils.create_user(username='******')
contact = Contact(first_name='josh', creator=user)
db.session.add(user)
db.session.add(contact)
db.session.commit()
contact_dict = contact.get_dict()
assert isinstance(contact_dict, dict)
assert contact_dict['contact_id']
assert contact_dict['first_name'] == "josh"
assert contact_dict['creator']['username'] == 'samson'
def test_get_charts(self):
usergroup1 = test_utils.create_usergroup(label='group1')
user = test_utils.create_user(username='******')
chart_label = 'test1'
chart1 = test_utils.create_chart(label=chart_label)
chart1.usergroups.append(usergroup1)
user.usergroups.append(usergroup1)
db.session.commit()
charts = user.get_charts()
assert len(charts) == 1
assert charts[0]['label'] == chart_label
def test_get_dict_returns_dict(self):
user = test_utils.create_user(username='******')
query = SqlQuery(label='q1', creator=user)
db.session.add(user)
db.session.add(query)
db.session.commit()
query_dict = query.get_dict()
assert isinstance(query_dict, dict)
assert query_dict['query_id']
assert query_dict['label'] == "q1"
assert query_dict['creator']['username'] == 'samson'
def test_post_to_delete_user_with_valid_data(self):
user_id = 42
username = '******'
user = test_utils.create_user(user_id=user_id, username=username)
personal_usergroup = user.get_personal_usergroup()
usergroup_id = personal_usergroup.id
response = self.post_to_delete_user(user_id=user_id)
response_dict = json.loads(response.data)
user = helpers.get_record_from_id(User, user_id)
usergroup = helpers.get_record_from_id(Usergroup, usergroup_id)
assert not user
assert not usergroup
def test_get_publications(self):
pub_type = 'dashboard'
user = test_utils.create_user(username='******')
report = Report(label='report1', creator=user)
Publication(creator=user, type=pub_type, publication_report=report)
db.session.add(report)
db.session.commit()
pub_list = report.get_publications()
assert isinstance(pub_list, list)
assert isinstance(pub_list[0], dict)
assert pub_list[0]['type'] == pub_type
assert pub_list[0]['creator']['username'] == 'samson'
def test_get_reports(self):
usergroup1 = test_utils.create_usergroup(label='group1')
user = test_utils.create_user(username='******')
report1 = Report(label='rep1', creator=user)
report1.usergroups.append(usergroup1)
user.usergroups.append(usergroup1)
db.session.add(report1)
db.session.commit()
reports = user.get_reports()
assert len(reports) == 1
assert reports[0]['label'] == 'rep1'
assert reports[0]['creator']['username'] == 'samson'
def test_get_queries(self):
usergroup1 = test_utils.create_usergroup(label='group1')
user = test_utils.create_user(username='******')
query1 = SqlQuery(label='query1', creator=user)
query1.usergroups.append(usergroup1)
user.usergroups.append(usergroup1)
db.session.add(query1)
db.session.commit()
queries = user.get_queries()
assert len(queries) == 1
assert queries[0]['label'] == 'query1'
assert queries[0]['creator']['username'] == 'samson'
def test_get_connections(self):
usergroup1 = test_utils.create_usergroup(label='group1')
user = test_utils.create_user(username='******')
connection1 = Connection(label='con1', creator=user)
connection1.usergroups.append(usergroup1)
user.usergroups.append(usergroup1)
db.session.add(connection1)
db.session.add(usergroup1)
db.session.commit()
connections = user.get_connections()
assert len(connections) == 1
assert connections[0]['label'] == 'con1'
def test_login_logout(self):
username = '******'
password = '******'
test_utils.create_user(username=username, password=password)
response = test_utils.login(client=self.client,
username=username,
password=password)
response_dict = json.loads(response.data)
token = response_dict['access_token']
assert response.status_code == 200 # login successful
response = test_utils.logout(client=self.client, token=token)
assert response.status_code == 200 # logout successful
response = test_utils.logout(client=self.client, token=token)
assert response.status_code == 401 # token revoked
response = test_utils.login(client=self.client,
username='******',
password=password)
assert response.status_code == 401 # username rejected
response = test_utils.login(client=self.client,
username='******',
password='******')
assert response.status_code == 401 # password rejected
response = test_utils.login(client=self.client,
username='******',
password='')
assert response.status_code == 401 # empty password rejected
response = test_utils.login(client=self.client,
username='',
password=password)
assert response.status_code == 401 # empty username rejected
def test_get_dicts_from_usergroups(self):
user = test_utils.create_user(username='******')
starting_usergroups_count = len(user.get_dicts_from_usergroups())
usergroup2 = test_utils.create_usergroup(label='group2')
usergroup3 = test_utils.create_usergroup(label='group3')
user.usergroups.append(usergroup2)
user.usergroups.append(usergroup3)
db.session.commit()
usergroups = user.get_dicts_from_usergroups()
ending_usergroups_count = len(usergroups)
assert ending_usergroups_count == starting_usergroups_count + 2
assert isinstance(usergroups[0], dict)
def test_edit_user_with_valid_usergroups(self):
starting_user_count = len(User.query.all())
user_id = 42
test_utils.create_user(username='******',
email='*****@*****.**',
role='viewer',
user_id=user_id)
test_utils.create_usergroup(label='ug101', usergroup_id=101)
test_utils.create_usergroup(label='ug102', usergroup_id=102)
response = self.patch_to_edit_user(username='******',
email='*****@*****.**',
role='writer',
user_id=user_id,
usergroup_ids=[101, 102])
edited_user = User.query.filter(User.id == user_id).first()
edited_user_usergroup_ids = edited_user.get_usergroup_ids()
number_of_users = len(User.query.all())
assert response.status_code == 200
assert 101 in edited_user_usergroup_ids
assert number_of_users == starting_user_count + 1
def test_add_member_to_usergroup(self):
user_id = 42
user = test_utils.create_user(user_id=user_id)
usergroup_id = 1234
test_utils.create_usergroup(usergroup_id=usergroup_id)
response = self.patch_to_edit_usergroups(usergroup_id=usergroup_id,
member_ids=[user_id])
usergroup = helpers.get_record_from_id(Usergroup, usergroup_id)
assert response.status_code == 200
assert len(usergroup.members) == 1
assert usergroup.members[0].id == user_id
def test_get_dict_returns_dict(self):
pub_type = 'dashboard'
user = test_utils.create_user(username='******')
report = test_utils.create_report(label='r1')
publication = Publication(type=pub_type,
creator=user,
publication_report=report)
db.session.add(publication)
db.session.commit()
publication_dict = publication.get_dict()
assert isinstance(publication_dict, dict)
assert publication_dict['publication_id']
assert publication_dict['type'] == pub_type
assert publication_dict['creator']['username'] == 'samson'
assert publication_dict['report_id'] == 1
def test_get_dict_returns_dict(self):
user = test_utils.create_user(username='******')
query = SqlQuery(label='q1', creator=user)
connection = Connection(label='con1', creator=user)
db.session.add(connection)
chart = Chart(label='chart1',
creator=user,
sql_query=query,
chart_connection=connection)
db.session.add(query)
db.session.add(chart)
db.session.commit()
chart_dict = chart.get_dict()
assert isinstance(chart_dict, dict)
assert chart_dict['chart_id']
assert chart_dict['label'] == "chart1"
assert chart_dict['creator']['username'] == 'samson'
assert chart_dict['sql_query']['label'] == 'q1'
assert chart_dict['connection']['label'] == 'con1'
