def test_notBeforeBefore(self):
"""
L{PeerConnectionPool.enqueueWork} will execute its work immediately if
the C{notBefore} attribute of the work item in question is in the past.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(
txn, DummyWorkItem, a=3, b=9,
notBefore=datetime.datetime(2012, 12, 12, 12, 12, 0)
).whenProposed()
proposal = yield check
clock.advance(1000)
# Advance far beyond the given timestamp.
self.assertEquals(performerChosen, [True])
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
def test_notBeforeWhenCheckingForLostWork(self):
"""
L{PeerConnectionPool._periodicLostWorkCheck} should execute any
outstanding work items, but only those that are expired.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
# An arbitrary point in time.
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
# *why* does datetime still not have .astimestamp()
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
# Let's create a couple of work items directly, not via the enqueue
# method, so that they exist but nobody will try to immediately execute
# them.
@transactionally(dbpool.connection)
@inlineCallbacks
def setup(txn):
# First, one that's right now.
yield DummyWorkItem.create(txn, a=1, b=2, notBefore=fakeNow)
# Next, create one that's actually far enough into the past to run.
yield DummyWorkItem.create(
txn,
a=3,
b=4,
notBefore=(
# Schedule it in the past so that it should have already
# run.
fakeNow - datetime.timedelta(
seconds=qpool.queueProcessTimeout + 20)))
# Finally, one that's actually scheduled for the future.
yield DummyWorkItem.create(txn,
a=10,
b=20,
notBefore=fakeNow +
datetime.timedelta(1000))
yield setup
qpool.running = True
yield qpool._periodicLostWorkCheck()
@transactionally(dbpool.connection)
def check(txn):
return DummyWorkDone.all(txn)
every = yield check
self.assertEquals([x.aPlusB for x in every], [7])
def test_notBeforeWhenEnqueueing(self):
"""
L{PeerConnectionPool.enqueueWork} enqueues some work immediately, but
only executes it when enough time has elapsed to allow the C{notBefore}
attribute of the given work item to have passed.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(txn,
DummyWorkItem,
a=3,
b=9,
notBefore=datetime.datetime(
2012, 12, 12, 12, 12,
20)).whenProposed()
proposal = yield check
# This is going to schedule the work to happen with some asynchronous
# I/O in the middle; this is a problem because how do we know when it's
# time to check to see if the work has started? We need to intercept
# the thing that kicks off the work; we can then wait for the work
# itself.
self.assertEquals(performerChosen, [])
# Advance to exactly the appointed second.
clock.advance(20 - 12)
self.assertEquals(performerChosen, [True])
# FIXME: if this fails, it will hang, but that's better than no
# notification that it is broken at all.
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
def test_notBeforeWhenCheckingForLostWork(self):
"""
L{PeerConnectionPool._periodicLostWorkCheck} should execute any
outstanding work items, but only those that are expired.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
# An arbitrary point in time.
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
# *why* does datetime still not have .astimestamp()
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
# Let's create a couple of work items directly, not via the enqueue
# method, so that they exist but nobody will try to immediately execute
# them.
@transactionally(dbpool.connection)
@inlineCallbacks
def setup(txn):
# First, one that's right now.
yield DummyWorkItem.create(txn, a=1, b=2, notBefore=fakeNow)
# Next, create one that's actually far enough into the past to run.
yield DummyWorkItem.create(
txn, a=3, b=4, notBefore=(
# Schedule it in the past so that it should have already
# run.
fakeNow - datetime.timedelta(
seconds=qpool.queueProcessTimeout + 20
)
)
)
# Finally, one that's actually scheduled for the future.
yield DummyWorkItem.create(
txn, a=10, b=20, notBefore=fakeNow + datetime.timedelta(1000)
)
yield setup
yield qpool._periodicLostWorkCheck()
@transactionally(dbpool.connection)
def check(txn):
return DummyWorkDone.all(txn)
every = yield check
self.assertEquals([x.aPlusB for x in every], [7])
def test_notBeforeWhenEnqueueing(self):
"""
L{PeerConnectionPool.enqueueWork} enqueues some work immediately, but
only executes it when enough time has elapsed to allow the C{notBefore}
attribute of the given work item to have passed.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(
txn, DummyWorkItem, a=3, b=9,
notBefore=datetime.datetime(2012, 12, 12, 12, 12, 20)
).whenProposed()
proposal = yield check
# This is going to schedule the work to happen with some asynchronous
# I/O in the middle; this is a problem because how do we know when it's
# time to check to see if the work has started? We need to intercept
# the thing that kicks off the work; we can then wait for the work
# itself.
self.assertEquals(performerChosen, [])
# Advance to exactly the appointed second.
clock.advance(20 - 12)
self.assertEquals(performerChosen, [True])
# FIXME: if this fails, it will hang, but that's better than no
# notification that it is broken at all.
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
def test_notBeforeBefore(self):
"""
L{PeerConnectionPool.enqueueWork} will execute its work immediately if
the C{notBefore} attribute of the work item in question is in the past.
"""
dbpool = buildConnectionPool(self, schemaText + nodeSchema)
fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)
sinceEpoch = astimestamp(fakeNow)
clock = Clock()
clock.advance(sinceEpoch)
qpool = PeerConnectionPool(clock, dbpool.connection, 0, schema)
realChoosePerformer = qpool.choosePerformer
performerChosen = []
def catchPerformerChoice():
result = realChoosePerformer()
performerChosen.append(True)
return result
qpool.choosePerformer = catchPerformerChoice
@transactionally(dbpool.connection)
def check(txn):
return qpool.enqueueWork(txn,
DummyWorkItem,
a=3,
b=9,
notBefore=datetime.datetime(
2012, 12, 12, 12, 12,
0)).whenProposed()
proposal = yield check
clock.advance(1000)
# Advance far beyond the given timestamp.
self.assertEquals(performerChosen, [True])
result = yield proposal.whenExecuted()
self.assertIdentical(result, proposal)
def setUp(self):
self.pool = buildConnectionPool(self)
def setUp(self):
self.pool = buildConnectionPool(self)
def setUp(self):
self.pool = buildConnectionPool(self, schemaString)
def setUp(self):
"""
Build a connection pool for the tests to use.
"""
self.pool = buildConnectionPool(self, schemaText)
def setUp(self):
"""
Build a connection pool for the tests to use.
"""
self.pool = buildConnectionPool(self, schemaText)
def setUp(self):
self.pool = buildConnectionPool(self, schemaString)