def unreact_message():
data = request.get_json()
token = str(data["token"])
message_id = int(data["message_id"])
react_id = int(data["react_id"])
message_unreact(token, message_id, react_id)
return dumps({})
def test_message_unreact_no_active_react():
'''Test if function raises an input error when the message is not reacted'''
clear()
# Register user 0
user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang",
"W")
# Register user 1
user1_info = auth_register("*****@*****.**", "VukkFs", "Bill",
"Gates")
# User 0 create a channel
channel0_info = channels_create(user0_info['token'], "channel0", True)
# User 1 join the channel
channel_join(user1_info['token'], channel0_info['channel_id'])
# User 0 send a message
message0_info = message_send(user0_info['token'],
channel0_info['channel_id'], "Hello")
# Message not reacted yet
with pytest.raises(InputError):
assert message_unreact(user1_info['token'],
message0_info['message_id'], 1)
# User 1 reacts to the message
message_react(user1_info['token'], message0_info['message_id'], 1)
message_unreact(user1_info['token'], message0_info['message_id'], 1)
# Message already unreacted by user 1
with pytest.raises(InputError):
assert message_unreact(user1_info['token'],
message0_info['message_id'], 1)
def test_unreact_valid():
"""
Test for valided input
"""
data = helper_create_react()
message_unreact(data['token'], data['message_id'], 1)
assert data['message_file']['messages'][0]['reacts'][0]['u_ids'] == []
def test_message_unreact_react_and_unreact_again():
_, wenyao_dict, _, channel_team1, _ = initialise_data()
message_id1 = message_send(wenyao_dict['token'], channel_team1['channel_id'], "hello")
message_react(wenyao_dict['token'], message_id1['message_id'], 1)
message_unreact(wenyao_dict['token'], message_id1['message_id'], 1)
with pytest.raises(InputError):
message_unreact(wenyao_dict['token'], message_id1['message_id'], 1)
def test_unreact_invalid_react_id():
"""
Test whether invailed react id will raise InputError
"""
data = helper_create_react()
with pytest.raises(InputError):
message_unreact(data['token'], data['message_id'], -1)
def test_message_unreact_invalid_token():
_, wenyao_dict, _, channel_team1, _ = initialise_data()
message_id1 = message_send(wenyao_dict['token'],
channel_team1['channel_id'], "hello")
message_react(wenyao_dict['token'], message_id1['message_id'], 1)
with pytest.raises(AccessError):
message_unreact("invalid token", message_id1['message_id'], 1)
def unreact():
""" This is a flask wrapper for the message_unreact function
Parameters:
No parameters
Returns:
(dictionary): Empty dictionary.
"""
data = request.get_json()
token = data['token']
react_id = int(data['react_id'])
message_id = int(data['message_id'])
if react_id != 1:
raise InputError(description="Invalid react id")
if not token_check(token):
raise AccessError(description="Invalid user")
user = token_check(token)
if not react_check(message_id, user['u_id'], react_id):
raise InputError(description="Already reacted")
message_unreact(token, message_id, 1)
return dumps({})
def test_message_unreact_non_existent_msg(make_users):
# setting up user
user_ab, user_cd = make_users
# no messages yet. Cannot unreact anything
with pytest.raises(InputError):
message_unreact(user_ab['token'], 0, 1)
def test_message_unreact_already_unreacted():
'''
Test:
- Unreact on a message that contains no reacts at all
Scenario:
- The owner creates an account and channel
- The user creats an account and gets invited to the channel
- The owner sends a message
- No one has reacted to the message at all
- Test that the user tries to unreact with valid tokens, message id and react id
'''
clear()
owner = auth_register('*****@*****.**', 'password', 'Einstein', 'Einsteinson')
channel = channels_create(owner['token'], 'UNSW HUB', True)
user = auth_register('*****@*****.**', 'password', 'Zeke', 'Zekeson')
channel_invite(owner['token'], channel['channel_id'], user['u_id'])
msg = 'this message has no reaction'
# There is an existing message
m_id1 = message_send(owner['token'], channel['channel_id'], msg)['message_id']
# Unreact to message that has no reacts
with pytest.raises(InputError):
message_unreact(user['token'], m_id1, 1)
def test_unreact_twice():
"""
Test whether message unreact twic will raise InputError
"""
data = helper_create_react()
message_unreact(data["token"], data["message_id"], 1)
with pytest.raises(InputError):
message_unreact(data["token"], data["message_id"], 1)
def test_react_unreact_invalid_token(initial_msgs, initial_data):
'''
given token does not refer to a valid user
'''
with pytest.raises(AccessError):
message_react('invalid_token', 10002, 1)
with pytest.raises(AccessError):
message_unreact('invalid_token', 10002, 1)
def test_message_unreact_invalid_message_id2():
_, wenyao_dict, weiqiang_dict, channel_team1, channel_team2 = initialise_data()
message1 = message_send(wenyao_dict['token'], channel_team1['channel_id'], "hello")
message2 = message_send(weiqiang_dict['token'], channel_team2['channel_id'], "hello")
message_react(wenyao_dict['token'], message1['message_id'], 1)
message_react(weiqiang_dict['token'], message2['message_id'], 1)
with pytest.raises(InputError):
message_unreact(wenyao_dict['token'], message2['message_id'], 1)
def test_unreact_invalid_react_id():
"""Tests passing and invalid react id into message_unreact"""
clear()
valid_user = auth_register("*****@*****.**", "michaelpennnis2131", "Borat", "Me")
new_channel = channels_create(valid_user["token"], "Non Cool Kids Club", False)
new_msg = message_send(valid_user["token"], new_channel["channel_id"], "VERY NICE")
with pytest.raises(InputError):
message_unreact("invalid token", new_msg["message_id"], 3)
def test_unreact_contains_no_reacts():
"""Tests trying to unreact to a message with no reacts"""
clear()
valid_user = auth_register("*****@*****.**", "michaelpennnis2131", "Borat", "Me")
new_channel = channels_create(valid_user["token"], "Non Cool Kids Club", False)
new_msg = message_send(valid_user["token"], new_channel["channel_id"], "VERY NICE")
with pytest.raises(InputError):
message_unreact(valid_user["token"], new_msg["message_id"], 1)
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_unreact_invalid_token():
"""Test passing an invalid token to message_unreact"""
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_unreact(2770, new_msg["message_id"], 0)
def message_unreact():
"""
Function message unreact route
"""
message_info = request.get_json()
message.message_unreact(message_info['token'],
int(message_info['message_id']),
int(message_info['react_id']))
return dumps({})
def test_invalid_unreact_id():
reset_data()
owner = auth.auth_register("*****@*****.**", "hellocse1", "Sinha",
"Nawa")
channels.channels_create(owner['token'], "New Channel", True)
message.message_send(owner['token'], 1, "test")
message.message_react(owner['token'], 1, 1)
with pytest.raises(InputError):
message.message_unreact(owner['token'], 1, 2)
def unreact():
data = request.get_json()
token = data['token']
react_id = int(data['react_id'])
message_id = int(data['message_id'])
message_unreact(token, message_id, 1)
return dumps(message_id)
def test_unreact_bad_msg_id():
"""
Test whether invalid message id will raise InputError
"""
user_info = auth_register("*****@*****.**", "ccc337992611", "Min",
"Li")
with pytest.raises(InputError):
message_unreact(user_info['token'], -1, 1)
def test_unreact_invalid_message_id():
"""
Test user trying to unreact to a invalid message id
"""
clear()
user_a = register_n_users(1)
invalid_message_id = -1
with pytest.raises(InputError):
message_unreact(user_a["token"], invalid_message_id, 1)
def test_react_unreact_invalid_reactid(initial_data, initial_msgs):
'''
input error
user1 reacts and unreacts to the msg 10001 with wrong react_id
'''
with pytest.raises(InputError):
message_react(users[0]['token'], 10001, 0)
with pytest.raises(InputError):
message_unreact(users[0]['token'], 10001, 0)
def test_not_in_channel1():
reset_data()
owner = auth.auth_register("*****@*****.**", "hellocse1", "Sinha",
"Nawa")
member = auth.auth_register("*****@*****.**", "hellocse", "jiaqi",
"zhu")
channels.channels_create(owner['token'], "New Channel", True)
message.message_send(owner['token'], 1, "test")
with pytest.raises(InputError):
message.message_unreact(member['token'], 1, 1)
def test_message_unreact_invalid_react(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'],
"Some message")
with pytest.raises(InputError):
message_unreact(user_ab['token'], msg1['message_id'], 22222)
def test_unreact_user_has_not_previously_reacted():
"""Tests a user trying to unreact a message that havent reacted to before"""
clear()
valid_user1 = auth_register("*****@*****.**", "michaelpennnis2131", "Borat", "Me")
valid_user2 = auth_register("*****@*****.**", "michaelpennnis2131", "Borat", "Me")
new_channel = channels_create(valid_user1["token"], "Non Cool Kids Club", False)
new_msg = message_send(valid_user1["token"], new_channel["channel_id"], "VERY NICE")
message_react(valid_user1["token"], new_msg["message_id"], 1)
with pytest.raises(InputError):
message_unreact(valid_user2["token"], new_msg["message_id"], 1)
def message_unreact():
'''
Route that unreacts to the specified message
'''
payload = request.get_json()
token = payload['token']
message_id = payload['message_id']
react_id = payload['react_id']
message.message_unreact(token, message_id, react_id)
return dumps({})
def test_unreact_inactive_react_id():
clear()
user_a = register_n_users(1)
public_channel_id = channels_create(user_a["token"], "public_channel",
True)["channel_id"]
message_id = message_send(user_a["token"], public_channel_id,
"How are you")["message_id"]
# React id 1 is a valid id but not active
with pytest.raises(InputError):
message_unreact(user_a["token"], message_id, 1)
def test_message_unreact_invalid_token(make_users):
# setting up users and public channel
user_ab = make_users[0]
new_ch = channels_create(user_ab['token'], 'test_channel_public', True)
msg_id0 = message_send(user_ab["token"], new_ch["channel_id"],
"Random msg")["message_id"]
with pytest.raises(AccessError):
message_unreact(user_ab['token'] + "invalid", msg_id0, 1)
def test_unreact_invalid_react_id():
clear()
user_a = register_n_users(1)
public_channel_id = channels_create(user_a["token"], "public_channel",
True)["channel_id"]
message_id = message_send(user_a["token"], public_channel_id,
"How are you")["message_id"]
message_react(user_a["token"], message_id, 1)
invalid_react_number = -1
with pytest.raises(InputError):
message_unreact(user_a["token"], message_id, invalid_react_number)
def test_unreact():
reset_data()
owner = auth.auth_register("*****@*****.**", "hellocse1", "Sinha",
"Nawa")
channels.channels_create(owner['token'], "New Channel", True)
message.message_send(owner['token'], 1, "test")
message.message_react(owner['token'], 1, 1)
message.message_unreact(owner['token'], 1, 1)
data = get_data()
msg = data['messages'][0]
assert msg['react'] == []
