def test_channel_leave_invalid_channel(register_new_user):
new_user = register_new_user
channels_create(new_user['token'], "Test Channel 1", True)
with pytest.raises(InputError):
channel_leave(new_user['token'], 4)
def test_details_valid_after_invite(register_and_login_user):
token = register_and_login_user
channels_create(token, "test channel", True)
auth_register("*****@*****.**", "password", "Lmao", "Bus")
login = auth_login("*****@*****.**", "password")
token = login['token']
channel_invite(token, 0, 1)
result = channel_details(token, 0)
assert result == {
'name':
'test channel',
'owner_members': [{
'u_id': 0,
'name_first': 'Angus',
'name_last': 'Doe',
'profile_img_url': 'default.jpg',
}],
'all_members': [
{
'u_id': 0,
'name_first': 'Angus',
'name_last': 'Doe',
'profile_img_url': 'default.jpg',
},
{
'u_id': 1,
'name_first': 'Lmao',
'name_last': 'Bus',
'profile_img_url': 'default.jpg',
},
]
}
def test_list_multiple_and_only_user(register_login_create_channel,
register_login_user2):
token = register_login_create_channel
channels_create(token, "test2 channel", True)
token2 = register_login_user2
channels_create(token2, "unretrieved channel", True)
result = channels_list(token)
assert result == {
'channels': [{
'channel_id': 0,
'name': 'test channel',
'owner_members': [0],
'all_members': [0],
'is_public': True,
'time_finish': None,
'messages': [],
}, {
'channel_id': 1,
'name': 'test2 channel',
'owner_members': [0],
'all_members': [0],
'is_public': True,
'time_finish': None,
'messages': [],
}]
}
def test_details_valid(register_and_login_user):
token = register_and_login_user
# Create another user and a channel before it to not retrieve it
auth_register("*****@*****.**", "password", "Angus", "Doe")
login = auth_login("*****@*****.**", "password")
channels_create(login['token'], "ignore channel", True)
channels_create(token, "test channel", True)
result = channel_details(token, 1)
assert result == {
'name':
'test channel',
'owner_members': [{
'u_id': 0,
'name_first': 'Angus',
'name_last': 'Doe',
'profile_img_url': 'default.jpg',
}],
'all_members': [{
'u_id': 0,
'name_first': 'Angus',
'name_last': 'Doe',
'profile_img_url': 'default.jpg',
}]
}
def test_channel_leave_member(register_new_user):
# Create the user
new_user = register_new_user
token = new_user['token']
# Create the channel
public = True
channels_create(token, "Test Channel 2", public)
test_channel = channels_create(token, "Test Channel", public)
c_id = test_channel['channel_id']
in_channel = True
# Create a new user who joins the channel
auth_register("*****@*****.**", "password1", "Bilson", "Doe")
user2 = auth_login("*****@*****.**", "password1")
token2 = user2['token']
channel_join(token2, c_id)
# 2nd member leaves, check if they are in the channel
channel_leave(token2, c_id)
member_check = channel_details(token, c_id)
in_channel = user2['u_id'] in member_check['all_members']
assert in_channel == False
def test_unauthorised_member(register_and_login_user):
token = register_and_login_user
channels_create(token, "test channel", True)
auth_register("*****@*****.**", "password", "Abus", "Doe")
user = auth_login("*****@*****.**", "password")
token = user['token']
with pytest.raises(AccessError):
channel_details(token, 0)
def register_login_create_channel():
clear()
# register and login a user
auth_register("*****@*****.**", "password", "Angus", "Doe")
login = auth_login("*****@*****.**", "password")
token = login['token']
# create channel using that user
channels_create(token, "test channel", True)
return token
def test_valid_token(register_and_login_user):
token = register_and_login_user
channels_create(token, "test channel", True)
result = channels_listall(token)
assert result == {
'channels': [{
'channel_id': 0,
'name': 'test channel',
'owner_members': [0],
'all_members': [0],
'is_public': True,
'time_finish': None,
'messages': [],
}]
}
def test_invalid_token(register_login):
token = register_login
public = True
c_id = channels_create(token['token'], "Channel", public)
invalid_token = token_hash(1)
with pytest.raises(AccessError):
channel_addowner(invalid_token, c_id['channel_id'], token['u_id'])
def test_invalid_u_id(register_login):
token = register_login
public = True
c_id = channels_create(token['token'], "Channel", public)
invalid_u_id = -1
with pytest.raises(InputError):
channel_addowner(token['token'], c_id['channel_id'], invalid_u_id)
def test_invalid_token(register_and_login_user):
token = register_and_login_user
private = False
c_id = channels_create(token['token'], "Channel", private)
invalid_token = token_hash(1)
with pytest.raises(AccessError):
channel_invite(invalid_token, c_id, token['u_id'])
def test_flockr_owner_permissions(register_login, create_channel):
flockr_owner = register_login
# Creates a new user who is the owner of a channel
auth_register("*****@*****.**", "password2", "Richard2", "Shen2")
user_2 = auth_login("*****@*****.**", "password2")
c_id = channels_create(user_2["token"], "Channel", True)['channel_id']
# Create a new user who is not flockr owner, and is a member of a channel,
# sends a message
auth_register("*****@*****.**", "password3", "Richard3", "Shen3")
user_3 = auth_login("*****@*****.**", "password3")
channel_join(user_3['token'], c_id)
channel_join(flockr_owner['token'], c_id)
m_id = message_send(user_3['token'], c_id, "First Message")['message_id']
message_edit(flockr_owner['token'], m_id, "Edited Message")
# Check the message was edited correctly
updated_message = channel_messages(flockr_owner['token'], c_id,
0)['messages'][0]['message']
assert updated_message == "Edited Message"
def test_flockr_owner():
clear()
# Register and login the global owner
auth_register("*****@*****.**", "password", "First", "Last")
flockr_owner = auth_login("*****@*****.**", "password")
# Register and login 2 other users
auth_register("*****@*****.**", "password", "First", "Last")
owner_1 = auth_login("*****@*****.**", "password")
auth_register("*****@*****.**", "password", "First", "Last")
owner_2 = auth_login("*****@*****.**", "password")
# Create a channel for owner_1
public = True
owner_1_c_id = channels_create(owner_1['token'], "Channel",
public)['channel_id']
channel_join(owner_2['token'], owner_1_c_id)
# Make owner_2 actually an owner
channel_addowner(owner_1['token'], owner_1_c_id, owner_2['u_id'])
# The flockr_owner removes owner_2 as an owner
channel_removeowner(flockr_owner['token'], owner_1_c_id, owner_2['u_id'])
details = channel_details(owner_1['token'], owner_1_c_id)
assert len(details['owner_members']) == 1
assert details['owner_members'][0]['u_id'] == 1
def test_invalid_u_id(register_and_login_user):
token = register_and_login_user
private = False
c_id = channels_create(token['token'], "Channel", private)
invalid_u_id = -1
with pytest.raises(InputError):
channel_invite(token['token'], c_id, invalid_u_id)
def test_flockr_owner_remover(channel_with_user):
clear()
# Creating the flockr owner
auth_register("*****@*****.**", "flockr_ownerpassword",
"flockr_ownerFirstname", "flockr_ownerLastname")
flockr_owner = auth_login("*****@*****.**", "flockr_ownerpassword")
# Creating the owner and their own channel
auth_register("*****@*****.**", "ownerpassword", "ownerFirstname",
"ownerLastname")
owner = auth_login("*****@*****.**", "ownerpassword")
public = True
channel_id = channels_create(owner['token'], "Channel", public)
# Creating the message via the owner
message_id = message_send(owner['token'], channel_id['channel_id'],
"Test Message 1")
message = channel_messages(owner['token'], channel_id['channel_id'],
0)['messages']
# assert message == [
# {'message_id': 0, 'u_id': 1, 'message': 'Test Message 1', 'time_created': timestamp}
# ]
assert message[0]['message_id'] == 0
assert message[0]['u_id'] == 1
assert message[0]['message'] == 'Test Message 1'
# Removing the message via the flockr owner
message_remove(flockr_owner['token'], message_id['message_id'])
messages = channel_messages(owner['token'], channel_id['channel_id'],
0)['messages']
assert not messages
def test_multiple_channels(channel_user, send_messages):
owner = channel_user
ch_0_ms_0 = channel_messages(owner['token'], owner['c_id'],
0)['messages'][0]
ch_0_ms_1 = channel_messages(owner['token'], owner['c_id'],
0)['messages'][1]
# Create another channel which also contains messages
public = True
c_id_2 = channels_create(owner['token'], "Channel1", public)['channel_id']
# Messages in Channel1 to be used in search
message_send(owner['token'], c_id_2, "Channel1 - Message 0")
message_send(owner['token'], c_id_2, "Channel1 - Message 1")
ch_1_ms_0 = channel_messages(owner['token'], c_id_2, 0)['messages'][0]
ch_1_ms_1 = channel_messages(owner['token'], c_id_2, 0)['messages'][1]
query_str = "Channel0"
search_result = search(owner['token'], query_str)
assert search_result == {'messages': [ch_0_ms_0, ch_0_ms_1]}
query_str = "Channel1"
search_result = search(owner['token'], query_str)
assert search_result == {'messages': [ch_1_ms_0, ch_1_ms_1]}
def channels_create_flask():
payload = request.get_json()
token = payload['token']
name = payload['name']
is_public = payload['is_public']
return dumps(cs.channels_create(token, name, is_public))
def test_invalid_token(register_new_user):
new_user = register_new_user
token = new_user['token']
public = True
c_id = channels_create(token, "Test Channel", public)
with pytest.raises(AccessError):
channel_leave(token_hash(1), c_id)
def register_2_users_channel():
clear()
# Create a dummy channel for coverage where code loops through channels
owner = auth_register("*****@*****.**", "password", "Angus", "Doe")
channels_create(owner['token'], "Dummy Channel", True)
# Create a user who is flockr owner and is creating the channel
c_id = channels_create(owner['token'], "Channel", True)
member = auth_register("*****@*****.**", "password", "Bungus", "Two")
channel_join(member['token'], c_id['channel_id'])
return {
'c_id': c_id['channel_id'],
'owner': owner,
'member': member,
}
def test_private_channel(register_login_user):
owner = register_login_user
# Register and login a new user who plans to join the channel
auth_register("*****@*****.**", "password", "First", "Last")
member = auth_login("*****@*****.**", "password")
private = False
c_id = channels_create(owner['token'], "Channel", private)
with pytest.raises(AccessError):
channel_join(member['token'], c_id['channel_id'])
def channel_with_user():
clear()
auth_register("*****@*****.**", "password", "Firstname", "Lastname")
user = auth_login("*****@*****.**", "password")
public = True
c_id = channels_create(user['token'], "Channel", public)
return {
'u_id': user['u_id'],
'token': user['token'],
'c_id': c_id['channel_id'],
}
def test_unretrieved_channel(register_login_create_channel,
register_login_user2):
token = register_login_create_channel
token2 = register_login_user2
# create channel which should not be retrieved
channels_create(token2, "unretrieved channel", True)
result = channels_list(token)
assert result == {
'channels': [{
'channel_id': 0,
'name': 'test channel',
'owner_members': [0],
'all_members': [0],
'is_public': True,
'time_finish': None,
'messages': [],
}]
}
def test_channel_leave_unauthorised(register_new_user):
new_user = register_new_user
token = new_user['token']
public = True
test_channel = channels_create(token, "Test Channel", public)
c_id = test_channel['channel_id']
auth_register("*****@*****.**", "password1", "Bilson", "Doe")
user2 = auth_login("*****@*****.**", "password1")
with pytest.raises(AccessError):
channel_leave(user2['token'], c_id)
def test_multiple_channels(channel_with_user, get_current_time):
sender = channel_with_user
timestamp = get_current_time
# Ensure there's no messages in the channel to begin with
messages = channel_messages(sender['token'], sender['c_id'], 0)['messages']
assert not messages
# Send the first message to the first channel
message_send(sender['token'], sender['c_id'], "Test Message 1")
messages = channel_messages(sender['token'], sender['c_id'], 0)['messages']
assert messages == [
{
'message_id': 0,
'u_id': 0,
'message': 'Test Message 1',
'time_created': timestamp,
'reacts': [
{
'react_id': 0,
'u_ids': [],
'is_this_user_reacted': False,
}
],
'is_pinned': False,
},
]
public = True
channel_2 = channels_create(sender['token'], "Channel 2", public)['channel_id']
# Send the second message to the second channel
message_send(sender['token'], channel_2, "Test Message 2")
messages = channel_messages(sender['token'], channel_2, 0)['messages']
assert messages == [
{
'message_id': 1,
'u_id': 0, 'message':
'Test Message 2',
'time_created': timestamp,
'reacts': [
{
'react_id': 0,
'u_ids': [],
'is_this_user_reacted': False,
}
],
'is_pinned': False,
},
]
def channel_with_user():
# A user is registered, logged in and owns a channel
clear()
auth_register("*****@*****.**", "password", "Firstname", "Lastname")
token = auth_login("*****@*****.**", "password")
public = True
c_id = channels_create(token['token'], "Channel", public)
return {
'u_id': token['u_id'],
'token': token['token'],
'c_id': c_id['channel_id'],
}
def test_invite_success(register_and_login_user):
token_1 = register_and_login_user
auth_register("*****@*****.**", "password2", "First2", "Last2")
token_2 = auth_login("*****@*****.**", "password2")
private = False
c_id = channels_create(token_1['token'], 'User_1s Channel', private)
channel_invite(token_1['token'], c_id['channel_id'], token_2['u_id'])
details = channel_details(token_1['token'], c_id['channel_id'])
assert details['all_members'] == [
{'u_id': 0, 'name_first': 'First', 'name_last': 'Last', 'profile_img_url': 'default.jpg'},
{'u_id': 1, 'name_first': 'First2', 'name_last': 'Last2', 'profile_img_url': 'default.jpg'}
]
def test_unreact_noreacts(register_login):
user = register_login
token = user['token']
is_public = True
# creating public channel
channel_id = channels_create(token, "Channel", is_public)
# send a message but no reacts
message_example = 'hello anto'
message = message_send(token, channel_id['channel_id'], message_example)
message_id = message['message_id']
react_id = 1
with pytest.raises(InputError):
message_unreact(token, message_id, react_id)
def test_second_user_added(register_login_user):
token_1 = register_login_user
auth_register("*****@*****.**", "password", "First", "Last")
token_2 = auth_login("*****@*****.**", "password")
public = True
c_id = channels_create(token_1['token'], "Channel", public)
channel_join(token_2['token'], c_id['channel_id'])
details = channel_details(token_1['token'], c_id['channel_id'])
assert details['all_members'] == [
{'u_id': 0, 'name_first': 'First', 'name_last': 'Last', 'profile_img_url': 'default.jpg'},
{'u_id': 1, 'name_first': 'First', 'name_last': 'Last', 'profile_img_url': 'default.jpg'}
]
def channel_with_2_owners():
clear()
# The first user is automatically an owner
auth_register("*****@*****.**", "password", "First", "Last")
token_1 = auth_login("*****@*****.**", "password")
public = True
# Create user and channel to be ignored but to pass authorised user
auth_register("*****@*****.**", "password", "John", "Doe")
ignore_me = auth_login("*****@*****.**", "password")
channels_create(ignore_me['token'], "Ignore Me", public)
c_id = channels_create(token_1['token'], "Channel", public)
# The second user is made an owner for test purposes
auth_register("*****@*****.**", "password2", "First2", "Last2")
token_2 = auth_login("*****@*****.**", "password2")
channel_join(token_2['token'], c_id['channel_id'])
channel_addowner(token_1['token'], c_id['channel_id'], token_2['u_id'])
return {'token_1': token_1, 'c_id': c_id, 'token_2': token_2}
def test_add_owner_success(register_login):
token = register_login
public = True
# Create channel to be ignored but considered when testing
auth_register("*****@*****.**", "password", "ignore", "me")
ignore_me = auth_login("*****@*****.**", "password")
channels_create(ignore_me['token'], "IgnoreMe", public)
c_id = channels_create(token['token'], "Channel", public)
auth_register("*****@*****.**", "password", "First", "Last")
token2 = auth_login("*****@*****.**", "password")
channel_join(token2['token'], c_id['channel_id'])
details = channel_details(token['token'], c_id['channel_id'])
assert len(details['owner_members']) == 1
assert (details['owner_members'][0]['u_id']) == 0
channel_addowner(token['token'], c_id['channel_id'], token2['u_id'])
details = channel_details(token['token'], c_id['channel_id'])
assert len(details['owner_members']) == 2
assert details['owner_members'][1]['u_id'] == token2['u_id']
