← Back to branch summary

~ubuntu-branches/debian/sid/subunit/sid

« back to all changes in this revision

Viewing changes to python/subunit/tests/test_test_results.py

  • Committer: Package Import Robot
  • Author(s): Jelmer Vernooij
  • Date: 2012-04-08 21:44:01 UTC
  • mfrom: (1.1.7)
  • Revision ID: package-import@ubuntu.com-20120408214401-7uyuh0zhx7lvpp7j
Tags: 0.0.7+bzr162-1
http://bugs.debian.org/669491
https://launchpad.net/bugs/893620
* New upstream snapshot.
 + Fixes compatibility with current versions of testtools. Closes: #669491
* Support installation for multiple python versions.
* Include egg-info for python-subunit. LP: #893620
* Add python3-subunit package.
* Bump standards version to 3.9.3 (no changes).
* Use machine parseable format for copyright file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
python/subunit/tests/test_test_results.py
14
14
#  limitations under that license.
15
15
#
16
16
 
 
17
import csv
17
18
import datetime
 
19
import sys
18
20
import unittest
19
21
 
20
22
from testtools import TestCase
 
23
from testtools.compat import StringIO
 
24
from testtools.content import (
 
25
    text_content,
 
26
    TracebackContent,
 
27
    )
21
28
from testtools.testresult.doubles import ExtendedTestResult
22
29
 
23
30
import subunit
24
31
import subunit.iso8601 as iso8601
25
32
import subunit.test_results
26
33
 
 
34
import testtools
 
35
 
27
36
 
28
37
class LoggingDecorator(subunit.test_results.HookedTestResultDecorator):
29
38
 
294
303
             ('stopTest', foo)], result._events)
295
304
 
296
305
 
 
306
class TestByTestResultTests(testtools.TestCase):
 
307
 
 
308
    def setUp(self):
 
309
        super(TestByTestResultTests, self).setUp()
 
310
        self.log = []
 
311
        self.result = subunit.test_results.TestByTestResult(self.on_test)
 
312
        self.result._now = iter(range(5)).next
 
313
 
 
314
    def assertCalled(self, **kwargs):
 
315
        defaults = {
 
316
            'test': self,
 
317
            'tags': set(),
 
318
            'details': None,
 
319
            'start_time': 0,
 
320
            'stop_time': 1,
 
321
            }
 
322
        defaults.update(kwargs)
 
323
        self.assertEqual([defaults], self.log)
 
324
 
 
325
    def on_test(self, **kwargs):
 
326
        self.log.append(kwargs)
 
327
 
 
328
    def test_no_tests_nothing_reported(self):
 
329
        self.result.startTestRun()
 
330
        self.result.stopTestRun()
 
331
        self.assertEqual([], self.log)
 
332
 
 
333
    def test_add_success(self):
 
334
        self.result.startTest(self)
 
335
        self.result.addSuccess(self)
 
336
        self.result.stopTest(self)
 
337
        self.assertCalled(status='success')
 
338
 
 
339
    def test_add_success_details(self):
 
340
        self.result.startTest(self)
 
341
        details = {'foo': 'bar'}
 
342
        self.result.addSuccess(self, details=details)
 
343
        self.result.stopTest(self)
 
344
        self.assertCalled(status='success', details=details)
 
345
 
 
346
    def test_tags(self):
 
347
        if not getattr(self.result, 'tags', None):
 
348
            self.skipTest("No tags in testtools")
 
349
        self.result.tags(['foo'], [])
 
350
        self.result.startTest(self)
 
351
        self.result.addSuccess(self)
 
352
        self.result.stopTest(self)
 
353
        self.assertCalled(status='success', tags=set(['foo']))
 
354
 
 
355
    def test_add_error(self):
 
356
        self.result.startTest(self)
 
357
        try:
 
358
            1/0
 
359
        except ZeroDivisionError:
 
360
            error = sys.exc_info()
 
361
        self.result.addError(self, error)
 
362
        self.result.stopTest(self)
 
363
        self.assertCalled(
 
364
            status='error',
 
365
            details={'traceback': TracebackContent(error, self)})
 
366
 
 
367
    def test_add_error_details(self):
 
368
        self.result.startTest(self)
 
369
        details = {"foo": text_content("bar")}
 
370
        self.result.addError(self, details=details)
 
371
        self.result.stopTest(self)
 
372
        self.assertCalled(status='error', details=details)
 
373
 
 
374
    def test_add_failure(self):
 
375
        self.result.startTest(self)
 
376
        try:
 
377
            self.fail("intentional failure")
 
378
        except self.failureException:
 
379
            failure = sys.exc_info()
 
380
        self.result.addFailure(self, failure)
 
