openstack
/
mox3
Code Issues Proposed changes

Merge pull request #3 from quermit/fix-callables-inconsistency 

Full Python 3 compatibility
This commit is contained in:
Przemysław Gajda 2012-04-24 14:49:42 -07:00
parent ec173d58f0 64a3cb2446
commit 17bee3dab4
3 changed files with 284 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -3,6 +3,8 @@ python:
- "2.6" - "2.6"
- "2.7" - "2.7"
- "3.2" - "3.2"
install: pip install pep8
script: script:
- pep8 --ignore E111 *.py || echo "Done"
- python mox_test.py - python mox_test.py
- python stubout_test.py - python stubout_test.py

117
mox.py
View File

@ -14,7 +14,9 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
# #
# This file was mofified by quermit@gmail.com # This file was mofified by:
# quermit@gmail.com
# dawid.fatyga@gmail.com
"""Mox, an object-mocking framework for Python. """Mox, an object-mocking framework for Python.
@ -69,7 +71,6 @@ import inspect
import re import re
import types import types
import unittest import unittest
import collections
import stubout import stubout
@ -241,7 +242,7 @@ class Mox(object):
self._mock_objects = [] self._mock_objects = []
self.stubs = stubout.StubOutForTesting() self.stubs = stubout.StubOutForTesting()
def CreateMock(self, class_to_mock, attrs=None): def CreateMock(self, class_to_mock, attrs=None, bounded_to=None):
"""Create a new mock object. """Create a new mock object.
Args: Args:
@ -249,13 +250,15 @@ class Mox(object):
class_to_mock: class class_to_mock: class
attrs: dict of attribute names to values that will be set on the mock attrs: dict of attribute names to values that will be set on the mock
object. Only public attributes may be set. object. Only public attributes may be set.
bounded_to: optionally, when class_to_mock is not a class, it points
to a real class object, to which attribute is bound
Returns: Returns:
MockObject that can be used as the class_to_mock would be. MockObject that can be used as the class_to_mock would be.
""" """
if attrs is None: if attrs is None:
attrs = {} attrs = {}
new_mock = MockObject(class_to_mock, attrs=attrs) new_mock = MockObject(class_to_mock, attrs=attrs, class_to_bind=bounded_to)
self._mock_objects.append(new_mock) self._mock_objects.append(new_mock)
return new_mock return new_mock
@ -305,18 +308,23 @@ class Mox(object):
of the type of attribute. of the type of attribute.
""" """
if inspect.isclass(obj):
class_to_bind = obj
else:
class_to_bind = None
attr_to_replace = getattr(obj, attr_name) attr_to_replace = getattr(obj, attr_name)
attr_type = type(attr_to_replace) attr_type = type(attr_to_replace)
if attr_type == MockAnything or attr_type == MockObject: if attr_type == MockAnything or attr_type == MockObject:
raise TypeError('Cannot mock a MockAnything! Did you remember to ' raise TypeError('Cannot mock a MockAnything! Did you remember to '
'call UnsetStubs in your previous test?') 'call UnsetStubs in your previous test?')
type_check = ( type_check = (
attr_type in self._USE_MOCK_OBJECT or inspect.isclass(attr_to_replace) attr_type in self._USE_MOCK_OBJECT or inspect.isclass(attr_to_replace)
or isinstance(attr_to_replace, object)) or isinstance(attr_to_replace, object))
if type_check and not use_mock_anything: if type_check and not use_mock_anything:
stub = self.CreateMock(attr_to_replace) stub = self.CreateMock(attr_to_replace, bounded_to=class_to_bind)
else: else:
stub = self.CreateMockAnything(description='Stub for %s' % attr_to_replace) stub = self.CreateMockAnything(description='Stub for %s' % attr_to_replace)
stub.__name__ = attr_name stub.__name__ = attr_name
@ -367,7 +375,7 @@ class Mox(object):
if attr_type == MockAnything or attr_type == MockObject: if attr_type == MockAnything or attr_type == MockObject:
raise TypeError('Cannot mock a MockAnything! Did you remember to ' raise TypeError('Cannot mock a MockAnything! Did you remember to '
'call UnsetStubs in your previous test?') 'call UnsetStubs in your previous test?')
if not inspect.isclass(attr_to_replace): if not inspect.isclass(attr_to_replace):
raise TypeError('Given attr is not a Class. Use StubOutWithMock.') raise TypeError('Given attr is not a Class. Use StubOutWithMock.')
@ -380,6 +388,7 @@ class Mox(object):
self.stubs.UnsetAll() self.stubs.UnsetAll()
def Replay(*args): def Replay(*args):
"""Put mocks into Replay mode. """Put mocks into Replay mode.
@ -453,22 +462,24 @@ class MockAnything(object):
return self.__class__.__dir__.__get__(self, self.__class__) return self.__class__.__dir__.__get__(self, self.__class__)
return self._CreateMockMethod(method_name) return self._CreateMockMethod(method_name)
def __str__(self): def __str__(self):
return self._CreateMockMethod('__str__')() return self._CreateMockMethod('__str__')()
def __call__(self, *args, **kwargs): def __call__(self, *args, **kwargs):
return self._CreateMockMethod('__call__')(*args, **kwargs) return self._CreateMockMethod('__call__')(*args, **kwargs)
def __getitem__(self, i): def __getitem__(self, i):
return self._CreateMockMethod('__getitem__')(i) return self._CreateMockMethod('__getitem__')(i)
def _CreateMockMethod(self, method_name, method_to_mock=None): def _CreateMockMethod(self, method_name, method_to_mock=None,
class_to_bind=object):
"""Create a new mock method call and return it. """Create a new mock method call and return it.
Args: Args:
# method_name: the name of the method being called. # method_name: the name of the method being called.
# method_to_mock: The actual method being mocked, used for introspection. # method_to_mock: The actual method being mocked, used for introspection.
# class_to_bind: Class to which method is bounded (object by default)
method_name: str method_name: str
method_to_mock: a method object method_to_mock: a method object
@ -478,13 +489,14 @@ class MockAnything(object):
return MockMethod(method_name, self._expected_calls_queue, return MockMethod(method_name, self._expected_calls_queue,
self._replay_mode, method_to_mock=method_to_mock, self._replay_mode, method_to_mock=method_to_mock,
description=self._description) description=self._description,
class_to_bind=class_to_bind)
def __nonzero__(self): def __nonzero__(self):
"""Return 1 for nonzero so the mock can be used as a conditional.""" """Return 1 for nonzero so the mock can be used as a conditional."""
return 1 return 1
def __bool__(self): def __bool__(self):
"""Return True for nonzero so the mock can be used as a conditional.""" """Return True for nonzero so the mock can be used as a conditional."""
return True return True
@ -537,7 +549,7 @@ class MockAnything(object):
class MockObject(MockAnything): class MockObject(MockAnything):
"""A mock object that simulates the public/protected interface of a class.""" """A mock object that simulates the public/protected interface of a class."""
def __init__(self, class_to_mock, attrs=None): def __init__(self, class_to_mock, attrs=None, class_to_bind=None):
"""Initialize a mock object. """Initialize a mock object.
This determines the methods and properties of the class and stores them. This determines the methods and properties of the class and stores them.
@ -547,6 +559,8 @@ class MockObject(MockAnything):
class_to_mock: class class_to_mock: class
attrs: dict of attribute names to values that will be set on the mock attrs: dict of attribute names to values that will be set on the mock
object. Only public attributes may be set. object. Only public attributes may be set.
class_to_bind: optionally, when class_to_mock is not a class at all, it
points to a real class
Raises: Raises:
PrivateAttributeError: if a supplied attribute is not public. PrivateAttributeError: if a supplied attribute is not public.
@ -563,6 +577,12 @@ class MockObject(MockAnything):
self._known_methods = set() self._known_methods = set()
self._known_vars = set() self._known_vars = set()
self._class_to_mock = class_to_mock self._class_to_mock = class_to_mock
if inspect.isclass(class_to_mock):
self._class_to_bind = self._class_to_mock
else:
self._class_to_bind = class_to_bind
try: try:
if inspect.isclass(self._class_to_mock): if inspect.isclass(self._class_to_mock):
self._description = class_to_mock.__name__ self._description = class_to_mock.__name__
@ -591,6 +611,11 @@ class MockObject(MockAnything):
else: else:
setattr(self, attr, value) setattr(self, attr, value)
def _CreateMockMethod(self, *args, **kwargs):
"""Overridden to provide self._class_to_mock to class_to_bind parameter."""
kwargs.setdefault("class_to_bind", self._class_to_bind)
return super(MockObject, self)._CreateMockMethod(*args, **kwargs)
def __getattr__(self, name): def __getattr__(self, name):
"""Intercept attribute request on this object. """Intercept attribute request on this object.
@ -776,24 +801,36 @@ class MockObject(MockAnything):
# __call__ method # __call__ method
method = None method = None
if type(self._class_to_mock) in (types.FunctionType, types.MethodType): if type(self._class_to_mock) in (types.FunctionType, types.MethodType):
method = self._class_to_mock; method = self._class_to_mock
else: else:
method = getattr(self._class_to_mock, '__call__') method = getattr(self._class_to_mock, '__call__')
mock_method = self._CreateMockMethod('__call__', method_to_mock=method) mock_method = self._CreateMockMethod('__call__', method_to_mock=method)
return mock_method(*params, **named_params) return mock_method(*params, **named_params)
@property
def __class__(self):
"""Return the class that is being mocked."""
return self._class_to_mock
@property @property
def __name__(self): def __name__(self):
"""Return the name that is being mocked.""" """Return the name that is being mocked."""
return self._description return self._description
# TODO(dejw): this property stopped to work after I introduced changes with
# binding classes. Fortunately I found a solution in the form of
# __getattribute__ method below, but this issue should be investigated
@property
def __class__(self):
return self._class_to_mock
def __dir__(self):
"""Return only attributes of a class to mock """
return dir(self._class_to_mock)
def __getattribute__(self, name):
"""Return _class_to_mock on __class__ attribute. """
if name == "__class__":
return super(MockObject, self).__getattribute__("_class_to_mock")
return super(MockObject, self).__getattribute__(name)
class _MockObjectFactory(MockObject): class _MockObjectFactory(MockObject):
"""A MockObjectFactory creates mocks and verifies __init__ params. """A MockObjectFactory creates mocks and verifies __init__ params.
@ -848,12 +885,15 @@ class MethodSignatureChecker(object):
_NEEDED, _DEFAULT, _GIVEN = range(3) _NEEDED, _DEFAULT, _GIVEN = range(3)
def __init__(self, method): def __init__(self, method, class_to_bind=None):
"""Creates a checker. """Creates a checker.
Args: Args:
# method: A method to check. # method: A method to check.
# class_to_bind: optionally, a class used to type check first method
# parameter, only used with unbound methods
method: function method: function
class_to_bind: type or None
Raises: Raises:
ValueError: method could not be inspected, so checks aren't possible. ValueError: method could not be inspected, so checks aren't possible.
@ -864,10 +904,17 @@ class MethodSignatureChecker(object):
except TypeError: except TypeError:
raise ValueError('Could not get argument specification for %r' raise ValueError('Could not get argument specification for %r'
% (method,)) % (method,))
if inspect.ismethod(method): if inspect.ismethod(method) or class_to_bind:
self._args = self._args[1:] # Skip 'self'. self._args = self._args[1:] # Skip 'self'.
self._method = method self._method = method
self._instance = None # May contain the instance this is bound to. self._instance = None # May contain the instance this is bound to.
self._instance = getattr(method, "__self__", None)
# _bounded_to determines whether the method is bound or not
if self._instance:
self._bounded_to = self._instance.__class__
else:
self._bounded_to = class_to_bind or getattr(method, "im_class", None)
self._has_varargs = varargs is not None self._has_varargs = varargs is not None
self._has_varkw = varkw is not None self._has_varkw = varkw is not None
@ -920,10 +967,10 @@ class MethodSignatureChecker(object):
# #
# NOTE: If a Func() comparator is used, and the signature is not # NOTE: If a Func() comparator is used, and the signature is not
# correct, this will cause extra executions of the function. # correct, this will cause extra executions of the function.
if inspect.ismethod(self._method): if inspect.ismethod(self._method) or self._bounded_to:
# The extra param accounts for the bound instance. # The extra param accounts for the bound instance.
if len(params) > len(self._required_args): if len(params) > len(self._required_args):
expected = getattr(self._method, 'im_class', None) expected = self._bounded_to
# Check if the param is an instance of the expected class, # Check if the param is an instance of the expected class,
# or check equality (useful for checking Comparators). # or check equality (useful for checking Comparators).
@ -934,7 +981,7 @@ class MethodSignatureChecker(object):
try: try:
param_equality = (params[0] == expected) param_equality = (params[0] == expected)
except: except:
param_equality = False; param_equality = False
if isinstance(params[0], expected) or param_equality: if isinstance(params[0], expected) or param_equality:
@ -982,7 +1029,7 @@ class MockMethod(object):
""" """
def __init__(self, method_name, call_queue, replay_mode, def __init__(self, method_name, call_queue, replay_mode,
method_to_mock=None, description=None): method_to_mock=None, description=None, class_to_bind=None):
"""Construct a new mock method. """Construct a new mock method.
Args: Args:
@ -994,11 +1041,16 @@ class MockMethod(object):
# method_to_mock: The actual method being mocked, used for introspection. # method_to_mock: The actual method being mocked, used for introspection.
# description: optionally, a descriptive name for this method. Typically # description: optionally, a descriptive name for this method. Typically
# this is equal to the descriptive name of the method's class. # this is equal to the descriptive name of the method's class.
# class_to_bind: optionally, a class that is used for unbound methods
# (or functions in Python3) to which method is bound, in order not
# to loose binding information. If given, it will be used for
# checking the type of first method parameter
method_name: str method_name: str
call_queue: list or deque call_queue: list or deque
replay_mode: bool replay_mode: bool
method_to_mock: a method object method_to_mock: a method object
description: str or None description: str or None
class_to_bind: type or None
""" """
self._name = method_name self._name = method_name
@ -1016,7 +1068,8 @@ class MockMethod(object):
self._side_effects = None self._side_effects = None
try: try:
self._checker = MethodSignatureChecker(method_to_mock) self._checker = MethodSignatureChecker(method_to_mock,
class_to_bind=class_to_bind)
except ValueError: except ValueError:
self._checker = None self._checker = None
@ -1069,7 +1122,7 @@ class MockMethod(object):
"""Raise a TypeError with a helpful message.""" """Raise a TypeError with a helpful message."""
raise TypeError('MockMethod cannot be iterated. ' raise TypeError('MockMethod cannot be iterated. '
'Did you remember to put your mocks in replay mode?') 'Did you remember to put your mocks in replay mode?')
def __next__(self): def __next__(self):
"""Raise a TypeError with a helpful message.""" """Raise a TypeError with a helpful message."""
raise TypeError('MockMethod cannot be iterated. ' raise TypeError('MockMethod cannot be iterated. '
@ -1117,7 +1170,7 @@ class MockMethod(object):
if self._description: if self._description:
full_desc = "%s.%s" % (self._description, full_desc) full_desc = "%s.%s" % (self._description, full_desc)
return full_desc return full_desc
def __hash__(self): def __hash__(self):
return id(self) return id(self)
@ -1643,7 +1696,7 @@ class SameElementsAs(Comparator):
# This happens because Mox uses __eq__ both to check object equality (in # This happens because Mox uses __eq__ both to check object equality (in
# MethodSignatureChecker) and to invoke Comparators. # MethodSignatureChecker) and to invoke Comparators.
return False return False
try: try:
return set(self._expected_list) == set(actual_list) return set(self._expected_list) == set(actual_list)
except TypeError: except TypeError:

369
mox_test.py
View File

@ -16,11 +16,14 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
# #
# This file was mofified by quermit@gmail.com # This file was mofified by:
# quermit@gmail.com
# dawid.fatyga@gmail.com
import io import io
import unittest import unittest
import re import re
import sys
import mox import mox
@ -67,13 +70,13 @@ class OrTest(unittest.TestCase):
def testValidOr(self): def testValidOr(self):
"""Or should be True if either Comparator returns True.""" """Or should be True if either Comparator returns True."""
self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == {}) self.assertTrue(mox.Or(mox.IsA(dict), mox.IsA(str)) == {})
self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == 'test') self.assertTrue(mox.Or(mox.IsA(dict), mox.IsA(str)) == 'test')
self.assert_(mox.Or(mox.IsA(str), mox.IsA(str)) == 'test') self.assertTrue(mox.Or(mox.IsA(str), mox.IsA(str)) == 'test')
def testInvalidOr(self): def testInvalidOr(self):
"""Or should be False if both Comparators return False.""" """Or should be False if both Comparators return False."""
self.failIf(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0) self.assertFalse(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)
class AndTest(unittest.TestCase): class AndTest(unittest.TestCase):
@ -81,12 +84,12 @@ class AndTest(unittest.TestCase):
def testValidAnd(self): def testValidAnd(self):
"""And should be True if both Comparators return True.""" """And should be True if both Comparators return True."""
self.assert_(mox.And(mox.IsA(str), mox.IsA(str)) == '1') self.assertTrue(mox.And(mox.IsA(str), mox.IsA(str)) == '1')
def testClauseOneFails(self): def testClauseOneFails(self):
"""And should be False if the first Comparator returns False.""" """And should be False if the first Comparator returns False."""
self.failIf(mox.And(mox.IsA(dict), mox.IsA(str)) == '1') self.assertFalse(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')
def testAdvancedUsage(self): def testAdvancedUsage(self):
"""And should work with other Comparators. """And should work with other Comparators.
@ -94,13 +97,13 @@ class AndTest(unittest.TestCase):
Note: this test is reliant on In and ContainsKeyValue. Note: this test is reliant on In and ContainsKeyValue.
""" """
test_dict = {"mock" : "obj", "testing" : "isCOOL"} test_dict = {"mock" : "obj", "testing" : "isCOOL"}
self.assert_(mox.And(mox.In("testing"), self.assertTrue(mox.And(mox.In("testing"),
mox.ContainsKeyValue("mock", "obj")) == test_dict) mox.ContainsKeyValue("mock", "obj")) == test_dict)
def testAdvancedUsageFails(self): def testAdvancedUsageFails(self):
"""Note: this test is reliant on In and ContainsKeyValue.""" """Note: this test is reliant on In and ContainsKeyValue."""
test_dict = {"mock" : "obj", "testing" : "isCOOL"} test_dict = {"mock" : "obj", "testing" : "isCOOL"}
self.failIf(mox.And(mox.In("NOTFOUND"), self.assertFalse(mox.And(mox.In("NOTFOUND"),
mox.ContainsKeyValue("mock", "obj")) == test_dict) mox.ContainsKeyValue("mock", "obj")) == test_dict)
class FuncTest(unittest.TestCase): class FuncTest(unittest.TestCase):
@ -111,13 +114,12 @@ class FuncTest(unittest.TestCase):
equals_one = lambda x: x == 1 equals_one = lambda x: x == 1
always_none = lambda x: None always_none = lambda x: None
self.assert_(mox.Func(equals_one) == 1) self.assertTrue(mox.Func(equals_one) == 1)
self.failIf(mox.Func(equals_one) == 0) self.assertFalse(mox.Func(equals_one) == 0)
self.assertFalse(mox.Func(always_none) == 1)
self.failIf(mox.Func(always_none) == 1) self.assertFalse(mox.Func(always_none) == 0)
self.failIf(mox.Func(always_none) == 0) self.assertFalse(mox.Func(always_none) == None)
self.failIf(mox.Func(always_none) == None)
def testFuncExceptionPropagation(self): def testFuncExceptionPropagation(self):
"""Exceptions within the validating function should propagate.""" """Exceptions within the validating function should propagate."""
@ -130,7 +132,7 @@ class FuncTest(unittest.TestCase):
else: else:
return True return True
self.assert_(mox.Func(raiseExceptionOnNotOne) == 1) self.assertTrue(mox.Func(raiseExceptionOnNotOne) == 1)
self.assertRaises(TestException, mox.Func(raiseExceptionOnNotOne).__eq__, 2) self.assertRaises(TestException, mox.Func(raiseExceptionOnNotOne).__eq__, 2)
class SameElementsAsTest(unittest.TestCase): class SameElementsAsTest(unittest.TestCase):
@ -138,32 +140,32 @@ class SameElementsAsTest(unittest.TestCase):
def testSortedLists(self): def testSortedLists(self):
"""Should return True if two lists are exactly equal.""" """Should return True if two lists are exactly equal."""
self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c']) self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c'])
def testUnsortedLists(self): def testUnsortedLists(self):
"""Should return True if two lists are unequal but have same elements.""" """Should return True if two lists are unequal but have same elements."""
self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1]) self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1])
def testUnhashableLists(self): def testUnhashableLists(self):
"""Should return True if two lists have the same unhashable elements.""" """Should return True if two lists have the same unhashable elements."""
self.assert_(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == self.assertTrue(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) ==
[{2: 'b'}, {'a': 1}]) [{2: 'b'}, {'a': 1}])
def testEmptyLists(self): def testEmptyLists(self):
"""Should return True for two empty lists.""" """Should return True for two empty lists."""
self.assert_(mox.SameElementsAs([]) == []) self.assertTrue(mox.SameElementsAs([]) == [])
def testUnequalLists(self): def testUnequalLists(self):
"""Should return False if the lists are not equal.""" """Should return False if the lists are not equal."""
self.failIf(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c']) self.assertFalse(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c'])
def testUnequalUnhashableLists(self): def testUnequalUnhashableLists(self):
"""Should return False if two lists with unhashable elements are unequal.""" """Should return False if two lists with unhashable elements are unequal."""
self.failIf(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}]) self.assertFalse(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}])
def testActualIsNotASequence(self): def testActualIsNotASequence(self):
"""Should return False if the actual object is not a sequence.""" """Should return False if the actual object is not a sequence."""
self.failIf(mox.SameElementsAs([1]) == object()) self.assertFalse(mox.SameElementsAs([1]) == object())
def testOneUnhashableObjectInActual(self): def testOneUnhashableObjectInActual(self):
"""Store the entire iterator for a correct comparison. """Store the entire iterator for a correct comparison.
@ -172,7 +174,7 @@ class SameElementsAsTest(unittest.TestCase):
unhashable object was encountered and then was restarted, so the actual list unhashable object was encountered and then was restarted, so the actual list
appeared smaller than it was. appeared smaller than it was.
""" """
self.failIf(mox.SameElementsAs([1, 2]) == iter([{}, 1, 2])) self.assertFalse(mox.SameElementsAs([1, 2]) == iter([{}, 1, 2]))
class ContainsKeyValueTest(unittest.TestCase): class ContainsKeyValueTest(unittest.TestCase):
@ -181,15 +183,15 @@ class ContainsKeyValueTest(unittest.TestCase):
def testValidPair(self): def testValidPair(self):
"""Should return True if the key value is in the dict.""" """Should return True if the key value is in the dict."""
self.assert_(mox.ContainsKeyValue("key", 1) == {"key": 1}) self.assertTrue(mox.ContainsKeyValue("key", 1) == {"key": 1})
def testInvalidValue(self): def testInvalidValue(self):
"""Should return False if the value is not correct.""" """Should return False if the value is not correct."""
self.failIf(mox.ContainsKeyValue("key", 1) == {"key": 2}) self.assertFalse(mox.ContainsKeyValue("key", 1) == {"key": 2})
def testInvalidKey(self): def testInvalidKey(self):
"""Should return False if they key is not in the dict.""" """Should return False if they key is not in the dict."""
self.failIf(mox.ContainsKeyValue("qux", 1) == {"key": 2}) self.assertFalse(mox.ContainsKeyValue("qux", 1) == {"key": 2})
class ContainsAttributeValueTest(unittest.TestCase): class ContainsAttributeValueTest(unittest.TestCase):
@ -207,15 +209,15 @@ class ContainsAttributeValueTest(unittest.TestCase):
def testValidPair(self): def testValidPair(self):
"""Should return True if the object has the key attribute and it matches.""" """Should return True if the object has the key attribute and it matches."""
self.assert_(mox.ContainsAttributeValue("key", 1) == self.test_object) self.assertTrue(mox.ContainsAttributeValue("key", 1) == self.test_object)
def testInvalidValue(self): def testInvalidValue(self):
"""Should return False if the value is not correct.""" """Should return False if the value is not correct."""
self.failIf(mox.ContainsKeyValue("key", 2) == self.test_object) self.assertFalse(mox.ContainsKeyValue("key", 2) == self.test_object)
def testInvalidKey(self): def testInvalidKey(self):
"""Should return False if they the object doesn't have the property.""" """Should return False if they the object doesn't have the property."""
self.failIf(mox.ContainsKeyValue("qux", 1) == self.test_object) self.assertFalse(mox.ContainsKeyValue("qux", 1) == self.test_object)
class InTest(unittest.TestCase): class InTest(unittest.TestCase):
@ -223,24 +225,24 @@ class InTest(unittest.TestCase):
def testItemInList(self): def testItemInList(self):
"""Should return True if the item is in the list.""" """Should return True if the item is in the list."""
self.assert_(mox.In(1) == [1, 2, 3]) self.assertTrue(mox.In(1) == [1, 2, 3])
def testKeyInDict(self): def testKeyInDict(self):
"""Should return True if the item is a key in a dict.""" """Should return True if the item is a key in a dict."""
self.assert_(mox.In("test") == {"test" : "module"}) self.assertTrue(mox.In("test") == {"test" : "module"})
def testItemInTuple(self): def testItemInTuple(self):
"""Should return True if the item is in the list.""" """Should return True if the item is in the list."""
self.assert_(mox.In(1) == (1, 2, 3)) self.assertTrue(mox.In(1) == (1, 2, 3))
def testTupleInTupleOfTuples(self): def testTupleInTupleOfTuples(self):
self.assert_(mox.In((1, 2, 3)) == ((1, 2, 3), (1, 2))) self.assertTrue(mox.In((1, 2, 3)) == ((1, 2, 3), (1, 2)))
def testItemNotInList(self): def testItemNotInList(self):
self.failIf(mox.In(1) == [2, 3]) self.assertFalse(mox.In(1) == [2, 3])
def testTupleNotInTupleOfTuples(self): def testTupleNotInTupleOfTuples(self):
self.failIf(mox.In((1, 2)) == ((1, 2, 3), (4, 5))) self.assertFalse(mox.In((1, 2)) == ((1, 2, 3), (4, 5)))
class NotTest(unittest.TestCase): class NotTest(unittest.TestCase):
@ -248,15 +250,15 @@ class NotTest(unittest.TestCase):
def testItemInList(self): def testItemInList(self):
"""Should return True if the item is NOT in the list.""" """Should return True if the item is NOT in the list."""
self.assert_(mox.Not(mox.In(42)) == [1, 2, 3]) self.assertTrue(mox.Not(mox.In(42)) == [1, 2, 3])
def testKeyInDict(self): def testKeyInDict(self):
"""Should return True if the item is NOT a key in a dict.""" """Should return True if the item is NOT a key in a dict."""
self.assert_(mox.Not(mox.In("foo")) == {"key" : 42}) self.assertTrue(mox.Not(mox.In("foo")) == {"key" : 42})
def testInvalidKeyWithNot(self): def testInvalidKeyWithNot(self):
"""Should return False if they key is NOT in the dict.""" """Should return False if they key is NOT in the dict."""
self.assert_(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2}) self.assertTrue(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})
class StrContainsTest(unittest.TestCase): class StrContainsTest(unittest.TestCase):
@ -265,23 +267,23 @@ class StrContainsTest(unittest.TestCase):
def testValidSubstringAtStart(self): def testValidSubstringAtStart(self):
"""Should return True if the substring is at the start of the string.""" """Should return True if the substring is at the start of the string."""
self.assert_(mox.StrContains("hello") == "hello world") self.assertTrue(mox.StrContains("hello") == "hello world")
def testValidSubstringInMiddle(self): def testValidSubstringInMiddle(self):
"""Should return True if the substring is in the middle of the string.""" """Should return True if the substring is in the middle of the string."""
self.assert_(mox.StrContains("lo wo") == "hello world") self.assertTrue(mox.StrContains("lo wo") == "hello world")
def testValidSubstringAtEnd(self): def testValidSubstringAtEnd(self):
"""Should return True if the substring is at the end of the string.""" """Should return True if the substring is at the end of the string."""
self.assert_(mox.StrContains("ld") == "hello world") self.assertTrue(mox.StrContains("ld") == "hello world")
def testInvaildSubstring(self): def testInvaildSubstring(self):
"""Should return False if the substring is not in the string.""" """Should return False if the substring is not in the string."""
self.failIf(mox.StrContains("AAA") == "hello world") self.assertFalse(mox.StrContains("AAA") == "hello world")
def testMultipleMatches(self): def testMultipleMatches(self):
"""Should return True if there are multiple occurances of substring.""" """Should return True if there are multiple occurances of substring."""
self.assert_(mox.StrContains("abc") == "ababcabcabcababc") self.assertTrue(mox.StrContains("abc") == "ababcabcabcababc")
class RegexTest(unittest.TestCase): class RegexTest(unittest.TestCase):
@ -296,23 +298,23 @@ class RegexTest(unittest.TestCase):
This ensures that re.search is used (instead of re.find). This ensures that re.search is used (instead of re.find).
""" """
self.assert_(mox.Regex(r"a\s+b") == "x y z a b c") self.assertTrue(mox.Regex(r"a\s+b") == "x y z a b c")
def testNonMatchPattern(self): def testNonMatchPattern(self):
"""Should return False if the pattern does not match the string.""" """Should return False if the pattern does not match the string."""
self.failIf(mox.Regex(r"a\s+b") == "x y z") self.assertFalse(mox.Regex(r"a\s+b") == "x y z")
def testFlagsPassedCorrectly(self): def testFlagsPassedCorrectly(self):
"""Should return True as we pass IGNORECASE flag.""" """Should return True as we pass IGNORECASE flag."""
self.assert_(mox.Regex(r"A", re.IGNORECASE) == "a") self.assertTrue(mox.Regex(r"A", re.IGNORECASE) == "a")
def testReprWithoutFlags(self): def testReprWithoutFlags(self):
"""repr should return the regular expression pattern.""" """repr should return the regular expression pattern."""
self.assert_(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>") self.assertTrue(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>")
def testReprWithFlags(self): def testReprWithFlags(self):
"""repr should return the regular expression pattern and flags.""" """repr should return the regular expression pattern and flags."""
self.assert_(repr(mox.Regex(r"a\s+b", flags=4)) == self.assertTrue(repr(mox.Regex(r"a\s+b", flags=4)) ==
"<regular expression 'a\s+b', flags=4>") "<regular expression 'a\s+b', flags=4>")
@ -367,37 +369,37 @@ class IsATest(unittest.TestCase):
def testEqualityValid(self): def testEqualityValid(self):
"""Verify that == correctly identifies objects of the same type.""" """Verify that == correctly identifies objects of the same type."""
self.assert_(mox.IsA(str) == 'test') self.assertTrue(mox.IsA(str) == 'test')
def testEqualityInvalid(self): def testEqualityInvalid(self):
"""Verify that == correctly identifies objects of different types.""" """Verify that == correctly identifies objects of different types."""
self.failIf(mox.IsA(str) == 10) self.assertFalse(mox.IsA(str) == 10)
def testInequalityValid(self): def testInequalityValid(self):
"""Verify that != identifies objects of different type.""" """Verify that != identifies objects of different type."""
self.assert_(mox.IsA(str) != 10) self.assertTrue(mox.IsA(str) != 10)
def testInequalityInvalid(self): def testInequalityInvalid(self):
"""Verify that != correctly identifies objects of the same type.""" """Verify that != correctly identifies objects of the same type."""
self.failIf(mox.IsA(str) != "test") self.assertFalse(mox.IsA(str) != "test")
def testEqualityInListValid(self): def testEqualityInListValid(self):
"""Verify list contents are properly compared.""" """Verify list contents are properly compared."""
isa_list = [mox.IsA(str), mox.IsA(str)] isa_list = [mox.IsA(str), mox.IsA(str)]
str_list = ["abc", "def"] str_list = ["abc", "def"]
self.assert_(isa_list == str_list) self.assertTrue(isa_list == str_list)
def testEquailtyInListInvalid(self): def testEquailtyInListInvalid(self):
"""Verify list contents are properly compared.""" """Verify list contents are properly compared."""
isa_list = [mox.IsA(str),mox.IsA(str)] isa_list = [mox.IsA(str),mox.IsA(str)]
mixed_list = ["abc", 123] mixed_list = ["abc", 123]
self.failIf(isa_list == mixed_list) self.assertFalse(isa_list == mixed_list)
def testSpecialTypes(self): def testSpecialTypes(self):
"""Verify that IsA can handle objects like io.StringIO.""" """Verify that IsA can handle objects like io.StringIO."""
isA = mox.IsA(io.StringIO()) isA = mox.IsA(io.StringIO())
stringIO = io.StringIO() stringIO = io.StringIO()
self.assert_(isA == stringIO) self.assertTrue(isA == stringIO)
class IsAlmostTest(unittest.TestCase): class IsAlmostTest(unittest.TestCase):
@ -405,23 +407,23 @@ class IsAlmostTest(unittest.TestCase):
def testEqualityValid(self): def testEqualityValid(self):
"""Verify that == correctly identifies nearly equivalent floats.""" """Verify that == correctly identifies nearly equivalent floats."""
self.assertEquals(mox.IsAlmost(1.8999999999), 1.9) self.assertEqual(mox.IsAlmost(1.8999999999), 1.9)
def testEqualityInvalid(self): def testEqualityInvalid(self):
"""Verify that == correctly identifies non-equivalent floats.""" """Verify that == correctly identifies non-equivalent floats."""
self.assertNotEquals(mox.IsAlmost(1.899), 1.9) self.assertNotEqual(mox.IsAlmost(1.899), 1.9)
def testEqualityWithPlaces(self): def testEqualityWithPlaces(self):
"""Verify that specifying places has the desired effect.""" """Verify that specifying places has the desired effect."""
self.assertNotEquals(mox.IsAlmost(1.899), 1.9) self.assertNotEqual(mox.IsAlmost(1.899), 1.9)
self.assertEquals(mox.IsAlmost(1.899, places=2), 1.9) self.assertEqual(mox.IsAlmost(1.899, places=2), 1.9)
def testNonNumericTypes(self): def testNonNumericTypes(self):
"""Verify that IsAlmost handles non-numeric types properly.""" """Verify that IsAlmost handles non-numeric types properly."""
self.assertNotEquals(mox.IsAlmost(1.8999999999), '1.9') self.assertNotEqual(mox.IsAlmost(1.8999999999), '1.9')
self.assertNotEquals(mox.IsAlmost('1.8999999999'), 1.9) self.assertNotEqual(mox.IsAlmost('1.8999999999'), 1.9)
self.assertNotEquals(mox.IsAlmost('1.8999999999'), '1.9') self.assertNotEqual(mox.IsAlmost('1.8999999999'), '1.9')
class ValueRememberTest(unittest.TestCase): class ValueRememberTest(unittest.TestCase):
@ -431,28 +433,28 @@ class ValueRememberTest(unittest.TestCase):
"""Verify that value will compare to stored value.""" """Verify that value will compare to stored value."""
value = mox.Value() value = mox.Value()
value.store_value('hello world') value.store_value('hello world')
self.assertEquals(value, 'hello world') self.assertEqual(value, 'hello world')
def testNoValue(self): def testNoValue(self):
"""Verify that uninitialized value does not compare to "empty" values.""" """Verify that uninitialized value does not compare to "empty" values."""
value = mox.Value() value = mox.Value()
self.assertNotEquals(value, None) self.assertNotEqual(value, None)
self.assertNotEquals(value, False) self.assertNotEqual(value, False)
self.assertNotEquals(value, 0) self.assertNotEqual(value, 0)
self.assertNotEquals(value, '') self.assertNotEqual(value, '')
self.assertNotEquals(value, ()) self.assertNotEqual(value, ())
self.assertNotEquals(value, []) self.assertNotEqual(value, [])
self.assertNotEquals(value, {}) self.assertNotEqual(value, {})
self.assertNotEquals(value, object()) self.assertNotEqual(value, object())
self.assertNotEquals(value, set()) self.assertNotEqual(value, set())
def testRememberValue(self): def testRememberValue(self):
"""Verify that comparing against remember will store argument.""" """Verify that comparing against remember will store argument."""
value = mox.Value() value = mox.Value()
remember = mox.Remember(value) remember = mox.Remember(value)
self.assertNotEquals(value, 'hello world') # value not yet stored. self.assertNotEqual(value, 'hello world') # value not yet stored.
self.assertEquals(remember, 'hello world') # store value here. self.assertEqual(remember, 'hello world') # store value here.
self.assertEquals(value, 'hello world') # compare against stored value. self.assertEqual(value, 'hello world') # compare against stored value.
class MockMethodTest(unittest.TestCase): class MockMethodTest(unittest.TestCase):
@ -465,19 +467,19 @@ class MockMethodTest(unittest.TestCase):
def testNameAttribute(self): def testNameAttribute(self):
"""Should provide a __name__ attribute.""" """Should provide a __name__ attribute."""
self.assertEquals('testMethod', self.mock_method.__name__) self.assertEqual('testMethod', self.mock_method.__name__)
def testAndReturnNoneByDefault(self): def testAndReturnNoneByDefault(self):
"""Should return None by default.""" """Should return None by default."""
return_value = self.mock_method(['original']) return_value = self.mock_method(['original'])
self.assert_(return_value == None) self.assertTrue(return_value == None)
def testAndReturnValue(self): def testAndReturnValue(self):
"""Should return a specificed return value.""" """Should return a specificed return value."""
expected_return_value = "test" expected_return_value = "test"
self.expected_method.AndReturn(expected_return_value) self.expected_method.AndReturn(expected_return_value)
return_value = self.mock_method(['original']) return_value = self.mock_method(['original'])
self.assert_(return_value == expected_return_value) self.assertTrue(return_value == expected_return_value)
def testAndRaiseException(self): def testAndRaiseException(self):
"""Should raise a specified exception.""" """Should raise a specified exception."""
@ -493,7 +495,7 @@ class MockMethodTest(unittest.TestCase):
mutable_list[0] = 'mutation' mutable_list[0] = 'mutation'
self.expected_method.WithSideEffects(modifier).AndReturn(1) self.expected_method.WithSideEffects(modifier).AndReturn(1)
self.mock_method(local_list) self.mock_method(local_list)
self.assertEquals('mutation', local_list[0]) self.assertEqual('mutation', local_list[0])
def testWithReturningSideEffects(self): def testWithReturningSideEffects(self):
"""Should call state modifier and propagate its return value.""" """Should call state modifier and propagate its return value."""
@ -505,8 +507,8 @@ class MockMethodTest(unittest.TestCase):
return expected_return return expected_return
self.expected_method.WithSideEffects(modifier_with_return) self.expected_method.WithSideEffects(modifier_with_return)
actual_return = self.mock_method(local_list) actual_return = self.mock_method(local_list)
self.assertEquals('mutation', local_list[0]) self.assertEqual('mutation', local_list[0])
self.assertEquals(expected_return, actual_return) self.assertEqual(expected_return, actual_return)
def testWithReturningSideEffectsWithAndReturn(self): def testWithReturningSideEffectsWithAndReturn(self):
"""Should call state modifier and ignore its return value.""" """Should call state modifier and ignore its return value."""
@ -520,8 +522,8 @@ class MockMethodTest(unittest.TestCase):
self.expected_method.WithSideEffects(modifier_with_return).AndReturn( self.expected_method.WithSideEffects(modifier_with_return).AndReturn(
expected_return) expected_return)
actual_return = self.mock_method(local_list) actual_return = self.mock_method(local_list)
self.assertEquals('mutation', local_list[0]) self.assertEqual('mutation', local_list[0])
self.assertEquals(expected_return, actual_return) self.assertEqual(expected_return, actual_return)
def testEqualityNoParamsEqual(self): def testEqualityNoParamsEqual(self):
"""Methods with the same name and without params should be equal.""" """Methods with the same name and without params should be equal."""
@ -531,7 +533,7 @@ class MockMethodTest(unittest.TestCase):
def testEqualityNoParamsNotEqual(self): def testEqualityNoParamsNotEqual(self):
"""Methods with different names and without params should not be equal.""" """Methods with different names and without params should not be equal."""
expected_method = mox.MockMethod("otherMethod", [], False) expected_method = mox.MockMethod("otherMethod", [], False)
self.failIfEqual(self.mock_method, expected_method) self.assertNotEqual(self.mock_method, expected_method)
def testEqualityParamsEqual(self): def testEqualityParamsEqual(self):
"""Methods with the same name and parameters should be equal.""" """Methods with the same name and parameters should be equal."""
@ -548,7 +550,7 @@ class MockMethodTest(unittest.TestCase):
expected_method._params = [1, 2, 3] expected_method._params = [1, 2, 3]
self.mock_method._params = ['a', 'b', 'c'] self.mock_method._params = ['a', 'b', 'c']
self.failIfEqual(self.mock_method, expected_method) self.assertNotEqual(self.mock_method, expected_method)
def testEqualityNamedParamsEqual(self): def testEqualityNamedParamsEqual(self):
"""Methods with the same name and same named params should be equal.""" """Methods with the same name and same named params should be equal."""
@ -565,11 +567,11 @@ class MockMethodTest(unittest.TestCase):
expected_method._named_params = {"input1": "test", "input2": "params"} expected_method._named_params = {"input1": "test", "input2": "params"}
self.mock_method._named_params = {"input1": "test2", "input2": "params2"} self.mock_method._named_params = {"input1": "test2", "input2": "params2"}
self.failIfEqual(self.mock_method, expected_method) self.assertNotEqual(self.mock_method, expected_method)
def testEqualityWrongType(self): def testEqualityWrongType(self):
"""Method should not be equal to an object of a different type.""" """Method should not be equal to an object of a different type."""
self.failIfEqual(self.mock_method, "string?") self.assertNotEqual(self.mock_method, "string?")
def testObjectEquality(self): def testObjectEquality(self):
"""Equality of objects should work without a Comparator""" """Equality of objects should work without a Comparator"""
@ -629,12 +631,12 @@ class MockAnythingTest(unittest.TestCase):
self.mock_object._Replay() self.mock_object._Replay()
actual = str(self.mock_object) actual = str(self.mock_object)
self.mock_object._Verify(); self.mock_object._Verify();
self.assertEquals("foo", actual) self.assertEqual("foo", actual)
def testSetupMode(self): def testSetupMode(self):
"""Verify the mock will accept any call.""" """Verify the mock will accept any call."""
self.mock_object.NonsenseCall() self.mock_object.NonsenseCall()
self.assert_(len(self.mock_object._expected_calls_queue) == 1) self.assertTrue(len(self.mock_object._expected_calls_queue) == 1)
def testReplayWithExpectedCall(self): def testReplayWithExpectedCall(self):
"""Verify the mock replays method calls as expected.""" """Verify the mock replays method calls as expected."""
@ -668,7 +670,7 @@ class MockAnythingTest(unittest.TestCase):
self.mock_object[1].AndReturn(True) self.mock_object[1].AndReturn(True)
self.mock_object._Replay() self.mock_object._Replay()
returned_val = self.mock_object[1] returned_val = self.mock_object[1]
self.assert_(returned_val) self.assertTrue(returned_val)
self.mock_object._Verify() self.mock_object._Verify()
def testNonzero(self): def testNonzero(self):
@ -689,18 +691,18 @@ class MockAnythingTest(unittest.TestCase):
def testEquals(self): def testEquals(self):
"""A mock should be able to compare itself to another object.""" """A mock should be able to compare itself to another object."""
self.mock_object._Replay() self.mock_object._Replay()
self.assertEquals(self.mock_object, self.mock_object) self.assertEqual(self.mock_object, self.mock_object)
def testEqualsMockFailure(self): def testEqualsMockFailure(self):
"""Verify equals identifies unequal objects.""" """Verify equals identifies unequal objects."""
self.mock_object.SillyCall() self.mock_object.SillyCall()
self.mock_object._Replay() self.mock_object._Replay()
self.assertNotEquals(self.mock_object, mox.MockAnything()) self.assertNotEqual(self.mock_object, mox.MockAnything())
def testEqualsInstanceFailure(self): def testEqualsInstanceFailure(self):
"""Verify equals identifies that objects are different instances.""" """Verify equals identifies that objects are different instances."""
self.mock_object._Replay() self.mock_object._Replay()
self.assertNotEquals(self.mock_object, TestClass()) self.assertNotEqual(self.mock_object, TestClass())
def testNotEquals(self): def testNotEquals(self):
"""Verify not equals works.""" """Verify not equals works."""
@ -735,21 +737,37 @@ class MockAnythingTest(unittest.TestCase):
self.mock_object().AndReturn('mox0rd') self.mock_object().AndReturn('mox0rd')
self.mock_object._Replay() self.mock_object._Replay()
self.assertEquals('mox0rd', self.mock_object()) self.assertEqual('mox0rd', self.mock_object())
self.mock_object._Verify() self.mock_object._Verify()
def testIsReprable(self): def testIsReprable(self):
"""Test that MockAnythings can be repr'd without causing a failure.""" """Test that MockAnythings can be repr'd without causing a failure."""
self.failUnless('MockAnything' in repr(self.mock_object)) self.assertTrue('MockAnything' in repr(self.mock_object))
class MethodCheckerTest(unittest.TestCase): class MethodCheckerTest(unittest.TestCase):
"""Tests MockMethod's use of MethodChecker method.""" """Tests MockMethod's use of MethodChecker method."""
def testNoParameters(self): def testUnboundMethodsRequiresInstance(self):
# SKIP TEST IN PYTHON 2.x (Ugly hack for python 2.6)
# REASON: semantics for unbound methods has changed only in Python 3
# so this test in earlier versions is invald
if sys.version_info < (3, 0):
return
instance = CheckCallTestClass()
method = mox.MockMethod('NoParameters', [], False, method = mox.MockMethod('NoParameters', [], False,
CheckCallTestClass.NoParameters) CheckCallTestClass.NoParameters)
self.assertRaises(AttributeError, method)
method(instance)
self.assertRaises(AttributeError, method, instance, 1)
def testNoParameters(self):
method = mox.MockMethod('NoParameters', [], False,
CheckCallTestClass.NoParameters,
class_to_bind=CheckCallTestClass)
method() method()
self.assertRaises(AttributeError, method, 1) self.assertRaises(AttributeError, method, 1)
self.assertRaises(AttributeError, method, 1, 2) self.assertRaises(AttributeError, method, 1, 2)
@ -758,7 +776,8 @@ class MethodCheckerTest(unittest.TestCase):
def testOneParameter(self): def testOneParameter(self):
method = mox.MockMethod('OneParameter', [], False, method = mox.MockMethod('OneParameter', [], False,
CheckCallTestClass.OneParameter) CheckCallTestClass.OneParameter,
class_to_bind=CheckCallTestClass)
self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method)
method(1) method(1)
method(a=1) method(a=1)
@ -769,7 +788,8 @@ class MethodCheckerTest(unittest.TestCase):
def testTwoParameters(self): def testTwoParameters(self):
method = mox.MockMethod('TwoParameters', [], False, method = mox.MockMethod('TwoParameters', [], False,
CheckCallTestClass.TwoParameters) CheckCallTestClass.TwoParameters,
class_to_bind=CheckCallTestClass)
self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method)
self.assertRaises(AttributeError, method, 1) self.assertRaises(AttributeError, method, 1)
self.assertRaises(AttributeError, method, a=1) self.assertRaises(AttributeError, method, a=1)
@ -786,7 +806,8 @@ class MethodCheckerTest(unittest.TestCase):
def testOneDefaultValue(self): def testOneDefaultValue(self):
method = mox.MockMethod('OneDefaultValue', [], False, method = mox.MockMethod('OneDefaultValue', [], False,
CheckCallTestClass.OneDefaultValue) CheckCallTestClass.OneDefaultValue,
class_to_bind=CheckCallTestClass)
method() method()
method(1) method(1)
method(a=1) method(a=1)
@ -797,7 +818,8 @@ class MethodCheckerTest(unittest.TestCase):
def testTwoDefaultValues(self): def testTwoDefaultValues(self):
method = mox.MockMethod('TwoDefaultValues', [], False, method = mox.MockMethod('TwoDefaultValues', [], False,
CheckCallTestClass.TwoDefaultValues) CheckCallTestClass.TwoDefaultValues,
class_to_bind=CheckCallTestClass)
self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method)
self.assertRaises(AttributeError, method, c=3) self.assertRaises(AttributeError, method, c=3)
self.assertRaises(AttributeError, method, 1) self.assertRaises(AttributeError, method, 1)
@ -816,7 +838,8 @@ class MethodCheckerTest(unittest.TestCase):
self.assertRaises(AttributeError, method, a=1, b=2, e=9) self.assertRaises(AttributeError, method, a=1, b=2, e=9)
def testArgs(self): def testArgs(self):
method = mox.MockMethod('Args', [], False, CheckCallTestClass.Args) method = mox.MockMethod('Args', [], False, CheckCallTestClass.Args,
class_to_bind=CheckCallTestClass)
self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method)
self.assertRaises(AttributeError, method, 1) self.assertRaises(AttributeError, method, 1)
method(1, 2) method(1, 2)
@ -827,7 +850,8 @@ class MethodCheckerTest(unittest.TestCase):
self.assertRaises(AttributeError, method, 1, 2, c=3) self.assertRaises(AttributeError, method, 1, 2, c=3)
def testKwargs(self): def testKwargs(self):
method = mox.MockMethod('Kwargs', [], False, CheckCallTestClass.Kwargs) method = mox.MockMethod('Kwargs', [], False, CheckCallTestClass.Kwargs,
class_to_bind=CheckCallTestClass)
self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method)
method(1) method(1)
method(1, 2) method(1, 2)
@ -843,7 +867,8 @@ class MethodCheckerTest(unittest.TestCase):
def testArgsAndKwargs(self): def testArgsAndKwargs(self):
method = mox.MockMethod('ArgsAndKwargs', [], False, method = mox.MockMethod('ArgsAndKwargs', [], False,
CheckCallTestClass.ArgsAndKwargs) CheckCallTestClass.ArgsAndKwargs,
class_to_bind=CheckCallTestClass)
self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method)
method(1) method(1)
method(1, 2) method(1, 2)
@ -891,7 +916,7 @@ class MockObjectTest(unittest.TestCase):
def testSetupModeWithValidCall(self): def testSetupModeWithValidCall(self):
"""Verify the mock object properly mocks a basic method call.""" """Verify the mock object properly mocks a basic method call."""
self.mock_object.ValidCall() self.mock_object.ValidCall()
self.assert_(len(self.mock_object._expected_calls_queue) == 1) self.assertTrue(len(self.mock_object._expected_calls_queue) == 1)
def testSetupModeWithInvalidCall(self): def testSetupModeWithInvalidCall(self):
"""UnknownMethodCallError should be raised if a non-member method is called. """UnknownMethodCallError should be raised if a non-member method is called.
@ -923,47 +948,47 @@ class MockObjectTest(unittest.TestCase):
def testIsInstance(self): def testIsInstance(self):
"""Mock should be able to pass as an instance of the mocked class.""" """Mock should be able to pass as an instance of the mocked class."""
self.assert_(isinstance(self.mock_object, TestClass)) self.assertTrue(isinstance(self.mock_object, TestClass))
def testFindValidMethods(self): def testFindValidMethods(self):
"""Mock should be able to mock all public methods.""" """Mock should be able to mock all public methods."""
self.assert_('ValidCall' in self.mock_object._known_methods) self.assertTrue('ValidCall' in self.mock_object._known_methods)
self.assert_('OtherValidCall' in self.mock_object._known_methods) self.assertTrue('OtherValidCall' in self.mock_object._known_methods)
self.assert_('MyClassMethod' in self.mock_object._known_methods) self.assertTrue('MyClassMethod' in self.mock_object._known_methods)
self.assert_('MyStaticMethod' in self.mock_object._known_methods) self.assertTrue('MyStaticMethod' in self.mock_object._known_methods)
self.assert_('_ProtectedCall' in self.mock_object._known_methods) self.assertTrue('_ProtectedCall' in self.mock_object._known_methods)
self.assert_('__PrivateCall' not in self.mock_object._known_methods) self.assertTrue('__PrivateCall' not in self.mock_object._known_methods)
self.assert_('_TestClass__PrivateCall' in self.mock_object._known_methods) self.assertTrue('_TestClass__PrivateCall' in self.mock_object._known_methods)
def testFindsSuperclassMethods(self): def testFindsSuperclassMethods(self):
"""Mock should be able to mock superclasses methods.""" """Mock should be able to mock superclasses methods."""
self.mock_object = mox.MockObject(ChildClass) self.mock_object = mox.MockObject(ChildClass)
self.assert_('ValidCall' in self.mock_object._known_methods) self.assertTrue('ValidCall' in self.mock_object._known_methods)
self.assert_('OtherValidCall' in self.mock_object._known_methods) self.assertTrue('OtherValidCall' in self.mock_object._known_methods)
self.assert_('MyClassMethod' in self.mock_object._known_methods) self.assertTrue('MyClassMethod' in self.mock_object._known_methods)
self.assert_('ChildValidCall' in self.mock_object._known_methods) self.assertTrue('ChildValidCall' in self.mock_object._known_methods)
def testAccessClassVariables(self): def testAccessClassVariables(self):
"""Class variables should be accessible through the mock.""" """Class variables should be accessible through the mock."""
self.assert_('SOME_CLASS_VAR' in self.mock_object._known_vars) self.assertTrue('SOME_CLASS_VAR' in self.mock_object._known_vars)
self.assert_('_PROTECTED_CLASS_VAR' in self.mock_object._known_vars) self.assertTrue('_PROTECTED_CLASS_VAR' in self.mock_object._known_vars)
self.assertEquals('test_value', self.mock_object.SOME_CLASS_VAR) self.assertEqual('test_value', self.mock_object.SOME_CLASS_VAR)
def testEquals(self): def testEquals(self):
"""A mock should be able to compare itself to another object.""" """A mock should be able to compare itself to another object."""
self.mock_object._Replay() self.mock_object._Replay()
self.assertEquals(self.mock_object, self.mock_object) self.assertEqual(self.mock_object, self.mock_object)
def testEqualsMockFailure(self): def testEqualsMockFailure(self):
"""Verify equals identifies unequal objects.""" """Verify equals identifies unequal objects."""
self.mock_object.ValidCall() self.mock_object.ValidCall()
self.mock_object._Replay() self.mock_object._Replay()
self.assertNotEquals(self.mock_object, mox.MockObject(TestClass)) self.assertNotEqual(self.mock_object, mox.MockObject(TestClass))
def testEqualsInstanceFailure(self): def testEqualsInstanceFailure(self):
"""Verify equals identifies that objects are different instances.""" """Verify equals identifies that objects are different instances."""
self.mock_object._Replay() self.mock_object._Replay()
self.assertNotEquals(self.mock_object, TestClass()) self.assertNotEqual(self.mock_object, TestClass())
def testNotEquals(self): def testNotEquals(self):
"""Verify not equals works.""" """Verify not equals works."""
@ -1115,7 +1140,7 @@ class MockObjectTest(unittest.TestCase):
dummy[1].AndReturn('3') dummy[1].AndReturn('3')
dummy._Replay() dummy._Replay()
self.assertEquals('3', dummy.__getitem__(1)) self.assertEqual('3', dummy.__getitem__(1))
dummy._Verify() dummy._Verify()
def testMockIter_ExpectedIter_Success(self): def testMockIter_ExpectedIter_Success(self):
@ -1142,7 +1167,7 @@ class MockObjectTest(unittest.TestCase):
dummy._Replay() dummy._Replay()
self.failUnless('X' in dummy) self.assertTrue('X' in dummy)
dummy._Verify() dummy._Verify()
@ -1205,7 +1230,7 @@ class MockObjectTest(unittest.TestCase):
dummy[2].AndRaise(IndexError) dummy[2].AndRaise(IndexError)
dummy._Replay() dummy._Replay()
self.assertEquals(['a', 'b'], [x for x in dummy]) self.assertEqual(['a', 'b'], [x for x in dummy])
dummy._Verify() dummy._Verify()
def testMockIter_ExpectedNoGetItem_NoSuccess(self): def testMockIter_ExpectedNoGetItem_NoSuccess(self):
@ -1228,12 +1253,12 @@ class MockObjectTest(unittest.TestCase):
dummy = mox.MockObject(TestSubClass) dummy = mox.MockObject(TestSubClass)
iter(dummy).AndReturn(iter(['a', 'b'])) iter(dummy).AndReturn(iter(['a', 'b']))
dummy._Replay() dummy._Replay()
self.assertEquals(['a', 'b'], [x for x in dummy]) self.assertEqual(['a', 'b'], [x for x in dummy])
dummy._Verify() dummy._Verify()
def testInstantiationWithAdditionalAttributes(self): def testInstantiationWithAdditionalAttributes(self):
mock_object = mox.MockObject(TestClass, attrs={"attr1": "value"}) mock_object = mox.MockObject(TestClass, attrs={"attr1": "value"})
self.assertEquals(mock_object.attr1, "value") self.assertEqual(mock_object.attr1, "value")
def testCantOverrideMethodsWithAttributes(self): def testCantOverrideMethodsWithAttributes(self):
self.assertRaises(ValueError, mox.MockObject, TestClass, self.assertRaises(ValueError, mox.MockObject, TestClass,
@ -1281,7 +1306,7 @@ class MoxTest(unittest.TestCase):
self.mox.ReplayAll() self.mox.ReplayAll()
ret_val = mock_obj.ValidCall() ret_val = mock_obj.ValidCall()
self.assertEquals("yes", ret_val) self.assertEqual("yes", ret_val)
self.mox.VerifyAll() self.mox.VerifyAll()
def testSignatureMatchingWithComparatorAsFirstArg(self): def testSignatureMatchingWithComparatorAsFirstArg(self):
@ -1312,7 +1337,7 @@ class MoxTest(unittest.TestCase):
self.mox.ReplayAll() self.mox.ReplayAll()
ret_val = mock_obj("foo") ret_val = mock_obj("foo")
self.assertEquals("qux", ret_val) self.assertEqual("qux", ret_val)
self.mox.VerifyAll() self.mox.VerifyAll()
def testInheritedCallableObject(self): def testInheritedCallableObject(self):
@ -1322,7 +1347,7 @@ class MoxTest(unittest.TestCase):
self.mox.ReplayAll() self.mox.ReplayAll()
ret_val = mock_obj("foo") ret_val = mock_obj("foo")
self.assertEquals("qux", ret_val) self.assertEqual("qux", ret_val)
self.mox.VerifyAll() self.mox.VerifyAll()
def testCallOnNonCallableObject(self): def testCallOnNonCallableObject(self):
@ -1413,8 +1438,8 @@ class MoxTest(unittest.TestCase):
actual_one = mock_obj.Method(1) actual_one = mock_obj.Method(1)
mock_obj.Close() mock_obj.Close()
self.assertEquals(9, actual_one) self.assertEqual(9, actual_one)
self.assertEquals(10, actual_two) self.assertEqual(10, actual_two)
self.mox.VerifyAll() self.mox.VerifyAll()
@ -1459,10 +1484,10 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.assertEquals(9, actual_one) self.assertEqual(9, actual_one)
self.assertEquals(9, second_one) # Repeated calls should return same number. self.assertEqual(9, second_one) # Repeated calls should return same number.
self.assertEquals(10, actual_two) self.assertEqual(10, actual_two)
self.assertEquals(42, actual_three) self.assertEqual(42, actual_three)
def testMultipleTimesUsingIsAParameter(self): def testMultipleTimesUsingIsAParameter(self):
"""Test if MultipleTimesGroup works with a IsA parameter.""" """Test if MultipleTimesGroup works with a IsA parameter."""
@ -1479,8 +1504,8 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.assertEquals(9, actual_one) self.assertEqual(9, actual_one)
self.assertEquals(9, second_one) # Repeated calls should return same number. self.assertEqual(9, second_one) # Repeated calls should return same number.
def testMutlipleTimesUsingFunc(self): def testMutlipleTimesUsingFunc(self):
"""Test that the Func is not evaluated more times than necessary. """Test that the Func is not evaluated more times than necessary.
@ -1509,7 +1534,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.assertEquals(2, self.counter) self.assertEqual(2, self.counter)
def testMultipleTimesThreeMethods(self): def testMultipleTimesThreeMethods(self):
"""Test if MultipleTimesGroup works with three or more methods.""" """Test if MultipleTimesGroup works with three or more methods."""
@ -1531,10 +1556,10 @@ class MoxTest(unittest.TestCase):
actual_four = mock_obj.Method(4) actual_four = mock_obj.Method(4)
mock_obj.Close() mock_obj.Close()
self.assertEquals(9, actual_one) self.assertEqual(9, actual_one)
self.assertEquals(8, actual_two) self.assertEqual(8, actual_two)
self.assertEquals(7, actual_three) self.assertEqual(7, actual_three)
self.assertEquals(10, actual_four) self.assertEqual(10, actual_four)
self.mox.VerifyAll() self.mox.VerifyAll()
@ -1576,8 +1601,8 @@ class MoxTest(unittest.TestCase):
mock_obj.Method(3) mock_obj.Method(3)
mock_obj.Close() mock_obj.Close()
self.assertEquals(9, actual_one) self.assertEqual(9, actual_one)
self.assertEquals(42, actual_three) self.assertEqual(42, actual_three)
self.mox.VerifyAll() self.mox.VerifyAll()
@ -1625,7 +1650,7 @@ class MoxTest(unittest.TestCase):
self.mox.ReplayAll() self.mox.ReplayAll()
local_list = ['original'] local_list = ['original']
self.failUnlessRaises(Exception, self.assertRaises(Exception,
mock_obj.ConfigureInOutParameter, mock_obj.ConfigureInOutParameter,
local_list) local_list)
mock_obj.WorkWithParameter(local_list) mock_obj.WorkWithParameter(local_list)
@ -1648,7 +1673,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.mox.UnsetStubs() self.mox.UnsetStubs()
self.assertEquals('foo', actual) self.assertEqual('foo', actual)
self.assertTrue(type(test_obj.OtherValidCall) is method_type) self.assertTrue(type(test_obj.OtherValidCall) is method_type)
def testStubOutMethod_Unbound_Comparator(self): def testStubOutMethod_Unbound_Comparator(self):
@ -1662,7 +1687,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.mox.UnsetStubs() self.mox.UnsetStubs()
self.assertEquals('foo', actual) self.assertEqual('foo', actual)
def testStubOutMethod_Unbound_Subclass_Comparator(self): def testStubOutMethod_Unbound_Subclass_Comparator(self):
self.mox.StubOutWithMock(mox_test_helper.TestClassFromAnotherModule, 'Value') self.mox.StubOutWithMock(mox_test_helper.TestClassFromAnotherModule, 'Value')
@ -1675,7 +1700,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.mox.UnsetStubs() self.mox.UnsetStubs()
self.assertEquals('foo', actual) self.assertEqual('foo', actual)
def testStubOuMethod_Unbound_WithOptionalParams(self): def testStubOuMethod_Unbound_WithOptionalParams(self):
self.mox = mox.Mox() self.mox = mox.Mox()
@ -1700,7 +1725,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.mox.UnsetStubs() self.mox.UnsetStubs()
self.assertEquals('foo', actual) self.assertEqual('foo', actual)
def testStubOutMethod_Unbound_DifferentInstance(self): def testStubOutMethod_Unbound_DifferentInstance(self):
instance = TestClass() instance = TestClass()
@ -1761,7 +1786,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.mox.UnsetStubs() self.mox.UnsetStubs()
self.assertEquals('foo', actual) self.assertEqual('foo', actual)
def testStubOutMethod_Bound_NamedUsingPositional(self): def testStubOutMethod_Bound_NamedUsingPositional(self):
"""Check positional parameters can be matched to keyword arguments.""" """Check positional parameters can be matched to keyword arguments."""
@ -1840,7 +1865,7 @@ class MoxTest(unittest.TestCase):
def testStubOutClass_OldStyle(self): def testStubOutClass_OldStyle(self):
"""Test a mocked class whose __init__ returns a Mock.""" """Test a mocked class whose __init__ returns a Mock."""
self.mox.StubOutWithMock(mox_test_helper, 'TestClassFromAnotherModule') self.mox.StubOutWithMock(mox_test_helper, 'TestClassFromAnotherModule')
self.assert_(isinstance(mox_test_helper.TestClassFromAnotherModule, self.assertTrue(isinstance(mox_test_helper.TestClassFromAnotherModule,
mox.MockObject)) mox.MockObject))
mock_instance = self.mox.CreateMock( mock_instance = self.mox.CreateMock(
@ -1855,7 +1880,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.mox.UnsetStubs() self.mox.UnsetStubs()
self.assertEquals('mock instance', actual) self.assertEqual('mock instance', actual)
def testStubOutClass(self): def testStubOutClass(self):
self.mox.StubOutClassWithMocks(mox_test_helper, 'CallableClass') self.mox.StubOutClassWithMocks(mox_test_helper, 'CallableClass')
@ -1880,12 +1905,12 @@ class MoxTest(unittest.TestCase):
self.mox.UnsetStubs() self.mox.UnsetStubs()
# Verify the correct mocks were returned # Verify the correct mocks were returned
self.assertEquals(mock_one, one) self.assertEqual(mock_one, one)
self.assertEquals(mock_two, two) self.assertEqual(mock_two, two)
# Verify # Verify
self.assertEquals('mock', actual_one) self.assertEqual('mock', actual_one)
self.assertEquals('called mock', actual_two) self.assertEqual('called mock', actual_two)
def testStubOutClass_NotAClass(self): def testStubOutClass_NotAClass(self):
self.assertRaises(TypeError, self.mox.StubOutClassWithMocks, self.assertRaises(TypeError, self.mox.StubOutClassWithMocks,
@ -1979,7 +2004,7 @@ class MoxTest(unittest.TestCase):
foo = Foo() foo = Foo()
self.mox.StubOutWithMock(foo, "obj") self.mox.StubOutWithMock(foo, "obj")
self.assert_(isinstance(foo.obj, mox.MockObject)) self.assertTrue(isinstance(foo.obj, mox.MockObject))
foo.obj.ValidCall() foo.obj.ValidCall()
self.mox.ReplayAll() self.mox.ReplayAll()
@ -1987,7 +2012,7 @@ class MoxTest(unittest.TestCase):
self.mox.VerifyAll() self.mox.VerifyAll()
self.mox.UnsetStubs() self.mox.UnsetStubs()
self.failIf(isinstance(foo.obj, mox.MockObject)) self.assertFalse(isinstance(foo.obj, mox.MockObject))
def testForgotReplayHelpfulMessage(self): def testForgotReplayHelpfulMessage(self):
"""If there is an AttributeError on a MockMethod, give users a helpful msg. """If there is an AttributeError on a MockMethod, give users a helpful msg.
@ -2000,7 +2025,7 @@ class MoxTest(unittest.TestCase):
try: try:
foo.GetBar().ShowMeTheMoney() foo.GetBar().ShowMeTheMoney()
except AttributeError as e: except AttributeError as e:
self.assertEquals('MockMethod has no attribute "ShowMeTheMoney". ' self.assertEqual('MockMethod has no attribute "ShowMeTheMoney". '
'Did you remember to put your mocks in replay mode?', str(e)) 'Did you remember to put your mocks in replay mode?', str(e))
@ -2101,14 +2126,14 @@ class MoxTestBaseTest(unittest.TestCase):
self.test_stubs.SmartUnsetAll() self.test_stubs.SmartUnsetAll()
self.mox.ReplayAll() self.mox.ReplayAll()
self.test.run(result=self.result) self.test.run(result=self.result)
self.failIf(self.result.wasSuccessful()) self.assertFalse(self.result.wasSuccessful())
self.mox.VerifyAll() self.mox.VerifyAll()
def testExpectedNotCalledNoMocks(self): def testExpectedNotCalledNoMocks(self):
"""Let testExpectedNotCalled() unset all the mocks by itself.""" """Let testExpectedNotCalled() unset all the mocks by itself."""
self._CreateTest('testExpectedNotCalled') self._CreateTest('testExpectedNotCalled')
self.test.run(result=self.result) self.test.run(result=self.result)
self.failIf(self.result.wasSuccessful()) self.assertFalse(self.result.wasSuccessful())
self.assertEqual(OS_LISTDIR, mox_test_helper.os.listdir) self.assertEqual(OS_LISTDIR, mox_test_helper.os.listdir)
def testUnexpectedCall(self): def testUnexpectedCall(self):
@ -2124,7 +2149,7 @@ class MoxTestBaseTest(unittest.TestCase):
self.test_stubs.SmartUnsetAll() self.test_stubs.SmartUnsetAll()
self.mox.ReplayAll() self.mox.ReplayAll()
self.test.run(result=self.result) self.test.run(result=self.result)
self.failIf(self.result.wasSuccessful()) self.assertFalse(self.result.wasSuccessful())
self.mox.VerifyAll() self.mox.VerifyAll()
def testFailure(self): def testFailure(self):
@ -2140,7 +2165,7 @@ class MoxTestBaseTest(unittest.TestCase):
self.test_stubs.SmartUnsetAll() self.test_stubs.SmartUnsetAll()
self.mox.ReplayAll() self.mox.ReplayAll()
self.test.run(result=self.result) self.test.run(result=self.result)
self.failIf(self.result.wasSuccessful()) self.assertFalse(self.result.wasSuccessful())
self.mox.VerifyAll() self.mox.VerifyAll()
def testMixin(self): def testMixin(self):
@ -2182,11 +2207,11 @@ class ResetTest(unittest.TestCase):
self.assertFalse(mock_obj._replay_mode) self.assertFalse(mock_obj._replay_mode)
mock_obj._Replay() mock_obj._Replay()
self.assertTrue(mock_obj._replay_mode) self.assertTrue(mock_obj._replay_mode)
self.assertEquals(1, len(mock_obj._expected_calls_queue)) self.assertEqual(1, len(mock_obj._expected_calls_queue))
mox.Reset(mock_obj) mox.Reset(mock_obj)
self.assertFalse(mock_obj._replay_mode) self.assertFalse(mock_obj._replay_mode)
self.assertEquals(0, len(mock_obj._expected_calls_queue)) self.assertEqual(0, len(mock_obj._expected_calls_queue))
class MyTestCase(unittest.TestCase): class MyTestCase(unittest.TestCase):
@ -2199,7 +2224,7 @@ class MyTestCase(unittest.TestCase):
def testMethodOverride(self): def testMethodOverride(self):
"""Should be properly overriden in a derived class.""" """Should be properly overriden in a derived class."""
self.assertEquals(42, self.another_critical_variable) self.assertEqual(42, self.another_critical_variable)
self.another_critical_variable += 1 self.another_critical_variable += 1
@ -2212,15 +2237,15 @@ class MoxTestBaseMultipleInheritanceTest(mox.MoxTestBase, MyTestCase):
def testMultipleInheritance(self): def testMultipleInheritance(self):
"""Should be able to access members created by all parent setUp().""" """Should be able to access members created by all parent setUp()."""
self.assert_(isinstance(self.mox, mox.Mox)) self.assertTrue(isinstance(self.mox, mox.Mox))
self.assertEquals(42, self.critical_variable) self.assertEqual(42, self.critical_variable)
def testMethodOverride(self): def testMethodOverride(self):
"""Should run before MyTestCase.testMethodOverride.""" """Should run before MyTestCase.testMethodOverride."""
self.assertEquals(99, self.another_critical_variable) self.assertEqual(99, self.another_critical_variable)
self.another_critical_variable = 42 self.another_critical_variable = 42
super(MoxTestBaseMultipleInheritanceTest, self).testMethodOverride() super(MoxTestBaseMultipleInheritanceTest, self).testMethodOverride()
self.assertEquals(43, self.another_critical_variable) self.assertEqual(43, self.another_critical_variable)
class MoxTestDontMockProperties(MoxTestBaseTest): class MoxTestDontMockProperties(MoxTestBaseTest):
def testPropertiesArentMocked(self): def testPropertiesArentMocked(self):