def message_react(token, message_id, react_id):
"""
Given a message within a channel the authorised user is part of,
add a "react" to that particular message.
"""
u_id = get_current_user(token)
# React_id check
if react_id != 1:
raise InputError(description='react_id is not a valid React ID.' +
'The only valid react ID the frontend has is 1')
# Check user is in channel they are reacting in and if they are,
# execute.
if user_in_message_channel(message_id, u_id) is True:
message_file = get_message(message_id)
u_id_to_react = next(
(i for i in message_file['reacts'][0]['u_ids'] if u_id == i),
False)
if u_id_to_react is not False:
# This user has already reacted.
raise InputError(description='Message with ID message_id already' +
'contains an active React with ID react_id')
else:
# User has not already reacted.
message_file['reacts'][0]['u_ids'].append(u_id)
return {}
def test_hangmne_normal():
"""
Test if hangman can start with correct input
"""
user_infor = auth_register("*****@*****.**", "ccc337992611", "Min",
"Li")
channel_infor = channels_create(user_infor['token'], 'test_one', True)
time_create_date = datetime.datetime.now().replace(microsecond=0)
time_create = time_create_date.timestamp()
message_id = message_send(user_infor['token'], channel_infor['channel_id'],
"/hangman")
assert search(BOT_TOKEN,
"A game of hangman has been started in this channel") == {
"messages": [{
'message_id': message_id["message_id"] + 1,
'u_id': -1,
'message':
"A game of hangman has been started in this channel",
'time_created': time_create,
'reacts': [set_reacts()],
'is_pinned': False
}]
}
auth_logout(BOT_TOKEN)
message_id = message_send(user_infor['token'], channel_infor['channel_id'],
"/guess e")
assert database.get_current_user(BOT_TOKEN) == -1
def message_unreact(token, message_id, react_id):
"""
Given a message within a channel the authorised user is part of,
remove a "react" to that particular message.
"""
# Token check
u_id = get_current_user(token)
# React_id check
if react_id != 1:
raise InputError(description='react_id is not a valid React ID.' +
'The only valid react ID the frontend has is 1')
# Check user is in channel they are reacting in and if they are,
# execute.
if user_in_message_channel(message_id, u_id) is True:
message_file = get_message(message_id)
u_id_to_unreact = next(
(i for i in message_file['reacts'][0]['u_ids'] if u_id == i), None)
if u_id_to_unreact is not None:
# If there was a react from the user.
message_file['reacts'][0]['u_ids'].remove(u_id)
else:
# If there wasn't a react from the user.
raise InputError(
description='Message with ID message_id does not' +
'contain an active React with ID react_id')
return {}
def change_user_permission(token, u_id, permission_id):
"""
Given a User by their user ID, set their permissions
to new permissions described by permission_id
"""
# Store u_id of person running command
user_from_token = database.get_current_user(token)
if permission_id not in VALID_PERMISSION_IDS.values():
raise error.InputError(description="permission_id does not refer to a value permission")
if (database.get_permission_dict(user_from_token).get("permission_id")
!= VALID_PERMISSION_IDS['owner']):
# User is not a global owner.
raise error.AccessError(description="The authorised user is not an owner")
number_of_owners = 0
for member in database.get_permissions_list():
if member.get('permission_id') == VALID_PERMISSION_IDS['owner']:
number_of_owners += 1
if (u_id == user_from_token and number_of_owners == 1):
# i.e. Owner calling this function is only owner.
raise error.AccessError(description="Owner cannot remove" +
" permissions when he is the only owner")
# Now, having checked for all errors, run function:
database.set_permissions(u_id, permission_id)
def message_sendlater(token, channel_id, message, time_sent):
"""
Send a message from authorised_user to the channel specified by
channel_id automatically at a specified time in the future.
"""
u_id = get_current_user(token)
if is_user_channel_member(channel_id, u_id) is False:
raise AccessError(description='The authorised user has not ' +
'joined the channel they are trying to post to')
# raise error if the message is longer than 1000 or empty string is given.
if len(message) > 1000:
raise InputError(description='Message is more than 1000 characters')
if message == '':
raise InputError(description='Cannot send an empty message')
time_now_datetime = datetime.now().replace(microsecond=0)
time_now = time_now_datetime.timestamp()
if time_now > time_sent:
raise InputError(description='Time sent is a time in the past')
else:
# Run sendlater
time_diff = time_sent - time_now
time.sleep(time_diff)
return message_send(token, channel_id, message)
def standup_send(token, channel_id, message):
""" Add a message to standup queue """
# If token is valid, take u_id which is used to look through users
u_id = database.get_current_user(token)
# Check if user is member of channel that message is within
# if not then raise an AccessError
channel_data = database.get_channel_data(channel_id)
if u_id not in channel_data['member_ids']:
raise error.AccessError(
description="You are not a member of this channel")
# Check if message if more than 1000 characters long and raise InputError if that is the case
if len(message) > 1000:
raise error.InputError(
description="The message entered is more than 1000 characters long"
)
# Check if standup is currently active in channel, raise InputError if not
if standup_active(token, channel_id)['is_active'] is False:
raise error.InputError(
description="There are no standups active in this channel")
# Format message to "handle_str: message"
handle_str = database.get_user_data(u_id)['handle_str']
string = handle_str + ": " + message
# Now add string to the appropriate list in queues
QUEUES[str(channel_id)].append(string)
return {}
def message_remove(token, message_id):
"""
Given a message_id for a message, this message is removed from the channel.
"""
u_id = get_current_user(token)
message_location = get_message_location(message_id)
channel_id = message_location["channel_id"]
channel_data = get_channel_data(channel_id)
if u_id not in channel_data['member_ids']:
raise AccessError(
description="User must be a member of the channel they are trying"
+ " to access.")
# Find the message to be deleted. At this point
# The message definitely exists and the user is definitely a member of the channel
# it exists in.
for message in channel_data["messages"]:
if message['message_id'] == message_id:
if message["u_id"] != u_id and get_permission_dict(u_id).get(
'permission_id') != 1:
raise AccessError(
description="Authorised user did not send the message " +
"and is not a server/channel owner.")
else:
remove_message(message_id)
return {}
def message_send(token, channel_id, message):
"""
Grab information from the frontend chat bar and send it.
"""
u_id = get_current_user(token)
if is_user_channel_member(channel_id, u_id) is False:
raise AccessError(description='The authorised user has not ' +
'joined the channel they are trying to post to')
# raise error if the message is longer than 1000 or empty string is given.
if len(message) > 1000:
raise InputError(description='Message is more than 1000 characters')
if message == '':
raise InputError(description='Cannot send an empty message')
# Now parse the message
message_id = message_parser.parse_message(u_id, channel_id, message)
check_command(channel_id, message)
return {
"message_id": message_id,
}
def message_unpin(token, message_id):
"""
Given a message within a channel, remove it's mark as unpinned.
"""
u_id = get_current_user(token)
message_location = get_message_location(message_id)
message_file = get_message(message_id)
################### START ERROR CHECKS ############################
channel_data = get_channel_data(message_location['channel_id'])
check = next((i for i in channel_data['member_ids'] if i == u_id), False)
if check is False:
raise AccessError(description='The authorised user is not ' +
'a member of the channel that the message is within')
if u_id not in channel_data['owner_ids']:
raise AccessError(description='The authorised user is not an owner')
##################### END ERROR CHECKS ########################
if message_file['is_pinned'] is False:
raise InputError(
description='Message with ID message_id is already unpinned')
else:
message_file['is_pinned'] = False
return {}
def user_profile_setemail(token, email):
"""
Given input for email sets user's email if valid and not taken
"""
users = database.get_users()
for user in users:
if user['email'] is email:
raise error.InputError(description="This email is already taken")
u_id = database.get_current_user(token)
user = database.get_user_data(u_id)
user['email'] = email
database.set_user_data(user)
def user_profile_sethandle(token, handle_str):
"""
given input for a handle name set user's handle
"""
if (len(handle_str) > 20 or len(handle_str) < 2):
raise error.InputError(
description="Handle is not within 2-20 characters")
users = database.get_users()
for user in users:
if user['handle_str'] is handle_str:
raise error.InputError(description="Handle is already taken")
u_id = database.get_current_user(token)
user = database.get_user_data(u_id)
user['handle_str'] = handle_str
database.set_user_data(user)
def user_profile_uploadphoto(token, img_url, x_start, y_start, x_end, y_end):
"""
given url of image on the internet, crops it within bounds.
"""
# pylint: disable=too-many-arguments
# This pylint warning is supressed because the function requires 6 arguments
# Get the image from img_url and check if HTTP status of 200 returned
try:
req = urllib.request.Request(img_url,
headers={'User-Agent': 'Mozilla/5.0'})
response = urllib.request.urlopen(req)
except:
raise error.InputError(
description="The image could not be opened from the given url")
# Open the image, check if x and y are within dimensions of the image
img = Image.open(response)
width, height = img.size
if x_start < 0 or y_start < 0 or x_end > width or y_end > height:
raise error.InputError(
description="Bounds given exceed the dimensions of the image")
# Check if image type if a JPG
if img.format != "JPEG":
raise error.InputError(description="Image given is not of JPG type")
# Crop the image to the correct dimensions
img = img.crop((x_start, y_start, x_end, y_end))
# Get u_id from token
u_id = database.get_current_user(token)
img_path = os.path.join(os.path.dirname(__file__), f"static/{u_id}.jpg")
# Save the image in the static directory
# image saved as {u_id}.jpg
img.save(img_path)
# serve image from file
profile_img_url = url_for('static', filename=f"{u_id}.jpg", _external=True)
# Add profile_img_url to database
user = database.get_user_data(u_id)
user['profile_img_url'] = profile_img_url
database.set_user_data(user)
return {}
def channels_list(token):
""" Returns {channels}, where channels is a list of channels that the user is part of.
i.e. {'channels': [{channel_id, name}, {channel_id, name}]} """
u_id = database.get_current_user(token)
output = {'channels': []}
# obtain channels so that I can see lists of members
# insert channel into the output list if user is a member
for channel in database.get_channels():
channeldata = database.get_channel_data(channel['channel_id'])
if u_id in channeldata['member_ids']:
output['channels'].append(channel)
return output
def wrapper_func(*args, **kwargs):
""" Wrapper function """
try:
token_arg_index = argspec.args.index("token")
# Check the token is valid.
if database.get_current_user(args[token_arg_index]) is None:
# Token is invalid
raise error.AccessError(
description="Current token is not valid.")
else:
return func(*args, **kwargs)
except ValueError:
print("\033[93m" +
"WARNING: Token arg not found - running function " +
f"{func.__name__} without token check." + "\033[0m")
return func(*args, **kwargs)
def user_profile_setname(token, name_first, name_last):
"""
Given input for first and last name sets user's firtname and lastname if within character limit
"""
if (len(name_first) > 50 or name_first == ""):
raise error.InputError(
description="First name is not within 1-50 characters")
if (len(name_last) > 50 or name_last == ""):
raise error.InputError(
description="Last name is not within 1-50 characters")
u_id = database.get_current_user(token)
user = database.get_user_data(u_id)
user['name_first'] = name_first
user['name_last'] = name_last
database.set_user_data(user)
def channel_addowner(token, channel_id, u_id):
"""
This function intakes the token of current authorised (auth) user, channel_id and a user u_id
It then adds the user u_id as an owner of the channel,
as long as the current auth user is an owner of slackr/channel
"""
# Check if token is valid and raise AccessError if not
curr_id = database.get_current_user(token)
# gets current channel data
curr_channel = database.get_channel_data(channel_id)
# gets the permissions of current user from database
user_perms = database.get_permission_dict(curr_id)
# check if user u_id is already an owner of the channel and raise InputError if so
# also checks to see if current auth user is a owner of channel
# a counter to check if user is a member of the channel
is_curr_owner = False
for owner_id in curr_channel["owner_ids"]:
if u_id == owner_id:
raise error.InputError(description="user u_id is already an owner of this channel")
# checks if curr_id is an owner of channel
if curr_id == owner_id:
is_curr_owner = True
# checks if the user u_id is a member of the channel already
is_u_member = False
for member_id in curr_channel["member_ids"]:
if u_id == member_id:
is_u_member = True
# if the auth user is an owner of the slackr, allow him to add u_id as owner of channel
if is_u_member is True:
if user_perms["permission_id"] == 1:
# adds the user into channel_owner
curr_channel["owner_ids"].append(u_id)
# if the auth user is an owner of the channel, allow him to add u_id as owner of channel
elif is_curr_owner is True:
# adds the user into channel_owner
curr_channel["owner_ids"].append(u_id)
# else the auth user is not an owner and thus cannot use addowner
else:
raise error.AccessError(description="""current user is not an owner of the channel,
or of the slackr""")
def remove_user(token, u_id):
""" Given a u_id, remove the user from the Slackr. """
# we get the current user data
terminator = database.get_current_user(token)
# Raise AccessError if user is not an owner of the Slackr
terminator_perm = database.get_permission_dict(terminator)
if terminator_perm['permission_id'] != 1:
raise error.AccessError(description="""Action cannot be performed
because you are not a Slackr owner.""")
# Do a soft remove
# they stay a part of everything, but they are removed from owner/memberID
# in channels, and they are also banned from ever logging in again.
# we get the token of the user to be removed
# introduce a new permission ID 66:
# terminated and set the user to be removed to perm_id 66: terminated
terminated_id = 66
database.set_permissions(u_id, terminated_id)
# remove the user from every channel's member_id and owner_id
#first we call a list of every channel
all_channels = database.get_channels()
# we then get the data for each channel
for each_channel in all_channels:
channel_data = database.get_channel_data(each_channel["channel_id"])
# remove user u_id from owner_ids
for owner_id in channel_data['owner_ids']:
if u_id == owner_id:
channel.channel_removeowner(token, channel_data["channel_id"], u_id)
# remove user u_id from member_ids
if u_id in channel_data['member_ids']:
channel_data['member_ids'].remove(u_id)
database.set_channel_data(channel_data)
# finally we log the user out of the session (invalidating terminated token)
terminated_token = database.get_token_from_user(u_id)
if terminated_token is not None:
auth.auth_logout(terminated_token)
def channel_details(token, channel_id):
"""
This function is given a valid token and channel_id.
It then returns the name, owners and members of the channel
"""
# Check if token is valid and raise AccessError if not
curr_id = database.get_current_user(token)
# check if user is a member of channel with channel_ID and return AccessError if not
if is_user_channel_member(channel_id, curr_id) is False:
raise error.AccessError(description="""You must be a member of the channel to view its
details.""")
# now we return the name, owners and members of the channel
details = {"name": "", "owner_members": [], "all_members": []}
# for owner/all_members we need a list of dictionaries containing u_id, first name and last name
# {"u_id": [], "name_first": "", "name_last": ""}
channel = database.get_channel(channel_id)
members = database.get_channel_data(channel_id)
details["name"] = channel["name"]
for user_id in members["owner_ids"]:
owner_id = user_id
user_data = database.get_user_data(owner_id)
name_first = user_data["name_first"]
name_last = user_data["name_last"]
profile_img_url = user_data['profile_img_url']
details["owner_members"].append({"u_id": owner_id, "name_first": name_first,
"name_last": name_last,
"profile_img_url": profile_img_url})
for user_id in members["member_ids"]:
member_id = user_id
user_data = database.get_user_data(member_id)
name_first = user_data["name_first"]
name_last = user_data["name_last"]
profile_img_url = user_data['profile_img_url']
details["all_members"].append({"u_id": member_id, "name_first": name_first,
"name_last": name_last,
"profile_img_url": profile_img_url})
return details
def channel_removeowner(token, channel_id, u_id):
"""
This function intakes the token of current authorised (auth) user, channel_id and a user u_id
It then removes the user u_id as an owner of the channel,
as long as the current auth user is an owner of slackr/channel
and the user u_id is an owner
"""
# Check if token is valid and raise AccessError if not
curr_id = database.get_current_user(token)
# gets current channel data
curr_channel = database.get_channel_data(channel_id)
# gets the permissions of current user from database
user_perms = database.get_permission_dict(curr_id)
u_id_permission = database.get_permission_dict(u_id)
if u_id_permission["permission_id"] == 1:
raise error.AccessError(description="user being removed is the owner of the slackr")
# checks if u_id is not an owner of the channel
# also checks if current auth user is an owner of the channel
is_u_owner = False
is_curr_owner = False
for owner_id in curr_channel["owner_ids"]:
if u_id == owner_id:
is_u_owner = True
if curr_id == owner_id:
is_curr_owner = True
if is_u_owner is False:
raise error.InputError(description="user being removed is not an owner of the channel")
# if the auth user is owner of slackr, allows him to remove u_id as owner
if user_perms["permission_id"] == 1:
# removes the user from channel_owner
curr_channel["owner_ids"].remove(u_id)
# if the auth user is an owner of the channel, allow him to remove u_id as owner of channel
elif is_curr_owner is True:
# adds the user into channel_owner
curr_channel["owner_ids"].remove(u_id)
# else the auth user is not an owner and thus cannot use addowner
else:
raise error.AccessError(description="""Authorised user user is not an owner of the channel,
or of the slackr""")
def message_edit(token, message_id, message):
"""
Given a message, update it's text with new text.
If the new message is an empty string, the message is deleted.
"""
u_id = get_current_user(token)
message_location = get_message_location(message_id)
# if message is longer than 1000 an Inputerror should be raised.
if len(message) > 1000:
raise InputError(
description=
'Message is more than 1000 characters or try to send an empty message'
)
channel_id = message_location["channel_id"]
channel_data = get_channel_data(channel_id)
if u_id not in channel_data['member_ids']:
raise AccessError(
description="User must be a member of the channel they are trying"
+ " to access.")
# Find the message to be deleted (assume it definitely exists)
msg_to_edit = next(msg for msg in channel_data['messages']
if msg['message_id'] == message_id)
if msg_to_edit['u_id'] != u_id and get_permission_dict(
u_id)['permission_id'] != 1:
raise AccessError(
description="Authorised user did not send the message " +
"and is not a server/channel owner.")
if message == '':
remove_message(message_id)
else:
msg_to_edit['message'] = message
set_message(channel_id, msg_to_edit)
return {}
def channel_invite(token, channel_id, u_id):
"""
Invites a user (with user id u_id) to join a channel with
ID channel_id. Once invited the user is added to the channel immediately
"""
if database.get_current_user(token) not in database.get_channel_data(channel_id)['member_ids']:
raise error.AccessError(description="""Authorised user is not
a member of channel with that channel_id.""")
if u_id in database.get_channel_data(channel_id).get('member_ids'):
raise error.InputError(description="This user is already a part of the channel.")
new_channel_data = database.get_channel_data(channel_id)
new_channel_data['member_ids'].append(u_id)
if database.get_permission_dict(u_id).get('permission_id') == 1:
new_channel_data['owner_ids'].append(u_id)
database.set_channel_data(new_channel_data)
return {}
def channel_join(token, channel_id):
"""
this function is passed a valid token and channel_id.
It adds the user associated with the token into the channel, unless the channel is private
"""
# Check if token is valid and raise AccessError if not
curr_id = database.get_current_user(token)
# gets current channel data
curr_channel = database.get_channel_data(channel_id)
# gets the permissions of current user from database
user_perms = database.get_permission_dict(curr_id)
# checks if user is already a part of channel
for user_id in curr_channel["member_ids"]:
if curr_id == user_id:
raise error.InputError(description="user is joining a channel user is already in")
# this checks if the channel is empty (or new) in this case we make the new member an owner.
if curr_channel["member_ids"] == []:
# adds the user into channel_member
curr_channel["member_ids"].append(curr_id)
# adds the user into channel_owner
curr_channel["owner_ids"].append(curr_id)
# this checks if the user is an owner of the slacker
# if they are they are given owner privelages in the channel
# else they are a member
elif user_perms["permission_id"] == 1:
# adds the user into channel_member
curr_channel["member_ids"].append(curr_id)
# adds the user into channel_owner
curr_channel["owner_ids"].append(curr_id)
elif curr_channel["is_public"] is True:
# adds the user into the channel_member
curr_channel["member_ids"].append(curr_id)
elif curr_channel["is_public"] is False:
raise error.InputError(description="""channel_join recieved a channel_id
for a private channel""")
def channel_leave(token, channel_id):
"""
This function takes in a token and channel ID.
if both are valid, it will then remove the member from channel
"""
# Check if token is valid and raise AccessError if not
curr_id = database.get_current_user(token)
# check if user is a member of channel with channel_ID and return AccessError if not
user_channel = is_user_channel_member(channel_id, curr_id)
if user_channel is False:
raise error.AccessError(description="user is not a member of this channel")
# remove user with u_id from the channel (from member_ids)
curr_channel = database.get_channel_data(channel_id)
curr_channel["member_ids"].remove(curr_id)
# if user is an owner it removes them as an owner as well
for owner_id in curr_channel["owner_ids"]:
if owner_id == curr_id:
curr_channel["owner_ids"].remove(curr_id)
database.set_channel_data(curr_channel)
def channel_messages(token, channel_id, start):
"""
Retrieve a set of 50 or less messages from the channel.
Returns a {messages, start, end} dictionary.
"""
# Check if token is valid and raise AccessError if not
curr_id = database.get_current_user(token)
# check if user is a member of channel with channel_ID and return AccessError if not
if is_user_channel_member(channel_id, curr_id) is False:
raise error.AccessError(description="user is not a member of this channel")
#get channel data
curr_channel = database.get_channel_data(channel_id)
# find the length of messages
messages_length = len(curr_channel["messages"])
# if start is after the oldest message in messages InputError is raised
# if messages is called and start is 0 on an empty channel, it returns an empty channel.
# if start is after the oldest message in messages InputError is raised
if messages_length <= start and (messages_length != 0 or start > 0):
raise error.InputError(description="""The start value selected is
past the oldest message in the list""")
if messages_length == 0 and start == 0:
return {"messages": [], "start": start, "end": -1}
# get the list of dictionaries 'message'
curr_messages = curr_channel["messages"]
messages_returned = []
end = start + 50
num_msgs_to_check = messages_length - start
# If end is larger than the total no. of messages,
# the function will print till end and return -1
if num_msgs_to_check < 50:
counter = 0
while counter < num_msgs_to_check:
target_message_index = start + counter
messages_returned.append(curr_messages[target_message_index])
counter += 1
end = -1
# else if end is within total no of messages,
# function will print 50 messaages from start and return start + 50
else:
# loop to add each message to return up till 50 messages is returned
counter = 0
while counter < 50:
target_message_index = start + counter
messages_returned.append(curr_messages[target_message_index])
counter += 1
for msg in messages_returned:
for react in msg['reacts']:
react['is_this_user_reacted'] = curr_id in react['u_ids']
return {"messages": messages_returned, "start": start, "end": end}
def test_remove_user():
"""
Tests if user_remove correctly removes a user from the required parts of database:
-retained in USERS, PASSWORD_DATA_LIST and in CHANNEL_DATA_LIST (for messages)
-permission_id of user is now terminated (66)
-removed from:
CURRENT_USERS,
CHANNELS[owner_id]/[member_ID],
"""
# establish a test register
test_dict = auth.auth_register("*****@*****.**", "password", "Bob", "Ross")
# valid channel ID (assigned by channels_create)
c_id_dict = channels.channels_create(test_dict["token"], "test rum ham", True)
# create a second user and add them to the channel as an owner
test_dict_2 = auth.auth_register("*****@*****.**", "password2", "James", "May")
channel.channel_join(test_dict_2["token"], c_id_dict["channel_id"])
channel.channel_addowner(test_dict["token"], c_id_dict["channel_id"], test_dict_2["u_id"])
# store our details before the leave
details_before = channel.channel_details(test_dict["token"], c_id_dict["channel_id"])
# ensure there are two members: test_dict & test_dict_2
assert len(details_before["all_members"]) == 2
assert details_before["all_members"][0]["u_id"] == test_dict["u_id"]
assert details_before["all_members"][1]["u_id"] == test_dict_2["u_id"]
#ensure there are two owners: test_dict & test_dict_2
assert len(details_before["owner_members"]) == 2
assert details_before["owner_members"][0]["u_id"] == test_dict["u_id"]
assert details_before["owner_members"][1]["u_id"] == test_dict_2["u_id"]
# now we send a message to test rum ham
message.message_send(test_dict_2["token"], c_id_dict["channel_id"], "hello world")
# test that messages successfully returns the message
sent_messages = channel.channel_messages(test_dict["token"], c_id_dict["channel_id"], 0)
assert sent_messages["messages"][0]["message"] == "hello world"
######## Now we call the user_remove function:
admin.remove_user(test_dict["token"], test_dict_2["u_id"])
########
# we test that they still remain in user
all_users = database.get_users()
assert len(all_users) == 2
assert all_users[0]["u_id"] == test_dict["u_id"]
assert all_users[1]["u_id"] == test_dict_2["u_id"]
# we test that their messages can still be printed
messages_post_remove = channel.channel_messages(test_dict["token"], c_id_dict["channel_id"], 0)
assert messages_post_remove["messages"][0]["message"] == "hello world"
assert messages_post_remove["messages"][0]["u_id"] == test_dict_2["u_id"]
# we test that their permission is changed to 66
terminated_id = 66
permissions_post_remove = database.get_permission_dict(test_dict_2["u_id"])
assert permissions_post_remove["u_id"] == test_dict_2["u_id"]
assert permissions_post_remove["permission_id"] == terminated_id
# we test that they are no longer a part of CURRENT_USERS,
assert database.get_current_user(test_dict_2["token"]) is None
# we test that they are no longer a part of CHANNELS[owner_id]/[member_ID],
details_after = channel.channel_details(test_dict["token"], c_id_dict["channel_id"])
# ensure there is one member: test_dict
assert len(details_after["all_members"]) == 1
assert details_after["all_members"][0]["u_id"] == test_dict["u_id"]
# ensure there is one owner: test_dict
assert len(details_after["owner_members"]) == 1
assert details_after["owner_members"][0]["u_id"] == test_dict["u_id"]
# we test that they are unable to log in again
password_test = "qwertyuiop"
with pytest.raises(error.AccessError):
auth.auth_login("*****@*****.**", "password2")
# Test that the InputError raised when an unregistered email is entered
# still takes priority over the AccessError of admin_user_remove.
with pytest.raises(error.InputError):
auth.auth_login("*****@*****.**", password_test)
# Check incorrect password works stil
with pytest.raises(error.AccessError):
auth.auth_login("*****@*****.**", password_test)
with pytest.raises(error.InputError):
auth.auth_login("wrongemailformat", password_test)
