def test_invite_global_owner(create_input):
    """ Tests that when a global owner is invited to a channel, they will have
        owner permissions in that channel.
    """
    
    channel_1 = create_input[1][1]
    
    assert channel_invite_v2(create_input[0][1]['token'], channel_1['channel_id'],
                             create_input[0][0]['auth_user_id']).status_code == SUCCESS
    assert channel_invite_v2(create_input[0][1]['token'], channel_1['channel_id'],
                             create_input[0][2]['auth_user_id']).status_code == SUCCESS
    
    # create_input[0][0] is a global owner, so when invited, they should join 
    # as a member but have owner permissions
    # create_input[0][2] is a member
    assert len(channel_details_v2(create_input[0][1]['token'], 
                                  channel_1['channel_id']).json()['owner_members']) == 1
    assert len(channel_details_v2(create_input[0][1]['token'], 
                                  channel_1['channel_id']).json()['all_members']) == 3

    # create_input[0][0] should be able to promote create_input[0][2] to a
    # channel owner
    assert channel_addowner_v1(create_input[0][0]['token'],
                               channel_1['channel_id'],
                               create_input[0][2]['auth_user_id']).status_code == SUCCESS
Esempio n. 2
0
def test_success_remove_multiple(create_input):
    # Add extra owner to First Channel
    assert channel_addowner_v1(
        create_input[0][0]["token"], create_input[1][0]["channel_id"],
        create_input[0][2]["auth_user_id"]).json() == {}

    # length of *_members for First Channel before remove
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 3
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 4

    assert channel_removeowner_v1(
        create_input[0][0]["token"], create_input[1][0]["channel_id"],
        create_input[0][1]["auth_user_id"]).json() == {}
    assert channel_removeowner_v1(
        create_input[0][0]["token"], create_input[1][0]["channel_id"],
        create_input[0][2]["auth_user_id"]).json() == {}

    # length of *_members for First Channel after remove; testing for all users
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][4]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][4]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 4
def test_successful_invites(create_input):
    """ Tests for multiple successful invites to a channel
    """

    # Create a set of users not in the channel yet
    user_1, user_2, user_3, user_4, user_5 = create_input[0]

    channel_1, channel_2, channel_3 = create_input[1]

    # Test for successful calls and that users have been immediately added into
    # their channels

    # Invite user2, user3, user4, user5 to channel 1
    assert channel_invite_v2(user_1['token'], channel_1['channel_id'],
                             user_2['auth_user_id']).status_code == SUCCESS
    assert channel_invite_v2(user_1['token'], channel_1['channel_id'],
                             user_3['auth_user_id']).status_code == SUCCESS
    assert channel_invite_v2(user_1['token'], channel_1['channel_id'],
                             user_4['auth_user_id']).status_code == SUCCESS
    assert channel_invite_v2(user_1['token'], channel_1['channel_id'],
                             user_5['auth_user_id']).status_code == SUCCESS

    # Invite user4, user5 to channel 2
    assert channel_invite_v2(user_2['token'], channel_2['channel_id'],
                             user_4['auth_user_id']).status_code == SUCCESS
    assert channel_invite_v2(user_2['token'], channel_2['channel_id'],
                             user_5['auth_user_id']).status_code == SUCCESS

    # Invite user1 to channel 3
    assert channel_invite_v2(user_3['token'], channel_3['channel_id'],
                             user_1['auth_user_id']).status_code == SUCCESS

    # Check that users have been added to channels
    channel_detail_1 = channel_details_v2(user_1['token'],
                                          channel_1['channel_id']).json()
    channel_detail_2 = channel_details_v2(user_2['token'],
                                          channel_2['channel_id']).json()
    channel_detail_3 = channel_details_v2(user_3['token'],
                                          channel_3['channel_id']).json()

    # Check channel 1
    assert channel_detail_1['all_members'][0]['u_id'] == user_1['auth_user_id']
    assert channel_detail_1['all_members'][1]['u_id'] == user_2['auth_user_id']
    assert channel_detail_1['all_members'][2]['u_id'] == user_3['auth_user_id']
    assert channel_detail_1['all_members'][3]['u_id'] == user_4['auth_user_id']
    assert channel_detail_1['all_members'][4]['u_id'] == user_5['auth_user_id']

    # Check channel 2
    assert channel_detail_2['all_members'][0]['u_id'] == user_2['auth_user_id']
    assert channel_detail_2['all_members'][1]['u_id'] == user_4['auth_user_id']
    assert channel_detail_2['all_members'][2]['u_id'] == user_5['auth_user_id']

    # Check channel 3
    assert channel_detail_3['all_members'][0]['u_id'] == user_3['auth_user_id']
    assert channel_detail_3['all_members'][1]['u_id'] == user_1['auth_user_id']
