From 4b4421e766fec59ad7ebd24fe6f45bec8fe27883 Mon Sep 17 00:00:00 2001 From: Monty Taylor Date: Tue, 21 May 2013 18:37:02 -0400 Subject: Fix all of the flake8/hacking warnings. --- mox3/mox.py | 415 +++++++++++++++++++++++-------------------- mox3/stubout.py | 91 +++++----- mox3/tests/stubout_helper.py | 1 - mox3/tests/test_mox.py | 253 +++++++++++++------------- mox3/tests/test_stubout.py | 2 +- setup.py | 4 +- tox.ini | 1 - 7 files changed, 408 insertions(+), 359 deletions(-) diff --git a/mox3/mox.py b/mox3/mox.py index ad3daf9..3c10cc8 100644 --- a/mox3/mox.py +++ b/mox3/mox.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # -# # This is a fork of the pymox library intended to work with Python 3. # The file was modified by quermit@gmail.com and dawid.fatyga@gmail.com @@ -63,14 +62,14 @@ Suggested usage / workflow: my_mox.VerifyAll() """ -from collections import deque +import collections import difflib import inspect import re import types import unittest -from . import stubout +from mox3 import stubout class Error(AssertionError): @@ -164,9 +163,7 @@ class UnknownMethodCallError(Error): class PrivateAttributeError(Error): - """ - Raised if a MockObject is passed a private additional attribute name. - """ + """Raised if a MockObject is passed a private additional attribute name.""" def __init__(self, attr): Error.__init__(self) @@ -261,7 +258,8 @@ class Mox(object): """ if attrs is None: attrs = {} - new_mock = MockObject(class_to_mock, attrs=attrs, class_to_bind=bounded_to) + new_mock = MockObject(class_to_mock, attrs=attrs, + class_to_bind=bounded_to) self._mock_objects.append(new_mock) return new_mock @@ -271,8 +269,8 @@ class Mox(object): This does not enforce an interface. Args: - description: str. Optionally, a descriptive name for the mock object - being created, for debugging output purposes. + description: str. Optionally, a descriptive name for the mock object + being created, for debugging output purposes. """ new_mock = MockAnything(description=description) self._mock_objects.append(new_mock) @@ -299,15 +297,16 @@ class Mox(object): def StubOutWithMock(self, obj, attr_name, use_mock_anything=False): """Replace a method, attribute, etc. with a Mock. - This will replace a class or module with a MockObject, and everything else - (method, function, etc) with a MockAnything. This can be overridden to - always use a MockAnything by setting use_mock_anything to True. + This will replace a class or module with a MockObject, and everything + else (method, function, etc) with a MockAnything. This can be + overridden to always use a MockAnything by setting use_mock_anything + to True. Args: obj: A Python object (class, module, instance, callable). - attr_name: str. The name of the attribute to replace with a mock. - use_mock_anything: bool. True if a MockAnything should be used regardless - of the type of attribute. + attr_name: str. The name of the attribute to replace with a mock. + use_mock_anything: bool. True if a MockAnything should be used + regardless of the type of attribute. """ if inspect.isclass(obj): @@ -320,16 +319,17 @@ class Mox(object): if attr_type == MockAnything or attr_type == MockObject: raise TypeError('Cannot mock a MockAnything! Did you remember to ' - 'call UnsetStubs in your previous test?') + 'call UnsetStubs in your previous test?') type_check = ( - attr_type in self._USE_MOCK_OBJECT or inspect.isclass(attr_to_replace) - or isinstance(attr_to_replace, object)) + attr_type in self._USE_MOCK_OBJECT or + inspect.isclass(attr_to_replace) or + isinstance(attr_to_replace, object)) if type_check and not use_mock_anything: stub = self.CreateMock(attr_to_replace, bounded_to=class_to_bind) else: stub = self.CreateMockAnything( - description='Stub for %s' % attr_to_replace) + description='Stub for %s' % attr_to_replace) stub.__name__ = attr_name self.stubs.Set(obj, attr_name, stub) @@ -352,7 +352,7 @@ class Mox(object): mock1 = mox.CreateMock(my_import.FooClass) mock2 = mox.CreateMock(my_import.FooClass) foo_factory = mox.StubOutWithMock(my_import, 'FooClass', - use_mock_anything=True) + use_mock_anything=True) foo_factory(1, 2).AndReturn(mock1) foo_factory(9, 10).AndReturn(mock2) mox.ReplayAll() @@ -377,10 +377,10 @@ class Mox(object): if attr_type == MockAnything or attr_type == MockObject: 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): - raise TypeError('Given attr is not a Class. Use StubOutWithMock.') + raise TypeError('Given attr is not a Class. Use StubOutWithMock.') factory = _MockObjectFactory(attr_to_replace, self) self._mock_objects.append(factory) @@ -435,8 +435,8 @@ class MockAnything(object): """Initialize a new MockAnything. Args: - description: str. Optionally, a descriptive name for the mock object - being created, for debugging output purposes. + description: str. Optionally, a descriptive name for the mock + object being created, for debugging output purposes. """ self._description = description self._Reset() @@ -476,13 +476,15 @@ class MockAnything(object): return self._CreateMockMethod('__getitem__')(i) def _CreateMockMethod(self, method_name, method_to_mock=None, - class_to_bind=object): + class_to_bind=object): """Create a new mock method call and return it. Args: # method_name: the name of the method being called. - # method_to_mock: The actual method being mocked, used for introspection. - # class_to_bind: Class to which method is bounded (object by default) + # 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_to_mock: a method object @@ -491,9 +493,9 @@ class MockAnything(object): """ return MockMethod(method_name, self._expected_calls_queue, - self._replay_mode, method_to_mock=method_to_mock, - description=self._description, - class_to_bind=class_to_bind) + self._replay_mode, method_to_mock=method_to_mock, + description=self._description, + class_to_bind=class_to_bind) def __nonzero__(self): """Return 1 for nonzero so the mock can be used as a conditional.""" @@ -508,8 +510,8 @@ class MockAnything(object): """Provide custom logic to compare objects.""" return (isinstance(rhs, MockAnything) and - self._replay_mode == rhs._replay_mode and - self._expected_calls_queue == rhs._expected_calls_queue) + self._replay_mode == rhs._replay_mode and + self._expected_calls_queue == rhs._expected_calls_queue) def __ne__(self, rhs): """Provide custom logic to compare objects.""" @@ -525,15 +527,16 @@ class MockAnything(object): """Verify that all of the expected calls have been made. Raises: - ExpectedMethodCallsError: if there are still more method calls in the - expected queue. + ExpectedMethodCallsError: if there are still more method calls in + the expected queue. """ # If the list of expected calls is not empty, raise an exception if self._expected_calls_queue: # The last MultipleTimesGroup is not popped from the queue. if (len(self._expected_calls_queue) == 1 and - isinstance(self._expected_calls_queue[0], MultipleTimesGroup) and + isinstance(self._expected_calls_queue[0], + MultipleTimesGroup) and self._expected_calls_queue[0].IsSatisfied()): pass else: @@ -543,27 +546,27 @@ class MockAnything(object): """Reset the state of this mock to record mode with an empty queue.""" # Maintain a list of method calls we are expecting - self._expected_calls_queue = deque() + self._expected_calls_queue = collections.deque() # Make sure we are in setup mode, not replay mode self._replay_mode = False class MockObject(MockAnything): - """A mock object that simulates the public/protected interface of a class.""" + """Mock object that simulates the public/protected interface of a class.""" def __init__(self, class_to_mock, attrs=None, class_to_bind=None): """Initialize a mock object. - This determines the methods and properties of the class and stores them. + Determines the methods and properties of the class and stores them. Args: # class_to_mock: class to be mocked class_to_mock: class - attrs: dict of attribute names to values that will be set on the mock - 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 + attrs: dict of attribute names to values that will be set on the + mock 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: PrivateAttributeError: if a supplied attribute is not public. @@ -572,7 +575,7 @@ class MockObject(MockAnything): if attrs is None: attrs = {} - # This is used to hack around the mixin/inheritance of MockAnything, which + # Used to hack around the mixin/inheritance of MockAnything, which # is not a proper object (it can be anything. :-) MockAnything.__dict__['__init__'](self) @@ -610,20 +613,20 @@ class MockObject(MockAnything): raise PrivateAttributeError(attr) elif attr in self._known_methods: raise ValueError("'%s' is a method of '%s' objects." % (attr, - class_to_mock)) + class_to_mock)) else: setattr(self, attr, value) def _CreateMockMethod(self, *args, **kwargs): - """Overridden to provide self._class_to_mock to class_to_bind parameter.""" + """Overridden to provide self._class_to_mock to class_to_bind.""" kwargs.setdefault("class_to_bind", self._class_to_bind) return super(MockObject, self)._CreateMockMethod(*args, **kwargs) def __getattr__(self, name): """Intercept attribute request on this object. - If the attribute is a public class variable, it will be returned and not - recorded as a call. + If the attribute is a public class variable, it will be returned and + not recorded as a call. If the attribute is not a variable, it is handled like a method call. The method name is checked against the set of mockable @@ -636,12 +639,12 @@ class MockObject(MockAnything): name: str Returns: - Either a class variable or a new MockMethod that is aware of the state - of the mock (record or replay). + Either a class variable or a new MockMethod that is aware of the + state of the mock (record or replay). Raises: - UnknownMethodCallError if the MockObject does not mock the requested - method. + UnknownMethodCallError if the MockObject does not mock the + requested method. """ if name in self._known_vars: @@ -649,8 +652,8 @@ class MockObject(MockAnything): if name in self._known_methods: return self._CreateMockMethod( - name, - method_to_mock=getattr(self._class_to_mock, name)) + name, + method_to_mock=getattr(self._class_to_mock, name)) raise UnknownMethodCallError(name) @@ -658,20 +661,21 @@ class MockObject(MockAnything): """Provide custom logic to compare objects.""" return (isinstance(rhs, MockObject) and - self._class_to_mock == rhs._class_to_mock and - self._replay_mode == rhs._replay_mode and - self._expected_calls_queue == rhs._expected_calls_queue) + self._class_to_mock == rhs._class_to_mock and + self._replay_mode == rhs._replay_mode and + self._expected_calls_queue == rhs._expected_calls_queue) def __setitem__(self, key, value): - """Provide custom logic for mocking classes that support item assignment. + """Custom logic for mocking classes that support item assignment. Args: key: Key to set the value for. value: Value to set. Returns: - Expected return value in replay mode. A MockMethod object for the - __setitem__ method that has already been called if not in replay mode. + Expected return value in replay mode. A MockMethod object for the + __setitem__ method that has already been called if not in replay + mode. Raises: TypeError if the underlying class does not support item assignment. @@ -683,10 +687,10 @@ class MockObject(MockAnything): if '__setitem__' not in dir(self._class_to_mock): raise TypeError('object does not support item assignment') - # If we are in replay mode then simply call the mock __setitem__ method. + # If we are in replay mode then simply call the mock __setitem__ method if self._replay_mode: return MockMethod('__setitem__', self._expected_calls_queue, - self._replay_mode)(key, value) + self._replay_mode)(key, value) # Otherwise, create a mock method __setitem__. return self._CreateMockMethod('__setitem__')(key, value) @@ -698,8 +702,9 @@ class MockObject(MockAnything): key: Key to return the value for. Returns: - Expected return value in replay mode. A MockMethod object for the - __getitem__ method that has already been called if not in replay mode. + Expected return value in replay mode. A MockMethod object for the + __getitem__ method that has already been called if not in replay + mode. Raises: TypeError if the underlying class is not subscriptable. @@ -711,10 +716,10 @@ class MockObject(MockAnything): if '__getitem__' not in dir(self._class_to_mock): raise TypeError('unsubscriptable object') - # If we are in replay mode then simply call the mock __getitem__ method. + # If we are in replay mode then simply call the mock __getitem__ method if self._replay_mode: return MockMethod('__getitem__', self._expected_calls_queue, - self._replay_mode)(key) + self._replay_mode)(key) # Otherwise, create a mock method __getitem__. return self._CreateMockMethod('__getitem__')(key) @@ -723,7 +728,7 @@ class MockObject(MockAnything): """Provide custom logic for mocking classes that are iterable. Returns: - Expected return value in replay mode. A MockMethod object for the + Expected return value in replay mode. A MockMethod object for the __iter__ method that has already been called if not in replay mode. Raises: @@ -736,8 +741,8 @@ class MockObject(MockAnything): # Verify the class supports iteration. if '__iter__' not in methods: - # If it doesn't have iter method and we are in replay method, then try to - # iterate using subscripts. + # If it doesn't have iter method and we are in replay method, + # then try to iterate using subscripts. if '__getitem__' not in methods or not self._replay_mode: raise TypeError('not iterable object') else: @@ -753,7 +758,7 @@ class MockObject(MockAnything): # If we are in replay mode then simply call the mock __iter__ method. if self._replay_mode: return MockMethod('__iter__', self._expected_calls_queue, - self._replay_mode)() + self._replay_mode)() # Otherwise, create a mock method __iter__. return self._CreateMockMethod('__iter__')() @@ -765,8 +770,9 @@ class MockObject(MockAnything): key: Key to look in container for. Returns: - Expected return value in replay mode. A MockMethod object for the - __contains__ method that has already been called if not in replay mode. + Expected return value in replay mode. A MockMethod object for the + __contains__ method that has already been called if not in replay + mode. Raises: TypeError if the underlying class does not implement __contains__ @@ -781,7 +787,7 @@ class MockObject(MockAnything): if self._replay_mode: return MockMethod('__contains__', self._expected_calls_queue, - self._replay_mode)(key) + self._replay_mode)(key) return self._CreateMockMethod('__contains__')(key) @@ -820,11 +826,11 @@ class MockObject(MockAnything): return self._class_to_mock def __dir__(self): - """Return only attributes of a class to mock """ + """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. """ + """Return _class_to_mock on __class__ attribute.""" if name == "__class__": return super(MockObject, self).__getattribute__("_class_to_mock") @@ -838,8 +844,8 @@ class _MockObjectFactory(MockObject): necessary to stub out direction instantiation of a class. The MockObjectFactory creates new MockObjects when called and verifies the - __init__ params are correct when in record mode. When replaying, existing - mocks are returned, and the __init__ params are verified. + __init__ params are correct when in record mode. When replaying, + existing mocks are returned, and the __init__ params are verified. See StubOutWithMock vs StubOutClassWithMocks for more detail. """ @@ -847,7 +853,7 @@ class _MockObjectFactory(MockObject): def __init__(self, class_to_mock, mox_instance): MockObject.__init__(self, class_to_mock) self._mox = mox_instance - self._instance_queue = deque() + self._instance_queue = collections.deque() def __call__(self, *params, **named_params): """Instantiate and record that a new mock has been created.""" @@ -860,7 +866,7 @@ class _MockObjectFactory(MockObject): if self._replay_mode: if not self._instance_queue: raise UnexpectedMockCreationError(self._class_to_mock, *params, - **named_params) + **named_params) mock_method(*params, **named_params) @@ -889,20 +895,21 @@ class MethodSignatureChecker(object): Args: # method: A method to check. - # class_to_bind: optionally, a class used to type check first method - # parameter, only used with unbound methods + # class_to_bind: optionally, a class used to type check first + # method parameter, only used with unbound methods method: function class_to_bind: type or None Raises: - ValueError: method could not be inspected, so checks aren't possible. - Some methods and functions like built-ins can't be inspected. + ValueError: method could not be inspected, so checks aren't + possible. Some methods and functions like built-ins + can't be inspected. """ try: self._args, varargs, varkw, defaults = inspect.getargspec(method) except TypeError: raise ValueError('Could not get argument specification for %r' - % (method,)) + % (method,)) if inspect.ismethod(method) or class_to_bind: self._args = self._args[1:] # Skip 'self'. self._method = method @@ -913,7 +920,8 @@ class MethodSignatureChecker(object): if self._instance: self._bounded_to = self._instance.__class__ else: - self._bounded_to = class_to_bind or getattr(method, "im_class", None) + self._bounded_to = class_to_bind or getattr(method, "im_class", + None) self._has_varargs = varargs is not None self._has_varkw = varkw is not None @@ -929,7 +937,8 @@ class MethodSignatureChecker(object): Args: # arg_name: The name of the argument to mark in arg_status. - # arg_status: Maps argument names to one of _NEEDED, _DEFAULT, _GIVEN. + # arg_status: Maps argument names to one of + # _NEEDED, _DEFAULT, _GIVEN. arg_name: string arg_status: dict @@ -950,10 +959,11 @@ class MethodSignatureChecker(object): named_params: dict Raises: - AttributeError: the given parameters don't work with the given method. + AttributeError: the given parameters don't work with the given + method. """ arg_status = dict((a, MethodSignatureChecker._NEEDED) - for a in self._required_args) + for a in self._required_args) for arg in self._default_args: arg_status[arg] = MethodSignatureChecker._DEFAULT @@ -979,16 +989,17 @@ class MethodSignatureChecker(object): # an exception during this comparison, which is OK. try: param_equality = (params[0] == expected) - except: + except Exception: param_equality = False if isinstance(params[0], expected) or param_equality: params = params[1:] # If the IsA() comparator is being used, we need to check the - # inverse of the usual case - that the given instance is a subclass - # of the expected class. For example, the code under test does - # late binding to a subclass. - elif isinstance(params[0], IsA) and params[0]._IsSubClass(expected): + # inverse of the usual case - that the given instance is a + # subclass of the expected class. For example, the code under + # test does late binding to a subclass. + elif (isinstance(params[0], IsA) and + params[0]._IsSubClass(expected)): params = params[1:] # Check that each positional param is valid. @@ -997,8 +1008,9 @@ class MethodSignatureChecker(object): arg_name = self._args[i] except IndexError: if not self._has_varargs: - raise AttributeError('%s does not take %d or more positional ' - 'arguments' % (self._method.__name__, i)) + raise AttributeError( + '%s does not take %d or more positional ' + 'arguments' % (self._method.__name__, i)) else: self._RecordArgumentGiven(arg_name, arg_status) @@ -1006,15 +1018,15 @@ class MethodSignatureChecker(object): for arg_name in named_params: if arg_name not in arg_status and not self._has_varkw: raise AttributeError('%s is not expecting keyword argument %s' - % (self._method.__name__, arg_name)) + % (self._method.__name__, arg_name)) self._RecordArgumentGiven(arg_name, arg_status) # Ensure all the required arguments have been given. still_needed = [k for k, v in arg_status.items() - if v == MethodSignatureChecker._NEEDED] + if v == MethodSignatureChecker._NEEDED] if still_needed: raise AttributeError('No values given for arguments: %s' - % (' '.join(sorted(still_needed)))) + % (' '.join(sorted(still_needed)))) class MockMethod(object): @@ -1027,22 +1039,25 @@ class MockMethod(object): """ def __init__(self, method_name, call_queue, replay_mode, - method_to_mock=None, description=None, class_to_bind=None): + method_to_mock=None, description=None, class_to_bind=None): """Construct a new mock method. Args: # method_name: the name of the method - # call_queue: deque of calls, verify this call against the head, or add - # this call to the queue. - # replay_mode: False if we are recording, True if we are verifying calls - # against the call queue. - # method_to_mock: The actual method being mocked, used for introspection. - # description: optionally, a descriptive name for this method. Typically - # 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 + # call_queue: deque of calls, verify this call against the head, + # or add this call to the queue. + # replay_mode: False if we are recording, True if we are verifying + # calls against the call queue. + # method_to_mock: The actual method being mocked, used for + # introspection. + # description: optionally, a descriptive name for this method. + # Typically 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 call_queue: list or deque replay_mode: bool @@ -1054,8 +1069,8 @@ class MockMethod(object): self._name = method_name self.__name__ = method_name self._call_queue = call_queue - if not isinstance(call_queue, deque): - self._call_queue = deque(self._call_queue) + if not isinstance(call_queue, collections.deque): + self._call_queue = collections.deque(self._call_queue) self._replay_mode = replay_mode self._description = description @@ -1067,21 +1082,21 @@ class MockMethod(object): try: self._checker = MethodSignatureChecker(method_to_mock, - class_to_bind=class_to_bind) + class_to_bind=class_to_bind) except ValueError: self._checker = None def __call__(self, *params, **named_params): """Log parameters and return the specified return value. - If the Mock(Anything/Object) associated with this call is in record mode, - this MockMethod will be pushed onto the expected call queue. If the mock - is in replay mode, this will pop a MockMethod off the top of the queue and - verify this call is equal to the expected call. + If the Mock(Anything/Object) associated with this call is in record + mode, this MockMethod will be pushed onto the expected call queue. + If the mock is in replay mode, this will pop a MockMethod off the + top of the queue and verify this call is equal to the expected call. Raises: - UnexpectedMethodCall if this call is supposed to match an expected method - call and it does not. + UnexpectedMethodCall if this call is supposed to match an expected + method call and it does not. """ self._params = params @@ -1108,23 +1123,27 @@ class MockMethod(object): def __getattr__(self, name): """Raise an AttributeError with a helpful message.""" - raise AttributeError('MockMethod has no attribute "%s". ' - 'Did you remember to put your mocks in replay mode?' % name) + raise AttributeError( + 'MockMethod has no attribute "%s". ' + 'Did you remember to put your mocks in replay mode?' % name) def __iter__(self): """Raise a TypeError with a helpful message.""" - raise TypeError('MockMethod cannot be iterated. ' - 'Did you remember to put your mocks in replay mode?') + raise TypeError( + 'MockMethod cannot be iterated. ' + 'Did you remember to put your mocks in replay mode?') def next(self): """Raise a TypeError with a helpful message.""" - raise TypeError('MockMethod cannot be iterated. ' - 'Did you remember to put your mocks in replay mode?') + raise TypeError( + 'MockMethod cannot be iterated. ' + 'Did you remember to put your mocks in replay mode?') def __next__(self): """Raise a TypeError with a helpful message.""" - raise TypeError('MockMethod cannot be iterated. ' - 'Did you remember to put your mocks in replay mode?') + raise TypeError( + 'MockMethod cannot be iterated. ' + 'Did you remember to put your mocks in replay mode?') def _PopNextMethod(self): """Pop the next method from our call queue.""" @@ -1162,8 +1181,8 @@ class MockMethod(object): def __str__(self): params = ', '.join( - [repr(p) for p in self._params or []] + - ['%s=%r' % x for x in sorted((self._named_params or {}).items())]) + [repr(p) for p in self._params or []] + + ['%s=%r' % x for x in sorted((self._named_params or {}).items())]) full_desc = "%s(%s) -> %r" % (self._name, params, self._return_value) if self._description: full_desc = "%s.%s" % (self._description, full_desc) @@ -1181,12 +1200,12 @@ class MockMethod(object): """ return (isinstance(rhs, MockMethod) and - self._name == rhs._name and - self._params == rhs._params and - self._named_params == rhs._named_params) + self._name == rhs._name and + self._params == rhs._params and + self._named_params == rhs._named_params) def __ne__(self, rhs): - """Test whether this MockMethod is not equivalent to another MockMethod. + """Test if this MockMethod is not equivalent to another MockMethod. Args: # rhs: the right hand side of the test @@ -1196,8 +1215,9 @@ class MockMethod(object): return not self == rhs def GetPossibleGroup(self): - """Returns a possible group from the end of the call queue or None if no - other methods are on the stack. + """Returns a possible group from the end of the call queue. + + Return None if no other methods are on the stack. """ # Remove this method from the tail of the queue so we can add it @@ -1205,8 +1225,8 @@ class MockMethod(object): this_method = self._call_queue.pop() assert this_method == self - # Determine if the tail of the queue is a group, or just a regular ordered - # mock method. + # Determine if the tail of the queue is a group, or just a regular + # ordered mock method. group = None try: group = self._call_queue[-1] @@ -1217,7 +1237,8 @@ class MockMethod(object): def _CheckAndCreateNewGroup(self, group_name, group_class): """Checks if the last method (a possible group) is an instance of our - group_class. Adds the current method to this group or creates a new one. + group_class. Adds the current method to this group or creates a + new one. Args: @@ -1240,12 +1261,12 @@ class MockMethod(object): def InAnyOrder(self, group_name="default"): """Move this method into a group of unordered calls. - A group of unordered calls must be defined together, and must be executed - in full before the next expected method can be called. There can be - multiple groups that are expected serially, if they are given - different group names. The same group name can be reused if there is a - standard method call, or a group with a different name, spliced between - usages. + A group of unordered calls must be defined together, and must be + executed in full before the next expected method can be called. + There can be multiple groups that are expected serially, if they are + given different group names. The same group name can be reused if there + is a standard method call, or a group with a different name, spliced + between usages. Args: group_name: the name of the unordered group. @@ -1256,10 +1277,10 @@ class MockMethod(object): return self._CheckAndCreateNewGroup(group_name, UnorderedGroup) def MultipleTimes(self, group_name="default"): - """Move this method into group of calls which may be called multiple times. + """Move method into group of calls which may be called multiple times. - A group of repeating calls must be defined together, and must be executed - in full before the next expected method can be called. + A group of repeating calls must be defined together, and must be + executed in full before the next expected method can be called. Args: group_name: the name of the unordered group. @@ -1293,8 +1314,8 @@ class MockMethod(object): """Set the side effects that are simulated when this method is called. Args: - side_effects: A callable which modifies the parameters or other relevant - state which a given test case depends on. + side_effects: A callable which modifies the parameters or other + relevant state which a given test case depends on. Returns: Self for chaining with AndReturn and AndRaise. @@ -1307,10 +1328,10 @@ class Comparator: """Base class for all Mox comparators. A Comparator can be used as a parameter to a mocked method when the exact - value is not known. For example, the code you are testing might build up a - long SQL string that is passed to your mock DAO. You're only interested that - the IN clause contains the proper primary keys, so you can set your mock - up as follows: + value is not known. For example, the code you are testing might build up + a long SQL string that is passed to your mock DAO. You're only interested + that the IN clause contains the proper primary keys, so you can set your + mock up as follows: mock_dao.RunQuery(StrContains('IN (1, 2, 4, 5)')).AndReturn(mock_result) @@ -1442,7 +1463,7 @@ class IsAlmost(Comparator): try: return round(rhs - self._float_value, self._places) == 0 except Exception: - # This is probably because either float_value or rhs is not a number. + # Probably because either float_value or rhs is not a number. return False def __repr__(self): @@ -1565,7 +1586,8 @@ class Not(Comparator): """Checks whether a predicates is False. Example: - mock_dao.UpdateUsers(Not(ContainsKeyValue('stevepm', stevepm_user_info))) + mock_dao.UpdateUsers(Not(ContainsKeyValue('stevepm', + stevepm_user_info))) """ def __init__(self, predicate): @@ -1576,7 +1598,7 @@ class Not(Comparator): """ assert isinstance(predicate, Comparator), ("predicate %r must be a" - " Comparator." % predicate) + " Comparator." % predicate) self._predicate = predicate def equals(self, rhs): @@ -1630,11 +1652,11 @@ class ContainsKeyValue(Comparator): def __repr__(self): return '' % (str(self._key), - str(self._value)) + str(self._value)) class ContainsAttributeValue(Comparator): - """Checks whether a passed parameter contains attributes with a given value. + """Checks whether passed parameter contains attributes with a given value. Example: mock_dao.UpdateSomething(ContainsAttribute('stevepm', stevepm_user_info)) @@ -1690,20 +1712,21 @@ class SameElementsAs(Comparator): bool """ try: - # Store in case actual_seq is an iterator. We potentially iterate twice: - # once to make the dict, once in the list fallback. + # Store in case actual_seq is an iterator. We potentially iterate + # twice: once to make the dict, once in the list fallback. actual_list = list(actual_seq) except TypeError: # actual_seq cannot be read as a sequence. # - # This happens because Mox uses __eq__ both to check object equality (in - # MethodSignatureChecker) and to invoke Comparators. + # This happens because Mox uses __eq__ both to check object + # equality (in MethodSignatureChecker) and to invoke Comparators. return False try: return set(self._expected_list) == set(actual_list) except TypeError: - # Fall back to slower list-compare if any of the objects are unhashable. + # Fall back to slower list-compare if any of the objects + # are unhashable. if len(self._expected_list) != len(actual_list): return False for el in actual_list: @@ -1749,8 +1772,7 @@ class And(Comparator): class Or(Comparator): - """Evaluates one or more Comparators on RHS and returns an OR of the results. - """ + """Evaluates one or more Comparators on RHS; returns OR of the results.""" def __init__(self, *args): """Initialize. @@ -1784,9 +1806,9 @@ class Or(Comparator): class Func(Comparator): """Call a function that should verify the parameter passed in is correct. - You may need the ability to perform more advanced operations on the parameter - in order to validate it. You can use this to have a callable validate any - parameter. The callable should return either True or False. + You may need the ability to perform more advanced operations on the + parameter in order to validate it. You can use this to have a callable + validate any parameter. The callable should return either True or False. Example: @@ -1831,7 +1853,8 @@ class IgnoreArg(Comparator): This can be used when we don't care about an argument of a method call. Example: - # Check if CastMagic is called with 3 as first arg and 'disappear' as third. + # Check if CastMagic is called with 3 as first arg and + # 'disappear' as third. mymock.CastMagic(3, IgnoreArg(), 'disappear') """ @@ -1895,7 +1918,8 @@ class Remember(Comparator): def __init__(self, value_store): if not isinstance(value_store, Value): - raise TypeError("value_store is not an instance of the Value class") + raise TypeError( + "value_store is not an instance of the Value class") self._value_store = value_store def equals(self, rhs): @@ -1941,9 +1965,9 @@ class UnorderedGroup(MethodGroup): def __str__(self): return '%s "%s" pending calls:\n%s' % ( - self.__class__.__name__, - self._group_name, - "\n".join(str(method) for method in self._methods)) + self.__class__.__name__, + self._group_name, + "\n".join(str(method) for method in self._methods)) def AddMethod(self, mock_method): """Add a method to this group. @@ -1961,7 +1985,8 @@ class UnorderedGroup(MethodGroup): raised. Args: - mock_method: a mock method that should be equal to a method in the group. + mock_method: a mock method that should be equal to a method in the + group. Returns: The mock method from the group @@ -1974,13 +1999,14 @@ class UnorderedGroup(MethodGroup): # and return it. for method in self._methods: if method == mock_method: - # Remove the called mock_method instead of the method in the group. - # The called method will match any comparators when equality is checked - # during removal. The method in the group could pass a comparator to - # another comparator during the equality check. + # Remove the called mock_method instead of the method in the + # group. The called method will match any comparators when + # equality is checked during removal. The method in the group + # could pass a comparator to another comparator during the + # equality check. self._methods.remove(mock_method) - # If this group is not empty, put it back at the head of the queue. + # If group is not empty, put it back at the head of the queue. if not self.IsSatisfied(): mock_method._call_queue.appendleft(self) @@ -1999,7 +2025,8 @@ class MultipleTimesGroup(MethodGroup): Note: Each method must be called at least once. - This is helpful, if you don't know or care how many times a method is called. + This is helpful, if you don't know or care how many times a method is + called. """ def __init__(self, group_name): @@ -2024,7 +2051,8 @@ class MultipleTimesGroup(MethodGroup): raised. Args: - mock_method: a mock method that should be equal to a method in the group. + mock_method: a mock method that should be equal to a method in the + group. Returns: The mock method from the group @@ -2038,8 +2066,8 @@ class MultipleTimesGroup(MethodGroup): for method in self._methods: if method == mock_method: self._methods_left.discard(method) - # Always put this group back on top of the queue, because we don't know - # when we are done. + # Always put this group back on top of the queue, + # because we don't know when we are done. mock_method._call_queue.appendleft(self) return self, method @@ -2050,7 +2078,7 @@ class MultipleTimesGroup(MethodGroup): raise UnexpectedMethodCallError(mock_method, self) def IsSatisfied(self): - """Return True if all methods in this group are called at least once.""" + """Return True if all methods in group are called at least once.""" return len(self._methods_left) == 0 @@ -2060,8 +2088,8 @@ class MoxMetaTestBase(type): As the mox unit testing class is being constructed (MoxTestBase or a subclass), this metaclass will modify all test functions to call the CleanUpMox method of the test class after they finish. This means that - unstubbing and verifying will happen for every test with no additional code, - and any failures will result in test failures as opposed to errors. + unstubbing and verifying will happen for every test with no additional + code, and any failures will result in test failures as opposed to errors. """ def __init__(cls, name, bases, d): @@ -2087,8 +2115,10 @@ class MoxMetaTestBase(type): otherwise pass. Args: - cls: MoxTestBase or subclass; the class whose method we are altering. - func: method; the method of the MoxTestBase test class we wish to alter. + cls: MoxTestBase or subclass; the class whose method we are + altering. + func: method; the method of the MoxTestBase test class we wish to + alter. Returns: The modified method. @@ -2100,7 +2130,8 @@ class MoxMetaTestBase(type): cleanup_stubout = False if mox_obj and isinstance(mox_obj, Mox): cleanup_mox = True - if stubout_obj and isinstance(stubout_obj, stubout.StubOutForTesting): + if stubout_obj and isinstance(stubout_obj, + stubout.StubOutForTesting): cleanup_stubout = True try: func(self, *args, **kwargs) @@ -2125,10 +2156,10 @@ class MoxTestBase(_MoxTestBase): """Convenience test class to make stubbing easier. Sets up a "mox" attribute which is an instance of Mox (any mox tests will - want this), and a "stubs" attribute that is an instance of StubOutForTesting - (needed at times). Also automatically unsets any stubs and verifies that all - mock methods have been called at the end of each test, eliminating - boilerplate code. + want this), and a "stubs" attribute that is an instance of + StubOutForTesting (needed at times). Also automatically unsets any stubs + and verifies that all mock methods have been called at the end of each + test, eliminating boilerplate code. """ def setUp(self): diff --git a/mox3/stubout.py b/mox3/stubout.py index 2681e5d..a02ed40 100644 --- a/mox3/stubout.py +++ b/mox3/stubout.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # -# # This is a fork of the pymox library intended to work with Python 3. # The file was modified by quermit@gmail.com and dawid.fatyga@gmail.com @@ -21,16 +20,17 @@ import inspect class StubOutForTesting(object): """Sample Usage: - You want os.path.exists() to always return true during testing. - stubs = StubOutForTesting() - stubs.Set(os.path, 'exists', lambda x: 1) - ... - stubs.UnsetAll() + You want os.path.exists() to always return true during testing. - The above changes os.path.exists into a lambda that returns 1. Once - the ... part of the code finishes, the UnsetAll() looks up the old value - of os.path.exists and restores it. + stubs = StubOutForTesting() + stubs.Set(os.path, 'exists', lambda x: 1) + ... + stubs.UnsetAll() + + The above changes os.path.exists into a lambda that returns 1. Once + the ... part of the code finishes, the UnsetAll() looks up the old value + of os.path.exists and restores it. """ def __init__(self): @@ -42,24 +42,25 @@ class StubOutForTesting(object): self.UnsetAll() def SmartSet(self, obj, attr_name, new_attr): - """Replace obj.attr_name with new_attr. This method is smart and works - at the module, class, and instance level while preserving proper - inheritance. It will not stub out C types however unless that has been - explicitly allowed by the type. - - This method supports the case where attr_name is a staticmethod or a - classmethod of obj. - - Notes: - - If obj is an instance, then it is its class that will actually be - stubbed. Note that the method Set() does not do that: if obj is - an instance, it (and not its class) will be stubbed. - - The stubbing is using the builtin getattr and setattr. So, the __get__ - and __set__ will be called when stubbing (TODO: A better idea would - probably be to manipulate obj.__dict__ instead of getattr() and - setattr()). - - Raises AttributeError if the attribute cannot be found. + """Replace obj.attr_name with new_attr. + + This method is smart and works at the module, class, and instance level + while preserving proper inheritance. It will not stub out C types + however unless that has been explicitly allowed by the type. + + This method supports the case where attr_name is a staticmethod or a + classmethod of obj. + + Notes: + - If obj is an instance, then it is its class that will actually be + stubbed. Note that the method Set() does not do that: if obj is + an instance, it (and not its class) will be stubbed. + - The stubbing is using the builtin getattr and setattr. So, the + __get__ and __set__ will be called when stubbing (TODO: A better + idea would probably be to manipulate obj.__dict__ instead of + getattr() and setattr()). + + Raises AttributeError if the attribute cannot be found. """ if (inspect.ismodule(obj) or (not inspect.isclass(obj) and attr_name in obj.__dict__)): @@ -86,20 +87,22 @@ class StubOutForTesting(object): if orig_attr is None: raise AttributeError("Attribute not found.") - # Calling getattr() on a staticmethod transforms it to a 'normal' function. - # We need to ensure that we put it back as a staticmethod. + # Calling getattr() on a staticmethod transforms it to a 'normal' + # function. We need to ensure that we put it back as a staticmethod. old_attribute = obj.__dict__.get(attr_name) - if old_attribute is not None and isinstance(old_attribute, staticmethod): + if (old_attribute is not None + and isinstance(old_attribute, staticmethod)): orig_attr = staticmethod(orig_attr) self.stubs.append((orig_obj, attr_name, orig_attr)) setattr(orig_obj, attr_name, new_attr) def SmartUnsetAll(self): - """Reverses all the SmartSet() calls, restoring things to their original - definition. Its okay to call SmartUnsetAll() repeatedly, as later calls - have no effect if no SmartSet() calls have been made. + """Reverses all the SmartSet() calls. + Restores things to their original definition. Its okay to call + SmartUnsetAll() repeatedly, as later calls have no effect if no + SmartSet() calls have been made. """ self.stubs.reverse() @@ -109,11 +112,13 @@ class StubOutForTesting(object): self.stubs = [] def Set(self, parent, child_name, new_child): - """Replace child_name's old definition with new_child, in the context - of the given parent. The parent could be a module when the child is a - function at module scope. Or the parent could be a class when a class' - method is being replaced. The named child is set to new_child, while - the prior definition is saved away for later, when UnsetAll() is called. + """Replace child_name's old definition with new_child. + + Replace definiion in the context of the given parent. The parent could + be a module when the child is a function at module scope. Or the parent + could be a class when a class' method is being replaced. The named + child is set to new_child, while the prior definition is saved away + for later, when UnsetAll() is called. This method supports the case where child_name is a staticmethod or a classmethod of parent. @@ -131,13 +136,15 @@ class StubOutForTesting(object): setattr(parent, child_name, new_child) def UnsetAll(self): - """Reverses all the Set() calls, restoring things to their original - definition. Its okay to call UnsetAll() repeatedly, as later calls have - no effect if no Set() calls have been made. + """Reverses all the Set() calls. + Restores things to their original definition. Its okay to call + UnsetAll() repeatedly, as later calls have no effect if no Set() + calls have been made. """ # Undo calls to Set() in reverse order, in case Set() was called on the - # same arguments repeatedly (want the original call to be last one undone) + # same arguments repeatedly (want the original call to be last one + # undone) self.cache.reverse() for (parent, old_child, child_name) in self.cache: diff --git a/mox3/tests/stubout_helper.py b/mox3/tests/stubout_helper.py index 233de89..7a6b266 100644 --- a/mox3/tests/stubout_helper.py +++ b/mox3/tests/stubout_helper.py @@ -12,7 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. # -# # This is a fork of the pymox library intended to work with Python 3. # The file was modified by quermit@gmail.com and dawid.fatyga@gmail.com diff --git a/mox3/tests/test_mox.py b/mox3/tests/test_mox.py index 29c04f2..db00b29 100644 --- a/mox3/tests/test_mox.py +++ b/mox3/tests/test_mox.py @@ -18,12 +18,12 @@ # The file was modified by quermit@gmail.com and dawid.fatyga@gmail.com import io -import unittest import re import sys +import unittest from mox3 import mox -from . import mox_helper +from mox3.tests import mox_helper OS_LISTDIR = mox_helper.os.listdir @@ -40,9 +40,9 @@ class ExpectedMethodCallsErrorTest(unittest.TestCase): method(1, 2).AndReturn('output') e = mox.ExpectedMethodCallsError([method]) self.assertEqual( - "Verify: Expected methods never called:\n" - " 0. testMethod(1, 2) -> 'output'", - str(e)) + "Verify: Expected methods never called:\n" + " 0. testMethod(1, 2) -> 'output'", + str(e)) def testManyErrors(self): method1 = mox.MockMethod("testMethod", [], False) @@ -55,12 +55,12 @@ class ExpectedMethodCallsErrorTest(unittest.TestCase): method4(1, 2).AndReturn('output') e = mox.ExpectedMethodCallsError([method1, method2, method3, method4]) self.assertEqual( - "Verify: Expected methods never called:\n" - " 0. testMethod(1, 2) -> 'output'\n" - " 1. testMethod(a=1, b=2, c='only named') -> None\n" - " 2. testMethod2() -> 44\n" - " 3. testMethod(1, 2) -> 'output'", - str(e)) + "Verify: Expected methods never called:\n" + " 0. testMethod(1, 2) -> 'output'\n" + " 1. testMethod(a=1, b=2, c='only named') -> None\n" + " 2. testMethod2() -> 44\n" + " 3. testMethod(1, 2) -> 'output'", + str(e)) class OrTest(unittest.TestCase): @@ -96,13 +96,13 @@ class AndTest(unittest.TestCase): """ test_dict = {"mock": "obj", "testing": "isCOOL"} self.assertTrue(mox.And(mox.In("testing"), - mox.ContainsKeyValue("mock", "obj")) == test_dict) + mox.ContainsKeyValue("mock", "obj")) == test_dict) def testAdvancedUsageFails(self): """Note: this test is reliant on In and ContainsKeyValue.""" test_dict = {"mock": "obj", "testing": "isCOOL"} self.assertFalse(mox.And(mox.In("NOTFOUND"), - mox.ContainsKeyValue("mock", "obj")) == test_dict) + mox.ContainsKeyValue("mock", "obj")) == test_dict) class FuncTest(unittest.TestCase): @@ -118,7 +118,7 @@ class FuncTest(unittest.TestCase): self.assertFalse(mox.Func(always_none) == 1) self.assertFalse(mox.Func(always_none) == 0) - self.assertFalse(mox.Func(always_none) == None) + self.assertFalse(mox.Func(always_none) is None) def testFuncExceptionPropagation(self): """Exceptions within the validating function should propagate.""" @@ -133,24 +133,24 @@ class FuncTest(unittest.TestCase): self.assertTrue(mox.Func(raiseExceptionOnNotOne) == 1) self.assertRaises( - TestException, mox.Func(raiseExceptionOnNotOne).__eq__, 2) + TestException, mox.Func(raiseExceptionOnNotOne).__eq__, 2) class SameElementsAsTest(unittest.TestCase): - """Test SameElementsAs correctly identifies sequences with same elements.""" + """SameElementsAs correctly identifies sequences with same elements.""" def testSortedLists(self): """Should return True if two lists are exactly equal.""" self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c']) def testUnsortedLists(self): - """Should return True if two lists are unequal but have same elements.""" + """Should return True if lists are unequal but have same elements.""" self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1]) def testUnhashableLists(self): - """Should return True if two lists have the same unhashable elements.""" + """Should return True if lists have the same unhashable elements.""" self.assertTrue(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == - [{2: 'b'}, {'a': 1}]) + [{2: 'b'}, {'a': 1}]) def testEmptyLists(self): """Should return True for two empty lists.""" @@ -161,8 +161,9 @@ class SameElementsAsTest(unittest.TestCase): self.assertFalse(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c']) def testUnequalUnhashableLists(self): - """Should return False if two lists with unhashable items are unequal.""" - self.assertFalse(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}]) + """Should return False if lists with unhashable items are unequal.""" + self.assertFalse(mox.SameElementsAs( + [{'a': 1}, {2: 'b'}]) == [{2: 'b'}]) def testActualIsNotASequence(self): """Should return False if the actual object is not a sequence.""" @@ -196,8 +197,7 @@ class ContainsKeyValueTest(unittest.TestCase): class ContainsAttributeValueTest(unittest.TestCase): - """Test ContainsAttributeValue correctly identifies properties in an object. - """ + """Test ContainsAttributeValue identifies properties in an object.""" def setUp(self): """Create an object to test with.""" @@ -208,8 +208,9 @@ class ContainsAttributeValueTest(unittest.TestCase): self.test_object = TestObject() def testValidPair(self): - """Should return True if the object has the key attribute that matches.""" - self.assertTrue(mox.ContainsAttributeValue("key", 1) == self.test_object) + """Return True if the object has the key attribute that matches.""" + self.assertTrue(mox.ContainsAttributeValue("key", 1) + == self.test_object) def testInvalidValue(self): """Should return False if the value is not correct.""" @@ -221,7 +222,7 @@ class ContainsAttributeValueTest(unittest.TestCase): class InTest(unittest.TestCase): - """Test In correctly identifies a key in a list/dict""" + """Test In correctly identifies a key in a list/dict.""" def testItemInList(self): """Should return True if the item is in the list.""" @@ -262,15 +263,14 @@ class NotTest(unittest.TestCase): class StrContainsTest(unittest.TestCase): - """Test StrContains correctly checks for substring occurrence of a parameter. - """ + """Test StrContains checks for substring occurrence of a parameter.""" def testValidSubstringAtStart(self): - """Should return True if the substring is at the start of the string.""" + """Should return True if substring is at the start of the string.""" self.assertTrue(mox.StrContains("hello") == "hello world") def testValidSubstringInMiddle(self): - """Should return True if the substring is in the middle of the string.""" + """Should return True if substring is in the middle of the string.""" self.assertTrue(mox.StrContains("lo wo") == "hello world") def testValidSubstringAtEnd(self): @@ -294,7 +294,7 @@ class RegexTest(unittest.TestCase): self.assertRaises(re.error, mox.Regex, '(a|b') def testPatternInMiddle(self): - """Should return True if the pattern matches at the middle of the string. + """Return True if the pattern matches at the middle of the string. This ensures that re.search is used (instead of re.find). """ @@ -311,16 +311,16 @@ class RegexTest(unittest.TestCase): def testReprWithoutFlags(self): """repr should return the regular expression pattern.""" self.assertTrue( - repr(mox.Regex(r"a\s+b")) == "") + repr(mox.Regex(r"a\s+b")) == "") def testReprWithFlags(self): """repr should return the regular expression pattern and flags.""" self.assertTrue(repr(mox.Regex(r"a\s+b", flags=4)) == - "") + "") class IsTest(unittest.TestCase): - """Verify Is correctly checks equality based upon identity, not value""" + """Verify Is correctly checks equality based upon identity, not value.""" class AlwaysComparesTrue(object): def __eq__(self, other): @@ -368,7 +368,7 @@ class IsTest(unittest.TestCase): class IsATest(unittest.TestCase): - """Verify IsA correctly checks equality based upon class type, not value.""" + """Verify IsA correctly checks equality based upon class type not value.""" def testEqualityValid(self): """Verify that == correctly identifies objects of the same type.""" @@ -439,7 +439,7 @@ class ValueRememberTest(unittest.TestCase): self.assertEqual(value, 'hello world') 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() self.assertNotEqual(value, None) self.assertNotEqual(value, False) @@ -455,9 +455,9 @@ class ValueRememberTest(unittest.TestCase): """Verify that comparing against remember will store argument.""" value = mox.Value() remember = mox.Remember(value) - self.assertNotEqual(value, 'hello world') # value not yet stored. - self.assertEqual(remember, 'hello world') # store value here. - self.assertEqual(value, 'hello world') # compare against stored value. + self.assertNotEqual(value, 'hello world') # value not yet stored. + self.assertEqual(remember, 'hello world') # store value here. + self.assertEqual(value, 'hello world') # compare against stored value. class MockMethodTest(unittest.TestCase): @@ -465,9 +465,9 @@ class MockMethodTest(unittest.TestCase): def setUp(self): self.expected_method = mox.MockMethod( - "testMethod", [], False)(['original']) - self.mock_method = mox.MockMethod("testMethod", [self.expected_method], - True) + "testMethod", [], False)(['original']) + self.mock_method = mox.MockMethod( + "testMethod", [self.expected_method], True) def testNameAttribute(self): """Should provide a __name__ attribute.""" @@ -476,7 +476,7 @@ class MockMethodTest(unittest.TestCase): def testAndReturnNoneByDefault(self): """Should return None by default.""" return_value = self.mock_method(['original']) - self.assertTrue(return_value == None) + self.assertTrue(return_value is None) def testAndReturnValue(self): """Should return a specificed return value.""" @@ -487,9 +487,12 @@ class MockMethodTest(unittest.TestCase): def testAndRaiseException(self): """Should raise a specified exception.""" - expected_exception = Exception('test exception') + class TestException(Exception): + pass + + expected_exception = TestException('test exception') self.expected_method.AndRaise(expected_exception) - self.assertRaises(Exception, self.mock_method) + self.assertRaises(TestException, self.mock_method) def testWithSideEffects(self): """Should call state modifier.""" @@ -530,7 +533,7 @@ class MockMethodTest(unittest.TestCase): return unexpected_return self.expected_method.WithSideEffects(modifier_with_return).AndReturn( - expected_return) + expected_return) actual_return = self.mock_method(local_list) self.assertEqual('mutation', local_list[0]) self.assertEqual(expected_return, actual_return) @@ -541,7 +544,7 @@ class MockMethodTest(unittest.TestCase): self.assertEqual(self.mock_method, expected_method) def testEqualityNoParamsNotEqual(self): - """Methods with different names and without params should not be equal.""" + """Methods with different names without params should not be equal.""" expected_method = mox.MockMethod("otherMethod", [], False) self.assertNotEqual(self.mock_method, expected_method) @@ -555,7 +558,7 @@ class MockMethodTest(unittest.TestCase): self.assertEqual(self.mock_method, expected_method) def testEqualityParamsNotEqual(self): - """Methods with the same name and different params should not be equal.""" + """Methods with same name and different params should not be equal.""" expected_method = mox.MockMethod("testMethod", [], False) expected_method._params = [1, 2, 3] @@ -572,11 +575,12 @@ class MockMethodTest(unittest.TestCase): self.assertEqual(self.mock_method, expected_method) def testEqualityNamedParamsNotEqual(self): - """Methods with the same name and diffnamed params should not be equal.""" + """Methods with same name and diffnamed params should not be equal.""" expected_method = mox.MockMethod("testMethod", [], False) 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.assertNotEqual(self.mock_method, expected_method) def testEqualityWrongType(self): @@ -598,17 +602,18 @@ class MockMethodTest(unittest.TestCase): def testStrConversion(self): method = mox.MockMethod("f", [], False) method(1, 2, "st", n1=8, n2="st2") - self.assertEqual(str(method), ("f(1, 2, 'st', n1=8, n2='st2') -> None")) + self.assertEqual(str(method), + ("f(1, 2, 'st', n1=8, n2='st2') -> None")) method = mox.MockMethod("testMethod", [], False) method(1, 2, "only positional") self.assertEqual(str(method), - "testMethod(1, 2, 'only positional') -> None") + "testMethod(1, 2, 'only positional') -> None") method = mox.MockMethod("testMethod", [], False) method(a=1, b=2, c="only named") self.assertEqual(str(method), - "testMethod(a=1, b=2, c='only named') -> None") + "testMethod(a=1, b=2, c='only named') -> None") method = mox.MockMethod("testMethod", [], False) method() @@ -616,7 +621,8 @@ class MockMethodTest(unittest.TestCase): method = mox.MockMethod("testMethod", [], False) method(x="only 1 parameter") - self.assertEqual(str(method), "testMethod(x='only 1 parameter') -> None") + self.assertEqual(str(method), + "testMethod(x='only 1 parameter') -> None") method = mox.MockMethod("testMethod", [], False) method().AndReturn('return_value') @@ -660,7 +666,7 @@ class MockAnythingTest(unittest.TestCase): self.mock_object.ValidCall() # setup method call self.mock_object._Replay() # start replay mode self.assertRaises(mox.UnexpectedMethodCallError, - self.mock_object.OtherValidCall) + self.mock_object.OtherValidCall) def testVerifyWithCompleteReplay(self): """Verify should not raise an exception for a valid replay.""" @@ -674,10 +680,11 @@ class MockAnythingTest(unittest.TestCase): self.mock_object.ValidCall() # setup method call self.mock_object._Replay() # start replay mode # ValidCall() is never made - self.assertRaises(mox.ExpectedMethodCallsError, self.mock_object._Verify) + self.assertRaises( + mox.ExpectedMethodCallsError, self.mock_object._Verify) def testSpecialClassMethod(self): - """Verify should not raise an exception when special methods are used.""" + """Verify should not raise exception when special methods are used.""" self.mock_object[1].AndReturn(True) self.mock_object._Replay() returned_val = self.mock_object[1] @@ -769,7 +776,7 @@ class MethodCheckerTest(unittest.TestCase): instance = CheckCallTestClass() method = mox.MockMethod('NoParameters', [], False, - CheckCallTestClass.NoParameters) + CheckCallTestClass.NoParameters) self.assertRaises(AttributeError, method) method(instance) @@ -777,8 +784,8 @@ class MethodCheckerTest(unittest.TestCase): def testNoParameters(self): method = mox.MockMethod('NoParameters', [], False, - CheckCallTestClass.NoParameters, - class_to_bind=CheckCallTestClass) + CheckCallTestClass.NoParameters, + class_to_bind=CheckCallTestClass) method() self.assertRaises(AttributeError, method, 1) self.assertRaises(AttributeError, method, 1, 2) @@ -787,8 +794,8 @@ class MethodCheckerTest(unittest.TestCase): def testOneParameter(self): method = mox.MockMethod('OneParameter', [], False, - CheckCallTestClass.OneParameter, - class_to_bind=CheckCallTestClass) + CheckCallTestClass.OneParameter, + class_to_bind=CheckCallTestClass) self.assertRaises(AttributeError, method) method(1) method(a=1) @@ -799,8 +806,8 @@ class MethodCheckerTest(unittest.TestCase): def testTwoParameters(self): method = mox.MockMethod('TwoParameters', [], False, - CheckCallTestClass.TwoParameters, - class_to_bind=CheckCallTestClass) + CheckCallTestClass.TwoParameters, + class_to_bind=CheckCallTestClass) self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method, 1) self.assertRaises(AttributeError, method, a=1) @@ -817,8 +824,8 @@ class MethodCheckerTest(unittest.TestCase): def testOneDefaultValue(self): method = mox.MockMethod('OneDefaultValue', [], False, - CheckCallTestClass.OneDefaultValue, - class_to_bind=CheckCallTestClass) + CheckCallTestClass.OneDefaultValue, + class_to_bind=CheckCallTestClass) method() method(1) method(a=1) @@ -829,8 +836,8 @@ class MethodCheckerTest(unittest.TestCase): def testTwoDefaultValues(self): method = mox.MockMethod('TwoDefaultValues', [], False, - CheckCallTestClass.TwoDefaultValues, - class_to_bind=CheckCallTestClass) + CheckCallTestClass.TwoDefaultValues, + class_to_bind=CheckCallTestClass) self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method, c=3) self.assertRaises(AttributeError, method, 1) @@ -850,7 +857,7 @@ class MethodCheckerTest(unittest.TestCase): def testArgs(self): method = mox.MockMethod('Args', [], False, CheckCallTestClass.Args, - class_to_bind=CheckCallTestClass) + class_to_bind=CheckCallTestClass) self.assertRaises(AttributeError, method) self.assertRaises(AttributeError, method, 1) method(1, 2) @@ -862,7 +869,7 @@ class MethodCheckerTest(unittest.TestCase): def testKwargs(self): method = mox.MockMethod('Kwargs', [], False, CheckCallTestClass.Kwargs, - class_to_bind=CheckCallTestClass) + class_to_bind=CheckCallTestClass) self.assertRaises(AttributeError, method) method(1) method(1, 2) @@ -878,8 +885,8 @@ class MethodCheckerTest(unittest.TestCase): def testArgsAndKwargs(self): method = mox.MockMethod('ArgsAndKwargs', [], False, - CheckCallTestClass.ArgsAndKwargs, - class_to_bind=CheckCallTestClass) + CheckCallTestClass.ArgsAndKwargs, + class_to_bind=CheckCallTestClass) self.assertRaises(AttributeError, method) method(1) method(1, 2) @@ -930,7 +937,7 @@ class MockObjectTest(unittest.TestCase): self.assertTrue(len(self.mock_object._expected_calls_queue) == 1) def testSetupModeWithInvalidCall(self): - """UnknownMethodCallError should be raised for a non-member method call. + """Rase UnknownMethodCallError for a non-member method call. """ # Note: assertRaises does not catch exceptions thrown by MockObject's # __getattr__ @@ -940,13 +947,14 @@ class MockObjectTest(unittest.TestCase): except mox.UnknownMethodCallError: pass except Exception: - self.fail("Wrong exception type thrown, expected UnknownMethodCallError") + self.fail("Wrong exception type thrown," + " expected UnknownMethodCallError") def testReplayWithInvalidCall(self): - """UnknownMethodCallError should be raised for a non-member method call. + """Rase UnknownMethodCallError for a non-member method call. """ - self.mock_object.ValidCall() # setup method call - self.mock_object._Replay() # start replay mode + self.mock_object.ValidCall() # setup method call + self.mock_object._Replay() # start replay mode # Note: assertRaises does not catch exceptions thrown by MockObject's # __getattr__ try: @@ -955,7 +963,8 @@ class MockObjectTest(unittest.TestCase): except mox.UnknownMethodCallError: pass except Exception: - self.fail("Wrong exception type thrown, expected UnknownMethodCallError") + self.fail("Wrong exception type thrown," + " expected UnknownMethodCallError") def testIsInstance(self): """Mock should be able to pass as an instance of the mocked class.""" @@ -970,7 +979,7 @@ class MockObjectTest(unittest.TestCase): self.assertTrue('_ProtectedCall' in self.mock_object._known_methods) self.assertTrue('__PrivateCall' not in self.mock_object._known_methods) self.assertTrue( - '_TestClass__PrivateCall' in self.mock_object._known_methods) + '_TestClass__PrivateCall' in self.mock_object._known_methods) def testFindsSuperclassMethods(self): """Mock should be able to mock superclasses methods.""" @@ -1282,13 +1291,13 @@ class MockObjectTest(unittest.TestCase): def testCantOverrideMethodsWithAttributes(self): self.assertRaises(ValueError, mox.MockObject, TestClass, - attrs={"ValidCall": "value"}) + attrs={"ValidCall": "value"}) def testCantMockNonPublicAttributes(self): self.assertRaises(mox.PrivateAttributeError, mox.MockObject, TestClass, - attrs={"_protected": "value"}) + attrs={"_protected": "value"}) self.assertRaises(mox.PrivateAttributeError, mox.MockObject, TestClass, - attrs={"__private": "value"}) + attrs={"__private": "value"}) class MoxTest(unittest.TestCase): @@ -1299,7 +1308,7 @@ class MoxTest(unittest.TestCase): def testCreateObject(self): """Mox should create a mock object.""" - mock_obj = self.mox.CreateMock(TestClass) + self.mox.CreateMock(TestClass) def testVerifyObjectWithCompleteReplay(self): """Mox should replay and verify all objects it created.""" @@ -1361,7 +1370,7 @@ class MoxTest(unittest.TestCase): self.mox.VerifyAll() def testInheritedCallableObject(self): - """Test recording calls to an object inheriting from a callable object.""" + """Recording calls to an object inheriting from a callable object.""" mock_obj = self.mox.CreateMock(InheritsFromCallable) mock_obj("foo").AndReturn("qux") self.mox.ReplayAll() @@ -1464,7 +1473,7 @@ class MoxTest(unittest.TestCase): self.mox.VerifyAll() def testUnorderedGroupWithComparator(self): - """Unordered groups should work with comparators""" + """Unordered groups should work with comparators.""" def VerifyOne(cmd): if not isinstance(cmd, str): @@ -1476,9 +1485,9 @@ class MoxTest(unittest.TestCase): mock_obj = self.mox.CreateMockAnything() mock_obj.Foo(['test'], mox.Func(VerifyOne), bar=1).InAnyOrder().\ - AndReturn('yes test') + AndReturn('yes test') mock_obj.Foo(['test'], mox.Func(VerifyTwo), bar=1).InAnyOrder().\ - AndReturn('anything') + AndReturn('anything') self.mox.ReplayAll() @@ -1641,9 +1650,9 @@ class MoxTest(unittest.TestCase): self.mox.ReplayAll() mock_obj.Open() - actual_one = mock_obj.Method(1) mock_obj.Method(1) - actual_three = mock_obj.Method(3) + mock_obj.Method(1) + mock_obj.Method(3) self.assertRaises(mox.UnexpectedMethodCallError, mock_obj.Method, 1) @@ -1652,7 +1661,8 @@ class MoxTest(unittest.TestCase): def modifier(mutable_list): mutable_list[0] = 'mutated' mock_obj = self.mox.CreateMockAnything() - mock_obj.ConfigureInOutParameter(['original']).WithSideEffects(modifier) + mock_obj.ConfigureInOutParameter( + ['original']).WithSideEffects(modifier) mock_obj.WorkWithParameter(['mutated']) self.mox.ReplayAll() @@ -1664,18 +1674,21 @@ class MoxTest(unittest.TestCase): def testWithSideEffectsException(self): """Test side effect operations actually modify their target objects.""" + class TestException(Exception): + pass + def modifier(mutable_list): mutable_list[0] = 'mutated' mock_obj = self.mox.CreateMockAnything() method = mock_obj.ConfigureInOutParameter(['original']) - method.WithSideEffects(modifier).AndRaise(Exception('exception')) + method.WithSideEffects(modifier).AndRaise(TestException('exception')) mock_obj.WorkWithParameter(['mutated']) self.mox.ReplayAll() local_list = ['original'] - self.assertRaises(Exception, - mock_obj.ConfigureInOutParameter, - local_list) + self.assertRaises(TestException, + mock_obj.ConfigureInOutParameter, + local_list) mock_obj.WorkWithParameter(local_list) self.mox.VerifyAll() @@ -1714,9 +1727,9 @@ class MoxTest(unittest.TestCase): def testStubOutMethod_Unbound_Subclass_Comparator(self): self.mox.StubOutWithMock( - mox_helper.TestClassFromAnotherModule, 'Value') + mox_helper.TestClassFromAnotherModule, 'Value') mox_helper.TestClassFromAnotherModule.Value( - mox.IsA(mox_helper.ChildClassFromAnotherModule)).AndReturn('foo') + mox.IsA(mox_helper.ChildClassFromAnotherModule)).AndReturn('foo') self.mox.ReplayAll() instance = mox_helper.ChildClassFromAnotherModule() @@ -1760,7 +1773,7 @@ class MoxTest(unittest.TestCase): # This should fail, since the instances are different self.assertRaises(mox.UnexpectedMethodCallError, - TestClass.OtherValidCall, "wrong self") + TestClass.OtherValidCall, "wrong self") self.mox.VerifyAll() self.mox.UnsetStubs() @@ -1848,7 +1861,7 @@ class MoxTest(unittest.TestCase): self.mox.UnsetStubs() def testStubOutMethod_Func_PropgatesExceptions(self): - """Errors in a Func comparator should propagate to the calling method.""" + """Errors in Func comparator should propagate to the calling method.""" class TestException(Exception): pass @@ -1861,14 +1874,14 @@ class MoxTest(unittest.TestCase): test_obj = TestClass() self.mox.StubOutWithMock(test_obj, 'MethodWithArgs') test_obj.MethodWithArgs( - mox.IgnoreArg(), mox.Func(raiseExceptionOnNotOne)).AndReturn(1) + mox.IgnoreArg(), mox.Func(raiseExceptionOnNotOne)).AndReturn(1) test_obj.MethodWithArgs( - mox.IgnoreArg(), mox.Func(raiseExceptionOnNotOne)).AndReturn(1) + mox.IgnoreArg(), mox.Func(raiseExceptionOnNotOne)).AndReturn(1) self.mox.ReplayAll() self.assertEqual(test_obj.MethodWithArgs('ignored', 1), 1) self.assertRaises(TestException, - test_obj.MethodWithArgs, 'ignored', 2) + test_obj.MethodWithArgs, 'ignored', 2) self.mox.VerifyAll() self.mox.UnsetStubs() @@ -1889,10 +1902,10 @@ class MoxTest(unittest.TestCase): """Test a mocked class whose __init__ returns a Mock.""" self.mox.StubOutWithMock(mox_helper, 'TestClassFromAnotherModule') self.assertTrue(isinstance(mox_helper.TestClassFromAnotherModule, - mox.MockObject)) + mox.MockObject)) mock_instance = self.mox.CreateMock( - mox_helper.TestClassFromAnotherModule) + mox_helper.TestClassFromAnotherModule) mox_helper.TestClassFromAnotherModule().AndReturn(mock_instance) mock_instance.Value().AndReturn('mock instance') @@ -1937,7 +1950,7 @@ class MoxTest(unittest.TestCase): def testStubOutClass_NotAClass(self): self.assertRaises(TypeError, self.mox.StubOutClassWithMocks, - mox_helper, 'MyTestFunction') + mox_helper, 'MyTestFunction') def testStubOutClassNotEnoughCreated(self): self.mox.StubOutClassWithMocks(mox_helper, 'CallableClass') @@ -1966,7 +1979,7 @@ class MoxTest(unittest.TestCase): self.mox.ReplayAll() self.assertRaises(mox.UnexpectedMethodCallError, - mox_helper.CallableClass, 8, 9) + mox_helper.CallableClass, 8, 9) self.mox.UnsetStubs() def testStubOutClassTooManyCreated(self): @@ -1977,7 +1990,7 @@ class MoxTest(unittest.TestCase): self.mox.ReplayAll() mox_helper.CallableClass(1, 2) self.assertRaises(mox.UnexpectedMockCreationError, - mox_helper.CallableClass, 8, 9) + mox_helper.CallableClass, 8, 9) self.mox.UnsetStubs() @@ -1985,7 +1998,7 @@ class MoxTest(unittest.TestCase): """Test that user is warned if they try to stub out a MockAnything.""" self.mox.StubOutWithMock(TestClass, 'MyStaticMethod') self.assertRaises(TypeError, self.mox.StubOutWithMock, TestClass, - 'MyStaticMethod') + 'MyStaticMethod') def testStubOutFirstClassMethodVerifiesSignature(self): self.mox.StubOutWithMock(mox_helper, 'MyTestFunction') @@ -2038,8 +2051,7 @@ class MoxTest(unittest.TestCase): self.assertFalse(isinstance(foo.obj, mox.MockObject)) 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 helpful msg.""" foo = self.mox.CreateMockAnything() bar = self.mox.CreateMockAnything() foo.GetBar().AndReturn(bar) @@ -2048,8 +2060,9 @@ class MoxTest(unittest.TestCase): try: foo.GetBar().ShowMeTheMoney() except AttributeError as e: - self.assertEqual('MockMethod has no attribute "ShowMeTheMoney". ' - 'Did you remember to put your mocks in replay mode?', str(e)) + self.assertEqual( + 'MockMethod has no attribute "ShowMeTheMoney". ' + 'Did you remember to put your mocks in replay mode?', str(e)) class ReplayTest(unittest.TestCase): @@ -2064,7 +2077,7 @@ class ReplayTest(unittest.TestCase): class MoxTestBaseTest(unittest.TestCase): - """Verify that all tests in a class derived from MoxTestBase are wrapped.""" + """Verify that all tests in class derived from MoxTestBase are wrapped.""" def setUp(self): self.mox = mox.Mox() @@ -2081,8 +2094,8 @@ class MoxTestBaseTest(unittest.TestCase): def _setUpTestClass(self): """Replacement for setUp in the test class instance. - Assigns a mox.Mox instance as the mox attribute of the test class instance. - This replacement Mox instance is under our control before setUp is called + Assigns a mox.Mox instance as the mox attribute of the test instance. + Replacement Mox instance is under our control before setUp is called in the test class instance. """ self.test.mox = self.test_mox @@ -2119,7 +2132,7 @@ class MoxTestBaseTest(unittest.TestCase): self._VerifySuccess() def testSuccessNoMocks(self): - """Let testSuccess() unset all the mocks, and verify they've been unset.""" + """testSuccess() unsets all the mocks. Vverify they've been unset.""" self._CreateTest('testSuccess') self.test.run(result=self.result) self.assertTrue(self.result.wasSuccessful()) @@ -2199,7 +2212,7 @@ class MoxTestBaseTest(unittest.TestCase): def testMixinAgain(self): """Run same test as above but from the current test class. - This ensures metaclass properly wrapped test methods from all base classes. + Ensures metaclass properly wrapped test methods from all base classes. If unsetting of stubs doesn't happen, this will fail. """ self._CreateTest('testStatOther') @@ -2212,7 +2225,7 @@ class VerifyTest(unittest.TestCase): def testVerify(self): """Verify should be called for all objects. - This should throw an exception because the expected behavior did not occur. + Should throw an exception because the expected behavior did not occur. """ mock_obj = mox.MockObject(TestClass) mock_obj.ValidCall() @@ -2275,11 +2288,11 @@ class MoxTestDontMockProperties(MoxTestBaseTest): def testPropertiesArentMocked(self): mock_class = self.mox.CreateMock(ClassWithProperties) self.assertRaises(mox.UnknownMethodCallError, - lambda: mock_class.prop_attr) + lambda: mock_class.prop_attr) class TestClass(object): - """This class is used only for testing the mock framework""" + """This class is used only for testing the mock framework.""" SOME_CLASS_VAR = "test_value" _PROTECTED_CLASS_VAR = "protected value" @@ -2376,7 +2389,7 @@ class SubscribtableNonIterableClass(object): class InheritsFromCallable(CallableClass): - """This class should also be mockable; it inherits from a callable class.""" + """This class should be mockable; it inherits from a callable class.""" pass diff --git a/mox3/tests/test_stubout.py b/mox3/tests/test_stubout.py index e729d34..621e4d7 100644 --- a/mox3/tests/test_stubout.py +++ b/mox3/tests/test_stubout.py @@ -19,7 +19,7 @@ import unittest from mox3 import mox from mox3 import stubout -from . import stubout_helper +from mox3.tests import stubout_helper class StubOutForTestingTest(unittest.TestCase): diff --git a/setup.py b/setup.py index 0c9e136..b3e85a7 100644 --- a/setup.py +++ b/setup.py @@ -17,5 +17,5 @@ import setuptools setuptools.setup( - setup_requires=['d2to1>=0.2.10,<0.3', 'pbr>=0.5.10,<0.6'], - d2to1=True) + setup_requires=['d2to1>=0.2.10,<0.3', 'pbr>=0.5.10,<0.6'], + d2to1=True) diff --git a/tox.ini b/tox.ini index 69c834e..bbc49e1 100644 --- a/tox.ini +++ b/tox.ini @@ -22,6 +22,5 @@ commands = [flake8] show-source = true -ignore = H builtins = _ exclude=.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg -- cgit v1.2.1