import unittest

class TestClass:
    "test"
    y=2
    def __init__(self):
        self.x=1
        
    def do(self, *args, **kwargs):
        return 1

    def dont(self):
        return 2

    def a(self):
        pass

    def b(self):
        pass

    def c(self):
        raise Exception("test")

    def d(self, x=1):
        print x

    def e(self, a,b,c=2,d=3):
        pass

    def main(self):
        self.do(1)
        self.dont()
        self.a()
        self.b()
        try:
            res = self.c()
        except Exception, e:
            print e
            res = self.dont()
        return res


class NewStyleTestClass(object, TestClass):
    'new style test class'
    y = 2   
    
class TestClass2(TestClass):
    def __init__(self, a,b,c,d={}):
        TestClass.__init__(self)

class TestClass3(TestClass):
    pass


class SpecialCase:
    def __init__(self):
        self.obj = TestClass()
        
    def __getattr__(self, name):
        return getatr(self.obj, name)


class NewStyleSpecialCase(object, SpecialCase):
    'what it says on the tin'

class NewAndOld(unittest.TestCase):
    def setUp(self):
        self.klassTypes = [TestClass, NewStyleTestClass]

class AcceptMockFactory(NewAndOld):

    def testAttributes(self):
        for klass in self.klassTypes:
            mockInstance = self.createMockInstance(klass, [])
            self.assertEqual(mockInstance.y, 2)

            mockInstance.y = 5
            self.assertEqual(mockInstance.y, 5)
            self.assertEqual(klass.y, 2)
            klass.y = 100
            mockInstance.y = 0
            self.assertEqual(klass.y, 100)

        
    def testMethods(self):
        for klass in self.klassTypes:
            mockInstance = self.createMockInstance(klass, [])
            callables = [ getattr(mockInstance, n) for n in dir(klass)
                      if callable(getattr(mockInstance, n)) and not n.startswith("__")]
            for method in callables:
                #just check that doesn't raise
                method.setEventSequence(['anything'])

        self.assertRaises(AttributeError, self.createMockInstance, TestClass3, ["a", "d", "quit"])
        mockInstance = self.createMockInstance(TestClass3, ["a", "d"])
        self.failUnless(isinstance(mockInstance.a, unittest.MockMethod))
        self.failUnless(isinstance(mockInstance.d, unittest.MockMethod))
        

class TestMockFactory(unittest.TestCase):

    def testInitialiser(self):
        self.assertRaises(TypeError, self.createMockInstance, TestClass2, [])
        self.assertRaises(TypeError, self.createMockInstance, TestClass2, [], 1,2)
        self.assertRaises(TypeError, self.createMockInstance, TestClass2, [], 1,2,3,e={1:1})
        self.assertRaises(unittest.MockError, self.createMockInstance, SpecialCase, [])
        self.assertRaises(unittest.MockError, self.createMockInstance, NewStyleSpecialCase, [])
        self.assertRaises(TypeError, self.createMockInstance, NewStyleTestClass, [], 1,2)
        self.createMockInstance(TestClass2, [], 1,2,3)
        self.createMockInstance(TestClass2, [], 1,2,3,d={1:2})
        self.createMockInstance(NewStyleTestClass, [])
        


    

class TestMockMethod(NewAndOld):
    def testSetException(self):
        for klass in self.klassTypes:
            mockObject = self.createMockInstance(klass, [])
            mockObject.a.setException(IOError("deliberate exception"))
            self.assertRaises(IOError, mockObject.a)

    def testSetReturnValue(self):
        for klass in self.klassTypes:
            mockObject = self.createMockInstance(klass, [])
            self.assertEqual(mockObject.dont(), 2)

            expected = "123"
            mockObject.dont.setReturnValue(expected)
            self.assertEqual(mockObject.dont(), expected)

    def test(self):
        expected = [(123, "test"),(1123123,), ("matt",)]
        for klass in self.klassTypes:
            mockObject = self.createMockInstance(klass, [])
            for args in expected:
                apply(mockObject.do, args)
            self.assertEqual(mockObject.do.argsPassed(), expected)
            
    def testKwargsPassed(self):
        expected = [{"test":1},{"default":2}, {"3":4}]
        for klass in self.klassTypes:
            mockObject = self.createMockInstance(klass, ["a", "b", "c"])
            for kwargs in expected:
                apply(mockObject.do, [], kwargs)
            self.assertEqual(mockObject.do.kwargsPassed(), expected)

    def testSetEventSequence(self):
        events = [Exception("delibratly raised"), "some return value", IOError("Another raise"), None, "another return value"]
        for klass in self.klassTypes:
            mockObject = self.createMockInstance(klass, [])
            mockObject.a.setEventSequence(events)

            for event in events:
                if isinstance(event, Exception):
                    self.assertRaises(event.__class__, mockObject.a)
                else:
                    self.assertEqual(mockObject.a(), event)

            self.assertRaises(IndexError, mockObject.a)

class TestTestCase(NewAndOld):
    def testCreateMockInstance(self):
        for klass in self.klassTypes:
            x = self.createMockInstance(klass, [])
            y = klass()
            self.assertEqual(dir(x), dir(y))
        
    def testGetMockInstanceCalls(self):
        tests = [(TestClass, [], ["main", "do", "dont", "a", "b", "c", "dont"]),
                 (NewStyleTestClass, [], ["main", "do", "dont", "a", "b", "c", "dont"]),
                 (TestClass, ['c'], ["main", "do", "dont", "a", "b", "c"]),
                 (NewStyleTestClass, ['c'], ["main", "do", "dont", "a", "b", "c"]),
                 (TestClass3, [], ["main", "do", "dont", "a", "b", "c", "dont"])
                 ]
        for i, (testKlass, mockMethods, expected) in enumerate(tests):
            mockObject = self.createMockInstance(testKlass, mockMethods)
            mockObject.main()   
            actual = self.getMockInstanceCalls()
            self.assertEqual(actual,expected, msg="<%s> != <%s>, %s iteration" % (actual, expected, i) )

            
        
if __name__=="__main__":
    unittest.main(exitsOnResult=False)