def test_json_sign_in_third_user(self):
        """ A third user connect in a pos already taken """

        self.test_json_sign_in_with_same_user()
        self.test_json_sign_in_second_user()

        self.client_json.on_data(smpacket.SMPacketClientNSSMONL(
            packet=smpacket.SMOPacketClientLogin(
                username="******",
                password="******",
                player_number=1
            )
        ).json)

        user3 = self.session.query(models.User).filter_by(name="clientjson-user3").first()
        user1 = self.session.query(models.User).filter_by(name="clientjson-user1").first()

        self.assertTrue(user3.online)
        self.assertEqual(user3.last_ip, self.client_json.ip)
        self.assertIsNone(user3.room)
        self.assertEqual(user3.pos, 1)

        self.assertIn(user3, self.json_connection.users)

        self.assertEqual(len(self.json_connection.users), 3)
        self.assertEqual(len(self.json_connection.active_users), 2)

        self.assertFalse(user1.online)
    def test_json_fail_enter_room_wrong_password(self):
        """ Json client try to enter in a room with the wrong password """
        self.test_client_bin_room_creation()

        self.client_json.on_data(
            smpacket.SMPacketClientNSSMONL(
                packet=smpacket.SMOPacketClientEnterRoom(
                    enter=1, room="Room client-bin",
                    password="******")).json)

        self.assertIsNone(self.json_connection.room)
    def setUp(self):
        super().setUp()

        # Client bin create a room
        self.client_bin.on_data(
            smpacket.SMPacketClientNSSMONL(
                packet=smpacket.SMOPacketClientCreateRoom(
                    type=1,
                    title="ChatRoom",
                    description="test chat room",
                    password="******")).binary)

        # Client JSON enter in his room
        self.client_json.on_data(
            smpacket.SMPacketClientNSSMONL(
                packet=smpacket.SMOPacketClientEnterRoom(
                    enter=1, room="ChatRoom", password="******")).json)

        self.client_bin.packet_send = []
        self.client_json.packet_send = []
        self.server.listener.start()
    def test_json_fail_create_room_name_already_taken(self):
        """ Json client create a room that already exist """

        self.test_client_bin_room_creation()

        self.client_json.on_data(
            smpacket.SMPacketClientNSSMONL(
                packet=smpacket.SMOPacketClientCreateRoom(
                    type=1,
                    title="Room client-bin",
                    description="test room",
                    password="******")).json)

        self.assertIsNone(self.json_connection.room)
