def testLaunchLaunchFails(self):
"""
Launch a job twice and make sure the second attempt gets a
C{RuntimeError}.
"""
job = Job(None, 0)
job.launch(lambda x: x)
self.assertRaises(RuntimeError, job.launch, lambda x: x)
def testWatchLaunchSucceedCheckResult(self):
"""
Watch a job, launch it, and check the C{Deferred} receives a L{Job}
instance whose result is correct.
"""
def cb(result):
self.assertEqual(result.result, 42)
job = Job(6, 0)
deferred = job.watch()
deferred.addCallback(cb)
job.launch(lambda x: x * 7)
return deferred
def testLaunchSucceedWatch(self):
"""
Launch a job that succeeds, then watch it and check the C{Deferred}
receives a L{Job} instance whose state is FINISHED.
"""
def cb(result):
self.assertEqual(result.state, Job.FINISHED)
job = Job(None, 0)
job.launch(lambda x: x)
deferred = job.watch()
deferred.addCallback(cb)
return deferred
def testWatchLaunchSucceedCancelDeferred(self):
"""
Watch a job that is launched and succeeds, and then call cancel on
the watching C{Deferred}. 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)
deferred.cancel()
return deferred
def testWatchLaunchFail(self):
"""
Watch a job that launches and fails. The L{Job} instance in the
failure must be in the FAILED state. Check the underlying failure
is as expected (in this case a ZeroDivisionError).
"""
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)
deferred = job.watch()
deferred.addCallbacks(cb, eb)
job.launch(lambda x: 1 / 0)
return deferred
def testLaunchFailWatchCancelDeferred(self):
"""
Launch a job that fails, then watch it, then cancel the watching
C{Deferred}. 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)
deferred.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
