def test_login(self, enter_room):
""" Test login in a room """
with self.assertRaises(exceptions.Forbidden):
self.resource.login("name", "pass")
enter_room.assert_not_called()
room = RoomFactory(name="Room 1")
enter_room.return_value = room
self.assertEqual(self.resource.login("Room 1"), room)
enter_room.assert_called_with(room)
enter_room.reset_mock()
password = hashlib.sha256("pass".encode('utf-8')).hexdigest()
room = RoomFactory(name="Room 2", password=password)
enter_room.return_value = room
with self.assertRaises(exceptions.Forbidden):
self.resource.login("Room 2", password="******")
self.assertEqual(self.resource.login("Room 2", password="******"), room)
enter_room.assert_called_with(room)
def test_available_rooms(self):
""" Test getting the available rooms for a given user """
self.assertEqual(models.Room.available_rooms(self.session).count(), 0)
room = RoomFactory(hidden=False, name="Room classic")
room_hidden = RoomFactory(hidden=True, name="Room hidden")
user = UserFactory(rank=5)
rooms = list(models.Room.available_rooms(self.session, user))
self.assertEqual(len(rooms), 2)
self.assertIn(room, rooms)
self.assertIn(room_hidden, rooms)
user = UserFactory()
rooms = list(models.Room.available_rooms(self.session, user))
self.assertEqual(len(rooms), 1)
self.assertIn(room, rooms)
self.assertNotIn(room_hidden, rooms)
user2 = user_with_room_privilege(room=room_hidden, level=2)
rooms = list(models.Room.available_rooms(self.session, user2))
self.assertEqual(len(rooms), 2)
self.assertIn(room, rooms)
self.assertIn(room_hidden, rooms)
def test_enter_room(self, del_from_room, add_to_room):
""" Test enter in a room """
room = RoomFactory()
user = UserFactory(connection=self.connection, online=True)
self.resource.enter(room)
self.assertEqual(self.connection.room, room)
self.assertEqual(user.room, room)
del_from_room.assert_not_called()
add_to_room.assert_called_with(self.token, room.id)
add_to_room.reset_mock()
# Change of room
room2 = RoomFactory()
self.resource.enter(room2)
self.assertEqual(self.connection.room, room2)
self.assertEqual(user.room, room2)
del_from_room.assert_called_with(self.token, room.id)
add_to_room.assert_called_with(self.token, room2.id)
# User reenter in the same room
self.resource.enter(room2)
self.assertEqual(self.connection.room, room2)
self.assertEqual(user.room, room2)
del_from_room.assert_called_with(self.token, room2.id)
add_to_room.assert_called_with(self.token, room2.id)
def test_enter_room_unauthorized(self, del_from_room, add_to_room):
""" Test enter in a room """
room = RoomFactory()
# No user unauthorized
with self.assertRaises(exceptions.Forbidden):
self.resource.enter(room)
user_with_room_privilege(room=room,
level=0,
connection=self.connection,
online=True)
# User with insufficient right
with self.assertRaises(exceptions.Forbidden):
self.resource.enter(room)
#Room full
room = RoomFactory()
room.max_users = 2
UserFactory(room=room, online=True)
UserFactory(room=room, online=True)
with self.assertRaises(exceptions.Unauthorized):
self.resource.enter(room)
del_from_room.assert_not_called()
add_to_room.assert_not_called()
def test_login(self):
""" Test login in a room """
self.assertIsNone(
models.Room.login("name", "pass", self.session)
)
# Room without password
room = RoomFactory(name="Room 1")
self.assertEqual(
models.Room.login("Room 1", None, self.session),
room
)
self.assertEqual(
models.Room.login("Room 1", "password", self.session),
room
)
# Room with password
password = hashlib.sha256("pass".encode('utf-8')).hexdigest()
room = RoomFactory(name="Room 2", password=password)
self.assertIsNone(
models.Room.login("Room 2", "Wrong password", self.session)
)
self.assertEqual(
models.Room.login("Room 2", "pass", self.session),
room
)
def test_is_full(self):
""" Test checking if the room is full """
room = RoomFactory(max_users=2)
self.assertEqual(room.is_full(), False)
UserFactory(room=room, online=True)
UserFactory(room=room, online=True)
self.session.commit()
self.assertEqual(room.is_full(), True)
def test_set_op(self):
""" Test to OP a user in a room """
room = RoomFactory()
self.connection.room = room
user_with_room_privilege(level=7,
connection=self.connection,
online=True,
room=room)
target_user_admin = user_with_room_privilege(level=10,
online=True,
room=room)
target_user = user_with_room_privilege(level=1, online=True, room=room)
target_user2 = user_with_room_privilege(level=6,
online=True,
room=room)
ret = self.chat_command(self.resource, "invalid_user")
self.assertEqual(len(ret), 1)
self.assertRegex(ret[0], "Unknown user")
ret = self.chat_command(self.resource, target_user_admin.name)
self.assertEqual(len(ret), 1)
self.assertRegex(ret[0], "Not authorize")
self.assertEqual(target_user_admin.level(room.id), 10)
ret = self.chat_command(self.resource, target_user.name)
self.assertIsNone(ret)
self.assertEqual(target_user.level(room.id), 5)
ret = self.chat_command(self.resource, target_user2.name)
self.assertIsNone(ret)
self.assertEqual(target_user2.level(room.id), 5)
def test_handle_room_message(self, sendconnection, sendroom):
""" Test handling an incomming message """
room = RoomFactory(name="room_name")
connection = ConnectionFactory()
user = UserFactory(connection=connection, online=True, room=room)
self.worker.handle(
{
"target": {
"type": "room",
"value": room.id
},
"message": "message",
"source": connection.token
},
token=connection.token,
session=self.session,
)
sendconnection.assert_not_called()
sendroom.assert_called_once()
self.assertEqual(sendroom.call_args[0][0], room.id)
packet = sendroom.call_args[0][1]
self.assertIsInstance(packet, smpacket.SMPacketServerNSCCM)
self.assertRegex(packet["message"], "room_name")
self.assertRegex(packet["message"], "message")
self.assertRegex(packet["message"], user.name)
def test_kick_with_room(self, disconnect_user):
""" Test banning a user from a room """
room = RoomFactory()
self.connection.room = room
user_with_room_privilege(
connection=self.connection,
online=True,
room=room,
level=self.chat_command.permission.value,
)
target_connection = ConnectionFactory(room=room)
target_user = user_with_room_privilege(
room=room,
online=True,
connection=target_connection,
)
self.chat_command(self.resource, target_user.name)
self.assertFalse(
models.Ban.is_ban(self.session, user_id=target_user.id))
self.assertFalse(
models.Ban.is_ban(self.session,
user_id=target_user.id,
room_id=room.id))
self.assertIsNone(target_user.room)
self.assertIsNone(target_connection.room)
disconnect_user.assert_not_called()
def test_by_name(self):
""" Test getting a room by it's name"""
room = RoomFactory()
self.assertEqual(models.Room.by_name(room.name, self.session), room)
self.assertIsNone(models.Room.by_name("invalid room", self.session))
def test_by_id(self):
""" Test getting a room by it's id"""
room = RoomFactory()
self.assertEqual(models.Room.by_id(room.id, self.session), room)
self.assertIsNone(models.Room.by_id("invalid id", self.session))
def test_get_room(self):
""" Test getting a room given his ID """
with self.assertRaises(exceptions.NotFound):
self.resource.get(4)
room = RoomFactory()
self.assertEqual(room, self.resource.get(room.id))
def test_room(self):
""" Test getting the room associated with a connection """
self.assertEqual(self.controller.room, None)
room = RoomFactory()
self.connection.room = room
self.session.commit()
self.assertEqual(self.controller.room, room)
def test_nb_players(self):
""" Test getting the number of user in the room """
room = RoomFactory()
self.assertEqual(room.nb_players, 0)
UserFactory(room=room, online=True)
self.session.commit()
self.assertEqual(room.nb_players, 1)
def test_change_description(self):
""" Test to change the description in a room """
room = RoomFactory()
self.connection.room = room
user_with_room_privilege(level=5,
connection=self.connection,
online=True,
room=room)
ret = self.chat_command(self.resource, "New description")
self.assertIsNone(ret)
self.assertEqual(room.description, "New description")
def test_leave_room(self, del_from_room):
""" Test enter in a room """
room = self.resource.leave()
self.assertIsNone(room)
del_from_room.assert_not_called()
room = RoomFactory()
user = UserFactory(connection=self.connection, online=True, room=room)
self.connection.room = room
self.assertEqual(self.resource.leave(), room)
self.assertIsNone(user.room)
self.assertIsNone(self.connection.room)
def test_enter_room_unauthorized(self, del_from_room, add_to_room):
""" Test enter in a room """
room = RoomFactory()
# No user unauthorized
with self.assertRaises(exceptions.Forbidden):
self.resource.enter(room)
user_with_room_privilege(room=room, level=0, connection=self.connection, online=True)
# User with insufficient right
with self.assertRaises(exceptions.Forbidden):
self.resource.enter(room)
#Room full
room = RoomFactory()
room.max_users = 2
UserFactory(room=room, online=True)
UserFactory(room=room, online=True)
with self.assertRaises(exceptions.Unauthorized):
self.resource.enter(room)
del_from_room.assert_not_called()
add_to_room.assert_not_called()
def test_list(self, available_rooms):
""" Test listing the rooms """
self.assertEqual(list(self.resource.list()), [])
available_rooms.assert_not_called()
room = RoomFactory()
user = UserFactory(connection=self.connection, online=True)
available_rooms.return_value = [room]
rooms = self.resource.list()
self.assertEqual(rooms, [room])
available_rooms.assert_called_with(session=self.session, users=[user])
def test_moderators(self):
""" Test getting the list of moderators in the room """
room = RoomFactory()
user_with_room_privilege(level=1, room=room)
self.assertEqual(list(room.moderators), [])
mod1 = user_with_room_privilege(level=6, room=room)
mod2 = user_with_room_privilege(level=10, room=room)
moderators = list(room.moderators)
self.assertEqual(len(moderators), 2)
self.assertIn(mod1, moderators)
self.assertIn(mod2, moderators)
def test_online_users(self):
""" Test getting the online users in the room """
room = RoomFactory()
self.assertEqual(list(room.online_users), [])
user1 = UserFactory(room=room, online=True)
user2 = UserFactory(room=room, online=True)
self.session.commit()
online_users = list(room.online_users)
self.assertEqual(len(online_users), 2)
self.assertIn(user1, online_users)
self.assertIn(user2, online_users)
def test_leave(self):
""" Test to leave a room """
room = RoomFactory()
self.connection.room = room
user_with_room_privilege(
level=1,
connection=self.connection,
online=True,
room=room,
)
ret = self.chat_command(self.resource, None)
self.assertIsNone(ret)
self.assertEqual(self.connection.room, None)
def test_delete(self):
""" Test to delete of a room """
room = RoomFactory()
self.connection.room = room
user_with_room_privilege(
level=10,
connection=self.connection,
online=True,
room=room,
)
ret = self.chat_command(self.resource, None)
self.assertIsNone(ret)
self.assertEqual(self.connection.room, None)
self.assertIsNone(self.session.query(models.Room).get(room.id))
def test_delete(self):
""" Test delete a room """
room = RoomFactory()
with self.assertRaises(exceptions.Forbidden):
self.resource.delete(room.id)
user_with_room_privilege(room=room,
level=10,
online=True,
connection=self.connection)
self.connection.room = room
self.assertEqual(self.session.query(models.Room).get(room.id), room)
self.assertTrue(self.resource.delete(room.id))
self.assertIsNone(self.session.query(models.Room).get(room.id))
self.assertIsNone(self.connection.room)
def test_send_message_room(self, sendroom):
""" Test sending a message to a specific room """
self.worker.send_message_room("bla", None)
self.assertLog("WARNING")
sendroom.assert_not_called()
room = RoomFactory(name="room_name")
self.worker.send_message_room("bla", room)
sendroom.assert_called_once()
self.assertEqual(sendroom.call_args[0][0], room.id)
packet = sendroom.call_args[0][1]
self.assertIsInstance(packet, smpacket.SMPacketServerNSCCM)
self.assertRegex(packet["message"], "room_name")
self.assertRegex(packet["message"], "bla")
def test_send_room_message(self, send_message):
""" Test sending a message """
room = RoomFactory(name="machin")
UserFactory(online=True, connection=self.connection, room=room)
self.connection.room = room
self.resource.send("bla")
send_message.assert_called_once()
msg = send_message.call_args[0][0]
self.assertEqual(msg.kind, event.EventKind.chat_message)
self.assertEqual(msg.token, self.token)
self.assertEqual(msg.room_id, room.id)
self.assertEqual(msg.data["message"], "bla")
self.assertEqual(msg.data["target"]["value"], room.id)
self.assertEqual(msg.data["target"]["type"], "room")
def test_change_max_users(self):
""" Test to change the nb max of users in a room """
room = RoomFactory()
self.connection.room = room
user_with_room_privilege(
level=5,
connection=self.connection,
online=True,
room=room
)
ret = self.chat_command(self.resource, "invalid_number")
self.assertEqual(len(ret), 1)
self.assertRegex(ret[0], "Invalid number")
ret = self.chat_command(self.resource, "54")
self.assertIsNone(ret)
self.assertEqual(room.max_users, 54)
def test_change_free(self):
""" Test to change the free of a room """
room = RoomFactory(free=False)
self.connection.room = room
user_with_room_privilege(
level=5,
connection=self.connection,
online=True,
room=room,
)
ret = self.chat_command(self.resource, None)
self.assertIsNone(ret)
self.assertEqual(room.free, True)
ret = self.chat_command(self.resource, None)
self.assertIsNone(ret)
self.assertEqual(room.free, False)
def test_list_user_with_room(self):
""" Test displaying the list of users """
room = RoomFactory(max_users=42)
self.connection.room = room
user1 = UserFactory(online=True, room=room)
UserFactory(online=False)
UserFactory(online=True)
user4 = UserFactory(online=True, room=room)
res = self.chat_command(self.resource, "bla")
self.assertEqual(len(res), 3)
self.assertEqual(res[0], "2/42 players online")
self.assertRegex(res[1], user1.name)
self.assertRegex(res[2], user4.name)
res = self.chat_command(self.resource, "bla", limit=1)
self.assertEqual(len(res), 2)
self.assertEqual(res[0], "2/42 players online")
self.assertRegex(res[1], user1.name)
def test_unban_with_room(self):
""" Test banning a user from a room """
room = RoomFactory()
self.connection.room = room
UserFactory(online=True, connection=self.connection, room=room)
target_user = UserFactory(online=True)
models.Ban.ban(self.session, user_id=target_user.id, room_id=room.id)
self.assertTrue(
models.Ban.is_ban(self.session,
user_id=target_user.id,
room_id=room.id))
res = self.chat_command(self.resource, target_user.name)
self.assertFalse(
models.Ban.is_ban(self.session,
user_id=target_user.id,
room_id=room.id))
self.assertIsNone(res)
def test_find_ban(self):
""" Test to find a ban """
ban = BanFactory(ip="8.8.8.8")
self.assertEqual(
models.Ban.find_ban(session=self.session, ip="8.8.8.8"), ban)
ban.end_at = datetime.datetime.utcnow() + datetime.timedelta(days=1)
self.assertEqual(
models.Ban.find_ban(session=self.session, ip="8.8.8.8"), ban)
ban.end_at = datetime.datetime.utcnow()
self.assertIsNone(
models.Ban.find_ban(session=self.session, ip="8.8.8.8"))
room = RoomFactory()
ban.room = room
ban.end_at = None
self.assertIsNone(
models.Ban.find_ban(session=self.session, ip="8.8.8.8"))
self.assertEqual(
models.Ban.find_ban(session=self.session,
ip="8.8.8.8",
room_id=room.id), ban)
user = UserFactory()
ban = BanFactory(user=user)
self.assertEqual(
models.Ban.find_ban(session=self.session, user_id=user.id), ban)
ban.room = room
self.assertIsNone(
models.Ban.find_ban(session=self.session, user_id=user.id))
self.assertEqual(
models.Ban.find_ban(session=self.session,
user_id=user.id,
room_id=room.id), ban)