diff options
Diffstat (limited to 'python')
| -rw-r--r-- | python/iso8601/LICENSE | 20 | ||||
| -rw-r--r-- | python/iso8601/README | 26 | ||||
| -rw-r--r-- | python/iso8601/README.subunit | 5 | ||||
| -rw-r--r-- | python/iso8601/setup.py | 58 | ||||
| -rw-r--r-- | python/iso8601/test_iso8601.py | 111 | ||||
| -rw-r--r-- | python/subunit/__init__.py | 29 | ||||
| -rw-r--r-- | python/subunit/iso8601.py | 123 | ||||
| -rw-r--r-- | python/subunit/test_results.py | 143 | ||||
| -rw-r--r-- | python/subunit/tests/__init__.py | 2 | ||||
| -rw-r--r-- | python/subunit/tests/test_test_protocol.py | 81 | ||||
| -rw-r--r-- | python/subunit/tests/test_test_results.py | 171 |
11 files changed, 735 insertions, 34 deletions
diff --git a/python/iso8601/LICENSE b/python/iso8601/LICENSE new file mode 100644 index 0000000..5ca93da --- /dev/null +++ b/python/iso8601/LICENSE @@ -0,0 +1,20 @@ +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. diff --git a/python/iso8601/README b/python/iso8601/README new file mode 100644 index 0000000..5ec9d45 --- /dev/null +++ b/python/iso8601/README @@ -0,0 +1,26 @@ +A simple package to deal with ISO 8601 date time formats. + +ISO 8601 defines a neutral, unambiguous date string format, which also +has the property of sorting naturally. + +e.g. YYYY-MM-DDTHH:MM:SSZ or 2007-01-25T12:00:00Z + +Currently this covers only the most common date formats encountered, not +all of ISO 8601 is handled. + +Currently the following formats are handled: + +* 2006-01-01T00:00:00Z +* 2006-01-01T00:00:00[+-]00:00 + +I'll add more as I encounter them in my day to day life. Patches with +new formats and tests will be gratefully accepted of course :) + +References: + +* http://www.cl.cam.ac.uk/~mgk25/iso-time.html - simple overview + +* http://hydracen.com/dx/iso8601.htm - more detailed enumeration of + valid formats. + +See the LICENSE file for the license this package is released under. diff --git a/python/iso8601/README.subunit b/python/iso8601/README.subunit new file mode 100644 index 0000000..d1ed8a1 --- /dev/null +++ b/python/iso8601/README.subunit @@ -0,0 +1,5 @@ +This is a [slightly rearranged] import of http://pypi.python.org/pypi/iso8601/ +version 0.1.4. The OS X hidden files have been stripped, and the package +turned into a single module, to simplify installation. The remainder of the +source distribution is included in the subunit source tree at python/iso8601 +for reference. diff --git a/python/iso8601/setup.py b/python/iso8601/setup.py new file mode 100644 index 0000000..cdb61ec --- /dev/null +++ b/python/iso8601/setup.py @@ -0,0 +1,58 @@ +try: + from setuptools import setup +except ImportError: + from distutils import setup + +long_description="""Simple module to parse ISO 8601 dates + +This module parses the most common forms of ISO 8601 date strings (e.g. +2007-01-14T20:34:22+00:00) into datetime objects. + +>>> import iso8601 +>>> iso8601.parse_date("2007-01-25T12:00:00Z") +datetime.datetime(2007, 1, 25, 12, 0, tzinfo=<iso8601.iso8601.Utc ...>) +>>> + +Changes +======= + +0.1.4 +----- + +* The default_timezone argument wasn't being passed through correctly, + UTC was being used in every case. Fixes issue 10. + +0.1.3 +----- + +* Fixed the microsecond handling, the generated microsecond values were + way too small. Fixes issue 9. + +0.1.2 +----- + +* Adding ParseError to __all__ in iso8601 module, allows people to import it. + Addresses issue 7. +* Be a little more flexible when dealing with dates without leading zeroes. + This violates the spec a little, but handles more dates as seen in the + field. Addresses issue 6. +* Allow date/time separators other than T. + +0.1.1 +----- + +* When parsing dates without a timezone the specified default is used. If no + default is specified then UTC is used. Addresses issue 4. +""" + +setup( + name="iso8601", + version="0.1.4", + description=long_description.split("\n")[0], + long_description=long_description, + author="Michael Twomey", + author_email="micktwomey+iso8601@gmail.com", + url="http://code.google.com/p/pyiso8601/", + packages=["iso8601"], + license="MIT", +) diff --git a/python/iso8601/test_iso8601.py b/python/iso8601/test_iso8601.py new file mode 100644 index 0000000..ff9e273 --- /dev/null +++ b/python/iso8601/test_iso8601.py @@ -0,0 +1,111 @@ +import iso8601 + +def test_iso8601_regex(): + assert iso8601.ISO8601_REGEX.match("2006-10-11T00:14:33Z") + +def test_timezone_regex(): + assert iso8601.TIMEZONE_REGEX.match("+01:00") + assert iso8601.TIMEZONE_REGEX.match("+00:00") + assert iso8601.TIMEZONE_REGEX.match("+01:20") + assert iso8601.TIMEZONE_REGEX.match("-01:00") + +def test_parse_date(): + d = iso8601.parse_date("2006-10-20T15:34:56Z") + assert d.year == 2006 + assert d.month == 10 + assert d.day == 20 + assert d.hour == 15 + assert d.minute == 34 + assert d.second == 56 + assert d.tzinfo == iso8601.UTC + +def test_parse_date_fraction(): + d = iso8601.parse_date("2006-10-20T15:34:56.123Z") + assert d.year == 2006 + assert d.month == 10 + assert d.day == 20 + assert d.hour == 15 + assert d.minute == 34 + assert d.second == 56 + assert d.microsecond == 123000 + assert d.tzinfo == iso8601.UTC + +def test_parse_date_fraction_2(): + """From bug 6 + + """ + d = iso8601.parse_date("2007-5-7T11:43:55.328Z'") + assert d.year == 2007 + assert d.month == 5 + assert d.day == 7 + assert d.hour == 11 + assert d.minute == 43 + assert d.second == 55 + assert d.microsecond == 328000 + assert d.tzinfo == iso8601.UTC + +def test_parse_date_tz(): + d = iso8601.parse_date("2006-10-20T15:34:56.123+02:30") + assert d.year == 2006 + assert d.month == 10 + assert d.day == 20 + assert d.hour == 15 + assert d.minute == 34 + assert d.second == 56 + assert d.microsecond == 123000 + assert d.tzinfo.tzname(None) == "+02:30" + offset = d.tzinfo.utcoffset(None) + assert offset.days == 0 + assert offset.seconds == 60 * 60 * 2.5 + +def test_parse_invalid_date(): + try: + iso8601.parse_date(None) + except iso8601.ParseError: + pass + else: + assert 1 == 2 + +def test_parse_invalid_date2(): + try: + iso8601.parse_date("23") + except iso8601.ParseError: + pass + else: + assert 1 == 2 + +def test_parse_no_timezone(): + """issue 4 - Handle datetime string without timezone + + This tests what happens when you parse a date with no timezone. While not + strictly correct this is quite common. I'll assume UTC for the time zone + in this case. + """ + d = iso8601.parse_date("2007-01-01T08:00:00") + assert d.year == 2007 + assert d.month == 1 + assert d.day == 1 + assert d.hour == 8 + assert d.minute == 0 + assert d.second == 0 + assert d.microsecond == 0 + assert d.tzinfo == iso8601.UTC + +def test_parse_no_timezone_different_default(): + tz = iso8601.FixedOffset(2, 0, "test offset") + d = iso8601.parse_date("2007-01-01T08:00:00", default_timezone=tz) + assert d.tzinfo == tz + +def test_space_separator(): + """Handle a separator other than T + + """ + d = iso8601.parse_date("2007-06-23 06:40:34.00Z") + assert d.year == 2007 + assert d.month == 6 + assert d.day == 23 + assert d.hour == 6 + assert d.minute == 40 + assert d.second == 34 + assert d.microsecond == 0 + assert d.tzinfo == iso8601.UTC 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 |