Beispiel #5
0
 def setUp(self):
     super().setUp()
     self.client_bin.on_data(smpacket.SMPacketClientNSSMONL(
         packet=smpacket.SMOPacketClientLogin(
             username="******",
             password="******",
             player_number=0
         )
     ).binary)
     self.client_bin.on_data(smpacket.SMPacketClientNSSMONL(
         packet=smpacket.SMOPacketClientLogin(
             username="******",
             password="******",
             player_number=1
         )
     ).binary)
     self.client_json.on_data(smpacket.SMPacketClientNSSMONL(
         packet=smpacket.SMOPacketClientLogin(
             username="******",
             password="******",
             player_number=0
         )
     ).json)
    def test_client_bin_sign_in_one_user(self):
        """ First time login for clientbin-user1, the user is created """
        self.client_bin.on_data(smpacket.SMPacketClientNSSMONL(
            packet=smpacket.SMOPacketClientLogin(
                username="******",
                password="******",
                player_number=0
            )
        ).binary)

        user = self.session.query(models.User).filter_by(name="clientbin-user1").first()

        self.assertIsNotNone(user)
        self.assertTrue(user.online)
        self.assertEqual(user.last_ip, self.client_bin.ip)
        self.assertIsNone(user.room)
        self.assertEqual(user.pos, 0)
        self.assertIn(user, self.bin_connection.users)
    def test_json_room_info(self):
        """ Display room information in room selection """
        self.test_client_bin_room_creation()

        self.client_json.on_data(
            smpacket.SMPacketClientNSSMONL(
                packet=smpacket.SMOPacketClientRoomInfo(
                    room="Room client-bin")).json)

        packet = self.get_smpacket_in(smpacket.SMPacketServerNSSMONL,
                                      self.client_json.packet_send)

        self.assertIsNotNone(packet)

        self.assertIsInstance(packet["packet"],
                              smpacket.SMOPacketServerRoomInfo)

        self.assertEqual(packet["packet"]["num_players"], 2)
        self.assertIn("clientbin-user1", packet["packet"]["players"])
        self.assertIn("clientbin-user2", packet["packet"]["players"])
    def test_client_bin_room_creation(self):
        """ First room creation """

        self.client_bin.on_data(
            smpacket.SMPacketClientNSSMONL(
                packet=smpacket.SMOPacketClientCreateRoom(
                    type=1,
                    title="Room client-bin",
                    description="test room",
                    password="******")).binary)

        room = self.session.query(
            models.Room).filter_by(name="Room client-bin").first()

        self.assertEqual(self.bin_connection.room, room)
        self.assertEqual(room.description, "test room")

        self.assertEqual(self.user_bin1.room, room)
        self.assertEqual(self.user_bin2.room, room)

        self.assertEqual(self.user_bin1.level(room.id), 10)
        self.assertEqual(self.user_bin2.level(room.id), 10)
    def test_client_bin_sign_in_wrong_password(self):
        """ Login with a wrong password """

        self.test_client_bin_sign_in_one_user()

        self.client_bin.on_data(smpacket.SMPacketClientNSSMONL(
            packet=smpacket.SMOPacketClientLogin(
                username="******",
                password="******",
                player_number=1
            )
        ).binary)

        user = self.session.query(models.User).filter_by(name="clientbin-user1").first()

        self.assertIsNotNone(user)
        self.assertTrue(user.online)
        self.assertEqual(user.last_ip, self.client_bin.ip)
        self.assertIsNone(user.room)
        self.assertEqual(user.pos, 0)

        self.assertIn(user, self.bin_connection.users)
    def test_json_sign_in_with_same_user(self):
        """ Player reconnect the same user already logued in (in another pos) """

        self.test_json_sign_in_one_user()

        self.client_json.on_data(smpacket.SMPacketClientNSSMONL(
            packet=smpacket.SMOPacketClientLogin(
                username="******",
                password="******",
                player_number=1
            )
        ).json)

        user = self.session.query(models.User).filter_by(name="clientjson-user1").first()

        self.assertTrue(user.online)
        self.assertEqual(user.last_ip, self.client_json.ip)
        self.assertIsNone(user.room)
        self.assertEqual(user.pos, 1)

        self.assertIn(user, self.json_connection.users)
        self.assertEqual(len(self.json_connection.users), 1)
    def test_client_json_room_creation(self):
        """ Json client create a new room, and exit the client-bin room """

        self.test_json_enter_room()

        self.client_json.on_data(
            smpacket.SMPacketClientNSSMONL(
                packet=smpacket.SMOPacketClientCreateRoom(
                    type=1,
                    title="Room client-json",
                    description="test room",
                    password="******")).json)

        room = self.session.query(
            models.Room).filter_by(name="Room client-json").first()
        user = self.user_json1

        self.assertEqual(self.json_connection.room, room)
        self.assertEqual(room.description, "test room")

        self.assertEqual(user.room, room)

        self.assertEqual(user.level(room.id), 10)
    def test_json_sign_in_second_user(self):
        """ A second user sign in the free pos"""

        self.test_json_sign_in_with_same_user()

        self.client_json.on_data(smpacket.SMPacketClientNSSMONL(
            packet=smpacket.SMOPacketClientLogin(
                username="******",
                password="******",
                player_number=0
            )
        ).json)

        user = self.session.query(models.User).filter_by(name="clientjson-user2").first()

        self.assertTrue(user.online)
        self.assertEqual(user.last_ip, self.client_json.ip)
        self.assertIsNone(user.room)
        self.assertEqual(user.pos, 0)

        self.assertIn(user, self.json_connection.users)

        self.assertEqual(len(self.json_connection.users), 2)