#!/usr/bin/env python
"""\
testSkippedTest.py   Test cases for adding skipped tests to unittest.py
Copyright (C) 2004  Remy Blank
"""

import unittest
import sys
from cStringIO import StringIO

# Dummy test cases
class SkipInTest(unittest.TestCase):
        """Tests skip in test methods"""
        def testDoesntSkip(self):
                """Doesn't skip"""
                self.assert_(True)

        def testFails(self):
                """Fails"""
                self.fail()
                
        def testSkips(self):
                """Test skips"""
                self.skip()

        def testSkipsMessage(self):
                """Test skips with a message"""
                self.skip("A message")

                
class SkipInSetUp(unittest.TestCase):
        """Tests skip in setUp()"""
        def setUp(self):
                super(SkipInSetUp, self).setUp()
                self.skip()

        def testDummy(self):
                """Never executed"""
                

# Test cases
class TestResultTest(unittest.TestCase):
        """Tests relating to TestResult"""
        def testSkippedAttribute(self):
                """List of skipped tests"""
                result = unittest.TestResult()
                self.assertEqual([], result.skipped)
                self.assertEqual("<unittest.TestResult run=0 errors=0 failures=0 skipped=0>", repr(result))

        def testAddSkipped(self):
                """TestResult.addSkipped()"""
                result = unittest.TestResult()
                test = SkipInTest("testDoesntSkip")
                try:
                        raise unittest.SkipException, "Skipped"
                except:
                        result.addSkipped(test, sys.exc_info())
                        
                self.assert_(test is result.skipped[0][0])
                self.assertEqual("Skipped", result.skipped[0][1])
                self.assertEqual("<unittest.TestResult run=0 errors=0 failures=0 skipped=1>", repr(result))


class TestCaseTest(unittest.TestCase):
        """Tests relating to TestCase"""
        def setUp(self):
                super(TestCaseTest, self).setUp()
                self.result = unittest.TestResult()
                
        def testNoSkip(self):
                """Test case that doesn't skip"""
                test = SkipInTest("testDoesntSkip")
                test(self.result)

                self.assertEqual(1, self.result.testsRun)
                self.assertEqual([], self.result.skipped)

        def testSkipInTest(self):
                """Test case that skips in test method"""
                test = SkipInTest("testSkips")
                test(self.result)

                self.assertEqual(1, self.result.testsRun)
                self.assertEqual([], self.result.failures)
                self.assertEqual([], self.result.errors)
                self.assert_(test is self.result.skipped[0][0])
                
        def testSkipInSetUp(self):
                """Test case that skips in setUp()"""
                test = SkipInSetUp("testDummy")
                test(self.result)

                self.assertEqual(1, self.result.testsRun)
                self.assertEqual([], self.result.failures)
                self.assertEqual([], self.result.errors)
                self.assert_(test is self.result.skipped[0][0])


class SkipMethodsTest(unittest.TestCase):
        """Tests for skip() methods"""
        def setUp(self):
                super(SkipMethodsTest, self).setUp()
                self.test = SkipInTest("testDoesntSkip")
                
        def catchSkipException(self, callable, *args, **kwargs):
                try:
                        callable(*args, **kwargs)
                except unittest.SkipException, e:
                        return e
                return None

        def testSkip(self):
                """skip()"""
                e = self.catchSkipException(self.test.skip)
                self.assertNotEqual(None, e)
                
        def testSkipMessage(self):
                """skip(message)"""
                e = self.catchSkipException(self.test.skip, "A message")
                self.assertNotEqual(None, e)
                self.assertEqual("A message", str(e))

        def testSkipIfFalse(self):
                """skipIf(False)"""
                e = self.catchSkipException(self.test.skipIf, False)
                self.assertEqual(None, e)
                
        def testSkipIfTrue(self):
                """skipIf(True)"""
                e = self.catchSkipException(self.test.skipIf, True)
                self.assertNotEqual(None, e)
                
        def testSkipIfTrueMessage(self):
                """skipIf(True, message)"""
                e = self.catchSkipException(self.test.skipIf, True, "Another message")
                self.assertNotEqual(None, e)
                self.assertEqual("Another message", str(e))

                
class TextTestResultTest(unittest.TestCase):
        """Tests for _TextTestResult"""
        def setUp(self):
                super(TextTestResultTest, self).setUp()
                self.out = unittest._WritelnDecorator(StringIO())

        def testNoSkippingQuiet(self):
                """No skipping, verbosity=1"""
                result = unittest._TextTestResult(self.out, True, 1)
                test = SkipInTest("testDoesntSkip")
                test(result)

                self.assertEqual(".", self.out.getvalue())
                
        def testNoSkippingVerbose(self):
                """No skipping, verbosity=2"""
                result = unittest._TextTestResult(self.out, True, 2)
                test = SkipInTest("testDoesntSkip")
                test(result)

                self.assertEqual("Doesn't skip ... ok\n", self.out.getvalue())

        def testSkippingQuiet(self):
                """Skipping, verbosity=1"""
                result = unittest._TextTestResult(self.out, True, 1)
                test = SkipInTest("testSkips")
                test(result)

                self.assertEqual("S", self.out.getvalue())

        def testSkippingVerbose(self):
                """Skipping, verbosity=2"""
                result = unittest._TextTestResult(self.out, True, 2)
                test = SkipInTest("testSkips")
                test(result)

                self.assertEqual("Test skips ... SKIPPED\n", self.out.getvalue())

        def testSkippingMessageVerbose(self):
                """Skipping with a message, verbosity=2"""
                result = unittest._TextTestResult(self.out, True, 2)
                test = SkipInTest("testSkipsMessage")
                test(result)

                self.assertEqual("Test skips with a message ... SKIPPED (A message)\n", self.out.getvalue())


class TextTestRunnerTest(unittest.TestCase):
        """Tests for TextTestRunner"""
        def setUp(self):
                super(TextTestRunnerTest, self).setUp()
                self.out = unittest._WritelnDecorator(StringIO())

        def testOkNoSkips(self):
                """All tests OK, no skips"""
                runner = unittest.TextTestRunner(self.out, True)
                test = SkipInTest("testDoesntSkip")
                runner.run(test)

                self.assert_(self.out.getvalue().endswith("OK\n"))

        def testOkSkip(self):
                """All tests OK, one skip"""
                runner = unittest.TextTestRunner(self.out, True)
                test = SkipInTest("testSkips")
                runner.run(test)

                self.assert_(self.out.getvalue().endswith("OK (skipped=1)\n"))

        def testFailedNoSkip(self):
                """Failed test, no skips"""
                runner = unittest.TextTestRunner(self.out, True)
                test = SkipInTest("testFails")
                runner.run(test)

                self.assert_(self.out.getvalue().endswith("FAILED (failures=1)\n"))

        def testFailedSkip(self):
                """Failed test, one skip"""
                runner = unittest.TextTestRunner(self.out, True)
                test = unittest.TestSuite((SkipInTest("testFails"), SkipInTest("testSkips")))
                runner.run(test)

                self.assert_(self.out.getvalue().endswith("FAILED (failures=1, skipped=1)\n"))


if __name__ == "__main__":
        unittest.TestProgram(argv=sys.argv + ["TestResultTest", "TestCaseTest",
                "SkipMethodsTest", "TextTestResultTest", "TextTestRunnerTest"])