def testHandleData(self): """Testing handleData""" fakeProcessQueuesDeferred = self.fakeProcessQueuesDeferred() self.u._expected_len = 3 self.u._packet.append("\x00\x00\x03") self.u._packet_len = len("\x00\x00\x03") clear_all_messages() self.u.handleData() self.assertEquals(get_messages(), ['(3 bytes) => type = NONE(0)']) self.u._poll = False self.u._packet.append("\x00\x00\x03") self.u._packet_len = len("\x00\x00\x03") clear_all_messages() self.u.handleData() self.assertEquals(get_messages(), ['(3 bytes) => type = NONE(0)']) self.u._packet.append("\xff\x00\x03") self.u._packet_len = len("\xff\x00\x03") clear_all_messages() self.u.handleData() self.assertEquals(get_messages(), [': unknown message received (id 255, length 3)\n', "known types are {0: 'NONE', 1: 'STRING', 2: 'INT', 3: 'ERROR', 4: 'ACK', 5: 'PING', 6: 'SERIAL', 7: 'QUIT', 8: 'AUTH_OK', 9: 'AUTH_REFUSED', 10: 'LOGIN', 11: 'AUTH_REQUEST', 12: 'LIST', 13: 'LOGOUT', 14: 'BOOTSTRAP', 15: 'PROTOCOL_ERROR', 16: 'MESSAGE', 50: 'POKER_SEATS', 51: 'POKER_ID', 52: 'POKER_MESSAGE', 53: 'ERROR', 54: 'POKER_POSITION', 55: 'POKER_INT', 56: 'POKER_BET', 57: 'POKER_FOLD', 58: 'POKER_STATE', 59: 'POKER_WIN', 60: 'POKER_CARDS', 61: 'POKER_PLAYER_CARDS', 62: 'POKER_BOARD_CARDS', 63: 'POKER_CHIPS', 64: 'POKER_PLAYER_CHIPS', 65: 'POKER_CHECK', 66: 'POKER_START', 67: 'POKER_IN_GAME', 68: 'POKER_CALL', 69: 'POKER_RAISE', 70: 'POKER_DEALER', 71: 'POKER_TABLE_JOIN', 72: 'POKER_TABLE_SELECT', 73: 'POKER_TABLE', 74: 'POKER_TABLE_LIST', 75: 'POKER_SIT', 76: 'POKER_TABLE_DESTROY', 77: 'POKER_TIMEOUT_WARNING', 78: 'POKER_TIMEOUT_NOTICE', 79: 'POKER_SEAT', 80: 'POKER_TABLE_MOVE', 81: 'POKER_PLAYER_LEAVE', 82: 'POKER_SIT_OUT', 83: 'POKER_TABLE_QUIT', 84: 'POKER_BUY_IN', 85: 'POKER_REBUY', 86: 'POKER_CHAT', 87: 'POKER_PLAYER_INFO', 88: 'POKER_PLAYER_ARRIVE', 89: 'POKER_HAND_SELECT', 90: 'POKER_HAND_LIST', 91: 'POKER_HAND_SELECT_ALL', 92: 'POKER_USER_INFO', 93: 'POKER_GET_USER_INFO', 94: 'POKER_ANTE', 95: 'POKER_BLIND', 96: 'POKER_WAIT_BIG_BLIND', 97: 'POKER_AUTO_BLIND_ANTE', 98: 'POKER_NOAUTO_BLIND_ANTE', 99: 'POKER_CANCELED', 100: 'POKER_BLIND_REQUEST', 101: 'POKER_ANTE_REQUEST', 102: 'POKER_AUTO_FOLD', 103: 'POKER_WAIT_FOR', 104: 'POKER_STREAM_MODE', 105: 'POKER_BATCH_MODE', 106: 'POKER_LOOK_CARDS', 107: 'POKER_TABLE_REQUEST_PLAYERS_LIST', 108: 'POKER_PLAYERS_LIST', 109: 'POKER_PERSONAL_INFO', 110: 'POKER_GET_PERSONAL_INFO', 111: 'POKER_TOURNEY_SELECT', 112: 'POKER_TOURNEY', 113: 'POKER_TOURNEY_INFO', 114: 'POKER_TOURNEY_LIST', 115: 'POKER_TOURNEY_REQUEST_PLAYERS_LIST', 116: 'POKER_TOURNEY_REGISTER', 117: 'POKER_TOURNEY_UNREGISTER', 118: 'POKER_TOURNEY_PLAYERS_LIST', 119: 'POKER_HAND_HISTORY', 120: 'POKER_SET_ACCOUNT', 121: 'POKER_CREATE_ACCOUNT', 122: 'POKER_PLAYER_SELF', 123: 'POKER_GET_PLAYER_INFO', 124: 'POKER_ROLES', 125: 'POKER_SET_ROLE', 126: 'POKER_READY_TO_PLAY', 127: 'POKER_PROCESSING_HAND', 128: 'POKER_MUCK_REQUEST', 129: 'POKER_AUTO_MUCK', 130: 'POKER_MUCK_ACCEPT', 131: 'POKER_MUCK_DENY', 132: 'POKER_CASH_IN', 133: 'POKER_CASH_OUT', 134: 'POKER_CASH_OUT_COMMIT', 135: 'POKER_CASH_QUERY', 136: 'POKER_RAKE', 137: 'POKER_TOURNEY_RANK', 138: 'POKER_PLAYER_IMAGE', 139: 'POKER_GET_PLAYER_IMAGE', 140: 'POKER_HAND_REPLAY', 141: 'POKER_GAME_MESSAGE', 142: 'POKER_EXPLAIN', 143: 'POKER_STATS_QUERY', 144: 'POKER_STATS', 145: 'POKER_BUY_IN_LIMITS', 146: 'POKER_MONITOR', 147: 'POKER_MONITOR_EVENT', 148: 'POKER_GET_TOURNEY_MANAGER', 149: 'POKER_TOURNEY_MANAGER', 151: 'POKER_GET_PLAYER_PLACES', 152: 'POKER_PLAYER_PLACES', 153: 'POKER_SET_LOCALE', 154: 'POKER_TABLE_TOURNEY_BREAK_BEGIN', 155: 'POKER_TABLE_TOURNEY_BREAK_DONE', 156: 'POKER_TOURNEY_START', 161: 'POKER_PLAYER_STATS', 164: 'POKER_TOURNEY_INFO', 165: 'POKER_TABLE_PICKER', 166: 'POKER_CREATE_TOURNEY', 167: 'POKER_LONG_POLL', 168: 'POKER_LONG_POLL_RETURN', 170: 'POKER_BEST_CARDS', 171: 'POKER_POT_CHIPS', 172: 'POKER_CLIENT_ACTION', 173: 'POKER_BET_LIMIT', 174: 'POKER_SIT_REQUEST', 175: 'POKER_PLAYER_NO_CARDS', 176: 'POKER_CHIPS_PLAYER2BET', 177: 'POKER_CHIPS_BET2POT', 178: 'POKER_CHIPS_POT2PLAYER', 179: 'POKER_CHIPS_POT_MERGE', 180: 'POKER_CHIPS_POT_RESET', 181: 'POKER_CHIPS_BET2PLAYER', 182: 'POKER_END_ROUND', 183: 'POKER_DISPLAY_NODE', 184: 'POKER_DEAL_CARDS', 185: 'POKER_CHAT_HISTORY', 186: 'POKER_DISPLAY_CARD', 187: 'POKER_SELF_IN_POSITION', 188: 'POKER_SELF_LOST_POSITION', 189: 'POKER_HIGHEST_BET_INCREASE', 190: 'POKER_PLAYER_WIN', 191: 'POKER_ANIMATION_PLAYER_NOISE', 192: 'POKER_ANIMATION_PLAYER_FOLD', 193: 'POKER_ANIMATION_PLAYER_BET', 194: 'POKER_ANIMATION_PLAYER_CHIPS', 195: 'POKER_ANIMATION_DEALER_CHANGE', 196: 'POKER_ANIMATION_DEALER_BUTTON', 197: 'POKER_BEGIN_ROUND', 198: 'POKER_CURRENT_GAMES', 199: 'POKER_END_ROUND_LAST', 200: 'POKER_PYTHON_ANIMATION', 201: 'POKER_SIT_OUT_NEXT_TURN', 202: 'POKER_RENDERER_STATE', 203: 'POKER_CHAT_WORD', 204: 'POKER_SHOWDOWN', 205: 'POKER_CLIENT_PLAYER_CHIPS', 206: 'POKER_INTERFACE_COMMAND', 207: 'POKER_PLAYER_ME_LOOK_CARDS', 208: 'POKER_PLAYER_ME_IN_FIRST_PERSON', 209: 'POKER_ALLIN_SHOWDOWN', 210: 'POKER_PLAYER_HAND_STRENGTH'} "]) # trying with wrong packet self.u._packet.append("\xff\x00\x00") self.u._packet_len = len("\xff\x00\x00") clear_all_messages() self.u.handleData() # FIXME (maybe): I am not completely sure it's correct that we # should get absolutely no output when we send the "wrong packet". # I've asked Loic to take a look. self.assertEquals(get_messages(), []) return fakeProcessQueuesDeferred
def deferPacket(self, client): server = self.server_factory.instance self.failUnless(search_output('protocol established')) clear_all_messages() self.deferredPacket = defer.Deferred() server.sendPackets([self.deferredPacket, PacketAck()]) self.assertEquals(get_messages(), []) self.deferredPacket.callback(PacketPing()) self.assertEquals(get_messages(), []) def callbackDeferredPacket(client): pingFound = False ackFound = False msgs = get_messages() for msg in get_messages(): if msg == '(3 bytes) => type = PING(5)': self.failIf(pingFound or ackFound) pingFound = True elif msg == '(3 bytes) => type = ACK(4)': self.failUnless(pingFound) ackFound = True self.failUnless(ackFound and pingFound) d = client.connection_lost_deferred d.addCallback(callbackDeferredPacket) return d
def deferErrorPacket(self, client): server = self.server_factory.instance clear_all_messages() self.deferredPacket = defer.Deferred() server.sendPackets([self.deferredPacket, PacketAck()]) self.assertEquals(get_messages(), []) self.deferredPacket.errback("forced to fail") self.assertEquals(get_messages(), []) def callbackDeferredPacket(client): errFound = False ackFound = False msgs = get_messages() for msg in get_messages(): if msg == "(132 bytes) => type = ERROR(3) message = [Failure instance: Traceback (failure with no frames): <class 'twisted.python.failure.DefaultException'>: forced to fail\n], code = 0, other_type = ERROR": self.failIf(errFound or ackFound) errFound = True elif msg == '(3 bytes) => type = ACK(4)': self.failUnless(errFound) ackFound = True self.failUnless(ackFound and errFound) d = client.connection_lost_deferred d.addCallback(callbackDeferredPacket) return d
def validate(result): if isinstance(result, failure.Failure): raise result self.assertEqual("lock01", result) for string in ['__acquire lock01', '__acquire got MySQL lock', 'acquired' ]: if not search_output(string): print get_messages() self.failUnless(search_output(string), "missing '%s' in output" % string) return lockFastTimeout()
def validate(result): if isinstance(result, failure.Failure): raise result for string in ['__acquire lock01', 'acquired', '__acquire got MySQL lock']: if not search_output(string): print get_messages() self.failUnless(search_output(string), "%s not found in string" % string) self.assertEqual("lock01", result) return locker2()
def locker2_failed(result): for string in [ '__acquire lock01', 'acquired', 'exception in function', 'release because exception', 'loop, queue size']: if not search_output(string): print get_messages() self.failUnless(search_output(string), "missing '%s' in output" % string) clear_all_messages() self.locker.release('lock01') self.assertTrue(isinstance(result, failure.Failure)) self.assertEqual(result.value[0], pokerlock.PokerLock.TIMED_OUT) self.locker2.close()
def callbackDeferredPacket(client): pingFound = False ackFound = False msgs = get_messages() for msg in get_messages(): if msg == '(3 bytes) => type = PING(5)': self.failIf(pingFound or ackFound) pingFound = True elif msg == '(3 bytes) => type = ACK(4)': self.failUnless(pingFound) ackFound = True self.failUnless(ackFound and pingFound)
def callbackDeferredPacket(client): errFound = False ackFound = False msgs = get_messages() for msg in get_messages(): if msg == "(132 bytes) => type = ERROR(3) message = [Failure instance: Traceback (failure with no frames): <class 'twisted.python.failure.DefaultException'>: forced to fail\n], code = 0, other_type = ERROR": self.failIf(errFound or ackFound) errFound = True elif msg == '(3 bytes) => type = ACK(4)': self.failUnless(errFound) ackFound = True self.failUnless(ackFound and errFound)
def testHandleConnection(self): """Testing _handleConnection""" clear_all_messages() # there is just a pass here in the implementation, there is really # nothing to be done to truly test it. self.assertEquals(self.u._handleConnection("..."), None) self.assertEquals(get_messages(), [])
def test02_pingWithoutTimer(self): clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') del server.__dict__['_ping_timer'] self.assertEquals(server.ping(), None) self.assertEqual(get_messages(), [])
def test08_connectionLostNonePingTimerNoAvatar(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') server._processQueues = self.processQueuesCounter server.ignoreIncomingData = self.ignoreIncomingDataCounter server._ping_timer = None server._queues = [] server.avatar = None self.assertEquals(server.connectionLost("test08"), None) self.failIf(server.__dict__.has_key('avatar')) self.assertEquals(server._ping_timer, None) self.assertEquals(processQueuesCount, 0) self.assertEquals(ignoreIncomingDataCount, 1) self.assertEquals(self.server_factory.destroyedAvatars, []) self.assertEquals(get_messages(), [ 'connectionLost: reason = test08', 'connectionLost: reason = test08', 'client with protocol different rejected (need 002.000)' ])
def test09_connectionLostNoPingTimerWithAvatarButNoQueues(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') server._protocol_ok = True server._processQueues = self.processQueuesCounter server.ignoreIncomingData = self.ignoreIncomingDataCounter del server._ping_timer server._queues = [] server.avatar = FakeAvatar() self.assertEquals(server.connectionLost("test09"), None) self.failIf(server.__dict__.has_key('avatar')) self.assertEquals(server._ping_timer, None) self.assertEquals(processQueuesCount, 0) self.assertEquals(ignoreIncomingDataCount, 1) self.assertEquals(len(self.server_factory.destroyedAvatars), 1) self.failUnless( isinstance(self.server_factory.destroyedAvatars[0], FakeAvatar)) self.assertEquals(get_messages(), ['connectionLost: reason = test09'])
def test03_pingWithNoneTimer(self): clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') server._ping_timer = None self.assertEquals(server.ping(), None) self.assertEqual(get_messages(), [])
def dummyClientError(self, client): silence_all_messages() clear_all_messages() client.error("stupid dummy error test since client never calls") self.assertEquals( get_messages(), ["ERROR stupid dummy error test since client never calls"]) return (client, )
def test06_validAuthWhenEntryExists(self): """test06_validAuthWhenEntryExists Tests case for single-row returned existing auth, both success and failure. """ cursor = self.db.cursor() cursor.execute( "INSERT INTO users (created, name, password) values (%d, '%s', '%s')" % (seconds(), "dan_harrington", "bar") ) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth("dan_harrington", "bar"), ((4L, "dan_harrington", 1L), None)) self.assertEquals(get_messages(), []) clear_all_messages() self.assertEquals(auth.auth("dan_harrington", "wrongpass"), (False, "Invalid login or password")) self.assertEquals(get_messages(), ["password mismatch for dan_harrington"])
def test06_validAuthWhenEntryExists(self): """test06_validAuthWhenEntryExists Tests case for single-row returned existing auth, both success and failure. """ cursor = self.db.cursor() cursor.execute( "INSERT INTO %s (username, password, privilege) values ('%s', '%s', %i)" % (self.parameters["table"], "dan_harrington", "bar", User.REGULAR) ) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth("dan_harrington", "bar"), (("dan_harrington", "dan_harrington", 1L), None)) self.assertEquals(get_messages(), []) clear_all_messages() self.assertEquals(auth.auth("dan_harrington", "wrongpass"), (False, "Invalid login or password")) self.assertEquals(get_messages(), [])
def validate(result): if isinstance(result, failure.Failure): raise result self.assertEqual("lock01", result) for string in ['__acquire lock01', 'acquired', '__acquire got MySQL lock']: if not search_output(string): print get_messages() self.failUnless(search_output(string), "%s not found in output" % string) clear_all_messages() self.locker.release("lock01") self.failUnless(search_output('release lock01'), "missing 'release lock01' in output") clear_all_messages() try: self.locker.release("lock01") problem = True except Exception, e: problem = False self.assertEqual(e[0], pokerlock.PokerLock.RELEASE) self.failUnless(search_output('release lock01'), "missing 'release lock01' in output")
def test07_pingWithInactiveTimerWithUser(self): clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') pt = MockPingTimer() server._ping_timer = pt self.assertEquals(server.ping(), None) self.assertEquals(server._ping_timer, None) self.assertEquals(pt.resetValues, []) self.assertEquals(pt.cancelCount, 0) self.assertEquals(server.transport.loseConnectionCount, 1) self.assertEqual(get_messages(), ['ping: timeout Mr.Fakey/-1'])
def test06_validAuthWhenEntryExists(self): """test06_validAuthWhenEntryExists Tests case for single-row returned existing auth, both success and failure. """ cursor = self.db.cursor() cursor.execute( "INSERT INTO users (created, name, password) values (%d, '%s', '%s')" % (seconds(), 'dan_harrington', 'bar')) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth('dan_harrington', 'bar'), ((4L, 'dan_harrington', 1L), None)) self.assertEquals(get_messages(), []) clear_all_messages() self.assertEquals(auth.auth('dan_harrington', 'wrongpass'), (False, 'Invalid login or password')) self.assertEquals(get_messages(), ['password mismatch for dan_harrington'])
def test06_pingWithInactiveTimerNoUser(self): clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') pt = MockPingTimer() server._ping_timer = pt del server.__dict__['user'] self.assertEquals(server.ping(), None) self.assertEquals(server._ping_timer, None) self.assertEquals(pt.resetValues, []) self.assertEquals(pt.cancelCount, 0) self.assertEquals(server.transport.loseConnectionCount, 1) self.assertEqual(get_messages(), [])
def test06_validAuthWhenEntryExists(self): """test06_validAuthWhenEntryExists Tests case for single-row returned existing auth, both success and failure. """ cursor = self.db.cursor() cursor.execute( "INSERT INTO %s (username, password, privilege) values ('%s', '%s', %i)" % (self.parameters["table"], 'dan_harrington', 'bar', User.REGULAR)) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth('dan_harrington', 'bar'), (('dan_harrington', 'dan_harrington', 1L), None)) self.assertEquals(get_messages(), []) clear_all_messages() self.assertEquals(auth.auth('dan_harrington', 'wrongpass'), (False, 'Invalid login or password')) self.assertEquals(get_messages(), [])
def test02_pingWithNoneTimer(self): def myDataWrite(clientSelf): failIf(True) clear_all_messages() client = pokernetwork.client.UGAMEClientProtocol() client.dataWrite = myDataWrite client._ping_timer = None client.factory = None self.assertEquals(client.ping(), None) self.assertEqual(get_messages(), [])
def testHandleVersion(self): """Testing handleVersion""" assert self.u._protocol_ok == False, "_protocol_ok : False expected" # Messages should be empty, protocol is not established clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), []) assert self.u._protocol_ok == False, "_protocol_ok change unexpected" self.u._packet = list('\n') # Messages should be empty, protocol is not established clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), []) assert self.u.transport._loseConnection == True, "loseConnection not called" self.u.transport = FakeTransport() # transport re-init self.u._packet = list('CGI a.b\n') # Messages should be empty, protocol is not established clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), []) assert self.u.transport._loseConnection == True, "loseConnection not called" self.u.transport = FakeTransport() # transport re-init vers = Version(protocol_number) PROTOCOL_MAJOR = "%03d" % vers.major() PROTOCOL_MINOR = "%d%02d" % (vers.medium(), vers.minor()) self.u._packet = list('CGI %s.%s \n' % (PROTOCOL_MAJOR, PROTOCOL_MINOR)) clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), ["protocol established"]) assert self.u._protocol_ok == True, "_protocol_ok value unexpected"
def testHandleData(self): """Testing handleData""" fakeProcessQueuesDeferred = self.fakeProcessQueuesDeferred() self.u._expected_len = 3 self.u._packet.append("\x00\x00\x03") self.u._packet_len = len("\x00\x00\x03") clear_all_messages() self.u.handleData() self.assertEquals(get_messages(), ['(3 bytes) => type = NONE(0)']) self.u._poll = False self.u._packet.append("\x00\x00\x03") self.u._packet_len = len("\x00\x00\x03") clear_all_messages() self.u.handleData() self.assertEquals(get_messages(), ['(3 bytes) => type = NONE(0)']) self.u._packet.append("\xff\x00\x03") self.u._packet_len = len("\xff\x00\x03") clear_all_messages() self.u.handleData() self.assertEquals(get_messages(), [ ': unknown message received (id 255, length 3)\n', "known types are {0: 'NONE', 1: 'STRING', 2: 'INT', 3: 'ERROR', 4: 'ACK', 5: 'PING', 6: 'SERIAL', 7: 'QUIT', 8: 'AUTH_OK', 9: 'AUTH_REFUSED', 10: 'LOGIN', 11: 'AUTH_REQUEST', 12: 'LIST', 13: 'LOGOUT', 14: 'BOOTSTRAP', 15: 'PROTOCOL_ERROR', 16: 'MESSAGE', 50: 'POKER_SEATS', 51: 'POKER_ID', 52: 'POKER_MESSAGE', 53: 'ERROR', 54: 'POKER_POSITION', 55: 'POKER_INT', 56: 'POKER_BET', 57: 'POKER_FOLD', 58: 'POKER_STATE', 59: 'POKER_WIN', 60: 'POKER_CARDS', 61: 'POKER_PLAYER_CARDS', 62: 'POKER_BOARD_CARDS', 63: 'POKER_CHIPS', 64: 'POKER_PLAYER_CHIPS', 65: 'POKER_CHECK', 66: 'POKER_START', 67: 'POKER_IN_GAME', 68: 'POKER_CALL', 69: 'POKER_RAISE', 70: 'POKER_DEALER', 71: 'POKER_TABLE_JOIN', 72: 'POKER_TABLE_SELECT', 73: 'POKER_TABLE', 74: 'POKER_TABLE_LIST', 75: 'POKER_SIT', 76: 'POKER_TABLE_DESTROY', 77: 'POKER_TIMEOUT_WARNING', 78: 'POKER_TIMEOUT_NOTICE', 79: 'POKER_SEAT', 80: 'POKER_TABLE_MOVE', 81: 'POKER_PLAYER_LEAVE', 82: 'POKER_SIT_OUT', 83: 'POKER_TABLE_QUIT', 84: 'POKER_BUY_IN', 85: 'POKER_REBUY', 86: 'POKER_CHAT', 87: 'POKER_PLAYER_INFO', 88: 'POKER_PLAYER_ARRIVE', 89: 'POKER_HAND_SELECT', 90: 'POKER_HAND_LIST', 91: 'POKER_HAND_SELECT_ALL', 92: 'POKER_USER_INFO', 93: 'POKER_GET_USER_INFO', 94: 'POKER_ANTE', 95: 'POKER_BLIND', 96: 'POKER_WAIT_BIG_BLIND', 97: 'POKER_AUTO_BLIND_ANTE', 98: 'POKER_NOAUTO_BLIND_ANTE', 99: 'POKER_CANCELED', 100: 'POKER_BLIND_REQUEST', 101: 'POKER_ANTE_REQUEST', 102: 'POKER_AUTO_FOLD', 103: 'POKER_WAIT_FOR', 104: 'POKER_STREAM_MODE', 105: 'POKER_BATCH_MODE', 106: 'POKER_LOOK_CARDS', 107: 'POKER_TABLE_REQUEST_PLAYERS_LIST', 108: 'POKER_PLAYERS_LIST', 109: 'POKER_PERSONAL_INFO', 110: 'POKER_GET_PERSONAL_INFO', 111: 'POKER_TOURNEY_SELECT', 112: 'POKER_TOURNEY', 113: 'POKER_TOURNEY_INFO', 114: 'POKER_TOURNEY_LIST', 115: 'POKER_TOURNEY_REQUEST_PLAYERS_LIST', 116: 'POKER_TOURNEY_REGISTER', 117: 'POKER_TOURNEY_UNREGISTER', 118: 'POKER_TOURNEY_PLAYERS_LIST', 119: 'POKER_HAND_HISTORY', 120: 'POKER_SET_ACCOUNT', 121: 'POKER_CREATE_ACCOUNT', 122: 'POKER_PLAYER_SELF', 123: 'POKER_GET_PLAYER_INFO', 124: 'POKER_ROLES', 125: 'POKER_SET_ROLE', 126: 'POKER_READY_TO_PLAY', 127: 'POKER_PROCESSING_HAND', 128: 'POKER_MUCK_REQUEST', 129: 'POKER_AUTO_MUCK', 130: 'POKER_MUCK_ACCEPT', 131: 'POKER_MUCK_DENY', 132: 'POKER_CASH_IN', 133: 'POKER_CASH_OUT', 134: 'POKER_CASH_OUT_COMMIT', 135: 'POKER_CASH_QUERY', 136: 'POKER_RAKE', 137: 'POKER_TOURNEY_RANK', 138: 'POKER_PLAYER_IMAGE', 139: 'POKER_GET_PLAYER_IMAGE', 140: 'POKER_HAND_REPLAY', 141: 'POKER_GAME_MESSAGE', 142: 'POKER_EXPLAIN', 143: 'POKER_STATS_QUERY', 144: 'POKER_STATS', 145: 'POKER_BUY_IN_LIMITS', 146: 'POKER_MONITOR', 147: 'POKER_MONITOR_EVENT', 148: 'POKER_GET_TOURNEY_MANAGER', 149: 'POKER_TOURNEY_MANAGER', 151: 'POKER_GET_PLAYER_PLACES', 152: 'POKER_PLAYER_PLACES', 153: 'POKER_SET_LOCALE', 154: 'POKER_TABLE_TOURNEY_BREAK_BEGIN', 155: 'POKER_TABLE_TOURNEY_BREAK_DONE', 156: 'POKER_TOURNEY_START', 161: 'POKER_PLAYER_STATS', 164: 'POKER_TOURNEY_INFO', 165: 'POKER_TABLE_PICKER', 166: 'POKER_CREATE_TOURNEY', 167: 'POKER_LONG_POLL', 168: 'POKER_LONG_POLL_RETURN', 170: 'POKER_BEST_CARDS', 171: 'POKER_POT_CHIPS', 172: 'POKER_CLIENT_ACTION', 173: 'POKER_BET_LIMIT', 174: 'POKER_SIT_REQUEST', 175: 'POKER_PLAYER_NO_CARDS', 176: 'POKER_CHIPS_PLAYER2BET', 177: 'POKER_CHIPS_BET2POT', 178: 'POKER_CHIPS_POT2PLAYER', 179: 'POKER_CHIPS_POT_MERGE', 180: 'POKER_CHIPS_POT_RESET', 181: 'POKER_CHIPS_BET2PLAYER', 182: 'POKER_END_ROUND', 183: 'POKER_DISPLAY_NODE', 184: 'POKER_DEAL_CARDS', 185: 'POKER_CHAT_HISTORY', 186: 'POKER_DISPLAY_CARD', 187: 'POKER_SELF_IN_POSITION', 188: 'POKER_SELF_LOST_POSITION', 189: 'POKER_HIGHEST_BET_INCREASE', 190: 'POKER_PLAYER_WIN', 191: 'POKER_ANIMATION_PLAYER_NOISE', 192: 'POKER_ANIMATION_PLAYER_FOLD', 193: 'POKER_ANIMATION_PLAYER_BET', 194: 'POKER_ANIMATION_PLAYER_CHIPS', 195: 'POKER_ANIMATION_DEALER_CHANGE', 196: 'POKER_ANIMATION_DEALER_BUTTON', 197: 'POKER_BEGIN_ROUND', 198: 'POKER_CURRENT_GAMES', 199: 'POKER_END_ROUND_LAST', 200: 'POKER_PYTHON_ANIMATION', 201: 'POKER_SIT_OUT_NEXT_TURN', 202: 'POKER_RENDERER_STATE', 203: 'POKER_CHAT_WORD', 204: 'POKER_SHOWDOWN', 205: 'POKER_CLIENT_PLAYER_CHIPS', 206: 'POKER_INTERFACE_COMMAND', 207: 'POKER_PLAYER_ME_LOOK_CARDS', 208: 'POKER_PLAYER_ME_IN_FIRST_PERSON', 209: 'POKER_ALLIN_SHOWDOWN', 210: 'POKER_PLAYER_HAND_STRENGTH'} " ]) # trying with wrong packet self.u._packet.append("\xff\x00\x00") self.u._packet_len = len("\xff\x00\x00") clear_all_messages() self.u.handleData() # FIXME (maybe): I am not completely sure it's correct that we # should get absolutely no output when we send the "wrong packet". # I've asked Loic to take a look. self.assertEquals(get_messages(), []) return fakeProcessQueuesDeferred
def testHandleVersion(self): """Testing handleVersion""" assert self.u._protocol_ok == False , "_protocol_ok : False expected" # Messages should be empty, protocol is not established clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), []) assert self.u._protocol_ok == False ,"_protocol_ok change unexpected" self.u._packet = list('\n') # Messages should be empty, protocol is not established clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), []) assert self.u.transport._loseConnection == True , "loseConnection not called" self.u.transport = FakeTransport() # transport re-init self.u._packet = list('CGI a.b\n') # Messages should be empty, protocol is not established clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), []) assert self.u.transport._loseConnection == True , "loseConnection not called" self.u.transport = FakeTransport() # transport re-init vers = Version(protocol_number) PROTOCOL_MAJOR = "%03d" % vers.major() PROTOCOL_MINOR = "%d%02d" % ( vers.medium(), vers.minor() ) self.u._packet = list( 'CGI %s.%s \n' % (PROTOCOL_MAJOR, PROTOCOL_MINOR )) clear_all_messages() self.u._handleVersion() self.assertEquals(get_messages(), ["protocol established"]) assert self.u._protocol_ok == True , "_protocol_ok value unexpected"
def test03_authWithAutoCreate(self): """test03_authWithAutoCreate Test Poker auth : Try basic auth with autocreate on""" db = self.db settings = pokernetworkconfig.Config([]) autocreate_xml = settings_xml.replace('<server auto_create_account="no" ', "<server ") settings.doc = libxml2.parseMemory(autocreate_xml, len(autocreate_xml)) settings.header = settings.doc.xpathNewContext() auth = pokerauth.get_auth_instance(db, settings) clear_all_messages() self.assertEquals(auth.auth("joe_schmoe", "foo"), ((4, "joe_schmoe", 1), None)) self.assertEquals( get_messages(), ["user joe_schmoe does not exist, create it", "creating user joe_schmoe", "create user with serial 4"], ) self.failUnless(len(self.checkIfUserExistsInDB("joe_schmoe")) == 1)
def test05_authWhenDoubleEntry(self): """test05_authWhenDoubleEntry Tests case in fallback authentication where more than one entry exists. """ cursor = self.db.cursor() for ii in [1, 2]: cursor.execute( "INSERT INTO %s (username, password, privilege) values ('%s', '%s', %i)" % (self.parameters["table"], "doyle_brunson", "foo", User.REGULAR) ) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth("doyle_brunson", "foo"), (False, "Invalid login or password")) self.assertEquals(get_messages(), [])
def test03_pingWithActiveTimer(self): def myDataWrite(clientSelf): failIf(True) clear_all_messages() client = pokernetwork.client.UGAMEClientProtocol() pt = MockPingTimer() pt.isActive = True client._ping_timer = pt client.factory = None self.assertEquals(client.ping(), None) self.assertEquals(pt, client._ping_timer) self.assertEquals(pt.resetValues, [5]) self.assertEquals(pt.cancelCount, 0) self.assertEqual(get_messages(), [])
def test05_authWhenDoubleEntry(self): """test05_authWhenDoubleEntry Tests case in fallback authentication where more than one entry exists. """ cursor = self.db.cursor() for ii in [1, 2]: cursor.execute( "INSERT INTO %s (username, password, privilege) values ('%s', '%s', %i)" % (self.parameters["table"], 'doyle_brunson', 'foo', User.REGULAR)) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth('doyle_brunson', 'foo'), (False, "Invalid login or password")) self.assertEquals(get_messages(), [])
def clientConnectionLost(self, client): class ReasonMockUp: def __str__(self): return "you mock me" def check(self, foo): return False silence_all_messages() clear_all_messages() client.connectionLost(ReasonMockUp()) self.assertEquals(get_messages(), [ 'connectionLost: reason = you mock me', 'UGAMEClient.connectionLost you mock me' ]) self.assertEquals(client._ping_timer, None) self.assertEquals(self.client_factory[0].protocol_instance, None) return True
def test04_pingWithInactiveTimer(self): global dataWritten dataWritten = 0 def myDataWrite(packet): global dataWritten self.assertEquals(packet, PacketPing().pack()) dataWritten += 1 class DummyFactory: def __init__(factSelf): factSelf.verbose = 7 clear_all_messages() client = pokernetwork.client.UGAMEClientProtocol() pt = MockPingTimer() pt.isActive = False client._ping_timer = pt client.factory = DummyFactory() client.dataWrite = myDataWrite client._prefix = "BLAH " # Reactor failure should occur if this never gets called. We # replace the real object's ping with pingDummy and call using the # static method so that new reactor setup works properly. pingRecallDeferred = defer.Deferred() def pingDummy(): pingRecallDeferred.callback(True) client.ping = pingDummy self.assertEquals(pokernetwork.client.UGAMEClientProtocol.ping(client), None) self.failUnless( isinstance(client._ping_timer, twisted.internet.base.DelayedCall)) self.failUnless(client._ping_timer.__str__().find('pingDummy()') > 0) self.assertEquals(pt.resetValues, []) self.assertEquals(pt.cancelCount, 0) self.assertEquals(dataWritten, 1) self.assertEqual(get_messages(), ['BLAH send ping']) return pingRecallDeferred
def test03_authWithAutoCreate(self): """test03_authWithAutoCreate Test Poker auth : Try basic auth with autocreate on""" db = self.db settings = pokernetworkconfig.Config([]) autocreate_xml = settings_xml.replace( '<server auto_create_account="no" ', '<server ') settings.doc = libxml2.parseMemory(autocreate_xml, len(autocreate_xml)) settings.header = settings.doc.xpathNewContext() auth = pokerauth.get_auth_instance(db, settings) clear_all_messages() self.assertEquals(auth.auth('joe_schmoe', 'foo'), ((4, 'joe_schmoe', 1), None)) self.assertEquals(get_messages(), [ 'user joe_schmoe does not exist, create it', 'creating user joe_schmoe', 'create user with serial 4' ]) self.failUnless(len(self.checkIfUserExistsInDB('joe_schmoe')) == 1)
def testCoverDataWrite(self): """Testing data write""" clear_all_messages() tot = protocol.UGAMEProtocol._stats_write global calledWrite calledWrite = 0 myData = "testing data" def mockTransportWrite(data): global calledWrite self.assertEquals(data, myData) calledWrite += 1 self.u.transport.write = mockTransportWrite self.u.dataWrite(myData) self.assertEquals(tot + len(myData), protocol.UGAMEProtocol._stats_write) self.assertEquals(calledWrite, 1) self.assertEquals(get_messages(), [])
def test05_authWhenDoubleEntry(self): """test05_authWhenDoubleEntry Tests case in fallback authentication where more than one entry exists. """ cursor = self.db.cursor() cursor.execute("DROP TABLE users") cursor.execute( """CREATE TABLE users ( serial int unsigned not null auto_increment, name varchar(32), password varchar(32), privilege int default 1, primary key (serial))""" ) for ii in [1, 2]: cursor.execute("INSERT INTO users (name, password) values ('%s', '%s')" % ("doyle_brunson", "foo")) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth("doyle_brunson", "foo"), (False, "Invalid login or password")) self.assertEquals(get_messages(), ["*ERROR* more than one row for doyle_brunson"])
def test10_connectionLostWithInactivePingTimerWithAvatarAndQueues(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') server._protocol_ok = True def actualButDummyProcessQueueCounter(): global processQueuesCount processQueuesCount += 1 if processQueuesCount > 1: server._queues = [] server._processQueues = actualButDummyProcessQueueCounter server.ignoreIncomingData = self.ignoreIncomingDataCounter pt = MockPingTimer() server._ping_timer = pt server._queues = ['a', 'b', 'c'] server.avatar = FakeAvatar() self.assertEquals(server.connectionLost("test10"), None) self.failIf(server.__dict__.has_key('avatar')) self.assertEquals(server._ping_timer, None) self.assertEquals(processQueuesCount, 2) self.assertEquals(ignoreIncomingDataCount, 1) self.assertEquals(pt.cancelCount, 0) self.assertEquals(pt.resetValues, []) self.assertEquals(len(self.server_factory.destroyedAvatars), 1) self.failUnless( isinstance(self.server_factory.destroyedAvatars[0], FakeAvatar)) self.assertEquals(get_messages(), ['connectionLost: reason = test10'])
def test05_authWhenDoubleEntry(self): """test05_authWhenDoubleEntry Tests case in fallback authentication where more than one entry exists. """ cursor = self.db.cursor() cursor.execute("DROP TABLE users") cursor.execute("""CREATE TABLE users ( serial int unsigned not null auto_increment, name varchar(32), password varchar(32), privilege int default 1, primary key (serial))""") for ii in [1, 2]: cursor.execute( "INSERT INTO users (name, password) values ('%s', '%s')" % ('doyle_brunson', 'foo')) cursor.close() auth = pokerauth.get_auth_instance(self.db, self.settings) clear_all_messages() self.assertEquals(auth.auth('doyle_brunson', 'foo'), (False, "Invalid login or password")) self.assertEquals(get_messages(), ['*ERROR* more than one row for doyle_brunson'])
def test11_connectionLostActivePingTimerNoAvatarOneQueues(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 clear_all_messages() self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') server._protocol_ok = True def actualButDummyProcessQueueCounter(): global processQueuesCount processQueuesCount += 1 server._queues = [] server._processQueues = actualButDummyProcessQueueCounter server.ignoreIncomingData = self.ignoreIncomingDataCounter pt = MockPingTimer() pt.isActive = True server._ping_timer = pt server._queues = ['b', 'c'] server.avatar = None self.assertEquals(server.connectionLost("test11"), None) self.failIf(server.__dict__.has_key('avatar')) self.assertEquals(server._ping_timer, None) # Queues don't get processed when lost connection without avatar self.assertEquals(processQueuesCount, 0) self.assertEquals(ignoreIncomingDataCount, 1) self.assertEquals(pt.cancelCount, 1) self.assertEquals(pt.resetValues, []) self.assertEquals(self.server_factory.destroyedAvatars, []) self.assertEquals(get_messages(), ['connectionLost: reason = test11'])
def testForceError(self): """Testing error call""" clear_all_messages() self.u.error("testing this error") self.assertEquals(get_messages(), ["ERROR testing this error"])
def testProcessQueues(self): """Testing _proccessQueues""" global triggerTimerCallCount triggerTimerCallCount = 0 def mockTriggerTimer(): global triggerTimerCallCount triggerTimerCallCount += 1 self.u.triggerTimer = mockTriggerTimer self.u.canHandlePacket = lambda x : (False, time()+10) self.failIf(self.u._queues.has_key(0)) self.u.getOrCreateQueue(0) self.failUnless(self.u._queues.has_key(0)) self.u._lagmax = 10 self.failIf(self.u._queues.has_key(1)) self.u.getOrCreateQueue(1) self.failUnless(self.u._queues.has_key(1)) self.u._queues[1].delay = time()+10 oneArg = 0 self.u._queues[1].packets.insert( 0, FakePacket(oneArg, "one") ) self.u._queues[1].packets[0].nodelay__ = True self.failIf(self.u._queues.has_key(2)) self.u.getOrCreateQueue(2) self.failUnless(self.u._queues.has_key(2)) self.u._queues[2].delay = time() twoArg = time() self.u._queues[2].packets.insert( 0, FakePacket(twoArg, "two") ) self.failIf(self.u._queues.has_key(3)) self.u.getOrCreateQueue(3) self.failUnless(self.u._queues.has_key(3)) self.u._queues[3].delay = time()+1 threeArg = time() +10 self.u._queues[3].packets.insert( 0, FakePacket(threeArg, "three") ) # Ok, Test blocked first -- nothing happens clear_all_messages() self.u._blocked = True self.u._processQueues() k = self.u._queues.keys() self.assertEquals(triggerTimerCallCount, 1) k.sort() self.assertEquals(k, [ 0, 1, 2, 3 ]) self.assertEquals(get_messages(), []) self.assertEquals(self.u._lag, 0) # Unblocked test, function fully runs triggerTimerCallCount = 0 self.u._blocked = False global callCount callCount = 0 def mockHandler(packet): global callCount callCount += 1 self.assertEquals(packet.arg, oneArg) self.assertEquals(packet.id, 'one') self.u._handler = mockHandler startTime = time() self.u._processQueues() endTime = time() self.assertEquals(callCount, 1) self.failUnless(self.u._lag > startTime) self.failUnless(self.u._lag <= endTime) k = self.u._queues.keys() k.sort() self.assertEquals(k, [ 1, 2, 3 ]) self.assertEquals(len(self.u._queues[1].packets), 0) self.assertEquals(len(self.u._queues[2].packets), 1) self.assertEquals(len(self.u._queues[3].packets), 1) self.assertEquals(triggerTimerCallCount, 1) self.assertEquals(len(get_messages()), 2) self.assertEquals(get_messages()[0], ' => queue 1 delay canceled because lag too high') self.assertEquals(get_messages()[1].find('seconds before handling the next packet in queue 3') > 0, True)