Example #1
0
    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()
Example #3
0
 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()
Example #4
0
    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(), [])
Example #5
0
 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(), [])
Example #6
0
 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
Example #7
0
    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(), [])
Example #8
0
    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)
Example #9
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'])
Example #10
0
    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(), [])
Example #11
0
 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'])
Example #12
0
 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'])
Example #14
0
        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()
Example #15
0
 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")
Example #17
0
    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)
Example #18
0
 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
Example #19
0
        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")
Example #20
0
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"])
Example #21
0
    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(), [])
Example #22
0
        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()
Example #23
0
    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"
Example #24
0
    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
Example #25
0
    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'])
Example #27
0
    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'])
Example #28
0
    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(), [])
Example #29
0
    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
Example #30
0
    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(), [])
Example #31
0
    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(), [])
Example #32
0
    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)
Example #33
0
    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()
Example #35
0
 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()