Esempio n. 4
0
def test_success_owner_leave(create_input):
    # Add another owner to First Channel
    assert channel_addowner_v1(
        create_input[0][0]["token"], create_input[1][0]["channel_id"],
        create_input[0][4]["auth_user_id"]).json() == {}

    # length of *_members for First Channel before leave
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 4

    # One owner leaves
    assert channel_leave_v1(create_input[0][0]["token"],
                            create_input[1][0]["channel_id"]).json() == {}

    # length of *_members for First Channel after leave; testing for all involved users
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3
    assert len(
        channel_details_v2(
            create_input[0][4]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][4]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3

    assert channel_details_v2(
        create_input[0][0]["token"],
        create_input[1][0]["channel_id"]).status_code == ACCESS_ERROR

    # number of channels each user is a part of
    assert len(
        channels_list_v2(create_input[0][0]["token"]).json()["channels"]) == 0
    assert len(
        channels_list_v2(create_input[0][1]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][2]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][4]["token"]).json()["channels"]) == 1
def test_success_private_channel(create_input):
    """ Tests that users can be invited into private channels too.
    """
    
    channel_private = create_input[1][2]
    
    assert channel_invite_v2(create_input[0][2]['token'], channel_private['channel_id'],
                             create_input[0][0]['auth_user_id']).status_code == SUCCESS
    
    assert len(channel_details_v2(create_input[0][2]['token'], 
                                  channel_private['channel_id']).json()['owner_members']) == 1
    assert len(channel_details_v2(create_input[0][2]['token'], 
                                  channel_private['channel_id']).json()['all_members']) == 2
Esempio n. 6
0
def test_fail_user_not_owner(create_input):
    # length of *_members for First Channel
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3

    assert channel_removeowner_v1(
        create_input[0][0]["token"], create_input[1][0]["channel_id"],
        create_input[0][4]["auth_user_id"]).status_code == INPUT_ERROR
def test_fail_token_not_owner(create_input):
    # length of *_members for Second Channel before add
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][1]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][1]["channel_id"]).json()["all_members"]) == 1

    assert channel_addowner_v1(
        create_input[0][2]["token"], create_input[1][1]["channel_id"],
        create_input[0][3]["auth_user_id"]).status_code == ACCESS_ERROR
Esempio n. 8
0
def test_fail_last_owner_leave(create_input):
    # length of *_members for First Channel before leave
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3

    assert channel_leave_v1(
        create_input[0][0]["token"],
        create_input[1][0]["channel_id"]).status_code == INPUT_ERROR
def test_success_user_is_member(create_input):
    # Add member to First Channel before making them owner
    assert channel_join_v2(create_input[0][1]["token"],
                           create_input[1][0]["channel_id"]).json() == {}
    assert channel_join_v2(create_input[0][2]["token"],
                           create_input[1][0]["channel_id"]).json() == {}

    # length of *_members for First Channel before add
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3

    assert channel_addowner_v1(
        create_input[0][0]["token"], create_input[1][0]["channel_id"],
        create_input[0][1]["auth_user_id"]).json() == {}

    # length of *_members for First Channel after add; testing for all users
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 3

    # number of channels each user is a part of
    assert len(
        channels_list_v2(create_input[0][0]["token"]).json()["channels"]) == 1
    assert len(
        channels_list_v2(create_input[0][1]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][2]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][3]["token"]).json()["channels"]) == 1
    assert len(
        channels_list_v2(create_input[0][4]["token"]).json()["channels"]) == 0
Esempio n. 10
0
def test_fail_no_permission(create_input):
    # length of *_members for Third Channel before remove
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 2

    assert channel_join_v2(create_input[0][4]["token"],
                           create_input[1][2]["channel_id"]).json() == {}

    assert channel_removeowner_v1(
        create_input[0][4]["token"], create_input[1][2]["channel_id"],
        create_input[0][2]["auth_user_id"]).status_code == ACCESS_ERROR
