Mercurial > libervia-backend

diff src/test/test_plugin_misc_room_game.py @ 1271:2308f8405ffb

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
test: refactoring: - rename internal init methods to reinit - rename getSentMessage to getSentMessageXml - rename getSentMessageRaw to getSentMessage
author souliane <souliane@mailoo.org>
date Fri, 19 Dec 2014 11:36:00 +0100
parents b3f383ab39da
children 069ad98b360d
line wrap: on
line diff
--- a/src/test/test_plugin_misc_room_game.py	Mon Dec 15 15:29:08 2014 +0100
+++ b/src/test/test_plugin_misc_room_game.py	Fri Dec 19 11:36:00 2014 +0100
@@ -54,8 +54,8 @@
     def setUp(self):
         self.host = helpers.FakeSAT()
 
-    def init(self, game_init={}, player_init={}):
-        self.host.init()
+    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)
@@ -83,20 +83,20 @@
         return "<message to='%s' type='%s'><%s xmlns='%s'>%s</dummy></message>" % (to, type_, TAG, NAMESERVICE, content)
 
     def test_createOrInvite_solo(self):
-        self.init()
+        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_S, True))
 
     def test_createOrInvite_multi_not_waiting(self):
-        self.init()
+        self.reinit()
         self.plugin_0045.joinRoom(0, 0)
         other_players = [Const.JID_STR[1], Const.JID_STR[2]]
         self.plugin._createOrInvite(self.plugin_0045.getRoom(0, 0), other_players, Const.PROFILE[0])
         self.assertTrue(self.plugin._gameExists(ROOM_JID_S, True))
 
     def test_createOrInvite_multi_waiting(self):
-        self.init(player_init={'score': 0})
+        self.reinit(player_init={'score': 0})
         self.plugin_0045.joinRoom(0, 0)
         other_players = [Const.JID_STR[1], Const.JID_STR[2]]
         self.plugin._createOrInvite(self.plugin_0045.getRoom(0, 0), other_players, Const.PROFILE[0])
@@ -104,13 +104,13 @@
         self.assertFalse(self.plugin._gameExists(ROOM_JID_S, True))
 
     def test_initGame(self):
-        self.init()
+        self.reinit()
         self.initGame(0, 0)
         self.assertTrue(self.plugin.isReferee(ROOM_JID_S, Const.JID[0].user))
         self.assertEqual([], self.plugin.games[ROOM_JID_S]['players'])
 
     def test_checkJoinAuth(self):
-        self.init()
+        self.reinit()
         check = lambda value: getattr(self, "assert%s" % value)(self.plugin._checkJoinAuth(ROOM_JID_S, Const.JID_STR[0], Const.JID[0].user))
         check(False)
         # to test the "invited" mode, the referee must be different than the user to test
@@ -127,7 +127,7 @@
         check(True)
 
     def test_updatePlayers(self):
-        self.init()
+        self.reinit()
         self.initGame(0, 0)
         self.assertEqual(self.plugin.games[ROOM_JID_S]['players'], [])
         self.plugin._updatePlayers(ROOM_JID_S, [], True, Const.PROFILE[0])
@@ -140,27 +140,27 @@
         self.assertEqual(self.plugin.games[ROOM_JID_S]['players'], ["user1", "user2", "user3"])
 
     def test_synchronizeRoom(self):
-        self.init()
+        self.reinit()
         self.initGame(0, 0)
         self.plugin._synchronizeRoom(ROOM_JID_S, [Const.MUC[0]], Const.PROFILE[0])
-        self.assertEqual(self.host.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", []))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", []))
         self.plugin.games[ROOM_JID_S]['players'].append("test1")
         self.plugin._synchronizeRoom(ROOM_JID_S, [Const.MUC[0]], Const.PROFILE[0])
-        self.assertEqual(self.host.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", ["test1"]))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", ["test1"]))
         self.plugin.games[ROOM_JID_S]['started'] = True
         self.plugin.games[ROOM_JID_S]['players'].append("test2")
         self.plugin._synchronizeRoom(ROOM_JID_S, [Const.MUC[0]], Const.PROFILE[0])
-        self.assertEqual(self.host.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", ["test1", "test2"]))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", ["test1", "test2"]))
         self.plugin.games[ROOM_JID_S]['players'].append("test3")
         self.plugin.games[ROOM_JID_S]['players'].append("test4")
         user1 = JID(ROOM_JID_S + "/" + Const.JID[0].user)
         user2 = JID(ROOM_JID_S + "/" + Const.JID[1].user)
         self.plugin._synchronizeRoom(ROOM_JID_S, [user1, user2], Const.PROFILE[0])
