def test_message_unpin_invalid1():
'''Message with ID message_id is already unpinned'''
clear()
# Register user 0
user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang",
"W")
# Register user 1
user1_info = auth_register("*****@*****.**", "VukkFs", "Bill",
"Gates")
# Register user 2
user2_info = auth_register("*****@*****.**", "RFVtgb45678", "M",
"Johnson")
# 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 1 create another channel
channel1_info = channels_create(user1_info['token'], "channel1", True)
# User 2 join channel1
channel_join(user2_info['token'], channel1_info['channel_id'])
# User 0 join channel1
channel_join(user0_info['token'], channel1_info['channel_id'])
# User 2 send a message
message0_info = message_send(user2_info['token'],
channel1_info['channel_id'], "Hello")
# USer 1 send a message
message_send(user1_info['token'], channel0_info['channel_id'], "Hi")
# User 1 pin the message sent by user 2
message_pin(user1_info['token'], message0_info['message_id'])
# User 0 unpin the message just pinned by user 1
message_unpin(user0_info['token'], message0_info['message_id'])
with pytest.raises(InputError):
# User 1 unpin that message again
message_unpin(user1_info['token'], message0_info['message_id'])
def test_message_unpin_invalid3():
'''The authorised user is not an owner'''
clear()
# Register user 0
user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang",
"W")
# Register user 1
user1_info = auth_register("*****@*****.**", "VukkFs", "Bill",
"Gates")
# Register user 2
user2_info = auth_register("*****@*****.**", "RFVtgb45678", "M",
"Johnson")
# 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 1 create another channel
channel1_info = channels_create(user1_info['token'], "channel1", True)
# User 2 join channel1
channel_join(user2_info['token'], channel1_info['channel_id'])
# User 0 join channel1
channel_join(user0_info['token'], channel1_info['channel_id'])
# User 2 send a message
message0_info = message_send(user2_info['token'],
channel1_info['channel_id'], "Hello")
# User 1 pin the message sent by user 2
message_pin(user1_info['token'], message0_info['message_id'])
with pytest.raises(AccessError):
# User 2 pin the message sent by himself
message_unpin(user2_info['token'], message0_info['message_id'])
def test_message_pin_invalid2():
'''The authorised user is not a member of the channel that the message is within'''
clear()
# Register user 0
user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang",
"W")
# Register user 1
user1_info = auth_register("*****@*****.**", "VukkFs", "Bill",
"Gates")
# Register user 2
user2_info = auth_register("*****@*****.**", "RFVtgb45678", "M",
"Johnson")
# User 0 create channel0
channel0_info = channels_create(user0_info['token'], "channel0", True)
# User 1 join channel0
channel_join(user1_info['token'], channel0_info['channel_id'])
# User 1 create channel1
channel1_info = channels_create(user1_info['token'], "channel1", True)
# User 2 join channel1
channel_join(user2_info['token'], channel1_info['channel_id'])
# User 2 send a message
message0_info = message_send(user2_info['token'],
channel1_info['channel_id'], "Hello")
# USer 1 send a message
message_send(user1_info['token'], channel0_info['channel_id'], "Hi")
with pytest.raises(AccessError):
# User 0 pin a message in channel1 which he is not in
message_pin(user0_info['token'], message0_info['message_id'])
def test_message_pin_invalid0():
'''message_id is not a valid message'''
clear()
# Register user 0
user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang",
"W")
# Register user 1
user1_info = auth_register("*****@*****.**", "VukkFs", "Bill",
"Gates")
# Register user 2
user2_info = auth_register("*****@*****.**", "RFVtgb45678", "M",
"Johnson")
# 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 1 create another channel
channel1_info = channels_create(user1_info['token'], "channel1", True)
# User 2 join channel1
channel_join(user2_info['token'], channel1_info['channel_id'])
# User 0 join channel1
channel_join(user0_info['token'], channel1_info['channel_id'])
# User 2 send a message
message_send(user2_info['token'], channel1_info['channel_id'], "Hello")
# User 1 send a message
message_send(user1_info['token'], channel1_info['channel_id'], "Hi")
with pytest.raises(InputError):
# User 0 pin a message with wrong message_id
message_pin(user0_info['token'], 2)
def test_message_unpin_invalid_user():
_, wenyao_dict, weiqiang_dict, channel_team1, _ = initialise_data()
message_id1 = message_send(wenyao_dict['token'],
channel_team1['channel_id'], "hello")
message_pin(wenyao_dict['token'], message_id1['message_id'])
with pytest.raises(AccessError):
message_unpin(weiqiang_dict['token'], message_id1['message_id'])
def test_message_pin_valid2():
'''Owner of the channel pin the message sent by the owner of the channel'''
clear()
# Register user 0
user0_info = auth_register("*****@*****.**", "ihfeh3hgi00d", "Yilang",
"W")
# Register user 1
user1_info = auth_register("*****@*****.**", "VukkFs", "Bill",
"Gates")
# Register user 2
user2_info = auth_register("*****@*****.**", "RFVtgb45678", "M",
"Johnson")
# 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 1 create another channel
channel1_info = channels_create(user1_info['token'], "channel1", True)
# User 2 join channel1
channel_join(user2_info['token'], channel1_info['channel_id'])
# User 0 join channel1
channel_join(user0_info['token'], channel1_info['channel_id'])
# User 2 send a message
message_send(user2_info['token'], channel1_info['channel_id'], "Hello")
# USer 1 send a message
message1_info = message_send(user1_info['token'],
channel1_info['channel_id'], "Hi")
# User 0 pin the message sent by user 1
message_pin(user0_info['token'], message1_info['message_id'])
# User 0 get all channel messages
all_message_info = channel_messages(user0_info['token'],
channel1_info['channel_id'], 0)
assert all_message_info['messages'][1]['is_pinned'] == True
def test_message_pin_no_msgs(make_users):
# setting up users and public channel
user_ab, user_cd = make_users
new_ch = channels_create(user_ab['token'], 'test_channel_public', True)
with pytest.raises(InputError):
message_pin(user_ab["token"], 0)
def message_pin():
"""
Function message pin route
"""
message_info = request.get_json()
message.message_pin(message_info['token'], int(message_info['message_id']))
return dumps({})
def pin():
""" This is a flask wrapper for the message_pin function
Parameters:
No parameters
Returns:
(dictionary): Empty dictionary
"""
data = request.get_json()
token = data['token']
message_id = int(data['message_id'])
if message_check(message_id) is None:
raise InputError(description="Invalid id")
message = message_check(message_id)
if message['is_pinned']:
raise InputError(description="Already pinned")
if not check_if_user_in_channel_member(token, message['channel_id']):
raise AccessError(description="User not member")
if not check_if_user_in_channel_owner(token, message['channel_id']):
raise AccessError(description="User not Owner")
message_pin(token,message_id)
return dumps(message_id)
def test_message_unpin_non_owner(channels_fixture):
'''
Test case for when non owner of a channel tries to unpin a message
'''
(server_data, channels_fixture) = channels_fixture
# get details for user1 and channel 1
token1 = channels_fixture[1]["token"]
token2 = channels_fixture[2]["token"]
uid2 = channels_fixture[2]["u_id"]
channel_id = channels_fixture[1]["channels"][0]["channel_id"]
# user1 invites user2 to channel1
channel_invite(server_data, token1, channel_id, uid2)
# user1 sends a message to channel 1
msgid = message_send(server_data, token1, channel_id,
'Only owners can pin')['message_id']
# user1 pins the message
message_pin(server_data, token1, msgid)
# try to pin the message
with pytest.raises(InputError) as error_raise:
message_unpin(server_data, token2, msgid)
def test_pin_invalid_token():
"""
Test for invalid token
"""
with pytest.raises(AccessError):
message_pin("notatoken", -1)
def test_message_pin_twice():
"""
Test whether message pin twice will raise InputError
"""
data = create_pinned_message()
with pytest.raises(InputError):
message_pin(data["token"], data["message_id"])
def test_message_pin_upin(channels_fixture):
'''
Test case for working pin and unpin feature
'''
(server_data, channels_fixture) = channels_fixture
# get details for user1 and channel 1
token = channels_fixture[1]["token"]
channel_id = channels_fixture[1]["channels"][0]["channel_id"]
# send a message to channel 1
msgid = message_send(server_data, token, channel_id,
'Pin and unpin this')['message_id']
# pin the message
message_pin(server_data, token, msgid)
# make sure that the message is pinned
msg_list1 = search(server_data, token, 'Pin and unpin this')['messages']
msgpin = [i['is_pinned'] for i in msg_list1 if i['message_id'] == msgid]
assert msgpin == [True]
# unpin the message
message_unpin(server_data, token, msgid)
#m make sure that the message is unpinned
msg_list2 = search(server_data, token, 'Pin and unpin this')['messages']
msgunpin = [i['is_pinned'] for i in msg_list2 if i['message_id'] == msgid]
assert msgunpin == [False]
def test_message_unpin_others_msg(make_users):
# setting up users and public channel
user_ab, user_cd = make_users
new_ch = channels_create(user_ab['token'], 'test_channel_public', True)
channel_invite(user_ab["token"], new_ch["channel_id"], user_cd["u_id"])
msg_id0 = message_send(
user_ab["token"], new_ch["channel_id"],
"This message by the owner will not be pinned.")["message_id"]
msg_id1 = message_send(
user_cd["token"], new_ch["channel_id"],
"This message from a normal member will be pinned by the owner"
)["message_id"]
message_pin(user_ab["token"], msg_id1)
msg_dict = channel_messages(user_ab["token"], new_ch["channel_id"],
0)["messages"]
assert msg_dict[0]["is_pinned"]
assert not msg_dict[1]["is_pinned"]
message_unpin(user_ab["token"], msg_id1)
assert not channel_messages(user_ab["token"], new_ch["channel_id"],
0)["messages"][0]["is_pinned"]
def test_message_unpin_and_unpin_again():
_, wenyao_dict, _, channel_team1, _ = initialise_data()
message_id1 = message_send(wenyao_dict['token'], channel_team1['channel_id'], "hello")
message_pin(wenyao_dict['token'], message_id1['message_id'])
message_unpin(wenyao_dict['token'], message_id1['message_id'])
with pytest.raises(InputError):
message_unpin(wenyao_dict['token'], message_id1['message_id'])
def test_pin_non_existent_user():
"""Tests passing an invalid token into message_pin"""
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(AccessError):
message_pin("invalid token", new_msg["message_id"])
def test_message_pin_return_value():
boyu_dict, 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'], "hello")
assert message_pin(wenyao_dict['token'], message_id1['message_id']) == {}
assert message_pin(boyu_dict['token'], message_id2['message_id']) == {}
def test_message_pin_invalid_token():
"""Test passing an invalid token to message_pin"""
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_pin(2148, new_msg["message_id"])
def pin():
data = request.get_json()
token = data['token']
message_id = int(data['message_id'])
message_pin(token, message_id)
return dumps(message_id)
def test_invalid_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")
with pytest.raises(InputError):
message.message_pin(owner['token'], 2)
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_unpin_data():
_, wenyao_dict, _, channel_team1, _ = initialise_data()
message_id1 = message_send(wenyao_dict['token'], channel_team1['channel_id'], "hello")
# member of channel
message_pin(wenyao_dict['token'], message_id1['message_id'])
message_unpin(wenyao_dict['token'], message_id1['message_id'])
details_dict = channel_messages((wenyao_dict['token']), channel_team1['channel_id'], 0)
assert details_dict['messages'][0]['is_pinned'] == False
def test_pin_invalid_msg_id():
"""
Test whether pin invalid message will raise InputError.
"""
user = auth_register("*****@*****.**", "ccc337992611", "Min", "Li")
with pytest.raises(InputError):
message_pin(user['token'], -1)
def test_pin_success():
"""Tests a valid pinning of a newly created message"""
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")
message_pin(valid_user["token"], new_msg["message_id"])
message_list = list(filter(lambda msg: msg["message_id"] == new_msg["message_id"], data["messages"]))
assert message_list[0]["is_pinned"] is True
def test_pin_already_pinned():
"""Tests trying to pin a message that is already pinned"""
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")
message_pin(valid_user["token"], new_msg["message_id"])
with pytest.raises(InputError):
message_pin(valid_user["token"], new_msg["message_id"])
def test_pin_unauthorised_user():
"""Tests registers two users, and passing an unauthorised user into message_pin"""
clear()
valid_user1 = auth_register("*****@*****.**", "michaelpennnis2131", "Borat", "Me")
valid_user2 = auth_register("*****@*****.**", "michaelpennnis1131", "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")
with pytest.raises(AccessError):
message_pin(valid_user2["token"], new_msg["message_id"])
def test_pin_unpin_invalid_msg(initial_data, initial_msgs):
'''
input error
user 1 pin and unpin a non-existing msg
'''
with pytest.raises(InputError):
message_pin(users[0]['token'], 10003)
with pytest.raises(InputError):
message_unpin(users[0]['token'], 10003)
def test_pin_unpin_not_member(initial_data, initial_msgs):
'''
access error
user1 pin msg 20001 and unpin it
'''
with pytest.raises(AccessError):
message_pin(users[0]['token'], 20001)
with pytest.raises(AccessError):
message_unpin(users[0]['token'], 20001)
def test_pin_unpin_invalid_token(initial_data, initial_msgs):
'''
access error
given token is invalid
'''
with pytest.raises(AccessError):
message_pin('invalid_token', 10001)
with pytest.raises(AccessError):
message_unpin('invalid_token', 10001)
def test_pin_unpin_not_owner(initial_data, initial_msgs):
'''
access error
user 2 pin msg 10001 and unpin it
'''
with pytest.raises(AccessError):
message_pin(users[1]['token'], 10002)
with pytest.raises(AccessError):
message_unpin(users[1]['token'], 10002)
