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") log_history.reset() self.u.handleData() self.assertEquals(log_history.get_all(), ['(3 bytes) => type = NONE(0)']) self.u._poll = False self.u._packet.append("\x00\x00\x03") self.u._packet_len = len("\x00\x00\x03") log_history.reset() self.u.handleData() self.assertEquals(log_history.get_all(), ['(3 bytes) => type = NONE(0)']) self.u._packet.append("\xff\x00\x03") self.u._packet_len = len("\xff\x00\x03") log_history.reset() self.u.handleData() self.assertEquals(log_history.get_all(), [': unknown message received (id 255, length 3)\n']) # trying with wrong packet self.u._packet.append("\xff\x00\x00") self.u._packet_len = len("\xff\x00\x00") log_history.reset() 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(log_history.get_all(), []) return fakeProcessQueuesDeferred
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 log_history.search(string): print log_history.get_all() self.failUnless(log_history.search(string), "missing '%s' in output" % string) return lockFastTimeout()
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 log_history.search(string): print log_history.get_all() self.failUnless(log_history.search(string), "missing '%s' in output" % string) return lockFastTimeout()
def test09_connectionLostNoPingTimerWithAvatarButNoQueues(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 log_history.reset() 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('avatar' in server.__dict__) 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(log_history.get_all(), [])
def testHandleConnection(self): """Testing _handleConnection""" log_history.reset() # 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(log_history.get_all(), [])
def deferPacket(self, client): server = self.server_factory.instance self.failUnless(log_history.search('protocol established')) log_history.reset() self.deferredPacket = defer.Deferred() server.sendPackets([ self.deferredPacket, PacketAck()]) self.assertEquals(log_history.get_all(), []) self.deferredPacket.callback(PacketPing()) self.assertEquals(log_history.get_all(), []) def callbackDeferredPacket(client): self.assertTrue(log_history.search('ACK type = 4 length = 3')) d = client.connection_lost_deferred d.addCallback(callbackDeferredPacket) return d
def test08_connectionLostNonePingTimerNoAvatar(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 log_history.reset() 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('avatar' in server.__dict__) self.assertEquals(server._ping_timer, None) self.assertEquals(processQueuesCount, 0) self.assertEquals(ignoreIncomingDataCount, 1) self.assertEquals(self.server_factory.destroyedAvatars, []) self.assertEquals(log_history.get_all(), [])
def test04_authWithoutAutoCreate(self, expectedMessage = 'user does not exist. name: john_smith'): """test04_authWithoutAutoCreate Test Poker auth : Try basic auth with autocreate on""" auth = pokerauth.get_auth_instance(self.db, None, self.settings) self.assertEquals(auth.auth(PACKET_LOGIN,('john_smith', 'blah')), (False, 'Invalid login or password')) if expectedMessage: self.assertEquals(log_history.get_all()[-1], expectedMessage) self.failUnless(len(self.checkIfUserExistsInDB('john_smith')) == 0)
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 (%s, %s, %s)", (seconds(), 'dan_harrington', 'bar') ) cursor.close() auth = pokerauth.get_auth_instance(self.db, None, self.settings) log_history.reset() self.assertEquals(auth.auth(PACKET_LOGIN,('dan_harrington', 'bar')), ((4L, 'dan_harrington', 1L), None)) self.assertEquals(log_history.get_all(), []) log_history.reset() self.assertEquals(auth.auth(PACKET_LOGIN,('dan_harrington', 'wrongpass')), (False, 'Invalid login or password')) self.assertEquals(log_history.get_all(), ['invalid password in login attempt. name: dan_harrington, serial: 4'])
def test02_pingWithNoneTimer(self): def myDataWrite(clientSelf): failIf(True) log_history.reset() client = pokernetwork.client.UGAMEClientProtocol() client.dataWrite = myDataWrite client._ping_timer = None client.factory = None self.assertEquals(client.ping(), None) self.assertEqual(log_history.get_all(), [])
def test07_pingWithInactiveTimerWithUser(self): 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(log_history.get_all(), ['ping: timeout Mr.Fakey/-1'])
def callbackDeferredPacket(client): errFound = False ackFound = False for msg in log_history.get_all(): if msg == "(132 bytes) => ERROR type = 3 length = 132 message = [Failure instance: Traceback (failure with no frames): <class 'twisted.python.failure.DefaultException'>: forced to fail\n] code = 0 other_type = 3": self.failIf(errFound or ackFound) errFound = True elif msg == '(3 bytes) => ACK type = 4 length = 3': self.failUnless(errFound) ackFound = True self.failUnless(ackFound and errFound)
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 "+self.parameters["table"]+" (username, password, privilege) values (%s, %s, %s)", ('dan_harrington', 'bar', User.REGULAR) ) cursor.close() auth = pokerauth.get_auth_instance(self.db, None, self.settings) log_history.reset() self.assertEquals(auth.auth(PACKET_LOGIN,('dan_harrington', 'bar')), (('dan_harrington', 'dan_harrington', 1L), None)) self.assertEquals(log_history.get_all(), []) log_history.reset() self.assertEquals(auth.auth(PACKET_LOGIN,('dan_harrington', 'wrongpass')), (False, 'Invalid login or password')) self.assertEquals(log_history.get_all(), ['password mismatch for dan_harrington'])
def validate(result): if isinstance(result, failure.Failure): raise result needed = [ '__acquire lock01', 'acquired', '__acquire got MySQL lock' ] for s in needed: self.assertTrue( log_history.search(s), "missing '%s' in output (got %s)" % (s, log_history.get_all())) self.assertEqual("lock01", result) return locker2()
def test06_pingWithInactiveTimerNoUser(self): 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(log_history.get_all(), [])
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 log_history.search(string): print log_history.get_all() self.failUnless(log_history.search(string), "%s not found in output" % string) log_history.reset()() self.locker.release("lock01") self.failUnless(log_history.search('release lock01'), "missing 'release lock01' in output") log_history.reset()() try: self.locker.release("lock01") problem = True except Exception, e: problem = False self.assertEqual(e[0], pokerlock.PokerLock.RELEASE) self.failUnless(log_history.search('release lock01'), "missing 'release lock01' in output")
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 auto_create_account="yes" ') settings.doc = libxml2.parseMemory(autocreate_xml, len(autocreate_xml)) settings.header = settings.doc.xpathNewContext() auth = pokerauth.get_auth_instance(db, None, settings) self.assertEquals(auth.auth(PACKET_LOGIN,('joe_schmoe', 'foo')), ((4, 'joe_schmoe', 1), None)) self.assertEquals(log_history.get_all()[-1], 'created user. serial: 4, name: joe_schmoe') self.failUnless(len(self.checkIfUserExistsInDB('joe_schmoe')) == 1)
def clientConnectionLost(self, client): class ReasonMockUp: def __str__(self): return "you mock me" def check(self, foo): return False log_history.reset() client.transport.loseConnection() client.connectionLost(ReasonMockUp()) self.assertEquals(log_history.get_all(), ['connectionLost: you mock me']) self.assertEquals(client._ping_timer, None) self.assertEquals(self.client_factory[0].protocol_instance, None) return True
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 log_history.search(string): print log_history.get_all() self.failUnless(log_history.search(string), "%s not found in output" % string) log_history.reset()() self.locker.release("lock01") self.failUnless(log_history.search('release lock01'), "missing 'release lock01' in output") log_history.reset()() try: self.locker.release("lock01") problem = True except Exception, e: problem = False self.assertEqual(e[0], pokerlock.PokerLock.RELEASE) self.failUnless(log_history.search('release lock01'), "missing 'release lock01' in output")
class ErrorCondtionsCurrencyClientTestCase(unittest.TestCase): def destroyDb(self): if len(config.test.mysql.root_user.password) > 0: os.system( "%(mysql_command)s -u %(dbroot)s --password='******' -h '%(dbhost)s' -e 'DROP DATABASE IF EXISTS currencytest'" % { 'mysql_command': config.test.mysql.command, 'dbroot': config.test.mysql.root_user.name, 'dbroot_password': config.test.mysql.root_user.password, 'dbhost': config.test.mysql.host, 'dbname': config.test.mysql.database }) else: os.system( "%(mysql_command)s -u %(dbroot)s -h '%(dbhost)s' -e 'DROP DATABASE IF EXISTS currencytest'" % { 'mysql_command': config.test.mysql.command, 'dbroot': config.test.mysql.root_user.name, 'dbhost': config.test.mysql.host, 'dbname': config.test.mysql.database }) # ----------------------------------------------------------------------------- def setUp(self): self.destroyDb() # ----------------------------------------------------------------------------- def tearDown(self): del self.client self.destroyDb() # ----------------------------------------------------------------------------- def test01_parseResultNote_InvalidResult(self): from cStringIO import StringIO self.client = currencyclient.RealCurrencyClient() caughtIt = False log_history.reset() try: self.client.parseResultNote("two\tfield") self.fail("Previous line should have caused exception") except Exception, e: self.assertEquals(str(e), "expected notes got something else") caughtIt = True self.assertTrue(caughtIt, "Should have caught an exception") self.assertEquals(log_history.get_all(), ["parseResultNote: ignore line: two\tfield"])
def test03_pingWithActiveTimer(self): def myDataWrite(clientSelf): failIf(True) log_history.reset() 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(log_history.get_all(), [])
def locker2_failed(result): needed = [ '__acquire lock01', 'acquired', 'exception in function', 'loop, queue size' ] for s in needed: self.assertTrue( log_history.search(s), "missing '%s' in output (got %s)" % (s, log_history.get_all())) log_history.reset()() self.locker.release('lock01') self.assertTrue(isinstance(result, failure.Failure)) self.assertEqual(result.value[0], pokerlock.PokerLock.TIMED_OUT) self.locker2.close()
def testHandleVersion(self): """Testing handleVersion""" assert self.u._protocol_ok == False , "_protocol_ok : False expected" # Messages should be empty, protocol is not established log_history.reset() self.u._handleVersion() self.assertEquals(log_history.get_all(), []) assert self.u._protocol_ok == False ,"_protocol_ok change unexpected" self.u._packet = list('\n') # Messages should be empty, protocol is not established log_history.reset() self.u._handleVersion() self.assertEquals(log_history.get_all(), []) 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 log_history.reset() self.u._handleVersion() self.assertEquals(log_history.get_all(), []) 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 )) log_history.reset() self.u._handleVersion() self.assertEquals(log_history.get_all(), ["protocol established"]) assert self.u._protocol_ok == True , "_protocol_ok value unexpected"
def deferErrorPacket(self, client): server = self.server_factory.instance log_history.reset() self.deferredPacket = defer.Deferred() server.sendPackets([ self.deferredPacket, PacketAck()]) self.assertEquals(log_history.get_all(), []) self.deferredPacket.errback("forced to fail") self.assertEquals(log_history.get_all(), []) def callbackDeferredPacket(client): errFound = False ackFound = False for msg in log_history.get_all(): if msg == "(132 bytes) => ERROR type = 3 length = 132 message = [Failure instance: Traceback (failure with no frames): <class 'twisted.python.failure.DefaultException'>: forced to fail\n] code = 0 other_type = 3": self.failIf(errFound or ackFound) errFound = True elif msg == '(3 bytes) => ACK type = 4 length = 3': self.failUnless(errFound) ackFound = True self.failUnless(ackFound and errFound) d = client.connection_lost_deferred d.addCallback(callbackDeferredPacket) return d
def test08_mysqlbeyond11userCreate(self): """test08_mysqlbeyond11userCreate Tests userCreate() as it will behave under MySQL > 1.1 by mocking up the situation. """ class MockCursor: def __init__(self): self.lastrowid = 162342 def execute(self, *a): pass def close(self): pass class MockDatabase: def cursor(self): return MockCursor() auth = pokerauth.get_auth_instance(MockDatabase(), None, self.settings) self.assertEquals(auth.userCreate("somebody", "something"), 162342) self.assertEquals(log_history.get_all()[-1], 'created user. serial: 162342, name: somebody')
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 "+self.parameters["table"]+" (username, password, privilege) values (%s, %s, %s)", ('doyle_brunson', 'foo', User.REGULAR) ) cursor.close() auth = pokerauth.get_auth_instance(self.db, None, self.settings) log_history.reset() self.assertEquals(auth.auth(PACKET_LOGIN,('doyle_brunson', 'foo')), (False, "Invalid login or password")) self.assertEquals(log_history.get_all(), ['more than one row for doyle_brunson'])
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, None, self.settings) log_history.reset() self.assertEquals(auth.auth(PACKET_LOGIN,('doyle_brunson', 'foo')), (False, "Invalid login or password")) self.assertEquals(log_history.get_all(), ['multiple entries for user in database. name: doyle_brunson'])
def testCoverDataWrite(self): """Testing data write""" log_history.reset() 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(log_history.get_all(), [])
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 log_history.reset() 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(log_history.get_all(), ['send ping']) return pingRecallDeferred
def test10_connectionLostWithInactivePingTimerWithAvatarAndQueues(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 log_history.reset() 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('avatar' in server.__dict__) 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(log_history.get_all(), [])
def test11_connectionLostActivePingTimerNoAvatarOneQueues(self): global processQueuesCount processQueuesCount = 0 global ignoreIncomingDataCount ignoreIncomingDataCount = 0 log_history.reset() 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('avatar' in server.__dict__) 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(log_history.get_all(), [])
def test2(self): tourney = self.tourney game = self.game players = self.players player3 = [p for p in players if p.serial == 3][0] original_startmoney = player3.money def myremove_player(tournament, game_id, serial, now=False): if now: tournament.finallyRemovePlayer(serial, now) tourney.callback_remove_player = myremove_player def my_rebuy(tournament, serial, table_id, player_chips, tourney_chips): self.assertEqual(table_id, game.id) self.assertEqual(tourney.buy_in, player_chips) if serial == 1: return 0 return tourney_chips tourney.callback_rebuy_payment = my_rebuy def updateShowdownStack(serial, money): if len(game.showdown_stack) == 0: game.showdown_stack.append({'serial2delta':{}}) game.showdown_stack[0]['serial2delta'][serial] = - money def looseMoney(serial, set_money_to=0): for player in players: if player.serial != serial: continue money = set_money_to - player.money player.money = set_money_to if set_money_to == 0: self.assertTrue(game.isBroke(serial)) updateShowdownStack(serial, money) # prizes will be cached, but we have to make sure that the rebuy process # will update the cache. tourney.prizes() # Player got broke looseMoney(1) self.assertEqual(tourney.winners, []) # Even removeBrokePlayers and endTurn doesn't remove him, # because he has a chance for rebuy tourney.removeBrokePlayers(1) self.assertEqual(tourney.winners, []) # Player 2 gets broke, and chooses not to rebuy looseMoney(2) tourney.removeBrokePlayers(1) tourney.tourneyEnd(1) tourney.removePlayer(1, 2) self.assertEqual(tourney.winners, [2]) self.assertEqual(tourney.getRank(2), 4) # Player 1 tries to rebuy but has not enough money success, error = tourney.rebuyPlayerRequest(game.id, 1) self.assertFalse(success) self.assertEquals(error, "money") # After Player 1 Timed out, he will be also removed # Note: this changes the rank for player 2 tourney.removePlayer(1, 1) self.assertEqual(tourney.winners, [2, 1]) self.assertEqual(tourney.getRank(2), 3) self.assertEqual(tourney.getRank(1), 4) # Player 3 get broke but rebuys a few times for _i in range(4): looseMoney(3) self.assertEqual(player3.money, 0) tourney.removeBrokePlayers(1) tourney.tourneyEnd(1) self.assertEqual(tourney.winners, [2, 1]) success, error = tourney.rebuyPlayerRequest(game.id, 3) self.assertTrue(success, error) tourney.removeBrokePlayers(1) tourney.tourneyEnd(1) self.assertEqual(tourney.winners, [2, 1]) # after the rebuy player 3 has the same money as he started self.assertEqual(original_startmoney, player3.money) self.assertEqual(tourney.winners, [2, 1]) looseMoney(4, set_money_to=game.buyIn()) # rebuy will fail because users money plus the new game.buyIn() is bigger than game.maxBuyIn() success, error = tourney.rebuyPlayerRequest(game.id, 4) self.assertFalse(success) self.assertEqual(error, "user") looseMoney(4, set_money_to=game.buyIn()-1) success, error = tourney.rebuyPlayerRequest(game.id, 4) self.assertTrue(success) looseMoney(4) tourney.removeBrokePlayers(1) tourney.tourneyEnd(1) # if game.rebuy fails, there should be an error message in the log! log_history.reset() self.assertEqual(log_history.get_all(), []) old_rebuy = game.rebuy game.rebuy = lambda *args, **kw: False success, error = tourney.rebuyPlayerRequest(game.id, 4) self.assertFalse(success) self.assertEqual(len(log_history.get_all()), 1) game.rebuy = old_rebuy success, error = tourney.rebuyPlayerRequest(game.id, 4) self.assertTrue(success, error) tourney.removeBrokePlayers(1) tourney.tourneyEnd(1) self.assertEqual(tourney.winners, [2, 1]) looseMoney(4) tourney.removeBrokePlayers(1) tourney.tourneyEnd(1) tourney.removePlayer(1, 4) self.assertFalse(tourney.tourneyEnd(1)) self.assertEqual(tourney.winners, [3,4,2,1]) # We have just one winner and he wins the complete pot (4 * buy_in) + ( 6 * succesfull_rebuys) self.assertEqual(sum(tourney.prizes()), 50)
def test13_handleConnectionWithExceptionRaised(self): self.server_factory = FakeFactory(self) server = self.server_factory.buildProtocol('addr') pt = MockPingTimer() pt.isActive = True server._ping_timer = pt class MockRaise: def __init__(raiseSelf, str): raiseSelf.value = str class MockAvatar: def __init__(avatarSelf, expected = None): avatarSelf.handlePacketCount = 0 avatarSelf.expectedPacket = expected def handlePacket(avatarSelf, packet): global triggerCount global sendPacketsCount avatarSelf.handlePacketCount += 1 self.assertEquals(packet, avatarSelf.expectedPacket) self.assertEquals(pt, server._ping_timer) self.assertEquals(pt.resetValues, [ 10 ]) self.assertEquals(pt.cancelCount, 0) self.assertEquals(server._blocked, True) self.assertEquals(triggerCount, 0) raise MockRaise("handlePacketsRaise") return "handlePacketsReturn" avatar = MockAvatar("test13 dummy packets") global triggerCount triggerCount = 0 def doMyTrigger(): global triggerCount triggerCount += 1 def doSendPackets(packets): self.failIf(True) # This should never be called server.avatar = avatar server._blocked = False server.triggerTimer = doMyTrigger server.sendPackets = doSendPackets log_history.reset() self.assertEquals(server.exception, None) server._handleConnection("test13 dummy packets") self.assertEquals(log_history.get_all(), ['ping: renew Mr.Fakey/-1']) self.assertEquals(pt, server._ping_timer) self.assertEquals(pt.resetValues, [ 10 ]) self.assertEquals(pt.cancelCount, 0) self.assertEquals(avatar.handlePacketCount, 1) self.assertEquals(server._blocked, False) self.assertEquals(triggerCount, 1) self.assertEquals(len(server.exception), 3) self.assertEquals(server.exception[0], MockRaise) self.failUnless(isinstance(server.exception[1], MockRaise)) self.assertEquals(server.exception[1].value, 'handlePacketsRaise') self.assertEquals(server.transport.loseConnectionCount, 1)
def validate(result): if isinstance(result, failure.Failure): raise result needed = [ '__acquire lock01', 'acquired', '__acquire got MySQL lock' ] for s in needed: self.assertTrue(log_history.search(s), "missing '%s' in output (got %s)" % (s,log_history.get_all())) self.assertEqual("lock01", result) return locker2()
def test10_factoryError(self): log_history.reset() clientFactory = pokernetwork.client.UGAMEClientFactory() clientFactory.log.error("test10") self.assertEquals(log_history.get_all(), [ "test10"])
def locker2_failed(result): needed = [ '__acquire lock01', 'acquired', 'exception in function', 'loop, queue size' ] for s in needed: self.assertTrue(log_history.search(s), "missing '%s' in output (got %s)" % (s,log_history.get_all())) log_history.reset()() self.locker.release('lock01') self.assertTrue(isinstance(result, failure.Failure)) self.assertEqual(result.value[0], pokerlock.PokerLock.TIMED_OUT) self.locker2.close()