def testExcludeSecondLevel(self):
import UserList
original_append = UserList.UserList.append
with isolate(UserList, 'UserList.append'):
self.assertEqual(UserList.UserList.append.im_func,
original_append.im_func)
self.assertFalse(isinstance(original_append, Mock))
def testRestoreEverythingInModule(self):
import UserList
OriginalUserList = UserList.UserList
with isolate(UserList):
pass
self.assertEqual(UserList.UserList, OriginalUserList)
self.assertFalse(isinstance(OriginalUserList, Mock))
def testClassInstantiation(self):
with isolate(tests.isolationfixture,
'MyClass.unmocked_method'):
mod = tests.isolationfixture
self.assertFalse(isinstance(mod.MyClass.unmocked_method, Mock))
instance = mod.MyClass()
#self.assertTrue(isinstance(instance, Mock))
self.assertFalse(isinstance(instance.unmocked_method, Mock))
def testExcludeClassMethod(self):
mod = tests.isolationfixture
original_method = mod.MyClass.class_method
with isolate(mod, 'MyClass.class_method'):
self.assertFalse(isinstance(mod.MyClass.class_method, Mock))
#self.assertEqual(mod.MyClass.class_method, original_method)
# class_method() returns cls
self.assertEqual(mod.MyClass.class_method(), mod.MyClass)
instance = mod.MyClass()
self.assertEqual(instance.class_method(), mod.MyClass)
def testConstructorIsolation(self):
"""Isolated __init__() is called correctly"""
original_cls = tests.isolationfixture.MyClass
original_init = original_cls.__init__
with isolate(tests.isolationfixture, 'MyClass.__init__'):
mod = tests.isolationfixture
self.assertNotEqual(mod.MyClass, original_cls)
self.assertEqual(mod.MyClass.__init__, original_init)
self.assertFalse(isinstance(mod.MyClass.__init__, Mock))
instance = mod.MyClass()
self.assertEqual(instance.my_attribute,
'value of MyClass().my_attribute')
def testExcludeInstanceMethodInClass(self):
mod = tests.isolationfixture
original_method = mod.MyClass.unmocked_method
with isolate(mod, 'MyClass.unmocked_method'):
self.assertFalse(isinstance(mod.MyClass.unmocked_method, Mock))
self.assertEqual(mod.MyClass.unmocked_method.im_func,
original_method.im_func)
self.assertEqual(mod.MyClass().unmocked_method.im_func,
original_method.im_func)
instance = mod.MyClass()
retval = instance.unmocked_method()
self.assertEqual(retval,
'return value of MyClass.unmocked_method')
def testExcludeInstanceMethod(self):
class MyClass(object):
def my_method(self):
return 'return value of my_method'
class mymodule:
my_instance = MyClass()
original_method = mymodule.my_instance.my_method
original_retval = original_method()
with isolate(mymodule, 'my_instance.my_method'):
self.assertTrue(isinstance(mymodule.my_instance, Mock))
self.assertNotEqual(mymodule.my_instance.my_method, original_method)
self.assertEqual(mymodule.my_instance.my_method(),
'return value of my_method')
def testConstructorWithSuper(self):
"""super() is called correctly inside an isolated __init__()"""
with isolate(tests.isolationfixture,
'ClassWithSuperInConstructor.__init__'):
mod = tests.isolationfixture
self.assertFalse(
isinstance(mod.ClassWithSuperInConstructor.__init__, Mock))
instance = mod.ClassWithSuperInConstructor()
self.assertEqual(
instance.my_attribute,
'value of ClassWithSuperInConstructor().my_attribute')
self.assertEqual(
instance.other_attribute,
'value of ClassWithSuperInConstructor().other_attribute')
def testExcludeTopLevel(self):
import UserList
OriginalUserList = UserList.UserList
with isolate(UserList, 'UserList'):
self.assertEqual(UserList.UserList, OriginalUserList)
self.assertFalse(isinstance(OriginalUserList, Mock))
def testPatchEverythingInModule(self):
import UserList
with isolate(UserList):
self.assertTrue(isinstance(UserList.UserList.append, Mock))
