def testParallelReturnsAllResults(self, taskqueue, ndb):
queue.parallel(
task(Ok, 'ONE'), task(Ok, 'TWO')
).then(handler).run()
consume(taskqueue)
assert [["ONE", "TWO"]] == messages
def testParentUsesId2(self, taskqueue):
main = task(noop, _use_id='A')
sub = task(P)
main.enqueue_subtask(sub)
main.enqueue_subtask(sub)
assert count_tasks(taskqueue) == 1
def testAbortInOrder(self, taskqueue, ndb):
queue.inorder(
task(A), task(T), task(C)
).run()
consume(taskqueue)
assert ["A"] == messages
def testInOrderReturnsLastResult(self, taskqueue, ndb):
queue.inorder(
task(Ok, 'ONE'), task(Ok, 'TWO')
).then(handler).run()
consume(taskqueue)
assert ['TWO'] == messages
def testParentUsesName2(self, taskqueue):
main = task(noop)
sub = task(P)
main.enqueue_subtask(sub)
main.enqueue_subtask(sub)
assert count_tasks(taskqueue) == 1
def testInOrder(self, taskqueue, ndb):
queue.inorder(
task(A), task(B), task(C)
).run()
assert count_tasks(taskqueue) == 1
consume(taskqueue)
assert ['A', 'B', 'C'] == messages
def testAbortParallel(self, taskqueue, fastndb):
queue.parallel(
task(P, 'ONE'), task(T), task(P, 'TWO')
).then(task(C)).run()
consume(taskqueue)
assert "ONE TWO".split() == messages
assert [] == queue._Counter.query().fetch()
def testParallel(self, taskqueue, ndb):
queue.parallel(
task(P, 'ONE'), task(P, 'TWO'), task(P, 'THREE')
).run()
assert count_tasks(taskqueue) == 3
consume(taskqueue)
assert 'ONE TWO THREE'.split() == messages
def testNestedInOrder(self, taskqueue, ndb):
queue.inorder(
task(A),
queue.inorder(task(P, 'ONE'), task(P, 'TWO')),
task(C)
).run()
consume(taskqueue)
assert 'A ONE TWO C'.split() == messages
def testEnsureInOrderExecution(self, taskqueue, ndb):
queue.inorder(
task(A),
task(DEFER),
task(B)
).run()
consume(taskqueue)
assert "A DEFER deferred B".split() == messages
def testReturnAbortToAbort(self, taskqueue, ndb):
queue.inorder(
task(A),
task(RETURN_ABORT),
task(B)
).run()
consume(taskqueue)
assert ["A"] == messages
def testEnsureMultipleTaskGetCleanedIfReleaseAfterIsIused(
self, taskqueue, fastndb):
queue.inorder(
task(P, 'ONE')
).enqueue(release_after=1)
queue.inorder(
task(P, 'TWO')
).enqueue(release_after=1)
consume(taskqueue)
semaphores = queue.Lock.model.query().fetch()
assert len(semaphores) == 0
def testCombined(self, taskqueue, fastndb):
queue.inorder(
task(A),
queue.parallel(task(P, 'ONE'), task(P, 'TWO'), task(P, 'THREE')),
task(B)
).run()
consume(taskqueue)
assert 'A ONE TWO THREE B'.split() == messages
assert [] == queue._Counter.query().fetch()
def testComplicated(self, taskqueue, ndb):
queue.parallel(
task(A),
queue.inorder(
task(P, 'ONE'),
task(P, 'TWO'),
task(P, 'THREE')
),
task(B)
).run()
consume(taskqueue)
assert "A B ONE TWO THREE".split() == messages
def testA(self, taskqueue, ndb):
A = queue.inorder(
task(P)
).enqueue(use_id='A')
B = queue.inorder(
task(P)
).enqueue(use_id='B')
assert count_tasks(taskqueue) == 2
tick(taskqueue)
assert count_tasks(taskqueue) == 2
tick(taskqueue)
assert count_tasks(taskqueue) == 0
assert 'P P'.split() == messages
def testIdIsReleasedAfterXSeconds(self, taskqueue, ndb):
task(noop).enqueue(release_after=1)
assert count_tasks(taskqueue) == 1
tick(taskqueue)
assert count_tasks(taskqueue) == 1 # the cleanup handler
cleanup_handler = taskqueue.get_filtered_tasks()[0]
now = datetime.datetime.now(tz=queue.taskqueue.taskqueue._UTC)
now = now.replace(microsecond=0)
assert cleanup_handler.eta == now + datetime.timedelta(seconds=1)
task(noop).enqueue()
assert count_tasks(taskqueue) == 1
tick(taskqueue)
assert count_tasks(taskqueue) == 0 # ensure
task(noop).enqueue()
assert count_tasks(taskqueue) == 1
def testA(self, taskqueue, ndb):
foo = Foo()
task(foo.bar).enqueue()
consume(taskqueue)
assert ['bar'] == messages
def testPreventNamedTaskToBeScheduledTwice2(self, taskqueue):
task(noop, _name='A').enqueue()
task(noop, _name='A').enqueue()
assert count_tasks(taskqueue) == 1
def testCallAbortToAbort(self, taskqueue):
task(CALL_ABORT).then(None, handler).run()
assert "ABORT NOW" == str(messages[0])
assert isinstance(messages[0], queue.AbortQueue)
def testFailure(self, taskqueue):
task(RETURN_ABORT).failure(handler).run()
assert [queue.ABORT] == messages
def testDeferredHandler(self, taskqueue, ndb):
task(Ok).success(task(handler)).run()
assert count_tasks(taskqueue) == 1
consume(taskqueue)
assert ['Ok'] == messages
def testCantAddTheSameHandlerTwice(self, taskqueue):
task(Ok).success(handler).success(handler).run()
assert ['Ok'] == messages
def testSuccess(self, taskqueue):
task(Ok).success(handler).run()
assert ['Ok'] == messages
def testSilentlyDisallowDoubleExecution(self, taskqueue, ndb):
task(noop).enqueue()
task(noop).enqueue()
assert count_tasks(taskqueue) == 1
def testProtectedByGivenId2(self, taskqueue, ndb):
task(noop, _use_id='A').enqueue()
task(noop, _use_id='A').enqueue()
assert count_tasks(taskqueue) == 1
def testIdCanBeReusedImmediately(self, taskqueue, ndb):
task(noop).enqueue()
assert count_tasks(taskqueue) == 1
consume(taskqueue)
task(noop).enqueue()
assert count_tasks(taskqueue) == 1
def testTaskStr(self):
print task(P, message='ONE')
print queue.inorder(task(A), task(B))
print queue.parallel(task(A), task(B), task(P, message='ONE'))
def DEFER():
messages.append('DEFER')
return task(P, 'deferred')
def testDisableProtection3(self, taskqueue):
task(noop, _use_id=False).enqueue()
task(noop, _use_id=False).enqueue()
assert count_tasks(taskqueue) == 2
def testFurtherDefer(self, taskqueue, ndb):
task(DEFER).run()
consume(taskqueue)
assert "DEFER deferred".split() == messages
