def test_channel_create_v2_token(reg_user, basic_channel_name):
clear_v2()
reg_user(0)['token']
channel_name = basic_channel_name
fake_token = 'random values r32fecaswd'
with pytest.raises(AccessError):
channels_create_v2(fake_token, channel_name, True)
def test_message_send_invalid_channel_id():
# Test if InputError is raised when given invalid channel id
clear_v1()
user = auth_register_v2('*****@*****.**', 'password123', 'Terry', 'Wills')
channels_create_v2(user['token'], 'TERRYS CHANNEL', True)
with pytest.raises(InputError):
message_send_v2(user['token'], -1, 'anyone here?')
def test_channel_create_v2_name_greater_than_twenty_characters(reg_user):
clear_v2()
token_1 = reg_user(0)['token']
channel_name = 'Rip memeber crying room 10000000000000 and there was 3'
is_public = True
with pytest.raises(InputError):
channels_create_v2(token_1, channel_name, is_public) # should not work as channel ....
def test_channels_listall_v2_correct(user_details):
clear_v2()
email, pwd, fName, lName = user_details
token = auth_register_v2(email, pwd, fName, lName)['token']
name_1 = "Stress Puppy"
name_2 = "Sweet Britney"
name_3 = "Small Room"
is_public_1 = True
is_public_2 = False
is_public_3 = False
channel_id_1 = channels_create_v2(token, name_1, is_public_1)['channel_id']
channel_id_2 = channels_create_v2(token, name_2, is_public_2)['channel_id']
channel_id_3 = channels_create_v2(token, name_3, is_public_3)['channel_id']
assert channels_listall_v2(token) == {
'channels': [{
'channel_id': channel_id_1,
'name': name_1
}, {
'channel_id': channel_id_2,
'name': name_2
}, {
'channel_id': channel_id_3,
'name': name_3
}]
}
def create_input():
clear_v1()
data_test_users = [
auth_register_v2("*****@*****.**", "validpassword", "Josh",
"Hatton"),
auth_register_v2("*****@*****.**", "anotherpassword", "Bunny",
"Dong"),
auth_register_v2("*****@*****.**", "password3", "Jordan",
"Milch"),
auth_register_v2("*****@*****.**", "4thpassword", "Dean",
"Zworestine"),
auth_register_v2("*****@*****.**", "finalpassword", "Eric",
"Zheng"),
]
data_test_channels = [
channels_create_v2(data_test_users[0]["token"], "First Channel", True),
channels_create_v2(data_test_users[1]["token"], "Second Channel",
True),
channels_create_v2(data_test_users[2]["token"], "Third Channel",
False),
]
return [data_test_users, data_test_channels]
def test_channels_listall_v2_invalid_user(user_setup):
'''
Invalid user attempts to call channels listall
'''
channels_create_v2(make_token(1), 'PChannel1', True)
with pytest.raises(AccessError):
channels_list_v2(make_token(1000))
def test_no_name():
clear_v1()
owner = auth_register_v2("*****@*****.**", "password", "David",
"Folly")['token']
with pytest.raises(InputError):
channels_create_v2(owner, "", False)
def test_channel_leave_invalid_channel_id():
# Test if InputError is raised when given invalid channel id
clear_v1()
user = auth_register_v2('*****@*****.**', 'password123', 'Terry', 'Wills')
channels_create_v2(user['token'], 'Example Channel', True)
with pytest.raises(InputError):
channel_leave_v1(user['token'], -1)
def test_data():
"""
channel a
owners
a
members
a, b
channel c
owners
c
members
c
"""
clear_v1()
global_owner = auth_register_v2('*****@*****.**', '123456', 'Global',
'Owner')
a_data = auth_register_v2('*****@*****.**', '123456', 'Andy', 'Anderson')
b_data = auth_register_v2('*****@*****.**', '123456', 'Bob', 'Bobinson')
c_data = auth_register_v2('*****@*****.**', '123456', 'Chris', 'Con')
# Channel that only 'a' and 'b' are in
a_ch_id = channels_create_v2(a_data["token"], 'A\'s Public',
True)['channel_id']
# b to join channel a
channel_join_v2(b_data["token"], a_ch_id)
c_ch_id = channels_create_v2(c_data["token"], 'C\'s Public',
True)['channel_id']
return global_owner, a_data, b_data, c_data, a_ch_id, c_ch_id
def create_valid_user_data():
""" Creates and returns a set of valid users.
"""
clear_v1()
user1 = auth_register_v2('*****@*****.**', '123abc!@#', 'a', 'b')
user2 = auth_register_v2('*****@*****.**', '123abc!@#', 'c', 'd')
user3 = auth_register_v2('*****@*****.**', '123abc!@#', 'e', 'f')
user4 = auth_register_v2('*****@*****.**', '123abc!@#', 'g', 'h')
users = [user1, user2, user3, user4]
# Create 3 channels with owners user1, user2 & user3 respectively
channel_1 = channels_create_v2(user1['token'], "General", True)
channel_2 = channels_create_v2(user2['token'], "Music", True)
channel_3 = channels_create_v2(user3['token'], "Study", True)
# User2, user3 all join channel1
channel_join_v2(user2['token'], channel_1['channel_id'])
channel_join_v2(user3['token'], channel_1['channel_id'])
# User4 join channel2
channel_join_v2(user4['token'], channel_2['channel_id'])
# User1 join channel3
channel_join_v2(user1['token'], channel_3['channel_id'])
channels = [channel_1, channel_2, channel_3]
return {'users': users, 'channels': channels}
def test_notifications(register_users):
channels_create_v2(make_token(1), "PublicChannel1", True)
channel_invite_v2(make_token(1), 0, 0)
assert notifications_get_v1(make_token(0)) == {
"notifications": [{
"channel_id":
0,
"dm_id":
-1,
"notification_message":
"petertran invited you to PublicChannel1"
}]
}
dm_create_v1(make_token(0), [1]) # dm_id 0
assert notifications_get_v1(make_token(1)) == {
"notifications": [{
"channel_id":
-1,
"dm_id":
0,
"notification_message":
"gungeetsingh added you to dm gungeetsingh, petertran"
}]
}
clear_v1()
def test_channels_create_length():
# InputError should arise from creating a channel name that
# is longer than 20 characters.
clear_v1()
user = auth_register_v2("*****@*****.**", "password", "John",
"Smith")['token']
with pytest.raises(InputError):
channels_create_v2(user, "L" * 21, True)
def test_invalid_token():
clear_v1()
result1 = auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
channels_create_v2(result1['token'], "The party channel 1", True)
channels_create_v2(result1['token'], "The party channel 2", True)
with pytest.raises(AccessError):
user_stats('abcdef')
def test_multiple_errors():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
user_2 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_2 = channels_create_v2(user_1['token'], 'Channel 2', True)
with pytest.raises(InputError):
message_send_v2(user_1['token'], channel_2['channel_id'], 'a' * 1001)
message_send_v2(user_2['token'], channel_1['channel_id'], 'b' * 1001)
def test_not_in_channel():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
user_2 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
channel_2 = channels_create_v2(user_1['token'], 'Channel 2', True)
with pytest.raises(AccessError):
message_send_v2(user_1['token'], channel_2['channel_id'], 'Hey!')
message_send_v2(user_2['token'], channel_1['channel_id'], 'Imposter')
def test_create_channel_successfully():
clear_v1()
u1 = auth_register_v2("*****@*****.**", "abcdefg1234", "bunny",
"dong")
u2 = auth_register_v2("*****@*****.**", "abcdefg1234", "bunny",
"dong")
u3 = auth_register_v2("*****@*****.**", "abcdefg1234", "abcdef",
"fwef")
channel_1 = channels_create_v2(u1['token'], "The party channel 1",
True)['channel_id']
assert (channels_listall_v2(u1['token']) == {
'channels': [
{
'channel_id': channel_1,
'name': "The party channel 1",
},
]
})
channel_2 = channels_create_v2(u2['token'], "The party channel 2",
True)['channel_id']
assert (channels_listall_v2(u1['token']) == {
'channels': [
{
'channel_id': channel_1,
'name': "The party channel 1",
},
{
'channel_id': channel_2,
'name': "The party channel 2",
},
]
})
channel_3 = channels_create_v2(u3['token'], "The party channel 3",
True)['channel_id']
assert (channels_listall_v2(u1['token']) == {
'channels': [
{
'channel_id': channel_1,
'name': "The party channel 1",
},
{
'channel_id': channel_2,
'name': "The party channel 2",
},
{
'channel_id': channel_3,
'name': "The party channel 3",
},
]
})
clear_v1()
def test_channel_messages_invalid_channel():
"""
Messages should not be displayed from invalid channel
"""
clear_v1()
user = auth_register_v2("*****@*****.**", "password", "Harry", "Stein")
channels_create_v2(user['token'], "Channel Example", True)
# InputError raised when invalid channel id is given
with pytest.raises(InputError):
channel_messages_v2(user['token'], "invalid channel id", 0)
def test_global_owner(test_data):
global_owner, a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A\'s private", False)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B\'s private", False)["channel_id"]
c_ch_id = channels_create_v2(c_data["token"], "B\'s private", False)["channel_id"]
assert channel_join_v2(global_owner["token"], a_ch_id) == {}
assert channel_join_v2(global_owner["token"], b_ch_id) == {}
assert channel_join_v2(global_owner["token"], c_ch_id) == {}
def test_search_no_match(register_users):
assert search_v2(make_token(0), "Ciao") == {"messages": []}
channels_create_v2(make_token(0), "PublicChannel1", True)
dm_create_v1(make_token(0), [1, 2]) # dm_id 0
message_send_v2(make_token(0), 0, "Hello")
message_senddm_v1(make_token(0), 0, "Goodbye")
assert search_v2(make_token(0), "Ciao") == {"messages": []}
def test_undefined_privacy():
clear_v1()
owner = auth_register_v2("*****@*****.**", "password", "David",
"Folly")['token']
with pytest.raises(InputError):
channels_create_v2(owner, "Channel Name", 123121)
channels_create_v2(owner, "Channel Name", "True")
channels_create_v2(owner, "Channel Name", "False")
channels_create_v2(owner, "Channel Name", "")
channels_create_v2(owner, "Channel Name", "HEY HEY HEYYYYY")
def test_message_sendlater_invalid_channel_id():
# Test if InputError is raised when given invalid channel id
clear_v1()
user = auth_register_v2('*****@*****.**', 'password123', 'Terry', 'Wills')
channels_create_v2(user['token'], 'TERRYS CHANNEL', True)
time = datetime.now().replace(microsecond=0) + timedelta(0, 3)
time_sent = time.timestamp()
with pytest.raises(InputError):
message_sendlater_v1(user['token'], -1, 'anyone here?', time_sent)
def test_channels_create_v2_name_too_long(user_setup):
'''
User attempts to create a channel whose name is too long and fails
'''
badname1 = 'brothisnameiswaytoolongicantbelieveyouwouldeventrythisman'
badname2 = 'youreallytryingtoputanotherlongnamebroyouneverlearn'
# for public channel
with pytest.raises(InputError):
channels_create_v2(make_token(0), badname1, True)
# for private channel
with pytest.raises(InputError):
channels_create_v2(make_token(0), badname2, False)
def test_data():
clear_v1()
a_data = auth_register_v2("*****@*****.**", "123456", "Andy", "Anderson")
b_data = auth_register_v2("*****@*****.**", "123456", "Bob", "Bobinson")
c_data = auth_register_v2("*****@*****.**", "123456", "Chris", "Con")
a_ch_id = channels_create_v2(a_data["token"], "A\"s Public",
True)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B\"s Private",
False)["channel_id"]
return (a_data, b_data, c_data, a_ch_id, b_ch_id)
def test_channels_create_v2_works(user_setup):
'''
User is able to create a channel
'''
assert channels_create_v2(make_token(0), "channel1", True) == {
'channel_id': 0
}
assert channels_create_v2(make_token(0), "channel2", True) == {
'channel_id': 1
}
assert channels_create_v2(make_token(0), "channel3", True) == {
'channel_id': 2
}
def test_channels_create_valid():
# Test if channel has been successfully created by accessing channels_list_v2
clear_v1()
user_1 = auth_register_v2("*****@*****.**", "password", "Joshua", "King")
channel_1 = channels_create_v2(user_1['token'], "Channel 1",
True)['channel_id']
channel_2 = channels_create_v2(user_1['token'], "Channel 2",
False)['channel_id']
# Check stored values of channel_list_v2
channels_dict = channels_list_v2(user_1['token'])
assert channels_dict['channels'][0]['channel_id'] == channel_1
assert channels_dict['channels'][0]['name'] == 'Channel 1'
assert channels_dict['channels'][1]['channel_id'] == channel_2
assert channels_dict['channels'][1]['name'] == 'Channel 2'
def test_data():
clear_v1()
a_data = auth_register_v2("*****@*****.**", "123456", "Andy", "Anderson")
b_data = auth_register_v2("*****@*****.**", "123456", "Bob", "Bobinson")
c_data = auth_register_v2("*****@*****.**", "123456", "Chris", "Con")
# Channel that only "a" and "b" are in
ab_ch_id = channels_create_v2(a_data["token"], "A\"s Public",
True)["channel_id"]
channel_join_v2(b_data["token"], ab_ch_id)
c_ch_id = channels_create_v2(c_data["token"], "C\"s Private",
False)["channel_id"]
return (a_data, b_data, c_data, ab_ch_id, c_ch_id)
def test_private_channel(test_data):
_, a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A\'s private", False)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B\'s private", False)["channel_id"]
c_ch_id = channels_create_v2(c_data["token"], "B\'s private", False)["channel_id"]
with pytest.raises(AccessError):
channel_join_v2(b_data["token"], a_ch_id)
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(a_data["token"], b_ch_id)
channel_join_v2(c_data["token"], b_ch_id)
channel_join_v2(a_data["token"], c_ch_id)
channel_join_v2(b_data["token"], c_ch_id)
def test_channel_pin(test_data):
a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A channel",
True)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B channel",
True)["channel_id"]
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(c_data["token"], b_ch_id)
# pin own message
a1_msg_id = message_send_v2(a_data["token"], a_ch_id,
"My own message")["message_id"]
message_pin_v1(a_data["token"], a1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# we know there is only one message sent, so it must be index 0 of messages
assert messages[0]["message_id"] == a1_msg_id
assert messages[0]["is_pinned"] == True
# pin someone elses message
c1_msg_id = message_send_v2(c_data["token"], a_ch_id,
"C's message")["message_id"]
message_pin_v1(a_data["token"], c1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# channel_messages is most recent message first
assert messages[0]["message_id"] == c1_msg_id
assert messages[0]["is_pinned"] == True
# b_ch
b1_msg_id = message_send_v2(b_data["token"], b_ch_id,
"B's message whoo")["message_id"]
message_pin_v1(b_data["token"], b1_msg_id)
messages = channel_messages_v2(b_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == b1_msg_id
assert messages[0]["is_pinned"] == True
channel_addowner_v1(b_data["token"], b_ch_id, c_data["auth_user_id"])
c2_msg_id = message_send_v2(c_data["token"], b_ch_id,
"C's second message whoo")["message_id"]
message_pin_v1(c_data["token"], c2_msg_id)
messages = channel_messages_v2(c_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == c2_msg_id
assert messages[0]["is_pinned"] == True
def test_standup_start_v1_standup_not_started_in_multiple_channels_with_same_user(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token']
channel_name = basic_channel_name
channel_id_1 = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_id_2 = channels_create_v2(token_1, 'nice channel', True)['channel_id'] #second channel
standup_length = 1
standup_start_v1(token_1, channel_id_1, standup_length)
is_active_channel_1 = standup_active_v1(token_1, channel_id_1)['is_active']
assert is_active_channel_1 == True
is_active_channel_2 = standup_active_v1(token_1, channel_id_2)['is_active']
assert is_active_channel_2 == False
def test_share_message_not_in_receiving_channel():
clear_v1()
user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a')
user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b')
channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True)
channel_2 = channels_create_v2(user_2['token'], 'Channel 2', True)
msg1 = message_send_v2(user_1['token'], channel_1['channel_id'],
'Hi Chan 1')
msg2 = message_send_v2(user_2['token'], channel_2['channel_id'],
'Hi Chan 2')
with pytest.raises(AccessError):
message_share_v1(user_1['token'], msg2['message_id'], '', channel_2,
-1)
message_share_v1(user_2['token'], msg1['message_id'], 'SPAM!',
channel_1, -1)
