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_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_message_unpin_valid():
"""
Test for valid input
"""
data = create_pinned_message()
message_unpin(data["token"], data["message_id"])
assert data["message_file"]["messages"][0]["is_pinned"] is 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_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_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_valid1():
'''Owner of the flockr joins the channel and pin a message sent by a member then the
message is uppined 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
message0_info = message_send(user2_info['token'],
channel1_info['channel_id'], "Hello")
# User 0 pin the message sent by user 2
message_pin(user0_info['token'], message0_info['message_id'])
# User 1 unpin the message just pinned by user 0
message_unpin(user1_info['token'], message0_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'][0]['is_pinned'] == False
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 unpin():
""" This is a flask wrapper for the message_unpin 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 not message['is_pinned']:
raise InputError(description="Already unpinned")
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_unpin(token, message_id)
return dumps(message_id)
def test_message_unpin():
'''
Testing message_unpin function
'''
clear()
now = datetime.now()
timestamp = datetime.timestamp(now)
fake_token = jwt.encode({
'u_id': 3,
'time': timestamp
},
SECRET,
algorithm='HS256')
#creating users to create channels
user1 = auth_register("*****@*****.**", "user1pass", "user1", "last1",
None)
user2 = auth_register("*****@*****.**", "user2pass", "user2", "last2",
None)
token1 = user1['token']
token2 = user2['token']
#creating channels
ch_id1 = channels_create(token1, "FirstChannel", True)['channel_id']
#creating channel messages
m_id1 = message_send(token1, ch_id1, 'hello1')['message_id']
m_id2 = message_send(token1, ch_id1, 'hello2')['message_id']
with pytest.raises(InputError):
#invalid message_id
message_unpin(token2, 4)
#user pinning a message
message_pin(token1, m_id1)
#user unpinning a pinned message
message_unpin(token1, m_id1)
with pytest.raises(InputError):
#message is already unpinned
message_unpin(token1, m_id1)
message_pin(token1, m_id1)
with pytest.raises(AccessError):
#unauthorised user that is not an owner or part of the channel
message_unpin(fake_token, m_id1)
message_pin(token1, m_id2)
message = find_message(ch_id1, m_id2)
assert message['is_pinned']
message_unpin(token1, m_id2)
message = find_message(ch_id1, m_id2)
assert not message['is_pinned']
clear()
def unpin():
data = request.get_json()
token = data['token']
message_id = int(data['message_id'])
message_unpin(token, message_id)
return dumps(message_id)
def test_message_unpin_invalid_id():
'''
tests that message_unpin raises an input error when the message doesn't exist
'''
other.clear()
owner = auth.auth_register("*****@*****.**", "password", "John", "Smith")
with pytest.raises(error.InputError):
message.message_unpin(owner['token'], 1)
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 message_unpin():
"""
Function message unpin route
"""
message_info = request.get_json()
message.message_unpin(message_info['token'],
int(message_info['message_id']))
return dumps({})
def test_message_unpin_twice():
"""
Test whether message unreact twice will raise InputError
"""
data = create_pinned_message()
message_unpin(data["token"], data["message_id"])
with pytest.raises(InputError):
message_unpin(data["token"], data["message_id"])
def test_unpin_already_unpinned():
"""Tests trying to unpin an already unpinned 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")
with pytest.raises(InputError):
message_unpin(valid_user["token"], new_msg["message_id"])
def test_message_unpin_return_value():
boyu_dict, 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'])
assert message_unpin(wenyao_dict['token'], message_id1['message_id']) == {}
# owner
message_pin(wenyao_dict['token'], message_id1['message_id'])
assert message_unpin(boyu_dict['token'], message_id1['message_id']) == {}
def test_message_already_unpinned():
clear()
user_0 = auth_register("*****@*****.**", "password", "User_0",
"User_last_0")
channel_1 = channels_create(user_0.get('token'), 'channel_1', True)
message_info = message_send(user_0.get('token'),
channel_1.get('channel_id'), 'Hello world')
with pytest.raises(InputError):
message_unpin(user_0.get('token'), message_info.get('message_id'))
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)
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_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 message_unpin():
'''
Route that pins the specified message
'''
payload = request.get_json()
token = payload['token']
message_id = payload['message_id']
message.message_unpin(token, message_id)
return dumps({})
def test_message_unpin_invalid_token():
"""Test passing an invalid token to message_unpin"""
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")
message_pin(valid_user["token"], new_msg["message_id"])
with pytest.raises(AccessError):
message_unpin(2148, new_msg["message_id"])
def test_invalid_id1():
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_pin(owner['token'], 1)
with pytest.raises(InputError):
message.message_unpin(owner['token'], 2)
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_unpin_non_existant_user():
"""Tests passing an invalid token into message_unpin"""
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(AccessError):
message_unpin("invalid token", new_msg["message_id"])
def test_unpin_not_in_channel():
"""
Test whether unpin other person's message
when not in the channel will raise AccessError.
"""
data = create_pinned_message()
user_infor = auth_register('*****@*****.**', 'HereyouAreMyP', 'not',
'exit')
with pytest.raises(AccessError):
message_unpin(user_infor['token'], data['message_id'])
def test_unpin_success():
"""Tests successfully pinning then unpinning a 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_unpin(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 False
def test_unpin_unauthorised_user():
"""Tests registers two users, and passing an unauthorised user into message_unpin"""
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")
message_pin(valid_user1["token"], new_msg["message_id"])
with pytest.raises(AccessError):
message_unpin(valid_user2["token"], new_msg["message_id"])
