def test_channels_listall_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] channelsCreateDicOne = channels_create(token, "validchannel1", False) channel_id_one = channelsCreateDicOne['channel_id'] channelsCreateDicTwo = channels_create(token, "validchannel2", True) channel_id_two = channelsCreateDicTwo['channel_id'] channelsCreateDicThree = channels_create(token, "validchannel3", True) channel_id_three = channelsCreateDicThree['channel_id'] # SETUP END # Invalidating token auth_logout(token) with pytest.raises(ValueError): # Testing function using invalid token channels_list(token)
def test_channels_create(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END channels_create(token, "validchannel", True) channel_found = False data = getData() for channels in data['channels']: if channels['channel_name'] == 'validchannel': channel_found = True assert channel_found == True assert channels_create(token, "validchannel1", False) == { 'channel_id': "validchannel1" } channel2_found = False data = getData() for channels in data['channels']: if channels['channel_name'] == 'validchannel1': channel2_found = True assert channel2_found == True
def test_standup_start(): jsonClean() # Valid channel ID authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] time_finish = "19:15/02/10/2019" # Invalid channel ID registerInvalidUserDict = auth_register("*****@*****.**", "password", "Thom", "Browne") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerInvalidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] assert standup_start(token, channel_id) == {time_finish} with pytest.raises(ValueError): # Testing function with invalid channel_id standup_start(token, invalid_channelid) # Testing function with invalid token standup_start(invalid_token, channelid)
def test_channel_invite_bad(): # SET UP BEGIN jsonClean() authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channelsCreateDicOne = channels_create(token_one, "validchannel1", True) channel_id_one = channelsCreateDicOne['channel_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with invalid channel_id channel_invite(token, "invalidchannel_id", u_id_one) # Testing function with channel_id which the authorised user isn't a member of channel_invite(token, channel_id_one, u_id_two) # Testing function with an invalid u_id channel_invite(token, channel_id, "invalidu_id") auth_logout(token_one) with pytest.raises(ValueError): # Testing function with invalid token channel_invite(token_one, channel_id_one, u_id_two)
def test_message_sendlater(): jsonClean() # SETUP BEGIN # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "password", "Thom", "Browne") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] channel_invite(token, channel_id, u_id) message = "I Heart Thom Browne" timesent = present + timedelta(minutes=1) + tdelta # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "password", "Thom", "Browne") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerValidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] channel_invite(invalid_token, invalid_channelid, invalid_uid) invalid_message = 0 invalid_timesent = "20/10/1999" # Invalidate the invalid user auth_logout(invalid_token) # SET UP END # Asserting that the default case works message_id = message_sendlater(token, channel_id, message, timesent) time.sleep(60) data = getData() for channels in data['channels']: for messages in channels['messages']: if messages['message'] == message: assert messages['message_id'] == message_id['message_id'] # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token message_sendlater(invalid_token, channel_id, message, timesent) # Testing function with an invalid channel id message_sendlater(token, invalid_channelid, message, timesent) # Testing function with an invalid message message_sendlater(token, channel_id, invalid_message, timesent) # Testing function with an invalid timesent input message_sendlater(token, channel_id, message, invalid_timesent)
def test_message_send(): jsonClean() # SETUP BEGIN # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "valid6password", "first6name", "last6name") token = registerValidUserDict['token'] u_id = registerValidUserDict['u_id'] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict['channel_id'] channel_invite(token, channel_id, u_id) message = "I Heart Hayden Smith" # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "invalid6password", "invalid6firstname", "invalid6lastname") invalid_token = registerInvalidUserDict['token'] invalid_uid = registerValidUserDict['u_id'] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict['channel_id'] channel_invite(invalid_token, invalid_channelid, invalid_uid) invalid_message = 0 # Invalidate the invalid user auth_logout(invalid_token) # SETUP END # Asserting that the default case works message_id = message_send(token, channel_id, message) data = getData() for channels in data['channels']: for messages in channels['messages']: if messages['message'] == message: assert messages['message_id'] == message_id['message_id'] # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token message_send(invalid_token, channel_id, message) # Testing function with an invalid channel id message_send(token, invalid_channelid, message) # Testing function with an invalid message message_send(token, channel_id, invalid_message)
def test_message_remove(): jsonClean() # SETUP BEGIN # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] channel_invite(token, channel_id, u_id) message_send(token, channel_id, "Hi") message_send(token, channel_id, "My name is") message_send(token, channel_id, "Thom Browne") channelValidMessagesDict = channel_messages(token, channel_id, 0) message_list = channelValidMessagesDict["messages"] message_dict = message_list[0] message_id = message_dict["message_id"] # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "invalidpassword", "invalidfirstname", "invalidlastname") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerValidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] channel_invite(invalid_token, invalid_channelid, invalid_uid) message_send(invalid_token, channel_id, "iH") message_send(invalid_token, channel_id, "si eman yM") message_send(invalid_token, channel_id, "enworB mohT") channelInvalidMessagesDict = channel_messages(invalid_token, invalid_channelid, 1) invalid_messagelist = channelValidMessagesDict["messages"] invalid_messagedict = invalid_messagelist[1] invalid_messageid = invalid_messagedict["message_id"] # Invalidate the invalid user auth_logout(invalid_token) # SETUP END # Asserting that the default case works assert remove_message(token, message_id) == {} # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token remove_message(invalid_token, message_id) # Testing function with an invalid message id remove_message(valid_token, invalid_messageid)
def test_channels_create_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with public channel_name which is too long channels_create(token, "this name is way too long so it will cause an error", True) # Testing function with private channel name which is too long channels_create(token, "this name is way too long so it will cause an error", False) auth_logout(token) with pytest.raises(ValueError): # Testing function with invalid token to create public channel channels_create(token, "validchannel", True) # Testing function with invalid token to create private channel channels_create(token, "validchannel", False)
def test_message_pin(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid60password", "first60name", "last60name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "valid61password", "first61name", "last61name") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] message_send(token, channel_id, "validmessage") channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id = message_dic["message_id"] # SETUP END message_pin(token, message_id) with pytest.raises(ValueError): message_pin(token, message_id) assert message_unpin(token, message_id) == {} # Testing message_pin to check the message was successfully unpinned message_pin(token, message_id)
def test_channel_join_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "first10name", "last10name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", False) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "first20name1", "last20name1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with invalid channel_id channel_join(token_one, "invalidchannel_id") # Testing function with unauthorised token when channel is private channel_join(token_one, channel_id) # Invalidate token auth_logout(token_one) with pytest.raises(ValueError): # Testing function with invalid token channel_join(token_one, channel_id)
def test_channel_leave_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] # SETUP END channel_join(token_one, channel_id) with pytest.raises(ValueError): # Testing function using invalid channel_id channel_leave(token_one, "invalidchannel_id") # Testing function on user who isn't part of the channel channel_leave(token_two, channel_id) auth_logout(token_one) with pytest.raises(ValueError): # Testing function using invalid token channel_leave(token_one, channel_id)
def test_standup_send(): jsonClean() # Generate a valid user registerValidUserDict = auth_register("*****@*****.**", "feelspecial", "Hwang", "Yeji") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] message = "I Heart Hwang Yeji" message_list = createValidChannelDict['messages'] message_dict = message_list[0] message_id = message_dict["message_id"] time = "19:16/02/10" # Generate an invalid user registerInvalidUserDict = auth_register("*****@*****.**", "password", "Kang", "Daniel") invalid_token = registerInvalidUserDict["token"] invalid_uid = registerInvalidUserDict["u_id"] createInvalidChannelDict = channels_create(invalid_token, "invalidchannel", True) invalid_channelid = createInvalidChannelDict["channel_id"] channel_invite(invalid_token, invalid_channelid, invalid_uid) invalid_message = 0 # Asserting that the default case works assert standup_send(token, channel_id, message) == {} # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token standup_send(invalid_token, channel_id, message) # Testing function with an invalid channel id standup_send(token, invalid_channelid, message) # Testing function with an invalid message standup_send(token, channel_id, invalid_message)
def test_channel_join(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "first100name", "last100name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END channel_join(token_one, channel_id) # checking output matches local data base data = getData() for channels in data['channels']: if channels['channel_id'] == channel_id: assert channels['all_members'] == [{ "u_id": u_id, "name_first": "first100name", "name_last": "last100name" }, { "u_id": u_id_one, "name_first": "firstname1", "name_last": "lastname1" }] # Assuming admin isn't in all_members list since admin was specifically isn't a member assert channel_details(token, channel_id) == { "name": "validchannel", "owner_members": [{ "u_id": u_id, "name_first": "first100name", "name_last": "last100name" }], "all_members": [{ "u_id": u_id, "name_first": "first100name", "name_last": "last100name" }, { "u_id": u_id_one, "name_first": "firstname1", "name_last": "lastname1" }] }
def test_message_unreact_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channel_join(token_one, channel_id) authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] message_send(token, channel_id, "validmessage") channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id = message_dic["message_id"] # SETUP END message_react(token, message_id, 1) with pytest.raises(ValueError): # Testing function with user who isn't admin message_unreact(token_one, message_id, 1) # Testing function with invalid message_id message_unreact(token, "invalidmessage_id", 1) # Testing function with user who isn't part of the channel message_unreact(token_two, message_id, react_id) # Testing function with invalid react_id message_unreact(token, message_id, "invalidreact_id") message_unreact(token, message_id, 1) with pytest.raises(ValueError): # Testing function with already unreacted message_id message_unreact(token, message_id, 1) message_react(token, message_id, react_id) auth_logout(token) with pytest.raises(ValueError): # Testing function with invalid token message_unreact(token, message_id, react_id)
def test_channels_list_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("invalidemail", "invalidpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] # SETUP END auth_logout(token) with pytest.raises(ValueError): # Testing function using invalid token channels_list(token)
def test_channels_listall(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] channelsCreateDicOne = channels_create(token, "validchannel1", False) channel_id_one = channelsCreateDicOne['channel_id'] channelsCreateDicTwo = channels_create(token, "validchannel2", True) channel_id_two = channelsCreateDicTwo['channel_id'] channelsCreateDicThree = channels_create(token, "validchannel3", True) channel_id_three = channelsCreateDicThree['channel_id'] # SETUP END # Testing function using authorised user assert channels_listall(token) == { 'channels': [{ 'channel_id': channel_id, 'name': 'validchannel' }, { 'channel_id': channel_id_one, 'name': 'validchannel1' }, { 'channel_id': channel_id_two, 'name': 'validchannel2' }, { 'channel_id': channel_id_three, 'name': 'validchannel3' }] }
def test_channel_addowner_bad(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] authRegisterDicThree = auth_register("*****@*****.**", "validpassword3", "firstname3", "lastname3") token_three = authRegisterDicThree['token'] u_id_three = authRegisterDicThree['u_id'] authRegisterDicFour = auth_register("*****@*****.**", "validpassword4", "firstname4", "lastname4") token_four = authRegisterDicFour['token'] u_id_four = authRegisterDicFour['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with invalid channel_id channel_addowner(token, "invalidchannel_id", u_id_one) channel_addowner(token, channel_id, u_id_one) with pytest.raises(ValueError): # Testing function on a user who's already an owner channel_addowner(token, "invalidchannel_id", u_id_one) # Testing function with a user who isn't an owner channel_addowner(token_two, channel_id, u_id_three) auth_logout(token) with pytest.raises(ValueError): # Testing function on an invalid token channel_addowner(token, channel_id, u_id_four)
def test_message_edit(): # SETUP BEGIN jsonClean() # Token creates the channel so it should be the owner registerValidUserDict = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = registerValidUserDict["token"] u_id = registerValidUserDict["u_id"] createValidChannelDict = channels_create(token, "validchannel", True) channel_id = createValidChannelDict["channel_id"] message_send(token, channel_id, "Hi") message_send(token, channel_id, "My name is") message_send(token, channel_id, "Thom Browne") channelValidMessagesDict = channel_messages(token, channel_id, 0) message_list = channelValidMessagesDict["messages"] message_dict = message_list[0] message_id = message_dict["message_id"] # A member in the channel authRegisterDicOne = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channel_invite(token, channel_id, u_id_one) message_send(token_one, channel_id, "iH") message_send(token_one, channel_id, "si eman yM") message_send(token_one, channel_id, "enworB mohT") channelInvalidMessagesDict = channel_messages(token_one, channel_id, 1) invalid_messagelist = channelValidMessagesDict["messages"] invalid_messagedict = invalid_messagelist[1] invalid_messageid = invalid_messagedict["message_id"] # SETUP END # Asserting that the default case works assert message_edit(token, message_id, message_list[0]) == {} # Testing that ValueError is raised when invalid parameters are passed with pytest.raises(ValueError): # Testing function with an invalid token message_edit(token_one, message_id, message_list[0]) # Testing function with an invalid message id message_edit(token_one, invalid_messageid, message_list[1])
def test_channel_invite(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "first6name", "last6name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "first8name1", "last8name1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END channel_invite(token, channel_id, u_id_one) # Asserting that the invited user is now a member of the channel assert channel_details(token_one, channel_id) == {"name": "validchannel", "owner_members": [{"u_id": u_id, "name_first": "first6name", "name_last": "last6name"}], "all_members": [{"u_id": u_id, "name_first": "first6name", "name_last": "last6name"}, {"u_id": u_id_one, "name_first": "first8name1", "name_last": "last8name1"}]} # Testing channel_leave to check that he's a member of the channel channel_leave(token_one, channel_id)
def test_channels_list(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] # SETUP END # Testing function using authorised user assert channels_list(token) == [{'channels': {channel_id: "validchannel"}}] for channels in data['channels']: assert channels == {'channel_id' : channel_id, 'channel_name' : "validchannel", 'is_public' : True, 'owner_members' : [{'u_id' : u_id, 'name_first' : name_first,'name_last' : name_last}], 'all_members' : [{'u_id' : u_id, 'name_first' : name_first,'name_last' : name_last}], 'messages' : []}
def test_message_pin_bad(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid70password", "first70name", "last70name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "valid71password", "first71name", "last71name") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channel_join(token_one, channel_id) authRegisterDicTwo = auth_register("*****@*****.**", "valid72password", "first72name", "last72name") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] message_send(token, channel_id, "validmessage") channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id = message_dic["message_id"] # SETUP END with pytest.raises(ValueError): # Testing function with user who isn't admin message_unpin(token_one, message_id) # Testing function with invalid message_id message_unpin(token, "invalidmessage_id") # Testing function with user who isn't part of the channel message_unpin(token_two, message_id) message_unpin(token, message_id) with pytest.raises(ValueError): # Testing function with already unpinned message_id message_unpin(token, message_id)
def test_message_react(): jsonClean() # SETUP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] channel_join(token_one, channel_id) message_send(token, channel_id, "validmessage") channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id = message_dic["message_id"] # Assuming 123 is valid react_id react_id = 123 # SETUP END assert message_react(token, message_id, react_id) == {} # Testing two users can react laugh one message assert message_react(token_one, message_id, react_id) == {} with pytest.raises(ValueError): # Testing function can't react the message for a second time message_react(token, message_id, react_id) # Testing function can unreact the message assert message_unreact(token, message_id, react_id) == {}
def test_channel_removeowner(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "validpassword", "firstname", "lastname") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "validpassword1", "firstname1", "lastname1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] # SETUP END # Adding user_one as an owner channel_addowner(token, channel_id, u_id_one) # Removing user_one as an owner channel_removeowner(token, channel_id, u_id_one) # checking output matches local data base data = getData() for channels in data['channels']: if channels['channel_id'] == channel_id: assert channels['owner_members'] == [{"u_id": u_id, "name_first": "firstname", "name_last": "lastname"}] # Calling function with recently removed owner to check he's not an owner channel_addowner(token_one, channel_id, u_id_two) # checking output matches local data base data = getData() for channels in data['channels']: if channels['channel_id'] == channel_id: assert channels['owner_members'] == [{"u_id": u_id, "name_first": "firstname", "name_last": "lastname"}, {"u_id": u_id_two, "name_first": "firstname2", "name_last": "lastname2"}]
def test_search(): jsonClean() # SETUP BEGIN # User One validAuthRegisterDic = auth_register("*****@*****.**", "valid30password", "first30name", "last30name") token = validAuthRegisterDic['token'] u_id = validAuthRegisterDic['u_id'] # User Two validAuthRegisterDicOne = auth_register("*****@*****.**", "valid31password", "first31name", "last31name") token_one = validAuthRegisterDicOne['token'] u_id_one = validAuthRegisterDicOne['u_id'] # False User Three invalidAuthRegisterDic = auth_register("*****@*****.**", "valid32password", "first32name", "last32name") invalid_token = invalidAuthRegisterDic['token'] # Creates an Invalid Token auth_logout(invalid_token) # Create a channel channel_id_dic = channels_create(token, "Channel Nine", True) channel_id = channel_id_dic['channel_id'] # Invite the member channel_invite(token, channel_id, u_id_one) # Send the messages message_send(token_one, channel_id, "Safe and secure society") message_send(token, channel_id, "Hello") message_send(token_one, channel_id, "Hellomydude") message_send(token, channel_id, "Hellomyman") message_send(token, channel_id, "Seriously cool") message_send(token_one, channel_id, "Absolutely astonishing") message_send(token, channel_id, "Congratulations on the role!") message_send(token_one, channel_id, "Happy work anniversary!") message_send(token, channel_id, "New world. New skills.") message_send(token, channel_id, "New world") # Find the Message ID's channelMessagesDic = channel_messages(token, channel_id, 0) message_list = channelMessagesDic["messages"] message_dic = message_list[0] message_id_safe = message_dic["message_id"] message_dic_one = message_list[2] message_id_one = message_dic_one["message_id"] message_dic_two = message_list[3] message_id_two = message_dic_two["message_id"] # SETUP END # Testing for no results assert search(token, "???") == [] # Testing for one result assert search(token, "Safe") == {"message_id" : message_id_safe, "u_id" : u_id_one, "message" : "Safe and secure society", "time_created" : "19:35", "is_unread" : False} # Testing for two or more results assert search(token, "Hellomy") == [{ "message_id" : message_id_one, "u_id" : u_id_one, "message" : "Hellomydude", "time_created" : "17:35", "is_unread" : False }, { "message_id" : message_id, "u_id" : u_id, "message" : "Helloymyman", "time_created" : "18:35", "is_unread" : False }] # Testing Bad Cases with pytest.raises(ValueError): # Bad token with multiple search results search(invalid_token, "Hellomy") # Bad token with no search results search(invalid_token, "ahahahahahaha")
def wrap_channels_create(): channels_create(request.form.get('token'), request.form.get('name'), request.form.get('is_public')) return json.dumps({})
def test_channel_addowner(): jsonClean() # SET UP BEGIN authRegisterDic = auth_register("*****@*****.**", "valid9password", "first9name", "last9name") token = authRegisterDic['token'] u_id = authRegisterDic['u_id'] channelsCreateDic = channels_create(token, "validchannel", True) channel_id = channelsCreateDic['channel_id'] authRegisterDicOne = auth_register("*****@*****.**", "valid6password1", "first6name1", "last6name1") token_one = authRegisterDicOne['token'] u_id_one = authRegisterDicOne['u_id'] authRegisterDicTwo = auth_register("*****@*****.**", "validpassword2", "firstname2", "lastname2") token_two = authRegisterDicTwo['token'] u_id_two = authRegisterDicTwo['u_id'] # SETUP END with pytest.raises(ValueError): # Testing function with member token to confirm he's not an owner channel_addowner(token_one, channel_id, u_id_two) # Making token_one an owner channel_addowner(token, channel_id, u_id_one) # checking output matches local data base data = getData() for channels in data['channels']: if channels['channel_id'] == channel_id: assert channels['owner_members'] == [{ "u_id": u_id, "name_first": "first9name", "name_last": "last9name" }, { "u_id": u_id_one, "name_first": "first6name1", "name_last": "last6name1" }] # Testing function with recently declared owner (token_one) to check if he has owner permissions assert channel_addowner(token_one, channel_id, u_id_two) == {} # checking output matches local data base data = getData() for channels in data['channels']: if channels['channel_id'] == channel_id: assert channels['owner_members'] == [{ "u_id": u_id, "name_first": "first9name", "name_last": "last9name" }, { "u_id": u_id_one, "name_first": "first6name1", "name_last": "last6name1" }, { "u_id": u_id_two, "name_first": "firstname2", "name_last": "lastname2" }]