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