def test_self_invite(create_input):
    """ Test for user trying to invite themselves. The function should call
        successfully and not add the user again to the channel.
    """   
        
    user_1, user_2, user_3, user_4, user_5 = create_input[0]

    channel_1, channel_2, channel_3 = create_input[1]
    
    # Owner inviting themselves
    assert channel_invite_v2(user_1['token'], channel_1['channel_id'], 
                             user_1['auth_user_id']).status_code == SUCCESS
    channel_1_details = channel_details_v2(user_1['token'], 
                                           channel_1['channel_id']).json()
    assert len(channel_1_details['all_members']) == 1

    assert channel_invite_v2(user_2['token'], channel_2['channel_id'], 
                             user_2['auth_user_id']).status_code == SUCCESS
    channel_2_details = channel_details_v2(user_2['token'], 
                                           channel_2['channel_id']).json()
    assert len(channel_2_details['all_members']) == 1
    
    assert channel_invite_v2(user_3['token'], channel_3['channel_id'], 
                             user_3['auth_user_id']).status_code == SUCCESS
    channel_3_details = channel_details_v2(user_3['token'], 
                                           channel_3['channel_id']).json()
    assert len(channel_3_details['all_members']) == 1

    # User 4 inviting themselves after being invited by user 1
    assert channel_invite_v2(user_1['token'], channel_1['channel_id'],
                             user_4['auth_user_id']).status_code == SUCCESS
    assert channel_invite_v2(user_4['token'], channel_1['channel_id'],
                             user_4['auth_user_id']).status_code == SUCCESS
    channel_1_details = channel_details_v2(user_1['token'], 
                                           channel_1['channel_id']).json()
    assert len(channel_1_details['all_members']) == 2

    # User 5 inviting themselves after being invited by user 4
    assert channel_invite_v2(user_4['token'], channel_1['channel_id'],
                             user_5['auth_user_id']).status_code == SUCCESS
    assert channel_invite_v2(user_5['token'], channel_1['channel_id'],
                             user_5['auth_user_id']).status_code == SUCCESS
    channel_1_details = channel_details_v2(user_1['token'], 
                                           channel_1['channel_id']).json()
    assert len(channel_1_details['all_members']) == 3
Esempio n. 12
0
def test_fail_private_channel(create_input):
    # length of *_members for Third Channel before join
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 1

    # AccessError becuase these users are not global owners
    assert channel_join_v2(
        create_input[0][1]["token"],
        create_input[1][2]["channel_id"]).status_code == ACCESS_ERROR
    assert channel_join_v2(
        create_input[0][3]["token"],
        create_input[1][2]["channel_id"]).status_code == ACCESS_ERROR
    assert channel_join_v2(
        create_input[0][4]["token"],
        create_input[1][2]["channel_id"]).status_code == ACCESS_ERROR
Esempio n. 13
0
def test_success_private_channel(create_input):
    # length of *_members for Third Channel before join
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 1

    assert channel_join_v2(create_input[0][0]["token"],
                           create_input[1][2]["channel_id"]).json() == {}

    # create_input[0][0] is a global owner so will pass test
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 2
Esempio n. 14
0
def test_success_remove_with_global_owner(create_input):
    # length of *_members for Third Channel before remove
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 2

    # Global owner is not part of Third Channel, yet can still remove owners
    assert channel_removeowner_v1(
        create_input[0][0]["token"], create_input[1][2]["channel_id"],
        create_input[0][2]["auth_user_id"]).json() == {}

    assert len(
        channel_details_v2(
            create_input[0][3]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][3]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 2
Esempio n. 15
0
def test_removed_from_channel():
    """Tests that a user is removed from a channel"""
    clear_v1()
    user_1 = auth_register_v2("*****@*****.**", "finalpassword", "Eric",
                              "Zheng").json()
    user_2 = auth_register_v2("*****@*****.**", "validpassword", "Josh",
                              "Hatton").json()

    channel_1 = channels_create_v2(user_1["token"], "Test", True).json()
    channel_join_v2(user_2["token"], channel_1["channel_id"])

    admin_user_remove_v1(user_1["token"], user_2["auth_user_id"])

    members = channel_details_v2(user_1["token"],
                                 channel_1["channel_id"]).json()["all_members"]

    assert user_2["auth_user_id"] not in [m["u_id"] for m in members]
def test_success_owner_one_add(create_input):
    # length of *_members for First Channel before add
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 1

    assert channel_addowner_v1(
        create_input[0][0]["token"], create_input[1][0]["channel_id"],
        create_input[0][1]["auth_user_id"]).json() == {}

    # length of *_members for First Channel after join; testing for both users
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["owner_members"]) == 2
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][0]["channel_id"]).json()["all_members"]) == 2

    # number of channels each user is a part of
    assert len(
        channels_list_v2(create_input[0][0]["token"]).json()["channels"]) == 1
    assert len(
        channels_list_v2(create_input[0][1]["token"]).json()["channels"]) == 2
