Home | History | Annotate | Download | only in test 
      1 import unittest
      2 
      3 from .support import LoggingResult
      4 
      5 
      6 class Test_TestSkipping(unittest.TestCase):
      7 
      8     def test_skipping(self):
      9         class Foo(unittest.TestCase):
     10             def test_skip_me(self):
     11                 self.skipTest("skip")
     12         events = []
     13         result = LoggingResult(events)
     14         test = Foo("test_skip_me")
     15         test.run(result)
     16         self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
     17         self.assertEqual(result.skipped, [(test, "skip")])
     18 
     19         # Try letting setUp skip the test now.

     20         class Foo(unittest.TestCase):
     21             def setUp(self):
     22                 self.skipTest("testing")
     23             def test_nothing(self): pass
     24         events = []
     25         result = LoggingResult(events)
     26         test = Foo("test_nothing")
     27         test.run(result)
     28         self.assertEqual(events, ['startTest', 'addSkip', 'stopTest'])
     29         self.assertEqual(result.skipped, [(test, "testing")])
     30         self.assertEqual(result.testsRun, 1)
     31 
     32     def test_skipping_decorators(self):
     33         op_table = ((unittest.skipUnless, False, True),
     34                     (unittest.skipIf, True, False))
     35         for deco, do_skip, dont_skip in op_table:
     36             class Foo(unittest.TestCase):
     37                 @deco(do_skip, "testing")
     38                 def test_skip(self): pass
     39 
     40                 @deco(dont_skip, "testing")
     41                 def test_dont_skip(self): pass
     42             test_do_skip = Foo("test_skip")
     43             test_dont_skip = Foo("test_dont_skip")
     44             suite = unittest.TestSuite([test_do_skip, test_dont_skip])
     45             events = []
     46             result = LoggingResult(events)
     47             suite.run(result)
     48             self.assertEqual(len(result.skipped), 1)
     49             expected = ['startTest', 'addSkip', 'stopTest',
     50                         'startTest', 'addSuccess', 'stopTest']
     51             self.assertEqual(events, expected)
     52             self.assertEqual(result.testsRun, 2)
     53             self.assertEqual(result.skipped, [(test_do_skip, "testing")])
     54             self.assertTrue(result.wasSuccessful())
     55 
     56     def test_skip_class(self):
     57         @unittest.skip("testing")
     58         class Foo(unittest.TestCase):
     59             def test_1(self):
     60                 record.append(1)
     61         record = []
     62         result = unittest.TestResult()
     63         test = Foo("test_1")
     64         suite = unittest.TestSuite([test])
     65         suite.run(result)
     66         self.assertEqual(result.skipped, [(test, "testing")])
     67         self.assertEqual(record, [])
     68 
     69     def test_expected_failure(self):
     70         class Foo(unittest.TestCase):
     71             @unittest.expectedFailure
     72             def test_die(self):
     73                 self.fail("help me!")
     74         events = []
     75         result = LoggingResult(events)
     76         test = Foo("test_die")
     77         test.run(result)
     78         self.assertEqual(events,
     79                          ['startTest', 'addExpectedFailure', 'stopTest'])
     80         self.assertEqual(result.expectedFailures[0][0], test)
     81         self.assertTrue(result.wasSuccessful())
     82 
     83     def test_unexpected_success(self):
     84         class Foo(unittest.TestCase):
     85             @unittest.expectedFailure
     86             def test_die(self):
     87                 pass
     88         events = []
     89         result = LoggingResult(events)
     90         test = Foo("test_die")
     91         test.run(result)
     92         self.assertEqual(events,
     93                          ['startTest', 'addUnexpectedSuccess', 'stopTest'])
     94         self.assertFalse(result.failures)
     95         self.assertEqual(result.unexpectedSuccesses, [test])
     96         self.assertTrue(result.wasSuccessful())
     97 
     98     def test_skip_doesnt_run_setup(self):
     99         class Foo(unittest.TestCase):
    100             wasSetUp = False
    101             wasTornDown = False
    102             def setUp(self):
    103                 Foo.wasSetUp = True
    104             def tornDown(self):
    105                 Foo.wasTornDown = True
    106             @unittest.skip('testing')
    107             def test_1(self):
    108                 pass
    109 
    110         result = unittest.TestResult()
    111         test = Foo("test_1")
    112         suite = unittest.TestSuite([test])
    113         suite.run(result)
    114         self.assertEqual(result.skipped, [(test, "testing")])
    115         self.assertFalse(Foo.wasSetUp)
    116         self.assertFalse(Foo.wasTornDown)
    117 
    118     def test_decorated_skip(self):
    119         def decorator(func):
    120             def inner(*a):
    121                 return func(*a)
    122             return inner
    123 
    124         class Foo(unittest.TestCase):
    125             @decorator
    126             @unittest.skip('testing')
    127             def test_1(self):
    128                 pass
    129 
    130         result = unittest.TestResult()
    131         test = Foo("test_1")
    132         suite = unittest.TestSuite([test])
    133         suite.run(result)
    134         self.assertEqual(result.skipped, [(test, "testing")])
    135 
    136 
    137 if __name__ == '__main__':
    138     unittest.main()
    139