def test_leave_channel_success():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps({"leave_channel": "Client Team"}, indent=4))
expected_response = json.dumps(
{
"leave_channel": {
"channel": "Client Team",
"user": "******",
"message": "username has left the channel."
}
},
indent=4)
mydb.create_account("username", "password")
server, mydb = login(server, mydb, 'username', 'password')
mydb.create_channel("Client Team", None)
mydb.add_channels_to_user_info("username", ["Client Team"])
result = server.leave_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_new_message_user_cant_send_message_to_channel_theyre_not_in():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps(
{
"new_message": {
"channel_receiving_message": "Client Team",
"user": "******",
"timestamp": "2017-03-14 14:11:30",
"message": "the actual message that the user posted"
}
},
indent=4))
expected_response = json.dumps(
{
"error":
"The user is trying to send a message to a channel they haven't joined yet."
},
indent=4)
mydb.create_account('username', 'password')
server, mydb = login(server, mydb, 'username', 'password')
mydb.create_channel('Client Team', None)
result = server.new_message(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_delete_account_success():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps(
{
"delete_account": {
"username": "******",
"password": "******"
}
},
indent=4))
expected_response = json.dumps(
{
"account_deleted": {
"username": "******",
"channels_being_deleted": ["TestChannel"]
}
},
indent=4)
mydb.create_account("username", "password")
mydb.create_channel("TestChannel", "username")
result = server.delete_account(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_new_message_invalid_json():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps(
{
"new_message": {
"channel_receiving_": "Client Team",
"user": "******",
"timestamp": "2017-03-14 14:11:30",
"message": "the actual message that the user posted"
}
},
indent=4))
expected_response = json.dumps(
{"error": "The JSON file sent didn't contain valid information."},
indent=4)
mydb.create_account('username', 'password')
server, mydb = login(server, mydb, 'username', 'password')
mydb.create_channel('Client Team', None)
mydb.add_channels_to_user_info('username', ['Client Team'])
result = server.new_message(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_delete_channel_channel_not_found():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps({"delete_channel": "Non-existent channel"}, indent=4))
expected_response = json.dumps(
{"error": "The specified channel was not found."}, indent=4)
mydb.create_account("username", "password")
server, mydb = login(server, mydb, 'username', 'password')
mydb.create_channel("TestChannel", "username")
result = server.delete_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_join_channel_user_tries_to_send_json_containing_zero_channels_to_join(
):
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(json.dumps({"join_channel": []}, indent=4))
expected_response = json.dumps(
{"error": "No channels were given for the user to join."}, indent=4)
mydb.create_account("username", "password")
server, mydb = login(server, mydb, "username", "password")
mydb.create_channel("Client Team", "username")
mydb.create_channel("Server Team", "username")
result = server.join_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_join_channel_that_doesnt_exist():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps({"join_channel": ["Client Team", "Server Team"]}, indent=4))
expected_response = json.dumps(
{"error": "The user is trying to join a channel that doesn't exist."},
indent=4)
mydb.create_account('username', 'password')
server, mydb = login(server, mydb, 'username', 'password')
mydb.create_channel("TestChannel", "username")
result = server.join_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_join_channel_trying_to_join_channel_that_you_are_already_a_part_of():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps({"join_channel": ["Client Team", "Server Team"]}, indent=4))
expected_response = json.dumps({
"error":
"The user has already joined one or more of the channels they were trying to join again."
})
mydb.create_account("username", "password")
server, mydb = login(server, mydb, "username", "password")
mydb.create_channel("Client Team", "username")
mydb.create_channel("Server Team", "username")
server.join_channel(mydb, client_request)
result = server.join_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_login_success():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps(
{"login": {
"username": "******",
"password": "******",
}},
indent=4))
expected_response = json.dumps({"channels": ["ChannelTest"]}, indent=4)
mydb.create_account("username", "password")
mydb.create_channel("ChannelTest", "username")
result = server.login(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_join_channel_success():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps({"join_channel": ["Client Team", "Server Team"]}, indent=4))
expected_response = json.dumps(
{
"channels_joined": ["Client Team", "Server Team"],
"user": "******"
},
indent=4)
mydb.create_account("username", "password")
server, mydb = login(server, mydb, "username", "password")
mydb.create_channel("Client Team", "username")
mydb.create_channel("Server Team", "username")
result = server.join_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_delete_channel_user_not_authorized_to_delete_channel():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps({"delete_channel": "TestChannel"}, indent=4))
expected_response = json.dumps(
{
"error":
"The user trying to delete the channel isn't the admin of the channel."
},
indent=4)
mydb.create_account("username", "password")
server, mydb = login(server, mydb, 'username', 'password')
mydb.create_account("admin user", "password")
mydb.create_channel("TestChannel", "admin user")
result = server.delete_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
def test_delete_channel_success():
server = Camelot_Server()
mydb = Camelot_Database()
client_request = json.loads(
json.dumps({"delete_channel": "TestChannel"}, indent=4))
expected_response = json.dumps(
{
"channel_deleted": {
"channel": "TestChannel",
"message": "The channel `TestChannel` has been deleted."
}
},
indent=4)
mydb.create_account("username", "password")
server, mydb = login(server, mydb, 'username', 'password')
mydb.create_channel("TestChannel", "username")
result = server.delete_channel(mydb, client_request)
assert expected_response == result
mydb.empty_tables()