381
        self.result.stopTest(self)
 
382
        self.assertCalled(
 
383
            status='failure',
 
384
            details={'traceback': TracebackContent(failure, self)})
 
385
 
 
386
    def test_add_failure_details(self):
 
387
        self.result.startTest(self)
 
388
        details = {"foo": text_content("bar")}
 
389
        self.result.addFailure(self, details=details)
 
390
        self.result.stopTest(self)
 
391
        self.assertCalled(status='failure', details=details)
 
392
 
 
393
    def test_add_xfail(self):
 
394
        self.result.startTest(self)
 
395
        try:
 
396
            1/0
 
397
        except ZeroDivisionError:
 
398
            error = sys.exc_info()
 
399
        self.result.addExpectedFailure(self, error)
 
400
        self.result.stopTest(self)
 
401
        self.assertCalled(
 
402
            status='xfail',
 
403
            details={'traceback': TracebackContent(error, self)})
 
404
 
 
405
    def test_add_xfail_details(self):
 
406
        self.result.startTest(self)
 
407
        details = {"foo": text_content("bar")}
 
408
        self.result.addExpectedFailure(self, details=details)
 
409
        self.result.stopTest(self)
 
410
        self.assertCalled(status='xfail', details=details)
 
411
 
 
412
    def test_add_unexpected_success(self):
 
413
        self.result.startTest(self)
 
414
        details = {'foo': 'bar'}
 
415
        self.result.addUnexpectedSuccess(self, details=details)
 
416
        self.result.stopTest(self)
 
417
        self.assertCalled(status='success', details=details)
 
418
 
 
419
    def test_add_skip_reason(self):
 
420
        self.result.startTest(self)
 
421
        reason = self.getUniqueString()
 
422
        self.result.addSkip(self, reason)
 
423
        self.result.stopTest(self)
 
424
        self.assertCalled(
 
425
            status='skip', details={'reason': text_content(reason)})
 
426
 
 
427
    def test_add_skip_details(self):
 
428
        self.result.startTest(self)
 
429
        details = {'foo': 'bar'}
 
430
        self.result.addSkip(self, details=details)
 
431
        self.result.stopTest(self)
 
432
        self.assertCalled(status='skip', details=details)
 
433
 
 
434
    def test_twice(self):
 
435
        self.result.startTest(self)
 
436
        self.result.addSuccess(self, details={'foo': 'bar'})
 
437
        self.result.stopTest(self)
 
438
        self.result.startTest(self)
 
439
        self.result.addSuccess(self)
 
440
        self.result.stopTest(self)
 
441
        self.assertEqual(
 
442
            [{'test': self,
 
443
              'status': 'success',
 
444
              'start_time': 0,
 
445
              'stop_time': 1,
 
446
              'tags': set(),
 
447
              'details': {'foo': 'bar'}},
 
448
             {'test': self,
 
449
              'status': 'success',
 
450
              'start_time': 2,
 
451
              'stop_time': 3,
 
452
              'tags': set(),
 
453
              'details': None},
 
454
             ],
 
455
            self.log)
 
456
 
 
457
 
 
458
class TestCsvResult(testtools.TestCase):
 
459
 
 
460
    def parse_stream(self, stream):
 
461
        stream.seek(0)
 
462
        reader = csv.reader(stream)
 
463
        return list(reader)
 
464
 
 
465
    def test_csv_output(self):
 
466
        stream = StringIO()
 
467
        result = subunit.test_results.CsvResult(stream)
 
468
        result._now = iter(range(5)).next
 
469
        result.startTestRun()
 
470
        result.startTest(self)
 
471
        result.addSuccess(self)
 
472
        result.stopTest(self)
 
473
        result.stopTestRun()
 
474
        self.assertEqual(
 
475
            [['test', 'status', 'start_time', 'stop_time'],
 
476
             [self.id(), 'success', '0', '1'],
 
477
             ],
 
478
            self.parse_stream(stream))
 
479
 
 
480
    def test_just_header_when_no_tests(self):
 
481
        stream = StringIO()
 
482
        result = subunit.test_results.CsvResult(stream)
 
483
        result.startTestRun()
 
484
        result.stopTestRun()
 
485
        self.assertEqual(
 
486
            [['test', 'status', 'start_time', 'stop_time']],
 
487
            self.parse_stream(stream))
 
488
 
 
489
    def test_no_output_before_events(self):
 
490
        stream = StringIO()
 
491
        subunit.test_results.CsvResult(stream)
 
492
        self.assertEqual([], self.parse_stream(stream))
 
493
 
 
494
 
297
495
def test_suite():
298
496
    loader = subunit.tests.TestUtil.TestLoader()
299
497
    result = loader.loadTestsFromName(__name__)