Merge support for time: tags in the python bindings, and --times in subunit-ls.

6 files changed, 515 insertions, 34 deletions

diff --git a/python/subunit/__init__.py b/python/subunit/__init__.py
index fb6c83e..7859ea7 100644
--- a/python/subunit/__init__.py
+++ b/python/subunit/__init__.py
@@ -17,13 +17,17 @@
 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #
 
+import datetime
 import os
+import re
 from StringIO import StringIO
 import subprocess
 import sys
-import re
 import unittest
 
+import iso8601
+
+
 def test_suite():
     import subunit.tests
     return subunit.tests.test_suite()
@@ -207,6 +211,16 @@ class TestProtocolServer(object):
         update_tags.update(new_tags)
         update_tags.difference_update(gone_tags)
 
+    def _handleTime(self, offset, line):
+        # Accept it, but do not do anything with it yet.
+        try:
+            event_time = iso8601.parse_date(line[offset:-1])
+        except TypeError, e:
+            raise TypeError("Failed to parse %r, got %r" % (line, e))
+        time_method = getattr(self.client, 'time', None)
+        if callable(time_method):
+            time_method(event_time)
+
     def lineReceived(self, line):
         """Call the appropriate local method for the received line."""
         if line == "]\n":
@@ -236,8 +250,7 @@ class TestProtocolServer(object):
                 elif cmd in ('tags',):
                     self._handleTags(offset, line)
                 elif cmd in ('time',):
-                    # Accept it, but do not do anything with it yet.
-                    pass
+                    self._handleTime(offset, line)
                 elif cmd == 'xfail':
                     self._addExpectedFail(offset, line)
                 else:
@@ -342,6 +355,16 @@ class TestProtocolClient(unittest.TestResult):
         """Mark a test as starting its test run."""
         self._stream.write("test: %s\n" % test.id())
 
+    def time(self, a_datetime):
+        """Inform the client of the time.
+
+        ":param datetime: A datetime.datetime object.
+        """
+        time = a_datetime.astimezone(iso8601.Utc())
+        self._stream.write("time: %04d-%02d-%02d %02d:%02d:%02d.%06dZ\n" % (
+            time.year, time.month, time.day, time.hour, time.minute,
+            time.second, time.microsecond))
+
     def done(self):
         """Obey the testtools result.done() interface."""
 