def test_success_global_owner_add(create_input):
    # length of *_members for Third Channel before add
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 1

    # create_input[0][0]["token"] is a global owner; can add owners even if they aren't members of the channel
    assert channel_addowner_v1(
        create_input[0][0]["token"], create_input[1][2]["channel_id"],
        create_input[0][1]["auth_user_id"]).json() == {}
    assert channel_addowner_v1(
        create_input[0][0]["token"], create_input[1][2]["channel_id"],
        create_input[0][3]["auth_user_id"]).json() == {}
    assert channel_addowner_v1(
        create_input[0][0]["token"], create_input[1][2]["channel_id"],
        create_input[0][0]["auth_user_id"]).json() == {}

    # length of *_members for Third Channel after add; testing for all users
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][3]["token"],
            create_input[1][2]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][3]["token"],
            create_input[1][2]["channel_id"]).json()["all_members"]) == 4

    assert channel_details_v2(
        create_input[0][4]["token"],
        create_input[1][2]["channel_id"]).status_code == ACCESS_ERROR
    assert channel_details_v2(
        create_input[0][4]["token"],
        create_input[1][2]["channel_id"]).status_code == ACCESS_ERROR

    # number of channels each user is a part of
    assert len(
        channels_list_v2(create_input[0][0]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][1]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][2]["token"]).json()["channels"]) == 1
    assert len(
        channels_list_v2(create_input[0][3]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][4]["token"]).json()["channels"]) == 0
def test_success_owner_multiple_add(create_input):
    # length of *_members for Second Channel before add
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][1]["channel_id"]).json()["owner_members"]) == 1
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][1]["channel_id"]).json()["all_members"]) == 1

    assert channel_addowner_v1(
        create_input[0][1]["token"], create_input[1][1]["channel_id"],
        create_input[0][0]["auth_user_id"]).json() == {}
    assert channel_addowner_v1(
        create_input[0][1]["token"], create_input[1][1]["channel_id"],
        create_input[0][2]["auth_user_id"]).json() == {}
    assert channel_addowner_v1(
        create_input[0][1]["token"], create_input[1][1]["channel_id"],
        create_input[0][3]["auth_user_id"]).json() == {}

    # length of *_members for Second Channel after add; testing for all users
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][1]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][0]["token"],
            create_input[1][1]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][1]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][1]["token"],
            create_input[1][1]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][1]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][2]["token"],
            create_input[1][1]["channel_id"]).json()["all_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][3]["token"],
            create_input[1][1]["channel_id"]).json()["owner_members"]) == 4
    assert len(
        channel_details_v2(
            create_input[0][3]["token"],
            create_input[1][1]["channel_id"]).json()["all_members"]) == 4

    assert channel_details_v2(
        create_input[0][4]["token"],
        create_input[1][1]["channel_id"]).status_code == ACCESS_ERROR
    assert channel_details_v2(
        create_input[0][4]["token"],
        create_input[1][1]["channel_id"]).status_code == ACCESS_ERROR

    # number of channels each user is a part of
    assert len(
        channels_list_v2(create_input[0][0]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][1]["token"]).json()["channels"]) == 1
    assert len(
        channels_list_v2(create_input[0][2]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][3]["token"]).json()["channels"]) == 2
    assert len(
        channels_list_v2(create_input[0][4]["token"]).json()["channels"]) == 0