Rename TestWithScenarios as MixableTestWithScenarios

Define new class TestWithScenarios, which mixes MixableTestWithScenarios with unittest.TestCase

If unittest2 is importable when running tests, a new class which mixes MixableTestWithScenarios with unittest2.TestCase is created and exercised.

3 files changed, 141 insertions, 4 deletions

diff --git a/lib/testscenarios/__init__.py b/lib/testscenarios/__init__.py
index c501525..c1f4c0f 100644
--- a/lib/testscenarios/__init__.py
+++ b/lib/testscenarios/__init__.py
@@ -42,6 +42,7 @@ __version__ = (0, 2, 0, 'final', 0)
 
 __all__ = [
     'TestWithScenarios',
+    'MixableTestWithScenarios',
     'apply_scenario',
     'apply_scenarios',
     'generate_scenarios',
@@ -58,7 +59,7 @@ from testscenarios.scenarios import (
     load_tests_apply_scenarios,
     multiply_scenarios,
     )
-from testscenarios.testcase import TestWithScenarios
+from testscenarios.testcase import TestWithScenarios, MixableTestWithScenarios
 
 
 def test_suite():
diff --git a/lib/testscenarios/testcase.py b/lib/testscenarios/testcase.py
index 5ec3a94..33c6f9e 100644
--- a/lib/testscenarios/testcase.py
+++ b/lib/testscenarios/testcase.py
@@ -24,7 +24,7 @@ from testtools.testcase import clone_test_with_new_id
 
 from testscenarios.scenarios import generate_scenarios
 
-class TestWithScenarios(unittest.TestCase):
+class MixableTestWithScenarios(object):
     """A TestCase with support for scenarios via a scenarios attribute.
     
     When a test object which is an instance of TestWithScenarios is run,
@@ -50,7 +50,7 @@ class TestWithScenarios(unittest.TestCase):
             for test in generate_scenarios(self):
                 test.debug()
         else:
-            return super(TestWithScenarios, self).debug()
+            return super(MixableTestWithScenarios, self).debug()
 
     def run(self, result=None):
         scenarios = self._get_scenarios()
@@ -59,4 +59,7 @@ class TestWithScenarios(unittest.TestCase):
                 test.run(result)
             return
         else:
-            return super(TestWithScenarios, self).run(result)
+            return super(MixableTestWithScenarios, self).run(result)
+
+class TestWithScenarios(MixableTestWithScenarios, unittest.TestCase):
+    pass
diff --git a/lib/testscenarios/tests/test_testcase.py b/lib/testscenarios/tests/test_testcase.py
index 6a9bbf9..867f34a 100644
--- a/lib/testscenarios/tests/test_testcase.py
+++ b/lib/testscenarios/tests/test_testcase.py
@@ -143,3 +143,136 @@ class TestTestWithScenarios(unittest.TestCase):
         self.assertEqual(None, log[0].scenarios)
         self.assertEqual(None, log[1].scenarios)
         self.assertNotEqual(log[0].id(), log[1].id())
+
+try:
+    import unittest2
+    class TestWithScenariosWithUnittest2(testscenarios.MixableTestWithScenarios, unittest2.TestCase):
+        pass
+
+    class TestTestWithScenariosWithInittest2(unittest.TestCase):
+
+        def test_no_scenarios_no_error(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                def test_pass(self):
+                    pass
+            test = ReferenceTest("test_pass")
+            result = unittest.TestResult()
+            test.run(result)
+            self.assertTrue(result.wasSuccessful())
+            self.assertEqual(1, result.testsRun)
+
+        def test_with_one_scenario_one_run(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = [('demo', {})]
+                def test_pass(self):
+                    pass
+            test = ReferenceTest("test_pass")
+            log = []
+            result = LoggingResult(log)
+            test.run(result)
+            self.assertTrue(result.wasSuccessful())
+            self.assertEqual(1, result.testsRun)
+            self.assertEqual(
+                'testscenarios.tests.test_testcase.ReferenceTest.test_pass(demo)',
+                log[0][1].id())
+
+        def test_with_two_scenarios_two_run(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = [('1', {}), ('2', {})]
+                def test_pass(self):
+                    pass
+            test = ReferenceTest("test_pass")
+            log = []
+            result = LoggingResult(log)
+            test.run(result)
+            self.assertTrue(result.wasSuccessful())
+            self.assertEqual(2, result.testsRun)
+            self.assertEqual(
+                'testscenarios.tests.test_testcase.ReferenceTest.test_pass(1)',
+                log[0][1].id())
+            self.assertEqual(
+                'testscenarios.tests.test_testcase.ReferenceTest.test_pass(2)',
+                log[4][1].id())
+
+        def test_attributes_set(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = [
+                    ('1', {'foo': 1, 'bar': 2}),
+                    ('2', {'foo': 2, 'bar': 4})]
+                def test_check_foo(self):
+                    self.assertEqual(self.foo * 2, self.bar)
+            test = ReferenceTest("test_check_foo")
+            log = []
+            result = LoggingResult(log)
+            test.run(result)
+            self.assertTrue(result.wasSuccessful())
+            self.assertEqual(2, result.testsRun)
+
+        def test_scenarios_attribute_cleared(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = [
+                    ('1', {'foo': 1, 'bar': 2}),
+                    ('2', {'foo': 2, 'bar': 4})]
+                def test_check_foo(self):
+                    self.assertEqual(self.foo * 2, self.bar)
+            test = ReferenceTest("test_check_foo")
+            log = []
+            result = LoggingResult(log)
+            test.run(result)
+            self.assertTrue(result.wasSuccessful())
+            self.assertEqual(2, result.testsRun)
+            self.assertNotEqual(None, test.scenarios)
+            self.assertEqual(None, log[0][1].scenarios)
+            self.assertEqual(None, log[4][1].scenarios)
+
+        def test_countTestCases_no_scenarios(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                def test_check_foo(self):
+                    pass
+            test = ReferenceTest("test_check_foo")
+            self.assertEqual(1, test.countTestCases())
+
+        def test_countTestCases_empty_scenarios(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = []
+                def test_check_foo(self):
+                    pass
+            test = ReferenceTest("test_check_foo")
+            self.assertEqual(1, test.countTestCases())
+
+        def test_countTestCases_1_scenarios(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = [('1', {'foo': 1, 'bar': 2})]
+                def test_check_foo(self):
+                    pass
+            test = ReferenceTest("test_check_foo")
+            self.assertEqual(1, test.countTestCases())
+
+        def test_countTestCases_2_scenarios(self):
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = [
+                    ('1', {'foo': 1, 'bar': 2}),
+                    ('2', {'foo': 2, 'bar': 4})]
+                def test_check_foo(self):
+                    pass
+            test = ReferenceTest("test_check_foo")
+            self.assertEqual(2, test.countTestCases())
+
+        def test_debug_2_scenarios(self):
+            log = []
+            class ReferenceTest(TestWithScenariosWithUnittest2):
+                scenarios = [
+                    ('1', {'foo': 1, 'bar': 2}),
+                    ('2', {'foo': 2, 'bar': 4})]
+                def test_check_foo(self):
+                    log.append(self)
+            test = ReferenceTest("test_check_foo")
+            test.debug()
+            self.assertEqual(2, len(log))
+            self.assertEqual(None, log[0].scenarios)
+            self.assertEqual(None, log[1].scenarios)
+            self.assertNotEqual(log[0].id(), log[1].id())
+
+
+except ImportError:
+    pass