git.samba.org - third_party/subunit/blob - python/subunit/tests/test_test_protocol.py

   1 #
   2 #  subunit: extensions to python unittest to get test results from subprocesses.
   3 #  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
   4 #
   5 #  This program is free software; you can redistribute it and/or modify
   6 #  it under the terms of the GNU General Public License as published by
   7 #  the Free Software Foundation; either version 2 of the License, or
   8 #  (at your option) any later version.
   9 #
  10 #  This program is distributed in the hope that it will be useful,
  11 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #  GNU General Public License for more details.
  14 #
  15 #  You should have received a copy of the GNU General Public License
  16 #  along with this program; if not, write to the Free Software
  17 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18 #
  19
  20 import unittest
  21 from StringIO import StringIO
  22 import subunit
  23 import sys
  24 from subunit.tests.TestUtil import mockFile
  25
  26 try:
  27     class MockTestProtocolServerClient(object):
  28         """A mock protocol server client to test callbacks."""
  29
  30         def __init__(self):
  31             self.end_calls = []
  32             self.error_calls = []
  33             self.failure_calls = []
  34             self.start_calls = []
  35             self.success_calls = []
  36             super(MockTestProtocolServerClient, self).__init__()
  37
  38         def addError(self, test, error):
  39             self.error_calls.append((test, error))
  40
  41         def addFailure(self, test, error):
  42             self.failure_calls.append((test, error))
  43
  44         def addSuccess(self, test):
  45             self.success_calls.append(test)
  46
  47         def stopTest(self, test):
  48             self.end_calls.append(test)
  49
  50         def startTest(self, test):
  51             self.start_calls.append(test)
  52
  53 except AttributeError:
  54     MockTestProtocolServer = None
  55
  56
  57 class TestMockTestProtocolServer(unittest.TestCase):
  58
  59     def test_start_test(self):
  60         protocol = MockTestProtocolServerClient()
  61         protocol.startTest(subunit.RemotedTestCase("test old mcdonald"))
  62         self.assertEqual(protocol.start_calls,
  63                          [subunit.RemotedTestCase("test old mcdonald")])
  64         self.assertEqual(protocol.end_calls, [])
  65         self.assertEqual(protocol.error_calls, [])
  66         self.assertEqual(protocol.failure_calls, [])
  67         self.assertEqual(protocol.success_calls, [])
  68
  69     def test_add_error(self):
  70         protocol = MockTestProtocolServerClient()
  71         protocol.addError(subunit.RemotedTestCase("old mcdonald"),
  72                           subunit.RemoteError("omg it works"))
  73         self.assertEqual(protocol.start_calls, [])
  74         self.assertEqual(protocol.end_calls, [])
  75         self.assertEqual(protocol.error_calls, [(
  76                             subunit.RemotedTestCase("old mcdonald"),
  77                             subunit.RemoteError("omg it works"))])
  78         self.assertEqual(protocol.failure_calls, [])
  79         self.assertEqual(protocol.success_calls, [])
  80
  81     def test_add_failure(self):
  82         protocol = MockTestProtocolServerClient()
  83         protocol.addFailure(subunit.RemotedTestCase("old mcdonald"),
  84                             subunit.RemoteError("omg it works"))
  85         self.assertEqual(protocol.start_calls, [])
  86         self.assertEqual(protocol.end_calls, [])
  87         self.assertEqual(protocol.error_calls, [])
  88         self.assertEqual(protocol.failure_calls, [
  89                             (subunit.RemotedTestCase("old mcdonald"),
  90                              subunit.RemoteError("omg it works"))])
  91         self.assertEqual(protocol.success_calls, [])
  92
  93     def test_add_success(self):
  94         protocol = MockTestProtocolServerClient()
  95         protocol.addSuccess(subunit.RemotedTestCase("test old mcdonald"))
  96         self.assertEqual(protocol.start_calls, [])
  97         self.assertEqual(protocol.end_calls, [])
  98         self.assertEqual(protocol.error_calls, [])
  99         self.assertEqual(protocol.failure_calls, [])
 100         self.assertEqual(protocol.success_calls,
 101                          [subunit.RemotedTestCase("test old mcdonald")])
 102
 103     def test_end_test(self):
 104         protocol = MockTestProtocolServerClient()
 105         protocol.stopTest(subunit.RemotedTestCase("test old mcdonald"))
 106         self.assertEqual(protocol.end_calls,
 107                          [subunit.RemotedTestCase("test old mcdonald")])
 108         self.assertEqual(protocol.error_calls, [])
 109         self.assertEqual(protocol.failure_calls, [])
 110         self.assertEqual(protocol.success_calls, [])
 111         self.assertEqual(protocol.start_calls, [])
 112
 113 class TestTestImports(unittest.TestCase):
 114
 115     def test_imports(self):
 116         from subunit import TestProtocolServer
 117         from subunit import RemotedTestCase
 118         from subunit import RemoteError
 119         from subunit import ExecTestCase
 120         from subunit import IsolatedTestCase
 121         from subunit import TestProtocolClient
 122
 123
 124 class TestTestProtocolServerPipe(unittest.TestCase):
 125
 126     def test_story(self):
 127         client = unittest.TestResult()
 128         protocol = subunit.TestProtocolServer(client)
 129         pipe = StringIO("test old mcdonald\n"
 130                         "success old mcdonald\n"
 131                         "test bing crosby\n"
 132                         "failure bing crosby [\n"
 133                         "foo.c:53:ERROR invalid state\n"
 134                         "]\n"
 135                         "test an error\n"
 136                         "error an error\n")
 137         protocol.readFrom(pipe)
 138         mcdonald = subunit.RemotedTestCase("old mcdonald")
 139         bing = subunit.RemotedTestCase("bing crosby")
 140         an_error = subunit.RemotedTestCase("an error")
 141         self.assertEqual(client.errors,
 142                          [(an_error, 'RemoteException: \n\n')])
 143         self.assertEqual(
 144             client.failures,
 145             [(bing, "RemoteException: foo.c:53:ERROR invalid state\n\n")])
 146         self.assertEqual(client.testsRun, 3)
 147
 148
 149 class TestTestProtocolServerStartTest(unittest.TestCase):
 150
 151     def setUp(self):
 152         self.client = MockTestProtocolServerClient()
 153         self.protocol = subunit.TestProtocolServer(self.client)
 154
 155     def test_start_test(self):
 156         self.protocol.lineReceived("test old mcdonald\n")
 157         self.assertEqual(self.client.start_calls,
 158                          [subunit.RemotedTestCase("old mcdonald")])
 159
 160     def test_start_testing(self):
 161         self.protocol.lineReceived("testing old mcdonald\n")
 162         self.assertEqual(self.client.start_calls,
 163                          [subunit.RemotedTestCase("old mcdonald")])
 164
 165     def test_start_test_colon(self):
 166         self.protocol.lineReceived("test: old mcdonald\n")
 167         self.assertEqual(self.client.start_calls,
 168                          [subunit.RemotedTestCase("old mcdonald")])
 169
 170     def test_start_testing_colon(self):
 171         self.protocol.lineReceived("testing: old mcdonald\n")
 172         self.assertEqual(self.client.start_calls,
 173                          [subunit.RemotedTestCase("old mcdonald")])
 174
 175
 176 class TestTestProtocolServerPassThrough(unittest.TestCase):
 177
 178     def setUp(self):
 179         from StringIO import StringIO
 180         self.real_stdout = sys.stdout
 181         self.stdout = StringIO()
 182         sys.stdout = self.stdout
 183         self.test = subunit.RemotedTestCase("old mcdonald")
 184         self.client = MockTestProtocolServerClient()
 185         self.protocol = subunit.TestProtocolServer(self.client)
 186
 187     def tearDown(self):
 188         sys.stdout = self.real_stdout
 189
 190     def keywords_before_test(self):
 191         self.protocol.lineReceived("failure a\n")
 192         self.protocol.lineReceived("failure: a\n")
 193         self.protocol.lineReceived("error a\n")
 194         self.protocol.lineReceived("error: a\n")
 195         self.protocol.lineReceived("success a\n")
 196         self.protocol.lineReceived("success: a\n")
 197         self.protocol.lineReceived("successful a\n")
 198         self.protocol.lineReceived("successful: a\n")
 199         self.protocol.lineReceived("]\n")
 200         self.assertEqual(self.stdout.getvalue(), "failure a\n"
 201                                                  "failure: a\n"
 202                                                  "error a\n"
 203                                                  "error: a\n"
 204                                                  "success a\n"
 205                                                  "success: a\n"
 206                                                  "successful a\n"
 207                                                  "successful: a\n"
 208                                                  "]\n")
 209
 210     def test_keywords_before_test(self):
 211         self.keywords_before_test()
 212         self.assertEqual(self.client.start_calls, [])
 213         self.assertEqual(self.client.error_calls, [])
 214         self.assertEqual(self.client.failure_calls, [])
 215         self.assertEqual(self.client.success_calls, [])
 216
 217     def test_keywords_after_error(self):
 218         self.protocol.lineReceived("test old mcdonald\n")
 219         self.protocol.lineReceived("error old mcdonald\n")
 220         self.keywords_before_test()
 221         self.assertEqual(self.client.start_calls, [self.test])
 222         self.assertEqual(self.client.end_calls, [self.test])
 223         self.assertEqual(self.client.error_calls,
 224                          [(self.test, subunit.RemoteError(""))])
 225         self.assertEqual(self.client.failure_calls, [])
 226         self.assertEqual(self.client.success_calls, [])
 227
 228     def test_keywords_after_failure(self):
 229         self.protocol.lineReceived("test old mcdonald\n")
 230         self.protocol.lineReceived("failure old mcdonald\n")
 231         self.keywords_before_test()
 232         self.assertEqual(self.client.start_calls, [self.test])
 233         self.assertEqual(self.client.end_calls, [self.test])
 234         self.assertEqual(self.client.error_calls, [])
 235         self.assertEqual(self.client.failure_calls,
 236                          [(self.test, subunit.RemoteError())])
 237         self.assertEqual(self.client.success_calls, [])
 238
 239     def test_keywords_after_success(self):
 240         self.protocol.lineReceived("test old mcdonald\n")
 241         self.protocol.lineReceived("success old mcdonald\n")
 242         self.keywords_before_test()
 243         self.assertEqual(self.client.start_calls, [self.test])
 244         self.assertEqual(self.client.end_calls, [self.test])
 245         self.assertEqual(self.client.error_calls, [])
 246         self.assertEqual(self.client.failure_calls, [])
 247         self.assertEqual(self.client.success_calls, [self.test])
 248
 249     def test_keywords_after_test(self):
 250         self.protocol.lineReceived("test old mcdonald\n")
 251         self.protocol.lineReceived("test old mcdonald\n")
 252         self.protocol.lineReceived("failure a\n")
 253         self.protocol.lineReceived("failure: a\n")
 254         self.protocol.lineReceived("error a\n")
 255         self.protocol.lineReceived("error: a\n")
 256         self.protocol.lineReceived("success a\n")
 257         self.protocol.lineReceived("success: a\n")
 258         self.protocol.lineReceived("successful a\n")
 259         self.protocol.lineReceived("successful: a\n")
 260         self.protocol.lineReceived("]\n")
 261         self.protocol.lineReceived("failure old mcdonald\n")
 262         self.assertEqual(self.stdout.getvalue(), "test old mcdonald\n"
 263                                                  "failure a\n"
 264                                                  "failure: a\n"
 265                                                  "error a\n"
 266                                                  "error: a\n"
 267                                                  "success a\n"
 268                                                  "success: a\n"
 269                                                  "successful a\n"
 270                                                  "successful: a\n"
 271                                                  "]\n")
 272         self.assertEqual(self.client.start_calls, [self.test])
 273         self.assertEqual(self.client.end_calls, [self.test])
 274         self.assertEqual(self.client.failure_calls,
 275                          [(self.test, subunit.RemoteError())])
 276         self.assertEqual(self.client.error_calls, [])
 277         self.assertEqual(self.client.success_calls, [])
 278
 279     def test_keywords_during_failure(self):
 280         self.protocol.lineReceived("test old mcdonald\n")
 281         self.protocol.lineReceived("failure: old mcdonald [\n")
 282         self.protocol.lineReceived("test old mcdonald\n")
 283         self.protocol.lineReceived("failure a\n")
 284         self.protocol.lineReceived("failure: a\n")
 285         self.protocol.lineReceived("error a\n")
 286         self.protocol.lineReceived("error: a\n")
 287         self.protocol.lineReceived("success a\n")
 288         self.protocol.lineReceived("success: a\n")
 289         self.protocol.lineReceived("successful a\n")
 290         self.protocol.lineReceived("successful: a\n")
 291         self.protocol.lineReceived(" ]\n")
 292         self.protocol.lineReceived("]\n")
 293         self.assertEqual(self.stdout.getvalue(), "")
 294         self.assertEqual(self.client.start_calls, [self.test])
 295         self.assertEqual(self.client.failure_calls,
 296                          [(self.test, subunit.RemoteError("test old mcdonald\n"
 297                                                   "failure a\n"
 298                                                   "failure: a\n"
 299                                                   "error a\n"
 300                                                   "error: a\n"
 301                                                   "success a\n"
 302                                                   "success: a\n"
 303                                                   "successful a\n"
 304                                                   "successful: a\n"
 305                                                   "]\n"))])
 306         self.assertEqual(self.client.end_calls, [self.test])
 307         self.assertEqual(self.client.error_calls, [])
 308         self.assertEqual(self.client.success_calls, [])
 309
 310
 311 class TestTestProtocolServerLostConnection(unittest.TestCase):
 312
 313     def setUp(self):
 314         self.client = MockTestProtocolServerClient()
 315         self.protocol = subunit.TestProtocolServer(self.client)
 316         self.test = subunit.RemotedTestCase("old mcdonald")
 317
 318     def test_lost_connection_no_input(self):
 319         self.protocol.lostConnection()
 320         self.assertEqual(self.client.start_calls, [])
 321         self.assertEqual(self.client.error_calls, [])
 322         self.assertEqual(self.client.failure_calls, [])
 323         self.assertEqual(self.client.success_calls, [])
 324
 325     def test_lost_connection_after_start(self):
 326         self.protocol.lineReceived("test old mcdonald\n")
 327         self.protocol.lostConnection()
 328         self.assertEqual(self.client.start_calls, [self.test])
 329         self.assertEqual(self.client.end_calls, [self.test])
 330         self.assertEqual(self.client.error_calls, [
 331             (self.test, subunit.RemoteError("lost connection during "
 332                                             "test 'old mcdonald'"))])
 333         self.assertEqual(self.client.failure_calls, [])
 334         self.assertEqual(self.client.success_calls, [])
 335
 336     def test_lost_connected_after_error(self):
 337         self.protocol.lineReceived("test old mcdonald\n")
 338         self.protocol.lineReceived("error old mcdonald\n")
 339         self.protocol.lostConnection()
 340         self.assertEqual(self.client.start_calls, [self.test])
 341         self.assertEqual(self.client.failure_calls, [])
 342         self.assertEqual(self.client.end_calls, [self.test])
 343         self.assertEqual(self.client.error_calls, [
 344             (self.test, subunit.RemoteError(""))])
 345         self.assertEqual(self.client.success_calls, [])
 346
 347     def test_lost_connection_during_error(self):
 348         self.protocol.lineReceived("test old mcdonald\n")
 349         self.protocol.lineReceived("error old mcdonald [\n")
 350         self.protocol.lostConnection()
 351         self.assertEqual(self.client.start_calls, [self.test])
 352         self.assertEqual(self.client.end_calls, [self.test])
 353         self.assertEqual(self.client.error_calls, [
 354             (self.test, subunit.RemoteError("lost connection during error "
 355                                             "report of test 'old mcdonald'"))])
 356         self.assertEqual(self.client.failure_calls, [])
 357         self.assertEqual(self.client.success_calls, [])
 358
 359     def test_lost_connected_after_failure(self):
 360         self.protocol.lineReceived("test old mcdonald\n")
 361         self.protocol.lineReceived("failure old mcdonald\n")
 362         self.protocol.lostConnection()
 363         test = subunit.RemotedTestCase("old mcdonald")
 364         self.assertEqual(self.client.start_calls, [self.test])
 365         self.assertEqual(self.client.end_calls, [self.test])
 366         self.assertEqual(self.client.error_calls, [])
 367         self.assertEqual(self.client.failure_calls,
 368                          [(self.test, subunit.RemoteError())])
 369         self.assertEqual(self.client.success_calls, [])
 370
 371     def test_lost_connection_during_failure(self):
 372         self.protocol.lineReceived("test old mcdonald\n")
 373         self.protocol.lineReceived("failure old mcdonald [\n")
 374         self.protocol.lostConnection()
 375         self.assertEqual(self.client.start_calls, [self.test])
 376         self.assertEqual(self.client.end_calls, [self.test])
 377         self.assertEqual(self.client.error_calls,
 378                          [(self.test,
 379                            subunit.RemoteError("lost connection during "
 380                                                "failure report"
 381                                                " of test 'old mcdonald'"))])
 382         self.assertEqual(self.client.failure_calls, [])
 383         self.assertEqual(self.client.success_calls, [])
 384
 385     def test_lost_connection_after_success(self):
 386         self.protocol.lineReceived("test old mcdonald\n")
 387         self.protocol.lineReceived("success old mcdonald\n")
 388         self.protocol.lostConnection()
 389         self.assertEqual(self.client.start_calls, [self.test])
 390         self.assertEqual(self.client.end_calls, [self.test])
 391         self.assertEqual(self.client.error_calls, [])
 392         self.assertEqual(self.client.failure_calls, [])
 393         self.assertEqual(self.client.success_calls, [self.test])
 394
 395
 396 class TestTestProtocolServerAddError(unittest.TestCase):
 397
 398     def setUp(self):
 399         self.client = MockTestProtocolServerClient()
 400         self.protocol = subunit.TestProtocolServer(self.client)
 401         self.protocol.lineReceived("test mcdonalds farm\n")
 402         self.test = subunit.RemotedTestCase("mcdonalds farm")
 403
 404     def simple_error_keyword(self, keyword):
 405         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 406         self.assertEqual(self.client.start_calls, [self.test])
 407         self.assertEqual(self.client.end_calls, [self.test])
 408         self.assertEqual(self.client.error_calls, [
 409             (self.test, subunit.RemoteError(""))])
 410         self.assertEqual(self.client.failure_calls, [])
 411
 412     def test_simple_error(self):
 413         self.simple_error_keyword("error")
 414
 415     def test_simple_error_colon(self):
 416         self.simple_error_keyword("error:")
 417
 418     def test_error_empty_message(self):
 419         self.protocol.lineReceived("error mcdonalds farm [\n")
 420         self.protocol.lineReceived("]\n")
 421         self.assertEqual(self.client.start_calls, [self.test])
 422         self.assertEqual(self.client.end_calls, [self.test])
 423         self.assertEqual(self.client.error_calls, [
 424             (self.test, subunit.RemoteError(""))])
 425         self.assertEqual(self.client.failure_calls, [])
 426
 427     def error_quoted_bracket(self, keyword):
 428         self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
 429         self.protocol.lineReceived(" ]\n")
 430         self.protocol.lineReceived("]\n")
 431         self.assertEqual(self.client.start_calls, [self.test])
 432         self.assertEqual(self.client.end_calls, [self.test])
 433         self.assertEqual(self.client.error_calls, [
 434             (self.test, subunit.RemoteError("]\n"))])
 435         self.assertEqual(self.client.failure_calls, [])
 436
 437     def test_error_quoted_bracket(self):
 438         self.error_quoted_bracket("error")
 439
 440     def test_error_colon_quoted_bracket(self):
 441         self.error_quoted_bracket("error:")
 442
 443
 444 class TestTestProtocolServerAddFailure(unittest.TestCase):
 445
 446     def setUp(self):
 447         self.client = MockTestProtocolServerClient()
 448         self.protocol = subunit.TestProtocolServer(self.client)
 449         self.protocol.lineReceived("test mcdonalds farm\n")
 450         self.test = subunit.RemotedTestCase("mcdonalds farm")
 451
 452     def simple_failure_keyword(self, keyword):
 453         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 454         self.assertEqual(self.client.start_calls, [self.test])
 455         self.assertEqual(self.client.end_calls, [self.test])
 456         self.assertEqual(self.client.error_calls, [])
 457         self.assertEqual(self.client.failure_calls,
 458                          [(self.test, subunit.RemoteError())])
 459
 460     def test_simple_failure(self):
 461         self.simple_failure_keyword("failure")
 462
 463     def test_simple_failure_colon(self):
 464         self.simple_failure_keyword("failure:")
 465
 466     def test_failure_empty_message(self):
 467         self.protocol.lineReceived("failure mcdonalds farm [\n")
 468         self.protocol.lineReceived("]\n")
 469         self.assertEqual(self.client.start_calls, [self.test])
 470         self.assertEqual(self.client.end_calls, [self.test])
 471         self.assertEqual(self.client.error_calls, [])
 472         self.assertEqual(self.client.failure_calls,
 473                          [(self.test, subunit.RemoteError())])
 474
 475     def failure_quoted_bracket(self, keyword):
 476         self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
 477         self.protocol.lineReceived(" ]\n")
 478         self.protocol.lineReceived("]\n")
 479         self.assertEqual(self.client.start_calls, [self.test])
 480         self.assertEqual(self.client.end_calls, [self.test])
 481         self.assertEqual(self.client.error_calls, [])
 482         self.assertEqual(self.client.failure_calls,
 483                          [(self.test, subunit.RemoteError("]\n"))])
 484
 485     def test_failure_quoted_bracket(self):
 486         self.failure_quoted_bracket("failure")
 487
 488     def test_failure_colon_quoted_bracket(self):
 489         self.failure_quoted_bracket("failure:")
 490
 491
 492 class TestTestProtocolServerAddSuccess(unittest.TestCase):
 493
 494     def setUp(self):
 495         self.client = MockTestProtocolServerClient()
 496         self.protocol = subunit.TestProtocolServer(self.client)
 497         self.protocol.lineReceived("test mcdonalds farm\n")
 498         self.test = subunit.RemotedTestCase("mcdonalds farm")
 499
 500     def simple_success_keyword(self, keyword):
 501         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 502         self.assertEqual(self.client.start_calls, [self.test])
 503         self.assertEqual(self.client.end_calls, [self.test])
 504         self.assertEqual(self.client.error_calls, [])
 505         self.assertEqual(self.client.success_calls, [self.test])
 506
 507     def test_simple_success(self):
 508         self.simple_success_keyword("failure")
 509
 510     def test_simple_success_colon(self):
 511         self.simple_success_keyword("failure:")
 512
 513     def test_simple_success(self):
 514         self.simple_success_keyword("successful")
 515
 516     def test_simple_success_colon(self):
 517         self.simple_success_keyword("successful:")
 518
 519
 520 class TestRemotedTestCase(unittest.TestCase):
 521
 522     def test_simple(self):
 523         test = subunit.RemotedTestCase("A test description")
 524         self.assertRaises(NotImplementedError, test.setUp)
 525         self.assertRaises(NotImplementedError, test.tearDown)
 526         self.assertEqual("A test description",
 527                          test.shortDescription())
 528         self.assertEqual("subunit.RemotedTestCase.A test description",
 529                          test.id())
 530         self.assertEqual("A test description (subunit.RemotedTestCase)", "%s" % test)
 531         self.assertEqual("<subunit.RemotedTestCase description="
 532                          "'A test description'>", "%r" % test)
 533         result = unittest.TestResult()
 534         test.run(result)
 535         self.assertEqual([(test, "RemoteException: "
 536                                  "Cannot run RemotedTestCases.\n\n")],
 537                          result.errors)
 538         self.assertEqual(1, result.testsRun)
 539         another_test = subunit.RemotedTestCase("A test description")
 540         self.assertEqual(test, another_test)
 541         different_test = subunit.RemotedTestCase("ofo")
 542         self.assertNotEqual(test, different_test)
 543         self.assertNotEqual(another_test, different_test)
 544
 545
 546 class TestRemoteError(unittest.TestCase):
 547
 548     def test_eq(self):
 549         error = subunit.RemoteError("Something went wrong")
 550         another_error = subunit.RemoteError("Something went wrong")
 551         different_error = subunit.RemoteError("boo!")
 552         self.assertEqual(error, another_error)
 553         self.assertNotEqual(error, different_error)
 554         self.assertNotEqual(different_error, another_error)
 555
 556     def test_empty_constructor(self):
 557         self.assertEqual(subunit.RemoteError(), subunit.RemoteError(""))
 558
 559
 560 class TestExecTestCase(unittest.TestCase):
 561
 562     class SampleExecTestCase(subunit.ExecTestCase):
 563
 564         def test_sample_method(self):
 565             pass
 566         test_sample_method.__doc__ = mockFile("sample-script.py")
 567         # the sample script runs three tests, one each
 568         # that fails, errors and succeeds
 569
 570
 571     def test_construct(self):
 572         test = self.SampleExecTestCase("test_sample_method")
 573         self.assertEqual(test.script, mockFile("sample-script.py"))
 574
 575     def test_run(self):
 576         runner = MockTestProtocolServerClient()
 577         test = self.SampleExecTestCase("test_sample_method")
 578         test.run(runner)
 579         mcdonald = subunit.RemotedTestCase("old mcdonald")
 580         bing = subunit.RemotedTestCase("bing crosby")
 581         an_error = subunit.RemotedTestCase("an error")
 582         self.assertEqual(runner.error_calls,
 583                          [(an_error, subunit.RemoteError())])
 584         self.assertEqual(runner.failure_calls,
 585                          [(bing,
 586                            subunit.RemoteError(
 587                             "foo.c:53:ERROR invalid state\n"))])
 588         self.assertEqual(runner.start_calls, [mcdonald, bing, an_error])
 589         self.assertEqual(runner.end_calls, [mcdonald, bing, an_error])
 590
 591     def test_debug(self):
 592         test = self.SampleExecTestCase("test_sample_method")
 593         test.debug()
 594
 595     def test_count_test_cases(self):
 596         """TODO run the child process and count responses to determine the count."""
 597
 598
 599 class DoExecTestCase(subunit.ExecTestCase):
 600
 601     def test_working_script(self):
 602         pass
 603     test_working_script.__doc__ = mockFile("sample-two-script.py")
 604
 605
 606 class TestIsolatedTestCase(unittest.TestCase):
 607
 608     class SampleIsolatedTestCase(subunit.IsolatedTestCase):
 609
 610         SETUP = False
 611         TEARDOWN = False
 612         TEST = False
 613
 614         def setUp(self):
 615             TestIsolatedTestCase.SampleIsolatedTestCase.SETUP = True
 616
 617         def tearDown(self):
 618             TestIsolatedTestCase.SampleIsolatedTestCase.TEARDOWN = True
 619
 620         def test_sets_global_state(self):
 621             TestIsolatedTestCase.SampleIsolatedTestCase.TEST = True
 622
 623
 624     def test_construct(self):
 625         test = self.SampleIsolatedTestCase("test_sets_global_state")
 626
 627     def test_run(self):
 628         result = unittest.TestResult()
 629         test = self.SampleIsolatedTestCase("test_sets_global_state")
 630         test.run(result)
 631         self.assertEqual(result.testsRun, 1)
 632         self.assertEqual(self.SampleIsolatedTestCase.SETUP, False)
 633         self.assertEqual(self.SampleIsolatedTestCase.TEARDOWN, False)
 634         self.assertEqual(self.SampleIsolatedTestCase.TEST, False)
 635
 636     def test_debug(self):
 637         pass
 638         #test = self.SampleExecTestCase("test_sample_method")
 639         #test.debug()
 640
 641
 642 class TestIsolatedTestSuite(unittest.TestCase):
 643
 644     class SampleTestToIsolate(unittest.TestCase):
 645
 646         SETUP = False
 647         TEARDOWN = False
 648         TEST = False
 649
 650         def setUp(self):
 651             TestIsolatedTestSuite.SampleTestToIsolate.SETUP = True
 652
 653         def tearDown(self):
 654             TestIsolatedTestSuite.SampleTestToIsolate.TEARDOWN = True
 655
 656         def test_sets_global_state(self):
 657             TestIsolatedTestSuite.SampleTestToIsolate.TEST = True
 658
 659
 660     def test_construct(self):
 661         suite = subunit.IsolatedTestSuite()
 662
 663     def test_run(self):
 664         result = unittest.TestResult()
 665         suite = subunit.IsolatedTestSuite()
 666         sub_suite = unittest.TestSuite()
 667         sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
 668         sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
 669         suite.addTest(sub_suite)
 670         suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
 671         suite.run(result)
 672         self.assertEqual(result.testsRun, 3)
 673         self.assertEqual(self.SampleTestToIsolate.SETUP, False)
 674         self.assertEqual(self.SampleTestToIsolate.TEARDOWN, False)
 675         self.assertEqual(self.SampleTestToIsolate.TEST, False)
 676
 677
 678 class TestTestProtocolClient(unittest.TestCase):
 679
 680     def setUp(self):
 681         self.io = StringIO()
 682         self.protocol = subunit.TestProtocolClient(self.io)
 683         self.test = TestTestProtocolClient("test_start_test")
 684
 685
 686     def test_start_test(self):
 687         """Test startTest on a TestProtocolClient."""
 688         self.protocol.startTest(self.test)
 689         self.assertEqual(self.io.getvalue(), "test: Test startTest on a "
 690                                              "TestProtocolClient.\n")
 691
 692     def test_stop_test(self):
 693         """Test stopTest on a TestProtocolClient."""
 694         self.protocol.stopTest(self.test)
 695         self.assertEqual(self.io.getvalue(), "")
 696
 697     def test_add_success(self):
 698         """Test addSuccess on a TestProtocolClient."""
 699         self.protocol.addSuccess(self.test)
 700         self.assertEqual(self.io.getvalue(), "successful: Test startTest on a "
 701                                              "TestProtocolClient.\n")
 702
 703     def test_add_failure(self):
 704         """Test addFailure on a TestProtocolClient."""
 705         self.protocol.addFailure(self.test, subunit.RemoteError("boo"))
 706         self.assertEqual(self.io.getvalue(), "failure: Test startTest on a "
 707                                              "TestProtocolClient. [\n"
 708                                              "RemoteException:\n"
 709                                              "boo\n"
 710                                              "]\n")
 711
 712     def test_add_error(self):
 713         """Test stopTest on a TestProtocolClient."""
 714         self.protocol.addError(self.test, subunit.RemoteError("phwoar"))
 715         self.assertEqual(self.io.getvalue(), "error: Test startTest on a "
 716                                              "TestProtocolClient. [\n"
 717                                              "RemoteException:\n"
 718                                              "phwoar\n"
 719                                              "]\n")
 720
 721
 722 def test_suite():
 723     loader = subunit.tests.TestUtil.TestLoader()
 724     result = loader.loadTestsFromName(__name__)
 725     return result