def test_handle_user_message(self, sendconnection, sendroom):
""" Test handling an incomming message """
connection = ConnectionFactory()
user = UserFactory(connection=connection, online=True)
connection_target = ConnectionFactory()
self.worker.handle(
{
"target": {
"type": "token",
"value": connection_target.token
},
"message": "message",
"source": connection.token
},
token=connection.token,
session=self.session,
)
sendroom.assert_not_called()
sendconnection.assert_called_once()
self.assertEqual(sendconnection.call_args[0][0],
connection_target.token)
packet = sendconnection.call_args[0][1]
self.assertIsInstance(packet, smpacket.SMPacketServerNSCCM)
self.assertRegex(packet["message"], "message")
self.assertRegex(packet["message"], user.name)
def test_alive(self):
""" Test if a connectio is alive """
connection = ConnectionFactory()
self.assertTrue(connection.alive)
connection.close_at = datetime.datetime.utcnow()
self.assertFalse(connection.alive)
def test_alive(self):
""" Test if a connectio is alive """
connection = ConnectionFactory()
self.assertTrue(connection.alive)
connection.close_at = datetime.datetime.utcnow()
self.assertFalse(connection.alive)
def test_can(self):
""" Test connection can """
conn = ConnectionFactory()
self.assertEqual(conn.can(ability.Permissions.delete_room), False)
user = user_with_room_privilege(level=10, connection=conn, online=True)
room = user.room
self.assertEqual(conn.can(ability.Permissions.delete_room, room.id), True)
def test_by_token(self):
""" Test getting an object given his token """
self.assertEqual(models.Connection.by_token("aa", self.session), None)
ConnectionFactory()
conn = ConnectionFactory()
self.assertEqual(models.Connection.by_token(conn.token, self.session),
conn)
def test_can(self):
""" Test connection can """
conn = ConnectionFactory()
self.assertEqual(conn.can(ability.Permissions.delete_room), False)
user = user_with_room_privilege(level=10, connection=conn, online=True)
room = user.room
self.assertEqual(conn.can(ability.Permissions.delete_room, room.id),
True)
def test_level(self):
""" Test getting the level of a connection """
conn = ConnectionFactory()
self.assertEqual(conn.level(), 0)
user = user_with_room_privilege(level=2, connection=conn, online=True)
room = user.room
user_with_room_privilege(level=5, connection=conn, online=False, room=room)
self.assertEqual(conn.level(room.id), 2)
def test_level(self):
""" Test getting the level of a connection """
conn = ConnectionFactory()
self.assertEqual(conn.level(), 0)
user = user_with_room_privilege(level=2, connection=conn, online=True)
room = user.room
user_with_room_privilege(level=5,
connection=conn,
online=False,
room=room)
self.assertEqual(conn.level(room.id), 2)
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 setUp(self):
super().setUp()
self.server = server.StepmaniaServer()
self.connection = ConnectionFactory()
self.token = self.connection.token
def setUp(self):
super().setUp()
self.server = server.StepmaniaServer()
self.conn = smconn.StepmaniaConn(self.server, "8.8.8.8", 42)
self.connection = ConnectionFactory(token=self.conn.token)
self.controller = StepmaniaController(self.server, self.conn, None,
self.session)
def setUp(self):
super().setUp()
self.server = server.StepmaniaServer()
self.connection = ConnectionFactory()
self.token = self.connection.token
self.resource = ChatResource(self.server, self.token, self.session)
def test_remove(self):
""" Test remove connection """
self.session.query(models.Connection).delete()
models.Connection.remove("efz", self.session)
self.assertEqual(self.session.query(models.Connection).count(), 0)
conn = ConnectionFactory()
self.assertEqual(self.session.query(models.Connection).count(), 1)
models.Connection.remove(conn.token, self.session)
self.assertEqual(self.session.query(models.Connection).count(), 0)
def test_active_users(self):
""" Test getting the active users in a connection """
conn = ConnectionFactory()
self.assertEqual(conn.active_users, [])
user1 = UserFactory(connection=conn, online=True)
user2 = UserFactory(connection=conn, online=False)
self.assertEqual(conn.active_users, [user1])
user3 = UserFactory(connection=conn, online=True)
self.assertEqual(len(conn.active_users), 2)
self.assertIn(user1, conn.active_users)
self.assertIn(user3, conn.active_users)
self.assertNotIn(user2, conn.active_users)
def test_route(self, handle_controller1, handle_controller2):
""" Test routing packet """
test_router = router.Router()
serv = server.StepmaniaServer()
conn = smconn.StepmaniaConn(server, "8.8.8.8", 42)
connection = ConnectionFactory(token=conn.token)
command = smcommand.SMClientCommand.NSCAttack
packet = smpacket.SMPacket.new(command)
# No route
test_router.route(serv, conn, packet)
handle_controller1.assert_not_called()
handle_controller2.assert_not_called()
# Route only controller 1
test_router.add_route(command, Controller1)
test_router.route(serv, conn, packet, session=self.session)
handle_controller1.assert_called_with()
handle_controller1.reset_mock()
handle_controller2.assert_not_called()
# Route with require login
test_router.add_route(command, Controller2)
test_router.route(serv, conn, packet, session=self.session)
handle_controller1.assert_called_with()
handle_controller1.reset_mock()
handle_controller2.assert_not_called()
# Test with login user
UserFactory(connection_token=connection.token, online=True)
test_router.route(serv, conn, packet, session=self.session)
handle_controller1.assert_called_with()
handle_controller2.assert_called_with()
handle_controller1.reset_mock()
handle_controller2.reset_mock()
# With exceptions, no crash
handle_controller1.side_effect = Exception()
test_router.route(serv, conn, packet, session=self.session)
handle_controller1.assert_called_with()
handle_controller2.assert_called_with()
handle_controller1.reset_mock()
handle_controller2.reset_mock()