-        self.assertEqualXML(self.host.getSentMessage(0), self._expectedMessage(user1.full(), "normal", "started", ["test1", "test2", "test3", "test4"]))
-        self.assertEqualXML(self.host.getSentMessage(0), self._expectedMessage(user2.full(), "normal", "started", ["test1", "test2", "test3", "test4"]))
+        self.assertEqualXML(self.host.getSentMessageXml(0), self._expectedMessage(user1.full(), "normal", "started", ["test1", "test2", "test3", "test4"]))
+        self.assertEqualXML(self.host.getSentMessageXml(0), self._expectedMessage(user2.full(), "normal", "started", ["test1", "test2", "test3", "test4"]))
 
     def test_invitePlayers(self):
-        self.init()
+        self.reinit()
         self.initGame(0, 0)
         self.plugin_0045.joinRoom(0, 1)
         self.assertEqual(self.plugin.invitations[ROOM_JID_S], [])
@@ -181,7 +181,7 @@
             nick = self.plugin_0045.getNick(0, index)
             getattr(self, "assert%s" % value)(self.plugin._checkInviteAuth(ROOM_JID_S, nick))
 
-        self.init()
+        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
@@ -205,13 +205,13 @@
         check(False, 2)
 
     def test_isReferee(self):
-        self.init()
+        self.reinit()
         self.initGame(0, 0)
         self.assertTrue(self.plugin.isReferee(ROOM_JID_S, self.plugin_0045.getNick(0, 0)))
         self.assertFalse(self.plugin.isReferee(ROOM_JID_S, self.plugin_0045.getNick(0, 1)))
 
     def test_isPlayer(self):
-        self.init()
+        self.reinit()
         self.initGame(0, 0)
         self.assertTrue(self.plugin.isPlayer(ROOM_JID_S, self.plugin_0045.getNick(0, 0)))
         user_nick = self.plugin_0045.joinRoom(0, 1)
@@ -225,7 +225,7 @@
             room = self.plugin_0045.getRoom(0, 0)
             self.assertEqual((value, confirmed, rest), self.plugin._checkWaitAuth(room, other_players))
 
-        self.init()
+        self.reinit()
         self.initGame(0, 0)
         other_players = [Const.JID[1], Const.JID[3]]
         self.plugin.wait_mode = self.plugin.FOR_NONE
@@ -251,7 +251,7 @@
                                     self.plugin_0045.getNickOfUser(0, 2, 0)], [])
 
     def test_prepareRoom_trivial(self):
-        self.init()
+        self.reinit()
         other_players = []
         self.plugin.prepareRoom(other_players, ROOM_JID_S, PROFILE)
         self.assertTrue(self.plugin._gameExists(ROOM_JID_S, True))
@@ -263,7 +263,7 @@
         self.assertEqual((False, True), self.plugin._checkCreateGameAndInit(ROOM_JID_S, PROFILE))
 
     def test_prepareRoom_invite(self):
-        self.init()
+        self.reinit()
         other_players = [Const.JID_STR[1], Const.JID_STR[2]]
         self.plugin.prepareRoom(other_players, ROOM_JID_S, PROFILE)
         room = self.plugin_0045.getRoom(0, 0)
@@ -285,7 +285,7 @@
         self.assertEqual((False, False), self.plugin._checkCreateGameAndInit(ROOM_JID_S, Const.PROFILE[1]))
 
     def test_prepareRoom_score1(self):
-        self.init(player_init={'score': 0})
+        self.reinit(player_init={'score': 0})
         other_players = [Const.JID_STR[1], Const.JID_STR[2]]
         self.plugin.prepareRoom(other_players, ROOM_JID_S, PROFILE)
         room = self.plugin_0045.getRoom(0, 0)
@@ -311,7 +311,7 @@
         self.assertEqual((True, False), self.plugin._checkCreateGameAndInit(ROOM_JID_S, Const.PROFILE[0]))
 
     def test_prepareRoom_score2(self):
-        self.init(player_init={'score': 0})
+        self.reinit(player_init={'score': 0})
         other_players = [Const.JID_STR[1], Const.JID_STR[4]]
         self.plugin.prepareRoom(other_players, ROOM_JID_S, PROFILE)
         room = self.plugin_0045.getRoom(0, 0)
