def test_emptyList(self):
     """
     When asked to run an empty list of callables, runSequentially returns a
     successful Deferred that fires an empty list.
     """
     d = util._runSequentially([])
     self.assertDeferredResult(d, self.assertEqual, [])

 def test_singleAsynchronousSuccess(self):
     """
     When given a callable that returns a successful Deferred, include the
     result of the Deferred in the results list, tagged with a SUCCESS flag.
     """
     d = util._runSequentially([lambda: defer.succeed(None)])
     self.assertDeferredResult(d, self.assertEqual, [(defer.SUCCESS, None)])

    def test_callablesCalledInOrder(self):
        """
        Check that the callables are called in the given order, one after the
        other.
        """
        log = []
        deferreds = []

        def append(value):
            d = defer.Deferred()
            log.append(value)
            deferreds.append(d)
            return d

        d = util._runSequentially([lambda: append('foo'),
                                   lambda: append('bar')])

        # runSequentially should wait until the Deferred has fired before
        # running the second callable.
        self.assertEqual(log, ['foo'])
        deferreds[-1].callback(None)
        self.assertEqual(log, ['foo', 'bar'])

        # Because returning created Deferreds makes jml happy.
        deferreds[-1].callback(None)
        return d

 def test_singleSynchronousSuccess(self):
     """
     When given a callable that succeeds without returning a Deferred,
     include the return value in the results list, tagged with a SUCCESS
     flag.
     """
     d = util._runSequentially([lambda: None])
     self.assertDeferredResult(d, self.assertEqual, [(defer.SUCCESS, None)])

 def test_singleAsynchronousFailure(self):
     """
     When given a callable that returns a failing Deferred, include the
     failure the results list, tagged with a FAILURE flag.
     """
     d = util._runSequentially([lambda: defer.fail(ValueError('foo'))])
     def check(results):
         [(flag, fail)] = results
         fail.trap(ValueError)
         self.assertEqual(fail.getErrorMessage(), 'foo')
         self.assertEqual(flag, defer.FAILURE)
     self.assertDeferredResult(d, check)

 def test_singleSynchronousFailure(self):
     """
     When given a callable that raises an exception, include a Failure for
     that exception in the results list, tagged with a FAILURE flag.
     """
     d = util._runSequentially([lambda: self.fail('foo')])
     def check(results):
         [(flag, fail)] = results
         fail.trap(self.failureException)
         self.assertEqual(fail.getErrorMessage(), 'foo')
         self.assertEqual(flag, defer.FAILURE)
     self.assertDeferredResult(d, check)

    def _runCleanups(self):
        """
        Run the cleanups added with L{addCleanup} in order.

        @return: A C{Deferred} that fires when all cleanups are run.
        """
        def _makeFunction(f, args, kwargs):
            return lambda: f(*args, **kwargs)
        callables = []
        while len(self._cleanups) > 0:
            f, args, kwargs = self._cleanups.pop()
            callables.append(_makeFunction(f, args, kwargs))
        return util._runSequentially(callables)

 def test_stopOnFirstError(self):
     """
     If the C{stopOnFirstError} option is passed to C{runSequentially}, then
     no further callables are called after the first exception is raised.
     """
     d = util._runSequentially([lambda: self.fail('foo'), lambda: 'bar'],
                               stopOnFirstError=True)
     def check(results):
         [(flag1, fail)] = results
         fail.trap(self.failureException)
         self.assertEqual(flag1, defer.FAILURE)
         self.assertEqual(fail.getErrorMessage(), 'foo')
     self.assertDeferredResult(d, check)

 def test_continuesAfterError(self):
     """
     If one of the callables raises an error, then runSequentially continues
     to run the remaining callables.
     """
     d = util._runSequentially([lambda: self.fail('foo'), lambda: 'bar'])
     def check(results):
         [(flag1, fail), (flag2, result)] = results
         fail.trap(self.failureException)
         self.assertEqual(flag1, defer.FAILURE)
         self.assertEqual(fail.getErrorMessage(), 'foo')
         self.assertEqual(flag2, defer.SUCCESS)
         self.assertEqual(result, 'bar')
     self.assertDeferredResult(d, check)

 def test_stripFlags(self):
     """
     If the C{stripFlags} option is passed to C{runSequentially} then the
     SUCCESS / FAILURE flags are stripped from the output. Instead, the
     Deferred fires a flat list of results containing only the results and
     failures.
     """
     d = util._runSequentially([lambda: self.fail('foo'), lambda: 'bar'],
                               stripFlags=True)
     def check(results):
         [fail, result] = results
         fail.trap(self.failureException)
         self.assertEqual(fail.getErrorMessage(), 'foo')
         self.assertEqual(result, 'bar')
     return d.addCallback(check)

    def test_continuesAfterError(self):
        """
        If one of the callables raises an error, then runSequentially continues
        to run the remaining callables.
        """
        d = util._runSequentially([lambda: self.fail("foo"), lambda: "bar"])

        def check(results):
            [(flag1, fail), (flag2, result)] = results
            fail.trap(self.failureException)
            self.assertEqual(flag1, defer.FAILURE)
            self.assertEqual(fail.getErrorMessage(), "foo")
            self.assertEqual(flag2, defer.SUCCESS)
            self.assertEqual(result, "bar")

        return d.addCallback(check)