Mercurial > libervia-backend

view sat/test/test_plugin_misc_room_game.py @ 3728:b15644cae50d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
component AP gateway: JID/node ⟺ AP outbox conversion: - convert a combination of JID and optional pubsub node to AP actor handle (see `getJIDAndNode` for details) and vice versa - the gateway now provides a Pubsub service - retrieve pubsub node and convert it to AP collection, AP pagination is converted to RSM - do the opposite: convert AP collection to pubsub and handle RSM request. Due to ActivityStream collection pagination limitations, some RSM request produce inefficient requests, but caching should be used most of the time in the future and avoid the problem. - set specific name to HTTP Server - new `local_only` setting (`True` by default) to indicate if the gateway can request or not XMPP Pubsub nodes from other servers - disco info now specifies important features such as Pubsub RSM, and nodes metadata ticket 363
author Goffi <goffi@goffi.org>
date Tue, 25 Jan 2022 17:54:06 +0100
parents be6d91572633
children 524856bd7b19
line wrap: on
line source

#!/usr/bin/env python3


# SAT: a jabber client
# Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org)
# Copyright (C) 2013-2016 Adrien Cossa (souliane@mailoo.org)

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

""" Tests for the plugin room game (base class for MUC games) """

from sat.core.i18n import _
from .constants import Const
from sat.test import helpers, helpers_plugins
from sat.plugins import plugin_misc_room_game as plugin
from twisted.words.protocols.jabber.jid import JID
from wokkel.muc import User

from logging import WARNING

# Data used for test initialization
NAMESERVICE = "http://www.goffi.org/protocol/dummy"
TAG = "dummy"
PLUGIN_INFO = {
    "name": "Dummy plugin",
    "import_name": "DUMMY",
    "type": "MISC",
    "protocols": [],
    "dependencies": [],
    "main": "Dummy",
    "handler": "no",  # handler MUST be "no" (dynamic inheritance)
    "description": _("""Dummy plugin to test room game"""),
}

ROOM_JID = JID(Const.MUC_STR[0])
PROFILE = Const.PROFILE[0]
OTHER_PROFILE = Const.PROFILE[1]


