--- a/sat/test/test_plugin_misc_room_game.py	Wed Jun 27 07:51:29 2018 +0200
+++ b/sat/test/test_plugin_misc_room_game.py	Wed Jun 27 20:14:46 2018 +0200
@@ -30,8 +30,8 @@
 from logging import WARNING
 
 # Data used for test initialization
-NAMESERVICE = 'http://www.goffi.org/protocol/dummy'
-TAG = 'dummy'
+NAMESERVICE = "http://www.goffi.org/protocol/dummy"
+TAG = "dummy"
 PLUGIN_INFO = {
     "name": "Dummy plugin",
     "import_name": "DUMMY",
@@ -40,7 +40,7 @@
     "dependencies": [],
     "main": "Dummy",
     "handler": "no",  # handler MUST be "no" (dynamic inheritance)
-    "description": _("""Dummy plugin to test room game""")
+    "description": _("""Dummy plugin to test room game"""),
 }
 
 ROOM_JID = JID(Const.MUC_STR[0])
@@ -49,16 +49,21 @@
 
 
 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)
+        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]
 
@@ -75,7 +80,13 @@
             for i in xrange(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)
+        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()
@@ -87,14 +98,18 @@
         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.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.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.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))
 
@@ -102,11 +117,13 @@
         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'])
+        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 = 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)
@@ -118,41 +135,66 @@
         check(True)
         self.plugin.join_mode = self.plugin.NONE
         check(False)
-        self.plugin.games[ROOM_JID]['players'].append(Const.JID[0].user)
+        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.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.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.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"])
+        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.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.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")
+        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"]))
+        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()
@@ -160,25 +202,41 @@
         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()])
+        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()])
+        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))
+            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]:
+        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)
 
@@ -193,7 +251,7 @@
         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.games[ROOM_JID]["players"].append(user_nick)
         self.plugin.invite_mode = self.plugin.FROM_PLAYERS
         check(True, 0)
         check(True, 1)
@@ -210,22 +268,25 @@
         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.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.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, [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, [], [], [])
@@ -234,28 +295,51 @@
         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]])
+        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)], [])
+        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)], [])
+        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._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))
+        self.assertEqual(
+            (False, True), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
+        )
 
     def test_prepareRoom_invite(self):
         self.reinit()
@@ -264,10 +348,16 @@
         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.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))
+        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)
@@ -275,21 +365,32 @@
         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.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]))
+        self.assertEqual(
+            (False, False),
+            self.plugin._checkCreateGameAndInit(ROOM_JID, Const.PROFILE[1]),
+        )
 
     def test_prepareRoom_score1(self):
-        self.reinit(player_init={'score': 0})
+        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.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))
+        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)
@@ -298,25 +399,33 @@
         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)))
+        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]))
+        self.assertEqual(
+            (True, False), self.plugin._checkCreateGameAndInit(ROOM_JID, Const.PROFILE[0])
+        )
 
     def test_prepareRoom_score2(self):
-        self.reinit(player_init={'score': 0})
+        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))
+        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))
+        self.assertEqual(
+            (False, True), self.plugin._checkCreateGameAndInit(ROOM_JID, PROFILE)
+        )
 
     def test_userJoinedTrigger(self):
         self.reinit(player_init={"xxx": "xyz"})
@@ -324,34 +433,50 @@
         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.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.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.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.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.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)
 
@@ -364,7 +489,10 @@
         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.assertEqual(
+            self.host.getSentMessageXml(0),
+            self._expectedMessage(ROOM_JID, "groupchat", "started", nicks),
+        )
         self.assertTrue(self.plugin._gameExists(ROOM_JID, True))
 
     def test_userLeftTrigger(self):
@@ -373,7 +501,14 @@
         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()])
+        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)
@@ -381,16 +516,20 @@
         nicks.append(user_nick)
 
         # the user leaves
-        self.assertEqual(self.plugin.games[ROOM_JID]['players'], nicks)
+        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)
+        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
+        self.plugin.userLeftTrigger(
+            room, User(user_nick, Const.JID[1]), PROFILE
+        )  # referee
         nicks.pop()
-        self.assertEqual(self.plugin.games[ROOM_JID]['players'], nicks)
+        self.assertEqual(self.plugin.games[ROOM_JID]["players"], nicks)
 
         # all the users join
         user_nick = self.plugin_0045.joinRoom(0, 1)
@@ -402,20 +541,25 @@
         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.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()])
+        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()])
+        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)
@@ -424,31 +568,43 @@
         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.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))
+        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.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))
+        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.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))
+        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):
 
@@ -460,27 +616,39 @@
         # 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))
+        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
+            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'])
+            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.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))
+        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.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
+        self.assertEqual(
+            self.host.getSentMessage(0), None
+        )  # no sync message has been sent by other_profile