"""Test script for unittest.

By Collin Winter <collinw at gmail.com>

Still need testing:

    TestCase.{assert,fail}* methods (some are tested implicitly)

"""

from test import test_support

import unittest

from unittest import TestCase

import types

### Support code

################################################################

class LoggingResult(unittest.TestResult):

    def __init__(self, log):

        self._events = log

        super(LoggingResult, self).__init__()

    def startTest(self, test):

        self._events.append('startTest')

        super(LoggingResult, self).startTest(test)

    def stopTest(self, test):

        self._events.append('stopTest')

        super(LoggingResult, self).stopTest(test)

    def addFailure(self, *args):

        self._events.append('addFailure')

        super(LoggingResult, self).addFailure(*args)

    def addError(self, *args):

        self._events.append('addError')

        super(LoggingResult, self).addError(*args)

class TestEquality(object):

    # Check for a valid __eq__ implementation

    def test_eq(self):

        for obj_1, obj_2 in self.eq_pairs:

            self.assertEqual(obj_1, obj_2)

            self.assertEqual(obj_2, obj_1)

    # Check for a valid __ne__ implementation

    def test_ne(self):

        for obj_1, obj_2 in self.ne_pairs:

            self.failIfEqual(obj_1, obj_2)

            self.failIfEqual(obj_2, obj_1)

class TestHashing(object):

    # Check for a valid __hash__ implementation

    def test_hash(self):

        for obj_1, obj_2 in self.eq_pairs:

            try:

                assert hash(obj_1) == hash(obj_2)

            except KeyboardInterrupt:

                raise

            except AssertionError:

                self.fail("%s and %s do not hash equal" % (obj_1, obj_2))

            except Exception, e:

                self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))

        for obj_1, obj_2 in self.ne_pairs:

            try:

                assert hash(obj_1) != hash(obj_2)

            except KeyboardInterrupt:

                raise

            except AssertionError:

                self.fail("%s and %s hash equal, but shouldn't" % (obj_1, obj_2))

            except Exception, e:

                self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))

################################################################

### /Support code

