def test_list_not_member():
user1 = auth_register("*****@*****.**", "1234567", "John", "Smith")
channels_create(user1['token'], "name", True)
user2 = auth_register("*****@*****.**", "1234567", "Jane", "Smith")
chan_lst2 = channels_list(user2['token'])['channels']
# Checking that channels_list returns an empty list for user2,
# as they are not a member of the created channel.
assert len(chan_lst2) == 0
def test_chan_create_invalid_name():
test_user = auth_register("*****@*****.**", "1234567", "John",
"Smith")
with pytest.raises(InputError):
channels_create(test_user['token'], 'n' * 21, True)
#Assumption: channels_create raises an InputError if given empty name
with pytest.raises(InputError):
channels_create(test_user['token'], '', True)
def test_chan_create_double():
test_user = auth_register("*****@*****.**", "1234567", "John",
"Smith")
chan1 = channels_create(test_user['token'], 'name', True)
chan2 = channels_create(test_user['token'], 'name', False)
chan3 = channels_create(test_user['token'], 'name', True)
# Checking that channel_id's are unique
assert chan1['channel_id'] != chan2['channel_id']
assert chan1['channel_id'] != chan3['channel_id']
def test_listall_private():
user1 = auth_register("*****@*****.**", "1234567", "John", "Smith")
channels_create(user1['token'], "name", False)
user2 = auth_register("*****@*****.**", "1234567", "Jane", "Smith")
chan_lst1 = channels_listall(user1['token'])['channels']
chan_lst2 = channels_listall(user2['token'])['channels']
# Checking that channels_listall returns the same list for user2,
assert len(chan_lst1) == len(chan_lst2) == 1
assert chan_lst1 == chan_lst2
def test_chan_create_invalid_token():
test_user = auth_register("*****@*****.**", "1234567", "John",
"Smith")
token = test_user['token']
assert auth_logout(token) #invalidating token
with pytest.raises(AccessError):
auth_logout(token) #confirming that token is an invalid token
with pytest.raises(AccessError):
channels_create(token, 'name', True)
def test_searching_multiple_channels():
'''search should find all messages containing the query string regardless of channel'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
new_channel_a = channels_create(andrew['token'], "channel_a", True)
new_channel_b = channels_create(andrew['token'], "channel_b", True)
message_send(andrew['token'], new_channel_a['channel_id'],
f'this is a test message in channel a')
message_send(andrew['token'], new_channel_b['channel_id'],
f'this is a test message in channel b')
search_results = search(andrew['token'], 'this is a test message')
assert isinstance(search_results, dict)
assert len(search_results['messages']) == 2
def test_channel_join():
test_user = auth_register("*****@*****.**", "password", "John",
"Smith")
test_user2 = auth_register("*****@*****.**", "password", "Bob",
"Smith")
test_channel = channels_create(test_user["token"], "test_channel", True)
channel_join(test_user2["token"], test_channel["channel_id"])
def test_search_for_multiple_messages():
'''searching with valid paramters and checking the returned object is correct
messages_sent is a dictionary of message_ids as keys the message_content as
the value. This is used to verify that the messages found match the messages
that were sent.
'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
new_channel = channels_create(andrew['token'], "channel_1", True)
messages_sent = {}
for message_number in range(10):
message_content = f'this is message number {message_number}'
new_message_id = message_send(andrew['token'],
new_channel['channel_id'],
message_content)['message_id']
messages_sent[new_message_id] = message_content
search_results = search(andrew['token'], 'this is message number')
assert isinstance(search_results, dict)
assert len(search_results['messages']) == 10
for message in search_results['messages']:
assert isinstance(message, dict)
assert 'message_id' in message
assert isinstance(message['message_id'], int)
assert 'u_id' in message
assert isinstance(message['u_id'], int)
assert 'message' in message
assert isinstance(message['message'], str)
assert message['message'] == messages_sent[message['message_id']]
assert 'time_created' in message
assert isinstance(message['time_created'], int)
def test_chan_create_return():
test_user = auth_register("*****@*****.**", "1234567", "John",
"Smith")
chan1 = channels_create(test_user['token'], 'name', True)
assert isinstance(chan1, dict)
assert 'channel_id' in chan1.keys()
assert isinstance(chan1['channel_id'], int)
def test_listall_return_two():
test_user = auth_register("*****@*****.**", "1234567", "John",
"Smith")
channel1_name = 'My Channel'
channel2_name = 'My Second Channel'
channel1 = channels_create(test_user['token'], channel1_name, True)
channel2 = channels_create(test_user['token'], channel2_name, False)
chan_lst = channels_listall(test_user['token'])['channels']
assert len(chan_lst) == 2
channel1_details = chan_lst[0]
channel2_details = chan_lst[1]
assert channel1['channel_id'] == channel1_details['channel_id']
assert channel1_name == channel1_details['name']
# Checking that channel2's details match
assert channel2['channel_id'] == channel2_details['channel_id']
assert channel2_name == channel2_details['name']
def test_channel_leave_invalid_token():
test_user = auth_register("*****@*****.**", "password", "John",
"Smith")
test_channel = channels_create(test_user["token"], "test_channel", True)
auth_logout(test_user["token"]) # Invalidating token
with pytest.raises(AccessError):
channel_leave(test_user["token"], test_channel["channel_id"])
def test_channel_join_AccessError():
test_user = auth_register("*****@*****.**", "password", "John",
"Smith")
test_user2 = auth_register("*****@*****.**", "password", "Bob",
"Smith")
test_channel = channels_create(test_user["token"], "test_channel", False)
with pytest.raises(AccessError):
channel_join(test_user2["token"], test_channel["channel_id"])
def test_remove_user(new_user, new_user_2): glob_users = get_users() channel = channels_create(new_user['token'], "new_channel", False) channel_invite(new_user['token'], channel['channel_id'], new_user_2['u_id']) user_remove(new_user['token'], new_user_2['u_id']) assert not new_user_2 in get_channels()[channel['channel_id']]['members'] with pytest.raises(InputError): auth_login(glob_users[new_user_2['u_id']]['email'], glob_users[new_user_2['u_id']]['password_hash'])
def test_channel_join_InvalidToken():
test_user = auth_register("*****@*****.**", "password", "John",
"Smith")
test_user2 = auth_register("*****@*****.**", "password", "Bob",
"Smith")
test_channel = channels_create(test_user2["token"], "test_channel", True)
auth_logout(test_user["token"]) # Invalidating token of user1
with pytest.raises(AccessError):
channel_join(test_user["token"], test_channel["channel_id"])
def test_channel_leave_non_member():
test_owner_user = auth_register("*****@*****.**", "password", "John",
"Smith")
test_normal_user = auth_register("*****@*****.**", "password", "Bob",
"Smith")
test_channel = channels_create(test_owner_user["token"], "test_channel",
True)
with pytest.raises(AccessError):
channel_leave(test_normal_user["token"], test_channel["channel_id"])
def test_application_clean():
'''
Tests that all global variables have been emptied by the reset
'''
for new_user in range(100):
user = auth_register("z55555" + str(new_user) + "@unsw.edu.au",
"f for hayden rip", "hydaen", "smith")
channels_create(user['token'], "test channel" + str(new_user), True)
workspace_reset()
assert len(get_channels().keys()) == 0
assert len(get_users().keys()) == 0
assert len(get_users()) == 0
assert len(get_slackr_owners()) == 0
assert len(get_valid_tokens()) == 0
original_image_folder = os.path.join(os.getcwd(), 'images/original')
assert len(os.listdir(original_image_folder)) == 1
cropped_image_folder = os.path.join(os.getcwd(), 'images/cropped')
assert len(os.listdir(cropped_image_folder)) == 1
def test_searching_multiple_channels_with_no_access():
'''search should find all messages containing the query string THAT THE USER HAS ACCESS TO'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
andrews_channel = channels_create(andrew['token'], "andrews channel",
False)
message_send(andrew['token'], andrews_channel['channel_id'],
'this is a test message in andrews channel')
john = auth_register("*****@*****.**", "password", "john", "smith")
johns_channel = channels_create(john['token'], "channel_b", False)
message_send(john['token'], johns_channel['channel_id'],
'this is a test message in johns channel')
andrews_search_results = search(andrew['token'], 'this is a test message')
assert isinstance(andrews_search_results, dict)
assert len(andrews_search_results['messages']) == 1
johns_search_results = search(john['token'], 'this is a test message')
assert isinstance(johns_search_results, dict)
assert len(johns_search_results['messages']) == 1
def test_list_return_one():
test_user = auth_register("*****@*****.**", "1234567", "John",
"Smith")
channel_name = 'My Channel'
channel = channels_create(test_user['token'], channel_name, True)
chan_lst = channels_list(test_user['token'])['channels']
assert isinstance(chan_lst, list)
# One channel created. len should be 1
assert len(chan_lst) == 1
assert isinstance(chan_lst[0], dict)
assert 'channel_id' in chan_lst[0].keys()
assert 'name' in chan_lst[0].keys()
# Checking that the returned details match the channel that was created
#Assumption: channels_list lists channels in the order that the the user became a member of them
assert channel['channel_id'] == chan_lst[0]['channel_id']
assert channel_name == chan_lst[0]['name']
def test_search_for_one_message():
'''searching with valid paramters and checking the returned object is correct'''
andrew = auth_register("*****@*****.**", "password", "andrew", "taylor")
new_channel = channels_create(andrew['token'], "channel_1", True)
new_message = message_send(andrew['token'], new_channel['channel_id'],
f'this is a test message')
search_results = search(andrew['token'], 'test message')
assert isinstance(search_results, dict)
assert len(search_results['messages']) == 1
message = search_results['messages'][0]
assert isinstance(message, dict)
assert 'message_id' in message
assert isinstance(message['message_id'], int)
assert message['message_id'] == new_message['message_id']
assert 'u_id' in message
assert isinstance(message['u_id'], int)
assert 'message' in message
assert isinstance(message['message'], str)
assert 'time_created' in message
assert isinstance(message['time_created'], int)
def channels_create_wsgi():
json = request.get_json()
return jsonify(
channels_create(json['token'], json['name'], json['is_public']))
def new_channel_and_user_2(new_user_2):
"""creates a new user then a new channel and returns a merged dictionary"""
new_channel_2 = channels_create(new_user_2['token'], "channel_name", False)
return {**new_channel_2, **new_user_2}
def channel_dav(user_dav):
return channels_create(user_dav['token'], "channel_dav", False)
def test_chan_create_valid():
test_user = auth_register("*****@*****.**", "1234567", "John",
"Smith")
channels_create(test_user['token'], 'name', True)
channels_create(test_user['token'], 'name2', False)