@@ -324,56 +324,56 @@
         self.assertEqual((False, True), self.plugin._checkCreateGameAndInit(ROOM_JID_S, PROFILE))
 
     def test_userJoinedTrigger(self):
-        self.init(player_init={"xxx": "xyz"})
+        self.reinit(player_init={"xxx": "xyz"})
         other_players = [Const.JID_STR[1], Const.JID_STR[3]]
         self.plugin.prepareRoom(other_players, ROOM_JID_S, PROFILE)
         nicks = [self.plugin_0045.getNick(0, 0)]
 
-        self.assertEqual(self.host.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", nicks))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", nicks))
         self.assertTrue(len(self.plugin.invitations[ROOM_JID_S]) == 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.getSentMessageRaw(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_S, 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.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", nicks))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "players", nicks))
         self.assertFalse(self.plugin._gameExists(ROOM_JID_S, 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.getSentMessage(0), self._expectedMessage(ROOM_JID_S + '/' + user_nick, "normal", "players", nicks))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S + '/' + user_nick, "normal", "players", nicks))
         self.assertFalse(self.plugin._gameExists(ROOM_JID_S, 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.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
         self.assertTrue(self.plugin._gameExists(ROOM_JID_S, True))  # game started
         self.assertTrue(len(self.plugin.invitations[ROOM_JID_S]) == 0)
 
         # wait for none
-        self.init()
+        self.reinit()
         self.plugin.prepareRoom(other_players, ROOM_JID_S, PROFILE)
-        self.assertNotEqual(self.host.getSentMessageRaw(0), None)  # init messages
+        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.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
         self.assertTrue(self.plugin._gameExists(ROOM_JID_S, True))
 
     def test_userLeftTrigger(self):
-        self.init(player_init={"xxx": "xyz"})
+        self.reinit(player_init={"xxx": "xyz"})
         other_players = [Const.JID_STR[1], Const.JID_STR[3], Const.JID_STR[4]]
         self.plugin.prepareRoom(other_players, ROOM_JID_S, PROFILE)
         room = self.plugin_0045.getRoom(0, 0)
@@ -433,7 +433,7 @@
         self.assertTrue(len(self.plugin.invitations[ROOM_JID_S]) == 0)
 
     def test__checkCreateGameAndInit(self):
-        self.init()
+        self.reinit()
         self.assertEqual((False, False), self.plugin._checkCreateGameAndInit(ROOM_JID_S, PROFILE))  # print internal error
 
         nick = self.plugin_0045.joinRoom(0, 0)
@@ -453,7 +453,7 @@
 
     def test_createGame(self):
 
-        self.init(player_init={"xxx": "xyz"})
+        self.reinit(player_init={"xxx": "xyz"})
         nicks = []
         for i in [0, 1, 3, 4]:
             nicks.append(self.plugin_0045.joinRoom(0, i))
@@ -462,7 +462,7 @@
         self.plugin.createGame(ROOM_JID_S, nicks, PROFILE)
         self.assertTrue(self.plugin._gameExists(ROOM_JID_S, True))
         self.assertEqual(self.plugin.games[ROOM_JID_S]['players'], nicks)
-        self.assertEqual(self.host.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
         for nick in nicks:
             self.assertEqual('init', self.plugin.games[ROOM_JID_S]['status'][nick])
             self.assertEqual(self.plugin.player_init, self.plugin.games[ROOM_JID_S]['players_data'][nick])
@@ -472,16 +472,16 @@
             self.assertEqual(nick, self.plugin.games[ROOM_JID_S]['players_data'][nick]['xxx'])
 
         # game exists, current profile is referee
-        self.init(player_init={"xxx": "xyz"})
+        self.reinit(player_init={"xxx": "xyz"})
         self.initGame(0, 0)
         self.plugin.games[ROOM_JID_S]['started'] = True
         self.plugin.createGame(ROOM_JID_S, nicks, PROFILE)
-        self.assertEqual(self.host.getSentMessage(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
+        self.assertEqual(self.host.getSentMessageXml(0), self._expectedMessage(ROOM_JID_S, "groupchat", "started", nicks))
 
         # game exists, current profile is not referee
-        self.init(player_init={"xxx": "xyz"})
+        self.reinit(player_init={"xxx": "xyz"})
         self.initGame(0, 0)
         self.plugin.games[ROOM_JID_S]['started'] = True
         self.plugin_0045.joinRoom(0, 1)
         self.plugin.createGame(ROOM_JID_S, nicks, OTHER_PROFILE)
-        self.assertEqual(self.host.getSentMessageRaw(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