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"])