def test_join_nvt():
"""
tests if channel_join returns an access error if invalid token used
"""
# establish a test register
test_dict = auth.auth_register("*****@*****.**", "password", "Bob", "Ross")
# valid channel ID (assigned by channels_create)
c_id_dict = channels.channels_create(test_dict["token"], "test rum ham",
True)
# create an invalid token
invalid_token = 100
# test for AccessError
with pytest.raises(error.AccessError):
channel.channel_join(invalid_token, c_id_dict["channel_id"])
def test_addowner_already_owner():
'''
Testing when an owner is being added as an owner to the channel.
'''
clear()
user = auth_register("*****@*****.**", "password", "Firstname", "Lastname")
user_token = user.get("token")
user_id = user.get("u_id")
channels_return = channels_create(user_token, "username", True)
channel_id = channels_return.get("channel_id")
# channel_join(user_token, channel_id)
with pytest.raises(InputError):
channel_addowner(user_token, channel_id, user_id)
def test_invalid_user():
'''
Testing when user is invalid.
'''
clear()
user2 = auth_register("*****@*****.**", 'password', 'abcd2', 'efgh2')
user_token2 = user2.get("token")
channel = channels_create(user_token2, "Channel1", True)
channel_id = channel.get("channel_id")
invalid_token = 12312312
with pytest.raises(InputError):
channel_details(invalid_token, channel_id)
def test_invalid_user_remove():
'''
Testing when channel_remove is invalid.
'''
clear()
user2 = auth_register("*****@*****.**", 'password', 'abcd2', 'efgh2')
user_token2 = user2.get("token")
channel = channels_create(user_token2, "Channel1", True)
channel.get("channel_id")
user_id = 123123
with pytest.raises(InputError):
channel_removeowner(user_token2, "channel_id", user_id)
def initial_users():
clear()
auth_register('*****@*****.**', 'password', 'first_name', 'last_name')
auth_login('*****@*****.**', 'password')
auth_register('*****@*****.**', 'password', 'user2_name', 'user2_name')
auth_login('*****@*****.**', 'password')
auth_register('*****@*****.**', 'password', 'user3_first_name',
'user3_last_name')
auth_login('*****@*****.**', 'password')
def test_channel_join():
'''
Testing the channel_join function
'''
clear()
owner = auth_register('*****@*****.**', 'password', 'Peter',
'Michaels')
channel1 = channels_create(owner['token'], 'Channel 1', True)
user = auth_register('*****@*****.**', 'password', 'Kim',
'Williams')
details = channel_details(owner['token'], channel1['channel_id'])
assert len(details['all_members']) == 1
# Checking if a user can join a channel
# (verified if number of members becomes 2 and if they can leave the channel)
channel_join(user['token'], channel1['channel_id'])
details = channel_details(user['token'], channel1['channel_id'])
assert len(details['all_members']) == 2
channel_leave(user['token'], channel1['channel_id'])
# Authorised user does not have a valid token
with pytest.raises(AccessError):
channel_join('', channel1['channel_id'])
# Channel ID is not a valid channel
with pytest.raises(InputError):
channel_join(user['token'], channel1['channel_id'] + 100)
# Channel ID is a private channel (authorised user is not a global owner)
channel2 = channels_create(owner['token'], 'Channel 2', False)
with pytest.raises(AccessError):
channel_join(user['token'], channel2['channel_id'])
# User joining multiple times - doesn't raise error
channel_join(user['token'], channel1['channel_id'])
channel_join(user['token'], channel1['channel_id'])
def test_channel_invite():
'''
Testing the channel_invite function
'''
clear()
owner = auth_register('*****@*****.**', 'password', 'John', 'Smith')
user = auth_register('*****@*****.**', 'password', 'Steve',
'Jackson')
# User 1 creates a new channel, and invites User 2
channel1 = channels_create(owner['token'], 'Test Channel 1', True)
channel_invite(owner['token'], channel1['channel_id'], user['u_id'])
# Already invited
channel_invite(owner['token'], channel1['channel_id'], user['u_id'])
# Checking if User 2 is a member of the channel (whether they can access channel details)
channel_details(user['token'], channel1['channel_id'])
channel2 = channels_create(owner['token'], 'Test Channel 2', True)
# Authorised user does not have a valid token
with pytest.raises(AccessError):
channel_invite('', channel2['channel_id'], user['u_id'])
# Channel ID does not refer to a valid channel
with pytest.raises(InputError):
channel_invite(owner['token'], channel2['channel_id'] + 100,
user['u_id'])
# User ID does not refer to a valid user
with pytest.raises(InputError):
channel_invite(owner['token'], channel2['channel_id'],
user['u_id'] + 100)
# Authorised user is not a member of the channel
with pytest.raises(AccessError):
user3 = auth_register('*****@*****.**', 'password', 'Jim', 'Johnson')
channel_invite(user3['token'], channel2['channel_id'], user['u_id'])
def test_message_unpin_valid0():
'''Owner of the channel pin the message sent by a member, then the message is unpinned
by the owner of flockr'''
clear()
# Register user 0
user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang",
"W")
# Register user 1
user1_info = auth_register("*****@*****.**", "VukkFs", "Bill",
"Gates")
# Register user 2
user2_info = auth_register("*****@*****.**", "RFVtgb45678", "M",
"Johnson")
# User 0 create a channel
channel0_info = channels_create(user0_info['token'], "channel0", True)
# User 1 join the channel
channel_join(user1_info['token'], channel0_info['channel_id'])
# User 1 create another channel
channel1_info = channels_create(user1_info['token'], "channel1", True)
# User 2 join channel1
channel_join(user2_info['token'], channel1_info['channel_id'])
# User 0 join channel1
channel_join(user0_info['token'], channel1_info['channel_id'])
# User 2 send a message
message0_info = message_send(user2_info['token'],
channel1_info['channel_id'], "Hello")
# USer 1 send a message
message_send(user1_info['token'], channel1_info['channel_id'], "Hi")
# User 1 pin the message sent by user 2
message_pin(user1_info['token'], message0_info['message_id'])
# User 0 unpin the message just pinned by user 1
message_unpin(user0_info['token'], message0_info['message_id'])
# User 0 get all channel messages
all_message_info = channel_messages(user0_info['token'],
channel1_info['channel_id'], 0)
assert all_message_info['messages'][0]['is_pinned'] == False
def test_auth_passwordreset_request_unregistered_email_muplitple_users():
clear()
auth_register('*****@*****.**', 'password', 'madeline',
'younes')
auth_register('*****@*****.**', '238hadJHJ', 'Mira', 'Bankstone')
auth_register('*****@*****.**', '82hBKH', 'Thomas', 'Yossef')
with pytest.raises(InputError):
auth_passwordreset_request('*****@*****.**')
def test_channel_leave_public_channel():
other.clear()
user1 = auth.auth_register("*****@*****.**", "password", "John", "Smith")
user2 = auth.auth_register("*****@*****.**", "password", "Will", "Smith")
channel_1 = channels.channels_create(user1['token'], "channel_1", True)
channel.channel_join(user2['token'], channel_1['channel_id'])
user1_dict = {
'u_id': user1['u_id'],
'name_first': 'John',
'name_last': 'Smith',
'profile_img_url': ""
}
user2_dict = {
'u_id': user2['u_id'],
'name_first': 'Will',
'name_last': 'Smith',
'profile_img_url': ""
}
assert channel.channel_details(user2['token'],
channel_1['channel_id']) == {
'name': 'channel_1',
'owner_members': [user1_dict],
'all_members': [user1_dict, user2_dict]
}
channel.channel_leave(user2['token'], channel_1['channel_id'])
assert channel.channel_details(user1['token'],
channel_1['channel_id']) == {
'name': 'channel_1',
'owner_members': [user1_dict],
'all_members': [user1_dict]
}
def test_channels_leave():
'''
Tests for channel_leave
'''
clear()
#Creating users to create channels
user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1", None)
user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2", None)
token1 = user1['token']
token2 = user2['token']
u_id1 = user1['u_id']
u_id2 = user2['u_id']
#creating channels
ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id']
ch_id2 = channels_create(token2, "yetAnotherChannel", False)['channel_id']
with pytest.raises(InputError):
#test for invalid channel
channel_leave(token1, 50)
with pytest.raises(AccessError):
#test for user not already member of the channel
channel_leave(token2, ch_id1)
#test leaving a public channel
channel_leave(token1, ch_id1)
assert not user_in_channel_persist(u_id1, ch_id1)
assert not user_a_member_persist(u_id1, ch_id1)
# test leaving a private channel
channel_leave(token2, ch_id2)
assert not user_in_channel_persist(u_id2, ch_id2)
assert not user_a_member_persist(u_id2, ch_id2)
clear()
def test_check_channel_is_public():
"""
check_channel_is_public returns nothing if the channel is public
check_channel_is_public raises an AccessError if the channel is private
"""
user1 = auth.auth_register("*****@*****.**", "gotosleep", "assoonasi",
"finishthis")
channel1 = channels.channels_create(user1["token"], "thisispublicwoo",
True)
channel2 = channels.channels_create(user1["token"], "someoneelsecandodata",
False)
assert validation.check_channel_is_public(channel1["channel_id"]) == None
with pytest.raises(AccessError):
assert validation.check_channel_is_public(channel2["channel_id"])
other.clear()
def test_channel_listall_user_not_in_a_channel():
'''
Testing when user not in a channel.
'''
clear()
valid_viewer = auth_register("*****@*****.**", "passwordOne",
"Firstone", "Lastone")
valid_viewer_token = valid_viewer.get("token")
user_1 = auth_register("*****@*****.**", "passwordOne", "Firstone",
"Lastone")
user_1_token = user_1.get("token")
user_2 = auth_register("*****@*****.**", "passwordTwo", "Firsttwo",
"Lasttwo")
user_2_token = user_2.get("token")
channel1 = channels_create(user_1_token, "channel1", True)
channel_join(user_2_token, channel1.get("channel_id"))
channel_list = channels_listall(valid_viewer_token).get('channels')
assert channel_list[0]["channel_id"] == channel1.get("channel_id")
assert len(channel_list) == 1
def test_admin_userpermission_change_empty_input():
clear()
user = auth_register('*****@*****.**', '3mptyH3@dn0i', 'Ben', 'Lucas')
user2 = auth_register('*****@*****.**', '(&^hbhasj', 'Kyle', 'Phantom')
with pytest.raises(InputError):
admin_userpermission_change('', '', '')
with pytest.raises(InputError):
admin_userpermission_change(user['token'], '', '')
with pytest.raises(InputError):
admin_userpermission_change('', 12, '')
with pytest.raises(InputError):
admin_userpermission_change('', '', 1)
with pytest.raises(InputError):
admin_userpermission_change('', 12, 1)
with pytest.raises(InputError):
admin_userpermission_change(user['token'], '', 1)
with pytest.raises(InputError):
admin_userpermission_change(user['token'], user2['u_id'], '')
def test_channel_removeowner_invalidchannelid():
'''
Test case when attempting to remove someone as owner using an invalid channel_id
'''
clear()
#Registering a user
register = auth_register('*****@*****.**', '123abc!@#', 'Hayden',
'Everest', None)
#Storing token generated from registration process in a variable for easy access
owner_token = register['token']
#Registering another user
register1 = auth_register('*****@*****.**', '123abc!@#',
'Jordan', 'Fitch', None)
#Storing u_id generated from registration process in a variable for easy access
nonowner_u_id = register1['u_id']
#Using the registered user to create a channel
new_channel = channels_create(owner_token, "Testing Channel", True)
#Storing channel_id generated from channel creation in a variable for easy access
channel_id = new_channel['channel_id']
with pytest.raises(InputError):
channel_removeowner(owner_token, channel_id + 100, nonowner_u_id)
clear()
def test_standup_send_single_message():
'''
Test that a single message collected during the standup period is sent afterwards
'''
clear()
user = auth_register("*****@*****.**", "password", "Firstname", "Lastname")
channel = channels_create(user['token'], "Channel", True)
standup_start(user['token'], channel['channel_id'], 1)
standup_send(user['token'], channel['channel_id'], "message")
time.sleep(2)
check = search(user['token'], "message")
assert len(check['messages']) == 1
assert check['messages'][0]['message'] == "firstnamelastname: message"
def test_taken_handle():
'''
Two users register and try to change to the same valid handle.
'''
clear()
user1 = auth_register('*****@*****.**', 'p@ssw0rd', 'Apple',
'Appleson')
user2 = auth_register('*****@*****.**', 'password', 'Orange',
'Orangeson')
# user1 changes handle to hello world
user_profile_sethandle(user1['token'], 'hello world')
user_profile(user1['token'], user1['u_id'])
# user2 tries to also change to hello world
with pytest.raises(InputError):
user_profile_sethandle(user2['token'], 'hello world')
# user1 changes handle again
user_profile_sethandle(user2['token'], 'goodbye world')
user_profile(user2['token'], user2['u_id'])
with pytest.raises(InputError):
user_profile_sethandle(user1['token'], 'goodbye world')
def test_message_react_message_already_reacted():
'''
test that an InputError is raised when a user reacts to a message that they
have already reacted to
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "John", "Smith")
channel_1 = channels.channels_create(owner['token'], "channel_1", True)
message_sent = message.message_send(owner['token'],
channel_1['channel_id'],
'owner message')
message.message_react(owner['token'], message_sent['message_id'], 1)
with pytest.raises(error.InputError):
message.message_react(owner['token'], message_sent['message_id'], 1)
def test_admin_userpermission_change_invalid_user_id():
'''
Test that an InputError is raised when admin_userpermission_change
is given a u_id that does not refer to a valid user
'''
clear()
f_owner = auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
with pytest.raises(InputError):
admin_userpermission_change(f_owner['token'], f_owner['u_id'] + 1, 2)
with pytest.raises(InputError):
admin_userpermission_change(f_owner['token'], f_owner['u_id'] + 100, 2)
with pytest.raises(InputError):
admin_userpermission_change(f_owner['token'], f_owner['u_id'] - 13, 2)
with pytest.raises(InputError):
admin_userpermission_change(f_owner['token'], f_owner['u_id'] - 100, 2)
def test_message_send():
'''
tests that message_send is working
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "Homer",
"Simpson")
channel_1 = channels.channels_create(owner['token'], "channel_1", True)
message.message_send(owner['token'], channel_1['channel_id'],
'this is the first test message')
messages = channel.channel_messages(owner['token'],
channel_1['channel_id'], 0)
assert messages['messages'][0][
'message'] == 'this is the first test message'
def test_channel_remove_member(channel1):
"""
Removes member from channel, returns nothing
"""
channel_id = channel1["channel_id"]
user = data.get_user_info(1)
data.channel_remove_member(channel_id, user["u_id"])
assert data.check_user_in_channel(channel_id, user["u_id"]) == False
user2 = auth.auth_register("*****@*****.**", "google", "Alphabet", "Gamma")
channel.channel_join(user2["token"], channel_id)
data.channel_remove_member(channel_id, user2["u_id"])
assert data.check_user_in_channel(channel_id, user2["u_id"]) == False
other.clear()
def test_channel_messages():
'''
Tests for channel_messages
'''
clear()
#Creating users to create channels
user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1", None)
user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2", None)
token1 = user1['token']
token2 = user2['token']
#creating channels
ch_id1 = channels_create(token1, "aGreatChannel", True)['channel_id']
ch_id2 = channels_create(token2, "yetAnotherChannel", False)['channel_id']
with pytest.raises(InputError):
#test for invalid channel_id
channel_messages(token1, 50, 0)
#test for invalid start value
channel_messages(token1, ch_id1, 3)
with pytest.raises(AccessError):
#test for user sending message to channel they are not a member of
channel_messages(token1, ch_id2, 0)
def test_users_all_one_user():
workspace_reset()
user_ef = auth_register(
"*****@*****.**", "12345687", "Edward", "Frankenstein")
assert users_all(user_ef["token"])["users"] == [
{
'u_id': user_ef["u_id"],
'email': '*****@*****.**',
'name_first': 'Edward',
'name_last': 'Frankenstein',
'handle_str': 'edwardfrankenstein',
"profile_img_url": ""
}
]
def test_users_all_users_remain_when_logout():
workspace_reset()
user_gh = auth_register("*****@*****.**",
"ihaveadream", "Gregory", "Heidelberg")
user_ef = auth_register(
"*****@*****.**", "12345687", "Edward", "Frankenstein")
user_ij = auth_register(
"*****@*****.**", "stretchy0urh4mstrinG5thr1c3", "Ian", "Jacobs")
auth_logout(user_ef["token"])
assert users_all(user_ij["token"])["users"] == [
{
'u_id': user_gh["u_id"],
'email': '*****@*****.**',
'name_first': 'Gregory',
'name_last': 'Heidelberg',
'handle_str': 'gregoryheidelberg',
"profile_img_url": ""
},
{
'u_id': user_ef["u_id"],
'email': '*****@*****.**',
'name_first': 'Edward',
'name_last': 'Frankenstein',
'handle_str': 'edwardfrankenstein',
"profile_img_url": ""
},
{
'u_id': user_ij["u_id"],
'email': '*****@*****.**',
'name_first': 'Ian',
'name_last': 'Jacobs',
'handle_str': 'ianjacobs',
"profile_img_url": ""
}
]
def test_standup_send_notinstandup():
clear()
#Registering a user
register = auth_register('*****@*****.**', '123abc!@#', 'Hayden', 'Everest', None)
#Storing token generated from registration process in a variable for easy access
creator_token = register['token']
#Using the registered user to create a channel
new_channel = channels_create(creator_token, "Testing Channel", True)
#Storing channel_id generated from channel creation in a variable for easy access
channel_id = new_channel['channel_id']
with pytest.raises(InputError):
#Channel not in standup
standup_send(creator_token, channel_id, 'h')
def test_invalid_profile_setemail():
# Register some valid users with valid emails:
# Then check invalid
user1 = auth_register('*****@*****.**', 'Em4il123',
'Emailia', 'Compose')
token = user1['token']
with pytest.raises(InputError) as e:
user_profile_setemail(token, 'Thisisntanemail.com')
with pytest.raises(InputError) as e:
user_profile_setemail(token, '*****@*****.**')
with pytest.raises(InputError) as e:
user_profile_setemail(token, 'UNeverSleepWell.com')
user2 = auth_register('*****@*****.**', 'Abdullah1', 'Abdul',
'Ahmed')
token = user2['token']
with pytest.raises(InputError) as e:
user_profile_setemail(token, 'ThisisntanemailYouGenius.com')
with pytest.raises(InputError) as e:
user_profile_setemail(token, 'microsoft.com')
with pytest.raises(InputError) as e:
user_profile_setemail(token, '*****@*****.**')
user3 = auth_register('*****@*****.**', 'Jeffrey', 'Mynameis',
'Mypassword')
token = user3['token']
with pytest.raises(InputError) as e:
user_profile_setemail(token, 'ThisisntanemailYouGenius.com')
with pytest.raises(InputError) as e:
user_profile_setemail(token, '*****@*****.**')
with pytest.raises(InputError) as e:
user_profile_setemail(token, '*****@*****.**')
def test_message_remove_multiple_channels():
'''
Test that message remove works when a user is in multiple channels
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "Homer",
"Simpson")
user = auth.auth_register("*****@*****.**", "password", "Bart", "Simpson")
channels.channels_create(owner['token'], "channel_1", True)
channel_2 = channels.channels_create(owner['token'], "channel_2", True)
channel.channel_join(user['token'], channel_2['channel_id'])
message.message_send(user['token'], channel_2['channel_id'],
'test message 1')
message_to_remove = message.message_send(user['token'],
channel_2['channel_id'],
'test message 2')
message.message_remove(user['token'], message_to_remove['message_id'])
messages = channel.channel_messages(user['token'], channel_2['channel_id'],
0)
assert messages['messages'][0]['message'] == 'test message 1'
assert messages['start'] == 0
assert messages['end'] == -1
assert len(messages['messages']) == 1
def test_users_all_simple():
user_info = auth.auth_register('m@gmail', 'sadsad', 'name', 'lastname')
# Giving all the users' profile details
assert other.users_all(user_info['token']) == {
'users': [
{
'u_id': 1,
'email': 'm@gmail',
'name_first': 'name',
'name_last': 'lastname',
'handle_str': 'namelastname',
}
],
}
def test_message_remove():
'''
Test that message_remove removes the specified message in the channel
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "Homer",
"Simpson")
channel_1 = channels.channels_create(owner['token'], "channel_1", True)
message_1 = message.message_send(owner['token'], channel_1['channel_id'],
'this is the first test message')
message.message_remove(owner['token'], message_1['message_id'])
messages = channel.channel_messages(owner['token'],
channel_1['channel_id'], 0)
assert messages['messages'] == []
def test_standup_active_invalid_inputs():
'''
Test basic error raising from invalid inputs
'''
clear()
user = auth_register("*****@*****.**", "password", "Firstname", "Lastname")
channel = channels_create(user['token'], "Channel", True)
# invalid token raises AccessError
with pytest.raises(AccessError):
standup_active("notToken", channel['channel_id'])
# invalid channel_id raises InputError
with pytest.raises(InputError):
standup_active(user['token'], -1)
