Merge lp:~allenap/maas/wait-for-reset--bug-1356788 into lp:~maas-committers/maas/trunk

[Gavin Panella]

Unfired and unhandled EventualResults are checked for at the end of each test.

[Raphaël Badin (rvb)]

Looks good; I take it you tested that this correctly detects the problem described in the related bug…?

review: Approve

[Gavin Panella (allenap)]

> Looks good; I take it you tested that this correctly detects the problem
> described in the related bug…?

Yep, it sure does :) Thanks for the review.

=== modified file 'src/maasserver/tests/test_eventloop.py'
--- src/maasserver/tests/test_eventloop.py	2014-08-13 21:49:35 +0000
+++ src/maasserver/tests/test_eventloop.py	2014-08-14 16:32:52 +0000
@@ -51,7 +51,7 @@
         # After starting the loop, the services list is populated, and
         # the services are started too.
         eventloop.loop.start().wait(5)
-        self.addCleanup(eventloop.loop.reset)
+        self.addCleanup(lambda: eventloop.loop.reset().wait(5))
         self.assertTrue(eventloop.loop.services.running)
         self.assertTrue(eventloop.loop.running)
         self.assertEqual(

=== added file 'src/maastesting/crochet.py'
--- src/maastesting/crochet.py	1970-01-01 00:00:00 +0000
+++ src/maastesting/crochet.py	2014-08-14 16:32:52 +0000
@@ -0,0 +1,102 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Support for testing with `crochet`."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    "EventualResultCatchingMixin",
+    ]
+
+import crochet
+from testtools.content import (
+    Content,
+    UTF8_TEXT,
+    )
+from testtools.matchers import Equals
+
+
+class EventualResultCatchingMixin:
+    """A mix-in for tests that checks for unfired/unhandled `EventualResults`.
+
+    It reports about all py:class:`crochet.EventualResults` that are unfired
+    or whose results have not been retrieved. A test detail is recorded for
+    each, then the test is force-failed at the last moment.
+    """
+
+    def setUp(self):
+        super(EventualResultCatchingMixin, self).setUp()
+        # Every EventualResult that crochet creates is registered into this
+        # registry. We'll check it after the test has finished.
+        registry = crochet._main._registry
+        # The registry stores EventualResults in a WeakSet, which means that
+        # unfired and unhandled results can be garbage collected before we get
+        # to see them. Here we patch in a regular set so that nothing gets
+        # garbage collected until we've been able to check the results.
+        self.addCleanup(setattr, registry, "_results", registry._results)
+        registry._results = set()
+        # While unravelling clean-ups is a good time to check the results. Any
+        # meaningful work represented by an EventualResult should have done
+        # should been done by now.
+        self.addCleanup(self.__checkResults, registry._results)
+
+    def __checkResults(self, eventual_results):
+        fail_count = 0
+
+        # Go through all the EventualResults created in this test.
+        for eventual_result in eventual_results:
+            # If the result has been retrieved, fine, otherwise look closer.
+            if not eventual_result._result_retrieved:
+                fail_count += 1
+
+                try:
+                    # Is there a result waiting to be retrieved?
+                    result = eventual_result.wait(timeout=0)
+                except crochet.TimeoutError:
+                    # No result yet. This could be because the result is wired
+                    # up to a Deferred that hasn't fired yet, or because it
+                    # hasn't yet been connected.
+                    if eventual_result._deferred is None:
+                        message = [
+                            "*** EventualResult has not fired:\n",
+                            "%r\n" % (eventual_result,),
+                            "*** It was not connected to a Deferred.\n",
+                        ]
+                    else:
+                        message = [
+                            "*** EventualResult has not fired:\n",
+                            "%r\n" % (eventual_result,),
+                            "*** It was connected to a Deferred:\n",
+                            "%r\n" % (eventual_result._deferred,),
+                        ]
+                else:
+                    # A result, but nothing has collected it. This can be
+                    # caused by forgetting to call wait().
+                    message = [
+                        "*** EventualResult has fired:\n",
+                        "%r\n" % (eventual_result,),
+                        "*** It contained the following result:\n",
+                        "%r\n" % (result,),
+                        "*** but it was not collected.\n",
+                        "*** Was result.wait() called?\n",
+                    ]
+
+                # Record the details with a unique name.
+                message = [block.encode("utf-8") for block in message]
+                self.addDetail(
+                    "Unfired/unhandled EventualResult #%d" % fail_count,
+                    Content(UTF8_TEXT, lambda: message))
+
+        # Use expectThat() so that other clean-up tasks run to completion
+        # before, at the last moment, the test is failed.
+        self.expectThat(
+            fail_count, Equals(0), "Unfired and/or unhandled "
+            "EventualResult(s); see test details.")

=== modified file 'src/maastesting/testcase.py'
--- src/maastesting/testcase.py	2014-02-01 04:29:17 +0000
+++ src/maastesting/testcase.py	2014-08-14 16:32:52 +0000
@@ -20,6 +20,7 @@
 import doctest
 import unittest
 
+from maastesting.crochet import EventualResultCatchingMixin
 from maastesting.factory import factory
 from maastesting.fixtures import TempDirectory
 from maastesting.scenarios import WithScenarios
@@ -53,7 +54,10 @@
         yield
 
 
-class MAASTestCase(WithScenarios, testtools.TestCase):
+class MAASTestCase(
+        WithScenarios,
+        EventualResultCatchingMixin,
+        testtools.TestCase):
     """Base `TestCase` for MAAS.
 
     Supports `test resources`_, `test scenarios`_, and `fixtures`_.