diff --git a/python/subunit/iso8601.py b/python/subunit/iso8601.py
new file mode 100644
index 0000000..93c92fb
--- /dev/null
+++ b/python/subunit/iso8601.py
@@ -0,0 +1,123 @@
+# Copyright (c) 2007 Michael Twomey
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+"""ISO 8601 date time string parsing
+
+Basic usage:
+>>> import iso8601
+>>> iso8601.parse_date("2007-01-25T12:00:00Z")
+datetime.datetime(2007, 1, 25, 12, 0, tzinfo=<iso8601.iso8601.Utc ...>)
+>>>
+
+"""
+
+from datetime import datetime, timedelta, tzinfo
+import re
+
+__all__ = ["parse_date", "ParseError"]
+
+# Adapted from http://delete.me.uk/2005/03/iso8601.html
+ISO8601_REGEX = re.compile(r"(?P<year>[0-9]{4})(-(?P<month>[0-9]{1,2})(-(?P<day>[0-9]{1,2})"
+    r"((?P<separator>.)(?P<hour>[0-9]{2}):(?P<minute>[0-9]{2})(:(?P<second>[0-9]{2})(\.(?P<fraction>[0-9]+))?)?"
+    r"(?P<timezone>Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?"
+)
+TIMEZONE_REGEX = re.compile("(?P<prefix>[+-])(?P<hours>[0-9]{2}).(?P<minutes>[0-9]{2})")
+
+class ParseError(Exception):
+    """Raised when there is a problem parsing a date string"""
+
+# Yoinked from python docs
+ZERO = timedelta(0)
+class Utc(tzinfo):
+    """UTC
+    
+    """
+    def utcoffset(self, dt):
+        return ZERO
+
+    def tzname(self, dt):
+        return "UTC"
+
+    def dst(self, dt):
+        return ZERO
+UTC = Utc()
+
+class FixedOffset(tzinfo):
+    """Fixed offset in hours and minutes from UTC
+    
+    """
+    def __init__(self, offset_hours, offset_minutes, name):
+        self.__offset = timedelta(hours=offset_hours, minutes=offset_minutes)
+        self.__name = name
+
+    def utcoffset(self, dt):
+        return self.__offset
+
+    def tzname(self, dt):
+        return self.__name
+
+    def dst(self, dt):
+        return ZERO
+    
+    def __repr__(self):
+        return "<FixedOffset %r>" % self.__name
+
+def parse_timezone(tzstring, default_timezone=UTC):
+    """Parses ISO 8601 time zone specs into tzinfo offsets
+    
+    """
+    if tzstring == "Z":
+        return default_timezone
+    # This isn't strictly correct, but it's common to encounter dates without
+    # timezones so I'll assume the default (which defaults to UTC).
+    # Addresses issue 4.
+    if tzstring is None:
+        return default_timezone
+    m = TIMEZONE_REGEX.match(tzstring)
+    prefix, hours, minutes = m.groups()
+    hours, minutes = int(hours), int(minutes)
+    if prefix == "-":
+        hours = -hours
+        minutes = -minutes
+    return FixedOffset(hours, minutes, tzstring)
+
+def parse_date(datestring, default_timezone=UTC):
+    """Parses ISO 8601 dates into datetime objects
+    
+    The timezone is parsed from the date string. However it is quite common to
+    have dates without a timezone (not strictly correct). In this case the
+    default timezone specified in default_timezone is used. This is UTC by
+    default.
+    """
+    if not isinstance(datestring, basestring):
+        raise ParseError("Expecting a string %r" % datestring)
+    m = ISO8601_REGEX.match(datestring)
+    if not m:
+        raise ParseError("Unable to parse date string %r" % datestring)
+    groups = m.groupdict()
+    tz = parse_timezone(groups["timezone"], default_timezone=default_timezone)
+    if groups["fraction"] is None:
+        groups["fraction"] = 0
+    else:
+        groups["fraction"] = int(float("0.%s" % groups["fraction"]) * 1e6)
+    return datetime(int(groups["year"]), int(groups["month"]), int(groups["day"]),
+        int(groups["hour"]), int(groups["minute"]), int(groups["second"]),
+        int(groups["fraction"]), tz)
diff --git a/python/subunit/test_results.py b/python/subunit/test_results.py
new file mode 100644
index 0000000..0a87ba6
--- /dev/null
+++ b/python/subunit/test_results.py
@@ -0,0 +1,143 @@
+#
+#  subunit: extensions to Python unittest to get test results from subprocesses.
+#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+
+"""TestResult helper classes used to by subunit."""
+
+import datetime
+
+import iso8601
+
+class HookedTestResultDecorator(object):
+    """A TestResult which calls a hook on every event."""
+
+    def __init__(self, decorated):
+        self.decorated = decorated
+
+    def _call_maybe(self, method_name, *params):
+        """Call method_name on self.decorated, if present.
+        
+        This is used to guard newer methods which older pythons do not
+        support. While newer clients won't call these methods if they don't
+        exist, they do exist on the decorator, and thus the decorator has to be
+        the one to filter them out.
+
+        :param method_name: The name of the method to call.
+        :param *params: Parameters to pass to method_name.
+        :return: The result of self.decorated.method_name(*params), if it
+            exists, and None otherwise.
+        """
+        method = getattr(self.decorated, method_name, None)
+        if method is None:
+            return
+        return method(*params)
+
+    def startTest(self, test):
+        self._before_event()
+        return self.decorated.startTest(test)
+
+    def startTestRun(self):
+        self._before_event()
+        return self._call_maybe("startTestRun")
+
+    def stopTest(self, test):
+        self._before_event()
+        return self.decorated.stopTest(test)
+
+    def stopTestRun(self):
+        self._before_event()
+        return self._call_maybe("stopTestRun")
+
+    def addError(self, test, err):
+        self._before_event()
+        return self.decorated.addError(test, err)
+
+    def addFailure(self, test, err):
+        self._before_event()
+        return self.decorated.addFailure(test, err)
+
+    def addSuccess(self, test):
+        self._before_event()
+        return self.decorated.addSuccess(test)
+
+    def addSkip(self, test, reason):
+        self._before_event()
+        return self._call_maybe("addSkip", test, reason)
+
+    def addExpectedFailure(self, test, err):
+        self._before_event()
+        return self._call_maybe("addExpectedFailure", test, err)
+
+    def addUnexpectedSuccess(self, test):
+        self._before_event()
+        return self._call_maybe("addUnexpectedSuccess", test)
+
+    def wasSuccessful(self):
+        self._before_event()
+        return self.decorated.wasSuccessful()
+
+    @property
+    def shouldStop(self):
+        self._before_event()
+        return self.decorated.shouldStop
+
+    def stop(self):
+        self._before_event()
+        return self.decorated.stop()
+
+    def time(self, a_datetime):
+        self._before_event()
+        return self._call_maybe("time", a_datetime)
+
+
+class AutoTimingTestResultDecorator(HookedTestResultDecorator):
+    """Decorate a TestResult to add time events to a test run.
+
+    By default this will cause a time event before every test event,
+    but if explicit time data is being provided by the test run, then
+    this decorator will turn itself off to prevent causing confusion.
+    """
+
+    def __init__(self, decorated):
+        self._time = None
+        super(AutoTimingTestResultDecorator, self).__init__(decorated)
+
+    def _before_event(self):
+        time = self._time
+        if time is not None:
+            return
+        time = datetime.datetime.utcnow().replace(tzinfo=iso8601.Utc())
+        self._call_maybe("time", time)
+
+    @property
+    def shouldStop(self):
+        return self.decorated.shouldStop
+
+    def time(self, a_datetime):
+        """Provide a timestamp for the current test activity.
+
+        :param a_datetime: If None, automatically add timestamps before every
+            event (this is the default behaviour if time() is not called at
+            all).  If not None, pass the provided time onto the decorated
+            result object and disable automatic timestamps.
+        """
+        self._time = a_datetime
+        return self._call_maybe("time", a_datetime)
+
+    def done(self):
+        """Transition function until stopTestRun is used."""
diff --git a/python/subunit/tests/__init__.py b/python/subunit/tests/__init__.py
index fa41930..11f3095 100644
--- a/python/subunit/tests/__init__.py
+++ b/python/subunit/tests/__init__.py
@@ -24,10 +24,12 @@ from subunit.tests import (
     test_subunit_tags,
     test_tap2subunit,
     test_test_protocol,
+    test_test_results,
     )
 
 def test_suite():
     result = TestUtil.TestSuite()
