def test_multiple_members_to_owners(create_input):
""" Tests that the first owner of Dreams is able to promote several members of
Dreams to an owner. These new owners should also be able to promote
other members.
"""
# user_1 is a dreams owner, everyone else is a member
user_1, user_2, user_3, user_4, user_5 = create_input[0]
private_channel = create_input[1][2]
# Promote user_2 to owner
assert admin_userpermission_change_v1(user_1['token'],
user_2['auth_user_id'], 1) == {}
# user_2 should be able to promote other members to owners as well
assert admin_userpermission_change_v1(user_2['token'],
user_3['auth_user_id'], 1) == {}
assert admin_userpermission_change_v1(user_2['token'],
user_4['auth_user_id'], 1) == {}
# user_3 should also be able to promote members to owners
assert admin_userpermission_change_v1(user_3['token'],
user_5['auth_user_id'], 1) == {}
# everyone should be able to join a private channel
assert channel_join_v2(user_2['token'], private_channel['channel_id']) == {}
assert channel_join_v2(user_3['token'], private_channel['channel_id']) == {}
assert channel_join_v2(user_4['token'], private_channel['channel_id']) == {}
assert channel_join_v2(user_5['token'], private_channel['channel_id']) == {}
def test_data():
"""
channel a
owners
a
members
a, b
channel c
owners
c
members
c
"""
clear_v1()
global_owner = auth_register_v2('*****@*****.**', '123456', 'Global',
'Owner')
a_data = auth_register_v2('*****@*****.**', '123456', 'Andy', 'Anderson')
b_data = auth_register_v2('*****@*****.**', '123456', 'Bob', 'Bobinson')
c_data = auth_register_v2('*****@*****.**', '123456', 'Chris', 'Con')
# Channel that only 'a' and 'b' are in
a_ch_id = channels_create_v2(a_data["token"], 'A\'s Public',
True)['channel_id']
# b to join channel a
channel_join_v2(b_data["token"], a_ch_id)
c_ch_id = channels_create_v2(c_data["token"], 'C\'s Public',
True)['channel_id']
return global_owner, a_data, b_data, c_data, a_ch_id, c_ch_id
def test_two_tags():
clear_v1()
user1 = auth_register_v2("*****@*****.**", "finalpassword", "Eric",
"Zheng")
user2 = auth_register_v2("*****@*****.**", "validpassword", "Josh",
"Hatton")
channel1 = channels_create_v2(user1['token'], 'Channel 1', True)
channel_join_v2(user2['token'], channel1['channel_id'])
msg1str = "@ericzheng @joshhatton"
message_send_v2(user1['token'], channel1['channel_id'], msg1str)
assert notifications_get_v1(user1['token']) == {
'notifications': [{
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
f"ericzheng tagged you in Channel 1: {msg1str[0:20]}"
}]
}
assert notifications_get_v1(user2['token']) == {
'notifications': [{
'channel_id':
channel1['channel_id'],
'dm_id':
-1,
'notification_message':
f"ericzheng tagged you in Channel 1: {msg1str[0:20]}"
}]
}
def test_share_pin(test_data):
a_data, b_data, _ = test_data
a_ch_id = channels_create_v2(a_data["token"], "A channel",
True)["channel_id"]
channel_join_v2(b_data["token"], a_ch_id)
b_dm_id = dm_create_v1(b_data["token"], [a_data["auth_user_id"]])["dm_id"]
a_msg_id = message_send_v2(a_data["token"], a_ch_id,
"Message to be shared to dm")["message_id"]
b_msgdm_id = message_senddm_v1(
b_data["token"], b_dm_id,
"Message to be shared to channel")["message_id"]
a_share_id = message_share_v1(a_data["token"], a_msg_id, "Shared a msg",
-1, b_dm_id)["shared_message_id"]
b_share_id = message_share_v1(b_data["token"], b_msgdm_id, "Shared a msg",
a_ch_id, -1)["shared_message_id"]
message_pin_v1(a_data["token"], b_share_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
assert messages[0]["message_id"] == b_share_id
assert messages[0]["is_pinned"] == True
message_pin_v1(b_data["token"], a_share_id)
messages = dm_messages_v1(b_data["token"], b_dm_id, 0)["messages"]
assert messages[0]["message_id"] == a_share_id
assert messages[0]["is_pinned"] == True
def test_channel_join_stat():
clear_v1()
result1 = auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
result2 = auth_register_v2('*****@*****.**', 'password', 'comp', 'student')
channel1 = channels_create_v2(result1['token'], "The party channel 1", True)
channel_join_v2(result2['token'], channel1['channel_id'])
output = user_stats(result1['token'])
output1 = user_stats(result2['token'])
dreams = users_stats(result1['token'])
assert len(output['user_stats']) == 4
assert output['user_stats']['channels_joined'][-1]['num_channels_joined'] == 1
assert output['user_stats']['dms_joined'][-1]['num_dms_joined'] == 0
assert output['user_stats']['messages_sent'][-1]['num_messages_sent'] == 0
assert output['user_stats']['involvement_rate'] == 1
assert len(output1['user_stats']) == 4
assert output1['user_stats']['channels_joined'][-1]['num_channels_joined'] == 1
assert output1['user_stats']['dms_joined'][-1]['num_dms_joined'] == 0
assert output1['user_stats']['messages_sent'][-1]['num_messages_sent'] == 0
assert output1['user_stats']['involvement_rate'] == 1
assert len(dreams['dreams_stats']) == 4
assert dreams['dreams_stats']['channels_exist'][-1]['num_channels_exist'] == 1
assert dreams['dreams_stats']['dms_exist'][-1]['num_dms_exist'] == 0
assert dreams['dreams_stats']['messages_exist'][-1]['num_messages_exist'] == 0
assert dreams['dreams_stats']['utilization_rate'] == 2/2
def test_auth_user_not_owner(test_data):
a_data, b_data, c_data = test_data
# channel
a_ch_id = channels_create_v2(a_data["token"], "A channel",
True)["channel_id"]
channel_join_v2(b_data["token"], a_ch_id)
channel_join_v2(c_data["token"], a_ch_id)
a_msg_id = message_send_v2(a_data["token"], a_ch_id,
"A message")["message_id"]
with pytest.raises(AccessError):
message_pin_v1(b_data["token"], a_msg_id)
message_pin_v1(c_data["token"], a_msg_id)
# dm
a_dm_id = dm_create_v1(
a_data["token"],
[b_data["auth_user_id"], c_data["auth_user_id"]])["dm_id"]
a_msgdm_id = message_senddm_v1(a_data["token"], a_dm_id,
"A message")["message_id"]
with pytest.raises(AccessError):
message_pin_v1(b_data["token"], a_msgdm_id)
message_pin_v1(c_data["token"], a_msgdm_id)
def test_change_non_author_non_dreams_owner_channel_owner(
reg_user, create_channel):
clear_v2()
# new user
reg_user(
0
) # Create first user, who is a dreams owner (for testing purposes, we want non-dreams-owners)
new_user = reg_user(1)
user_token = new_user['token']
new_user_2 = reg_user(2)
# new channel
channel_id = create_channel(user_token)['channel_id']
channel_join_v2(new_user_2['token'], channel_id)
# new message
message_id = message_send_v2(new_user_2['token'], channel_id,
"Hi Britney!")['message_id']
message = "Hello World!"
message_edit_v2(user_token, message_id, message)
messages = channel_messages_v2(user_token, channel_id, 0)['messages']
for msg in messages:
if msg['message_id'] == message_id:
assert msg['message'] == "Hello World!"
def test_timeout(test_data):
a_data, b_data, c_data, a_ch_id = test_data
channel_join_v2(b_data["token"], a_ch_id)
channel_join_v2(c_data["token"], a_ch_id)
message_send_v2(a_data["token"], a_ch_id, "/u simple")
# scrambler sends "Unscramble this! xxxxx"
# scrambler should time out after 10 seconds
sleep(11)
# no message should be sent in between the timeout
assert channel_messages_v2(
a_data["token"], a_ch_id,
0)["messages"][0]["message"][:len("Unscramble this! "
)] == "Unscramble this! "
message_send_v2(a_data["token"], a_ch_id, "red")
message_send_v2(a_data["token"], a_ch_id, "green")
message_send_v2(a_data["token"], a_ch_id, "blue")
# should only be 5 total messages as unscrambler should stop listening after 10 secs
assert len(channel_messages_v2(a_data["token"], a_ch_id,
0)["messages"]) == 5
# should still work after timeout
message_send_v2(a_data["token"], a_ch_id, "/u simple")
assert channel_messages_v2(
a_data["token"], a_ch_id,
0)["messages"][0]["message"][:len("Unscramble this! "
)] == "Unscramble this! "
def test_dm(test_data):
a_data, b_data, c_data, a_ch_id = test_data
channel_join_v2(b_data["token"], a_ch_id)
channel_join_v2(c_data["token"], a_ch_id)
# Create the unscramble user
message_send_v2(a_data["token"], a_ch_id, "/u start")
us_id = None
for user in users_all_v1(a_data["token"])["users"]:
if user["name_first"] == "Sinister" and user[
"name_last"] == "Scrambler":
us_id = user["u_id"]
a_dm_id = dm_create_v1(
a_data["token"],
[b_data["auth_user_id"], c_data["auth_user_id"]])["dm_id"]
dm_invite_v1(a_data["token"], a_dm_id, us_id)
message_senddm_v1(a_data["token"], a_dm_id, "/u start")
# latest message should be the one above.
# scrambler shouldnt send any messages
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u start"
message_senddm_v1(a_data["token"], a_dm_id, "/u leaderboard")
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u leaderboard"
message_senddm_v1(a_data["token"], a_dm_id, "/u simple")
assert dm_messages_v1(a_data["token"], a_dm_id,
0)["messages"][0]["message"] == "/u simple"
def test_channel_join_v2(user_setup, channel_setup):
channel_join_v2(make_token(2), 0)
assert channel_details_v2(make_token(2), 0) == {
'name': 'PublicChannel1',
'is_public': True,
'owner_members': [
{
'u_id': 1,
'email': "*****@*****.**",
'name_first': "Peter",
'name_last': "Tran",
'handle': "petertran"
},
],
'all_members': [
{
'u_id': 1,
'email': "*****@*****.**",
'name_first': "Peter",
'name_last': "Tran",
'handle': "petertran"
},
{
'u_id': 2,
'email': "*****@*****.**",
'name_first': "Christopher",
'name_last': "Luong",
'handle': "christopherluong"
}
]
}
def test_add_existing_owner(test_data):
_, a_data, b_data, c_data, a_ch_id, c_ch_id = test_data
channel_join_v2(b_data["token"], c_ch_id)
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
channel_addowner_v1(c_data["token"], c_ch_id, b_data["auth_user_id"])
"""
channel a
owners
a, b
members
a, b
channel c
owners
c, b
members
c, b
"""
with pytest.raises(InputError):
# adding themselves
channel_addowner_v1(a_data["token"], a_ch_id, a_data["auth_user_id"])
channel_addowner_v1(b_data["token"], a_ch_id, b_data["auth_user_id"])
channel_addowner_v1(b_data["token"], c_ch_id, b_data["auth_user_id"])
channel_addowner_v1(c_data["token"], c_ch_id, c_data["auth_user_id"])
# adding another owner
channel_addowner_v1(a_data["token"], a_ch_id, b_data["auth_user_id"])
channel_addowner_v1(b_data["token"], a_ch_id, a_data["auth_user_id"])
channel_addowner_v1(b_data["token"], c_ch_id, c_data["auth_user_id"])
channel_addowner_v1(c_data["token"], c_ch_id, b_data["auth_user_id"])
def test_channel_create_v2_public_False(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token']
token_2 = reg_user(1)['token']
channel_name = basic_channel_name
is_public = False
channel_id = channels_create_v2(token_1, channel_name, is_public)['channel_id']
with pytest.raises(AccessError):
channel_join_v2(token_2, channel_id) # should not be able to join a private ....
def test_global_owner(test_data):
global_owner, a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A\'s private", False)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B\'s private", False)["channel_id"]
c_ch_id = channels_create_v2(c_data["token"], "B\'s private", False)["channel_id"]
assert channel_join_v2(global_owner["token"], a_ch_id) == {}
assert channel_join_v2(global_owner["token"], b_ch_id) == {}
assert channel_join_v2(global_owner["token"], c_ch_id) == {}
def test_channel_leave_v1_non_valid_channel_id(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token'] #use v2 because we want tokens as well
token_2 = reg_user(1)['token']
channel_name = basic_channel_name
fake_channel_id = 'random values sdasdsadsadsawer'
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_join_v2(token_2, channel_id) #user is able to join a real channel
with pytest.raises(InputError):
channel_leave_v1(token_2, fake_channel_id) #channel does not exist cant leave it
def test_channel_leave_v1_token(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token'] #use v2 because we want tokens as well
token_2 = reg_user(1)['token']
channel_name = basic_channel_name
fake_token = 'random values'
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
channel_join_v2(token_2, channel_id)
with pytest.raises(AccessError):
channel_leave_v1(fake_token, channel_id)
def test_non_owner_remove_message_of_other_user(reg_user, crt_channel,
send_message):
clear_v2()
user_1_token = reg_user(0)['token']
user_2_token = reg_user(1)['token']
channel_id = crt_channel(user_1_token)['channel_id']
channel_join_v2(user_2_token, channel_id)
message_id = message_send_v2(user_1_token, channel_id,
"Test")['message_id']
with pytest.raises(AccessError):
message_remove_v1(user_2_token, message_id)
def test_successful_remove(create_input):
user_1, user_2, user_3, user_4, user_5 = create_input[0]
assert admin_user_remove_v1(user_1["token"], user_2["auth_user_id"]) == {}
assert admin_user_remove_v1(user_1["token"], user_3["auth_user_id"]) == {}
assert admin_user_remove_v1(user_1["token"], user_4["auth_user_id"]) == {}
assert admin_user_remove_v1(user_1["token"], user_5["auth_user_id"]) == {}
# check to see that these users are indeed removed
# only user_1 should be shown when calling users_all
assert users_all_v1(user_1["token"]) == {
"users":
[user_profile_v2(user_1["token"], user_1["auth_user_id"])["user"]]
}
# calling channels list should raise an input error as their u_id's are invalid
with pytest.raises(AccessError):
channels_list_v2(user_2["token"])
channels_list_v2(user_3["token"])
channels_list_v2(user_4["token"])
channels_list_v2(user_5["token"])
# Check to see each removed user's profile is retrievable and their name is
# now 'Removed user'
for user in [user_2, user_3, user_4, user_5]:
user_profile = user_profile_v2(user_1["token"], user["auth_user_id"])
assert type(user_profile) == dict
assert (
f"{user_profile['user']['name_first']}{user_profile['user']['name_last']}"
== "Removed user" or
f"{user_profile['user']['name_first']} {user_profile['user']['name_last']}"
== "Removed user")
# CHECK THAT MESSAGES SENT ARE 'REMOVED USER'
# check channel messages for user 2
channel_join_v2(user_1["token"], create_input[1][1]["channel_id"])
channel_1_messages = channel_messages_v2(user_1["token"],
create_input[1][1]["channel_id"],
0)
for message in channel_1_messages["messages"]:
if message["message_id"] == create_input[2][1]:
assert message["message"] == "Removed user"
# check channel messages for user 3
channel_join_v2(user_1["token"], create_input[1][0]["channel_id"])
channel_2_messages = channel_messages_v2(user_1["token"],
create_input[1][0]["channel_id"],
0)
for message in channel_2_messages["messages"]:
if message["message_id"] == create_input[2][2]:
assert message["message"] == "Removed user"
clear_v1()
def test_dreams_owner_remove_message_of_other_user(reg_user, crt_channel,
send_message):
clear_v2()
user_1_token = reg_user(0)['token'] # Dreams owner
user_2_token = reg_user(1)['token']
channel_id = crt_channel(user_1_token)['channel_id']
channel_join_v2(user_2_token, channel_id)
message_id = send_message(user_2_token, channel_id)['message_id']
message_remove_v1(user_1_token, message_id)
messages = channel_messages_v2(user_1_token, channel_id, 0)['messages']
assert not len(messages)
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"]) == {}
assert channel_join_v2(create_input[0][2]["token"],
create_input[1][0]["channel_id"]) == {}
# length of *_members for First Channel before add
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 1
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["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"]) == {}
# 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"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][0]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 3
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][1]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 3
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][0]["channel_id"])["owner_members"]) == 2
assert len(
channel_details_v2(
create_input[0][2]["token"],
create_input[1][0]["channel_id"])["all_members"]) == 3
# number of channels each user is a part of
assert len(channels_list_v2(create_input[0][0]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][1]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][2]["token"])["channels"]) == 2
assert len(channels_list_v2(create_input[0][3]["token"])["channels"]) == 1
assert len(channels_list_v2(create_input[0][4]["token"])["channels"]) == 0
def test_standup_start_v1_another_user_cant_start_standup_when_standup_running(reg_user, basic_channel_name):
clear_v2()
token_1 = reg_user(0)['token']
joined_user_token = reg_user(1)['token']
channel_name = basic_channel_name
channel_id = channels_create_v2(token_1, channel_name, True)['channel_id']
standup_length = 10
channel_join_v2(joined_user_token, channel_id)
standup_start_v1(token_1, channel_id, standup_length)
with pytest.raises(InputError):
standup_start_v1(joined_user_token, channel_id, standup_length) # standup already running in the channel
def test_channels_create_public():
# Test creating a public channel
# User should be able to join if public
clear_v1()
owner = auth_register_v2("*****@*****.**", "password", "Steve",
"Jones")['token']
user_2 = auth_register_v2("*****@*****.**", "password", "Bob",
"Fisher")['token']
pub_channel = channels_create_v2(owner, "Public Channel",
True)['channel_id']
# User should join successfully
channel_join_v2(user_2, pub_channel)
def test_channels_create_private():
# Test creating a private channel
# User should not be able to join private server
clear_v1()
owner = auth_register_v2("*****@*****.**", "password", "David",
"Folly")['token']
user_2 = auth_register_v2("*****@*****.**", "password", "Ben",
"Stevens")['token']
private_channel = channels_create_v2(owner, "Private Channel",
False)['channel_id']
# Unauthorised user should not be able to join private server
with pytest.raises(AccessError):
channel_join_v2(user_2, private_channel)
def test_tag_edit():
clear_v1()
user1 = auth_register_v2("*****@*****.**", "finalpassword", "Eric",
"Zheng")
user2 = auth_register_v2("*****@*****.**", "validpassword", "Josh",
"Hatton")
channel1 = channels_create_v2(user1['token'], 'Channel 1', True)
channel_join_v2(user2['token'], channel1['channel_id'])
msg1str = "Hi friend"
msg1 = message_send_v2(user1['token'], channel1['channel_id'], msg1str)
assert len(notifications_get_v1(user2['token'])['notifications']) == 0
message_edit_v2(user1['token'], msg1['message_id'], "@joshhatton")
assert len(notifications_get_v1(user2['token'])['notifications']) == 1
def test_not_owner():
"""
AccessError when the authorised user is not an owner
"""
clear_v1()
user_1 = auth_register_v2("*****@*****.**", "asdjf~!", "Rengoku",
"Kyojuro")
user_2 = auth_register_v2("*****@*****.**", "boogie123", "Luffy",
"Monkey")
channel_1 = channels_create_v2(user_1["token"], "Hashira", True)
channel_join_v2(user_2["token"], channel_1["channel_id"])
with pytest.raises(AccessError):
userpermission_change_v1(user_2["token"], user_2["auth_user_id"], 2)
def test_joined_user_is_member(
reg_user, crt_channel): # Give valid user_id and channel_id
clear_v2()
auth_user_token = reg_user(0)['token']
channel_id = crt_channel(auth_user_token, True)['channel_id']
joined_user = reg_user(1)
channel_join_v2(joined_user['token'], channel_id)
channel_details = channel_details_v2(auth_user_token, channel_id)
joined_user_found = False
for user in channel_details['all_members']:
if joined_user['auth_user_id'] == user['u_id']:
joined_user_found = True
assert joined_user_found # Verify that joined user is in channel's all_members list
def test_invalid_permission_id():
"""
InputError when permission_id does not refer to a value permission
"""
clear_v1()
user_1 = auth_register_v2("*****@*****.**", "asdjf~!", "Rengoku",
"Kyojuro")
user_2 = auth_register_v2("*****@*****.**", "boogie123", "Luffy",
"Monkey")
channel_1 = channels_create_v2(user_1["token"], "Hashira", True)
channel_join_v2(user_2["token"], channel_1["channel_id"])
with pytest.raises(InputError):
userpermission_change_v1(user_2["token"], user_2["auth_user_id"], 34)
def test_standup_send_v1():
clear_v1()
auth_user_1_data = auth_register_v2("*****@*****.**", "123456", "Andy",
"Dandy")
auth_user_1_token = auth_user_1_data["token"]
auth_user_1_id = auth_user_1_data["auth_user_id"]
auth_user_1_handle = user_profile_v2(auth_user_1_token,
auth_user_1_id)["user"]["handle_str"]
auth_user_2_data = auth_register_v2("*****@*****.**", "123456", "Bob",
"Hobs")
auth_user_2_token = auth_user_2_data["token"]
auth_user_2_id = auth_user_2_data["auth_user_id"]
auth_user_2_handle = user_profile_v2(auth_user_2_token,
auth_user_2_id)["user"]["handle_str"]
auth_user_3_data = auth_register_v2("*****@*****.**", "123456", "Chris",
"Wiz")
auth_user_3_token = auth_user_3_data["token"]
auth_user_3_id = auth_user_3_data["auth_user_id"]
auth_user_3_handle = user_profile_v2(auth_user_3_token,
auth_user_3_id)["user"]["handle_str"]
channel_id_1 = channels_create_v2(auth_user_1_token, "Andys channel",
True)["channel_id"]
channel_join_v2(auth_user_2_token, channel_id_1)
channel_join_v2(auth_user_3_token, channel_id_1)
finish_time = standup_start_v1(auth_user_1_token, channel_id_1,
3)["time_finish"]
standup_send_v1(auth_user_1_token, channel_id_1, "Hello")
standup_send_v1(auth_user_2_token, channel_id_1, "Hi")
standup_send_v1(auth_user_3_token, channel_id_1, "Hey")
message_list = channel_messages_v2(auth_user_1_token, channel_id_1,
0)["messages"]
assert len(message_list) == 0
time.sleep(finish_time - time.time() + 1)
message_list = channel_messages_v2(auth_user_1_token, channel_id_1,
0)["messages"]
assert len(message_list) == 1
assert message_list[0]["u_id"] == auth_user_1_id
message_sent_after_standup = f"""{auth_user_1_handle}: Hello
{auth_user_2_handle}: Hi
{auth_user_3_handle}: Hey"""
assert message_list[0]["message"] == message_sent_after_standup
def test_multiple_owners_to_members(create_input):
""" Tests for demoting multiple owners to members.
"""
user_1, user_2, user_3, user_4, user_5 = create_input[0]
private_channel = create_input[1][2]
# make user 2,3,4 all owners
assert admin_userpermission_change_v1(user_1['token'],
user_2['auth_user_id'], 1) == {}
assert admin_userpermission_change_v1(user_1['token'],
user_3['auth_user_id'], 1) == {}
assert admin_userpermission_change_v1(user_1['token'],
user_4['auth_user_id'], 1) == {}
# as user 2, demote user1,3,4
assert admin_userpermission_change_v1(user_2['token'],
user_1['auth_user_id'], 2) == {}
assert admin_userpermission_change_v1(user_2['token'],
user_3['auth_user_id'], 2) == {}
assert admin_userpermission_change_v1(user_2['token'],
user_4['auth_user_id'], 2) == {}
# user1,3,4,5 should not be able to join private channels
with pytest.raises(AccessError):
channel_join_v2(user_1['token'], private_channel['channel_id'])
channel_join_v2(user_3['token'], private_channel['channel_id'])
channel_join_v2(user_4['token'], private_channel['channel_id'])
channel_join_v2(user_5['token'], private_channel['channel_id'])
def test_channel_pin(test_data):
a_data, b_data, c_data = test_data
a_ch_id = channels_create_v2(a_data["token"], "A channel",
True)["channel_id"]
b_ch_id = channels_create_v2(b_data["token"], "B channel",
True)["channel_id"]
channel_join_v2(c_data["token"], a_ch_id)
channel_join_v2(c_data["token"], b_ch_id)
# pin own message
a1_msg_id = message_send_v2(a_data["token"], a_ch_id,
"My own message")["message_id"]
message_pin_v1(a_data["token"], a1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# we know there is only one message sent, so it must be index 0 of messages
assert messages[0]["message_id"] == a1_msg_id
assert messages[0]["is_pinned"] == True
# pin someone elses message
c1_msg_id = message_send_v2(c_data["token"], a_ch_id,
"C's message")["message_id"]
message_pin_v1(a_data["token"], c1_msg_id)
messages = channel_messages_v2(a_data["token"], a_ch_id, 0)["messages"]
# channel_messages is most recent message first
assert messages[0]["message_id"] == c1_msg_id
assert messages[0]["is_pinned"] == True
# b_ch
b1_msg_id = message_send_v2(b_data["token"], b_ch_id,
"B's message whoo")["message_id"]
message_pin_v1(b_data["token"], b1_msg_id)
messages = channel_messages_v2(b_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == b1_msg_id
assert messages[0]["is_pinned"] == True
channel_addowner_v1(b_data["token"], b_ch_id, c_data["auth_user_id"])
c2_msg_id = message_send_v2(c_data["token"], b_ch_id,
"C's second message whoo")["message_id"]
message_pin_v1(c_data["token"], c2_msg_id)
messages = channel_messages_v2(c_data["token"], b_ch_id, 0)["messages"]
assert messages[0]["message_id"] == c2_msg_id
assert messages[0]["is_pinned"] == True
def test_global_owner_join_private_channel(
reg_user,
crt_channel): # Global owner should be able to join private channel
clear_v2()
global_owner = reg_user(0)
auth_user_token = reg_user(1)['token']
channel_id = crt_channel(auth_user_token, False)['channel_id']
channel_join_v2(global_owner['token'], channel_id)
channel_details = channel_details_v2(auth_user_token, channel_id)
global_owner_found = False
for user in channel_details['all_members']:
if global_owner['auth_user_id'] == user['u_id']:
global_owner_found = True
assert global_owner_found # Verify that global owner user is in channel's all_members list
