Move internal get_inserter to be StreamResult based.

3 files changed, 78 insertions, 117 deletions

diff --git a/testrepository/repository/__init__.py b/testrepository/repository/__init__.py
index 04471de..be9feec 100644
--- a/testrepository/repository/__init__.py
+++ b/testrepository/repository/__init__.py
@@ -148,7 +148,11 @@ class AbstractRepository(object):
 
 
 class AbstractTestRun(object):
-    """A test run that has been stored in a repository."""
+    """A test run that has been stored in a repository.
+    
+    Should implement the StreamResult protocol as well
+    as the testrepository specific methods documented here.
+    """
 
     def get_id(self):
         """Get the id of the test run.
diff --git a/testrepository/repository/file.py b/testrepository/repository/file.py
index 27bbb1b..30911ea 100644
--- a/testrepository/repository/file.py
+++ b/testrepository/repository/file.py
@@ -26,6 +26,7 @@ import tempfile
 
 import subunit
 from subunit import TestProtocolClient
+import testtools
 from testtools.compat import _b
 
 from testrepository.repository import (
@@ -192,7 +193,7 @@ class _DiskRun(AbstractTestRun):
         return subunit.ProtocolTestCase(self.get_subunit_stream())
 
 
-class _SafeInserter(TestProtocolClient):
+class _SafeInserter(object):
 
     def __init__(self, repository, partial=False):
         # XXX: Perhaps should factor into a decorator and use an unaltered
@@ -206,13 +207,25 @@ class _SafeInserter(TestProtocolClient):
         self._times = {}
         self._test_start = None
         self._time = None
-        TestProtocolClient.__init__(self, stream)
+        subunit_client = testtools.StreamToExtendedDecorator(
+            TestProtocolClient(stream))
+        self.hook = testtools.CopyStreamResult([
+            subunit_client,
+            testtools.StreamToDict(self._handle_test)])
+        self._stream = stream
+
+    def _handle_test(self, test_dict):
+        start, stop = test_dict['timestamps']
+        if None in (start, stop):
+            return
+        self._times[test_dict['id']] = str(timedelta_to_seconds(stop - start))
 
     def startTestRun(self):
-        pass
+        self.hook.startTestRun()
+        self._run_id = None
 
     def stopTestRun(self):
-        # TestProtocolClient.stopTestRun(self)
+        self.hook.stopTestRun()
         self._stream.flush()
         self._stream.close()
         run_id = self._name()
@@ -233,30 +246,18 @@ class _SafeInserter(TestProtocolClient):
                     db[key] = value
         finally:
             db.close()
-        return run_id
+        self._run_id = run_id
+
+    def status(self, *args, **kwargs):
+        self.hook.status(*args, **kwargs)
 
     def _cancel(self):
         """Cancel an insertion."""
         self._stream.close()
         os.unlink(self.fname)
 
-    def startTest(self, test):
-        result = TestProtocolClient.startTest(self, test)
-        self._test_start = self._time
-        return result
-
-    def stopTest(self, test):
-        result = TestProtocolClient.stopTest(self, test)
-        if None in (self._test_start, self._time):
-            return result
-        duration_seconds = timedelta_to_seconds(self._time - self._test_start)
-        self._times[test.id()] = str(duration_seconds)
-        return result
-
-    def time(self, timestamp):
-        result = TestProtocolClient.time(self, timestamp)
-        self._time = timestamp
-        return result
+    def get_id(self):
+        return self._run_id
 
 
 class _FailingInserter(_SafeInserter):
@@ -271,42 +272,37 @@ class _Inserter(_SafeInserter):
     def _name(self):
         return self._repository._allocate()
 
-    def get_id(self):
-        return self._run_id
-
-    def startTestRun(self):
-        super(_Inserter, self).startTestRun()
-        self._run_id = None
-
     def stopTestRun(self):
-        run_id = _SafeInserter.stopTestRun(self)
-        self._run_id = run_id
+        super(_Inserter, self).stopTestRun()
         # XXX: locking (other inserts may happen while we update the failing
         # file).
         # Combine failing + this run : strip passed tests, add failures.
         # use memory repo to aggregate. a bit awkward on layering ;).
+        # Should just pull the failing items aside as they happen perhaps.
+        # Or use a router and avoid using a memory object at all.
         from testrepository.repository import memory
         repo = memory.Repository()
         if self.partial:
             # Seed with current failing
-            inserter = repo.get_inserter()
+            inserter = testtools.ExtendedToStreamDecorator(repo.get_inserter())
             inserter.startTestRun()
             failing = self._repository.get_failing()
             failing.get_test().run(inserter)
             inserter.stopTestRun()
-        inserter= repo.get_inserter(partial=True)
+        inserter= testtools.ExtendedToStreamDecorator(repo.get_inserter(partial=True))
         inserter.startTestRun()
-        run = self._repository.get_test_run(run_id)
+        run = self._repository.get_test_run(self.get_id())
         run.get_test().run(inserter)
         inserter.stopTestRun()
         # and now write to failing
         inserter = _FailingInserter(self._repository)
-        inserter.startTestRun()
+        _inserter = testtools.ExtendedToStreamDecorator(inserter)
+        _inserter.startTestRun()
         try:
-            repo.get_failing().get_test().run(inserter)
+            repo.get_failing().get_test().run(_inserter)
         except:
             inserter._cancel()
             raise
         else:
-            inserter.stopTestRun()
-        return run_id
+            _inserter.stopTestRun()
+        return self.get_id()
diff --git a/testrepository/repository/memory.py b/testrepository/repository/memory.py
index 9eca6da..a332d6f 100644
--- a/testrepository/repository/memory.py
+++ b/testrepository/repository/memory.py
@@ -17,7 +17,7 @@
 from io import BytesIO
 
 import subunit
-from testtools.content import TracebackContent
+import testtools
 
 from testrepository.repository import (
     AbstractRepository,
@@ -107,10 +107,9 @@ class _Failures(AbstractTestRun):
         return self
 
     def run(self, result):
-        for outcome, test, details in self._repository._failing.values():
-            result.startTest(test)
-            getattr(result, 'add' + outcome)(test, details=details)
-            result.stopTest(test)
+        # Speaks original.
+        for case in self._repository._failing.values():
+            case.run(result)
 
 
 class _Inserter(AbstractTestRun):
@@ -119,98 +118,60 @@ class _Inserter(AbstractTestRun):
     def __init__(self, repository, partial):
         self._repository = repository
         self._partial = partial
-        self._outcomes = []
-        self._events = []
-        self._time = None
-        self._test_start = None
+        self._tests = []
+        # Subunit V1 stream for get_subunit_stream
+        self._subunit = None
 
     def startTestRun(self):
-        pass
+        self._subunit = BytesIO()
+        serialiser = subunit.TestProtocolClient(self._subunit)
+        serialiser = testtools.StreamToExtendedDecorator(serialiser)
+        self._hook = testtools.CopyStreamResult([
+            testtools.StreamToDict(self._handle_test),
+            serialiser])
+        self._hook.startTestRun()
+
+    def _handle_test(self, test_dict):
+        self._tests.append(test_dict)
+        start, stop = test_dict['timestamps']
+        if None in (start, stop):
+            return
+        duration_delta = stop - start
+        duration_seconds = ((duration_delta.microseconds +
+            (duration_delta.seconds + duration_delta.days * 24 * 3600)
+            * 10**6) / 10.0**6)
+        self._repository._times[test_dict['id']] = duration_seconds
 
     def stopTestRun(self):
+        self._hook.stopTestRun()
         self._repository._runs.append(self)
         self._run_id = len(self._repository._runs) - 1
         if not self._partial:
             self._repository._failing = {}
-        for record in self._outcomes:
-            test_id = record[1].id()
-            if record[0] in ('Failure', 'Error'):
-                self._repository._failing[test_id] = record
+        for test_dict in self._tests:
+            test_id = test_dict['id']
+            if test_dict['status'] == 'fail':
+                case = testtools.testresult.real.test_dict_to_case(test_dict)
+                self._repository._failing[test_id] = case
             else:
                 self._repository._failing.pop(test_id, None)
         return self._run_id
 
-    def startTest(self, test):
-        self._test_start = self._time
-        self._events.append(('startTest', test))
-
-    def stopTest(self, test):
-        self._events.append(('stopTest', test))
-        if None in (self._test_start, self._time):
-            return
-        duration_delta = self._time - self._test_start
-        duration_seconds = ((duration_delta.microseconds +
-            (duration_delta.seconds + duration_delta.days * 24 * 3600)
-            * 10**6) / 10.0**6)
-        self._repository._times[test.id()] = duration_seconds
-
-    def _addOutcome(self, outcome, test, details):
-        self._outcomes.append((outcome, test, details))
-
-    def addSuccess(self, test, details=None):
-        self._events.append(('addSuccess', test, details))
-        self._addOutcome('Success', test, details)
-
-    def _force_to_details(self, test, err, details):
-        if not details:
-            details = {}
-        if err is not None:
-            details['err'] = TracebackContent(err, test)
-        return details
-
-    def addFailure(self, test, err=None, details=None):
-        # Don't support old interface for now.
-        self._events.append(('addFailure', test, err, details))
-        details = self._force_to_details(test, err, details)
-        self._addOutcome('Failure', test, details)
-
-    def addError(self, test, err=None, details=None):
-        self._events.append(('addError', test, err, details))
-        details = self._force_to_details(test, err, details)
-        self._addOutcome('Error', test, details)
-
-    def addExpectedFailure(self, test, err=None, details=None):
-        assert err is None
-        self._events.append(('addExpectedFailure', test, None, details))
-        self._addOutcome('ExpectedFailure', test, details)
-
-    def addUnexpectedSuccess(self, test, details=None):
-        self._events.append(('addUnexpectedSuccess', test, details))
-        self._addOutcome('UnexpectedSuccess', test, details)
-
-    def addSkip(self, test, reason=None, details=None):
-        assert reason is None
-        self._events.append(('addSkip', test, None, details))
-        self._addOutcome('Skip', test, details)
+    def status(self, *args, **kwargs):
+        self._hook.status(*args, **kwargs)
 
     def get_id(self):
         return self._run_id
 
     def get_subunit_stream(self):
-        result = BytesIO()
-        serialiser = subunit.TestProtocolClient(result)
-        self.run(serialiser)
-        result.seek(0)
-        return result
+        self._subunit.seek(0)
+        return self._subunit
 
     def get_test(self):
         return self
 
     def run(self, result):
-        for event in self._events:
-            method = getattr(result, event[0])
-            method(*event[1:])
-
-    def time(self, timestamp):
-        self._events.append(('time', timestamp))
-        self._time = timestamp
+        # Speaks original.
+        for test_dict in self._tests:
+            case = testtools.testresult.real.test_dict_to_case(test_dict)
+            case.run(result)