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 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 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 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 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)
