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 getNote(self, url, value): log_history.reset() d = self.client.getNote(url, value) self.assertEquals(log_history.search("_buildNote"), True) self.assertEquals(log_history.search("getNote"), True) if "?" in url: check_url = url[:url.index("?")] else: check_url = url def validate(result): if isinstance(result, failure.Failure): raise result # I wonder, actually, if FakeCurrencyClient is supposed to # return a list of a list as RealCurrencyClient does in this # instance. I commented out: # note = result[0] # in favor of: note = result self.assertEqual(check_url, note[0]) self.assertEqual(40, len(note[2])) self.assertEqual(value, note[3]) return [result] d.addBoth(validate) return d
def testConnectionLost(self): """Testing ConnectionLost""" log_history.reset() self.u.established = 1 self.u.connectionLost("testing") self.assertEquals(self.u.established,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(), [])
def test04_changeNote(self): d = self.getCommitedNote("http://fake/", 100) log_history.reset() def changeNote(result): class FakeNoteToChange: def copy(self): return [8, 0, ""] d = self.client.changeNote(FakeNoteToChange()) def validate(result): if isinstance(result, failure.Failure): raise result self.assertEqual(result[0], 8) self.assertEqual(result[1], 2) self.assertEqual(40, len(result[2])) self.assertEquals(log_history.search("changeNote"), True) return result d.addBoth(validate) return d d.addCallback(changeNote) return d
def getNote(self, url, value): log_history.reset() d = self.client.getNote(url, value) self.assertEquals(log_history.search("_buildNote"), True) self.assertEquals(log_history.search("getNote"), True) if "?" in url: check_url = url[: url.index("?")] else: check_url = url def validate(result): if isinstance(result, failure.Failure): raise result # I wonder, actually, if FakeCurrencyClient is supposed to # return a list of a list as RealCurrencyClient does in this # instance. I commented out: # note = result[0] # in favor of: note = result self.assertEqual(check_url, note[0]) self.assertEqual(40, len(note[2])) self.assertEqual(value, note[3]) return [result] d.addBoth(validate) return d
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 test10_mainTests_notRunningForCallback(self): import Queue import time global myLock def setNotRunning(name, timeout): global myLock myLock.running = False d = defer.Deferred() def succeeded(result): self.failIf(True) def failed(result): self.failIf(True) d.addErrback(failed) d.addCallback(succeeded) class MockQueue: def __init__(qSelf): qSelf.count = 1 def qsize(qSelf): return qSelf.count def get(qSelf, timeout=1): if qSelf.count > 0: qSelf.count = 0 return ("Mocky", setNotRunning, 10, d) else: raise Queue.Empty def empty(qSelf): return qSelf.count <= 0 def put(qSelf, val): pass class MockLock: def __init__(lSelf): lSelf.calledReleaseCount = 0 def release(lSelf): lSelf.calledReleaseCount += 1 log_history.reset()() anotherLock = pokerlock.PokerLock(self.parameters) anotherLock.q = MockQueue() anotherLock.lock = MockLock() myLock = anotherLock anotherLock.start() time.sleep(2) self.failUnless(log_history.search('release because not running'), "missing 'release because not running' in output") self.assertEquals(anotherLock.running, False) self.assertEquals(anotherLock.lock.calledReleaseCount, 1)
def testConnectionLostWithProtocolOk(self): """Testing ConnectionLostWithProtocolOk""" log_history.reset() self.u.established = 1 self.u._protocol_ok = True self.u.connectionLost("another") self.assertEquals(self.u.established,0)
def locker2(): log_history.reset()() self.locker2 = pokerlock.PokerLock(self.parameters) self.locker2.start() d = self.locker2.acquire('lock01', 0) d.addCallback(locker2_succeeded) d.addErrback(locker2_failed) return d
def test11_mainTests_raiseForceRelease(self): import Queue import time class MockException(Exception): pass def raiseForceRelease(name, timeout): raise MockException() def succeeded(result): self.failIf(True) def failed(result): self.failUnless(issinstance(result, MockException)) # FIXME: this callback never happens; it should, however. I # am not completely sure why; I assume it's because the # reactor.callFromThread() errback call in the main() doesn't # get executed before the reactor dies. OTOH, I don't fully # understand the thread/reactor interaction issues . If # someone can figure out and make sure this callback happens, # I'd appreciate it. d = defer.Deferred() d.addErrback(failed) d.addCallback(succeeded) class MockQueue: def __init__(qSelf): qSelf.count = 1 def qsize(qSelf): return qSelf.count def get(qSelf, timeout = 1): if qSelf.count > 0: qSelf.count = 0 return ("Mocky", raiseForceRelease, 10, d) else: raise Queue.Empty def empty(qSelf): return qSelf.count <= 0 def put(qSelf, val): pass class MockLock: def release(lSelf): raise MockException("MOCKY NO LOCK RELEASE") log_history.reset()() anotherLock = pokerlock.PokerLock(self.parameters) anotherLock.q = MockQueue() anotherLock.lock = MockLock() anotherLock.start() time.sleep(2) self.assertEquals(anotherLock.running, True) for string in [ 'exception in function', 'failed to release lock after exception', 'raise MockException("MOCKY NO LOCK RELEASE")' ]: self.failUnless(log_history.search(string), "missing '%s' in output" % string)
def lockFastTimeout(): self.failUnless(log_history.search('acquire'), "missing 'acquire' in output") pokerlock.PokerLock.acquire_sleep = 1 log_history.reset()() d = self.locker.acquire('lock01', 0) d.addCallback(lockTimeoutExpected_succeeded) d.addErrback(lockTimeoutExpected_failed) return d
def getServerPacket(self, client): self.failUnless(log_history.search('protocol established')) log_history.reset() def findBufferedAckPacket(client): self.failUnless(log_history.search("ACK type = 4 length = 3")) d = client.connection_lost_deferred d.addCallback(findBufferedAckPacket) return d
def test14_handleConnectionWithExceptionRaisedNotSet(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 del server.exception 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("test14 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) exceptionFound = False try: server._handleConnection("test14 dummy packets") self.failIf(True) # This line should not be reached. except MockRaise, mr: exceptionFound = True self.failUnless(isinstance(mr, MockRaise)) self.assertEquals(mr.value, 'handlePacketsRaise')
def test07_breakNote(self): log_history.reset() d = CurrencyClientTestCase.test07_breakNote(self) def checkOutput(result): self.assertEquals(log_history.search("breakNote values"), True) return True d.addCallback(checkOutput) return d
def getCommitedNote(self, url, value): log_history.reset() def checkCommitVerboseOutput(result): self.assertEquals(log_history.search("commit"), True) return result ret = CurrencyClientTestCase.getCommitedNote(self, url, value) ret.addCallback(checkCommitVerboseOutput) return ret
def setUp(self): log_history.reset() self.tmpdir = tempfile.mkdtemp() self.filename = os.path.join(self.tmpdir, "poker.server.xml") f = open(self.filename, "w") self.manhole_port = 33333 f.write(settings_xml_server_manhole % {'manhole_port': self.manhole_port}) f.close() self.service = makeService(self.filename) self.service.startService()
def getServerPacket(self, client): # self.failUnless(log_history.search('protocol established')) log_history.reset() def findBufferedAckPacket(client): self.failUnless(log_history.search("PacketAck(4)")) d = client.connection_lost_deferred d.addCallback(findBufferedAckPacket) client.transport.loseConnection() return d
def test03_acquire_dead(self): self.locker.close() log_history.reset()() try: self.locker.acquire('lock01') problem = True except Exception, e: problem = False self.assertEqual(e[0], pokerlock.PokerLock.DEAD) self.failUnless(log_history.search('acquire'), "missing 'acquire' in output")
def test08_mainTests_emptyQueue(self): """test08_mainTests_emptyQueue This test creates a dummy PokerLock.__init__() so that a MockQueue can be used that force-raises a Queue.Empty() exception, which is caught by the running loop in the lock and ends it.""" import Queue import threading from pokernetwork.pokerlock import PokerLock from pokernetwork import log as network_log class MockQueue: def __init__(qSelf): qSelf.qSizeCallCount = 0 qSelf.getCallCount = 0 def qsize(qSelf): qSelf.qSizeCallCount += 1 return 1 def get(qSelf, timeout=1): qSelf.getCallCount += 1 raise Queue.Empty("MOCK") def empty(qSelf): return False def put(qSelf, val): pass myMockQueue = MockQueue() log = network_log.getChild('pokerlock') class MockInitLock(PokerLock): def __init__(self, parameters): self.log = log.getChild(self.__class__.__name__) self.q = myMockQueue self.lock = threading.Lock() self.db = None self.running = True self.connect(parameters) threading.Thread.__init__(self, target=self.main) log_history.reset()() mockLocker = MockInitLock(self.parameters) mockLocker.start() mockLocker.close() self.failUnless(log_history.search("timeout"), "output does not contain 'timeout'") self.failUnless(log_history.search("loop"), "output does not contain 'loop'") self.failUnless(myMockQueue.qSizeCallCount > 0, "MockQueue.qSize() should be called at least once.") self.failUnless(myMockQueue.getCallCount > 0, "MockQueue.get() should be called at least once.")
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_mainTests_stopped(self): log_history.reset()() self.locker.stopping() self.failUnless(log_history.search("stopping"), "missing 'stopping' in output") log_history.reset()() d = defer.Deferred() def checker(val): self.failIf(self.locker.running) self.failUnless(log_history.search("stopped"), "missing 'stopped' in output") reactor.callLater(pokerlock.PokerLock.acquire_sleep*3, lambda: d.callback(True)) return d
def bufferPackets(client): def checkOutput(client): msgs = log_history.get_all() self.assertEquals(msgs[0], 'sendPacket: ACK type = 4 length = 3') return (client,) client.bufferized_packets = [ PacketAck() ] log_history.reset() ccd = client.connection_lost_deferred ccd.addCallback(checkOutput) return ccd
def bufferPackets(client): def checkOutput(client): assert client._out_buffer == [PacketAck()] return (client,) client._out_buffer = [ PacketAck() ] log_history.reset() ccd = client.connection_lost_deferred ccd.addCallback(checkOutput) client.transport.loseConnection() return ccd
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 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(client._keepalive_timer, None) self.assertEquals(self.client_factory[0].protocol_instance, None) return True
def test01_simple(self): log_history.reset()() d = self.locker.acquire('lock01') def validate(result): if isinstance(result, failure.Failure): raise result for string in ['__acquire lock01', '__acquire got MySQL lock', 'acquired' ]: self.failUnless(log_history.search(string), "missing '%s' in output" % string) self.assertEqual("lock01", result) self.locker.release('lock01') return result d.addBoth(validate) return d
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
def test08_mainTests_emptyQueue(self): """test08_mainTests_emptyQueue This test creates a dummy PokerLock.__init__() so that a MockQueue can be used that force-raises a Queue.Empty() exception, which is caught by the running loop in the lock and ends it.""" import Queue import threading from pokernetwork.pokerlock import PokerLock from pokernetwork import log as network_log class MockQueue: def __init__(qSelf): qSelf.qSizeCallCount = 0 qSelf.getCallCount = 0 def qsize(qSelf): qSelf.qSizeCallCount += 1 return 1 def get(qSelf, timeout = 1): qSelf.getCallCount += 1 raise Queue.Empty("MOCK") def empty(qSelf): return False def put(qSelf, val): pass myMockQueue = MockQueue() log = network_log.getChild('pokerlock') class MockInitLock(PokerLock): def __init__(self, parameters): self.log = log.getChild(self.__class__.__name__) self.q = myMockQueue self.lock = threading.Lock() self.db = None self.running = True self.connect(parameters) threading.Thread.__init__(self, target = self.main) log_history.reset()() mockLocker = MockInitLock(self.parameters) mockLocker.start() mockLocker.close() self.failUnless(log_history.search("timeout"), "output does not contain 'timeout'") self.failUnless(log_history.search("loop"), "output does not contain 'loop'") self.failUnless(myMockQueue.qSizeCallCount > 0, "MockQueue.qSize() should be called at least once.") self.failUnless(myMockQueue.getCallCount > 0, "MockQueue.get() should be called at least once.")
def checkNote(result): log_history.reset() note_to_check = result d = self.client.checkNote(note_to_check) self.assertEquals(log_history.search("checkNote"), True) def validate(result): if isinstance(result, failure.Failure): raise result checked_note = result self.assertEqual(note_to_check, checked_note) return result d.addBoth(validate) return d
def test10_mainTests_notRunningForCallback(self): import Queue import time global myLock def setNotRunning(name, timeout): global myLock myLock.running = False d = defer.Deferred() def succeeded(result): self.failIf(True) def failed(result): self.failIf(True) d.addErrback(failed) d.addCallback(succeeded) class MockQueue: def __init__(qSelf): qSelf.count = 1 def qsize(qSelf): return qSelf.count def get(qSelf, timeout = 1): if qSelf.count > 0: qSelf.count = 0 return ("Mocky", setNotRunning, 10, d) else: raise Queue.Empty def empty(qSelf): return qSelf.count <= 0 def put(qSelf, val): pass class MockLock: def __init__(lSelf): lSelf.calledReleaseCount = 0 def release(lSelf): lSelf.calledReleaseCount += 1 log_history.reset()() anotherLock = pokerlock.PokerLock(self.parameters) anotherLock.q = MockQueue() anotherLock.lock = MockLock() myLock = anotherLock anotherLock.start() time.sleep(2) self.failUnless(log_history.search('release because not running'), "missing 'release because not running' in output") self.assertEquals(anotherLock.running, False) self.assertEquals(anotherLock.lock.calledReleaseCount, 1)
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 test02_wait(self): def locker2_succeeded(result): self.locker.release('lock01') self.fail( "locker2 succeeded with result = %s : should have failed with timeout" ) self.locker2.close() 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 locker2(): log_history.reset()() self.locker2 = pokerlock.PokerLock(self.parameters) self.locker2.start() d = self.locker2.acquire('lock01', 0) d.addCallback(locker2_succeeded) d.addErrback(locker2_failed) return d 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() log_history.reset()() d = self.locker.acquire('lock01', 0) d.addBoth(validate) return d
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 test05_many(self): self.locker.message = lambda self, string: True # Runs too slow if you have messages on dl = [] def show(x): self.locker.release('lock01') pokerlock.PokerLock.acquire_sleep = 0.01 for i in xrange(1,300): d = self.locker.acquire('lock01', 3) d.addBoth(show) dl.append(d) log_history.reset()() return defer.DeferredList(dl)
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 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 test07_mainTests_stopped(self): log_history.reset()() self.locker.stopping() self.failUnless(log_history.search("stopping"), "missing 'stopping' in output") log_history.reset()() d = defer.Deferred() def checker(val): self.failIf(self.locker.running) self.failUnless(log_history.search("stopped"), "missing 'stopped' in output") reactor.callLater(pokerlock.PokerLock.acquire_sleep * 3, lambda: d.callback(True)) return d
def test05_many(self): self.locker.message = lambda self, string: True # Runs too slow if you have messages on dl = [] def show(x): self.locker.release('lock01') pokerlock.PokerLock.acquire_sleep = 0.01 for i in xrange(1, 300): d = self.locker.acquire('lock01', 3) d.addBoth(show) dl.append(d) log_history.reset()() return defer.DeferredList(dl)