

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: test_setups.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>import sys

from cStringIO import StringIO

import unittest


def resultFactory(*_):
    return unittest.TestResult()


class TestSetups(unittest.TestCase):

    def getRunner(self):
        return unittest.TextTestRunner(resultclass=resultFactory,
                                          stream=StringIO())
    def runTests(self, *cases):
        suite = unittest.TestSuite()
        for case in cases:
            tests = unittest.defaultTestLoader.loadTestsFromTestCase(case)
            suite.addTests(tests)

        runner = self.getRunner()

        # creating a nested suite exposes some potential bugs
        realSuite = unittest.TestSuite()
        realSuite.addTest(suite)
        # adding empty suites to the end exposes potential bugs
        suite.addTest(unittest.TestSuite())
        realSuite.addTest(unittest.TestSuite())
        return runner.run(realSuite)

    def test_setup_class(self):
        class Test(unittest.TestCase):
            setUpCalled = 0
            @classmethod
            def setUpClass(cls):
                Test.setUpCalled += 1
                unittest.TestCase.setUpClass()
            def test_one(self):
                pass
            def test_two(self):
                pass

        result = self.runTests(Test)

        self.assertEqual(Test.setUpCalled, 1)
        self.assertEqual(result.testsRun, 2)
        self.assertEqual(len(result.errors), 0)

    def test_teardown_class(self):
        class Test(unittest.TestCase):
            tearDownCalled = 0
            @classmethod
            def tearDownClass(cls):
                Test.tearDownCalled += 1
                unittest.TestCase.tearDownClass()
            def test_one(self):
                pass
            def test_two(self):
                pass

        result = self.runTests(Test)

        self.assertEqual(Test.tearDownCalled, 1)
        self.assertEqual(result.testsRun, 2)
        self.assertEqual(len(result.errors), 0)

    def test_teardown_class_two_classes(self):
        class Test(unittest.TestCase):
            tearDownCalled = 0
            @classmethod
            def tearDownClass(cls):
                Test.tearDownCalled += 1
                unittest.TestCase.tearDownClass()
            def test_one(self):
                pass
            def test_two(self):
                pass

        class Test2(unittest.TestCase):
            tearDownCalled = 0
            @classmethod
            def tearDownClass(cls):
                Test2.tearDownCalled += 1
                unittest.TestCase.tearDownClass()
            def test_one(self):
                pass
            def test_two(self):
                pass

        result = self.runTests(Test, Test2)

        self.assertEqual(Test.tearDownCalled, 1)
        self.assertEqual(Test2.tearDownCalled, 1)
        self.assertEqual(result.testsRun, 4)
        self.assertEqual(len(result.errors), 0)

    def test_error_in_setupclass(self):
        class BrokenTest(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                raise TypeError(&#039;foo&#039;)
            def test_one(self):
                pass
            def test_two(self):
                pass

        result = self.runTests(BrokenTest)

        self.assertEqual(result.testsRun, 0)
        self.assertEqual(len(result.errors), 1)
        error, _ = result.errors[0]
        self.assertEqual(str(error),
                    &#039;setUpClass (%s.BrokenTest)&#039; % __name__)

    def test_error_in_teardown_class(self):
        class Test(unittest.TestCase):
            tornDown = 0
            @classmethod
            def tearDownClass(cls):
                Test.tornDown += 1
                raise TypeError(&#039;foo&#039;)
            def test_one(self):
                pass
            def test_two(self):
                pass

        class Test2(unittest.TestCase):
            tornDown = 0
            @classmethod
            def tearDownClass(cls):
                Test2.tornDown += 1
                raise TypeError(&#039;foo&#039;)
            def test_one(self):
                pass
            def test_two(self):
                pass

        result = self.runTests(Test, Test2)
        self.assertEqual(result.testsRun, 4)
        self.assertEqual(len(result.errors), 2)
        self.assertEqual(Test.tornDown, 1)
        self.assertEqual(Test2.tornDown, 1)

        error, _ = result.errors[0]
        self.assertEqual(str(error),
                    &#039;tearDownClass (%s.Test)&#039; % __name__)

    def test_class_not_torndown_when_setup_fails(self):
        class Test(unittest.TestCase):
            tornDown = False
            @classmethod
            def setUpClass(cls):
                raise TypeError
            @classmethod
            def tearDownClass(cls):
                Test.tornDown = True
                raise TypeError(&#039;foo&#039;)
            def test_one(self):
                pass

        self.runTests(Test)
        self.assertFalse(Test.tornDown)

    def test_class_not_setup_or_torndown_when_skipped(self):
        class Test(unittest.TestCase):
            classSetUp = False
            tornDown = False
            @classmethod
            def setUpClass(cls):
                Test.classSetUp = True
            @classmethod
            def tearDownClass(cls):
                Test.tornDown = True
            def test_one(self):
                pass

        Test = unittest.skip(&quot;hop&quot;)(Test)
        self.runTests(Test)
        self.assertFalse(Test.classSetUp)
        self.assertFalse(Test.tornDown)

    def test_setup_teardown_order_with_pathological_suite(self):
        results = []

        class Module1(object):
            @staticmethod
            def setUpModule():
                results.append(&#039;Module1.setUpModule&#039;)
            @staticmethod
            def tearDownModule():
                results.append(&#039;Module1.tearDownModule&#039;)

        class Module2(object):
            @staticmethod
            def setUpModule():
                results.append(&#039;Module2.setUpModule&#039;)
            @staticmethod
            def tearDownModule():
                results.append(&#039;Module2.tearDownModule&#039;)

        class Test1(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                results.append(&#039;setup 1&#039;)
            @classmethod
            def tearDownClass(cls):
                results.append(&#039;teardown 1&#039;)
            def testOne(self):
                results.append(&#039;Test1.testOne&#039;)
            def testTwo(self):
                results.append(&#039;Test1.testTwo&#039;)

        class Test2(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                results.append(&#039;setup 2&#039;)
            @classmethod
            def tearDownClass(cls):
                results.append(&#039;teardown 2&#039;)
            def testOne(self):
                results.append(&#039;Test2.testOne&#039;)
            def testTwo(self):
                results.append(&#039;Test2.testTwo&#039;)

        class Test3(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                results.append(&#039;setup 3&#039;)
            @classmethod
            def tearDownClass(cls):
                results.append(&#039;teardown 3&#039;)
            def testOne(self):
                results.append(&#039;Test3.testOne&#039;)
            def testTwo(self):
                results.append(&#039;Test3.testTwo&#039;)

        Test1.__module__ = Test2.__module__ = &#039;Module&#039;
        Test3.__module__ = &#039;Module2&#039;
        sys.modules[&#039;Module&#039;] = Module1
        sys.modules[&#039;Module2&#039;] = Module2

        first = unittest.TestSuite((Test1(&#039;testOne&#039;),))
        second = unittest.TestSuite((Test1(&#039;testTwo&#039;),))
        third = unittest.TestSuite((Test2(&#039;testOne&#039;),))
        fourth = unittest.TestSuite((Test2(&#039;testTwo&#039;),))
        fifth = unittest.TestSuite((Test3(&#039;testOne&#039;),))
        sixth = unittest.TestSuite((Test3(&#039;testTwo&#039;),))
        suite = unittest.TestSuite((first, second, third, fourth, fifth, sixth))

        runner = self.getRunner()
        result = runner.run(suite)
        self.assertEqual(result.testsRun, 6)
        self.assertEqual(len(result.errors), 0)

        self.assertEqual(results,
                         [&#039;Module1.setUpModule&#039;, &#039;setup 1&#039;,
                          &#039;Test1.testOne&#039;, &#039;Test1.testTwo&#039;, &#039;teardown 1&#039;,
                          &#039;setup 2&#039;, &#039;Test2.testOne&#039;, &#039;Test2.testTwo&#039;,
                          &#039;teardown 2&#039;, &#039;Module1.tearDownModule&#039;,
                          &#039;Module2.setUpModule&#039;, &#039;setup 3&#039;,
                          &#039;Test3.testOne&#039;, &#039;Test3.testTwo&#039;,
                          &#039;teardown 3&#039;, &#039;Module2.tearDownModule&#039;])

    def test_setup_module(self):
        class Module(object):
            moduleSetup = 0
            @staticmethod
            def setUpModule():
                Module.moduleSetup += 1

        class Test(unittest.TestCase):
            def test_one(self):
                pass
            def test_two(self):
                pass
        Test.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module

        result = self.runTests(Test)
        self.assertEqual(Module.moduleSetup, 1)
        self.assertEqual(result.testsRun, 2)
        self.assertEqual(len(result.errors), 0)

    def test_error_in_setup_module(self):
        class Module(object):
            moduleSetup = 0
            moduleTornDown = 0
            @staticmethod
            def setUpModule():
                Module.moduleSetup += 1
                raise TypeError(&#039;foo&#039;)
            @staticmethod
            def tearDownModule():
                Module.moduleTornDown += 1

        class Test(unittest.TestCase):
            classSetUp = False
            classTornDown = False
            @classmethod
            def setUpClass(cls):
                Test.classSetUp = True
            @classmethod
            def tearDownClass(cls):
                Test.classTornDown = True
            def test_one(self):
                pass
            def test_two(self):
                pass

        class Test2(unittest.TestCase):
            def test_one(self):
                pass
            def test_two(self):
                pass
        Test.__module__ = &#039;Module&#039;
        Test2.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module

        result = self.runTests(Test, Test2)
        self.assertEqual(Module.moduleSetup, 1)
        self.assertEqual(Module.moduleTornDown, 0)
        self.assertEqual(result.testsRun, 0)
        self.assertFalse(Test.classSetUp)
        self.assertFalse(Test.classTornDown)
        self.assertEqual(len(result.errors), 1)
        error, _ = result.errors[0]
        self.assertEqual(str(error), &#039;setUpModule (Module)&#039;)

    def test_testcase_with_missing_module(self):
        class Test(unittest.TestCase):
            def test_one(self):
                pass
            def test_two(self):
                pass
        Test.__module__ = &#039;Module&#039;
        sys.modules.pop(&#039;Module&#039;, None)

        result = self.runTests(Test)
        self.assertEqual(result.testsRun, 2)

    def test_teardown_module(self):
        class Module(object):
            moduleTornDown = 0
            @staticmethod
            def tearDownModule():
                Module.moduleTornDown += 1

        class Test(unittest.TestCase):
            def test_one(self):
                pass
            def test_two(self):
                pass
        Test.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module

        result = self.runTests(Test)
        self.assertEqual(Module.moduleTornDown, 1)
        self.assertEqual(result.testsRun, 2)
        self.assertEqual(len(result.errors), 0)

    def test_error_in_teardown_module(self):
        class Module(object):
            moduleTornDown = 0
            @staticmethod
            def tearDownModule():
                Module.moduleTornDown += 1
                raise TypeError(&#039;foo&#039;)

        class Test(unittest.TestCase):
            classSetUp = False
            classTornDown = False
            @classmethod
            def setUpClass(cls):
                Test.classSetUp = True
            @classmethod
            def tearDownClass(cls):
                Test.classTornDown = True
            def test_one(self):
                pass
            def test_two(self):
                pass

        class Test2(unittest.TestCase):
            def test_one(self):
                pass
            def test_two(self):
                pass
        Test.__module__ = &#039;Module&#039;
        Test2.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module

        result = self.runTests(Test, Test2)
        self.assertEqual(Module.moduleTornDown, 1)
        self.assertEqual(result.testsRun, 4)
        self.assertTrue(Test.classSetUp)
        self.assertTrue(Test.classTornDown)
        self.assertEqual(len(result.errors), 1)
        error, _ = result.errors[0]
        self.assertEqual(str(error), &#039;tearDownModule (Module)&#039;)

    def test_skiptest_in_setupclass(self):
        class Test(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                raise unittest.SkipTest(&#039;foo&#039;)
            def test_one(self):
                pass
            def test_two(self):
                pass

        result = self.runTests(Test)
        self.assertEqual(result.testsRun, 0)
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.skipped), 1)
        skipped = result.skipped[0][0]
        self.assertEqual(str(skipped), &#039;setUpClass (%s.Test)&#039; % __name__)

    def test_skiptest_in_setupmodule(self):
        class Test(unittest.TestCase):
            def test_one(self):
                pass
            def test_two(self):
                pass

        class Module(object):
            @staticmethod
            def setUpModule():
                raise unittest.SkipTest(&#039;foo&#039;)

        Test.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module

        result = self.runTests(Test)
        self.assertEqual(result.testsRun, 0)
        self.assertEqual(len(result.errors), 0)
        self.assertEqual(len(result.skipped), 1)
        skipped = result.skipped[0][0]
        self.assertEqual(str(skipped), &#039;setUpModule (Module)&#039;)

    def test_suite_debug_executes_setups_and_teardowns(self):
        ordering = []

        class Module(object):
            @staticmethod
            def setUpModule():
                ordering.append(&#039;setUpModule&#039;)
            @staticmethod
            def tearDownModule():
                ordering.append(&#039;tearDownModule&#039;)

        class Test(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                ordering.append(&#039;setUpClass&#039;)
            @classmethod
            def tearDownClass(cls):
                ordering.append(&#039;tearDownClass&#039;)
            def test_something(self):
                ordering.append(&#039;test_something&#039;)

        Test.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module

        suite = unittest.defaultTestLoader.loadTestsFromTestCase(Test)
        suite.debug()
        expectedOrder = [&#039;setUpModule&#039;, &#039;setUpClass&#039;, &#039;test_something&#039;, &#039;tearDownClass&#039;, &#039;tearDownModule&#039;]
        self.assertEqual(ordering, expectedOrder)

    def test_suite_debug_propagates_exceptions(self):
        class Module(object):
            @staticmethod
            def setUpModule():
                if phase == 0:
                    raise Exception(&#039;setUpModule&#039;)
            @staticmethod
            def tearDownModule():
                if phase == 1:
                    raise Exception(&#039;tearDownModule&#039;)

        class Test(unittest.TestCase):
            @classmethod
            def setUpClass(cls):
                if phase == 2:
                    raise Exception(&#039;setUpClass&#039;)
            @classmethod
            def tearDownClass(cls):
                if phase == 3:
                    raise Exception(&#039;tearDownClass&#039;)
            def test_something(self):
                if phase == 4:
                    raise Exception(&#039;test_something&#039;)

        Test.__module__ = &#039;Module&#039;
        sys.modules[&#039;Module&#039;] = Module

        _suite = unittest.defaultTestLoader.loadTestsFromTestCase(Test)
        suite = unittest.TestSuite()
        suite.addTest(_suite)

        messages = (&#039;setUpModule&#039;, &#039;tearDownModule&#039;, &#039;setUpClass&#039;, &#039;tearDownClass&#039;, &#039;test_something&#039;)
        for phase, msg in enumerate(messages):
            with self.assertRaisesRegexp(Exception, msg):
                suite.debug()

if __name__ == &#039;__main__&#039;:
    unittest.main()
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python2.7/unittest/test/test_setups.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython2.7%2Funittest%2Ftest' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>