import os
import sys
-import subunit
-from subunit.content import Content, TracebackContent
-from subunit.content_type import ContentType
-import subunit.iso8601 as iso8601
-from subunit.tests.test_test_results import (
- ExtendedTestResult,
+from testtools.content import Content, TracebackContent
+from testtools.content_type import ContentType
+from testtools.tests.helpers import (
Python26TestResult,
Python27TestResult,
+ ExtendedTestResult,
)
+import subunit
+from subunit import _remote_exception_str
+import subunit.iso8601 as iso8601
+
class TestTestImports(unittest.TestCase):
from subunit import ExecTestCase
from subunit import IsolatedTestCase
from subunit import TestProtocolClient
+ from subunit import ProtocolTestCase
class TestDiscardStream(unittest.TestCase):
subunit.DiscardStream().write("content")
+class TestProtocolServerForward(unittest.TestCase):
+
+ def test_story(self):
+ client = unittest.TestResult()
+ out = StringIO()
+ protocol = subunit.TestProtocolServer(client, forward_stream=out)
+ pipe = StringIO("test old mcdonald\n"
+ "success old mcdonald\n")
+ protocol.readFrom(pipe)
+ mcdonald = subunit.RemotedTestCase("old mcdonald")
+ self.assertEqual(client.testsRun, 1)
+ self.assertEqual(pipe.getvalue(), out.getvalue())
+
+ def test_not_command(self):
+ client = unittest.TestResult()
+ out = StringIO()
+ protocol = subunit.TestProtocolServer(client,
+ stream=subunit.DiscardStream(), forward_stream=out)
+ pipe = StringIO("success old mcdonald\n")
+ protocol.readFrom(pipe)
+ self.assertEqual(client.testsRun, 0)
+ self.assertEqual("", out.getvalue())
+
+
class TestTestProtocolServerPipe(unittest.TestCase):
def test_story(self):
bing = subunit.RemotedTestCase("bing crosby")
an_error = subunit.RemotedTestCase("an error")
self.assertEqual(client.errors,
- [(an_error, 'RemoteException: \n\n')])
+ [(an_error, _remote_exception_str + '\n')])
self.assertEqual(
client.failures,
- [(bing, "RemoteException: foo.c:53:ERROR invalid state\n\n")])
+ [(bing, _remote_exception_str + ": Text attachment: traceback\n"
+ "------------\nfoo.c:53:ERROR invalid state\n"
+ "------------\n\n")])
self.assertEqual(client.testsRun, 3)
+ def test_non_test_characters_forwarded_immediately(self):
+ pass
+
class TestTestProtocolServerStartTest(unittest.TestCase):
def test_start_test(self):
self.protocol.lineReceived("test old mcdonald\n")
- self.assertEqual(self.client._calls,
+ self.assertEqual(self.client._events,
[('startTest', subunit.RemotedTestCase("old mcdonald"))])
def test_start_testing(self):
self.protocol.lineReceived("testing old mcdonald\n")
- self.assertEqual(self.client._calls,
+ self.assertEqual(self.client._events,
[('startTest', subunit.RemotedTestCase("old mcdonald"))])
def test_start_test_colon(self):
self.protocol.lineReceived("test: old mcdonald\n")
- self.assertEqual(self.client._calls,
+ self.assertEqual(self.client._events,
[('startTest', subunit.RemotedTestCase("old mcdonald"))])
+ def test_indented_test_colon_ignored(self):
+ self.protocol.lineReceived(" test: old mcdonald\n")
+ self.assertEqual([], self.client._events)
+
def test_start_testing_colon(self):
self.protocol.lineReceived("testing: old mcdonald\n")
- self.assertEqual(self.client._calls,
+ self.assertEqual(self.client._events,
[('startTest', subunit.RemotedTestCase("old mcdonald"))])
def setUp(self):
self.stdout = StringIO()
self.test = subunit.RemotedTestCase("old mcdonald")
- self.client = Python26TestResult()
+ self.client = ExtendedTestResult()
self.protocol = subunit.TestProtocolServer(self.client, self.stdout)
def keywords_before_test(self):
def test_keywords_before_test(self):
self.keywords_before_test()
- self.assertEqual(self.client._calls, [])
+ self.assertEqual(self.client._events, [])
def test_keywords_after_error(self):
self.protocol.lineReceived("test old mcdonald\n")
self.keywords_before_test()
self.assertEqual([
('startTest', self.test),
- ('addError', self.test, subunit.RemoteError("")),
+ ('addError', self.test, {}),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_keywords_after_failure(self):
self.protocol.lineReceived("test old mcdonald\n")
self.protocol.lineReceived("failure old mcdonald\n")
self.keywords_before_test()
- self.assertEqual(self.client._calls, [
+ self.assertEqual(self.client._events, [
('startTest', self.test),
- ('addFailure', self.test, subunit.RemoteError("")),
+ ('addFailure', self.test, {}),
('stopTest', self.test),
])
('startTest', self.test),
('addSuccess', self.test),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_keywords_after_test(self):
self.protocol.lineReceived("test old mcdonald\n")
"successful a\n"
"successful: a\n"
"]\n")
- self.assertEqual(self.client._calls, [
+ self.assertEqual(self.client._events, [
('startTest', self.test),
- ('addFailure', self.test, subunit.RemoteError("")),
+ ('addFailure', self.test, {}),
('stopTest', self.test),
])
def test_keywords_during_failure(self):
+ # A smoke test to make sure that the details parsers have control
+ # appropriately.
self.protocol.lineReceived("test old mcdonald\n")
self.protocol.lineReceived("failure: old mcdonald [\n")
self.protocol.lineReceived("test old mcdonald\n")
self.protocol.lineReceived(" ]\n")
self.protocol.lineReceived("]\n")
self.assertEqual(self.stdout.getvalue(), "")
- failure = subunit.RemoteError("test old mcdonald\n"
+ details = {}
+ details['traceback'] = Content(ContentType("text", "x-traceback",
+ {'charset': 'utf8'}),
+ lambda:[
+ "test old mcdonald\n"
"failure a\n"
"failure: a\n"
"error a\n"
"success: a\n"
"successful a\n"
"successful: a\n"
- "]\n")
- self.assertEqual(self.client._calls, [
+ "]\n"])
+ self.assertEqual(self.client._events, [
('startTest', self.test),
- ('addFailure', self.test, failure),
+ ('addFailure', self.test, details),
('stopTest', self.test),
])
def test_lost_connection_no_input(self):
self.protocol.lostConnection()
- self.assertEqual([], self.client._calls)
+ self.assertEqual([], self.client._events)
def test_lost_connection_after_start(self):
self.protocol.lineReceived("test old mcdonald\n")
self.protocol.lostConnection()
failure = subunit.RemoteError(
- "lost connection during test 'old mcdonald'")
+ u"lost connection during test 'old mcdonald'")
self.assertEqual([
('startTest', self.test),
('addError', self.test, failure),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_lost_connected_after_error(self):
self.protocol.lineReceived("test old mcdonald\n")
self.protocol.lostConnection()
self.assertEqual([
('startTest', self.test),
- ('addError', self.test, subunit.RemoteError("")),
+ ('addError', self.test, subunit.RemoteError(u"")),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def do_connection_lost(self, outcome, opening):
self.protocol.lineReceived("test old mcdonald\n")
self.protocol.lineReceived("%s old mcdonald %s" % (outcome, opening))
self.protocol.lostConnection()
failure = subunit.RemoteError(
- "lost connection during %s report of test 'old mcdonald'" %
+ u"lost connection during %s report of test 'old mcdonald'" %
outcome)
self.assertEqual([
('startTest', self.test),
('addError', self.test, failure),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_lost_connection_during_error(self):
self.do_connection_lost("error", "[\n")
self.protocol.lostConnection()
self.assertEqual([
('startTest', self.test),
- ('addFailure', self.test, subunit.RemoteError("")),
+ ('addFailure', self.test, subunit.RemoteError(u"")),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_lost_connection_during_failure(self):
self.do_connection_lost("failure", "[\n")
('startTest', self.test),
('addSuccess', self.test),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_lost_connection_during_success(self):
self.do_connection_lost("success", "[\n")
('startTest', self.test),
('addError', self.test, details),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_simple_error(self):
self.simple_error_keyword("error")
self.protocol.lineReceived("error mcdonalds farm [\n")
self.protocol.lineReceived("]\n")
details = {}
- details['traceback'] = Content(ContentType("text", "x-traceback"),
- lambda:[""])
+ details['traceback'] = Content(ContentType("text", "x-traceback",
+ {'charset': 'utf8'}), lambda:[""])
self.assertEqual([
('startTest', self.test),
('addError', self.test, details),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def error_quoted_bracket(self, keyword):
self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
self.protocol.lineReceived(" ]\n")
self.protocol.lineReceived("]\n")
details = {}
- details['traceback'] = Content(ContentType("text", "x-traceback"),
- lambda:["]\n"])
+ details['traceback'] = Content(ContentType("text", "x-traceback",
+ {'charset': 'utf8'}), lambda:["]\n"])
self.assertEqual([
('startTest', self.test),
('addError', self.test, details),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_error_quoted_bracket(self):
self.error_quoted_bracket("error")
class TestTestProtocolServerAddFailure(unittest.TestCase):
def setUp(self):
- self.client = Python26TestResult()
+ self.client = ExtendedTestResult()
self.protocol = subunit.TestProtocolServer(self.client)
self.protocol.lineReceived("test mcdonalds farm\n")
self.test = subunit.RemotedTestCase("mcdonalds farm")
- def simple_failure_keyword(self, keyword):
- self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
- failure = subunit.RemoteError("")
+ def assertFailure(self, details):
self.assertEqual([
('startTest', self.test),
- ('addFailure', self.test, failure),
+ ('addFailure', self.test, details),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
+
+ def simple_failure_keyword(self, keyword):
+ self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+ details = {}
+ self.assertFailure(details)
def test_simple_failure(self):
self.simple_failure_keyword("failure")
def test_failure_empty_message(self):
self.protocol.lineReceived("failure mcdonalds farm [\n")
self.protocol.lineReceived("]\n")
- failure = subunit.RemoteError("")
- self.assertEqual([
- ('startTest', self.test),
- ('addFailure', self.test, failure),
- ('stopTest', self.test),
- ], self.client._calls)
+ details = {}
+ details['traceback'] = Content(ContentType("text", "x-traceback",
+ {'charset': 'utf8'}), lambda:[""])
+ self.assertFailure(details)
def failure_quoted_bracket(self, keyword):
self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
self.protocol.lineReceived(" ]\n")
self.protocol.lineReceived("]\n")
- failure = subunit.RemoteError("]\n")
- self.assertEqual([
- ('startTest', self.test),
- ('addFailure', self.test, failure),
- ('stopTest', self.test),
- ], self.client._calls)
+ details = {}
+ details['traceback'] = Content(ContentType("text", "x-traceback",
+ {'charset': 'utf8'}), lambda:["]\n"])
+ self.assertFailure(details)
def test_failure_quoted_bracket(self):
self.failure_quoted_bracket("failure")
"""
def capture_expected_failure(self, test, err):
- self._calls.append((test, err))
+ self._events.append((test, err))
def setup_python26(self):
"""Setup a test object ready to be xfailed and thunk to success."""
self.setup_protocol()
def setup_python27(self):
- """Setup a test object ready to be xfailed and thunk to success."""
+ """Setup a test object ready to be xfailed."""
self.client = Python27TestResult()
self.setup_protocol()
+ def setup_python_ex(self):
+ """Setup a test object ready to be xfailed with details."""
+ self.client = ExtendedTestResult()
+ self.setup_protocol()
+
def setup_protocol(self):
"""Setup the protocol based on self.client."""
self.protocol = subunit.TestProtocolServer(self.client)
self.protocol.lineReceived("test mcdonalds farm\n")
- self.test = self.client._calls[-1][-1]
+ self.test = self.client._events[-1][-1]
def simple_xfail_keyword(self, keyword, as_success):
self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
self.check_success_or_xfail(as_success)
- def check_success_or_xfail(self, as_success, error_message=""):
+ def check_success_or_xfail(self, as_success, error_message=None):
if as_success:
self.assertEqual([
('startTest', self.test),
('addSuccess', self.test),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
else:
- error = subunit.RemoteError(error_message)
+ details = {}
+ if error_message is not None:
+ details['traceback'] = Content(
+ ContentType("text", "x-traceback", {'charset': 'utf8'}),
+ lambda:[error_message])
+ if isinstance(self.client, ExtendedTestResult):
+ value = details
+ else:
+ if error_message is not None:
+ value = subunit.RemoteError(u'Text attachment: traceback\n'
+ '------------\n' + error_message + '------------\n')
+ else:
+ value = subunit.RemoteError()
self.assertEqual([
('startTest', self.test),
- ('addExpectedFailure', self.test, error),
+ ('addExpectedFailure', self.test, value),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_simple_xfail(self):
self.setup_python26()
self.simple_xfail_keyword("xfail", True)
self.setup_python27()
self.simple_xfail_keyword("xfail", False)
+ self.setup_python_ex()
+ self.simple_xfail_keyword("xfail", False)
def test_simple_xfail_colon(self):
self.setup_python26()
self.simple_xfail_keyword("xfail:", True)
self.setup_python27()
self.simple_xfail_keyword("xfail:", False)
+ self.setup_python_ex()
+ self.simple_xfail_keyword("xfail:", False)
def test_xfail_empty_message(self):
self.setup_python26()
self.empty_message(True)
self.setup_python27()
self.empty_message(False)
+ self.setup_python_ex()
+ self.empty_message(False, error_message="")
- def empty_message(self, as_success):
+ def empty_message(self, as_success, error_message="\n"):
self.protocol.lineReceived("xfail mcdonalds farm [\n")
self.protocol.lineReceived("]\n")
- self.check_success_or_xfail(as_success)
+ self.check_success_or_xfail(as_success, error_message)
def xfail_quoted_bracket(self, keyword, as_success):
# This tests it is accepted, but cannot test it is used today, because
self.xfail_quoted_bracket("xfail", True)
self.setup_python27()
self.xfail_quoted_bracket("xfail", False)
+ self.setup_python_ex()
+ self.xfail_quoted_bracket("xfail", False)
def test_xfail_colon_quoted_bracket(self):
self.setup_python26()
self.xfail_quoted_bracket("xfail:", True)
self.setup_python27()
self.xfail_quoted_bracket("xfail:", False)
+ self.setup_python_ex()
+ self.xfail_quoted_bracket("xfail:", False)
class TestTestProtocolServerAddSkip(unittest.TestCase):
def setUp(self):
"""Setup a test object ready to be skipped."""
- self.client = Python27TestResult()
+ self.client = ExtendedTestResult()
self.protocol = subunit.TestProtocolServer(self.client)
self.protocol.lineReceived("test mcdonalds farm\n")
- self.test = self.client._calls[-1][-1]
+ self.test = self.client._events[-1][-1]
- def simple_skip_keyword(self, keyword):
- self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+ def assertSkip(self, reason):
+ details = {}
+ if reason is not None:
+ details['reason'] = Content(
+ ContentType("text", "plain"), lambda:[reason])
self.assertEqual([
('startTest', self.test),
- ('addSkip', self.test, "No reason given"),
+ ('addSkip', self.test, details),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
+
+ def simple_skip_keyword(self, keyword):
+ self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+ self.assertSkip(None)
def test_simple_skip(self):
self.simple_skip_keyword("skip")
def test_skip_empty_message(self):
self.protocol.lineReceived("skip mcdonalds farm [\n")
self.protocol.lineReceived("]\n")
- self.assertEqual([
- ('startTest', self.test),
- ('addSkip', self.test, "No reason given"),
- ('stopTest', self.test),
- ], self.client._calls)
+ self.assertSkip("")
def skip_quoted_bracket(self, keyword):
# This tests it is accepted, but cannot test it is used today, because
self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
self.protocol.lineReceived(" ]\n")
self.protocol.lineReceived("]\n")
- self.assertEqual([
- ('startTest', self.test),
- ('addSkip', self.test, "]\n"),
- ('stopTest', self.test),
- ], self.client._calls)
+ self.assertSkip("]\n")
def test_skip_quoted_bracket(self):
self.skip_quoted_bracket("skip")
class TestTestProtocolServerAddSuccess(unittest.TestCase):
def setUp(self):
- self.client = Python26TestResult()
+ self.client = ExtendedTestResult()
self.protocol = subunit.TestProtocolServer(self.client)
self.protocol.lineReceived("test mcdonalds farm\n")
self.test = subunit.RemotedTestCase("mcdonalds farm")
('startTest', self.test),
('addSuccess', self.test),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
def test_simple_success(self):
self.simple_success_keyword("failure")
def test_simple_success_colon(self):
self.simple_success_keyword("successful:")
- def test_success_empty_message(self):
- self.protocol.lineReceived("success mcdonalds farm [\n")
- self.protocol.lineReceived("]\n")
+ def assertSuccess(self, details):
self.assertEqual([
('startTest', self.test),
- ('addSuccess', self.test),
+ ('addSuccess', self.test, details),
('stopTest', self.test),
- ], self.client._calls)
+ ], self.client._events)
+
+ def test_success_empty_message(self):
+ self.protocol.lineReceived("success mcdonalds farm [\n")
+ self.protocol.lineReceived("]\n")
+ details = {}
+ details['message'] = Content(ContentType("text", "plain"),
+ lambda:[""])
+ self.assertSuccess(details)
def success_quoted_bracket(self, keyword):
# This tests it is accepted, but cannot test it is used today, because
self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
self.protocol.lineReceived(" ]\n")
self.protocol.lineReceived("]\n")
- self.assertEqual([
- ('startTest', self.test),
- ('addSuccess', self.test),
- ('stopTest', self.test),
- ], self.client._calls)
+ details = {}
+ details['message'] = Content(ContentType("text", "plain"),
+ lambda:["]\n"])
+ self.assertSuccess(details)
def test_success_quoted_bracket(self):
self.success_quoted_bracket("success")
('progress', -2, subunit.PROGRESS_CUR),
('progress', None, subunit.PROGRESS_POP),
('progress', 4, subunit.PROGRESS_CUR),
- ], self.result._calls)
+ ], self.result._events)
class TestTestProtocolServerStreamTags(unittest.TestCase):
self.protocol.lineReceived("tags: foo bar:baz quux\n")
self.assertEqual([
('tags', set(["foo", "bar:baz", "quux"]), set()),
- ], self.client._calls)
+ ], self.client._events)
def test_minus_removes_tags(self):
self.protocol.lineReceived("tags: -bar quux\n")
self.assertEqual([
('tags', set(["quux"]), set(["bar"])),
- ], self.client._calls)
+ ], self.client._events)
def test_tags_do_not_get_set_on_test(self):
self.protocol.lineReceived("test mcdonalds farm\n")
- test = self.client._calls[0][-1]
+ test = self.client._events[0][-1]
self.assertEqual(None, getattr(test, 'tags', None))
def test_tags_do_not_get_set_on_global_tags(self):
self.protocol.lineReceived("tags: foo bar\n")
self.protocol.lineReceived("test mcdonalds farm\n")
- test = self.client._calls[-1][-1]
+ test = self.client._events[-1][-1]
self.assertEqual(None, getattr(test, 'tags', None))
def test_tags_get_set_on_test_tags(self):
self.protocol.lineReceived("test mcdonalds farm\n")
- test = self.client._calls[-1][-1]
+ test = self.client._events[-1][-1]
self.protocol.lineReceived("tags: foo bar\n")
self.protocol.lineReceived("success mcdonalds farm\n")
self.assertEqual(None, getattr(test, 'tags', None))
self.assertEqual([
('time', datetime.datetime(2001, 12, 12, 12, 59, 59, 0,
iso8601.Utc()))
- ], self.result._calls)
+ ], self.result._events)
class TestRemotedTestCase(unittest.TestCase):
"'A test description'>", "%r" % test)
result = unittest.TestResult()
test.run(result)
- self.assertEqual([(test, "RemoteException: "
+ self.assertEqual([(test, _remote_exception_str + ": "
"Cannot run RemotedTestCases.\n\n")],
result.errors)
self.assertEqual(1, result.testsRun)
class TestRemoteError(unittest.TestCase):
def test_eq(self):
- error = subunit.RemoteError("Something went wrong")
- another_error = subunit.RemoteError("Something went wrong")
- different_error = subunit.RemoteError("boo!")
+ error = subunit.RemoteError(u"Something went wrong")
+ another_error = subunit.RemoteError(u"Something went wrong")
+ different_error = subunit.RemoteError(u"boo!")
self.assertEqual(error, another_error)
self.assertNotEqual(error, different_error)
self.assertNotEqual(different_error, another_error)
def test_empty_constructor(self):
- self.assertEqual(subunit.RemoteError(), subunit.RemoteError(""))
+ self.assertEqual(subunit.RemoteError(), subunit.RemoteError(u""))
class TestExecTestCase(unittest.TestCase):
self.assertEqual(1, result.testsRun)
def test_run(self):
- result = Python26TestResult()
+ result = ExtendedTestResult()
test = self.SampleExecTestCase("test_sample_method")
test.run(result)
mcdonald = subunit.RemotedTestCase("old mcdonald")
bing = subunit.RemotedTestCase("bing crosby")
+ bing_details = {}
+ bing_details['traceback'] = Content(ContentType("text", "x-traceback",
+ {'charset': 'utf8'}), lambda:["foo.c:53:ERROR invalid state\n"])
an_error = subunit.RemotedTestCase("an error")
- error_error = subunit.RemoteError()
- bing_failure = subunit.RemoteError(
- "foo.c:53:ERROR invalid state\n")
+ error_details = {}
self.assertEqual([
('startTest', mcdonald),
('addSuccess', mcdonald),
('stopTest', mcdonald),
('startTest', bing),
- ('addFailure', bing, bing_failure),
+ ('addFailure', bing, bing_details),
('stopTest', bing),
('startTest', an_error),
- ('addError', an_error, error_error),
+ ('addError', an_error, error_details),
('stopTest', an_error),
- ], result._calls)
+ ], result._events)
def test_debug(self):
test = self.SampleExecTestCase("test_sample_method")
ContentType('text', 'plain'), lambda:['serialised\nform'])}
self.sample_tb_details = dict(self.sample_details)
self.sample_tb_details['traceback'] = TracebackContent(
- subunit.RemoteError("boo qux"))
+ subunit.RemoteError(u"boo qux"), self.test)
def test_start_test(self):
"""Test startTest on a TestProtocolClient."""
def test_add_failure(self):
"""Test addFailure on a TestProtocolClient."""
self.protocol.addFailure(
- self.test, subunit.RemoteError("boo qux"))
+ self.test, subunit.RemoteError(u"boo qux"))
self.assertEqual(
self.io.getvalue(),
- 'failure: %s [\nRemoteException: boo qux\n]\n' % self.test.id())
+ ('failure: %s [\n' + _remote_exception_str + ': boo qux\n]\n')
+ % self.test.id())
def test_add_failure_details(self):
"""Test addFailure on a TestProtocolClient with details."""
self.test, details=self.sample_tb_details)
self.assertEqual(
self.io.getvalue(),
- "failure: %s [ multipart\n"
+ ("failure: %s [ multipart\n"
"Content-Type: text/plain\n"
"something\n"
"F\r\nserialised\nform0\r\n"
- "Content-Type: text/x-traceback;language=python\n"
+ "Content-Type: text/x-traceback;charset=utf8,language=python\n"
"traceback\n"
- "19\r\nRemoteException: boo qux\n0\r\n"
- "]\n" % self.test.id())
+ "1A\r\n" + _remote_exception_str + ": boo qux\n0\r\n"
+ "]\n") % self.test.id())
def test_add_error(self):
"""Test stopTest on a TestProtocolClient."""
self.protocol.addError(
- self.test, subunit.RemoteError("phwoar crikey"))
+ self.test, subunit.RemoteError(u"phwoar crikey"))
self.assertEqual(
self.io.getvalue(),
- 'error: %s [\n'
- "RemoteException: phwoar crikey\n"
- "]\n" % self.test.id())
+ ('error: %s [\n' +
+ _remote_exception_str + ": phwoar crikey\n"
+ "]\n") % self.test.id())
def test_add_error_details(self):
"""Test stopTest on a TestProtocolClient with details."""
self.test, details=self.sample_tb_details)
self.assertEqual(
self.io.getvalue(),
- "error: %s [ multipart\n"
+ ("error: %s [ multipart\n"
"Content-Type: text/plain\n"
"something\n"
"F\r\nserialised\nform0\r\n"
- "Content-Type: text/x-traceback;language=python\n"
+ "Content-Type: text/x-traceback;charset=utf8,language=python\n"
"traceback\n"
- "19\r\nRemoteException: boo qux\n0\r\n"
- "]\n" % self.test.id())
+ "1A\r\n" + _remote_exception_str + ": boo qux\n0\r\n"
+ "]\n") % self.test.id())
def test_add_expected_failure(self):
"""Test addExpectedFailure on a TestProtocolClient."""
self.protocol.addExpectedFailure(
- self.test, subunit.RemoteError("phwoar crikey"))
+ self.test, subunit.RemoteError(u"phwoar crikey"))
self.assertEqual(
self.io.getvalue(),
- 'xfail: %s [\n'
- "RemoteException: phwoar crikey\n"
- "]\n" % self.test.id())
+ ('xfail: %s [\n' +
+ _remote_exception_str + ": phwoar crikey\n"
+ "]\n") % self.test.id())
def test_add_expected_failure_details(self):
"""Test addExpectedFailure on a TestProtocolClient with details."""
self.test, details=self.sample_tb_details)
self.assertEqual(
self.io.getvalue(),
- "xfail: %s [ multipart\n"
+ ("xfail: %s [ multipart\n"
"Content-Type: text/plain\n"
"something\n"
"F\r\nserialised\nform0\r\n"
- "Content-Type: text/x-traceback;language=python\n"
+ "Content-Type: text/x-traceback;charset=utf8,language=python\n"
"traceback\n"
- "19\r\nRemoteException: boo qux\n0\r\n"
- "]\n" % self.test.id())
+ "1A\r\n"+ _remote_exception_str + ": boo qux\n0\r\n"
+ "]\n") % self.test.id())
def test_add_skip(self):
"""Test addSkip on a TestProtocolClient."""
git.samba.org / third_party / subunit / blobdiff