def test_hidden_channels():
'''
Testing if certain channels are hidden to users
'''
clear()
# User1 makes 3 channels
user1 = auth_register('*****@*****.**', 'ilikeapPlEs', 'Steven',
'Stevenson')
channels_create(user1['token'], 'Private Channel 1', False)
channels_create(user1['token'], 'Secret Club', False)
channels_create(user1['token'], 'HIDDEN channel', False)
assert len(channels_list(user1['token'])['channels']) == 3
assert len(channels_listall(user1['token'])['channels']) == 3
# Public channel created, user1 should be able to see all 4
channels_create(user1['token'], 'Public', True)
assert len(channels_list(user1['token'])['channels']) == 4
# New user should only see public channel
user2 = auth_register('*****@*****.**', 'idontlikeapples',
'Matthew', 'Matthewson')
assert len(channels_list(user2['token'])['channels']) == 0
assert len(channels_listall(user2['token'])['channels']) == 4
# User2 has 1 channel
channels_create(user2['token'], 'matthew lair', False)
assert len(channels_list(user2['token'])['channels']) == 1
# User1 can still only see 4
assert len(channels_list(user1['token'])['channels']) == 4
# There should be a total of 5 channels
assert len(channels_listall(user2['token'])['channels']) == 5
def test_create_valid_channels():
'''
Creating valid channels
'''
clear()
# User1 creating 3 channels normally
user1 = auth_register('*****@*****.**', 'thisisagoodpassword',
'Andrew', 'Smith')
channels_create(user1['token'], "FirstChannel", True)
channels_create(user1['token'], "UNSW discussion", True)
channels_create(user1['token'], "Private", False)
assert len(channels_list(user1['token'])['channels']) == 3
assert len(channels_listall(user1['token'])['channels']) == 3
# User2 creating channel
user2 = auth_register('*****@*****.**', 'khjsdfiowefh2',
'Steven', 'Matthewson')
assert len(channels_list(user2['token'])['channels']) == 0
channels_create(user2['token'], "Steven land", True)
assert len(channels_list(user2['token'])['channels']) == 1
assert len(channels_listall(user1['token'])['channels']) == 4
# User3 creating no channels
user3 = auth_register('*****@*****.**', 'dwfwefhf', 'Steven',
'Smithson')
assert len(channels_list(user3['token'])['channels']) == 0
def test_listall_invalid_token(create_users, create_channels):
"""
Test for AccessError exception thrown by channels_create() when token
passed in is not a valid token.
:param create_users: pytest fixture to create two test users
:type create_users: pytest fixture
:param create_channels: pytest fixture to create six test channels
:type create_channels: pytest fixture
"""
# empty
with pytest.raises(AccessError):
channels_listall('')
# None
with pytest.raises(AccessError):
channels_listall(None)
# Not the correct data type
with pytest.raises(AccessError):
channels_listall(123)
# Not an authorised user
bad_token = 'invalid_token'
with pytest.raises(AccessError):
channels_listall(bad_token)
def channels_listall():
'''
Route that lists all created channels
'''
token = request.args.get('token')
dump = channels.channels_listall(token)
return dumps(dump)
def test_channels_listall_2channel():
#dictionary of token and uid when user logs in and the element removes when he logs out
helper_functions.clear_data()
user1_email = '*****@*****.**'
user1_password = '******'
user1_firstname = 'USER'
user1_lastname = '1'
diction = auth.auth_register(user1_email, user1_password, user1_firstname,
user1_lastname)
token = diction.get('token')
## uid = diction.get('u_id')
id_dict = channels.channels_create(token, user1_firstname, True)
channel_id1 = id_dict.get('channel_id')
id_dict2 = channels.channels_create(token, 'asdfg', True)
channel_id2 = id_dict2.get('channel_id')
chan = channels.channels_listall(token)
chan = chan.get('channels')
assert chan == [{
'channel_id': channel_id1,
'name': user1_firstname
}, {
'channel_id': channel_id2,
'name': 'asdfg'
}]
def test_channels_listall_empty():
reset_data()
# Creating the user
user_info = auth_register('*****@*****.**', 'sadsad', 'name', 'lastname')
assert channels_listall(user_info['token']) == {
'channels': [],
}
def test_listall_standard(create_users, create_channels):
"""
Test for standard functionality of channels_listall() according to spec.
:param create_users: pytest fixture to create two test users
:type create_users: pytest fixture
:param create_channels: pytest fixture to create six test channels
:type create_channels: pytest fixture
"""
# test length of returned channels list, making sure both
# users' channels are listed
temp = channels_listall(users[0]['token'])
assert len(temp['channels']) == 6
# test for accuracy of details of returned channels list
channel_01_listed = temp['channels'][0]
channel_02_listed = temp['channels'][1]
channel_03_listed = temp['channels'][2]
channel_04_listed = temp['channels'][3]
channel_05_listed = temp['channels'][4]
channel_06_listed = temp['channels'][5]
assert channel_01_listed['channel_id'] == channel_01['channel_id']
assert channel_01_listed['name'] == 'Channel 01'
assert channel_02_listed['channel_id'] == channel_02['channel_id']
assert channel_02_listed['name'] == 'Channel 02'
assert channel_03_listed['channel_id'] == channel_03['channel_id']
assert channel_03_listed['name'] == 'Channel 03'
assert channel_04_listed['channel_id'] == channel_04['channel_id']
assert channel_04_listed['name'] == 'Channel 04 User 2'
assert channel_05_listed['channel_id'] == channel_05['channel_id']
assert channel_05_listed['name'] == 'Channel 05 User 2'
assert channel_06_listed['channel_id'] == channel_06['channel_id']
assert channel_06_listed['name'] == 'Channel 06 User 2'
def test_channels_listall():
reset()
# Function channels_listall(token)
# Returns {channels}
# Provide a list of all channels (and their associated details)
u_id, token = get_user("user1")
#Assert that function returns a dictionary with keys "channels"
assert channels.channels_listall(token).keys() == {"channels"}
def test_channels_create_one_valid_private_channel(get_new_user_1,
get_new_user_2):
# dummy users.
u_id_1, token_1 = get_new_user_1
u_id_2, token_2 = get_new_user_2
# user_1 creates private channel, user_2 does not have access to this channel.
channel1 = channels.channels_create(token_1, valid_channel_name_1, False)
my_channel_list_2 = channels.channels_listall(token_2)
assert len(my_channel_list_2) == 0
def test_channels_listall_multiple_users_private():
clear()
user_01, user_02, user_03 = register_n_users(3)
tokens = [user_01["token"], user_02["token"], user_03["token"]]
channel_ids = []
names = ["private_channel_01", "private_channel_02", "private_channel_03"]
for name, token in zip(names, tokens):
channel_ids.append(channels_create(token, name, is_public=False)["channel_id"])
authorised_channels = []
for channel_id, name in zip(channel_ids, names):
authorised_channels.append({"channel_id": channel_id, "name": name})
assert channels_listall(user_01["token"]) == {"channels": authorised_channels}
assert channels_listall(user_02["token"]) == {"channels": authorised_channels}
assert channels_listall(user_03["token"]) == {"channels": authorised_channels}
def test_channels_listall_one_channels_one_authorized(get_new_user):
# dummy user.
u_id, token = get_new_user
# create one channels. assumes creates valid channels.
channel1 = channels.channels_create(token, 'channel1', True)
# join channel
channel.channel_join(token, channel1['channel_id'])
# ensure channels list for dummy user has all channels.
my_channels_list = channels.channels_listall(token)
assert len(my_channels_list) == 1
