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() == []