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
