def test_standup_send_valid(): ''' Test validly sending messages to get buffered in the standup queue ''' clear() # Set up users and channel f_owner = auth_register('*****@*****.**', 'password', 'Flockr', 'Owner') f_user = auth_register('*****@*****.**', 'password', 'Random', 'User') f_channel = channels_create(f_owner['token'], 'Test Channel', True) channel_join(f_user['token'], f_channel['channel_id']) # Start standup for 5 seconds standup_start(f_owner['token'], f_channel['channel_id'], 5) # Users send messages during the standup message1 = 'F' * 1000 message2 = 'X' * 1000 for _ in range(0, 3): standup_send(f_owner['token'], f_channel['channel_id'], message1) standup_send(f_user['token'], f_channel['channel_id'], message2) # Check only one message (containing all the standup messages) is sent after the standup ends time.sleep(6) messages = channel_messages(f_owner['token'], f_channel['channel_id'], 0) assert len(messages['messages']) == 1
def test_standup_start_nvid(): """ Tests if standup_start raises an InputError if the channel_id given is invalid. """ user = auth.auth_register("*****@*****.**", "password", "Donkey", "Kong") with pytest.raises(error.InputError): standup.standup_start(user['token'], 100, 100)
def test_standup_start_invalid_channel_id(): clear() user1 = register_n_users(1) invalid_channel_id = -1 with pytest.raises(InputError): standup_start(user1["token"], invalid_channel_id, 1)
def test_standup_start_channel_running(): time.sleep(1) _, wenyao_dict, _, channel_team1, _ = initialise_data() standup_start(wenyao_dict['token'], channel_team1['channel_id'], 5) with pytest.raises(InputError): assert standup_start(wenyao_dict['token'], channel_team1['channel_id'], 5)
def test_send_multiple(): """ Test if the standup_send can combine multiple message from send message """ channel_creater = auth.auth_register("*****@*****.**", "password", "Quick", "Shadow") test_user1 = auth.auth_register("*****@*****.**", "password", "Optimus", "Prime") test_channel_id1 = channels.channels_create(channel_creater["token"], "test1", True) channel.channel_join(test_user1["token"], test_channel_id1["channel_id"]) standup.standup_start(channel_creater["token"], test_channel_id1["channel_id"], 1) creater_profile = user.user_profile(channel_creater["token"], channel_creater["u_id"]) test_user_profile = user.user_profile(test_user1["token"], test_user1["u_id"]) new_message = "Know the new message" new_message2 = "Second message" standup.standup_send(channel_creater["token"], test_channel_id1["channel_id"], new_message) standup.standup_send(test_user1["token"], test_channel_id1["channel_id"], new_message2) inserted_message = creater_profile["user"][ "handle_str"] + ": " + new_message + "\n" inserted_message += test_user_profile["user"][ "handle_str"] + ": " + new_message2 + "\n" time.sleep(2) message_from_channel = channel.channel_messages( channel_creater["token"], test_channel_id1["channel_id"], 0) assert inserted_message == message_from_channel["messages"][0]["message"] assert channel_creater["u_id"] == message_from_channel["messages"][0][ "u_id"] other.clear()
def test_standup_send_handle(): """ Tests if standup_start and standup_send works. """ clear() user1 = auth.auth_register("*****@*****.**", "password", "Bilbo", "Baggins") channel_dict = channels.channels_create(user1['token'], "test_channel", True) user.user_profile_sethandle(user1['token'], 'handle') standup.standup_start(user1['token'], channel_dict['channel_id'], 3) standup.standup_send(user1['token'], channel_dict['channel_id'], "message1") time.sleep(5) standup.standup_active(user1['token'], channel_dict['channel_id']) message_dict = channel.channel_messages(user1['token'], channel_dict['channel_id'], 0) assert message_dict['messages'][0]['message'] == ("handle: message1") user.user_profile_sethandle(user1['token'], 'eren') standup.standup_start(user1['token'], channel_dict['channel_id'], 3) standup.standup_send(user1['token'], channel_dict['channel_id'], "message1") time.sleep(5) standup.standup_active(user1['token'], channel_dict['channel_id']) message_dict = channel.channel_messages(user1['token'], channel_dict['channel_id'], 0) assert message_dict['messages'][0]['message'] == ("eren: message1")
def test_standup_send_functionality(create_owner_with_channel_and_user): ''' Checks that standup_send actually works correctly and sends through a message in the correct format ''' owner = create_owner_with_channel_and_user['owner'] channel_1 = create_owner_with_channel_and_user['channel_1'] user = create_owner_with_channel_and_user['user'] standup.standup_start(owner['token'], channel_1['channel_id'], 2) standup.standup_send(owner['token'], channel_1['channel_id'], "Message 1 sent") standup.standup_send(user['token'], channel_1['channel_id'], "Message 2 sent") expected_message = '''homersimpson: Message 1 sent\nbartsimpson: Message 2 sent''' time.sleep(2) message_list = channel.channel_messages(owner['token'], channel_1['channel_id'], 0) standup_message = message_list['messages'][0] assert standup_message['message_id'] == 1 assert standup_message['u_id'] == owner['u_id'] assert standup_message['message'] == expected_message
def test_standup_active_usernotinchannel(): clear() channels = getChannelData() #Registering a user register = auth_register('*****@*****.**', '123abc!@#', 'Hayden', 'Everest', None) #Storing token generated from registration process in a variable for easy access creator_token = register['token'] #Using the registered user to create a channel new_channel = channels_create(creator_token, "Testing Channel", True) #Storing channel_id generated from channel creation in a variable for easy access channel_id = new_channel['channel_id'] for channel in channels: if channel['channel_id'] == channel_id: assert channel['is_standup'] == False standup_start(creator_token, channel_id, 3) for channel in channels: if channel['channel_id'] == channel_id: assert channel['is_standup'] == True #Registering a user register1 = auth_register('*****@*****.**', '!!!123abc!@#', 'Howard', 'Fog', None) #Storing token generated from registration process in a variable for easy access another_token = register1['token'] with pytest.raises(AccessError): standup_active(another_token, channel_id)
def test_standup_send_complex(): reset_data() member1 = auth_register('*****@*****.**', 'helloworld', 'a', 'A') member2 = auth_register('*****@*****.**', 'thisisfun', 'b', 'B') member3 = auth_register('*****@*****.**', 'iamrobbie', 'c', 'C') channel = channels_create(member1['token'], 'Hey Channel', True) channel_id = channel['channel_id'] channel_join(member2['token'], channel_id) channel_join(member3['token'], channel_id) standup_start(member1['token'], channel_id, 1) assert standup_send(member1['token'], channel_id, '1\nSTOP') == {} assert standup_send(member2['token'], channel_id, '2\nSTOP') == {} assert standup_send(member3['token'], channel_id, '3\nSTOP') == {} sleep(1.1) tmp = channel_messages(member1['token'], channel_id, 0) message = tmp['messages'][0] timestamp = message['time_created'] assert channel_messages(member1['token'], channel_id, 0) == { 'messages': [ { 'message_id': 1, 'u_id': 1, 'message': 'aa: 1\nSTOP\nbb: 2\nSTOP\ncc: 3\nSTOP', 'time_created': timestamp }, ], 'start': 0, 'end': -1, }
def test_standup_start_complex(): reset_data() member1 = auth_register('*****@*****.**', 'helloworld', 'ARoy', 'Wallace') member2 = auth_register('*****@*****.**', 'helloworld', 'BRoy', 'Wallace') test_channel = channels_create(member1['token'], 'New Channel', True) channel_id = test_channel['channel_id'] channel_join(member2['token'], channel_id) standup_start(member2['token'], channel_id, 1) standup_send(member1['token'], channel_id, 'Standup message1') standup_send(member2['token'], channel_id, 'Standup message2') sleep(1.1) tmp = channel_messages(member1['token'], channel_id, 0) message = tmp['messages'][0] timestamp = message['time_created'] assert channel_messages(member2['token'], channel_id, 0) == { 'messages': [ { 'message_id': 1, 'u_id': 2, 'message': 'aroywallace: Standup message1\nbroywallace: Standup message2', 'time_created': timestamp }, ], 'start': 0, 'end': -1, }
def test_standup_active_basecase(): clear() channels = getChannelData() #Registering a user register = auth_register('*****@*****.**', '123abc!@#', 'Hayden', 'Everest', None) #Storing token generated from registration process in a variable for easy access creator_token = register['token'] #Using the registered user to create a channel new_channel = channels_create(creator_token, "Testing Channel", True) #Storing channel_id generated from channel creation in a variable for easy access channel_id = new_channel['channel_id'] for channel in channels: if channel['channel_id'] == channel_id: assert channel['is_standup'] == False standup_start(creator_token, channel_id, 3) for channel in channels: if channel['channel_id'] == channel_id: assert channel['is_standup'] == True res = standup_active(creator_token, channel_id) assert len(res) == 2
def test_standup_whole(): time.sleep(5) _, wenyao_dict, _, channel_team1, _ = initialise_data() # start standup standup_start(wenyao_dict['token'], channel_team1['channel_id'], 5) # check if standup is active is_active = standup_active(wenyao_dict['token'], channel_team1['channel_id'])['is_active'] assert is_active == True standup_send(wenyao_dict['token'], channel_team1['channel_id'], "Hi") time.sleep(1) standup_send(wenyao_dict['token'], channel_team1['channel_id'], "Hello") # sleep for 5s time.sleep(5) # check if standup is active is_active = standup_active(wenyao_dict['token'], channel_team1['channel_id'])['is_active'] assert is_active == False # get handle wenyao_profile = user_profile(wenyao_dict['token'], wenyao_dict['u_id']) handle = wenyao_profile['user']['handle_str'] # check the return value for channel_message message_dict = channel_messages(wenyao_dict['token'], channel_team1['channel_id'], 0) msg = handle + ': ' + "Hi" + '\n' + handle + ': ' + "Hello" assert message_dict['messages'][0]['message'] == msg
def test_send_too_long(): """ Test if an error is raised if message is too long """ channel_creater = auth.auth_register("*****@*****.**", "password", "Quick", "Shadow") test_channel_id1 = channels.channels_create(channel_creater["token"], "test1", True) standup.standup_start(channel_creater["token"], test_channel_id1["channel_id"], 1) message_exp = ( "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula " "eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient " "montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, " "pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, " "aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis " "vitae, justo. Nullam dictum felis eu pede mollis pretium. Integer tincidunt. Cras " "dapibus. Vivamus elementum semper nisi. Aenean vulputate eleifend tellus. Aenean leo " "ligula, porttitor eu, consequat vitae, eleifend ac, enim. Aliquam lorem ante, dapibus " "in, viverra quis, feugiat a, tellus. Phasellus viverra nulla ut metus varius laoreet. " "Quisque rutrum. Aenean imperdiet. Etiam ultricies nisi vel augue. Curabitur ullamcorper " "ultricies nisi. Nam eget dui. Etiam rhoncus. Maecenas tempus, tellus eget condimentum " "rhoncus, sem quam semper libero, sit amet adipiscing sem neque sed ipsum...12345" ) with pytest.raises(InputError): standup.standup_send(channel_creater["token"], test_channel_id1["channel_id"], message_exp) other.clear()
def test_standup_send_during_standup(): ''' Test that messages sent during the standup period are not actually sent untill after, and then, all as one message ''' clear() user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") channel = channels_create(user['token'], "Channel", True) standup_start(user['token'], channel['channel_id'], 1) standup_send(user['token'], channel['channel_id'], "message1") check = search(user['token'], "message1") assert len(check['messages']) == 0 standup_send(user['token'], channel['channel_id'], "message2") check = search(user['token'], "message2") assert len(check['messages']) == 0 time.sleep(4) check = search(user['token'], "message") assert len(check['messages']) == 1 name = user_profile(user['token'], user['u_id'])['user']['handle_str'] assert check['messages'][0][ 'message'] == name + ": message1" + '\n' + name + ": message2"
def test_standup_send_invalid_token(): ''' Test basic error raising from invalid inputs ''' clear() user = auth_register("*****@*****.**", "password", "Firstname", "Lastname") user2 = auth_register("*****@*****.**", "password", "Firstname", "Lastname") channel = channels_create(user['token'], "Channel", True) standup_start(user['token'], channel['channel_id'], 1) # User not in channel causes access error with pytest.raises(AccessError): standup_send(user2['token'], channel['channel_id'], "message") # invalid token raises AccessError with pytest.raises(AccessError): standup_send("notToken", channel['channel_id'], "message") # invalid channel_id raises InputError with pytest.raises(InputError): standup_send(user['token'], -1, "message") # message over 1000 characters long raises InputError message = "a" * 1001 with pytest.raises(InputError): standup_send(user['token'], channel['channel_id'], message) time.sleep(2)
def test_standup_start1(): """ Tests if standup_start and standup_send works. """ clear() user1 = auth.auth_register("*****@*****.**", "password", "Bilbo", "Baggins") user2 = auth.auth_register("*****@*****.**", "password", "Frodo", "Baggins") user3 = auth.auth_register("*****@*****.**", "password", "Master", "Sauron") channel_dict = channels.channels_create(user1['token'], "test_channel", True) channel.channel_join(user2['token'], channel_dict['channel_id']) channel.channel_join(user3['token'], channel_dict['channel_id']) standup.standup_start(user1['token'], channel_dict['channel_id'], 3) standup.standup_send(user1['token'], channel_dict['channel_id'], "message1") standup.standup_send(user2['token'], channel_dict['channel_id'], "message2") standup.standup_send(user3['token'], channel_dict['channel_id'], "message3") time.sleep(5) standup.standup_active(user1['token'], channel_dict['channel_id']) message_dict = channel.channel_messages(user1['token'], channel_dict['channel_id'], 0) assert len(message_dict['messages']) == 1 assert message_dict['messages'][0]['message'] == ("bilbobaggins: message1\n" + "frodobaggins: message2\n" + "mastersauron: message3")
def test_standup_start_invalid_token(): """Tests passing an invalid token to standup_start""" clear() valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me") channels_create(valid_user["token"], "invalid_channel", False) with pytest.raises(AccessError): standup_start(90000, 1433125, 3)
def test_start_error_invalid_req(initial_data): ''' error test when user calls standup_start when it is active in that channel user 1 calls standup_start in channel_1 and call start again ''' standup_start(users[0]['token'], channels[0]['channel_id'], 3) with pytest.raises(InputError): standup_start(users[0]['token'], channels[0]['channel_id'], 3)
def test_start_error_invalid_channel(initial_data): ''' error test when given channel_id is invalid channel_id does not exist ''' # non-existing channel with id 0 with pytest.raises(InputError): standup_start(users[0]['token'], 0, 1)
def test_send_error_invalid_msg(initial_data): ''' error test when msg is too long (1000 characters) user1 calls start in channel1 and send a too long msg ''' standup_start(users[0]['token'], channels[0]['channel_id'], 1) with pytest.raises(InputError): standup_send(users[0]['token'], channels[0]['channel_id'], 'm' * 1001)
def test_standup_send_is_member(): time.sleep(5) boyu_dict, wenyao_dict, _, channel_team1, _ = initialise_data() channel_invite(wenyao_dict['token'], channel_team1['channel_id'], boyu_dict['u_id']) standup_start(wenyao_dict['token'], channel_team1['channel_id'], 5) sent = standup_send(boyu_dict['token'], channel_team1['channel_id'], "Hello") assert sent == {}
def test_standup_start_invalid_channel(): """Tests passing an invalid channel ID to standup_start""" clear() valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me") channels_create(valid_user["token"], "invalid_channel", False) with pytest.raises(InputError): standup_start(valid_user["token"], 9001, 3)
def test_standup_send_long_message(): reset_data() member = auth_register('*****@*****.**', 'helloworld', 'firstname', 'lastname') channel_id = channels_create(member['token'], 'Channel', True) standup_start(member['token'], channel_id['channel_id'], 3) with pytest.raises(InputError): standup_send(member['token'], 1, 'a'*1001)
def test_active_output3(): clear() user = auth.auth_register("*****@*****.**", "password", "First", "Last") channel = channels.channels_create(user['token'], "name", True) standup.standup_start(user['token'], channel["channel_id"], 3) assert standup.standup_active(user['token'], channel['channel_id']).get('is_active') == True time.sleep(4) assert standup.standup_active(user['token'], channel['channel_id']).get('is_active') == False
def test_standup_start_nvt(): """ Tests if standup_start raises an AccessError if the token given is invalid. """ user = auth.auth_register("*****@*****.**", "password", "Dwayne", "Johnson") channel_dict = channels.channels_create(user['token'], "test_channel", False) with pytest.raises(error.AccessError): standup.standup_start("InvalidToken", channel_dict['channel_id'], 100)
def test_standup_start_already_active(): reset_data() member1 = auth_register('*****@*****.**', 'helloworld', 'firstname', 'lastname') test_channel = channels_create(member1['token'], 'New Channel', True) standup_start(member1['token'], test_channel['channel_id'], 10) with pytest.raises(InputError): standup_start(member1['token'], test_channel['channel_id'], 6)
def test_standup_start_already_active(): """Tests running a standup on a channel that currently has a standup running""" clear() valid_user = auth_register("*****@*****.**", "validPassword", "Validate", "Me") new_channel = channels_create(valid_user["token"], "new_channel", False) standup_start(valid_user["token"], new_channel["channel_id"], 3) with pytest.raises(InputError): standup_start(valid_user["token"], new_channel["channel_id"], 3)
def test_send_error_not_active(initial_data): ''' error test when standup is not active in given channel user 1 calls start in channel 1 user 3 calls send in chanenl 2 ''' standup_start(users[0]['token'], channels[0]['channel_id'], 1) with pytest.raises(InputError): standup_send(users[2]['token'], channels[1]['channel_id'], 'msg')
def test_send_error_not_member(initial_data): ''' error test when standup_send to wrong channel user 1 calls start in channel1 user 3 calls standup_send to channel1 ''' standup_start(users[0]['token'], channels[0]['channel_id'], 1) with pytest.raises(AccessError): standup_send(users[2]['token'], channels[0]['channel_id'], 'msg')
def test_standup_send_user_not_in_channel(): reset_data() member1 = auth_register('*****@*****.**', 'helloworld', 'a', 'A') member2 = auth_register('*****@*****.**', 'helloworld', 'b', 'B') channel_id = channels_create(member1['token'], 'Channel', True) standup_start(member1['token'], channel_id['channel_id'], 3) with pytest.raises(AccessError): standup_send(member2['token'], 1, 'a')