+    result.addTest(test_test_results.test_suite())
     result.addTest(test_test_protocol.test_suite())
     result.addTest(test_tap2subunit.test_suite())
     result.addTest(test_subunit_filter.test_suite())
diff --git a/python/subunit/tests/test_test_protocol.py b/python/subunit/tests/test_test_protocol.py
index ead0ac6..8124042 100644
--- a/python/subunit/tests/test_test_protocol.py
+++ b/python/subunit/tests/test_test_protocol.py
@@ -17,46 +17,49 @@
 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #
 
+import datetime
 import unittest
 from StringIO import StringIO
 import os
 import subunit
 import sys
-import time
 
-try:
-    class MockTestProtocolServerClient(object):
-        """A mock protocol server client to test callbacks."""
+import subunit.iso8601 as iso8601
 
-        def __init__(self):
-            self.end_calls = []
-            self.error_calls = []
-            self.failure_calls = []
-            self.skip_calls = []
-            self.start_calls = []
-            self.success_calls = []
-            super(MockTestProtocolServerClient, self).__init__()
 
-        def addError(self, test, error):
-            self.error_calls.append((test, error))
+class MockTestProtocolServerClient(object):
+    """A mock protocol server client to test callbacks."""
 
-        def addFailure(self, test, error):
-            self.failure_calls.append((test, error))
+    def __init__(self):
+        self.end_calls = []
+        self.error_calls = []
+        self.failure_calls = []
+        self.skip_calls = []
+        self.start_calls = []
+        self.success_calls = []
+        self._time = None
+        super(MockTestProtocolServerClient, self).__init__()
 
-        def addSkip(self, test, reason):
-            self.skip_calls.append((test, reason))
+    def addError(self, test, error):
+        self.error_calls.append((test, error))
 
