title: How can Twisted Deferred errors without errbacks be tested with trial?
body: <p>I have some Twisted code which creates multiple chains of Deferreds.  Some of these may fail without having an errback which puts them back on the callback chain.  I haven't been able to write a unit test for this code - the failing Deferred causes the test to fail after the test code has completed.  How can I write a passing unit test for this code?  Is it expected that every Deferred which could fail in normal operation should have an errback at the end of the chain which puts it back on the callback chain?</p>
  
  <p>The same thing happens when there's a failed Deferred in a DeferredList, unless I create the DeferredList with consumeErrors.  This is the case even when the DeferredList is created with fireOnOneErrback and is given an errback which puts it back on the callback chain.  Are there any implications for consumeErrors besides suppressing test failures and error logging?  Should every Deferred which may fail without an errback be put a DeferredList?</p>
  
  <p>Example tests of example code:</p>
  
  <pre><code>from twisted.trial import unittest
  from twisted.internet import defer
  
  def get_dl(**kwargs):
      "Return a DeferredList with a failure and any kwargs given."
      return defer.DeferredList(
          [defer.succeed(True), defer.fail(ValueError()), defer.succeed(True)],
          **kwargs)
  
  def two_deferreds():
      "Create a failing Deferred, and create and return a succeeding Deferred."
      d = defer.fail(ValueError())
      return defer.succeed(True)
  
  
  class DeferredChainTest(unittest.TestCase):
  
      def check_success(self, result):
          "If we're called, we're on the callback chain."        
          self.fail()
  
      def check_error(self, failure):
          """
          If we're called, we're on the errback chain.
          Return to put us back on the callback chain.
          """
          return True
  
      def check_error_fail(self, failure):
          """
          If we're called, we're on the errback chain.
          """
          self.fail()        
  
      # This fails after all callbacks and errbacks have been run, with the
      # ValueError from the failed defer, even though we're
      # not on the errback chain.
      def test_plain(self):
          """
          Test that a DeferredList without arguments is on the callback chain.
          """
          # check_error_fail asserts that we are on the callback chain.
          return get_dl().addErrback(self.check_error_fail)
  
      # This fails after all callbacks and errbacks have been run, with the
      # ValueError from the failed defer, even though we're
      # not on the errback chain.
      def test_fire(self):
          """
          Test that a DeferredList with fireOnOneErrback errbacks on failure,
          and that an errback puts it back on the callback chain.
          """
          # check_success asserts that we don't callback.
          # check_error_fail asserts that we are on the callback chain.
          return get_dl(fireOnOneErrback=True).addCallbacks(
              self.check_success, self.check_error).addErrback(
              self.check_error_fail)
  
      # This succeeds.
      def test_consume(self):
          """
          Test that a DeferredList with consumeErrors errbacks on failure,
          and that an errback puts it back on the callback chain.
          """
          # check_error_fail asserts that we are on the callback chain.
          return get_dl(consumeErrors=True).addErrback(self.check_error_fail)
  
      # This succeeds.
      def test_fire_consume(self):
          """
          Test that a DeferredList with fireOnOneCallback and consumeErrors
          errbacks on failure, and that an errback puts it back on the
          callback chain.
          """
          # check_success asserts that we don't callback.
          # check_error_fail asserts that we are on the callback chain.
          return get_dl(fireOnOneErrback=True, consumeErrors=True).addCallbacks(
              self.check_success, self.check_error).addErrback(
              self.check_error_fail)
  
      # This fails after all callbacks and errbacks have been run, with the
      # ValueError from the failed defer, even though we're
      # not on the errback chain.
      def test_two_deferreds(self):
          # check_error_fail asserts that we are on the callback chain.        
          return two_deferreds().addErrback(self.check_error_fail)
  </code></pre>