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)