class RoomGameTest(helpers.SatTestCase):
    def setUp(self):
        self.host = helpers.FakeSAT()

    def reinit(self, game_init={}, player_init={}):
        self.host.reinit()
        self.plugin = plugin.RoomGame(self.host)
        self.plugin._init_(
            self.host, PLUGIN_INFO, (NAMESERVICE, TAG), game_init, player_init
        )
        self.plugin_0045 = self.host.plugins["XEP-0045"] = helpers_plugins.FakeXEP_0045(
            self.host
        )
        self.plugin_0249 = self.host.plugins["XEP-0249"] = helpers_plugins.FakeXEP_0249(
            self.host
        )
        for profile in Const.PROFILE:
            self.host.getClient(profile)  # init self.host.profiles[profile]

    def initGame(self, muc_index, user_index):
        self.plugin_0045.joinRoom(user_index, muc_index)
        self.plugin._initGame(JID(Const.MUC_STR[muc_index]), Const.JID[user_index].user)

    def _expectedMessage(self, to, type_, tag, players=[]):
        content = "<%s" % tag
        if not players:
            content += "/>"
        else:
            content += ">"
            for i in range(0, len(players)):
                content += "<player index='%s'>%s</player>" % (i, players[i])
            content += "</%s>" % tag
        return "<message to='%s' type='%s'><%s xmlns='%s'>%s</dummy></message>" % (
            to.full(),
            type_,
            TAG,
            NAMESERVICE,
            content,
        )

    def test_createOrInvite_solo(self):
        self.reinit()
        self.plugin_0045.joinRoom(0, 0)
        self.plugin._createOrInvite(self.plugin_0045.getRoom(0, 0), [], Const.PROFILE[0])
        self.assertTrue(self.plugin._gameExists(ROOM_JID, True))

    def test_createOrInvite_multi_not_waiting(self):
        self.reinit()
        self.plugin_0045.joinRoom(0, 0)
        other_players = [Const.JID[1], Const.JID[2]]
        self.plugin._createOrInvite(
            self.plugin_0045.getRoom(0, 0), other_players, Const.PROFILE[0]
        )
        self.assertTrue(self.plugin._gameExists(ROOM_JID, True))

    def test_createOrInvite_multi_waiting(self):
        self.reinit(player_init={"score": 0})
        self.plugin_0045.joinRoom(0, 0)
        other_players = [Const.JID[1], Const.JID[2]]
        self.plugin._createOrInvite(
            self.plugin_0045.getRoom(0, 0), other_players, Const.PROFILE[0]
        )
        self.assertTrue(self.plugin._gameExists(ROOM_JID, False))
        self.assertFalse(self.plugin._gameExists(ROOM_JID, True))

    def test_initGame(self):
        self.reinit()
        self.initGame(0, 0)
        self.assertTrue(self.plugin.isReferee(ROOM_JID, Const.JID[0].user))
        self.assertEqual([], self.plugin.games[ROOM_JID]["players"])

    def test_checkJoinAuth(self):
        self.reinit()
        check = lambda value: getattr(self, "assert%s" % value)(
            self.plugin._checkJoinAuth(ROOM_JID, Const.JID[0], Const.JID[0].user)
        )
        check(False)
        # to test the "invited" mode, the referee must be different than the user to test
        self.initGame(0, 1)
        self.plugin.join_mode = self.plugin.ALL
        check(True)
        self.plugin.join_mode = self.plugin.INVITED
        check(False)
        self.plugin.invitations[ROOM_JID] = [(None, [Const.JID[0].userhostJID()])]
        check(True)
        self.plugin.join_mode = self.plugin.NONE
        check(False)
        self.plugin.games[ROOM_JID]["players"].append(Const.JID[0].user)
        check(True)

    def test_updatePlayers(self):
        self.reinit()
        self.initGame(0, 0)
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], [])
        self.plugin._updatePlayers(ROOM_JID, [], True, Const.PROFILE[0])
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], [])
        self.plugin._updatePlayers(ROOM_JID, ["user1"], True, Const.PROFILE[0])
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], ["user1"])
        self.plugin._updatePlayers(ROOM_JID, ["user2", "user3"], True, Const.PROFILE[0])
        self.assertEqual(
            self.plugin.games[ROOM_JID]["players"], ["user1", "user2", "user3"]
        )
        self.plugin._updatePlayers(
            ROOM_JID, ["user2", "user3"], True, Const.PROFILE[0]
        )  # should not be stored twice
        self.assertEqual(
            self.plugin.games[ROOM_JID]["players"], ["user1", "user2", "user3"]
        )

    def test_synchronizeRoom(self):
        self.reinit()
        self.initGame(0, 0)
        self.plugin._synchronizeRoom(ROOM_JID, [Const.MUC[0]], Const.PROFILE[0])
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "players", []),
        )
        self.plugin.games[ROOM_JID]["players"].append("test1")
        self.plugin._synchronizeRoom(ROOM_JID, [Const.MUC[0]], Const.PROFILE[0])
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "players", ["test1"]),
        )
        self.plugin.games[ROOM_JID]["started"] = True
        self.plugin.games[ROOM_JID]["players"].append("test2")
        self.plugin._synchronizeRoom(ROOM_JID, [Const.MUC[0]], Const.PROFILE[0])
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "started", ["test1", "test2"]),
        )
        self.plugin.games[ROOM_JID]["players"].append("test3")
        self.plugin.games[ROOM_JID]["players"].append("test4")
        user1 = JID(ROOM_JID.userhost() + "/" + Const.JID[0].user)
        user2 = JID(ROOM_JID.userhost() + "/" + Const.JID[1].user)
        self.plugin._synchronizeRoom(ROOM_JID, [user1, user2], Const.PROFILE[0])
        self.assertEqualXML(
            self.host.getSentMessageXml(0),
            self._expectedMessage(
                user1, "normal", "started", ["test1", "test2", "test3", "test4"]
            ),
        )
        self.assertEqualXML(
            self.host.getSentMessageXml(0),
            self._expectedMessage(
                user2, "normal", "started", ["test1", "test2", "test3", "test4"]
            ),
        )

    def test_invitePlayers(self):
        self.reinit()
        self.initGame(0, 0)
        self.plugin_0045.joinRoom(0, 1)
        self.assertEqual(self.plugin.invitations[ROOM_JID], [])
        room = self.plugin_0045.getRoom(0, 0)
        nicks = self.plugin._invitePlayers(
            room, [Const.JID[1], Const.JID[2]], Const.JID[0].user, Const.PROFILE[0]
        )
        self.assertEqual(
            self.plugin.invitations[ROOM_JID][0][1],
            [Const.JID[1].userhostJID(), Const.JID[2].userhostJID()],
        )
        # the following assertion is True because Const.JID[1] and Const.JID[2] have the same userhost
        self.assertEqual(nicks, [Const.JID[1].user, Const.JID[2].user])

        nicks = self.plugin._invitePlayers(
            room, [Const.JID[1], Const.JID[3]], Const.JID[0].user, Const.PROFILE[0]
        )
        self.assertEqual(
            self.plugin.invitations[ROOM_JID][1][1],
            [Const.JID[1].userhostJID(), Const.JID[3].userhostJID()],
        )
        # this time Const.JID[1] and Const.JID[3] have the same user but the host differs
        self.assertEqual(nicks, [Const.JID[1].user])

    def test_checkInviteAuth(self):
        def check(value, index):
            nick = self.plugin_0045.getNick(0, index)
            getattr(self, "assert%s" % value)(
                self.plugin._checkInviteAuth(ROOM_JID, nick)
            )

        self.reinit()

        for mode in [
            self.plugin.FROM_ALL,
            self.plugin.FROM_NONE,
            self.plugin.FROM_REFEREE,
            self.plugin.FROM_PLAYERS,
        ]:
            self.plugin.invite_mode = mode
            check(True, 0)

        self.initGame(0, 0)
        self.plugin.invite_mode = self.plugin.FROM_ALL
        check(True, 0)
        check(True, 1)
        self.plugin.invite_mode = self.plugin.FROM_NONE
        check(True, 0)  # game initialized but not started yet, referee can invite
        check(False, 1)
        self.plugin.invite_mode = self.plugin.FROM_REFEREE
        check(True, 0)
        check(False, 1)
        user_nick = self.plugin_0045.joinRoom(0, 1)
        self.plugin.games[ROOM_JID]["players"].append(user_nick)
        self.plugin.invite_mode = self.plugin.FROM_PLAYERS
        check(True, 0)
        check(True, 1)
        check(False, 2)

    def test_isReferee(self):
        self.reinit()
        self.initGame(0, 0)
        self.assertTrue(self.plugin.isReferee(ROOM_JID, self.plugin_0045.getNick(0, 0)))
        self.assertFalse(self.plugin.isReferee(ROOM_JID, self.plugin_0045.getNick(0, 1)))

    def test_isPlayer(self):
        self.reinit()
        self.initGame(0, 0)
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, self.plugin_0045.getNick(0, 0)))
        user_nick = self.plugin_0045.joinRoom(0, 1)
        self.plugin.games[ROOM_JID]["players"].append(user_nick)
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, user_nick))
        self.assertFalse(self.plugin.isPlayer(ROOM_JID, self.plugin_0045.getNick(0, 2)))

    def test_checkWaitAuth(self):
        def check(value, other_players, confirmed, rest):
            room = self.plugin_0045.getRoom(0, 0)
            self.assertEqual(
                (value, confirmed, rest), self.plugin._checkWaitAuth(room, other_players)
            )

        self.reinit()
        self.initGame(0, 0)
        other_players = [Const.JID[1], Const.JID[3]]
        self.plugin.wait_mode = self.plugin.FOR_NONE
        check(True, [], [], [])
        check(
            True, [Const.JID[0]], [], [Const.JID[0]]
        )  # getRoomNickOfUser checks for the other users only
        check(True, other_players, [], other_players)
        self.plugin.wait_mode = self.plugin.FOR_ALL
        check(True, [], [], [])
        check(False, [Const.JID[0]], [], [Const.JID[0]])
        check(False, other_players, [], other_players)
        self.plugin_0045.joinRoom(0, 1)
        check(False, other_players, [], other_players)
        self.plugin_0045.joinRoom(0, 4)
        check(
            False,
            other_players,
            [self.plugin_0045.getNickOfUser(0, 1, 0)],
            [Const.JID[3]],
        )
        self.plugin_0045.joinRoom(0, 3)
        check(
            True,
            other_players,
            [
                self.plugin_0045.getNickOfUser(0, 1, 0),
                self.plugin_0045.getNickOfUser(0, 3, 0),
            ],
            [],
        )

        other_players = [Const.JID[1], Const.JID[3], Const.JID[2]]
        # the following assertion is True because Const.JID[1] and Const.JID[2] have the same userhost
        check(
            True,
            other_players,
            [
                self.plugin_0045.getNickOfUser(0, 1, 0),
                self.plugin_0045.getNickOfUser(0, 3, 0),
                self.plugin_0045.getNickOfUser(0, 2, 0),
            ],
            [],
        )

    def test_prepareRoom_trivial(self):
        self.reinit()
        other_players = []
        self.plugin.prepareRoom(other_players, ROOM_JID, PROFILE)
        self.assertTrue(self.plugin._gameExists(ROOM_JID, True))
        self.assertTrue(
            self.plugin._checkJoinAuth(ROOM_JID, Const.JID[0], Const.JID[0].user)
        )
        self.assertTrue(self.plugin._checkInviteAuth(ROOM_JID, Const.JID[0].user))
        self.assertEqual((True, [], []), self.plugin._checkWaitAuth(ROOM_JID, []))
        self.assertTrue(self.plugin.isReferee(ROOM_JID, Const.JID[0].user))
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, Const.JID[0].user))
        self.assertEqual(
            (False, True), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
        )

    def test_prepareRoom_invite(self):
        self.reinit()
        other_players = [Const.JID[1], Const.JID[2]]
        self.plugin.prepareRoom(other_players, ROOM_JID, PROFILE)
        room = self.plugin_0045.getRoom(0, 0)

        self.assertTrue(self.plugin._gameExists(ROOM_JID, True))
        self.assertTrue(
            self.plugin._checkJoinAuth(ROOM_JID, Const.JID[1], Const.JID[1].user)
        )
        self.assertFalse(
            self.plugin._checkJoinAuth(ROOM_JID, Const.JID[3], Const.JID[3].user)
        )
        self.assertFalse(self.plugin._checkInviteAuth(ROOM_JID, Const.JID[1].user))
        self.assertEqual(
            (True, [], other_players), self.plugin._checkWaitAuth(room, other_players)
        )

        player2_nick = self.plugin_0045.joinRoom(0, 1)
        self.plugin.userJoinedTrigger(room, room.roster[player2_nick], PROFILE)
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, player2_nick))
        self.assertTrue(self.plugin._checkInviteAuth(ROOM_JID, player2_nick))
        self.assertFalse(self.plugin.isReferee(ROOM_JID, player2_nick))
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, player2_nick))
        self.assertTrue(
            self.plugin.isPlayer(ROOM_JID, self.plugin_0045.getNickOfUser(0, 2, 0))
        )
        self.assertFalse(self.plugin.isPlayer(ROOM_JID, "xxx"))
        self.assertEqual(
            (False, False),
            self.plugin._checkCreateGameAndInit(ROOM_JID, Const.PROFILE[1]),
        )

    def test_prepareRoom_score1(self):
        self.reinit(player_init={"score": 0})
        other_players = [Const.JID[1], Const.JID[2]]
        self.plugin.prepareRoom(other_players, ROOM_JID, PROFILE)
        room = self.plugin_0045.getRoom(0, 0)

        self.assertFalse(self.plugin._gameExists(ROOM_JID, True))
        self.assertTrue(
            self.plugin._checkJoinAuth(ROOM_JID, Const.JID[1], Const.JID[1].user)
        )
        self.assertFalse(
            self.plugin._checkJoinAuth(ROOM_JID, Const.JID[3], Const.JID[3].user)
        )
        self.assertFalse(self.plugin._checkInviteAuth(ROOM_JID, Const.JID[1].user))
        self.assertEqual(
            (False, [], other_players), self.plugin._checkWaitAuth(room, other_players)
        )

        user_nick = self.plugin_0045.joinRoom(0, 1)
        self.plugin.userJoinedTrigger(room, room.roster[user_nick], PROFILE)
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, user_nick))
        self.assertFalse(self.plugin._checkInviteAuth(ROOM_JID, user_nick))
        self.assertFalse(self.plugin.isReferee(ROOM_JID, user_nick))
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, user_nick))
        # the following assertion is True because Const.JID[1] and Const.JID[2] have the same userhost
        self.assertTrue(
            self.plugin.isPlayer(ROOM_JID, self.plugin_0045.getNickOfUser(0, 2, 0))
        )
        # the following assertion is True because Const.JID[1] nick in the room is equal to Const.JID[3].user
        self.assertTrue(self.plugin.isPlayer(ROOM_JID, Const.JID[3].user))
        # but Const.JID[3] is actually not in the room
        self.assertEqual(self.plugin_0045.getNickOfUser(0, 3, 0), None)
        self.assertEqual(
            (True, False), self.plugin._checkCreateGameAndInit(ROOM_JID, Const.PROFILE[0])
        )

    def test_prepareRoom_score2(self):
        self.reinit(player_init={"score": 0})
        other_players = [Const.JID[1], Const.JID[4]]
        self.plugin.prepareRoom(other_players, ROOM_JID, PROFILE)
        room = self.plugin_0045.getRoom(0, 0)

        user_nick = self.plugin_0045.joinRoom(0, 1)
        self.plugin.userJoinedTrigger(room, room.roster[user_nick], PROFILE)
        self.assertEqual(
            (True, False), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
        )
        user_nick = self.plugin_0045.joinRoom(0, 4)
        self.plugin.userJoinedTrigger(room, room.roster[user_nick], PROFILE)
        self.assertEqual(
            (False, True), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
        )

    def test_userJoinedTrigger(self):
        self.reinit(player_init={"xxx": "xyz"})
        other_players = [Const.JID[1], Const.JID[3]]
        self.plugin.prepareRoom(other_players, ROOM_JID, PROFILE)
        nicks = [self.plugin_0045.getNick(0, 0)]

        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "players", nicks),
        )
        self.assertTrue(len(self.plugin.invitations[ROOM_JID]) == 1)

        # wrong profile
        user_nick = self.plugin_0045.joinRoom(0, 1)
        room = self.plugin_0045.getRoom(0, 1)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[1]), OTHER_PROFILE)
        self.assertEqual(
            self.host.getSentMessage(0), None
        )  # no new message has been sent
        self.assertFalse(self.plugin._gameExists(ROOM_JID, True))  # game not started

        # referee profile, user is allowed, wait for one more
        room = self.plugin_0045.getRoom(0, 0)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[1]), PROFILE)
        nicks.append(user_nick)
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "players", nicks),
        )
        self.assertFalse(self.plugin._gameExists(ROOM_JID, True))  # game not started

        # referee profile, user is not allowed
        user_nick = self.plugin_0045.joinRoom(0, 4)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[4]), PROFILE)
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(
                JID(ROOM_JID.userhost() + "/" + user_nick), "normal", "players", nicks
            ),
        )
        self.assertFalse(self.plugin._gameExists(ROOM_JID, True))  # game not started

        # referee profile, user is allowed, everybody here
        user_nick = self.plugin_0045.joinRoom(0, 3)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[3]), PROFILE)
        nicks.append(user_nick)
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "started", nicks),
        )
        self.assertTrue(self.plugin._gameExists(ROOM_JID, True))  # game started
        self.assertTrue(len(self.plugin.invitations[ROOM_JID]) == 0)

        # wait for none
        self.reinit()
        self.plugin.prepareRoom(other_players, ROOM_JID, PROFILE)
        self.assertNotEqual(self.host.getSentMessage(0), None)  # init messages
        room = self.plugin_0045.getRoom(0, 0)
        nicks = [self.plugin_0045.getNick(0, 0)]
        user_nick = self.plugin_0045.joinRoom(0, 3)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[3]), PROFILE)
        nicks.append(user_nick)
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "started", nicks),
        )
        self.assertTrue(self.plugin._gameExists(ROOM_JID, True))

    def test_userLeftTrigger(self):
        self.reinit(player_init={"xxx": "xyz"})
        other_players = [Const.JID[1], Const.JID[3], Const.JID[4]]
        self.plugin.prepareRoom(other_players, ROOM_JID, PROFILE)
        room = self.plugin_0045.getRoom(0, 0)
        nicks = [self.plugin_0045.getNick(0, 0)]
        self.assertEqual(
            self.plugin.invitations[ROOM_JID][0][1],
            [
                Const.JID[1].userhostJID(),
                Const.JID[3].userhostJID(),
                Const.JID[4].userhostJID(),
            ],
        )

        # one user joins
        user_nick = self.plugin_0045.joinRoom(0, 1)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[1]), PROFILE)
        nicks.append(user_nick)

        # the user leaves
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], nicks)
        room = self.plugin_0045.getRoom(0, 1)
        # to not call self.plugin_0045.leaveRoom(0, 1) here, we are testing the trigger with a wrong profile
        self.plugin.userLeftTrigger(
            room, User(user_nick, Const.JID[1]), Const.PROFILE[1]
        )  # not the referee
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], nicks)
        room = self.plugin_0045.getRoom(0, 0)
        user_nick = self.plugin_0045.leaveRoom(0, 1)
        self.plugin.userLeftTrigger(
            room, User(user_nick, Const.JID[1]), PROFILE
        )  # referee
        nicks.pop()
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], nicks)

        # all the users join
        user_nick = self.plugin_0045.joinRoom(0, 1)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[1]), PROFILE)
        nicks.append(user_nick)
        user_nick = self.plugin_0045.joinRoom(0, 3)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[3]), PROFILE)
        nicks.append(user_nick)
        user_nick = self.plugin_0045.joinRoom(0, 4)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[4]), PROFILE)
        nicks.append(user_nick)
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], nicks)
        self.assertTrue(len(self.plugin.invitations[ROOM_JID]) == 0)

        # one user leaves
        user_nick = self.plugin_0045.leaveRoom(0, 4)
        self.plugin.userLeftTrigger(room, User(user_nick, Const.JID[4]), PROFILE)
        nicks.pop()
        self.assertEqual(
            self.plugin.invitations[ROOM_JID][0][1], [Const.JID[4].userhostJID()]
        )

        # another leaves
        user_nick = self.plugin_0045.leaveRoom(0, 3)
        self.plugin.userLeftTrigger(room, User(user_nick, Const.JID[3]), PROFILE)
        nicks.pop()
        self.assertEqual(
            self.plugin.invitations[ROOM_JID][0][1],
            [Const.JID[4].userhostJID(), Const.JID[3].userhostJID()],
        )

        # they can join again
        user_nick = self.plugin_0045.joinRoom(0, 3)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[3]), PROFILE)
        nicks.append(user_nick)
        user_nick = self.plugin_0045.joinRoom(0, 4)
        self.plugin.userJoinedTrigger(room, User(user_nick, Const.JID[4]), PROFILE)
        nicks.append(user_nick)
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], nicks)
        self.assertTrue(len(self.plugin.invitations[ROOM_JID]) == 0)

    def test__checkCreateGameAndInit(self):
        self.reinit()
        helpers.muteLogging()
        self.assertEqual(
            (False, False), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
        )
        helpers.unmuteLogging()

        nick = self.plugin_0045.joinRoom(0, 0)
        self.assertEqual(
            (True, False), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
        )
        self.assertTrue(self.plugin._gameExists(ROOM_JID, False))
        self.assertFalse(self.plugin._gameExists(ROOM_JID, True))
        self.assertTrue(self.plugin.isReferee(ROOM_JID, nick))

        helpers.muteLogging()
        self.assertEqual(
            (False, False), self.plugin._checkCreateGameAndInit(ROOM_JID, OTHER_PROFILE)
        )
        helpers.unmuteLogging()

        self.plugin_0045.joinRoom(0, 1)
        self.assertEqual(
            (False, False), self.plugin._checkCreateGameAndInit(ROOM_JID, OTHER_PROFILE)
        )

        self.plugin.createGame(ROOM_JID, [Const.JID[1]], PROFILE)
        self.assertEqual(
            (False, True), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
        )
        self.assertEqual(
            (False, False), self.plugin._checkCreateGameAndInit(ROOM_JID, OTHER_PROFILE)
        )

    def test_createGame(self):

        self.reinit(player_init={"xxx": "xyz"})
        nicks = []
        for i in [0, 1, 3, 4]:
            nicks.append(self.plugin_0045.joinRoom(0, i))

        # game not exists
        self.plugin.createGame(ROOM_JID, nicks, PROFILE)
        self.assertTrue(self.plugin._gameExists(ROOM_JID, True))
        self.assertEqual(self.plugin.games[ROOM_JID]["players"], nicks)
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "started", nicks),
        )
        for nick in nicks:
            self.assertEqual("init", self.plugin.games[ROOM_JID]["status"][nick])
            self.assertEqual(
                self.plugin.player_init, self.plugin.games[ROOM_JID]["players_data"][nick]
            )
            self.plugin.games[ROOM_JID]["players_data"][nick]["xxx"] = nick
        for nick in nicks:
            # checks that a copy of self.player_init has been done and not a reference
            self.assertEqual(
                nick, self.plugin.games[ROOM_JID]["players_data"][nick]["xxx"]
            )

        # game exists, current profile is referee
        self.reinit(player_init={"xxx": "xyz"})
        self.initGame(0, 0)
        self.plugin.games[ROOM_JID]["started"] = True
        self.plugin.createGame(ROOM_JID, nicks, PROFILE)
        self.assertEqual(
            self.host.getSentMessageXml(0),
            self._expectedMessage(ROOM_JID, "groupchat", "started", nicks),
        )

        # game exists, current profile is not referee
        self.reinit(player_init={"xxx": "xyz"})
        self.initGame(0, 0)
        self.plugin.games[ROOM_JID]["started"] = True
        self.plugin_0045.joinRoom(0, 1)
        self.plugin.createGame(ROOM_JID, nicks, OTHER_PROFILE)
        self.assertEqual(
            self.host.getSentMessage(0), None
        )  # no sync message has been sent by other_profile