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 os
  23 import subunit
  24 import sys
  25 import time
  26
  27 try:
  28     class MockTestProtocolServerClient(object):
  29         """A mock protocol server client to test callbacks."""
  30
  31         def __init__(self):
  32             self.end_calls = []
  33             self.error_calls = []
  34             self.failure_calls = []
  35             self.start_calls = []
  36             self.success_calls = []
  37             super(MockTestProtocolServerClient, self).__init__()
  38
  39         def addError(self, test, error):
  40             self.error_calls.append((test, error))
  41
  42         def addFailure(self, test, error):
  43             self.failure_calls.append((test, error))
  44
  45         def addSuccess(self, test):
  46             self.success_calls.append(test)
  47
  48         def stopTest(self, test):
  49             self.end_calls.append(test)
  50
  51         def startTest(self, test):
  52             self.start_calls.append(test)
  53
  54 except AttributeError:
  55     MockTestProtocolServer = None
  56
  57
  58 class TestMockTestProtocolServer(unittest.TestCase):
  59
  60     def test_start_test(self):
  61         protocol = MockTestProtocolServerClient()
  62         protocol.startTest(subunit.RemotedTestCase("test old mcdonald"))
  63         self.assertEqual(protocol.start_calls,
  64                          [subunit.RemotedTestCase("test old mcdonald")])
  65         self.assertEqual(protocol.end_calls, [])
  66         self.assertEqual(protocol.error_calls, [])
  67         self.assertEqual(protocol.failure_calls, [])
  68         self.assertEqual(protocol.success_calls, [])
  69
  70     def test_add_error(self):
  71         protocol = MockTestProtocolServerClient()
  72         protocol.addError(subunit.RemotedTestCase("old mcdonald"),
  73                           subunit.RemoteError("omg it works"))
  74         self.assertEqual(protocol.start_calls, [])
  75         self.assertEqual(protocol.end_calls, [])
  76         self.assertEqual(protocol.error_calls, [(
  77                             subunit.RemotedTestCase("old mcdonald"),
  78                             subunit.RemoteError("omg it works"))])
  79         self.assertEqual(protocol.failure_calls, [])
  80         self.assertEqual(protocol.success_calls, [])
  81
  82     def test_add_failure(self):
  83         protocol = MockTestProtocolServerClient()
  84         protocol.addFailure(subunit.RemotedTestCase("old mcdonald"),
  85                             subunit.RemoteError("omg it works"))
  86         self.assertEqual(protocol.start_calls, [])
  87         self.assertEqual(protocol.end_calls, [])
  88         self.assertEqual(protocol.error_calls, [])
  89         self.assertEqual(protocol.failure_calls, [
  90                             (subunit.RemotedTestCase("old mcdonald"),
  91                              subunit.RemoteError("omg it works"))])
  92         self.assertEqual(protocol.success_calls, [])
  93
  94     def test_add_success(self):
  95         protocol = MockTestProtocolServerClient()
  96         protocol.addSuccess(subunit.RemotedTestCase("test old mcdonald"))
  97         self.assertEqual(protocol.start_calls, [])
  98         self.assertEqual(protocol.end_calls, [])
  99         self.assertEqual(protocol.error_calls, [])
 100         self.assertEqual(protocol.failure_calls, [])
 101         self.assertEqual(protocol.success_calls,
 102                          [subunit.RemotedTestCase("test old mcdonald")])
 103
 104     def test_end_test(self):
 105         protocol = MockTestProtocolServerClient()
 106         protocol.stopTest(subunit.RemotedTestCase("test old mcdonald"))
 107         self.assertEqual(protocol.end_calls,
 108                          [subunit.RemotedTestCase("test old mcdonald")])
 109         self.assertEqual(protocol.error_calls, [])
 110         self.assertEqual(protocol.failure_calls, [])
 111         self.assertEqual(protocol.success_calls, [])
 112         self.assertEqual(protocol.start_calls, [])
 113
 114
 115 class TestTestImports(unittest.TestCase):
 116
 117     def test_imports(self):
 118         from subunit import TestProtocolServer
 119         from subunit import RemotedTestCase
 120         from subunit import RemoteError
 121         from subunit import ExecTestCase
 122         from subunit import IsolatedTestCase
 123         from subunit import TestProtocolClient
 124
 125
 126 class TestTestProtocolServerPipe(unittest.TestCase):
 127
 128     def test_story(self):
 129         client = unittest.TestResult()
 130         protocol = subunit.TestProtocolServer(client)
 131         pipe = StringIO("test old mcdonald\n"
 132                         "success old mcdonald\n"
 133                         "test bing crosby\n"
 134                         "failure bing crosby [\n"
 135                         "foo.c:53:ERROR invalid state\n"
 136                         "]\n"
 137                         "test an error\n"
 138                         "error an error\n")
 139         protocol.readFrom(pipe)
 140         mcdonald = subunit.RemotedTestCase("old mcdonald")
 141         bing = subunit.RemotedTestCase("bing crosby")
 142         an_error = subunit.RemotedTestCase("an error")
 143         self.assertEqual(client.errors,
 144                          [(an_error, 'RemoteException: \n\n')])
 145         self.assertEqual(
 146             client.failures,
 147             [(bing, "RemoteException: foo.c:53:ERROR invalid state\n\n")])
 148         self.assertEqual(client.testsRun, 3)
 149
 150
 151 class TestTestProtocolServerStartTest(unittest.TestCase):
 152
 153     def setUp(self):
 154         self.client = MockTestProtocolServerClient()
 155         self.protocol = subunit.TestProtocolServer(self.client)
 156
 157     def test_start_test(self):
 158         self.protocol.lineReceived("test old mcdonald\n")
 159         self.assertEqual(self.client.start_calls,
 160                          [subunit.RemotedTestCase("old mcdonald")])
 161
 162     def test_start_testing(self):
 163         self.protocol.lineReceived("testing old mcdonald\n")
 164         self.assertEqual(self.client.start_calls,
 165                          [subunit.RemotedTestCase("old mcdonald")])
 166
 167     def test_start_test_colon(self):
 168         self.protocol.lineReceived("test: old mcdonald\n")
 169         self.assertEqual(self.client.start_calls,
 170                          [subunit.RemotedTestCase("old mcdonald")])
 171
 172     def test_start_testing_colon(self):
 173         self.protocol.lineReceived("testing: old mcdonald\n")
 174         self.assertEqual(self.client.start_calls,
 175                          [subunit.RemotedTestCase("old mcdonald")])
 176
 177
 178 class TestTestProtocolServerPassThrough(unittest.TestCase):
 179
 180     def setUp(self):
 181         from StringIO import StringIO
 182         self.stdout = StringIO()
 183         self.test = subunit.RemotedTestCase("old mcdonald")
 184         self.client = MockTestProtocolServerClient()
 185         self.protocol = subunit.TestProtocolServer(self.client, self.stdout)
 186
 187     def keywords_before_test(self):
 188         self.protocol.lineReceived("failure a\n")
 189         self.protocol.lineReceived("failure: a\n")
 190         self.protocol.lineReceived("error a\n")
 191         self.protocol.lineReceived("error: a\n")
 192         self.protocol.lineReceived("success a\n")
 193         self.protocol.lineReceived("success: a\n")
 194         self.protocol.lineReceived("successful a\n")
 195         self.protocol.lineReceived("successful: a\n")
 196         self.protocol.lineReceived("]\n")
 197         self.assertEqual(self.stdout.getvalue(), "failure a\n"
 198                                                  "failure: a\n"
 199                                                  "error a\n"
 200                                                  "error: a\n"
 201                                                  "success a\n"
 202                                                  "success: a\n"
 203                                                  "successful a\n"
 204                                                  "successful: a\n"
 205                                                  "]\n")
 206
 207     def test_keywords_before_test(self):
 208         self.keywords_before_test()
 209         self.assertEqual(self.client.start_calls, [])
 210         self.assertEqual(self.client.error_calls, [])
 211         self.assertEqual(self.client.failure_calls, [])
 212         self.assertEqual(self.client.success_calls, [])
 213
 214     def test_keywords_after_error(self):
 215         self.protocol.lineReceived("test old mcdonald\n")
 216         self.protocol.lineReceived("error old mcdonald\n")
 217         self.keywords_before_test()
 218         self.assertEqual(self.client.start_calls, [self.test])
 219         self.assertEqual(self.client.end_calls, [self.test])
 220         self.assertEqual(self.client.error_calls,
 221                          [(self.test, subunit.RemoteError(""))])
 222         self.assertEqual(self.client.failure_calls, [])
 223         self.assertEqual(self.client.success_calls, [])
 224
 225     def test_keywords_after_failure(self):
 226         self.protocol.lineReceived("test old mcdonald\n")
 227         self.protocol.lineReceived("failure old mcdonald\n")
 228         self.keywords_before_test()
 229         self.assertEqual(self.client.start_calls, [self.test])
 230         self.assertEqual(self.client.end_calls, [self.test])
 231         self.assertEqual(self.client.error_calls, [])
 232         self.assertEqual(self.client.failure_calls,
 233                          [(self.test, subunit.RemoteError())])
 234         self.assertEqual(self.client.success_calls, [])
 235
 236     def test_keywords_after_success(self):
 237         self.protocol.lineReceived("test old mcdonald\n")
 238         self.protocol.lineReceived("success old mcdonald\n")
 239         self.keywords_before_test()
 240         self.assertEqual(self.client.start_calls, [self.test])
 241         self.assertEqual(self.client.end_calls, [self.test])
 242         self.assertEqual(self.client.error_calls, [])
 243         self.assertEqual(self.client.failure_calls, [])
 244         self.assertEqual(self.client.success_calls, [self.test])
 245
 246     def test_keywords_after_test(self):
 247         self.protocol.lineReceived("test old mcdonald\n")
 248         self.protocol.lineReceived("test old mcdonald\n")
 249         self.protocol.lineReceived("failure a\n")
 250         self.protocol.lineReceived("failure: a\n")
 251         self.protocol.lineReceived("error a\n")
 252         self.protocol.lineReceived("error: a\n")
 253         self.protocol.lineReceived("success a\n")
 254         self.protocol.lineReceived("success: a\n")
 255         self.protocol.lineReceived("successful a\n")
 256         self.protocol.lineReceived("successful: a\n")
 257         self.protocol.lineReceived("]\n")
 258         self.protocol.lineReceived("failure old mcdonald\n")
 259         self.assertEqual(self.stdout.getvalue(), "test old mcdonald\n"
 260                                                  "failure a\n"
 261                                                  "failure: a\n"
 262                                                  "error a\n"
 263                                                  "error: a\n"
 264                                                  "success a\n"
 265                                                  "success: a\n"
 266                                                  "successful a\n"
 267                                                  "successful: a\n"
 268                                                  "]\n")
 269         self.assertEqual(self.client.start_calls, [self.test])
 270         self.assertEqual(self.client.end_calls, [self.test])
 271         self.assertEqual(self.client.failure_calls,
 272                          [(self.test, subunit.RemoteError())])
 273         self.assertEqual(self.client.error_calls, [])
 274         self.assertEqual(self.client.success_calls, [])
 275
 276     def test_keywords_during_failure(self):
 277         self.protocol.lineReceived("test old mcdonald\n")
 278         self.protocol.lineReceived("failure: old mcdonald [\n")
 279         self.protocol.lineReceived("test old mcdonald\n")
 280         self.protocol.lineReceived("failure a\n")
 281         self.protocol.lineReceived("failure: a\n")
 282         self.protocol.lineReceived("error a\n")
 283         self.protocol.lineReceived("error: a\n")
 284         self.protocol.lineReceived("success a\n")
 285         self.protocol.lineReceived("success: a\n")
 286         self.protocol.lineReceived("successful a\n")
 287         self.protocol.lineReceived("successful: a\n")
 288         self.protocol.lineReceived(" ]\n")
 289         self.protocol.lineReceived("]\n")
 290         self.assertEqual(self.stdout.getvalue(), "")
 291         self.assertEqual(self.client.start_calls, [self.test])
 292         self.assertEqual(self.client.failure_calls,
 293                          [(self.test, subunit.RemoteError("test old mcdonald\n"
 294                                                   "failure a\n"
 295                                                   "failure: a\n"
 296                                                   "error a\n"
 297                                                   "error: a\n"
 298                                                   "success a\n"
 299                                                   "success: a\n"
 300                                                   "successful a\n"
 301                                                   "successful: a\n"
 302                                                   "]\n"))])
 303         self.assertEqual(self.client.end_calls, [self.test])
 304         self.assertEqual(self.client.error_calls, [])
 305         self.assertEqual(self.client.success_calls, [])
 306
 307     def test_stdout_passthrough(self):
 308         """Lines received which cannot be interpreted as any protocol action
 309         should be passed through to sys.stdout.
 310         """
 311         bytes = "randombytes\n"
 312         self.protocol.lineReceived(bytes)
 313         self.assertEqual(self.stdout.getvalue(), bytes)
 314
 315
 316 class TestTestProtocolServerLostConnection(unittest.TestCase):
 317
 318     def setUp(self):
 319         self.client = MockTestProtocolServerClient()
 320         self.protocol = subunit.TestProtocolServer(self.client)
 321         self.test = subunit.RemotedTestCase("old mcdonald")
 322
 323     def test_lost_connection_no_input(self):
 324         self.protocol.lostConnection()
 325         self.assertEqual(self.client.start_calls, [])
 326         self.assertEqual(self.client.error_calls, [])
 327         self.assertEqual(self.client.failure_calls, [])
 328         self.assertEqual(self.client.success_calls, [])
 329
 330     def test_lost_connection_after_start(self):
 331         self.protocol.lineReceived("test old mcdonald\n")
 332         self.protocol.lostConnection()
 333         self.assertEqual(self.client.start_calls, [self.test])
 334         self.assertEqual(self.client.end_calls, [self.test])
 335         self.assertEqual(self.client.error_calls, [
 336             (self.test, subunit.RemoteError("lost connection during "
 337                                             "test 'old mcdonald'"))])
 338         self.assertEqual(self.client.failure_calls, [])
 339         self.assertEqual(self.client.success_calls, [])
 340
 341     def test_lost_connected_after_error(self):
 342         self.protocol.lineReceived("test old mcdonald\n")
 343         self.protocol.lineReceived("error old mcdonald\n")
 344         self.protocol.lostConnection()
 345         self.assertEqual(self.client.start_calls, [self.test])
 346         self.assertEqual(self.client.failure_calls, [])
 347         self.assertEqual(self.client.end_calls, [self.test])
 348         self.assertEqual(self.client.error_calls, [
 349             (self.test, subunit.RemoteError(""))])
 350         self.assertEqual(self.client.success_calls, [])
 351
 352     def test_lost_connection_during_error(self):
 353         self.protocol.lineReceived("test old mcdonald\n")
 354         self.protocol.lineReceived("error old mcdonald [\n")
 355         self.protocol.lostConnection()
 356         self.assertEqual(self.client.start_calls, [self.test])
 357         self.assertEqual(self.client.end_calls, [self.test])
 358         self.assertEqual(self.client.error_calls, [
 359             (self.test, subunit.RemoteError("lost connection during error "
 360                                             "report of test 'old mcdonald'"))])
 361         self.assertEqual(self.client.failure_calls, [])
 362         self.assertEqual(self.client.success_calls, [])
 363
 364     def test_lost_connected_after_failure(self):
 365         self.protocol.lineReceived("test old mcdonald\n")
 366         self.protocol.lineReceived("failure old mcdonald\n")
 367         self.protocol.lostConnection()
 368         test = subunit.RemotedTestCase("old mcdonald")
 369         self.assertEqual(self.client.start_calls, [self.test])
 370         self.assertEqual(self.client.end_calls, [self.test])
 371         self.assertEqual(self.client.error_calls, [])
 372         self.assertEqual(self.client.failure_calls,
 373                          [(self.test, subunit.RemoteError())])
 374         self.assertEqual(self.client.success_calls, [])
 375
 376     def test_lost_connection_during_failure(self):
 377         self.protocol.lineReceived("test old mcdonald\n")
 378         self.protocol.lineReceived("failure old mcdonald [\n")
 379         self.protocol.lostConnection()
 380         self.assertEqual(self.client.start_calls, [self.test])
 381         self.assertEqual(self.client.end_calls, [self.test])
 382         self.assertEqual(self.client.error_calls,
 383                          [(self.test,
 384                            subunit.RemoteError("lost connection during "
 385                                                "failure report"
 386                                                " of test 'old mcdonald'"))])
 387         self.assertEqual(self.client.failure_calls, [])
 388         self.assertEqual(self.client.success_calls, [])
 389
 390     def test_lost_connection_after_success(self):
 391         self.protocol.lineReceived("test old mcdonald\n")
 392         self.protocol.lineReceived("success old mcdonald\n")
 393         self.protocol.lostConnection()
 394         self.assertEqual(self.client.start_calls, [self.test])
 395         self.assertEqual(self.client.end_calls, [self.test])
 396         self.assertEqual(self.client.error_calls, [])
 397         self.assertEqual(self.client.failure_calls, [])
 398         self.assertEqual(self.client.success_calls, [self.test])
 399
 400     def test_lost_connection_during_skip(self):
 401         self.protocol.lineReceived("test old mcdonald\n")
 402         self.protocol.lineReceived("skip old mcdonald [\n")
 403         self.protocol.lostConnection()
 404         self.assertEqual(self.client.start_calls, [self.test])
 405         self.assertEqual(self.client.end_calls, [self.test])
 406         self.assertEqual(self.client.error_calls, [
 407             (self.test, subunit.RemoteError("lost connection during skip "
 408                                             "report of test 'old mcdonald'"))])
 409         self.assertEqual(self.client.failure_calls, [])
 410         self.assertEqual(self.client.success_calls, [])
 411
 412     def test_lost_connection_during_xfail(self):
 413         self.protocol.lineReceived("test old mcdonald\n")
 414         self.protocol.lineReceived("xfail old mcdonald [\n")
 415         self.protocol.lostConnection()
 416         self.assertEqual(self.client.start_calls, [self.test])
 417         self.assertEqual(self.client.end_calls, [self.test])
 418         self.assertEqual(self.client.error_calls, [
 419             (self.test, subunit.RemoteError("lost connection during xfail "
 420                                             "report of test 'old mcdonald'"))])
 421         self.assertEqual(self.client.failure_calls, [])
 422         self.assertEqual(self.client.success_calls, [])
 423
 424     def test_lost_connection_during_success(self):
 425         self.protocol.lineReceived("test old mcdonald\n")
 426         self.protocol.lineReceived("success old mcdonald [\n")
 427         self.protocol.lostConnection()
 428         self.assertEqual(self.client.start_calls, [self.test])
 429         self.assertEqual(self.client.end_calls, [self.test])
 430         self.assertEqual(self.client.error_calls, [
 431             (self.test, subunit.RemoteError("lost connection during success "
 432                                             "report of test 'old mcdonald'"))])
 433         self.assertEqual(self.client.failure_calls, [])
 434         self.assertEqual(self.client.success_calls, [])
 435
 436
 437 class TestTestProtocolServerAddError(unittest.TestCase):
 438
 439     def setUp(self):
 440         self.client = MockTestProtocolServerClient()
 441         self.protocol = subunit.TestProtocolServer(self.client)
 442         self.protocol.lineReceived("test mcdonalds farm\n")
 443         self.test = subunit.RemotedTestCase("mcdonalds farm")
 444
 445     def simple_error_keyword(self, keyword):
 446         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 447         self.assertEqual(self.client.start_calls, [self.test])
 448         self.assertEqual(self.client.end_calls, [self.test])
 449         self.assertEqual(self.client.error_calls, [
 450             (self.test, subunit.RemoteError(""))])
 451         self.assertEqual(self.client.failure_calls, [])
 452
 453     def test_simple_error(self):
 454         self.simple_error_keyword("error")
 455
 456     def test_simple_error_colon(self):
 457         self.simple_error_keyword("error:")
 458
 459     def test_error_empty_message(self):
 460         self.protocol.lineReceived("error mcdonalds farm [\n")
 461         self.protocol.lineReceived("]\n")
 462         self.assertEqual(self.client.start_calls, [self.test])
 463         self.assertEqual(self.client.end_calls, [self.test])
 464         self.assertEqual(self.client.error_calls, [
 465             (self.test, subunit.RemoteError(""))])
 466         self.assertEqual(self.client.failure_calls, [])
 467
 468     def error_quoted_bracket(self, keyword):
 469         self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
 470         self.protocol.lineReceived(" ]\n")
 471         self.protocol.lineReceived("]\n")
 472         self.assertEqual(self.client.start_calls, [self.test])
 473         self.assertEqual(self.client.end_calls, [self.test])
 474         self.assertEqual(self.client.error_calls, [
 475             (self.test, subunit.RemoteError("]\n"))])
 476         self.assertEqual(self.client.failure_calls, [])
 477
 478     def test_error_quoted_bracket(self):
 479         self.error_quoted_bracket("error")
 480
 481     def test_error_colon_quoted_bracket(self):
 482         self.error_quoted_bracket("error:")
 483
 484
 485 class TestTestProtocolServerAddFailure(unittest.TestCase):
 486
 487     def setUp(self):
 488         self.client = MockTestProtocolServerClient()
 489         self.protocol = subunit.TestProtocolServer(self.client)
 490         self.protocol.lineReceived("test mcdonalds farm\n")
 491         self.test = subunit.RemotedTestCase("mcdonalds farm")
 492
 493     def simple_failure_keyword(self, keyword):
 494         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 495         self.assertEqual(self.client.start_calls, [self.test])
 496         self.assertEqual(self.client.end_calls, [self.test])
 497         self.assertEqual(self.client.error_calls, [])
 498         self.assertEqual(self.client.failure_calls,
 499                          [(self.test, subunit.RemoteError())])
 500
 501     def test_simple_failure(self):
 502         self.simple_failure_keyword("failure")
 503
 504     def test_simple_failure_colon(self):
 505         self.simple_failure_keyword("failure:")
 506
 507     def test_failure_empty_message(self):
 508         self.protocol.lineReceived("failure mcdonalds farm [\n")
 509         self.protocol.lineReceived("]\n")
 510         self.assertEqual(self.client.start_calls, [self.test])
 511         self.assertEqual(self.client.end_calls, [self.test])
 512         self.assertEqual(self.client.error_calls, [])
 513         self.assertEqual(self.client.failure_calls,
 514                          [(self.test, subunit.RemoteError())])
 515
 516     def failure_quoted_bracket(self, keyword):
 517         self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
 518         self.protocol.lineReceived(" ]\n")
 519         self.protocol.lineReceived("]\n")
 520         self.assertEqual(self.client.start_calls, [self.test])
 521         self.assertEqual(self.client.end_calls, [self.test])
 522         self.assertEqual(self.client.error_calls, [])
 523         self.assertEqual(self.client.failure_calls,
 524                          [(self.test, subunit.RemoteError("]\n"))])
 525
 526     def test_failure_quoted_bracket(self):
 527         self.failure_quoted_bracket("failure")
 528
 529     def test_failure_colon_quoted_bracket(self):
 530         self.failure_quoted_bracket("failure:")
 531
 532
 533 class TestTestProtocolServerAddxFail(unittest.TestCase):
 534     """Tests for the xfail keyword.
 535
 536     In Python this thunks through to Success due to stdlib limitations (see
 537     README).
 538     """
 539
 540     def setUp(self):
 541         """Setup a test object ready to be xfailed."""
 542         self.client = MockTestProtocolServerClient()
 543         self.protocol = subunit.TestProtocolServer(self.client)
 544         self.protocol.lineReceived("test mcdonalds farm\n")
 545         self.test = self.client.start_calls[-1]
 546
 547     def simple_xfail_keyword(self, keyword):
 548         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 549         self.assertEqual(self.client.start_calls, [self.test])
 550         self.assertEqual(self.client.end_calls, [self.test])
 551         self.assertEqual(self.client.error_calls, [])
 552         self.assertEqual(self.client.failure_calls, [])
 553         self.assertEqual(self.client.success_calls, [self.test])
 554
 555     def test_simple_xfail(self):
 556         self.simple_xfail_keyword("xfail")
 557
 558     def test_simple_xfail_colon(self):
 559         self.simple_xfail_keyword("xfail:")
 560
 561     def test_xfail_empty_message(self):
 562         self.protocol.lineReceived("xfail mcdonalds farm [\n")
 563         self.protocol.lineReceived("]\n")
 564         self.assertEqual(self.client.start_calls, [self.test])
 565         self.assertEqual(self.client.end_calls, [self.test])
 566         self.assertEqual(self.client.error_calls, [])
 567         self.assertEqual(self.client.failure_calls, [])
 568         self.assertEqual(self.client.success_calls, [self.test])
 569
 570     def xfail_quoted_bracket(self, keyword):
 571         # This tests it is accepted, but cannot test it is used today, because
 572         # of not having a way to expose it in Python so far.
 573         self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
 574         self.protocol.lineReceived(" ]\n")
 575         self.protocol.lineReceived("]\n")
 576         self.assertEqual(self.client.start_calls, [self.test])
 577         self.assertEqual(self.client.end_calls, [self.test])
 578         self.assertEqual(self.client.error_calls, [])
 579         self.assertEqual(self.client.failure_calls, [])
 580         self.assertEqual(self.client.success_calls, [self.test])
 581
 582     def test_xfail_quoted_bracket(self):
 583         self.xfail_quoted_bracket("xfail")
 584
 585     def test_xfail_colon_quoted_bracket(self):
 586         self.xfail_quoted_bracket("xfail:")
 587
 588
 589 class TestTestProtocolServerAddSkip(unittest.TestCase):
 590     """Tests for the skip keyword.
 591
 592     In Python this thunks through to Success due to stdlib limitations. (See
 593     README).
 594     """
 595
 596     def setUp(self):
 597         """Setup a test object ready to be skipped."""
 598         self.client = MockTestProtocolServerClient()
 599         self.protocol = subunit.TestProtocolServer(self.client)
 600         self.protocol.lineReceived("test mcdonalds farm\n")
 601         self.test = self.client.start_calls[-1]
 602
 603     def simple_skip_keyword(self, keyword):
 604         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 605         self.assertEqual(self.client.start_calls, [self.test])
 606         self.assertEqual(self.client.end_calls, [self.test])
 607         self.assertEqual(self.client.error_calls, [])
 608         self.assertEqual(self.client.failure_calls, [])
 609         self.assertEqual(self.client.success_calls, [self.test])
 610
 611     def test_simple_skip(self):
 612         self.simple_skip_keyword("skip")
 613
 614     def test_simple_skip_colon(self):
 615         self.simple_skip_keyword("skip:")
 616
 617     def test_skip_empty_message(self):
 618         self.protocol.lineReceived("skip mcdonalds farm [\n")
 619         self.protocol.lineReceived("]\n")
 620         self.assertEqual(self.client.start_calls, [self.test])
 621         self.assertEqual(self.client.end_calls, [self.test])
 622         self.assertEqual(self.client.error_calls, [])
 623         self.assertEqual(self.client.failure_calls, [])
 624         self.assertEqual(self.client.success_calls, [self.test])
 625
 626     def skip_quoted_bracket(self, keyword):
 627         # This tests it is accepted, but cannot test it is used today, because
 628         # of not having a way to expose it in Python so far.
 629         self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
 630         self.protocol.lineReceived(" ]\n")
 631         self.protocol.lineReceived("]\n")
 632         self.assertEqual(self.client.start_calls, [self.test])
 633         self.assertEqual(self.client.end_calls, [self.test])
 634         self.assertEqual(self.client.error_calls, [])
 635         self.assertEqual(self.client.failure_calls, [])
 636         self.assertEqual(self.client.success_calls, [self.test])
 637
 638     def test_skip_quoted_bracket(self):
 639         self.skip_quoted_bracket("skip")
 640
 641     def test_skip_colon_quoted_bracket(self):
 642         self.skip_quoted_bracket("skip:")
 643
 644
 645 class TestTestProtocolServerAddSuccess(unittest.TestCase):
 646
 647     def setUp(self):
 648         self.client = MockTestProtocolServerClient()
 649         self.protocol = subunit.TestProtocolServer(self.client)
 650         self.protocol.lineReceived("test mcdonalds farm\n")
 651         self.test = subunit.RemotedTestCase("mcdonalds farm")
 652
 653     def simple_success_keyword(self, keyword):
 654         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
 655         self.assertEqual(self.client.start_calls, [self.test])
 656         self.assertEqual(self.client.end_calls, [self.test])
 657         self.assertEqual(self.client.error_calls, [])
 658         self.assertEqual(self.client.success_calls, [self.test])
 659
 660     def test_simple_success(self):
 661         self.simple_success_keyword("failure")
 662
 663     def test_simple_success_colon(self):
 664         self.simple_success_keyword("failure:")
 665
 666     def test_simple_success(self):
 667         self.simple_success_keyword("successful")
 668
 669     def test_simple_success_colon(self):
 670         self.simple_success_keyword("successful:")
 671
 672     def test_success_empty_message(self):
 673         self.protocol.lineReceived("success mcdonalds farm [\n")
 674         self.protocol.lineReceived("]\n")
 675         self.assertEqual(self.client.start_calls, [self.test])
 676         self.assertEqual(self.client.end_calls, [self.test])
 677         self.assertEqual(self.client.error_calls, [])
 678         self.assertEqual(self.client.failure_calls, [])
 679         self.assertEqual(self.client.success_calls, [self.test])
 680
 681     def success_quoted_bracket(self, keyword):
 682         # This tests it is accepted, but cannot test it is used today, because
 683         # of not having a way to expose it in Python so far.
 684         self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
 685         self.protocol.lineReceived(" ]\n")
 686         self.protocol.lineReceived("]\n")
 687         self.assertEqual(self.client.start_calls, [self.test])
 688         self.assertEqual(self.client.end_calls, [self.test])
 689         self.assertEqual(self.client.error_calls, [])
 690         self.assertEqual(self.client.failure_calls, [])
 691         self.assertEqual(self.client.success_calls, [self.test])
 692
 693     def test_success_quoted_bracket(self):
 694         self.success_quoted_bracket("success")
 695
 696     def test_success_colon_quoted_bracket(self):
 697         self.success_quoted_bracket("success:")
 698
 699
 700 class TestTestProtocolServerStreamTags(unittest.TestCase):
 701     """Test managing tags on the protocol level."""
 702
 703     def setUp(self):
 704         self.client = MockTestProtocolServerClient()
 705         self.protocol = subunit.TestProtocolServer(self.client)
 706
 707     def test_initial_tags(self):
 708         self.protocol.lineReceived("tags: foo bar:baz  quux\n")
 709         self.assertEqual(set(["foo", "bar:baz", "quux"]),
 710             self.protocol.tags)
 711
 712     def test_minus_removes_tags(self):
 713         self.protocol.lineReceived("tags: foo bar\n")
 714         self.protocol.lineReceived("tags: -bar quux\n")
 715         self.assertEqual(set(["foo", "quux"]),
 716             self.protocol.tags)
 717
 718     def test_tags_get_set_on_test_no_tags(self):
 719         self.protocol.lineReceived("test mcdonalds farm\n")
 720         test = self.client.start_calls[-1]
 721         self.assertEqual(set(), test.tags)
 722
 723     def test_tags_get_set_on_test_protocol_tags_only(self):
 724         self.protocol.lineReceived("tags: foo bar\n")
 725         self.protocol.lineReceived("test mcdonalds farm\n")
 726         test = self.client.start_calls[-1]
 727         self.assertEqual(set(["foo", "bar"]), test.tags)
 728
 729     def test_tags_get_set_on_test_simple(self):
 730         self.protocol.lineReceived("test mcdonalds farm\n")
 731         test = self.client.start_calls[-1]
 732         self.protocol.lineReceived("tags: foo bar\n")
 733         self.assertEqual(set(["foo", "bar"]), test.tags)
 734         self.assertEqual(set(), self.protocol.tags)
 735
 736     def test_tags_get_set_on_test_minus_removes(self):
 737         self.protocol.lineReceived("test mcdonalds farm\n")
 738         test = self.client.start_calls[-1]
 739         self.protocol.lineReceived("tags: foo bar\n")
 740         self.protocol.lineReceived("tags: -bar quux\n")
 741         self.assertEqual(set(["foo", "quux"]), test.tags)
 742         self.assertEqual(set(), self.protocol.tags)
 743
 744     def test_test_tags_inherit_protocol_tags(self):
 745         self.protocol.lineReceived("tags: foo bar\n")
 746         self.protocol.lineReceived("test mcdonalds farm\n")
 747         test = self.client.start_calls[-1]
 748         self.protocol.lineReceived("tags: -bar quux\n")
 749         self.assertEqual(set(["foo", "quux"]), test.tags)
 750         self.assertEqual(set(["foo", "bar"]), self.protocol.tags)
 751
 752
 753 class TestTestProtocolServerStreamTime(unittest.TestCase):
 754     """Test managing time information at the protocol level."""
 755
 756     def setUp(self):
 757         self.client = MockTestProtocolServerClient()
 758         self.stream = StringIO()
 759         self.protocol = subunit.TestProtocolServer(self.client,
 760             stream=self.stream)
 761
 762     def test_time_accepted(self):
 763         self.protocol.lineReceived("time: 2001-12-12 12:59:59Z\n")
 764         self.assertEqual("", self.stream.getvalue())
 765
 766
 767 class TestRemotedTestCase(unittest.TestCase):
 768
 769     def test_simple(self):
 770         test = subunit.RemotedTestCase("A test description")
 771         self.assertRaises(NotImplementedError, test.setUp)
 772         self.assertRaises(NotImplementedError, test.tearDown)
 773         self.assertEqual("A test description",
 774                          test.shortDescription())
 775         self.assertEqual("subunit.RemotedTestCase.A test description",
 776                          test.id())
 777         self.assertEqual("A test description (subunit.RemotedTestCase)", "%s" % test)
 778         self.assertEqual("<subunit.RemotedTestCase description="
 779                          "'A test description'>", "%r" % test)
 780         result = unittest.TestResult()
 781         test.run(result)
 782         self.assertEqual([(test, "RemoteException: "
 783                                  "Cannot run RemotedTestCases.\n\n")],
 784                          result.errors)
 785         self.assertEqual(1, result.testsRun)
 786         another_test = subunit.RemotedTestCase("A test description")
 787         self.assertEqual(test, another_test)
 788         different_test = subunit.RemotedTestCase("ofo")
 789         self.assertNotEqual(test, different_test)
 790         self.assertNotEqual(another_test, different_test)
 791
 792
 793 class TestRemoteError(unittest.TestCase):
 794
 795     def test_eq(self):
 796         error = subunit.RemoteError("Something went wrong")
 797         another_error = subunit.RemoteError("Something went wrong")
 798         different_error = subunit.RemoteError("boo!")
 799         self.assertEqual(error, another_error)
 800         self.assertNotEqual(error, different_error)
 801         self.assertNotEqual(different_error, another_error)
 802
 803     def test_empty_constructor(self):
 804         self.assertEqual(subunit.RemoteError(), subunit.RemoteError(""))
 805
 806
 807 class TestExecTestCase(unittest.TestCase):
 808
 809     class SampleExecTestCase(subunit.ExecTestCase):
 810
 811         def test_sample_method(self):
 812             """sample-script.py"""
 813             # the sample script runs three tests, one each
 814             # that fails, errors and succeeds
 815
 816
 817     def test_construct(self):
 818         test = self.SampleExecTestCase("test_sample_method")
 819         self.assertEqual(test.script,
 820                          subunit.join_dir(__file__, 'sample-script.py'))
 821
 822     def test_run(self):
 823         runner = MockTestProtocolServerClient()
 824         test = self.SampleExecTestCase("test_sample_method")
 825         test.run(runner)
 826         mcdonald = subunit.RemotedTestCase("old mcdonald")
 827         bing = subunit.RemotedTestCase("bing crosby")
 828         an_error = subunit.RemotedTestCase("an error")
 829         self.assertEqual(runner.error_calls,
 830                          [(an_error, subunit.RemoteError())])
 831         self.assertEqual(runner.failure_calls,
 832                          [(bing,
 833                            subunit.RemoteError(
 834                             "foo.c:53:ERROR invalid state\n"))])
 835         self.assertEqual(runner.start_calls, [mcdonald, bing, an_error])
 836         self.assertEqual(runner.end_calls, [mcdonald, bing, an_error])
 837
 838     def test_debug(self):
 839         test = self.SampleExecTestCase("test_sample_method")
 840         test.debug()
 841
 842     def test_count_test_cases(self):
 843         """TODO run the child process and count responses to determine the count."""
 844
 845     def test_join_dir(self):
 846         sibling = subunit.join_dir(__file__, 'foo')
 847         expected = '%s/foo' % (os.path.split(__file__)[0],)
 848         self.assertEqual(sibling, expected)
 849
 850
 851 class DoExecTestCase(subunit.ExecTestCase):
 852
 853     def test_working_script(self):
 854         """sample-two-script.py"""
 855
 856
 857 class TestIsolatedTestCase(unittest.TestCase):
 858
 859     class SampleIsolatedTestCase(subunit.IsolatedTestCase):
 860
 861         SETUP = False
 862         TEARDOWN = False
 863         TEST = False
 864
 865         def setUp(self):
 866             TestIsolatedTestCase.SampleIsolatedTestCase.SETUP = True
 867
 868         def tearDown(self):
 869             TestIsolatedTestCase.SampleIsolatedTestCase.TEARDOWN = True
 870
 871         def test_sets_global_state(self):
 872             TestIsolatedTestCase.SampleIsolatedTestCase.TEST = True
 873
 874
 875     def test_construct(self):
 876         test = self.SampleIsolatedTestCase("test_sets_global_state")
 877
 878     def test_run(self):
 879         result = unittest.TestResult()
 880         test = self.SampleIsolatedTestCase("test_sets_global_state")
 881         test.run(result)
 882         self.assertEqual(result.testsRun, 1)
 883         self.assertEqual(self.SampleIsolatedTestCase.SETUP, False)
 884         self.assertEqual(self.SampleIsolatedTestCase.TEARDOWN, False)
 885         self.assertEqual(self.SampleIsolatedTestCase.TEST, False)
 886
 887     def test_debug(self):
 888         pass
 889         #test = self.SampleExecTestCase("test_sample_method")
 890         #test.debug()
 891
 892
 893 class TestIsolatedTestSuite(unittest.TestCase):
 894
 895     class SampleTestToIsolate(unittest.TestCase):
 896
 897         SETUP = False
 898         TEARDOWN = False
 899         TEST = False
 900
 901         def setUp(self):
 902             TestIsolatedTestSuite.SampleTestToIsolate.SETUP = True
 903
 904         def tearDown(self):
 905             TestIsolatedTestSuite.SampleTestToIsolate.TEARDOWN = True
 906
 907         def test_sets_global_state(self):
 908             TestIsolatedTestSuite.SampleTestToIsolate.TEST = True
 909
 910
 911     def test_construct(self):
 912         suite = subunit.IsolatedTestSuite()
 913
 914     def test_run(self):
 915         result = unittest.TestResult()
 916         suite = subunit.IsolatedTestSuite()
 917         sub_suite = unittest.TestSuite()
 918         sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
 919         sub_suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
 920         suite.addTest(sub_suite)
 921         suite.addTest(self.SampleTestToIsolate("test_sets_global_state"))
 922         suite.run(result)
 923         self.assertEqual(result.testsRun, 3)
 924         self.assertEqual(self.SampleTestToIsolate.SETUP, False)
 925         self.assertEqual(self.SampleTestToIsolate.TEARDOWN, False)
 926         self.assertEqual(self.SampleTestToIsolate.TEST, False)
 927
 928
 929 class TestTestProtocolClient(unittest.TestCase):
 930
 931     def setUp(self):
 932         self.io = StringIO()
 933         self.protocol = subunit.TestProtocolClient(self.io)
 934         self.test = TestTestProtocolClient("test_start_test")
 935
 936
 937     def test_start_test(self):
 938         """Test startTest on a TestProtocolClient."""
 939         self.protocol.startTest(self.test)
 940         self.assertEqual(self.io.getvalue(), "test: %s\n" % self.test.id())
 941
 942     def test_stop_test(self):
 943         """Test stopTest on a TestProtocolClient."""
 944         self.protocol.stopTest(self.test)
 945         self.assertEqual(self.io.getvalue(), "")
 946
 947     def test_add_success(self):
 948         """Test addSuccess on a TestProtocolClient."""
 949         self.protocol.addSuccess(self.test)
 950         self.assertEqual(
 951             self.io.getvalue(), "successful: %s\n" % self.test.id())
 952
 953     def test_add_failure(self):
 954         """Test addFailure on a TestProtocolClient."""
 955         self.protocol.addFailure(
 956             self.test, subunit.RemoteError("boo qux"))
 957         self.assertEqual(
 958             self.io.getvalue(),
 959             'failure: %s [\nRemoteException: boo qux\n]\n' % self.test.id())
 960
 961     def test_add_error(self):
 962         """Test stopTest on a TestProtocolClient."""
 963         self.protocol.addError(
 964             self.test, subunit.RemoteError("phwoar crikey"))
 965         self.assertEqual(
 966             self.io.getvalue(),
 967             'error: %s [\n'
 968             "RemoteException: phwoar crikey\n"
 969             "]\n" % self.test.id())
 970
 971
 972 def test_suite():
 973     loader = subunit.tests.TestUtil.TestLoader()
 974     result = loader.loadTestsFromName(__name__)
 975     return result