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()