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(test_data):
a_data, b_data, c_data, a_ch_id = test_data
channel_join_v2(b_data["token"], a_ch_id)
channel_join_v2(c_data["token"], a_ch_id)
# Create the unscramble user
message_send_v2(a_data["token"], a_ch_id, "/u start")
us_id = None
for user in users_all_v1(a_data["token"])["users"]:
if user["name_first"] == "Sinister" and user[
"name_last"] == "Scrambler":
us_id = user["u_id"]
a_dm_id = dm_create_v1(
a_data["token"],
[b_data["auth_user_id"], c_data["auth_user_id"]])["dm_id"]
dm_invite_v1(a_data["token"], a_dm_id, us_id)
message_senddm_v1(a_data["token"], a_dm_id, "/u start")
# latest message should be the one above.
# scrambler shouldnt send any messages
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u start"
message_senddm_v1(a_data["token"], a_dm_id, "/u leaderboard")
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u leaderboard"
message_senddm_v1(a_data["token"], a_dm_id, "/u simple")
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u simple"
def test_invalid_dm_id():
clear_v1()
auth_user_1_data = auth_register_v2("*****@*****.**", "123456", "Andy", "Dandy")
auth_user_1_token = auth_user_1_data["token"]
with pytest.raises(InputError):
dm_messages_v1(auth_user_1_token, 99999, 0)
def test_dm_messages_v1_auth_user_is_not_a_member_of_dm(reg_user):
clear_v2()
token_sender = reg_user(0)['token']
auth_user_id_receiver = reg_user(1)['auth_user_id']
token_non_auth_user = reg_user(2)['token']
dm_id = dm_create_v1(token_sender, [auth_user_id_receiver])['dm_id']
start = 1
with pytest.raises(AccessError):
dm_messages_v1(token_non_auth_user, dm_id, start) #since this user was never appart of the dm send messages
def test_dm_messages_v1_dm_id_is_not_a_valid_dm(reg_user):
clear_v2()
token_sender = reg_user(0)['token']
auth_user_id_receiver = reg_user(1)['auth_user_id']
dm_create_v1(token_sender, [auth_user_id_receiver])
fake_dm_id = 'garbage values'
start = 2
with pytest.raises(InputError):
dm_messages_v1(token_sender, fake_dm_id, start)
def test_dm_messages_v1_token(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']
fake_token = 'garbage values'
start = 2
with pytest.raises(AccessError):
dm_messages_v1(fake_token, dm_id, start)
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_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_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_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_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_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_messages_v1_more_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_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"]
latest_msg = None
for num in range(99):
latest_msg = message_senddm_v1(auth_user_1_token, dm_id_1, "Test")
dm_messages_data = dm_messages_v1(auth_user_1_token, dm_id_1, 0)
for num in range(50):
assert dm_messages_data["messages"][num]["u_id"] == auth_user_1_id
assert dm_messages_data["messages"][num]["message"] == "Test"
assert dm_messages_data["messages"][0]["message_id"] == latest_msg["message_id"]
assert len(dm_messages_data["messages"]) == 50
assert dm_messages_data["start"] == 0
assert dm_messages_data["end"] == 50
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 dm_messages():
token = request.args.get('token')
dm_id = request.args.get('dm_id')
start = request.args.get('start')
dm_messages = dm_messages_v1(token, dm_id, start)
return dumps(dm_messages)
def dm_messages():
parameters = request.args
token = parameters['token']
dm_id = int(parameters['dm_id'])
start = int(parameters['start'])
output = dm_messages_v1(token, dm_id, start)
return dumps(output)
def test_invalid_start():
clear_v1()
auth_user_1_data = auth_register_v2("*****@*****.**", "123456", "Andy", "Dandy")
auth_user_1_token = auth_user_1_data["token"]
auth_user_2_data = auth_register_v2("*****@*****.**", "123456", "Bob", "Hobs")
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"]
with pytest.raises(InputError):
dm_messages_v1(auth_user_1_token, dm_id_1, 99999)
def test_remove_multiple_dm_messages(reg_user, crt_dm, send_dm_message):
clear_v2()
user_1_token = reg_user(0)['token']
user_2_id = reg_user(1)['auth_user_id']
dm_id = crt_dm(user_1_token, [user_2_id])['dm_id']
message_ids = []
for i in range(0, 10):
message_id = send_dm_message(user_1_token, dm_id)['message_id']
message_ids.append(message_id)
for i in range(0, len(message_ids) - 1):
message_remove_v1(user_1_token, message_ids[i])
messages = dm_messages_v1(user_1_token, dm_id, 0)['messages']
for msg in messages:
assert message_ids[i] != msg['message_id']
message_remove_v1(user_1_token, message_ids[-1])
messages = dm_messages_v1(user_1_token, dm_id, 0)['messages']
assert not len(messages)
def test_remove_single_dm_message(reg_user, crt_dm, send_dm_message):
clear_v2()
user_1_token = reg_user(0)['token']
user_2_id = reg_user(1)['auth_user_id']
dm_id = crt_dm(user_1_token, [user_2_id])['dm_id']
message_id = send_dm_message(user_1_token, dm_id)['message_id']
message_remove_v1(user_1_token, message_id)
messages = dm_messages_v1(user_1_token, dm_id, 0)['messages']
assert not len(messages)
def test_dm_message_senddm_v1_message_exactly_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'*1000
message_id = message_senddm_v1(token_sender, dm_id, yuge_string)['message_id']
message = dm_messages_v1(token_sender, dm_id, 0)['messages'][0]
assert message['message_id'] == message_id
assert message['message'] == yuge_string
def test_message_unpin_dm_basic(reg_user, basic_message):
clear_v2()
token_1 = reg_user(0)['token']
auth_user_id_receiver = reg_user(1)['auth_user_id']
dm_id = dm_create_v1(token_1, [auth_user_id_receiver])['dm_id']
message = basic_message
message_id = message_senddm_v1(token_1, dm_id, message)['message_id']
message_pin_v1(token_1, message_id)
start = 0
messages = dm_messages_v1(token_1, dm_id, start)['messages']
assert messages[0]['message_id'] == message_id
assert messages[0]['is_pinned'] == True
message_unpin_v1(token_1, message_id)
messages = dm_messages_v1(token_1, dm_id, start)['messages']
assert messages[0]['message_id'] == message_id
assert messages[0]['is_pinned'] == False
def test_dm_pin(test_data):
a_data, b_data, c_data = test_data
a_dm_id = dm_create_v1(a_data["token"], [c_data["auth_user_id"]])["dm_id"]
b_dm_id = dm_create_v1(b_data["token"], [c_data["auth_user_id"]])["dm_id"]
# pin own message
a1_msg_id = message_senddm_v1(a_data["token"], a_dm_id,
"My own message")["message_id"]
message_pin_v1(a_data["token"], a1_msg_id)
messages = dm_messages_v1(a_data["token"], a_dm_id, 0)["messages"]
assert messages[0]["message_id"] == a1_msg_id
assert messages[0]["is_pinned"] == True
# pin someone elses message
c1_msg_id = message_senddm_v1(c_data["token"], a_dm_id,
"C's message")["message_id"]
message_pin_v1(a_data["token"], c1_msg_id)
messages = dm_messages_v1(a_data["token"], a_dm_id, 0)["messages"]
assert messages[0]["message_id"] == c1_msg_id
assert messages[0]["is_pinned"] == True
# b_ch
b1_msg_id = message_senddm_v1(b_data["token"], b_dm_id,
"B's message whoo")["message_id"]
message_pin_v1(b_data["token"], b1_msg_id)
messages = dm_messages_v1(b_data["token"], b_dm_id, 0)["messages"]
assert messages[0]["message_id"] == b1_msg_id
assert messages[0]["is_pinned"] == True
c2_msg_id = message_senddm_v1(c_data["token"], b_dm_id,
"C's second message whoo")["message_id"]
message_pin_v1(b_data["token"], c2_msg_id)
messages = dm_messages_v1(c_data["token"], b_dm_id, 0)["messages"]
assert messages[0]["message_id"] == c2_msg_id
assert messages[0]["is_pinned"] == True
def test_dm_messages_v1_success(user_setup, dm_setup):
message_senddm_v1(make_token(1), 0, "onions can be eaten raw")
dateTimeObj = datetime.now()
timeStampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M)")
assert dm_messages_v1(make_token(1), 0, 0) == {
"messages": [
{
"message_id":
0,
"u_id":
1,
"message":
"onions can be eaten raw",
"time_created":
timeStampStr,
"channel_id":
-1,
"dm_id":
0,
'reacts': [{
'react_id': 1,
'u_ids': [],
'is_this_user_reacted': False
}],
'is_pinned':
False
},
],
"start":
0,
"end":
-1,
}
assert dm_messages_v1(make_token(1), 1, 0) == {
"messages": [],
"start": 0,
"end": -1,
}
def test_message_senddm_valid_case():
# Valid case, check if data matches
clear_v1()
DM_owner = auth_register_v2('*****@*****.**', 'password123', 'Ricky', 'Clean')
user_receiver = auth_register_v2('*****@*****.**', 'password123', 'Dean', 'Paul')
DM = dm_create_v1(DM_owner['token'], [user_receiver['auth_user_id']])
msg_sent = message_senddm_v1(DM_owner['token'], DM['dm_id'], 'Hey!')
# Get message through dm_messages
msg_list = dm_messages_v1(user_receiver['token'], DM['dm_id'], 0)
assert len(msg_list['messages']) == 1
assert msg_list['messages'][0]['message_id'] == msg_sent['message_id']
assert msg_list['messages'][0]['u_id'] == DM_owner['auth_user_id']
assert msg_list['messages'][0]['message'] == 'Hey!'
def test_non_member():
clear_v1()
auth_user_1_data = auth_register_v2("*****@*****.**", "123456", "Andy", "Dandy")
auth_user_1_token = auth_user_1_data["token"]
auth_user_2_data = auth_register_v2("*****@*****.**", "123456", "Bob", "Hobs")
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_senddm_v1(auth_user_1_token, dm_id_1, "Hello")
auth_user_4_data = auth_register_v2("*****@*****.**", "123456", "Joshua", "King")
auth_user_4_token = auth_user_4_data["token"]
with pytest.raises(AccessError):
dm_messages_v1(auth_user_4_token, dm_id_1, 0)
def test_dm_messages_v1_messages_different_message(reg_user):
clear_v2()
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']
messages_ids = []
for i in range(0, 20):
message_id = message_senddm_v1(user_register1['token'], dm_id, str(i))['message_id'] #send 20 messages
messages_ids.append(message_id)
messages = dm_messages_v1(user_register1['token'], dm_id, 0)['messages'] #messages is a list of dictionaries with message_id, u_id "who sent it", and the message contained inside
messages.reverse() # Most recent message should now be last
# Reverse for purpose of comparison
for i in range(0, 20):
assert messages_ids[i] == messages[i]['message_id']
def test_dm_messages_v1_basics(reg_user,basic_message):
clear_v2()
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_id_list = []
message = basic_message
for _ in range(0, 20):
message_id = message_senddm_v1(user_register1['token'], dm_id, basic_message)['message_id'] #send 20 messages
message_id_list.append(message_id)
messages = dm_messages_v1(user_register1['token'], dm_id, 0)['messages'] #messages is a list of dictionaries with message_id, u_id "who sent it", and the message contained inside
messages.reverse() # Most recent message should now be last
# Reverse for purpose of comparison
for single_message in messages: #inside each of our messages check if the values are correct
assert single_message['message_id'] in message_id_list
assert single_message['u_id'] == user_register1['auth_user_id'] #sent user is always the same for this test
assert single_message['message'] == message # the message is always the same for this test
def test_dm_messages_v1_errors(user_setup, dm_setup):
'''
test the errors for channel_messages_v2
'''
# invalid dm_id
with pytest.raises(InputError):
dm_messages_v1(make_token(1), 10, 0)
# start is greater than the total number of dms
with pytest.raises(InputError):
dm_messages_v1(make_token(1), 1, 100)
# authorised user is not a member of the dm
with pytest.raises(AccessError):
dm_messages_v1(make_token(2), 1, 0)
# invalid authorised user
with pytest.raises(AccessError):
dm_messages_v1(make_token(10), 1, 0)
def test_single_message(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 = "Test"
message_id = message_senddm_v1(token_sender, dm_id, message)['message_id']
messages = dm_messages_v1(token_sender, dm_id, start)
assert len(messages['messages']) == 1 # Should only be one message
assert messages['start'] == start
assert messages['end'] == -1
message_details = messages['messages'][0]
assert message_details['message_id'] == message_id
assert message_details['u_id'] == id_sender
assert message_details['message'] == message
def test_message_edit_simple_case_dm():
# Test a normal case for DM
clear_v1()
user = auth_register_v2('*****@*****.**', 'password542', 'Tommy', 'Son')
user_2 = auth_register_v2('*****@*****.**', 'password5342', 'Josh',
'Dann')
dm_group = dm_create_v1(user['token'], [user_2['auth_user_id']])
message_senddm_v1(user["token"], dm_group['dm_id'],
'message to dilute the history')
msg_sent = message_senddm_v1(user['token'], dm_group['dm_id'], 'hey!')
message_edit_v2(user['token'], msg_sent['message_id'], 'sike bye!')
dm_msg_list = dm_messages_v1(user['token'], dm_group['dm_id'], 0)
# message = {
# 'message_id' = 1
# 'u_id' = 1
# 'message' = 'sike bye!'
# }
assert dm_msg_list['messages'][0]['message_id'] == msg_sent['message_id']
assert dm_msg_list['messages'][0]['u_id'] == user['auth_user_id']
assert dm_msg_list['messages'][0]['message'] == 'sike bye!'