-        def addSuccess(self, test):
-            self.success_calls.append(test)
+    def addFailure(self, test, error):
+        self.failure_calls.append((test, error))
 
-        def stopTest(self, test):
-            self.end_calls.append(test)
+    def addSkip(self, test, reason):
+        self.skip_calls.append((test, reason))
 
-        def startTest(self, test):
-            self.start_calls.append(test)
+    def addSuccess(self, test):
+        self.success_calls.append(test)
 
-except AttributeError:
-    MockTestProtocolServer = None
+    def stopTest(self, test):
+        self.end_calls.append(test)
+
+    def startTest(self, test):
+        self.start_calls.append(test)
+
+    def time(self, time):
+        self._time = time
 
 
 class TestMockTestProtocolServer(unittest.TestCase):
@@ -763,15 +766,23 @@ class TestTestProtocolServerStreamTags(unittest.TestCase):
 class TestTestProtocolServerStreamTime(unittest.TestCase):
     """Test managing time information at the protocol level."""
 
-    def setUp(self):
-        self.client = MockTestProtocolServerClient()
+    def test_time_accepted_stdlib(self):
+        self.result = unittest.TestResult()
         self.stream = StringIO()
-        self.protocol = subunit.TestProtocolServer(self.client,
+        self.protocol = subunit.TestProtocolServer(self.result,
             stream=self.stream)
+        self.protocol.lineReceived("time: 2001-12-12 12:59:59Z\n")
+        self.assertEqual("", self.stream.getvalue())
 
-    def test_time_accepted(self):
+    def test_time_accepted_extended(self):
+        self.result = MockTestProtocolServerClient()
+        self.stream = StringIO()
+        self.protocol = subunit.TestProtocolServer(self.result,
+            stream=self.stream)
         self.protocol.lineReceived("time: 2001-12-12 12:59:59Z\n")
         self.assertEqual("", self.stream.getvalue())
+        self.assertEqual(datetime.datetime(2001, 12, 12, 12, 59, 59, 0,
+            iso8601.Utc()), self.result._time)
 
 
 class TestRemotedTestCase(unittest.TestCase):
@@ -958,7 +969,7 @@ class TestTestProtocolClient(unittest.TestCase):
         self.assertEqual(self.io.getvalue(), "test: %s\n" % self.test.id())
 
     def test_stop_test(self):
-        """Test stopTest on a TestProtocolClient."""
+        # stopTest doesn't output anything.
         self.protocol.stopTest(self.test)
         self.assertEqual(self.io.getvalue(), "")
 
@@ -994,6 +1005,14 @@ class TestTestProtocolClient(unittest.TestCase):
             self.io.getvalue(),
             'skip: %s [\nHas it really?\n]\n' % self.test.id())
 
+    def test_time(self):
+        # Calling time() outputs a time signal immediately.
+        self.protocol.time(
+            datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc()))
+        self.assertEqual(
+            "time: 2009-10-11 12:13:14.000015Z\n",
+            self.io.getvalue())
+
 
 def test_suite():
     loader = subunit.tests.TestUtil.TestLoader()
