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