def testWatchLaunchSucceedCancel(self):
"""
Watch a job that is launched and succeeds, and then call cancel on
it. The C{Deferred} will receive a Job instance whose state is
FINISHED (i.e., the cancel will have no effect).
"""
def cb(result):
self.assertEqual(result.state, Job.FINISHED)
job = Job(None, 0)
deferred = job.watch()
deferred.addCallback(cb)
job.launch(lambda x: x)
job.cancel()
return deferred
def testWatchCancel(self):
"""
Watch a job and check that when we cancel it before it has been
launched the watcher gets an errback with a L{Job} instance whose
state is CANCELLED.
"""
def cb(result):
self.fail('Unexpectedly succeeded!')
def eb(failure):
self.assertTrue(isinstance(failure.value, Job))
self.assertEqual(failure.value.state, Job.CANCELLED)
job = Job(None, 0)
deferred = job.watch()
deferred.addCallbacks(cb, eb)
job.cancel()
return deferred
def testLaunchFailWatchCancel(self):
"""
Launch a job that fails, then watch it, then cancel it. The
C{Deferred} will receive a Job instance whose state is FAILED (i.e.,
the cancel will have no effect).
"""
def cb(result):
self.fail('Unexpectedly succeeded!')
def eb(failure):
self.assertEqual(failure.value.state, Job.FAILED)
self.assertTrue(isinstance(failure.value.failure.value,
ZeroDivisionError))
job = Job(None, 0)
job.launch(lambda x: 1 / 0)
deferred = job.watch()
deferred.addCallbacks(cb, eb)
job.cancel()
return deferred
def testWatchLaunchUnderwayCancel(self):
"""
Watch a job, launch it with a function that returns a C{Deferred}
that is slow to fire, then cancel the job. Check the watching
C{Deferred} receives a L{Job} instance whose state is CANCELLED.
"""
def cb(result):
self.fail('Unexpectedly succeeded!')
def eb(failure):
self.assertEqual(failure.value.state, Job.CANCELLED)
def run(x):
return task.deferLater(reactor, 3, lambda x: x)
job = Job(None, 0)
deferred = job.watch()
deferred.addCallbacks(cb, eb)
job.launch(run)
job.cancel()
return deferred