diff --git a/python/subunit/tests/test_test_results.py b/python/subunit/tests/test_test_results.py
new file mode 100644
index 0000000..2ba9198
--- /dev/null
+++ b/python/subunit/tests/test_test_results.py
@@ -0,0 +1,171 @@
+#
+#  subunit: extensions to Python unittest to get test results from subprocesses.
+#  Copyright (C) 2009  Robert Collins <robertc@robertcollins.net>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+
+import datetime
+import unittest
+from StringIO import StringIO
+import os
+import subunit.test_results
+import sys
+
+import subunit.iso8601 as iso8601
+
+
+class LoggingDecorator(subunit.test_results.HookedTestResultDecorator):
+
+    def __init__(self, decorated):
+        self._calls = 0
+        super(LoggingDecorator, self).__init__(decorated)
+
+    def _before_event(self):
+        self._calls += 1
+
+
+class AssertBeforeTestResult(LoggingDecorator):
+    """A TestResult for checking preconditions."""
+
+    def __init__(self, decorated, test):
+        self.test = test
+        super(AssertBeforeTestResult, self).__init__(decorated)
+
+    def _before_event(self):
+        self.test.assertEqual(1, self.earlier._calls)
+        super(AssertBeforeTestResult, self)._before_event()
+
+
+class TimeCapturingResult(unittest.TestResult):
+
+    def __init__(self):
+        super(TimeCapturingResult, self).__init__()
+        self._calls = []
+
+    def time(self, a_datetime):
+        self._calls.append(a_datetime)
+
+
+class TestHookedTestResultDecorator(unittest.TestCase):
+
+    def setUp(self):
+        # And end to the chain
+        terminal = unittest.TestResult()
+        # Asserts that the call was made to self.result before asserter was
+        # called.
+        asserter = AssertBeforeTestResult(terminal, self)
+        # The result object we call, which much increase its call count.
+        self.result = LoggingDecorator(asserter)
+        asserter.earlier = self.result
+
+    def tearDown(self):
+        # The hook in self.result must have been called
+        self.assertEqual(1, self.result._calls)
+        # The hook in asserter must have been called too, otherwise the
+        # assertion about ordering won't have completed.
+        self.assertEqual(1, self.result.decorated._calls)
+
+    def test_startTest(self):
+        self.result.startTest(self)
+        
+    def test_startTestRun(self):
+        self.result.startTestRun()
+        
+    def test_stopTest(self):
+        self.result.stopTest(self)
+        
+    def test_stopTestRun(self):
+        self.result.stopTestRun()
+
+    def test_addError(self):
+        self.result.addError(self, subunit.RemoteError())
+        
+    def test_addFailure(self):
+        self.result.addFailure(self, subunit.RemoteError())
+
+    def test_addSuccess(self):
+        self.result.addSuccess(self)
+
+    def test_addSkip(self):
+        self.result.addSkip(self, "foo")
+
+    def test_addExpectedFailure(self):
+        self.result.addExpectedFailure(self, subunit.RemoteError())
+
+    def test_addUnexpectedSuccess(self):
+        self.result.addUnexpectedSuccess(self)
+
+    def test_wasSuccessful(self):
+        self.result.wasSuccessful()
+
+    def test_shouldStop(self):
+        self.result.shouldStop
+
+    def test_stop(self):
+        self.result.stop()
+
+    def test_time(self):
+        self.result.time(None)
+ 
+
+class TestAutoTimingTestResultDecorator(unittest.TestCase):
+
+    def setUp(self):
+        # And end to the chain which captures time events.
+        terminal = TimeCapturingResult()
+        # The result object under test.
+        self.result = subunit.test_results.AutoTimingTestResultDecorator(
+            terminal)
+
+    def test_without_time_calls_time_is_called_and_not_None(self):
+        self.result.startTest(self)
+        self.assertEqual(1, len(self.result.decorated._calls))
+        self.assertNotEqual(None, self.result.decorated._calls[0])
+
+    def test_no_time_from_shouldStop(self):
+        self.result.decorated.stop()
+        self.result.shouldStop
+        self.assertEqual(0, len(self.result.decorated._calls))
+
+    def test_calling_time_inhibits_automatic_time(self):
+        # Calling time() outputs a time signal immediately and prevents
+        # automatically adding one when other methods are called.
+        time = datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc())
+        self.result.time(time)
+        self.result.startTest(self)
+        self.result.stopTest(self)
+        self.assertEqual(1, len(self.result.decorated._calls))
+        self.assertEqual(time, self.result.decorated._calls[0])
+
+    def test_calling_time_None_enables_automatic_time(self):
+        time = datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc())
+        self.result.time(time)
+        self.assertEqual(1, len(self.result.decorated._calls))
+        self.assertEqual(time, self.result.decorated._calls[0])
+        # Calling None passes the None through, in case other results care.
+        self.result.time(None)
+        self.assertEqual(2, len(self.result.decorated._calls))
+        self.assertEqual(None, self.result.decorated._calls[1])
+        # Calling other methods doesn't generate an automatic time event.
+        self.result.startTest(self)
+        self.assertEqual(3, len(self.result.decorated._calls))
+        self.assertNotEqual(None, self.result.decorated._calls[2])
+
+
+def test_suite():
+    loader = subunit.tests.TestUtil.TestLoader()
+    result = loader.loadTestsFromName(__name__)
+    return result