def test_message_remove_owner_remove_user_msg(make_users):
# setting up users and public channel
user_ab, user_cd = make_users
new_public_channel = channels_create(user_ab['token'],
'test_channel_public', True)
# user_cd joins channel
channel_join(user_cd['token'], new_public_channel['channel_id'])
# messages sent
message_send(user_ab['token'], new_public_channel['channel_id'],
"Hello world!")
message_send(user_ab['token'], new_public_channel['channel_id'],
"Welcome to my channel.")
message_send(user_ab['token'], new_public_channel['channel_id'],
"Please do not leave inappropriate messages.")
msg4 = message_send(user_cd['token'], new_public_channel['channel_id'],
"Inappropriate messages.")
# user_ab (creator of channel) removes message made by user_cd
message_remove(user_ab['token'], msg4['message_id'])
msgs_view = channel_messages(user_ab['token'],
new_public_channel['channel_id'],
0)['messages']
msg_id_list = [msg['message_id'] for msg in msgs_view]
assert len(msg_id_list) == 4
assert msg4['message_id'] not in msg_id_list
def test_remove_valid_owner(users):
"""
Testing if a single message can be sent, be stored and removed by owner
"""
user1, user2, chan = users
message_exp2 = "Test this is different from message_exp"
message.message_send(user1["token"], chan['channel_id'], message_exp2)
message_exp = "Test 1 test 2 swiggity Swagg"
message_id = message.message_send(user2["token"], chan['channel_id'],
message_exp)
message_from_channel = channel.channel_messages(user1["token"],
chan['channel_id'], 0)
#Checks that the message was added
assert message_exp == message_from_channel["messages"][0]["message"]
assert user2["u_id"] == message_from_channel["messages"][0]["u_id"]
assert message_id["message_id"] == message_from_channel["messages"][0][
"message_id"]
message.message_remove(user1["token"], message_id["message_id"])
new_message_from_channel = channel.channel_messages(
user1["token"], chan['channel_id'], 0)
#Checks that the message was removed
assert message_exp != new_message_from_channel["messages"][0]["message"]
assert user2["u_id"] != new_message_from_channel["messages"][0]["u_id"]
assert message_id["message_id"] != new_message_from_channel["messages"][0][
"message_id"]
other.clear()
def test_remove_multiple_messages_valid(users):
"""
Testing if a message can be removed then a new message added then the new message removed
"""
user1, user2, chan = users
message_exp = "Test 1 test 2 swiggity Swagg"
message_id1 = message.message_send(user2["token"], chan['channel_id'],
message_exp)
#Pre-removes the message
message.message_remove(user1["token"], message_id1["message_id"])
message_exp10 = "Spagetti and memeballs"
message_id2 = message.message_send(user2["token"], chan['channel_id'],
message_exp10)
message_exp2 = "Test this is different from message_exp"
message.message_send(user1["token"], chan['channel_id'], message_exp2)
message.message_remove(user2["token"], message_id2["message_id"])
new_message_from_channel = channel.channel_messages(
user1["token"], chan['channel_id'], 0)
assert message_exp != new_message_from_channel["messages"][0]["message"]
assert user2["u_id"] != new_message_from_channel["messages"][0]["u_id"]
assert message_id2["message_id"] != new_message_from_channel["messages"][
0]["message_id"]
other.clear()
def test_channel_removeowner_good(reset, create_public_channel, create_user1):
'''
Assuming addowner works fine, we test removing a message after ownership is removed
'''
# creating a public channel
channel_id, owner_info = create_public_channel
# creating normal users
user_info = create_user1
# sending a message that we will test deleting afterwards
msg_id = message_send(owner_info['token'], channel_id['channel_id'],
"First owner's Message 1!")
msg_id2 = message_send(owner_info['token'], channel_id['channel_id'],
"First owner's Message 2!")
# adding general user as an owner to the channel
channel_addowner(owner_info['token'], channel_id['channel_id'],
user_info['u_id'])
# trying to remove a message to check if addowner works
message_remove(user_info['token'], msg_id2['message_id'])
messages = channel_messages(owner_info['token'], channel_id['channel_id'],
0)
assert len(messages['messages']) == 2
# removing user from being an owner
channel_removeowner(owner_info['token'], channel_id['channel_id'],
user_info['u_id'])
# trying to remove a message as a user, it should produce AccessError
with pytest.raises(AccessError):
message_remove(user_info['token'], msg_id['message_id'])
def test_message_edit():
database.reset()
#send a message
result = get_user("user1")
u_id = result['u_id']
token = result['token']
temp = channels.channels_create(token, "channel1", True)
channel_id = temp['channel_id']
msg = message.message_send(token, channel_id, "hello")
message_id = msg['message_id']
#edit the message
return_val = message.message_edit(token, message_id, "hi")
assert return_val == {}
#edit the message to an empty string so the message is deleted
message.message_edit(token, message_id, "")
#try to delete the message which is deleted
with pytest.raises(InputError) as e:
message.message_remove(token, message_id)
#have a new user join the channel and send a message
result = get_user("user2")
u_id2 = result['u_id']
token2 = result['token']
channel.channel_join(token2, channel_id)
msg2 = message.message_send(token2, channel_id, "hello")
#admin edit the new message
temp2 = message.message_edit(token, msg2['message_id'], "hi")
assert temp2 == {}
#new user edit him message
temp3 = message.message_edit(token2, msg2['message_id'], "hillo")
assert temp3 == {}
def remove():
""" This is a flask wrapper for the message_remove function
Parameters:
No parameters
Returns:
(dictionary): Empty dictionary
"""
data = request.get_json()
token = data['token']
message_id = int(data['message_id'])
message_probe = message_check(message_id)
user = token_check(token)
if message_probe is None:
raise InputError(description="Message not found")
if not check_if_user_in_channel_owner(token, message['channel_id']):
raise AccessError(description="User not owner")
if user['u_id'] != message_probe['user_id']:
raise AccessError(description="User not sender")
message_remove(token, message_id)
return dumps(message_id)
def test_message_remove_already_removed():
reset_data()
owner = auth.auth_register("*****@*****.**", "123456", "Sinha", "Nawa")
channels.channels_create(owner['token'], "Test_channel", True)
message.message_send(owner['token'], 1, "test")
message.message_remove(owner['token'], 1)
with pytest.raises(InputError):
message.message_remove(owner['token'], 1)
def remove():
data = request.get_json()
token = data['token']
message_id = int(data['message_id'])
message_remove(token, message_id)
return dumps(message_id)
def test_non_existing_user_in_message_remove():
"""Tests passing in an invalid user"""
clear()
new_user_1 = auth_register("*****@*****.**", "peter912", "Peter", "Wallace")
new_channel = channels_create(new_user_1["token"], "UNSW Cool Channel", True)
new_msg = message_send(new_user_1["token"], new_channel["channel_id"], "UNSW is fun")
with pytest.raises(AccessError):
message_remove("13211", new_msg["message_id"])
def test_unreact_msg_removed():
"""
Test whether unreact on a message is deleted will raise InputError.
"""
data = helper_create_react()
message_remove(data['token'], data['message_id'])
with pytest.raises(InputError):
message_unreact(data['token'], data['message_id'], 1)
def test_message_remove_not_authorised_user():
_, wenyao_dict, weiqiang_dict, channel_team1, _ = initialise_data()
message_id = message_send(wenyao_dict['token'],
channel_team1['channel_id'], "hello")
channel_invite(wenyao_dict['token'],
channel_team1['channel_id'], weiqiang_dict['u_id'])
with pytest.raises(AccessError):
message_remove(weiqiang_dict['token'], message_id['message_id'])
def test_message_remove_invalid_token():
"""Test passing an invalid token to message_remove"""
clear()
valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me")
new_channel = channels_create(valid_user["token"], "test_message_long", False)
new_msg = message_send(valid_user["token"], new_channel["channel_id"], "HECK YEAH")
with pytest.raises(AccessError):
message_remove(2170, new_msg["message_id"])
def test_invalid_message_id():
"""Testing for an InputError when an invalid message id is passed to message_send()"""
clear()
pleb_user = auth_register("*****@*****.**", "plebssword", "Plebbleton", "Pleb")
new_channel = channels_create(pleb_user["token"], "new_channel_bruh", False)
message_send(pleb_user["token"], new_channel["channel_id"], "th1s a val3d m3sg br0")
with pytest.raises(InputError):
message_remove(pleb_user["token"], 9001)
def test_message_remove_invald_user():
"""Tests message removed for a invalid user, should fail."""
clear()
new_user_1 = auth_register("*****@*****.**", "RobinCoolio19291", "Robin", "Fraser")
new_channel = channels_create(new_user_1["token"], "UNSW Clubhouse", False)
new_msg = message_send(new_user_1["token"], new_channel["channel_id"], "Borat 2 is funny")
with pytest.raises(AccessError):
message_remove("12346", new_msg["message_id"])
def message_remove():
"""
Function message remove route
"""
message_info = request.get_json()
message.message_remove(message_info['token'],
int(message_info['message_id']))
return dumps({})
def test_unpin_msg_removed():
"""
Test whether unpin invalid message_id will raise InputError.
"""
data = create_pinned_message()
message_remove(data['token'], data['message_id'])
with pytest.raises(InputError):
message_pin(data['token'], data['message_id'])
def test_message_remove_404():
"""
Test remove sends an InputError if msg_id is invalid.
"""
user_info = auth_register("*****@*****.**", "ccc337992611", "Min",
"Li")
with pytest.raises(InputError):
message_remove(user_info['token'], 0)
def test_message_remove_unauth_user():
"""Tests message removed for a unauthorised user, should fail."""
clear()
new_user_1 = auth_register("*****@*****.**", "peter912", "Peter", "Wallace")
new_channel = channels_create(new_user_1["token"], "UNSW Cool Channel", True)
new_msg = message_send(new_user_1["token"], new_channel["channel_id"], "UNSW is fun")
new_user_2 = auth_register("*****@*****.**", "hacking1281", "Hacker", "Man")
with pytest.raises(AccessError):
message_remove(new_user_2["token"], new_msg["message_id"])
def test_remove_message_non_existing():
'''
Testing for a message that has already been removed.
'''
clear()
user_1 = auth_register("*****@*****.**", "password", "First_1", "Last_1")
with pytest.raises(InputError):
message_remove(user_1.get('token'), 'message_id')
def test_message_unauthorized_remove_request():
"""Testing for an AccessError when a non-creater or non_owner attempts to remove a message"""
clear()
valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me")
step_user = auth_register("*****@*****.**", "stepPassword", "Step", "User")
new_channel = channels_create(valid_user["token"], "49 WAM CLUB", False)
message_send(valid_user["token"], new_channel["channel_id"], "my WAM make me cri")
with pytest.raises(AccessError):
message_remove(step_user["token"], 1)
def test_message_remove_flockr_owner():
boyu_dict, wenyao_dict, _, channel_team1, _ = initialise_data()
channel_invite(wenyao_dict['token'], channel_team1['channel_id'], boyu_dict['u_id'])
message_id = message_send(wenyao_dict['token'], channel_team1['channel_id'], "hello")
message_remove(boyu_dict['token'], message_id['message_id'])
messages_detail = channel_messages(wenyao_dict['token'], channel_team1['channel_id'], 0)
# check the return value
assert messages_detail['start'] == 0
assert messages_detail['end'] == -1
assert len(messages_detail['messages']) == 0
def test_message_remove_error():
'''
Test error for trying to remove message with message_id that does not exist
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "Homer",
"Simpson")
channels.channels_create(owner['token'], "channel_1", True)
with pytest.raises(error.InputError):
message.message_remove(owner['token'], 1)
def test_remove_message_non_existent():
clear()
user = register_n_users(1)
channel = channels_create(user["token"], "channel", is_public=True)
message = message_send(user["token"], channel["channel_id"],
"test message")
message_remove(user["token"], message["message_id"])
with pytest.raises(InputError):
message_remove(user["token"], message["message_id"])
def test_message_remove_invalid_id(make_users):
# setting up users and public channel
user_ab, user_cd = make_users
new_public_channel = channels_create(user_ab['token'],
'test_channel_public', True)
msg1 = message_send(user_ab['token'], new_public_channel['channel_id'],
"Hello world!")
with pytest.raises(InputError):
message_remove(user_ab['token'], msg1['message_id'] + 1)
def test_message_remove_neither_owner_nor_sender():
reset_data()
owner = auth.auth_register("*****@*****.**", "123456", "Sinha", "Nawa")
member = auth.auth_register("*****@*****.**", "1234567", "Sinha1",
"Nawa1")
channels.channels_create(owner['token'], "Test_channel", True)
message.message_send(owner['token'], 1, "test")
channel.channel_invite(owner['token'], 1, member['u_id'])
channel.channel_removeowner(owner['token'], 1, 1)
with pytest.raises(AccessError):
message.message_remove(member['token'], 1)
def delete():
'''
a route which calls message_delete from message
'''
data = request.get_json()
if not data['token'] or not data['message_id']:
raise RequestError(description="Missing data in request body")
message.message_remove(data['token'], int(data['message_id']))
return dumps({})
def test_message_remove_authorised_user():
_, wenyao_dict, _, channel_team1, _ = initialise_data()
message_id1 = message_send(wenyao_dict['token'], channel_team1['channel_id'], "hello")
message_id2 = message_send(wenyao_dict['token'], channel_team1['channel_id'], "how are you")
message_remove(wenyao_dict['token'], message_id2['message_id'])
messages_detail = channel_messages(wenyao_dict['token'], channel_team1['channel_id'], 0)
assert messages_detail['start'] == 0
assert messages_detail['end'] == -1
assert len(messages_detail['messages']) == 1
assert messages_detail['messages'][0]['message_id'] == message_id1['message_id']
assert messages_detail['messages'][0]['u_id'] == wenyao_dict['u_id']
assert messages_detail['messages'][0]['message'] == "hello"
def test_search_valid_substring():
'''
Testing valid substring search functionality for search
'''
clear()
f_owner = auth_register('*****@*****.**', 'password', 'Bob', 'Bob')
f_channel = channels_create(f_owner['token'], 'Channel 1', True)
random_user = auth_register('*****@*****.**', 'password', 'Random',
'User')
channel_invite(f_owner['token'], f_channel['channel_id'],
random_user['u_id'])
msg = message_send(f_owner['token'], f_channel['channel_id'],
'First message')
message_react(f_owner['token'], msg['message_id'], 1)
# Test exact match
messages = search(f_owner['token'], 'First message')['messages']
assert len(messages) == 1
assert messages[0]['message_id'] == msg['message_id']
assert messages[0]['u_id'] == f_owner['u_id']
# Test substring
messages = search(f_owner['token'], 'First')['messages']
assert len(messages) == 1
assert messages[0]['message_id'] == msg['message_id']
assert messages[0]['u_id'] == f_owner['u_id']
# Edited message
message_edit(f_owner['token'], msg['message_id'], 'Test message')
messages = search(f_owner['token'], 'First')['messages']
assert len(messages) == 0
# Removed message
message_remove(f_owner['token'], msg['message_id'])
messages = search(f_owner['token'], 'First message')['messages']
assert len(messages) == 0
# Test substring
for multiple in range(1, 51):
# f_owner and random_user sent
message_send(f_owner['token'], f_channel['channel_id'], 'A' * multiple)
message_send(random_user['token'], f_channel['channel_id'],
'A' * multiple)
# f_owner searched
messages = search(f_owner['token'], 'A')['messages']
assert len(messages) == multiple * 2
# random_user searched
messages = search(random_user['token'], 'A')['messages']
assert len(messages) == multiple * 2
# Caps-sensitive
messages = search(f_owner['token'], 'a')['messages']
assert len(messages) == 0
def test_message_remove():
"""
Make sure message_remove will work if all inputs are right and authorised.
"""
user_info = auth_register("*****@*****.**", "ccc337992611", "Min",
"Li")
channel_info = channels_create(user_info['token'], 'test_channel', True)
msg_info = message_send_helper(user_info['token'],
channel_info['channel_id'], "Test message!")
message_remove(user_info['token'], msg_info['msg_dict']['message_id'])
assert search(user_info['token'], "Test message!") == {"messages": []}
def test_message_remove_invalid_message_id():
'''
Test error for tryng to remove a message with invalid message id
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "Homer",
"Simpson")
channel_1 = channels.channels_create(owner['token'], "channel_1", True)
message.message_send(owner['token'], channel_1['channel_id'],
'test message 1')
with pytest.raises(error.InputError):
message.message_remove(owner['token'], 2)
for i in file:
zip_file.write(i)
zip_file.close()
message.message_good()
else:
message.message_bad()
else:
message.message_bad()
# перемещение архива с файлами и проверка на существование архива с таким же именем.
fileZip = 'ARH-'+message.now_date_str+'.zip'
os.chdir(destpath)
fileDest = glob.glob(fileZip)
if (len(fileDest) != 0):
os.remove(fileZip)
os.chdir(emailpath)
shutil.move(fileZip , destpath)
message.message_move()
else:
os.chdir(emailpath)
shutil.move(fileZip , destpath)
message.message_move()
# удаление заархивированных и перенесенных файлов
os.chdir(emailpath)
file_del = glob.glob("*.*")
for y in file_del:
os.remove(y)
message.message_remove()
