def test_removed_dms(): """Tests that sent dm messages are now 'Removed user' after the user is removed """ clear_v1() user_1 = auth_register_v2("*****@*****.**", "finalpassword", "Eric", "Zheng") user_2 = auth_register_v2("*****@*****.**", "validpassword", "Josh", "Hatton") dm_1 = dm_create_v1(user_1["token"], [user_2["auth_user_id"]]) message_senddm_v1(user_1["token"], dm_1["dm_id"], "Hello user 2!") message_2 = message_senddm_v1(user_2["token"], dm_1["dm_id"], "Nice to meet you user 1") message_senddm_v1(user_2["token"], dm_1["dm_id"], "you are a donkey :)") assert admin_user_remove_v1(user_1["token"], user_2["auth_user_id"]) == {} dm_1_messages = dm_messages_v1(user_1["token"], dm_1["dm_id"], 0) for dm in dm_1_messages["messages"]: if dm["message_id"] == message_2["message_id"]: assert dm["message"] == "Removed user" clear_v1()
def test_senddm_different_channels(): clear_v1() user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a') user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b') user_3 = auth_register_v2('*****@*****.**', 'cccccc', 'c', 'c') dm_1 = dm_create_v1(user_1['token'], [user_2['auth_user_id']]) dm_2 = dm_create_v1(user_2['token'], [user_3['auth_user_id']]) dm_3 = dm_create_v1(user_3['token'], [user_1['auth_user_id']]) msg1 = message_senddm_v1(user_1['token'], dm_1['dm_id'], 'Hello World!') msg2 = message_senddm_v1(user_2['token'], dm_2['dm_id'], 'Hello World!') msg3 = message_senddm_v1(user_3['token'], dm_3['dm_id'], 'Hello World!') assert type(msg1) == dict assert type(msg1['message_id']) == int assert type(msg2) == dict assert type(msg2['message_id']) == int assert type(msg3) == dict assert type(msg3['message_id']) == int assert dm_messages_v1(user_1['token'], dm_1['dm_id'], 0)['messages'][0]['message'] == "Hello World!" assert dm_messages_v1(user_2['token'], dm_2['dm_id'], 0)['messages'][0]['message'] == "Hello World!" assert dm_messages_v1(user_3['token'], dm_3['dm_id'], 0)['messages'][0]['message'] == "Hello World!" assert msg1 != msg2 assert msg1 != msg3 assert msg2 != msg3
def test_invalid_token(): """ Tests return of expected output when given a token that doesn't exist, or if the user is not in the channel/dm. """ clear_v1() # Token doesnt exist user_1 = auth_register_v2('*****@*****.**', 'happydays1', 'Eric', 'Zheng') with pytest.raises(AccessError): notifications_get_v1(user_1['token'] + 'bug') # User not in channel user_2 = auth_register_v2('*****@*****.**', 'happydays2', 'Josh', 'Hatton') channel_1 = channels_create_v2(user_1['token'], 'Channel 1', True) user_2_handle = user_profile_v2(user_1['token'], user_2['auth_user_id']) message_send_v2(user_1['token'], channel_1['channel_id'], f"Hi @{user_2_handle['user']['handle_str']}") assert notifications_get_v1(user_2['token']) == {'notifications': []} # User not in dm dm_1 = dm_create_v1(user_1['token'], [user_2['auth_user_id']]) user_3 = auth_register_v2('*****@*****.**', 'hihihi!!!', 'Bunny', 'Dong') user_3_handle = user_profile_v2(user_1['token'], user_3['auth_user_id']) message_senddm_v1(user_1['token'], dm_1['dm_id'], f"Hello @{user_3_handle['user']['handle_str']}") assert notifications_get_v1(user_3['token']) == {'notifications': []}
def test_channel_messages_fiftyone(user_setup, dm_setup): # send 51 messages and check the dms timeStampStr = [] for i in range(51): message_senddm_v1(make_token(0), 1, str(i)) dateTimeObj = datetime.now() timeStampStr.append(dateTimeObj.strftime("%d-%b-%Y (%H:%M)")) messages = [] for i in range(50): message = { "message_id": (49 - i), "u_id": 0, "message": str(49 - i), "time_created": timeStampStr[49 - i], "channel_id": -1, "dm_id": 1, 'reacts': [{ 'react_id': 1, 'u_ids': [], 'is_this_user_reacted': False }], 'is_pinned': False } messages.append(message) assert dm_messages_v1(make_token(0), 1, 0) == { "messages": messages, "start": 0, "end": 50, } # sends the least recent message assert dm_messages_v1(make_token(0), 1, 50) == { "messages": [{ "message_id": 0, "u_id": 0, "message": "0", "time_created": timeStampStr[0], "channel_id": -1, "dm_id": 1, 'reacts': [{ 'react_id': 1, 'u_ids': [], 'is_this_user_reacted': False }], 'is_pinned': False }], "start": 50, "end": -1, }
def test_dm_messages_v1_leave(user_setup, dm_setup): # testing to see if messages works after user leaves message_senddm_v1(make_token(0), 1, "onions cannot be eaten raw") dateTimeObj = datetime.now() timeStampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M)") dm_leave_v1(make_token(0), 1) assert dm_messages_v1(make_token(1), 1, 0) == { "messages": [ { "message_id": 0, "u_id": 0, "message": "onions cannot be eaten raw", "time_created": timeStampStr, "channel_id": -1, "dm_id": 1, 'reacts': [{ 'react_id': 1, 'u_ids': [], 'is_this_user_reacted': False }], 'is_pinned': False }, ], "start": 0, "end": -1, }
def test_dm_message_senddm_v1_no_valid_dm_id_found(reg_user, basic_message): clear_v2() token_sender = reg_user(0)['token'] dm_id = 'random values asf3q2vdvdsan cjewqjfqpfd' message = basic_message with pytest.raises(InputError): message_senddm_v1(token_sender, dm_id, message) #invalid dm_id so cant sent a message this will fail
def test_dm_messages_v1_less_50(): clear_v1() auth_user_1_data = auth_register_v2("*****@*****.**", "123456", "Andy", "Dandy") auth_user_1_token = auth_user_1_data["token"] auth_user_1_id = auth_user_1_data["auth_user_id"] auth_user_2_data = auth_register_v2("*****@*****.**", "123456", "Bob", "Hobs") auth_user_2_token = auth_user_2_data["token"] auth_user_2_id = auth_user_2_data["auth_user_id"] auth_user_3_data = auth_register_v2("*****@*****.**", "123456", "Chris", "Wiz") auth_user_3_id = auth_user_3_data["auth_user_id"] dm_data_1 = dm_create_v1(auth_user_1_token, [auth_user_2_id, auth_user_3_id]) dm_id_1 = dm_data_1["dm_id"] message_id_1 = message_senddm_v1(auth_user_1_token, dm_id_1, "Hello")["message_id"] message_id_2 = message_senddm_v1(auth_user_2_token, dm_id_1, "World")["message_id"] dm_messages_data = dm_messages_v1(auth_user_1_token, dm_id_1, 0) assert dm_messages_data["messages"][0]["message_id"] == message_id_2 assert dm_messages_data["messages"][0]["u_id"] == auth_user_2_id assert dm_messages_data["messages"][0]["message"] == "World" assert dm_messages_data["messages"][1]["message_id"] == message_id_1 assert dm_messages_data["messages"][1]["u_id"] == auth_user_1_id assert dm_messages_data["messages"][1]["message"] == "Hello" assert dm_messages_data["end"] == -1
def test_message_senddm_msg_too_long(): # InputError when message is more than 1000 characters clear_v1() DM_owner = auth_register_v2('*****@*****.**', 'password123', 'Roger', 'Rogerson') user_receiver = auth_register_v2('*****@*****.**', 'password123', 'Billy', 'Batson') DM = dm_create_v1(DM_owner['token'], [user_receiver['auth_user_id']]) with pytest.raises(InputError): message_senddm_v1(DM_owner['token'], DM['dm_id'], "E"*1001)
def test_message_senddm_invalid_dm_id(): # InputError if dm_id given is invalid clear_v1() DM_owner = auth_register_v2('*****@*****.**', 'password123', 'Jordy', 'Eli') user_receiver = auth_register_v2('*****@*****.**', 'password123', 'John', 'Lam') dm_create_v1(DM_owner['token'], [user_receiver['auth_user_id']]) with pytest.raises(InputError): message_senddm_v1(DM_owner['token'], -1, 'sup')
def test_message_senddm_invalid_token(): # AccessError should arise if passing invalid token clear_v1() DM_owner = auth_register_v2('*****@*****.**', 'password123', 'Jerry', 'Tin') user_receiver = auth_register_v2('*****@*****.**', 'password123', 'Shelly', 'Tin') DM = dm_create_v1(DM_owner['token'], [user_receiver['auth_user_id']]) with pytest.raises(AccessError): message_senddm_v1(-1, DM['dm_id'], 'yo what up')
def test_message_senddm_user_not_in_dm_group(): # AccessError should arise if user is not a member of the DM group clear_v1() DM_owner = auth_register_v2('*****@*****.**', 'password123', 'Sheldon', 'Andie') user_receiver = auth_register_v2('*****@*****.**', 'password123', 'Roger', 'Allie') user_random = auth_register_v2('*****@*****.**', 'password123', 'Billy', 'Bobby') DM = dm_create_v1(DM_owner['token'], [user_receiver['auth_user_id']]) with pytest.raises(AccessError): message_senddm_v1(user_random['token'], DM['dm_id'], 'can i join plz')
def test_dm_message_senddm_v1_message_more_than_1000_characters(reg_user): clear_v2() token_sender = reg_user(0)['token'] auth_user_id_receiver = reg_user(1)['auth_user_id'] dm_id = dm_create_v1(token_sender, [auth_user_id_receiver])['dm_id'] yuge_string = 'a'*1001 #check 1000 and 1001 with pytest.raises(InputError): message_senddm_v1(token_sender, dm_id, yuge_string) #yuge strings over 1000 characters so will raise error
def test_dm_message_senddm_v1_token(reg_user, basic_message): clear_v2() token_sender = reg_user(0)['token'] auth_user_id_receiver = reg_user(1)['auth_user_id'] dm_id = dm_create_v1(token_sender, [auth_user_id_receiver])['dm_id'] fake_token = 'garbage values' message = basic_message with pytest.raises(AccessError): message_senddm_v1(fake_token, dm_id, message) #check token
def test_senddm_invalid_access(): clear_v1() user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a') user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b') user_3 = auth_register_v2('*****@*****.**', 'cccccc', 'c', 'c') dm_1 = dm_create_v1(user_1['token'], [user_2['auth_user_id']]) with pytest.raises(AccessError): message_senddm_v1(user_3['token'], dm_1['dm_id'], 'Sliding in') message_senddm_v1(user_3['token'], dm_1['dm_id'], 'Back again')
def test_dm_message_senddm_v1_auth_user_not_member(reg_user, basic_message): clear_v2() token_sender = reg_user(0)['token'] auth_user_id_receiver = reg_user(1)['auth_user_id'] non_member_of_dm_token = reg_user(2)['token'] dm_id = dm_create_v1(token_sender, [auth_user_id_receiver])['dm_id'] message = basic_message with pytest.raises(AccessError): message_senddm_v1(non_member_of_dm_token, dm_id, message) #cant post when the user is not part of the dm
def test_multiple_success(create_input): message_senddm_v1(create_input[0][0]["token"], create_input[1][0]["dm_id"], "This is the first normal message") assert len(dm_messages_v1(create_input[0][0]["token"], create_input[1][0]["dm_id"], 0)["messages"]) == 1 current_time = int(time.time()) msg = message_sendlaterdm_v1(create_input[0][1]["token"], create_input[1][0]["dm_id"], "Hey there, I'm from the past!", current_time + 2) assert type(msg) == dict assert type(msg["message_id"]) == int msg = message_sendlaterdm_v1(create_input[0][2]["token"], create_input[1][0]["dm_id"], "Hey, I'm from the distant past!", current_time + 4) assert type(msg) == dict assert type(msg["message_id"]) == int msg = message_sendlaterdm_v1(create_input[0][0]["token"], create_input[1][0]["dm_id"], "Hey there, I'm from the past past!!", current_time + 3) assert type(msg) == dict assert type(msg["message_id"]) == int message_senddm_v1(create_input[0][2]["token"], create_input[1][0]["dm_id"], "This is the second normal message") # Make sure delayed message has not been sent yet assert len(dm_messages_v1(create_input[0][0]["token"], create_input[1][0]["dm_id"], 0)["messages"]) == 2 # Wait 2.5 seconds and check again; first delayed message should be there time.sleep(2.5) msgs = dm_messages_v1(create_input[0][1]["token"], create_input[1][0]["dm_id"], 0)["messages"] assert len(msgs) == 3 assert msgs[0]["message"] == "Hey there, I'm from the past!" assert msgs[0]["time_created"] == current_time + 2 assert msgs[1]["message"] == "This is the second normal message" assert msgs[1]["time_created"] == current_time assert msgs[2]["message"] == "This is the first normal message" assert msgs[2]["time_created"] == current_time # Wait 1 second; second delayed message should be there time.sleep(1) msgs = dm_messages_v1(create_input[0][1]["token"], create_input[1][0]["dm_id"], 0)["messages"] assert len(msgs) == 4 assert msgs[0]["message"] == "Hey there, I'm from the past past!!" assert msgs[0]["time_created"] == current_time + 3 assert msgs[1]["message"] == "Hey there, I'm from the past!" assert msgs[1]["time_created"] == current_time + 2 assert msgs[2]["message"] == "This is the second normal message" assert msgs[2]["time_created"] == current_time assert msgs[3]["message"] == "This is the first normal message" assert msgs[3]["time_created"] == current_time # Wait 1 more second; final delayed message should be there time.sleep(1) msgs = dm_messages_v1(create_input[0][1]["token"], create_input[1][0]["dm_id"], 0)["messages"] assert len(msgs) == 5 assert msgs[0]["message"] == "Hey, I'm from the distant past!" assert msgs[0]["time_created"] == current_time + 4 assert msgs[1]["message"] == "Hey there, I'm from the past past!!" assert msgs[1]["time_created"] == current_time + 3 assert msgs[2]["message"] == "Hey there, I'm from the past!" assert msgs[2]["time_created"] == current_time + 2 assert msgs[3]["message"] == "This is the second normal message" assert msgs[3]["time_created"] == current_time assert msgs[4]["message"] == "This is the first normal message" assert msgs[4]["time_created"] == current_time
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_start_negative(reg_user): clear_v2() sender = reg_user(0) token_sender = sender['token'] auth_user_id_receiver = reg_user(1)['auth_user_id'] dm_id = dm_create_v1(token_sender, [auth_user_id_receiver])['dm_id'] start = -1 message = "Test" message_senddm_v1(token_sender, dm_id, message)['message_id'] with pytest.raises(InputError): dm_messages_v1(token_sender, dm_id, start)
def test_different_permissions_remove_dm(): clear_v1() user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a') user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b') user_3 = auth_register_v2('*****@*****.**', 'cccccc', 'c', 'c') dm_1 = dm_create_v1(user_1['token'], [user_2['auth_user_id']]) dmsg1 = message_senddm_v1(user_2['token'], dm_1['dm_id'], 'Hello World! 1') assert message_remove_v1(user_2['token'], dmsg1['message_id']) == {} dmsg2 = message_senddm_v1(user_2['token'], dm_1['dm_id'], 'Hello World! 2') with pytest.raises(AccessError): message_remove_v1(user_1['token'], dmsg2['message_id']) message_remove_v1(user_3['token'], dmsg2['message_id'])
def test_invalid_dm_message_id(): clear_v1() user = auth_register_v2('*****@*****.**', 'passwod298372', 'Ming', 'Lee') user2 = auth_register_v2('*****@*****.**', 'passwod298372', 'Ming', 'Lee') dm = dm_create_v1(user["token"], [user2["auth_user_id"]]) message_senddm_v1(user['token'], dm['dm_id'], 'test') with pytest.raises(InputError): message_share_v1(user["token"], "invalid", "message", -1, dm["dm_id"]) message_share_v1(user["token"], 58181211, "message", -1, dm["dm_id"]) message_share_v1(user["token"], "", "message", -1, dm["dm_id"])
def test_share_message_not_in_receiving_dm(): clear_v1() user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a') user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b') dm_1 = dm_create_v1(user_1['token'], []) dm_2 = dm_create_v1(user_2['token'], []) msg1 = message_senddm_v1(user_1['token'], dm_1['dm_id'], 'Hi DM 1') msg2 = message_senddm_v1(user_2['token'], dm_2['dm_id'], 'Hi DM 2') with pytest.raises(AccessError): message_share_v1(user_1['token'], msg2['message_id'], '', -1, dm_1['dm_id']) message_share_v1(user_2['token'], msg1['message_id'], 'SPAM!', -1, dm_1['dm_id'])
def test_dm_messages_v1_start_is_greater_than_total(reg_user, basic_message): clear_v2() token_sender = reg_user(0)['token'] auth_user_id_receiver = reg_user(1)['auth_user_id'] dm_id = dm_create_v1(token_sender, [auth_user_id_receiver])['dm_id'] start = 57 for _ in range(0, 55): message_senddm_v1(token_sender, dm_id, basic_message) with pytest.raises(InputError): dm_messages_v1(token_sender, dm_id, start) #out of bounds of the total messages in the channel
def test_remove_from_dm(): clear_v1() user_1 = auth_register_v2('*****@*****.**', 'aaaaaa', 'a', 'a') user_2 = auth_register_v2('*****@*****.**', 'bbbbbb', 'b', 'b') dm_1 = dm_create_v1(user_1['token'], [user_2['auth_user_id']]) msg_1 = message_senddm_v1(user_1['token'], dm_1['dm_id'], 'Sliding in') message_remove_v1(user_1['token'], msg_1['message_id']) assert len(dm_messages_v1(user_1['token'], dm_1['dm_id'], 0)['messages']) == 0 msg_2 = message_senddm_v1(user_1['token'], dm_1['dm_id'], 'Pls dont block me') message_edit_v2(user_1['token'], msg_2['message_id'], '') assert len(dm_messages_v1(user_1['token'], dm_1['dm_id'], 0)['messages']) == 0
def create_dms(): 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] user_list = [] user_list.append(users[1]['auth_user_id']) user_list.append(users[2]['auth_user_id']) dm_1 = dm_create_v1(users[0]['token'], user_list) #create dm 1 user_list = [] user_list.append(users[0]['auth_user_id']) dm_2 = dm_create_v1(users[1]['token'], user_list) #create dm 2 user_list = [] user_list.append(users[0]['auth_user_id']) user_list.append(users[1]['auth_user_id']) user_list.append(users[2]['auth_user_id']) dm_3 = dm_create_v1(users[3]['token'], user_list) #create dm 3 message_ids_1 = [] #correct_msg_1 = [] for i in range(0, 50): msg = str(i) message_id = message_senddm_v1(users[0]['token'], dm_1['dm_id'], msg) message_ids_1.append(message_id) #correct_msg_1.append(msg) message_ids_2 = [] for i in range(200, 400): msg = str(i) message_id = message_senddm_v1(users[0]['token'], dm_2['dm_id'], msg) message_ids_2.append(message_id) # message_ids_3 = [] # for i in range(0, 800): # msg = str(i) # message_id = message_senddm_v1(users[0]['token'], dm_3['dm_id'], msg) # message_ids_3.append(message_id) return { 'users': users, 'dms': [dm_1, dm_2, dm_3], 'msg_ids': [message_ids_1, message_ids_2] }
def test_common_case_dm(reg_user, crt_dm): clear_v2() # new user new_user = reg_user(0) user_token = new_user['token'] new_user_2 = reg_user(1) # new channel dm_id = crt_dm(user_token, [new_user_2['auth_user_id']])['dm_id'] # new dm new_dm = crt_dm(user_token, [new_user_2['auth_user_id']]) new_dm_id = new_dm['dm_id'] # new message og_message_text = 'Hi !' og_message_id = message_senddm_v1(user_token, dm_id, og_message_text)['message_id'] shared_message_text = "Hello World !" shared_message_id = message_share_v1(user_token, og_message_id, shared_message_text, -1, new_dm_id)['shared_message_id'] messages = dm_messages_v1(user_token, new_dm_id, 0)['messages'] for msg in messages: if msg['message_id'] == shared_message_id: assert msg[ 'message'] == f'{shared_message_text}\n\n{og_message_text}'
def test_50_messages(reg_user): clear_v2() sender = reg_user(0) token_sender = sender['token'] id_sender = sender['auth_user_id'] auth_user_id_receiver = reg_user(1)['auth_user_id'] dm_id = dm_create_v1(token_sender, [auth_user_id_receiver])['dm_id'] start = 0 message_ids = [] message_count = 50 for i in range(message_count): message = f"Test{i}" message_id = message_senddm_v1(token_sender, dm_id, message)['message_id'] message_ids.append(message_id) message_dict = dm_messages_v1(token_sender, dm_id, start) messages = message_dict['messages'] messages.reverse() # Most recent message should now be last # Reverse for purpose of comparison assert len(messages) == message_count assert message_dict['start'] == start assert message_dict['end'] == -1 for i in range(message_count): message_details = messages[i] assert message_details['message_id'] == message_ids[i] assert message_details['u_id'] == id_sender assert message_details['message'] == f"Test{i}"
def test_auth_user_not_owner(test_data): a_data, b_data, c_data = test_data # channel a_ch_id = channels_create_v2(a_data["token"], "A channel", True)["channel_id"] channel_join_v2(b_data["token"], a_ch_id) channel_join_v2(c_data["token"], a_ch_id) a_msg_id = message_send_v2(a_data["token"], a_ch_id, "A message")["message_id"] with pytest.raises(AccessError): message_pin_v1(b_data["token"], a_msg_id) message_pin_v1(c_data["token"], a_msg_id) # dm a_dm_id = dm_create_v1( a_data["token"], [b_data["auth_user_id"], c_data["auth_user_id"]])["dm_id"] a_msgdm_id = message_senddm_v1(a_data["token"], a_dm_id, "A message")["message_id"] with pytest.raises(AccessError): message_pin_v1(b_data["token"], a_msgdm_id) message_pin_v1(c_data["token"], a_msgdm_id)
def test_share_pin(test_data): a_data, b_data, _ = test_data a_ch_id = channels_create_v2(a_data["token"], "A channel", True)["channel_id"] channel_join_v2(b_data["token"], a_ch_id) b_dm_id = dm_create_v1(b_data["token"], [a_data["auth_user_id"]])["dm_id"] a_msg_id = message_send_v2(a_data["token"], a_ch_id, "Message to be shared to dm")["message_id"] b_msgdm_id = message_senddm_v1( b_data["token"], b_dm_id, "Message to be shared to channel")["message_id"] a_share_id = message_share_v1(a_data["token"], a_msg_id, "Shared a msg", -1, b_dm_id)["shared_message_id"] b_share_id = message_share_v1(b_data["token"], b_msgdm_id, "Shared a msg", a_ch_id, -1)["shared_message_id"] message_pin_v1(a_data["token"], b_share_id) messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"] assert messages[0]["message_id"] == b_share_id assert messages[0]["is_pinned"] == True message_pin_v1(b_data["token"], a_share_id) messages = dm_messages_v1(b_data["token"], b_dm_id, 0)["messages"] assert messages[0]["message_id"] == a_share_id assert messages[0]["is_pinned"] == True
def message_senddm(): parameters = request.get_json() token = parameters['token'] dm_id = parameters['dm_id'] message = parameters['message'] output = message_senddm_v1(token, dm_id, message) return dumps(output)
def test_search_v2_non_case_sensitive_dm(reg_user): clear_v2() query_str = 'APPLES' #find messages that have the same text as this user_register1 = reg_user(0) auth_user_id_receiver = reg_user(1)['auth_user_id'] dm_id = dm_create_v1(user_register1['token'], [auth_user_id_receiver])['dm_id'] message = 'i love bananas, dont like apples' message_2 = 'i love bananas' for _ in range(0, 20): message_senddm_v1(user_register1['token'], dm_id, message_2) message_senddm_v1(user_register1['token'], dm_id, message) messages = search_v2(user_register1['token'], query_str)['messages'] for single_message in messages: assert single_message['message'] != message_2 assert single_message['message'] == message