def testT(self, taskqueue, fastndb):
task(T, 'T').enqueue()
consume(taskqueue)
assert [['T1', 'T2']] == messages
assert _Result.query().fetch() == []
assert queue.Lock.model.query().fetch() == []
def testParallelReturnsAllResults(self, taskqueue, ndb):
queue.parallel(
task(Ok, 'ONE'), task(Ok, 'TWO')
).then(handler).run()
consume(taskqueue)
assert [["ONE", "TWO"]] == messages
def testInOrderReturnsLastResult(self, taskqueue, ndb):
queue.inorder(
task(Ok, 'ONE'), task(Ok, 'TWO')
).then(handler).run()
consume(taskqueue)
assert ['TWO'] == messages
def testAbortInOrder(self, taskqueue, ndb):
queue.inorder(
task(A), task(T), task(C)
).run()
consume(taskqueue)
assert ["A"] == messages
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 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 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 testEnsureInOrderExecution(self, taskqueue, ndb):
queue.inorder(
task(A),
task(DEFER),
task(B)
).run()
consume(taskqueue)
assert "A DEFER deferred B".split() == 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 testLarge(self, taskqueue, fastndb):
data = 'A' * 100000
deferred.defer(A, data)
payload = deferred._DeferredTaskEntity.query().get()
assert payload.large
consume(taskqueue)
assert [data] == messages
assert deferred._DeferredTaskEntity.query().fetch() == []
def testReturnAbortToAbort(self, taskqueue, ndb):
queue.inorder(
task(A),
task(RETURN_ABORT),
task(B)
).run()
consume(taskqueue)
assert ["A"] == messages
def testNestedParallel(self, taskqueue, ndb):
queue.inorder(
task(A),
queue.parallel(
queue.parallel(task(P, 'ONE'), task(P, 'TWO'), task(P, 'THREE')),
task(B)),
task(C)
).run()
consume(taskqueue)
assert "A B ONE TWO THREE C".split() == messages
def testHuge(self, taskqueue, fastndb, blobstore):
data = 'A' * 1000000
deferred.defer(A, data)
payload = deferred._DeferredTaskEntity.query().get()
assert payload.huge
consume(taskqueue)
assert [data] == messages
assert deferred._DeferredTaskEntity.query().fetch() == []
assert blobstore.BlobInfo.all().fetch(limit=None) == []
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 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 testRemovesArgsBeforeCallingTheDeferred(self, taskqueue):
task = deferred.defer(A, 'A', _url_args=('foo','bar'))
consume(taskqueue)
assert ['A'] == messages
def testDeferredHandler(self, taskqueue, ndb):
task(Ok).success(task(handler)).run()
assert count_tasks(taskqueue) == 1
consume(taskqueue)
assert ['Ok'] == messages
def testA(self, taskqueue, ndb):
foo = Foo()
task(foo.bar).enqueue()
consume(taskqueue)
assert ['bar'] == messages
def testFurtherDefer(self, taskqueue, ndb):
task(DEFER).run()
consume(taskqueue)
assert "DEFER deferred".split() == messages
def testSmall(self, taskqueue, fastndb):
deferred.defer(A, 'A')
assert deferred._DeferredTaskEntity.query().fetch() == []
consume(taskqueue)
assert ['A'] == messages
def testYieldPlainValue(self, taskqueue, ndb):
task(Y, task(YieldPlainValue)).run()
consume(taskqueue)
assert ['VALUE'] == messages
assert _Result.query().fetch() == []
def testCallAbort(self, taskqueue, ndb):
task(Y, task(CallAbort)).run()
consume(taskqueue)
assert [] == messages
assert _Result.query().fetch() == []
def testRaisePermanentFailure(self, taskqueue, fastndb):
task(Y, task(RaisePermanentFailure)).run()
consume(taskqueue)
assert [] == messages
assert _Result.query().fetch() == []
def testB(self, taskqueue, ndb):
task(Y, task(B)).run()
consume(taskqueue)
assert ['B'] == messages
assert _Result.query().fetch() == []
def testIdCanBeReusedImmediately(self, taskqueue, ndb):
task(noop).enqueue()
assert count_tasks(taskqueue) == 1
consume(taskqueue)
task(noop).enqueue()
assert count_tasks(taskqueue) == 1
def testNested(self, taskqueue, fastndb):
task(Nested).enqueue()
consume(taskqueue)
assert "Nested Level1 Level2 Level1 Nested Done".split() == messages
assert _Result.query().fetch() == []