class Test_TestLoader(TestCase):

    ### Tests for TestLoader.loadTestsFromTestCase

    ################################################################

    # "Return a suite of all tests cases contained in the TestCase-derived

    # class testCaseClass"

    def test_loadTestsFromTestCase(self):

        class Foo(unittest.TestCase):

            def test_1(self): pass

            def test_2(self): pass

            def foo_bar(self): pass

        tests = unittest.TestSuite([Foo('test_1'), Foo('test_2')])

        loader = unittest.TestLoader()

        self.assertEqual(loader.loadTestsFromTestCase(Foo), tests)

    # "Return a suite of all tests cases contained in the TestCase-derived

    # class testCaseClass"

    #

    # Make sure it does the right thing even if no tests were found

    def test_loadTestsFromTestCase__no_matches(self):

        class Foo(unittest.TestCase):

            def foo_bar(self): pass

        empty_suite = unittest.TestSuite()

        loader = unittest.TestLoader()

        self.assertEqual(loader.loadTestsFromTestCase(Foo), empty_suite)

    # "Return a suite of all tests cases contained in the TestCase-derived

    # class testCaseClass"

    #

    # What happens if loadTestsFromTestCase() is given an object

    # that isn't a subclass of TestCase? Specifically, what happens

    # if testCaseClass is a subclass of TestSuite?

    #

    # This is checked for specifically in the code, so we better add a

    # test for it.

    def test_loadTestsFromTestCase__TestSuite_subclass(self):

        class NotATestCase(unittest.TestSuite):

            pass

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromTestCase(NotATestCase)

        except TypeError:

            pass

        else:

            self.fail('Should raise TypeError')

    # "Return a suite of all tests cases contained in the TestCase-derived

    # class testCaseClass"

    #

    # Make sure loadTestsFromTestCase() picks up the default test method

    # name (as specified by TestCase), even though the method name does

    # not match the default TestLoader.testMethodPrefix string

    def test_loadTestsFromTestCase__default_method_name(self):

        class Foo(unittest.TestCase):

            def runTest(self):

                pass

        loader = unittest.TestLoader()

        # This has to be false for the test to succeed

        self.failIf('runTest'.startswith(loader.testMethodPrefix))

        suite = loader.loadTestsFromTestCase(Foo)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [Foo('runTest')])

    ################################################################

    ### /Tests for TestLoader.loadTestsFromTestCase

    ### Tests for TestLoader.loadTestsFromModule

    ################################################################

    # "This method searches `module` for classes derived from TestCase"

    def test_loadTestsFromModule__TestCase_subclass(self):

        m = types.ModuleType('m')

        class MyTestCase(unittest.TestCase):

            def test(self):

                pass

        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromModule(m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        expected = [loader.suiteClass([MyTestCase('test')])]

        self.assertEqual(list(suite), expected)

    # "This method searches `module` for classes derived from TestCase"

    #

    # What happens if no tests are found (no TestCase instances)?

    def test_loadTestsFromModule__no_TestCase_instances(self):

        m = types.ModuleType('m')

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromModule(m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [])

    # "This method searches `module` for classes derived from TestCase"

    #

    # What happens if no tests are found (TestCases instances, but no tests)?

    def test_loadTestsFromModule__no_TestCase_tests(self):

        m = types.ModuleType('m')

        class MyTestCase(unittest.TestCase):

            pass

        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromModule(m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [loader.suiteClass()])

    # "This method searches `module` for classes derived from TestCase"s

    #

    # What happens if loadTestsFromModule() is given something other

    # than a module?

    #

    # XXX Currently, it succeeds anyway. This flexibility

    # should either be documented or loadTestsFromModule() should

    # raise a TypeError

    #

    # XXX Certain people are using this behaviour. We'll add a test for it

    def test_loadTestsFromModule__not_a_module(self):

        class MyTestCase(unittest.TestCase):

            def test(self):

                pass

        class NotAModule(object):

            test_2 = MyTestCase

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromModule(NotAModule)

        reference = [unittest.TestSuite([MyTestCase('test')])]

        self.assertEqual(list(suite), reference)

    ################################################################

    ### /Tests for TestLoader.loadTestsFromModule()

    ### Tests for TestLoader.loadTestsFromName()

    ################################################################

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    #

    # Is ValueError raised in response to an empty name?

    def test_loadTestsFromName__empty_name(self):

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromName('')

        except ValueError, e:

            self.assertEqual(str(e), "Empty module name")

        else:

            self.fail("TestLoader.loadTestsFromName failed to raise ValueError")

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    #

    # What happens when the name contains invalid characters?

    def test_loadTestsFromName__malformed_name(self):

        loader = unittest.TestLoader()

        # XXX Should this raise ValueError or ImportError?

        try:

            loader.loadTestsFromName('abc () //')

        except ValueError:

            pass

        except ImportError:

            pass

        else:

            self.fail("TestLoader.loadTestsFromName failed to raise ValueError")

    # "The specifier name is a ``dotted name'' that may resolve ... to a

    # module"

    #

    # What happens when a module by that name can't be found?

    def test_loadTestsFromName__unknown_module_name(self):

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromName('sdasfasfasdf')

        except ImportError, e:

            self.assertEqual(str(e), "No module named sdasfasfasdf")

        else:

            self.fail("TestLoader.loadTestsFromName failed to raise ImportError")

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    #

    # What happens when the module is found, but the attribute can't?

    def test_loadTestsFromName__unknown_attr_name(self):

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromName('unittest.sdasfasfasdf')

        except AttributeError, e:

            self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'")

        else:

            self.fail("TestLoader.loadTestsFromName failed to raise AttributeError")

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    #

    # What happens when we provide the module, but the attribute can't be

    # found?

    def test_loadTestsFromName__relative_unknown_name(self):

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromName('sdasfasfasdf', unittest)

        except AttributeError, e:

            self.assertEqual(str(e), "'module' object has no attribute 'sdasfasfasdf'")

        else:

            self.fail("TestLoader.loadTestsFromName failed to raise AttributeError")

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    # ...

    # "The method optionally resolves name relative to the given module"

    #

    # Does loadTestsFromName raise ValueError when passed an empty

    # name relative to a provided module?

    #

    # XXX Should probably raise a ValueError instead of an AttributeError

    def test_loadTestsFromName__relative_empty_name(self):

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromName('', unittest)

        except AttributeError, e:

            pass

        else:

            self.fail("Failed to raise AttributeError")

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    # ...

    # "The method optionally resolves name relative to the given module"

    #

    # What happens when an impossible name is given, relative to the provided

    # `module`?

    def test_loadTestsFromName__relative_malformed_name(self):

        loader = unittest.TestLoader()

        # XXX Should this raise AttributeError or ValueError?

        try:

            loader.loadTestsFromName('abc () //', unittest)

        except ValueError:

            pass

        except AttributeError:

            pass

        else:

            self.fail("TestLoader.loadTestsFromName failed to raise ValueError")

    # "The method optionally resolves name relative to the given module"

    #

    # Does loadTestsFromName raise TypeError when the `module` argument

    # isn't a module object?

    #

    # XXX Accepts the not-a-module object, ignorning the object's type

    # This should raise an exception or the method name should be changed

    #

    # XXX Some people are relying on this, so keep it for now

    def test_loadTestsFromName__relative_not_a_module(self):

        class MyTestCase(unittest.TestCase):

            def test(self):

                pass

        class NotAModule(object):

            test_2 = MyTestCase

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('test_2', NotAModule)

        reference = [MyTestCase('test')]

        self.assertEqual(list(suite), reference)

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    #

    # Does it raise an exception if the name resolves to an invalid

    # object?

    def test_loadTestsFromName__relative_bad_object(self):

        m = types.ModuleType('m')

        m.testcase_1 = object()

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromName('testcase_1', m)

        except TypeError:

            pass

        else:

            self.fail("Should have raised TypeError")

    # "The specifier name is a ``dotted name'' that may

    # resolve either to ... a test case class"

    def test_loadTestsFromName__relative_TestCase_subclass(self):

        m = types.ModuleType('m')

        class MyTestCase(unittest.TestCase):

            def test(self):

                pass

        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('testcase_1', m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [MyTestCase('test')])

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    def test_loadTestsFromName__relative_TestSuite(self):

        m = types.ModuleType('m')

        class MyTestCase(unittest.TestCase):

            def test(self):

                pass

        m.testsuite = unittest.TestSuite([MyTestCase('test')])

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('testsuite', m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [MyTestCase('test')])

    # "The specifier name is a ``dotted name'' that may resolve ... to

    # ... a test method within a test case class"

    def test_loadTestsFromName__relative_testmethod(self):

        m = types.ModuleType('m')

        class MyTestCase(unittest.TestCase):

            def test(self):

                pass

        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('testcase_1.test', m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [MyTestCase('test')])

    # "The specifier name is a ``dotted name'' that may resolve either to

    # a module, a test case class, a TestSuite instance, a test method

    # within a test case class, or a callable object which returns a

    # TestCase or TestSuite instance."

    #

    # Does loadTestsFromName() raise the proper exception when trying to

    # resolve "a test method within a test case class" that doesn't exist

    # for the given name (relative to a provided module)?

    def test_loadTestsFromName__relative_invalid_testmethod(self):

        m = types.ModuleType('m')

        class MyTestCase(unittest.TestCase):

            def test(self):

                pass

        m.testcase_1 = MyTestCase

        loader = unittest.TestLoader()

        try:

            loader.loadTestsFromName('testcase_1.testfoo', m)

        except AttributeError, e:

            self.assertEqual(str(e), "type object 'MyTestCase' has no attribute 'testfoo'")

        else:

            self.fail("Failed to raise AttributeError")

    # "The specifier name is a ``dotted name'' that may resolve ... to

    # ... a callable object which returns a ... TestSuite instance"

    def test_loadTestsFromName__callable__TestSuite(self):

        m = types.ModuleType('m')

        testcase_1 = unittest.FunctionTestCase(lambda: None)

        testcase_2 = unittest.FunctionTestCase(lambda: None)

        def return_TestSuite():

            return unittest.TestSuite([testcase_1, testcase_2])

        m.return_TestSuite = return_TestSuite

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('return_TestSuite', m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [testcase_1, testcase_2])

    # "The specifier name is a ``dotted name'' that may resolve ... to

    # ... a callable object which returns a TestCase ... instance"

    def test_loadTestsFromName__callable__TestCase_instance(self):

        m = types.ModuleType('m')

        testcase_1 = unittest.FunctionTestCase(lambda: None)

        def return_TestCase():

            return testcase_1

        m.return_TestCase = return_TestCase

        loader = unittest.TestLoader()

        suite = loader.loadTestsFromName('return_TestCase', m)

        self.failUnless(isinstance(suite, loader.suiteClass))

        self.assertEqual(list(suite), [testcase_1])

    # "The specifier name is a ``dotted name'' that may resolve ... to

    # ... a callable object which returns a TestCase or TestSuite instance"

    #

    # What happens if the callable returns something else?

    def test_loadTestsFromName__callable__wrong_type(self):

        m = types.ModuleType('m')

        def return_wrong():

            return 6

        m.return_wrong = return_wrong

        loader = unittest.TestLoader()

        try:

            suite = loader.loadTestsFromName('return_wrong', m)

        except TypeError:

            pass

        else:

            self.fail("TestLoader.loadTestsFromName failed to raise TypeError")

    # "The specifier can refer to modules and packages which have not been

    # imported; they will be imported as a side-effect"

    def test_loadTestsFromName__module_not_loaded(self):

        # We're going to try to load this module as a side-effect, so it

        # better not be loaded before we try.

        #

        # Why pick audioop? Google shows it isn't used very often, so there's

        # a good chance that it won't be imported when this test is run

        module_name = 'audioop'

        import sys

        if module_name in sys.modules:

            del sys.modules[module_name]

        loader = unittest.TestLoader()

        try:

            suite = loader.loadTestsFromName(module_name)

            self.failUnless(isinstance(suite, loader.suiteClass))

            self.assertEqual(list(suite), [])