def test_channel_invite_invalid_channel_id(url):
requests.delete(url + "clear")
owner, user = http_register_n_users(url, 2)
# Owner creates a private channel
requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": False
},
).json()
# Owner invites user with invalid channel id
invalid_channel_id = -1
response = requests.post(
url + "channel/invite",
json={
"token": owner["token"],
"channel_id": invalid_channel_id,
"u_id": user["u_id"],
},
)
assert response.status_code == 400
def test_standup_send_invalid_channel_id(url):
requests.delete(url + "clear")
user1 = http_register_n_users(url, 1)
# Create channel
channel = requests.post(
url + "channels/create",
json={
"token": user1["token"],
"name": "channel_01",
"is_public": True
},
).json()
# Start a standup
requests.post(
url + "standup/start",
json={
"token": user1["token"],
"channel_id": channel["channel_id"],
"length": 1,
},
)
# Send with invalid channel id
invalid_channel_id = -1
response = requests.post(
url + "standup/send",
json={
"token": user1["token"],
"channel_id": invalid_channel_id,
"message": "test",
},
)
assert response.status_code == 400
def test_http_channels_create_empty_name(url):
"""Testing empty names because the http stack might remove them
automatically or something. It's clearly an edge case"""
requests.delete(url + "clear")
usera = http_register_n_users(url, 1)
response = requests.post(
url + "channels/create",
json={
"token": usera["token"],
"name": "",
"is_public": True,
},
)
assert response.status_code == 200
channel_id = response.json()["channel_id"]
response = requests.get(
url + "channel/details",
params={
"token": usera["token"],
"channel_id": channel_id,
},
)
assert response.status_code == 200
channel_details = response.json()
# empty names are replaced with the name 'new_channel'
assert channel_details["name"] == "new_channel"
def test_add_invalid_user_to_owner(url):
requests.delete(url + "clear")
owner = http_register_n_users(url, 1)
private_channel = requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": False
},
).json()
# Owner tries to add a non-existent user as owner
invalid_uid = -1
response = requests.post(
url + "channel/addowner",
json={
"token": owner["token"],
"channel_id": private_channel["channel_id"],
"u_id": invalid_uid,
},
)
assert response.status_code == 400
def test_standup_start_standup_is_already_running(url):
requests.delete(url + "clear")
user1 = http_register_n_users(url, 1)
# Create channel
channel = requests.post(
url + "channels/create",
json={
"token": user1["token"],
"name": "channel_01",
"is_public": True
},
).json()
# Start a standup
requests.post(
url + "standup/start",
json={
"token": user1["token"],
"channel_id": channel["channel_id"],
"length": 1,
},
)
# Another standup when there's one already running
response = requests.post(
url + "standup/start",
json={
"token": user1["token"],
"channel_id": channel["channel_id"],
"length": 1,
},
)
assert response.status_code == 400
def test_messages_invalid_token(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
# Create a channel
response = requests.post(
url + "channels/create",
json={
"token": user["token"],
"name": "channel_01",
"is_public": True
},
)
assert response.status_code == 200
channel = response.json()
response = requests.get(
url + "channel/messages",
params={
"token": -1,
"channel_id": channel["channel_id"],
"start": 0,
},
)
assert response.status_code == 403
def test_add_owner_invalid_channel_id(url):
requests.delete(url + "clear")
owner, user = http_register_n_users(url, 2)
# Owner creates public channel
requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": True
},
).json()
# Owner adds user using invalid channel id
invalid_channel_id = -1
response = requests.post(
url + "channel/addowner",
json={
"token": owner["token"],
"channel_id": invalid_channel_id,
"u_id": user["u_id"],
},
)
assert response.status_code == 400
def test_channels_list_2_channels(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
channel01 = requests.post(
url + "channels/create",
json={
"token": user["token"],
"name": "channel_01",
"is_public": True
},
).json()
channel02 = requests.post(
url + "channels/create",
json={
"token": user["token"],
"name": "channel_02",
"is_public": True
},
).json()
response = requests.get(url + "channels/list",
params={"token": user["token"]})
assert response.status_code == 200
channels_list = response.json()
assert channel01["channel_id"] in [
x["channel_id"] for x in channels_list["channels"]
]
assert channel02["channel_id"] in [
x["channel_id"] for x in channels_list["channels"]
]
def tests_channels_list_non_admin(url):
requests.delete(url + "clear")
admin, user = http_register_n_users(url, 2)
channel = requests.post(
url + "channels/create",
json={
"token": admin["token"],
"name": "channel_01",
"is_public": True
},
).json()
requests.post(
url + "channel/join",
json={
"token": user["token"],
"channel_id": channel["channel_id"]
},
)
response = requests.get(url + "channels/list",
params={"token": user["token"]})
assert response.status_code == 200
channels_list = response.json()
assert channel["channel_id"] in [
x["channel_id"] for x in channels_list["channels"]
]
def test_react_invalid_react_id(url):
requests.delete(url + "clear")
user_a = http_register_n_users(url, 1)
# user_a create a channel
public_channel_id = requests.post(
url + "channels/create",
json={"token": user_a["token"], "name": "public_channel", "is_public": True},
).json()["channel_id"]
# user_a send a message
message_id = requests.post(
url + "message/send",
json={
"token": user_a["token"],
"channel_id": public_channel_id,
"message": "How are you",
},
).json()["message_id"]
invalid_react_number = -1
# user_a react the the message using a invalid message_id
response = requests.post(
url + "message/react",
json={
"token": user_a["token"],
"message_id": message_id,
"react_id": invalid_react_number,
},
)
assert response.status_code == 400
def test_message_sendlater_4xx_web(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
channel_id = requests.post(
url + "channels/create",
json={
"token": user["token"],
"name": "channel_name",
"is_public": True,
},
).json()["channel_id"]
assert (requests.post(
url + "message/sendlater",
json={
"token": -1,
"channel_id": channel_id,
"message": "message",
"time_sent": int(round(time.time() + 2)),
},
).status_code == 403)
assert (requests.post(
url + "message/sendlater",
json={
"token": user["token"],
"channel_id": -1,
"message": "asdfasfd",
"time_sent": int(round(time.time() + 2)),
},
).status_code == 400)
def test_react_invalid_message_id_out_channel(url):
requests.delete(url + "clear")
user_a, user_b = http_register_n_users(url, 2)
# user_b create a channel and send message in his own channel
public_channel_id_b = requests.post(
url + "channels/create",
json={"token": user_b["token"], "name": "public_channel_b", "is_public": True},
).json()["channel_id"]
message_id_b = requests.post(
url + "message/send",
json={
"token": user_b["token"],
"channel_id": public_channel_id_b,
"message": "Nice to see you mate",
},
).json()["message_id"]
# user_a trying to reponse in outside the channel
response = requests.post(
url + "message/react",
json={
"token": user_a["token"],
"message_id": message_id_b,
"react_id": 1,
},
)
# user_a should not be able to react the the message in the public_channel_b
assert response.status_code == 400
def test_channel_invite_invalid_user_id(url):
requests.delete(url + "clear")
owner = http_register_n_users(url, 1)
# Owner creates private channel
private_channel = requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": False
},
).json()
# Owner invites a user that does not exist in the database
invalid_user_id = -1
response = requests.post(
url + "channel/invite",
json={
"token": owner["token"],
"channel_id": private_channel["channel_id"],
"u_id": invalid_user_id,
},
)
assert response.status_code == 400
def test_channel_invite_from_unauthorised_user(url):
requests.delete(url + "clear")
owner, user1, user2 = http_register_n_users(url, 3)
# Owner creates a private channel
private_channel = requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": False
},
).json()
# User 1 (non-member) invites User2 (non-member) to Owner's channel
response = requests.post(
url + "channel/invite",
json={
"token": user1["token"],
"channel_id": private_channel["channel_id"],
"u_id": user2["u_id"],
},
)
assert response.status_code == 403
def test_remove_invald_message_id(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
# Create a new channel
channel_params = {
"token": user["token"],
"name": "channel_01",
"is_public": True,
}
response = requests.post(url + "channels/create", json=channel_params)
assert response.status_code == 200
channel = response.json()
# User sends a message
message_params = {
"token": user["token"],
"channel_id": channel["channel_id"],
"message": "test message",
}
response = requests.post(url + "message/send", json=message_params)
assert response.status_code == 200
# User tries to edit message with invalid message id
message_remove_params = {
"token": user["token"],
"message_id": INVALID_MESSAGE_ID
}
# Ensure input error raised
r = requests.delete(url + "message/remove", json=message_remove_params)
assert r.status_code == 400
def test_edit_non_existent_user(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
# Create a new channel
channel_params = {
"token": user["token"],
"name": "channel_01",
"is_public": True,
}
response = requests.post(url + "channels/create", json=channel_params)
assert response.status_code == 200
channel = response.json()
# User sends a message
message_params = {
"token": user["token"],
"channel_id": channel["channel_id"],
"message": "test message",
}
response = requests.post(url + "message/send", json=message_params)
assert response.status_code == 200
message = response.json()
# Non-existent user tries to edit the message
message_edit_data = {
"token": -1,
"message_id": message["message_id"],
"message": "try editing",
}
response = requests.put(url + "message/edit", json=message_edit_data)
assert response.status_code == 403
def test_remove_unauthorised_user(url):
requests.delete(url + "clear")
user01, user02 = http_register_n_users(url, 2)
# Create a new channel
channel_params = {
"token": user01["token"],
"name": "channel_01",
"is_public": True,
}
response = requests.post(url + "channels/create", json=channel_params)
assert response.status_code == 200
channel = response.json()
# User 1 sends a message
message_params = {
"token": user01["token"],
"channel_id": channel["channel_id"],
"message": "test message",
}
response = requests.post(url + "message/send", json=message_params)
assert response.status_code == 200
message = response.json()
# User 2 tries to remove message from User 1
message_remove_params = {
"token": user02["token"],
"message_id": message["message_id"],
}
r = requests.delete(url + "message/remove", json=message_remove_params)
assert r.status_code == 403
def test_message_edit_exceeeds_limit(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
# Create a new channel
channel_params = {
"token": user["token"],
"name": "channel_01",
"is_public": True,
}
response = requests.post(url + "channels/create", json=channel_params)
assert response.status_code == 200
channel = response.json()
# User sends a message
message_params = {
"token": user["token"],
"channel_id": channel["channel_id"],
"message": "test message",
}
response = requests.post(url + "message/send", json=message_params)
assert response.status_code == 200
message = response.json()
# Edited message exeeds 1000 chars
message_edit_data = {
"token": user["token"],
"message_id": message["message_id"],
"message": "a" * 1001,
}
response = requests.put(url + "message/edit", json=message_edit_data)
assert response.status_code == 400
def test_channels_listall_multiple_users_public(url):
requests.delete(url + "clear")
user_01, user_02 = http_register_n_users(url, 2)
tokens = [user_01["token"], user_02["token"]]
channel_ids = []
names = ["private_channel_01", "private_channel_02"]
# Create a list of tuple which include elements from
# names and token, and use it to create two channel
for name, token in zip(names, tokens):
channel_id = requests.post(
url + "channels/create",
json={"token": token, "name": name, "is_public": True},
).json()["channel_id"]
channel_ids.append(channel_id)
# Authorised channel is our expectation to the
# channels which should be listed.
authorised_channels = []
for channel_id, name in zip(channel_ids, names):
authorised_channels.append({"channel_id": channel_id, "name": name})
# For any user, channels/listall should list all of channels that exist.
response01 = requests.get(
url + "channels/listall", params={"token": user_01["token"]}
)
response02 = requests.get(
url + "channels/listall", params={"token": user_02["token"]}
)
assert response01.json()["channels"] == authorised_channels
assert response02.json()["channels"] == authorised_channels
def test_edit_invalid_message_id(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
# Create a new channel
channel_params = {
"token": user["token"],
"name": "channel_01",
"is_public": True,
}
response = requests.post(url + "channels/create", json=channel_params)
assert response.status_code == 200
channel = response.json()
# User sends a message
message_params = {
"token": user["token"],
"channel_id": channel["channel_id"],
"message": "test message",
}
response = requests.post(url + "message/send", json=message_params)
assert response.status_code == 200
# User tries to edit message with an invalid message id
message_edit_data = {
"token": "-1",
"message_id": INVALID_MESSAGE_ID,
"message": "try editing",
}
response = requests.put(url + "message/edit", json=message_edit_data)
assert response.status_code == 403
def test_add_owner_repeatedly(url):
requests.delete(url + "clear")
owner_1, owner_2 = http_register_n_users(url, 2)
# Owner_1 creates a public channel
public_channel = requests.post(
url + "channels/create",
json={
"token": owner_1["token"],
"name": "channel_01",
"is_public": True
},
).json()
# Owner_1 adds Owner_2 as an owner
requests.post(
url + "channel/addowner",
json={
"token": owner_1["token"],
"channel_id": public_channel["channel_id"],
"u_id": owner_2["u_id"],
},
)
# Owner_1 adds Owner_2 as an owner again
response = requests.post(
url + "channel/addowner",
json={
"token": owner_1["token"],
"channel_id": public_channel["channel_id"],
"u_id": owner_2["u_id"],
},
)
assert response.status_code == 400
def test_unreact_inactive_react_id(url):
"""
situation where a user trying to unreact a message which haven't been reacted
"""
requests.delete(url + "clear")
user_a = http_register_n_users(url, 1)
public_channel_id = requests.post(
url + "channels/create",
json={
"token": user_a["token"],
"name": "public_channel",
"is_public": True
},
).json()["channel_id"]
message_id = requests.post(
url + "message/send",
json={
"token": user_a["token"],
"channel_id": public_channel_id,
"message": "Nice to see you mate",
},
).json()["message_id"]
# React id 1 is a valid id but not active
response = requests.post(
url + "message/unreact",
json={
"token": user_a["token"],
"message_id": message_id,
"react_id": 1,
},
)
assert response.status_code == 400
def test_add_owner_invalid_token(url):
requests.delete(url + "clear")
owner, user = http_register_n_users(url, 2)
# Owner creates a public channel
channel = requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": True
},
).json()
# User tries to make themselves the owner of Owner's channel
response = requests.post(
url + "channel/addowner",
json={
"token": user["token"],
"channel_id": channel["channel_id"],
"u_id": user["u_id"],
},
)
assert response.status_code == 403
def test_remove_owner_on_nonexistent_user(url):
requests.delete(url + "clear")
owner = http_register_n_users(url, 1)
# Owner creates public channel
channel = requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": True
},
).json()
# User tries to remove non-existent user as owner of the channel
nonexistent_user_id = -1
response = requests.post(
url + "channel/removeowner",
json={
"token": owner["token"],
"channel_id": channel["channel_id"],
"u_id": nonexistent_user_id,
},
)
assert response.status_code == 400
def test_standup_start_no_message_sent(url):
requests.delete(url + "clear")
user1 = http_register_n_users(url, 1)
# Create channel
channel = requests.post(
url + "channels/create",
json={
"token": user1["token"],
"name": "channel_01",
"is_public": True
},
).json()
# Start a standup
requests.post(
url + "standup/start",
json={
"token": user1["token"],
"channel_id": channel["channel_id"],
"length": 1,
},
)
# Assert the messages are empty
messages = requests.get(
url + "channel/messages",
params={
"token": user1["token"],
"channel_id": channel["channel_id"],
"start": 0,
},
).json()["messages"]
assert len(messages) == 0
def test_remove_owner_on_member(url):
requests.delete(url + "clear")
owner, user = http_register_n_users(url, 2)
# Owner creates a public channel
channel = requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": True
},
).json()
# User joins channel and becomes a member
requests.post(
url + "channel/join",
json={
"token": user["token"],
"channel_id": channel["channel_id"],
},
)
# Owner tries to remove user using removeowner
response = requests.post(
url + "channel/removeowner",
json={
"token": owner["token"],
"channel_id": channel["channel_id"],
"u_id": user["u_id"],
},
)
assert response.status_code == 400
def test_standup_send_AccessError(url):
requests.delete(url + "clear")
user1, user2 = http_register_n_users(url, 2)
# Create channel
channel = requests.post(
url + "channels/create",
json={
"token": user1["token"],
"name": "channel_01",
"is_public": True
},
).json()
# Start a standup
requests.post(
url + "standup/start",
json={
"token": user1["token"],
"channel_id": channel["channel_id"],
"length": 1,
},
)
# User2 is not a member of the channel
response = requests.post(
url + "standup/send",
json={
"token": user2["token"],
"channel_id": channel["channel_id"],
"message": "test",
},
)
assert response.status_code == 403
def test_remove_invalid_user_token(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
# Create a new channel
channel_params = {
"token": user["token"],
"name": "channel_01",
"is_public": True,
}
response = requests.post(url + "channels/create", json=channel_params)
assert response.status_code == 200
channel = response.json()
# User sends a message
message_params = {
"token": user["token"],
"channel_id": channel["channel_id"],
"message": "test message",
}
response = requests.post(url + "message/send", json=message_params)
assert response.status_code == 200
message = response.json()
message_remove_params = {
"token": "-1",
"message_id": message["message_id"],
}
# Ensure access error raised
r = requests.delete(url + "message/remove", json=message_remove_params)
assert r.status_code == 403
def create_channel(url):
requests.delete(url + "clear")
user = http_register_n_users(url, 1)
# Create a channel
response = requests.post(
url + "channels/create",
json={
"token": user["token"],
"name": "channel_01",
"is_public": True,
},
)
assert response.status_code == 200
channel = response.json()
# User sends a message
response = requests.post(
url + "message/send",
json={
"token": user["token"],
"channel_id": channel["channel_id"],
"message": "test message",
},
)
assert response.status_code == 200
message = response.json()
return [url, user, channel, message]
def test_channel_invite_invalid_token(url):
requests.delete(url + "clear")
owner, user = http_register_n_users(url, 2)
# Owner creates private channel
private_channel = requests.post(
url + "channels/create",
json={
"token": owner["token"],
"name": "channel_01",
"is_public": False
},
).json()
# Invalid token used to invite user to owner's channel
invalid_token = "arandomtoken"
response = requests.post(
url + "channel/invite",
json={
"token": invalid_token,
"channel_id": private_channel["channel_id"],
"u_id": user["u_id"],
},
)
assert response.status_code == 403
