Add pymox to tests folder.
Requested by Sverre.
Patch by: Pawel Solyga
Reviewed by: to-be-reviewed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/COPYING Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/MANIFEST.in Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,3 @@
+include COPYING
+include mox_test.py
+include mox_test_helper.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/README Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,56 @@
+Mox is an open source mock object framework for Python, inspired by
+the Java library EasyMock.
+
+To install:
+
+ $ python setup.py install
+
+To run Mox's internal tests:
+
+ $ python mox_test.py
+
+Basic usage:
+
+ import unittest
+ import mox
+
+ class PersonTest(mox.MoxTestBase):
+
+ def testUsingMox(self):
+ # Create a mock Person
+ mock_person = self.mox.CreateMock(Person)
+
+ test_person = ...
+ test_primary_key = ...
+ unknown_person = ...
+
+ # Expect InsertPerson to be called with test_person; return
+ # test_primary_key at that point
+ mock_person.InsertPerson(test_person).AndReturn(test_primary_key)
+
+ # Raise an exception when this is called
+ mock_person.DeletePerson(unknown_person).AndRaise(UnknownPersonError())
+
+ # Switch from record mode to replay mode
+ self.mox.ReplayAll()
+
+ # Run the test
+ ret_pk = mock_person.InsertPerson(test_person)
+ self.assertEquals(test_primary_key, ret_pk)
+ self.assertRaises(UnknownPersonError, mock_person, unknown_person)
+
+For more documentation, see:
+
+ http://code.google.com/p/pymox/wiki/MoxDocumentation
+
+For more information, see:
+
+ http://code.google.com/p/pymox/
+
+Our user and developer discussion group is:
+
+ http://groups.google.com/group/mox-discuss
+
+Mox is Copyright 2008 Google Inc, and licensed under the Apache
+License, Version 2.0; see the file COPYING for details. If you would
+like to help us improve Mox, join the group.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/mox.py Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,1567 @@
+#!/usr/bin/python2.4
+#
+# Copyright 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Mox, an object-mocking framework for Python.
+
+Mox works in the record-replay-verify paradigm. When you first create
+a mock object, it is in record mode. You then programmatically set
+the expected behavior of the mock object (what methods are to be
+called on it, with what parameters, what they should return, and in
+what order).
+
+Once you have set up the expected mock behavior, you put it in replay
+mode. Now the mock responds to method calls just as you told it to.
+If an unexpected method (or an expected method with unexpected
+parameters) is called, then an exception will be raised.
+
+Once you are done interacting with the mock, you need to verify that
+all the expected interactions occured. (Maybe your code exited
+prematurely without calling some cleanup method!) The verify phase
+ensures that every expected method was called; otherwise, an exception
+will be raised.
+
+Suggested usage / workflow:
+
+ # Create Mox factory
+ my_mox = Mox()
+
+ # Create a mock data access object
+ mock_dao = my_mox.CreateMock(DAOClass)
+
+ # Set up expected behavior
+ mock_dao.RetrievePersonWithIdentifier('1').AndReturn(person)
+ mock_dao.DeletePerson(person)
+
+ # Put mocks in replay mode
+ my_mox.ReplayAll()
+
+ # Inject mock object and run test
+ controller.SetDao(mock_dao)
+ controller.DeletePersonById('1')
+
+ # Verify all methods were called as expected
+ my_mox.VerifyAll()
+"""
+
+from collections import deque
+import inspect
+import re
+import types
+import unittest
+
+import stubout
+
+class Error(AssertionError):
+ """Base exception for this module."""
+
+ pass
+
+
+class ExpectedMethodCallsError(Error):
+ """Raised when Verify() is called before all expected methods have been called
+ """
+
+ def __init__(self, expected_methods):
+ """Init exception.
+
+ Args:
+ # expected_methods: A sequence of MockMethod objects that should have been
+ # called.
+ expected_methods: [MockMethod]
+
+ Raises:
+ ValueError: if expected_methods contains no methods.
+ """
+
+ if not expected_methods:
+ raise ValueError("There must be at least one expected method")
+ Error.__init__(self)
+ self._expected_methods = expected_methods
+
+ def __str__(self):
+ calls = "\n".join(["%3d. %s" % (i, m)
+ for i, m in enumerate(self._expected_methods)])
+ return "Verify: Expected methods never called:\n%s" % (calls,)
+
+
+class UnexpectedMethodCallError(Error):
+ """Raised when an unexpected method is called.
+
+ This can occur if a method is called with incorrect parameters, or out of the
+ specified order.
+ """
+
+ def __init__(self, unexpected_method, expected):
+ """Init exception.
+
+ Args:
+ # unexpected_method: MockMethod that was called but was not at the head of
+ # the expected_method queue.
+ # expected: MockMethod or UnorderedGroup the method should have
+ # been in.
+ unexpected_method: MockMethod
+ expected: MockMethod or UnorderedGroup
+ """
+
+ Error.__init__(self)
+ self._unexpected_method = unexpected_method
+ self._expected = expected
+
+ def __str__(self):
+ return "Unexpected method call: %s. Expecting: %s" % \
+ (self._unexpected_method, self._expected)
+
+
+class UnknownMethodCallError(Error):
+ """Raised if an unknown method is requested of the mock object."""
+
+ def __init__(self, unknown_method_name):
+ """Init exception.
+
+ Args:
+ # unknown_method_name: Method call that is not part of the mocked class's
+ # public interface.
+ unknown_method_name: str
+ """
+
+ Error.__init__(self)
+ self._unknown_method_name = unknown_method_name
+
+ def __str__(self):
+ return "Method called is not a member of the object: %s" % \
+ self._unknown_method_name
+
+
+class Mox(object):
+ """Mox: a factory for creating mock objects."""
+
+ # A list of types that should be stubbed out with MockObjects (as
+ # opposed to MockAnythings).
+ _USE_MOCK_OBJECT = [types.ClassType, types.InstanceType, types.ModuleType,
+ types.ObjectType, types.TypeType]
+
+ def __init__(self):
+ """Initialize a new Mox."""
+
+ self._mock_objects = []
+ self.stubs = stubout.StubOutForTesting()
+
+ def CreateMock(self, class_to_mock):
+ """Create a new mock object.
+
+ Args:
+ # class_to_mock: the class to be mocked
+ class_to_mock: class
+
+ Returns:
+ MockObject that can be used as the class_to_mock would be.
+ """
+
+ new_mock = MockObject(class_to_mock)
+ self._mock_objects.append(new_mock)
+ return new_mock
+
+ def CreateMockAnything(self):
+ """Create a mock that will accept any method calls.
+
+ This does not enforce an interface.
+ """
+
+ new_mock = MockAnything()
+ self._mock_objects.append(new_mock)
+ return new_mock
+
+ def ReplayAll(self):
+ """Set all mock objects to replay mode."""
+
+ for mock_obj in self._mock_objects:
+ mock_obj._Replay()
+
+
+ def VerifyAll(self):
+ """Call verify on all mock objects created."""
+
+ for mock_obj in self._mock_objects:
+ mock_obj._Verify()
+
+ def ResetAll(self):
+ """Call reset on all mock objects. This does not unset stubs."""
+
+ for mock_obj in self._mock_objects:
+ mock_obj._Reset()
+
+ 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.
+
+ 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_to_replace = getattr(obj, attr_name)
+ if type(attr_to_replace) in self._USE_MOCK_OBJECT and not use_mock_anything:
+ stub = self.CreateMock(attr_to_replace)
+ else:
+ stub = self.CreateMockAnything()
+
+ self.stubs.Set(obj, attr_name, stub)
+
+ def UnsetStubs(self):
+ """Restore stubs to their original state."""
+
+ self.stubs.UnsetAll()
+
+def Replay(*args):
+ """Put mocks into Replay mode.
+
+ Args:
+ # args is any number of mocks to put into replay mode.
+ """
+
+ for mock in args:
+ mock._Replay()
+
+
+def Verify(*args):
+ """Verify mocks.
+
+ Args:
+ # args is any number of mocks to be verified.
+ """
+
+ for mock in args:
+ mock._Verify()
+
+
+def Reset(*args):
+ """Reset mocks.
+
+ Args:
+ # args is any number of mocks to be reset.
+ """
+
+ for mock in args:
+ mock._Reset()
+
+
+class MockAnything:
+ """A mock that can be used to mock anything.
+
+ This is helpful for mocking classes that do not provide a public interface.
+ """
+
+ def __init__(self):
+ """ """
+ self._Reset()
+
+ def __getattr__(self, method_name):
+ """Intercept method calls on this object.
+
+ A new MockMethod is returned that is aware of the MockAnything's
+ state (record or replay). The call will be recorded or replayed
+ by the MockMethod's __call__.
+
+ Args:
+ # method name: the name of the method being called.
+ method_name: str
+
+ Returns:
+ A new MockMethod aware of MockAnything's state (record or replay).
+ """
+
+ return self._CreateMockMethod(method_name)
+
+ def _CreateMockMethod(self, method_name, method_to_mock=None):
+ """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.
+ method_name: str
+ method_to_mock: a method object
+
+ Returns:
+ A new MockMethod aware of MockAnything's state (record or replay).
+ """
+
+ return MockMethod(method_name, self._expected_calls_queue,
+ self._replay_mode, method_to_mock=method_to_mock)
+
+ def __nonzero__(self):
+ """Return 1 for nonzero so the mock can be used as a conditional."""
+
+ return 1
+
+ def __eq__(self, rhs):
+ """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)
+
+ def __ne__(self, rhs):
+ """Provide custom logic to compare objects."""
+
+ return not self == rhs
+
+ def _Replay(self):
+ """Start replaying expected method calls."""
+
+ self._replay_mode = True
+
+ def _Verify(self):
+ """Verify that all of the expected calls have been made.
+
+ Raises:
+ 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
+ self._expected_calls_queue[0].IsSatisfied()):
+ pass
+ else:
+ raise ExpectedMethodCallsError(self._expected_calls_queue)
+
+ def _Reset(self):
+ """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()
+
+ # Make sure we are in setup mode, not replay mode
+ self._replay_mode = False
+
+
+class MockObject(MockAnything, object):
+ """A mock object that simulates the public/protected interface of a class."""
+
+ def __init__(self, class_to_mock):
+ """Initialize a mock object.
+
+ This determines the methods and properties of the class and stores them.
+
+ Args:
+ # class_to_mock: class to be mocked
+ class_to_mock: class
+ """
+
+ # This is used to hack around the mixin/inheritance of MockAnything, which
+ # is not a proper object (it can be anything. :-)
+ MockAnything.__dict__['__init__'](self)
+
+ # Get a list of all the public and special methods we should mock.
+ self._known_methods = set()
+ self._known_vars = set()
+ self._class_to_mock = class_to_mock
+ for method in dir(class_to_mock):
+ if callable(getattr(class_to_mock, method)):
+ self._known_methods.add(method)
+ else:
+ self._known_vars.add(method)
+
+ 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 not a variable, it is handled like a method
+ call. The method name is checked against the set of mockable
+ methods, and a new MockMethod is returned that is aware of the
+ MockObject's state (record or replay). The call will be recorded
+ or replayed by the MockMethod's __call__.
+
+ Args:
+ # name: the name of the attribute being requested.
+ name: str
+
+ Returns:
+ 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.
+ """
+
+ if name in self._known_vars:
+ return getattr(self._class_to_mock, name)
+
+ if name in self._known_methods:
+ return self._CreateMockMethod(
+ name,
+ method_to_mock=getattr(self._class_to_mock, name))
+
+ raise UnknownMethodCallError(name)
+
+ def __eq__(self, rhs):
+ """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)
+
+ def __setitem__(self, key, value):
+ """Provide 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.
+
+ Raises:
+ TypeError if the underlying class does not support item assignment.
+ UnexpectedMethodCallError if the object does not expect the call to
+ __setitem__.
+
+ """
+ setitem = self._class_to_mock.__dict__.get('__setitem__', None)
+
+ # Verify the class supports item assignment.
+ if setitem is None:
+ raise TypeError('object does not support item assignment')
+
+ # 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)
+
+
+ # Otherwise, create a mock method __setitem__.
+ return self._CreateMockMethod('__setitem__')(key, value)
+
+ def __getitem__(self, key):
+ """Provide custom logic for mocking classes that are subscriptable.
+
+ Args:
+ 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.
+
+ Raises:
+ TypeError if the underlying class is not subscriptable.
+ UnexpectedMethodCallError if the object does not expect the call to
+ __setitem__.
+
+ """
+ getitem = self._class_to_mock.__dict__.get('__getitem__', None)
+
+ # Verify the class supports item assignment.
+ if getitem is None:
+ raise TypeError('unsubscriptable object')
+
+ # 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)
+
+
+ # Otherwise, create a mock method __getitem__.
+ return self._CreateMockMethod('__getitem__')(key)
+
+ def __contains__(self, key):
+ """Provide custom logic for mocking classes that contain items.
+
+ Args:
+ 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.
+
+ Raises:
+ TypeError if the underlying class does not implement __contains__
+ UnexpectedMethodCaller if the object does not expect the call to
+ __contains__.
+
+ """
+ contains = self._class_to_mock.__dict__.get('__contains__', None)
+
+ if contains is None:
+ raise TypeError('unsubscriptable object')
+
+ if self._replay_mode:
+ return MockMethod('__contains__', self._expected_calls_queue,
+ self._replay_mode)(key)
+
+ return self._CreateMockMethod('__contains__')(key)
+
+ def __call__(self, *params, **named_params):
+ """Provide custom logic for mocking classes that are callable."""
+
+ # Verify the class we are mocking is callable
+ callable = self._class_to_mock.__dict__.get('__call__', None)
+ if callable is None:
+ raise TypeError('Not callable')
+
+ # Because the call is happening directly on this object instead of a method,
+ # the call on the mock method is made right here
+ mock_method = self._CreateMockMethod('__call__')
+ return mock_method(*params, **named_params)
+
+ @property
+ def __class__(self):
+ """Return the class that is being mocked."""
+
+ return self._class_to_mock
+
+
+class MethodCallChecker(object):
+ """Ensures that methods are called correctly."""
+
+ _NEEDED, _DEFAULT, _GIVEN = range(3)
+
+ def __init__(self, method):
+ """Creates a checker.
+
+ Args:
+ # method: A method to check.
+ method: function
+
+ Raises:
+ 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,))
+ if inspect.ismethod(method):
+ self._args = self._args[1:] # Skip 'self'.
+ self._method = method
+
+ self._has_varargs = varargs is not None
+ self._has_varkw = varkw is not None
+ if defaults is None:
+ self._required_args = self._args
+ self._default_args = []
+ else:
+ self._required_args = self._args[:-len(defaults)]
+ self._default_args = self._args[-len(defaults):]
+
+ def _RecordArgumentGiven(self, arg_name, arg_status):
+ """Mark an argument as being given.
+
+ 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_name: string
+ arg_status: dict
+
+ Raises:
+ AttributeError: arg_name is already marked as _GIVEN.
+ """
+ if arg_status.get(arg_name, None) == MethodCallChecker._GIVEN:
+ raise AttributeError('%s provided more than once' % (arg_name,))
+ arg_status[arg_name] = MethodCallChecker._GIVEN
+
+ def Check(self, params, named_params):
+ """Ensures that the parameters used while recording a call are valid.
+
+ Args:
+ # params: A list of positional parameters.
+ # named_params: A dict of named parameters.
+ params: list
+ named_params: dict
+
+ Raises:
+ AttributeError: the given parameters don't work with the given method.
+ """
+ arg_status = dict((a, MethodCallChecker._NEEDED)
+ for a in self._required_args)
+ for arg in self._default_args:
+ arg_status[arg] = MethodCallChecker._DEFAULT
+
+ # Check that each positional param is valid.
+ for i in range(len(params)):
+ try:
+ 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))
+ else:
+ self._RecordArgumentGiven(arg_name, arg_status)
+
+ # Check each keyword argument.
+ 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._RecordArgumentGiven(arg_name, arg_status)
+
+ # Ensure all the required arguments have been given.
+ still_needed = [k for k, v in arg_status.iteritems()
+ if v == MethodCallChecker._NEEDED]
+ if still_needed:
+ raise AttributeError('No values given for arguments %s'
+ % (' '.join(sorted(still_needed))))
+
+
+class MockMethod(object):
+ """Callable mock method.
+
+ A MockMethod should act exactly like the method it mocks, accepting parameters
+ and returning a value, or throwing an exception (as specified). When this
+ method is called, it can optionally verify whether the called method (name and
+ signature) matches the expected method.
+ """
+
+ def __init__(self, method_name, call_queue, replay_mode, method_to_mock=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.
+ method_name: str
+ call_queue: list or deque
+ replay_mode: bool
+ method_to_mock: a method object
+ """
+
+ self._name = method_name
+ self._call_queue = call_queue
+ if not isinstance(call_queue, deque):
+ self._call_queue = deque(self._call_queue)
+ self._replay_mode = replay_mode
+
+ self._params = None
+ self._named_params = None
+ self._return_value = None
+ self._exception = None
+ self._side_effects = None
+
+ try:
+ self._checker = MethodCallChecker(method_to_mock)
+ 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.
+
+ Raises:
+ UnexpectedMethodCall if this call is supposed to match an expected method
+ call and it does not.
+ """
+
+ self._params = params
+ self._named_params = named_params
+
+ if not self._replay_mode:
+ if self._checker is not None:
+ self._checker.Check(params, named_params)
+ self._call_queue.append(self)
+ return self
+
+ expected_method = self._VerifyMethodCall()
+
+ if expected_method._side_effects:
+ expected_method._side_effects(*params, **named_params)
+
+ if expected_method._exception:
+ raise expected_method._exception
+
+ return expected_method._return_value
+
+ 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)
+
+ def _PopNextMethod(self):
+ """Pop the next method from our call queue."""
+ try:
+ return self._call_queue.popleft()
+ except IndexError:
+ raise UnexpectedMethodCallError(self, None)
+
+ def _VerifyMethodCall(self):
+ """Verify the called method is expected.
+
+ This can be an ordered method, or part of an unordered set.
+
+ Returns:
+ The expected mock method.
+
+ Raises:
+ UnexpectedMethodCall if the method called was not expected.
+ """
+
+ expected = self._PopNextMethod()
+
+ # Loop here, because we might have a MethodGroup followed by another
+ # group.
+ while isinstance(expected, MethodGroup):
+ expected, method = expected.MethodCalled(self)
+ if method is not None:
+ return method
+
+ # This is a mock method, so just check equality.
+ if expected != self:
+ raise UnexpectedMethodCallError(self, expected)
+
+ return expected
+
+ 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())])
+ desc = "%s(%s) -> %r" % (self._name, params, self._return_value)
+ return desc
+
+ def __eq__(self, rhs):
+ """Test whether this MockMethod is equivalent to another MockMethod.
+
+ Args:
+ # rhs: the right hand side of the test
+ rhs: MockMethod
+ """
+
+ return (isinstance(rhs, MockMethod) and
+ 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.
+
+ Args:
+ # rhs: the right hand side of the test
+ rhs: MockMethod
+ """
+
+ 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.
+ """
+
+ # Remove this method from the tail of the queue so we can add it to a group.
+ 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.
+ group = None
+ try:
+ group = self._call_queue[-1]
+ except IndexError:
+ pass
+
+ return group
+
+ 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.
+
+ Args:
+
+ group_name: the name of the group.
+ group_class: the class used to create instance of this new group
+ """
+ group = self.GetPossibleGroup()
+
+ # If this is a group, and it is the correct group, add the method.
+ if isinstance(group, group_class) and group.group_name() == group_name:
+ group.AddMethod(self)
+ return self
+
+ # Create a new group and add the method.
+ new_group = group_class(group_name)
+ new_group.AddMethod(self)
+ self._call_queue.append(new_group)
+ return self
+
+ 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.
+
+ Args:
+ group_name: the name of the unordered group.
+
+ Returns:
+ self
+ """
+ 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.
+
+ A group of repeating calls must be defined together, and must be executed in
+ full before the next expected mehtod can be called.
+
+ Args:
+ group_name: the name of the unordered group.
+
+ Returns:
+ self
+ """
+ return self._CheckAndCreateNewGroup(group_name, MultipleTimesGroup)
+
+ def AndReturn(self, return_value):
+ """Set the value to return when this method is called.
+
+ Args:
+ # return_value can be anything.
+ """
+
+ self._return_value = return_value
+ return return_value
+
+ def AndRaise(self, exception):
+ """Set the exception to raise when this method is called.
+
+ Args:
+ # exception: the exception to raise when this method is called.
+ exception: Exception
+ """
+
+ self._exception = exception
+
+ def WithSideEffects(self, side_effects):
+ """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.
+
+ Returns:
+ Self for chaining with AndReturn and AndRaise.
+ """
+ self._side_effects = side_effects
+ return self
+
+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:
+
+ mock_dao.RunQuery(StrContains('IN (1, 2, 4, 5)')).AndReturn(mock_result)
+
+ Now whatever query is passed in must contain the string 'IN (1, 2, 4, 5)'.
+
+ A Comparator may replace one or more parameters, for example:
+ # return at most 10 rows
+ mock_dao.RunQuery(StrContains('SELECT'), 10)
+
+ or
+
+ # Return some non-deterministic number of rows
+ mock_dao.RunQuery(StrContains('SELECT'), IsA(int))
+ """
+
+ def equals(self, rhs):
+ """Special equals method that all comparators must implement.
+
+ Args:
+ rhs: any python object
+ """
+
+ raise NotImplementedError, 'method must be implemented by a subclass.'
+
+ def __eq__(self, rhs):
+ return self.equals(rhs)
+
+ def __ne__(self, rhs):
+ return not self.equals(rhs)
+
+
+class IsA(Comparator):
+ """This class wraps a basic Python type or class. It is used to verify
+ that a parameter is of the given type or class.
+
+ Example:
+ mock_dao.Connect(IsA(DbConnectInfo))
+ """
+
+ def __init__(self, class_name):
+ """Initialize IsA
+
+ Args:
+ class_name: basic python type or a class
+ """
+
+ self._class_name = class_name
+
+ def equals(self, rhs):
+ """Check to see if the RHS is an instance of class_name.
+
+ Args:
+ # rhs: the right hand side of the test
+ rhs: object
+
+ Returns:
+ bool
+ """
+
+ try:
+ return isinstance(rhs, self._class_name)
+ except TypeError:
+ # Check raw types if there was a type error. This is helpful for
+ # things like cStringIO.StringIO.
+ return type(rhs) == type(self._class_name)
+
+ def __repr__(self):
+ return str(self._class_name)
+
+class IsAlmost(Comparator):
+ """Comparison class used to check whether a parameter is nearly equal
+ to a given value. Generally useful for floating point numbers.
+
+ Example mock_dao.SetTimeout((IsAlmost(3.9)))
+ """
+
+ def __init__(self, float_value, places=7):
+ """Initialize IsAlmost.
+
+ Args:
+ float_value: The value for making the comparison.
+ places: The number of decimal places to round to.
+ """
+
+ self._float_value = float_value
+ self._places = places
+
+ def equals(self, rhs):
+ """Check to see if RHS is almost equal to float_value
+
+ Args:
+ rhs: the value to compare to float_value
+
+ Returns:
+ bool
+ """
+
+ try:
+ return round(rhs-self._float_value, self._places) == 0
+ except TypeError:
+ # This is probably because either float_value or rhs is not a number.
+ return False
+
+ def __repr__(self):
+ return str(self._float_value)
+
+class StrContains(Comparator):
+ """Comparison class used to check whether a substring exists in a
+ string parameter. This can be useful in mocking a database with SQL
+ passed in as a string parameter, for example.
+
+ Example:
+ mock_dao.RunQuery(StrContains('IN (1, 2, 4, 5)')).AndReturn(mock_result)
+ """
+
+ def __init__(self, search_string):
+ """Initialize.
+
+ Args:
+ # search_string: the string you are searching for
+ search_string: str
+ """
+
+ self._search_string = search_string
+
+ def equals(self, rhs):
+ """Check to see if the search_string is contained in the rhs string.
+
+ Args:
+ # rhs: the right hand side of the test
+ rhs: object
+
+ Returns:
+ bool
+ """
+
+ try:
+ return rhs.find(self._search_string) > -1
+ except Exception:
+ return False
+
+ def __repr__(self):
+ return '<str containing \'%s\'>' % self._search_string
+
+
+class Regex(Comparator):
+ """Checks if a string matches a regular expression.
+
+ This uses a given regular expression to determine equality.
+ """
+
+ def __init__(self, pattern, flags=0):
+ """Initialize.
+
+ Args:
+ # pattern is the regular expression to search for
+ pattern: str
+ # flags passed to re.compile function as the second argument
+ flags: int
+ """
+
+ self.regex = re.compile(pattern, flags=flags)
+
+ def equals(self, rhs):
+ """Check to see if rhs matches regular expression pattern.
+
+ Returns:
+ bool
+ """
+
+ return self.regex.search(rhs) is not None
+
+ def __repr__(self):
+ s = '<regular expression \'%s\'' % self.regex.pattern
+ if self.regex.flags:
+ s += ', flags=%d' % self.regex.flags
+ s += '>'
+ return s
+
+
+class In(Comparator):
+ """Checks whether an item (or key) is in a list (or dict) parameter.
+
+ Example:
+ mock_dao.GetUsersInfo(In('expectedUserName')).AndReturn(mock_result)
+ """
+
+ def __init__(self, key):
+ """Initialize.
+
+ Args:
+ # key is any thing that could be in a list or a key in a dict
+ """
+
+ self._key = key
+
+ def equals(self, rhs):
+ """Check to see whether key is in rhs.
+
+ Args:
+ rhs: dict
+
+ Returns:
+ bool
+ """
+
+ return self._key in rhs
+
+ def __repr__(self):
+ return '<sequence or map containing \'%s\'>' % self._key
+
+
+class Not(Comparator):
+ """Checks whether a predicates is False.
+
+ Example:
+ mock_dao.UpdateUsers(Not(ContainsKeyValue('stevepm', stevepm_user_info)))
+ """
+
+ def __init__(self, predicate):
+ """Initialize.
+
+ Args:
+ # predicate: a Comparator instance.
+ """
+
+ assert isinstance(predicate, Comparator), ("predicate %r must be a"
+ " Comparator." % predicate)
+ self._predicate = predicate
+
+ def equals(self, rhs):
+ """Check to see whether the predicate is False.
+
+ Args:
+ rhs: A value that will be given in argument of the predicate.
+
+ Returns:
+ bool
+ """
+
+ return not self._predicate.equals(rhs)
+
+ def __repr__(self):
+ return '<not \'%s\'>' % self._predicate
+
+
+class ContainsKeyValue(Comparator):
+ """Checks whether a key/value pair is in a dict parameter.
+
+ Example:
+ mock_dao.UpdateUsers(ContainsKeyValue('stevepm', stevepm_user_info))
+ """
+
+ def __init__(self, key, value):
+ """Initialize.
+
+ Args:
+ # key: a key in a dict
+ # value: the corresponding value
+ """
+
+ self._key = key
+ self._value = value
+
+ def equals(self, rhs):
+ """Check whether the given key/value pair is in the rhs dict.
+
+ Returns:
+ bool
+ """
+
+ try:
+ return rhs[self._key] == self._value
+ except Exception:
+ return False
+
+ def __repr__(self):
+ return '<map containing the entry \'%s: %s\'>' % (self._key, self._value)
+
+
+class SameElementsAs(Comparator):
+ """Checks whether iterables contain the same elements (ignoring order).
+
+ Example:
+ mock_dao.ProcessUsers(SameElementsAs('stevepm', 'salomaki'))
+ """
+
+ def __init__(self, expected_seq):
+ """Initialize.
+
+ Args:
+ expected_seq: a sequence
+ """
+
+ self._expected_seq = expected_seq
+
+ def equals(self, actual_seq):
+ """Check to see whether actual_seq has same elements as expected_seq.
+
+ Args:
+ actual_seq: sequence
+
+ Returns:
+ bool
+ """
+
+ try:
+ expected = dict([(element, None) for element in self._expected_seq])
+ actual = dict([(element, None) for element in actual_seq])
+ except TypeError:
+ # Fall back to slower list-compare if any of the objects are unhashable.
+ expected = list(self._expected_seq)
+ actual = list(actual_seq)
+ expected.sort()
+ actual.sort()
+ return expected == actual
+
+ def __repr__(self):
+ return '<sequence with same elements as \'%s\'>' % self._expected_seq
+
+
+class And(Comparator):
+ """Evaluates one or more Comparators on RHS and returns an AND of the results.
+ """
+
+ def __init__(self, *args):
+ """Initialize.
+
+ Args:
+ *args: One or more Comparator
+ """
+
+ self._comparators = args
+
+ def equals(self, rhs):
+ """Checks whether all Comparators are equal to rhs.
+
+ Args:
+ # rhs: can be anything
+
+ Returns:
+ bool
+ """
+
+ for comparator in self._comparators:
+ if not comparator.equals(rhs):
+ return False
+
+ return True
+
+ def __repr__(self):
+ return '<AND %s>' % str(self._comparators)
+
+
+class Or(Comparator):
+ """Evaluates one or more Comparators on RHS and returns an OR of the results.
+ """
+
+ def __init__(self, *args):
+ """Initialize.
+
+ Args:
+ *args: One or more Mox comparators
+ """
+
+ self._comparators = args
+
+ def equals(self, rhs):
+ """Checks whether any Comparator is equal to rhs.
+
+ Args:
+ # rhs: can be anything
+
+ Returns:
+ bool
+ """
+
+ for comparator in self._comparators:
+ if comparator.equals(rhs):
+ return True
+
+ return False
+
+ def __repr__(self):
+ return '<OR %s>' % str(self._comparators)
+
+
+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.
+
+
+ Example:
+
+ def myParamValidator(param):
+ # Advanced logic here
+ return True
+
+ mock_dao.DoSomething(Func(myParamValidator), true)
+ """
+
+ def __init__(self, func):
+ """Initialize.
+
+ Args:
+ func: callable that takes one parameter and returns a bool
+ """
+
+ self._func = func
+
+ def equals(self, rhs):
+ """Test whether rhs passes the function test.
+
+ rhs is passed into func.
+
+ Args:
+ rhs: any python object
+
+ Returns:
+ the result of func(rhs)
+ """
+
+ return self._func(rhs)
+
+ def __repr__(self):
+ return str(self._func)
+
+
+class IgnoreArg(Comparator):
+ """Ignore an argument.
+
+ 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.
+ mymock.CastMagic(3, IgnoreArg(), 'disappear')
+ """
+
+ def equals(self, unused_rhs):
+ """Ignores arguments and returns True.
+
+ Args:
+ unused_rhs: any python object
+
+ Returns:
+ always returns True
+ """
+
+ return True
+
+ def __repr__(self):
+ return '<IgnoreArg>'
+
+
+class MethodGroup(object):
+ """Base class containing common behaviour for MethodGroups."""
+
+ def __init__(self, group_name):
+ self._group_name = group_name
+
+ def group_name(self):
+ return self._group_name
+
+ def __str__(self):
+ return '<%s "%s">' % (self.__class__.__name__, self._group_name)
+
+ def AddMethod(self, mock_method):
+ raise NotImplementedError
+
+ def MethodCalled(self, mock_method):
+ raise NotImplementedError
+
+ def IsSatisfied(self):
+ raise NotImplementedError
+
+class UnorderedGroup(MethodGroup):
+ """UnorderedGroup holds a set of method calls that may occur in any order.
+
+ This construct is helpful for non-deterministic events, such as iterating
+ over the keys of a dict.
+ """
+
+ def __init__(self, group_name):
+ super(UnorderedGroup, self).__init__(group_name)
+ self._methods = []
+
+ def AddMethod(self, mock_method):
+ """Add a method to this group.
+
+ Args:
+ mock_method: A mock method to be added to this group.
+ """
+
+ self._methods.append(mock_method)
+
+ def MethodCalled(self, mock_method):
+ """Remove a method call from the group.
+
+ If the method is not in the set, an UnexpectedMethodCallError will be
+ raised.
+
+ Args:
+ mock_method: a mock method that should be equal to a method in the group.
+
+ Returns:
+ The mock method from the group
+
+ Raises:
+ UnexpectedMethodCallError if the mock_method was not in the group.
+ """
+
+ # Check to see if this method exists, and if so, remove it from the set
+ # 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.
+ self._methods.remove(mock_method)
+
+ # If this group is not empty, put it back at the head of the queue.
+ if not self.IsSatisfied():
+ mock_method._call_queue.appendleft(self)
+
+ return self, method
+
+ raise UnexpectedMethodCallError(mock_method, self)
+
+ def IsSatisfied(self):
+ """Return True if there are not any methods in this group."""
+
+ return len(self._methods) == 0
+
+
+class MultipleTimesGroup(MethodGroup):
+ """MultipleTimesGroup holds methods that may be called any number of times.
+
+ 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.
+ """
+
+ def __init__(self, group_name):
+ super(MultipleTimesGroup, self).__init__(group_name)
+ self._methods = set()
+ self._methods_called = set()
+
+ def AddMethod(self, mock_method):
+ """Add a method to this group.
+
+ Args:
+ mock_method: A mock method to be added to this group.
+ """
+
+ self._methods.add(mock_method)
+
+ def MethodCalled(self, mock_method):
+ """Remove a method call from the group.
+
+ If the method is not in the set, an UnexpectedMethodCallError will be
+ raised.
+
+ Args:
+ mock_method: a mock method that should be equal to a method in the group.
+
+ Returns:
+ The mock method from the group
+
+ Raises:
+ UnexpectedMethodCallError if the mock_method was not in the group.
+ """
+
+ # Check to see if this method exists, and if so add it to the set of
+ # called methods.
+
+ for method in self._methods:
+ if method == mock_method:
+ self._methods_called.add(mock_method)
+ # 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
+
+ if self.IsSatisfied():
+ next_method = mock_method._PopNextMethod();
+ return next_method, None
+ else:
+ raise UnexpectedMethodCallError(mock_method, self)
+
+ def IsSatisfied(self):
+ """Return True if all methods in this group are called at least once."""
+ # NOTE(psycho): We can't use the simple set difference here because we want
+ # to match different parameters which are considered the same e.g. IsA(str)
+ # and some string. This solution is O(n^2) but n should be small.
+ tmp = self._methods.copy()
+ for called in self._methods_called:
+ for expected in tmp:
+ if called == expected:
+ tmp.remove(expected)
+ if not tmp:
+ return True
+ break
+ return False
+
+
+class MoxMetaTestBase(type):
+ """Metaclass to add mox cleanup and verification to every test.
+
+ 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.
+ """
+
+ def __init__(cls, name, bases, d):
+ type.__init__(cls, name, bases, d)
+
+ # also get all the attributes from the base classes to account
+ # for a case when test class is not the immediate child of MoxTestBase
+ for base in bases:
+ for attr_name in dir(base):
+ d[attr_name] = getattr(base, attr_name)
+
+ for func_name, func in d.items():
+ if func_name.startswith('test') and callable(func):
+ setattr(cls, func_name, MoxMetaTestBase.CleanUpTest(cls, func))
+
+ @staticmethod
+ def CleanUpTest(cls, func):
+ """Adds Mox cleanup code to any MoxTestBase method.
+
+ Always unsets stubs after a test. Will verify all mocks for tests that
+ otherwise pass.
+
+ Args:
+ cls: MoxTestBase or subclass; the class whose test method we are altering.
+ func: method; the method of the MoxTestBase test class we wish to alter.
+
+ Returns:
+ The modified method.
+ """
+ def new_method(self, *args, **kwargs):
+ mox_obj = getattr(self, 'mox', None)
+ cleanup_mox = False
+ if mox_obj and isinstance(mox_obj, Mox):
+ cleanup_mox = True
+ try:
+ func(self, *args, **kwargs)
+ finally:
+ if cleanup_mox:
+ mox_obj.UnsetStubs()
+ if cleanup_mox:
+ mox_obj.VerifyAll()
+ new_method.__name__ = func.__name__
+ new_method.__doc__ = func.__doc__
+ new_method.__module__ = func.__module__
+ return new_method
+
+
+class MoxTestBase(unittest.TestCase):
+ """Convenience test class to make stubbing easier.
+
+ Sets up a "mox" attribute which is an instance of Mox - any mox tests will
+ want this. Also automatically unsets any stubs and verifies that all mock
+ methods have been called at the end of each test, eliminating boilerplate
+ code.
+ """
+
+ __metaclass__ = MoxMetaTestBase
+
+ def setUp(self):
+ super(MoxTestBase, self).setUp()
+ self.mox = Mox()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/mox_test.py Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,1544 @@
+#!/usr/bin/python2.4
+#
+# Unit tests for Mox.
+#
+# Copyright 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cStringIO
+import unittest
+import re
+
+import mox
+
+import mox_test_helper
+
+
+class ExpectedMethodCallsErrorTest(unittest.TestCase):
+ """Test creation and string conversion of ExpectedMethodCallsError."""
+
+ def testAtLeastOneMethod(self):
+ self.assertRaises(ValueError, mox.ExpectedMethodCallsError, [])
+
+ def testOneError(self):
+ method = mox.MockMethod("testMethod", [], False)
+ method(1, 2).AndReturn('output')
+ e = mox.ExpectedMethodCallsError([method])
+ self.assertEqual(
+ "Verify: Expected methods never called:\n"
+ " 0. testMethod(1, 2) -> 'output'",
+ str(e))
+
+ def testManyErrors(self):
+ method1 = mox.MockMethod("testMethod", [], False)
+ method1(1, 2).AndReturn('output')
+ method2 = mox.MockMethod("testMethod", [], False)
+ method2(a=1, b=2, c="only named")
+ method3 = mox.MockMethod("testMethod2", [], False)
+ method3().AndReturn(44)
+ method4 = mox.MockMethod("testMethod", [], False)
+ 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))
+
+
+class OrTest(unittest.TestCase):
+ """Test Or correctly chains Comparators."""
+
+ def testValidOr(self):
+ """Or should be True if either Comparator returns True."""
+ self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == {})
+ self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == 'test')
+ self.assert_(mox.Or(mox.IsA(str), mox.IsA(str)) == 'test')
+
+ def testInvalidOr(self):
+ """Or should be False if both Comparators return False."""
+ self.failIf(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)
+
+
+class AndTest(unittest.TestCase):
+ """Test And correctly chains Comparators."""
+
+ def testValidAnd(self):
+ """And should be True if both Comparators return True."""
+ self.assert_(mox.And(mox.IsA(str), mox.IsA(str)) == '1')
+
+ def testClauseOneFails(self):
+ """And should be False if the first Comparator returns False."""
+
+ self.failIf(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')
+
+ def testAdvancedUsage(self):
+ """And should work with other Comparators.
+
+ Note: this test is reliant on In and ContainsKeyValue.
+ """
+ test_dict = {"mock" : "obj", "testing" : "isCOOL"}
+ self.assert_(mox.And(mox.In("testing"),
+ 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.failIf(mox.And(mox.In("NOTFOUND"),
+ mox.ContainsKeyValue("mock", "obj")) == test_dict)
+
+
+class SameElementsAsTest(unittest.TestCase):
+ """Test SameElementsAs correctly identifies sequences with same elements."""
+
+ def testSortedLists(self):
+ """Should return True if two lists are exactly equal."""
+ self.assert_(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."""
+ self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1])
+
+ def testUnhashableLists(self):
+ """Should return True if two lists have the same unhashable elements."""
+ self.assert_(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) ==
+ [{2: 'b'}, {'a': 1}])
+
+ def testEmptyLists(self):
+ """Should return True for two empty lists."""
+ self.assert_(mox.SameElementsAs([]) == [])
+
+ def testUnequalLists(self):
+ """Should return False if the lists are not equal."""
+ self.failIf(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c'])
+
+ def testUnequalUnhashableLists(self):
+ """Should return False if two lists with unhashable elements are unequal."""
+ self.failIf(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}])
+
+
+class ContainsKeyValueTest(unittest.TestCase):
+ """Test ContainsKeyValue correctly identifies key/value pairs in a dict.
+ """
+
+ def testValidPair(self):
+ """Should return True if the key value is in the dict."""
+ self.assert_(mox.ContainsKeyValue("key", 1) == {"key": 1})
+
+ def testInvalidValue(self):
+ """Should return False if the value is not correct."""
+ self.failIf(mox.ContainsKeyValue("key", 1) == {"key": 2})
+
+ def testInvalidKey(self):
+ """Should return False if they key is not in the dict."""
+ self.failIf(mox.ContainsKeyValue("qux", 1) == {"key": 2})
+
+
+class InTest(unittest.TestCase):
+ """Test In correctly identifies a key in a list/dict"""
+
+ def testItemInList(self):
+ """Should return True if the item is in the list."""
+ self.assert_(mox.In(1) == [1, 2, 3])
+
+ def testKeyInDict(self):
+ """Should return True if the item is a key in a dict."""
+ self.assert_(mox.In("test") == {"test" : "module"})
+
+
+class NotTest(unittest.TestCase):
+ """Test Not correctly identifies False predicates."""
+
+ def testItemInList(self):
+ """Should return True if the item is NOT in the list."""
+ self.assert_(mox.Not(mox.In(42)) == [1, 2, 3])
+
+ def testKeyInDict(self):
+ """Should return True if the item is NOT a key in a dict."""
+ self.assert_(mox.Not(mox.In("foo")) == {"key" : 42})
+
+ def testInvalidKeyWithNot(self):
+ """Should return False if they key is NOT in the dict."""
+ self.assert_(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})
+
+
+class StrContainsTest(unittest.TestCase):
+ """Test StrContains correctly checks for substring occurrence of a parameter.
+ """
+
+ def testValidSubstringAtStart(self):
+ """Should return True if the substring is at the start of the string."""
+ self.assert_(mox.StrContains("hello") == "hello world")
+
+ def testValidSubstringInMiddle(self):
+ """Should return True if the substring is in the middle of the string."""
+ self.assert_(mox.StrContains("lo wo") == "hello world")
+
+ def testValidSubstringAtEnd(self):
+ """Should return True if the substring is at the end of the string."""
+ self.assert_(mox.StrContains("ld") == "hello world")
+
+ def testInvaildSubstring(self):
+ """Should return False if the substring is not in the string."""
+ self.failIf(mox.StrContains("AAA") == "hello world")
+
+ def testMultipleMatches(self):
+ """Should return True if there are multiple occurances of substring."""
+ self.assert_(mox.StrContains("abc") == "ababcabcabcababc")
+
+
+class RegexTest(unittest.TestCase):
+ """Test Regex correctly matches regular expressions."""
+
+ def testIdentifyBadSyntaxDuringInit(self):
+ """The user should know immediately if a regex has bad syntax."""
+ self.assertRaises(re.error, mox.Regex, '(a|b')
+
+ def testPatternInMiddle(self):
+ """Should return True if the pattern matches at the middle of the string.
+
+ 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")
+
+ def testNonMatchPattern(self):
+ """Should return False if the pattern does not match the string."""
+ self.failIf(mox.Regex(r"a\s+b") == "x y z")
+
+ def testFlagsPassedCorrectly(self):
+ """Should return True as we pass IGNORECASE flag."""
+ self.assert_(mox.Regex(r"A", re.IGNORECASE) == "a")
+
+ def testReprWithoutFlags(self):
+ """repr should return the regular expression pattern."""
+ self.assert_(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>")
+
+ def testReprWithFlags(self):
+ """repr should return the regular expression pattern and flags."""
+ self.assert_(repr(mox.Regex(r"a\s+b", flags=4)) ==
+ "<regular expression 'a\s+b', flags=4>")
+
+
+class IsATest(unittest.TestCase):
+ """Verify IsA correctly checks equality based upon class type, not value."""
+
+ def testEqualityValid(self):
+ """Verify that == correctly identifies objects of the same type."""
+ self.assert_(mox.IsA(str) == 'test')
+
+ def testEqualityInvalid(self):
+ """Verify that == correctly identifies objects of different types."""
+ self.failIf(mox.IsA(str) == 10)
+
+ def testInequalityValid(self):
+ """Verify that != identifies objects of different type."""
+ self.assert_(mox.IsA(str) != 10)
+
+ def testInequalityInvalid(self):
+ """Verify that != correctly identifies objects of the same type."""
+ self.failIf(mox.IsA(str) != "test")
+
+ def testEqualityInListValid(self):
+ """Verify list contents are properly compared."""
+ isa_list = [mox.IsA(str), mox.IsA(str)]
+ str_list = ["abc", "def"]
+ self.assert_(isa_list == str_list)
+
+ def testEquailtyInListInvalid(self):
+ """Verify list contents are properly compared."""
+ isa_list = [mox.IsA(str),mox.IsA(str)]
+ mixed_list = ["abc", 123]
+ self.failIf(isa_list == mixed_list)
+
+ def testSpecialTypes(self):
+ """Verify that IsA can handle objects like cStringIO.StringIO."""
+ isA = mox.IsA(cStringIO.StringIO())
+ stringIO = cStringIO.StringIO()
+ self.assert_(isA == stringIO)
+
+class IsAlmostTest(unittest.TestCase):
+ """Verify IsAlmost correctly checks equality of floating point numbers."""
+
+ def testEqualityValid(self):
+ """Verify that == correctly identifies nearly equivalent floats."""
+ self.assertEquals(mox.IsAlmost(1.8999999999), 1.9)
+
+ def testEqualityInvalid(self):
+ """Verify that == correctly identifies non-equivalent floats."""
+ self.assertNotEquals(mox.IsAlmost(1.899), 1.9)
+
+ def testEqualityWithPlaces(self):
+ """Verify that specifying places has the desired effect."""
+ self.assertNotEquals(mox.IsAlmost(1.899), 1.9)
+ self.assertEquals(mox.IsAlmost(1.899, places=2), 1.9)
+
+ def testNonNumericTypes(self):
+ """Verify that IsAlmost handles non-numeric types properly."""
+
+ self.assertNotEquals(mox.IsAlmost(1.8999999999), '1.9')
+ self.assertNotEquals(mox.IsAlmost('1.8999999999'), 1.9)
+ self.assertNotEquals(mox.IsAlmost('1.8999999999'), '1.9')
+
+class MockMethodTest(unittest.TestCase):
+ """Test class to verify that the MockMethod class is working correctly."""
+
+ def setUp(self):
+ self.expected_method = mox.MockMethod("testMethod", [], False)(['original'])
+ self.mock_method = mox.MockMethod("testMethod", [self.expected_method],
+ True)
+
+ def testAndReturnNoneByDefault(self):
+ """Should return None by default."""
+ return_value = self.mock_method(['original'])
+ self.assert_(return_value == None)
+
+ def testAndReturnValue(self):
+ """Should return a specificed return value."""
+ expected_return_value = "test"
+ self.expected_method.AndReturn(expected_return_value)
+ return_value = self.mock_method(['original'])
+ self.assert_(return_value == expected_return_value)
+
+ def testAndRaiseException(self):
+ """Should raise a specified exception."""
+ expected_exception = Exception('test exception')
+ self.expected_method.AndRaise(expected_exception)
+ self.assertRaises(Exception, self.mock_method)
+
+ def testWithSideEffects(self):
+ """Should call state modifier."""
+ local_list = ['original']
+ def modifier(mutable_list):
+ self.assertTrue(local_list is mutable_list)
+ mutable_list[0] = 'mutation'
+ self.expected_method.WithSideEffects(modifier).AndReturn(1)
+ self.mock_method(local_list)
+ self.assertEquals('mutation', local_list[0])
+
+ def testEqualityNoParamsEqual(self):
+ """Methods with the same name and without params should be equal."""
+ expected_method = mox.MockMethod("testMethod", [], False)
+ self.assertEqual(self.mock_method, expected_method)
+
+ def testEqualityNoParamsNotEqual(self):
+ """Methods with different names and without params should not be equal."""
+ expected_method = mox.MockMethod("otherMethod", [], False)
+ self.failIfEqual(self.mock_method, expected_method)
+
+ def testEqualityParamsEqual(self):
+ """Methods with the same name and parameters should be equal."""
+ params = [1, 2, 3]
+ expected_method = mox.MockMethod("testMethod", [], False)
+ expected_method._params = params
+
+ self.mock_method._params = params
+ self.assertEqual(self.mock_method, expected_method)
+
+ def testEqualityParamsNotEqual(self):
+ """Methods with the same name and different params should not be equal."""
+ expected_method = mox.MockMethod("testMethod", [], False)
+ expected_method._params = [1, 2, 3]
+
+ self.mock_method._params = ['a', 'b', 'c']
+ self.failIfEqual(self.mock_method, expected_method)
+
+ def testEqualityNamedParamsEqual(self):
+ """Methods with the same name and same named params should be equal."""
+ named_params = {"input1": "test", "input2": "params"}
+ expected_method = mox.MockMethod("testMethod", [], False)
+ expected_method._named_params = named_params
+
+ self.mock_method._named_params = named_params
+ self.assertEqual(self.mock_method, expected_method)
+
+ def testEqualityNamedParamsNotEqual(self):
+ """Methods with the 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.failIfEqual(self.mock_method, expected_method)
+
+ def testEqualityWrongType(self):
+ """Method should not be equal to an object of a different type."""
+ self.failIfEqual(self.mock_method, "string?")
+
+ def testObjectEquality(self):
+ """Equality of objects should work without a Comparator"""
+ instA = TestClass();
+ instB = TestClass();
+
+ params = [instA, ]
+ expected_method = mox.MockMethod("testMethod", [], False)
+ expected_method._params = params
+
+ self.mock_method._params = [instB, ]
+ self.assertEqual(self.mock_method, expected_method)
+
+ 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"))
+
+ method = mox.MockMethod("testMethod", [], False)
+ method(1, 2, "only positional")
+ self.assertEqual(str(method), "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")
+
+ method = mox.MockMethod("testMethod", [], False)
+ method()
+ self.assertEqual(str(method), "testMethod() -> None")
+
+ method = mox.MockMethod("testMethod", [], False)
+ method(x="only 1 parameter")
+ self.assertEqual(str(method), "testMethod(x='only 1 parameter') -> None")
+
+ method = mox.MockMethod("testMethod", [], False)
+ method().AndReturn('return_value')
+ self.assertEqual(str(method), "testMethod() -> 'return_value'")
+
+ method = mox.MockMethod("testMethod", [], False)
+ method().AndReturn(('a', {1: 2}))
+ self.assertEqual(str(method), "testMethod() -> ('a', {1: 2})")
+
+
+class MockAnythingTest(unittest.TestCase):
+ """Verify that the MockAnything class works as expected."""
+
+ def setUp(self):
+ self.mock_object = mox.MockAnything()
+
+ def testSetupMode(self):
+ """Verify the mock will accept any call."""
+ self.mock_object.NonsenseCall()
+ self.assert_(len(self.mock_object._expected_calls_queue) == 1)
+
+ def testReplayWithExpectedCall(self):
+ """Verify the mock replays method calls as expected."""
+ self.mock_object.ValidCall() # setup method call
+ self.mock_object._Replay() # start replay mode
+ self.mock_object.ValidCall() # make method call
+
+ def testReplayWithUnexpectedCall(self):
+ """Unexpected method calls should raise UnexpectedMethodCallError."""
+ self.mock_object.ValidCall() # setup method call
+ self.mock_object._Replay() # start replay mode
+ self.assertRaises(mox.UnexpectedMethodCallError,
+ self.mock_object.OtherValidCall)
+
+ def testVerifyWithCompleteReplay(self):
+ """Verify should not raise an exception for a valid replay."""
+ self.mock_object.ValidCall() # setup method call
+ self.mock_object._Replay() # start replay mode
+ self.mock_object.ValidCall() # make method call
+ self.mock_object._Verify()
+
+ def testVerifyWithIncompleteReplay(self):
+ """Verify should raise an exception if the replay was not complete."""
+ 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)
+
+ def testSpecialClassMethod(self):
+ """Verify should not raise an exception when special methods are used."""
+ self.mock_object[1].AndReturn(True)
+ self.mock_object._Replay()
+ returned_val = self.mock_object[1]
+ self.assert_(returned_val)
+ self.mock_object._Verify()
+
+ def testNonzero(self):
+ """You should be able to use the mock object in an if."""
+ self.mock_object._Replay()
+ if self.mock_object:
+ pass
+
+ def testNotNone(self):
+ """Mock should be comparable to None."""
+ self.mock_object._Replay()
+ if self.mock_object is not None:
+ pass
+
+ if self.mock_object is None:
+ pass
+
+ def testEquals(self):
+ """A mock should be able to compare itself to another object."""
+ self.mock_object._Replay()
+ self.assertEquals(self.mock_object, self.mock_object)
+
+ def testEqualsMockFailure(self):
+ """Verify equals identifies unequal objects."""
+ self.mock_object.SillyCall()
+ self.mock_object._Replay()
+ self.assertNotEquals(self.mock_object, mox.MockAnything())
+
+ def testEqualsInstanceFailure(self):
+ """Verify equals identifies that objects are different instances."""
+ self.mock_object._Replay()
+ self.assertNotEquals(self.mock_object, TestClass())
+
+ def testNotEquals(self):
+ """Verify not equals works."""
+ self.mock_object._Replay()
+ self.assertFalse(self.mock_object != self.mock_object)
+
+ def testNestedMockCallsRecordedSerially(self):
+ """Test that nested calls work when recorded serially."""
+ self.mock_object.CallInner().AndReturn(1)
+ self.mock_object.CallOuter(1)
+ self.mock_object._Replay()
+
+ self.mock_object.CallOuter(self.mock_object.CallInner())
+
+ self.mock_object._Verify()
+
+ def testNestedMockCallsRecordedNested(self):
+ """Test that nested cals work when recorded in a nested fashion."""
+ self.mock_object.CallOuter(self.mock_object.CallInner().AndReturn(1))
+ self.mock_object._Replay()
+
+ self.mock_object.CallOuter(self.mock_object.CallInner())
+
+ self.mock_object._Verify()
+
+ def testIsCallable(self):
+ """Test that MockAnything can even mock a simple callable.
+
+ This is handy for "stubbing out" a method in a module with a mock, and
+ verifying that it was called.
+ """
+ self.mock_object().AndReturn('mox0rd')
+ self.mock_object._Replay()
+
+ self.assertEquals('mox0rd', self.mock_object())
+
+ self.mock_object._Verify()
+
+
+class MethodCheckerTest(unittest.TestCase):
+ """Tests MockMethod's use of MethodChecker method."""
+
+ def testNoParameters(self):
+ method = mox.MockMethod('NoParameters', [], False,
+ CheckCallTestClass.NoParameters)
+ method()
+ self.assertRaises(AttributeError, method, 1)
+ self.assertRaises(AttributeError, method, 1, 2)
+ self.assertRaises(AttributeError, method, a=1)
+ self.assertRaises(AttributeError, method, 1, b=2)
+
+ def testOneParameter(self):
+ method = mox.MockMethod('OneParameter', [], False,
+ CheckCallTestClass.OneParameter)
+ self.assertRaises(AttributeError, method)
+ method(1)
+ method(a=1)
+ self.assertRaises(AttributeError, method, b=1)
+ self.assertRaises(AttributeError, method, 1, 2)
+ self.assertRaises(AttributeError, method, 1, a=2)
+ self.assertRaises(AttributeError, method, 1, b=2)
+
+ def testTwoParameters(self):
+ method = mox.MockMethod('TwoParameters', [], False,
+ CheckCallTestClass.TwoParameters)
+ self.assertRaises(AttributeError, method)
+ self.assertRaises(AttributeError, method, 1)
+ self.assertRaises(AttributeError, method, a=1)
+ self.assertRaises(AttributeError, method, b=1)
+ method(1, 2)
+ method(1, b=2)
+ method(a=1, b=2)
+ method(b=2, a=1)
+ self.assertRaises(AttributeError, method, b=2, c=3)
+ self.assertRaises(AttributeError, method, a=1, b=2, c=3)
+ self.assertRaises(AttributeError, method, 1, 2, 3)
+ self.assertRaises(AttributeError, method, 1, 2, 3, 4)
+ self.assertRaises(AttributeError, method, 3, a=1, b=2)
+
+ def testOneDefaultValue(self):
+ method = mox.MockMethod('OneDefaultValue', [], False,
+ CheckCallTestClass.OneDefaultValue)
+ method()
+ method(1)
+ method(a=1)
+ self.assertRaises(AttributeError, method, b=1)
+ self.assertRaises(AttributeError, method, 1, 2)
+ self.assertRaises(AttributeError, method, 1, a=2)
+ self.assertRaises(AttributeError, method, 1, b=2)
+
+ def testTwoDefaultValues(self):
+ method = mox.MockMethod('TwoDefaultValues', [], False,
+ CheckCallTestClass.TwoDefaultValues)
+ self.assertRaises(AttributeError, method)
+ self.assertRaises(AttributeError, method, c=3)
+ self.assertRaises(AttributeError, method, 1)
+ self.assertRaises(AttributeError, method, 1, d=4)
+ self.assertRaises(AttributeError, method, 1, d=4, c=3)
+ method(1, 2)
+ method(a=1, b=2)
+ method(1, 2, 3)
+ method(1, 2, 3, 4)
+ method(1, 2, c=3)
+ method(1, 2, c=3, d=4)
+ method(1, 2, d=4, c=3)
+ method(d=4, c=3, a=1, b=2)
+ self.assertRaises(AttributeError, method, 1, 2, 3, 4, 5)
+ self.assertRaises(AttributeError, method, 1, 2, e=9)
+ self.assertRaises(AttributeError, method, a=1, b=2, e=9)
+
+ def testArgs(self):
+ method = mox.MockMethod('Args', [], False, CheckCallTestClass.Args)
+ self.assertRaises(AttributeError, method)
+ self.assertRaises(AttributeError, method, 1)
+ method(1, 2)
+ method(a=1, b=2)
+ method(1, 2, 3)
+ method(1, 2, 3, 4)
+ self.assertRaises(AttributeError, method, 1, 2, a=3)
+ self.assertRaises(AttributeError, method, 1, 2, c=3)
+
+ def testKwargs(self):
+ method = mox.MockMethod('Kwargs', [], False, CheckCallTestClass.Kwargs)
+ self.assertRaises(AttributeError, method)
+ method(1)
+ method(1, 2)
+ method(a=1, b=2)
+ method(b=2, a=1)
+ self.assertRaises(AttributeError, method, 1, 2, 3)
+ self.assertRaises(AttributeError, method, 1, 2, a=3)
+ method(1, 2, c=3)
+ method(a=1, b=2, c=3)
+ method(c=3, a=1, b=2)
+ method(a=1, b=2, c=3, d=4)
+ self.assertRaises(AttributeError, method, 1, 2, 3, 4)
+
+ def testArgsAndKwargs(self):
+ method = mox.MockMethod('ArgsAndKwargs', [], False,
+ CheckCallTestClass.ArgsAndKwargs)
+ self.assertRaises(AttributeError, method)
+ method(1)
+ method(1, 2)
+ method(1, 2, 3)
+ method(a=1)
+ method(1, b=2)
+ self.assertRaises(AttributeError, method, 1, a=2)
+ method(b=2, a=1)
+ method(c=3, b=2, a=1)
+ method(1, 2, c=3)
+
+
+class CheckCallTestClass(object):
+ def NoParameters(self):
+ pass
+
+ def OneParameter(self, a):
+ pass
+
+ def TwoParameters(self, a, b):
+ pass
+
+ def OneDefaultValue(self, a=1):
+ pass
+
+ def TwoDefaultValues(self, a, b, c=1, d=2):
+ pass
+
+ def Args(self, a, b, *args):
+ pass
+
+ def Kwargs(self, a, b=2, **kwargs):
+ pass
+
+ def ArgsAndKwargs(self, a, *args, **kwargs):
+ pass
+
+
+class MockObjectTest(unittest.TestCase):
+ """Verify that the MockObject class works as exepcted."""
+
+ def setUp(self):
+ self.mock_object = mox.MockObject(TestClass)
+
+ def testSetupModeWithValidCall(self):
+ """Verify the mock object properly mocks a basic method call."""
+ self.mock_object.ValidCall()
+ self.assert_(len(self.mock_object._expected_calls_queue) == 1)
+
+ def testSetupModeWithInvalidCall(self):
+ """UnknownMethodCallError should be raised if a non-member method is called.
+ """
+ # Note: assertRaises does not catch exceptions thrown by MockObject's
+ # __getattr__
+ try:
+ self.mock_object.InvalidCall()
+ self.fail("No exception thrown, expected UnknownMethodCallError")
+ except mox.UnknownMethodCallError:
+ pass
+ except Exception:
+ self.fail("Wrong exception type thrown, expected UnknownMethodCallError")
+
+ def testReplayWithInvalidCall(self):
+ """UnknownMethodCallError should be raised if a non-member method is called.
+ """
+ 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:
+ self.mock_object.InvalidCall()
+ self.fail("No exception thrown, expected UnknownMethodCallError")
+ except mox.UnknownMethodCallError:
+ pass
+ except Exception:
+ self.fail("Wrong exception type thrown, expected UnknownMethodCallError")
+
+ def testIsInstance(self):
+ """Mock should be able to pass as an instance of the mocked class."""
+ self.assert_(isinstance(self.mock_object, TestClass))
+
+ def testFindValidMethods(self):
+ """Mock should be able to mock all public methods."""
+ self.assert_('ValidCall' in self.mock_object._known_methods)
+ self.assert_('OtherValidCall' in self.mock_object._known_methods)
+ self.assert_('MyClassMethod' in self.mock_object._known_methods)
+ self.assert_('MyStaticMethod' in self.mock_object._known_methods)
+ self.assert_('_ProtectedCall' in self.mock_object._known_methods)
+ self.assert_('__PrivateCall' not in self.mock_object._known_methods)
+ self.assert_('_TestClass__PrivateCall' in self.mock_object._known_methods)
+
+ def testFindsSuperclassMethods(self):
+ """Mock should be able to mock superclasses methods."""
+ self.mock_object = mox.MockObject(ChildClass)
+ self.assert_('ValidCall' in self.mock_object._known_methods)
+ self.assert_('OtherValidCall' in self.mock_object._known_methods)
+ self.assert_('MyClassMethod' in self.mock_object._known_methods)
+ self.assert_('ChildValidCall' in self.mock_object._known_methods)
+
+ def testAccessClassVariables(self):
+ """Class variables should be accessible through the mock."""
+ self.assert_('SOME_CLASS_VAR' in self.mock_object._known_vars)
+ self.assert_('_PROTECTED_CLASS_VAR' in self.mock_object._known_vars)
+ self.assertEquals('test_value', self.mock_object.SOME_CLASS_VAR)
+
+ def testEquals(self):
+ """A mock should be able to compare itself to another object."""
+ self.mock_object._Replay()
+ self.assertEquals(self.mock_object, self.mock_object)
+
+ def testEqualsMockFailure(self):
+ """Verify equals identifies unequal objects."""
+ self.mock_object.ValidCall()
+ self.mock_object._Replay()
+ self.assertNotEquals(self.mock_object, mox.MockObject(TestClass))
+
+ def testEqualsInstanceFailure(self):
+ """Verify equals identifies that objects are different instances."""
+ self.mock_object._Replay()
+ self.assertNotEquals(self.mock_object, TestClass())
+
+ def testNotEquals(self):
+ """Verify not equals works."""
+ self.mock_object._Replay()
+ self.assertFalse(self.mock_object != self.mock_object)
+
+ def testMockSetItem_ExpectedSetItem_Success(self):
+ """Test that __setitem__() gets mocked in Dummy.
+
+ In this test, _Verify() succeeds.
+ """
+ dummy = mox.MockObject(TestClass)
+ dummy['X'] = 'Y'
+
+ dummy._Replay()
+
+ dummy['X'] = 'Y'
+
+ dummy._Verify()
+
+ def testMockSetItem_ExpectedSetItem_NoSuccess(self):
+ """Test that __setitem__() gets mocked in Dummy.
+
+ In this test, _Verify() fails.
+ """
+ dummy = mox.MockObject(TestClass)
+ dummy['X'] = 'Y'
+
+ dummy._Replay()
+
+ # NOT doing dummy['X'] = 'Y'
+
+ self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)
+
+ def testMockSetItem_ExpectedNoSetItem_Success(self):
+ """Test that __setitem__() gets mocked in Dummy.
+
+ In this test, _Verify() succeeds.
+ """
+ dummy = mox.MockObject(TestClass)
+ # NOT doing dummy['X'] = 'Y'
+
+ dummy._Replay()
+
+ def call(): dummy['X'] = 'Y'
+ self.assertRaises(mox.UnexpectedMethodCallError, call)
+
+ dummy._Verify()
+
+ def testMockSetItem_ExpectedNoSetItem_NoSuccess(self):
+ """Test that __setitem__() gets mocked in Dummy.
+
+ In this test, _Verify() fails.
+ """
+ dummy = mox.MockObject(TestClass)
+ # NOT doing dummy['X'] = 'Y'
+
+ dummy._Replay()
+
+ # NOT doing dummy['X'] = 'Y'
+
+ dummy._Verify()
+
+ def testMockSetItem_ExpectedSetItem_NonmatchingParameters(self):
+ """Test that __setitem__() fails if other parameters are expected."""
+ dummy = mox.MockObject(TestClass)
+ dummy['X'] = 'Y'
+
+ dummy._Replay()
+
+ def call(): dummy['wrong'] = 'Y'
+
+ self.assertRaises(mox.UnexpectedMethodCallError, call)
+
+ dummy._Verify()
+
+ def testMockGetItem_ExpectedGetItem_Success(self):
+ """Test that __setitem__() gets mocked in Dummy.
+
+ In this test, _Verify() succeeds.
+ """
+ dummy = mox.MockObject(TestClass)
+ dummy['X'].AndReturn('value')
+
+ dummy._Replay()
+
+ self.assertEqual(dummy['X'], 'value')
+
+ dummy._Verify()
+
+ def testMockGetItem_ExpectedGetItem_NoSuccess(self):
+ """Test that __setitem__() gets mocked in Dummy.
+
+ In this test, _Verify() fails.
+ """
+ dummy = mox.MockObject(TestClass)
+ dummy['X'].AndReturn('value')
+
+ dummy._Replay()
+
+ # NOT doing dummy['X']
+
+ self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)
+
+ def testMockGetItem_ExpectedNoGetItem_NoSuccess(self):
+ """Test that __setitem__() gets mocked in Dummy.
+
+ In this test, _Verify() succeeds.
+ """
+ dummy = mox.MockObject(TestClass)
+ # NOT doing dummy['X']
+
+ dummy._Replay()
+
+ def call(): return dummy['X']
+ self.assertRaises(mox.UnexpectedMethodCallError, call)
+
+ dummy._Verify()
+
+ def testMockGetItem_ExpectedGetItem_NonmatchingParameters(self):
+ """Test that __setitem__() fails if other parameters are expected."""
+ dummy = mox.MockObject(TestClass)
+ dummy['X'].AndReturn('value')
+
+ dummy._Replay()
+
+ def call(): return dummy['wrong']
+
+ self.assertRaises(mox.UnexpectedMethodCallError, call)
+
+ dummy._Verify()
+
+ def testMockContains_ExpectedContains_Success(self):
+ """Test that __contains__ gets mocked in Dummy.
+
+ In this test, _Verify() succeeds.
+ """
+ dummy = mox.MockObject(TestClass)
+ dummy.__contains__('X').AndReturn(True)
+
+ dummy._Replay()
+
+ self.failUnless('X' in dummy)
+
+ dummy._Verify()
+
+ def testMockContains_ExpectedContains_NoSuccess(self):
+ """Test that __contains__() gets mocked in Dummy.
+
+ In this test, _Verify() fails.
+ """
+ dummy = mox.MockObject(TestClass)
+ dummy.__contains__('X').AndReturn('True')
+
+ dummy._Replay()
+
+ # NOT doing 'X' in dummy
+
+ self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)
+
+ def testMockContains_ExpectedContains_NonmatchingParameter(self):
+ """Test that __contains__ fails if other parameters are expected."""
+ dummy = mox.MockObject(TestClass)
+ dummy.__contains__('X').AndReturn(True)
+
+ dummy._Replay()
+
+ def call(): return 'Y' in dummy
+
+ self.assertRaises(mox.UnexpectedMethodCallError, call)
+
+ dummy._Verify()
+
+class MoxTest(unittest.TestCase):
+ """Verify Mox works correctly."""
+
+ def setUp(self):
+ self.mox = mox.Mox()
+
+ def testCreateObject(self):
+ """Mox should create a mock object."""
+ mock_obj = self.mox.CreateMock(TestClass)
+
+ def testVerifyObjectWithCompleteReplay(self):
+ """Mox should replay and verify all objects it created."""
+ mock_obj = self.mox.CreateMock(TestClass)
+ mock_obj.ValidCall()
+ mock_obj.ValidCallWithArgs(mox.IsA(TestClass))
+ self.mox.ReplayAll()
+ mock_obj.ValidCall()
+ mock_obj.ValidCallWithArgs(TestClass("some_value"))
+ self.mox.VerifyAll()
+
+ def testVerifyObjectWithIncompleteReplay(self):
+ """Mox should raise an exception if a mock didn't replay completely."""
+ mock_obj = self.mox.CreateMock(TestClass)
+ mock_obj.ValidCall()
+ self.mox.ReplayAll()
+ # ValidCall() is never made
+ self.assertRaises(mox.ExpectedMethodCallsError, self.mox.VerifyAll)
+
+ def testEntireWorkflow(self):
+ """Test the whole work flow."""
+ mock_obj = self.mox.CreateMock(TestClass)
+ mock_obj.ValidCall().AndReturn("yes")
+ self.mox.ReplayAll()
+
+ ret_val = mock_obj.ValidCall()
+ self.assertEquals("yes", ret_val)
+ self.mox.VerifyAll()
+
+ def testCallableObject(self):
+ """Test recording calls to a callable object works."""
+ mock_obj = self.mox.CreateMock(CallableClass)
+ mock_obj("foo").AndReturn("qux")
+ self.mox.ReplayAll()
+
+ ret_val = mock_obj("foo")
+ self.assertEquals("qux", ret_val)
+ self.mox.VerifyAll()
+
+ def testCallOnNonCallableObject(self):
+ """Test that you cannot call a non-callable object."""
+ mock_obj = self.mox.CreateMock(TestClass)
+ self.assertRaises(TypeError, mock_obj)
+
+ def testCallableObjectWithBadCall(self):
+ """Test verifying calls to a callable object works."""
+ mock_obj = self.mox.CreateMock(CallableClass)
+ mock_obj("foo").AndReturn("qux")
+ self.mox.ReplayAll()
+
+ self.assertRaises(mox.UnexpectedMethodCallError, mock_obj, "ZOOBAZ")
+
+ def testUnorderedGroup(self):
+ """Test that using one unordered group works."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Method(1).InAnyOrder()
+ mock_obj.Method(2).InAnyOrder()
+ self.mox.ReplayAll()
+
+ mock_obj.Method(2)
+ mock_obj.Method(1)
+
+ self.mox.VerifyAll()
+
+ def testUnorderedGroupsInline(self):
+ """Unordered groups should work in the context of ordered calls."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Open()
+ mock_obj.Method(1).InAnyOrder()
+ mock_obj.Method(2).InAnyOrder()
+ mock_obj.Close()
+ self.mox.ReplayAll()
+
+ mock_obj.Open()
+ mock_obj.Method(2)
+ mock_obj.Method(1)
+ mock_obj.Close()
+
+ self.mox.VerifyAll()
+
+ def testMultipleUnorderdGroups(self):
+ """Multiple unoreded groups should work."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Method(1).InAnyOrder()
+ mock_obj.Method(2).InAnyOrder()
+ mock_obj.Foo().InAnyOrder('group2')
+ mock_obj.Bar().InAnyOrder('group2')
+ self.mox.ReplayAll()
+
+ mock_obj.Method(2)
+ mock_obj.Method(1)
+ mock_obj.Bar()
+ mock_obj.Foo()
+
+ self.mox.VerifyAll()
+
+ def testMultipleUnorderdGroupsOutOfOrder(self):
+ """Multiple unordered groups should maintain external order"""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Method(1).InAnyOrder()
+ mock_obj.Method(2).InAnyOrder()
+ mock_obj.Foo().InAnyOrder('group2')
+ mock_obj.Bar().InAnyOrder('group2')
+ self.mox.ReplayAll()
+
+ mock_obj.Method(2)
+ self.assertRaises(mox.UnexpectedMethodCallError, mock_obj.Bar)
+
+ def testUnorderedGroupWithReturnValue(self):
+ """Unordered groups should work with return values."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Open()
+ mock_obj.Method(1).InAnyOrder().AndReturn(9)
+ mock_obj.Method(2).InAnyOrder().AndReturn(10)
+ mock_obj.Close()
+ self.mox.ReplayAll()
+
+ mock_obj.Open()
+ actual_two = mock_obj.Method(2)
+ actual_one = mock_obj.Method(1)
+ mock_obj.Close()
+
+ self.assertEquals(9, actual_one)
+ self.assertEquals(10, actual_two)
+
+ self.mox.VerifyAll()
+
+ def testUnorderedGroupWithComparator(self):
+ """Unordered groups should work with comparators"""
+
+ def VerifyOne(cmd):
+ if not isinstance(cmd, str):
+ self.fail('Unexpected type passed to comparator: ' + str(cmd))
+ return cmd == 'test'
+
+ def VerifyTwo(cmd):
+ return True
+
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Foo(['test'], mox.Func(VerifyOne), bar=1).InAnyOrder().\
+ AndReturn('yes test')
+ mock_obj.Foo(['test'], mox.Func(VerifyTwo), bar=1).InAnyOrder().\
+ AndReturn('anything')
+
+ self.mox.ReplayAll()
+
+ mock_obj.Foo(['test'], 'anything', bar=1)
+ mock_obj.Foo(['test'], 'test', bar=1)
+
+ self.mox.VerifyAll()
+
+ def testMultipleTimes(self):
+ """Test if MultipleTimesGroup works."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Method(1).MultipleTimes().AndReturn(9)
+ mock_obj.Method(2).AndReturn(10)
+ mock_obj.Method(3).MultipleTimes().AndReturn(42)
+ self.mox.ReplayAll()
+
+ actual_one = mock_obj.Method(1)
+ second_one = mock_obj.Method(1) # This tests MultipleTimes.
+ actual_two = mock_obj.Method(2)
+ actual_three = mock_obj.Method(3)
+ mock_obj.Method(3)
+ mock_obj.Method(3)
+
+ self.assertEquals(9, actual_one)
+ self.assertEquals(9, second_one) # Repeated calls should return same number.
+ self.assertEquals(10, actual_two)
+ self.assertEquals(42, actual_three)
+
+ self.mox.VerifyAll()
+
+ def testMultipleTimesUsingIsAParameter(self):
+ """Test if MultipleTimesGroup works with a IsA parameter."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Open()
+ mock_obj.Method(mox.IsA(str)).MultipleTimes("IsA").AndReturn(9)
+ mock_obj.Close()
+ self.mox.ReplayAll()
+
+ mock_obj.Open()
+ actual_one = mock_obj.Method("1")
+ second_one = mock_obj.Method("2") # This tests MultipleTimes.
+ mock_obj.Close()
+
+ self.assertEquals(9, actual_one)
+ self.assertEquals(9, second_one) # Repeated calls should return same number.
+
+ self.mox.VerifyAll()
+
+ def testMultipleTimesThreeMethods(self):
+ """Test if MultipleTimesGroup works with three or more methods."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Open()
+ mock_obj.Method(1).MultipleTimes().AndReturn(9)
+ mock_obj.Method(2).MultipleTimes().AndReturn(8)
+ mock_obj.Method(3).MultipleTimes().AndReturn(7)
+ mock_obj.Method(4).AndReturn(10)
+ mock_obj.Close()
+ self.mox.ReplayAll()
+
+ mock_obj.Open()
+ actual_three = mock_obj.Method(3)
+ mock_obj.Method(1)
+ actual_two = mock_obj.Method(2)
+ mock_obj.Method(3)
+ actual_one = mock_obj.Method(1)
+ actual_four = mock_obj.Method(4)
+ mock_obj.Close()
+
+ self.assertEquals(9, actual_one)
+ self.assertEquals(8, actual_two)
+ self.assertEquals(7, actual_three)
+ self.assertEquals(10, actual_four)
+
+ self.mox.VerifyAll()
+
+ def testMultipleTimesMissingOne(self):
+ """Test if MultipleTimesGroup fails if one method is missing."""
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Open()
+ mock_obj.Method(1).MultipleTimes().AndReturn(9)
+ mock_obj.Method(2).MultipleTimes().AndReturn(8)
+ mock_obj.Method(3).MultipleTimes().AndReturn(7)
+ mock_obj.Method(4).AndReturn(10)
+ mock_obj.Close()
+ self.mox.ReplayAll()
+
+ mock_obj.Open()
+ mock_obj.Method(3)
+ mock_obj.Method(2)
+ mock_obj.Method(3)
+ mock_obj.Method(3)
+ mock_obj.Method(2)
+
+ self.assertRaises(mox.UnexpectedMethodCallError, mock_obj.Method, 4)
+
+ def testMultipleTimesTwoGroups(self):
+ """Test if MultipleTimesGroup works with a group after a
+ MultipleTimesGroup.
+ """
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Open()
+ mock_obj.Method(1).MultipleTimes().AndReturn(9)
+ mock_obj.Method(3).MultipleTimes("nr2").AndReturn(42)
+ mock_obj.Close()
+ 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(3)
+ mock_obj.Close()
+
+ self.assertEquals(9, actual_one)
+ self.assertEquals(42, actual_three)
+
+ self.mox.VerifyAll()
+
+ def testMultipleTimesTwoGroupsFailure(self):
+ """Test if MultipleTimesGroup fails with a group after a
+ MultipleTimesGroup.
+ """
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.Open()
+ mock_obj.Method(1).MultipleTimes().AndReturn(9)
+ mock_obj.Method(3).MultipleTimes("nr2").AndReturn(42)
+ mock_obj.Close()
+ self.mox.ReplayAll()
+
+ mock_obj.Open()
+ actual_one = mock_obj.Method(1)
+ mock_obj.Method(1)
+ actual_three = mock_obj.Method(3)
+
+ self.assertRaises(mox.UnexpectedMethodCallError, mock_obj.Method, 1)
+
+ def testWithSideEffects(self):
+ """Test side effect operations actually modify their target objects."""
+ def modifier(mutable_list):
+ mutable_list[0] = 'mutated'
+ mock_obj = self.mox.CreateMockAnything()
+ mock_obj.ConfigureInOutParameter(['original']).WithSideEffects(modifier)
+ mock_obj.WorkWithParameter(['mutated'])
+ self.mox.ReplayAll()
+
+ local_list = ['original']
+ mock_obj.ConfigureInOutParameter(local_list)
+ mock_obj.WorkWithParameter(local_list)
+
+ self.mox.VerifyAll()
+
+ def testWithSideEffectsException(self):
+ """Test side effect operations actually modify their target objects."""
+ def modifier(mutable_list):
+ mutable_list[0] = 'mutated'
+ mock_obj = self.mox.CreateMockAnything()
+ method = mock_obj.ConfigureInOutParameter(['original'])
+ method.WithSideEffects(modifier).AndRaise(Exception('exception'))
+ mock_obj.WorkWithParameter(['mutated'])
+ self.mox.ReplayAll()
+
+ local_list = ['original']
+ self.failUnlessRaises(Exception,
+ mock_obj.ConfigureInOutParameter,
+ local_list)
+ mock_obj.WorkWithParameter(local_list)
+
+ self.mox.VerifyAll()
+
+ def testStubOutMethod(self):
+ """Test that a method is replaced with a MockAnything."""
+ test_obj = TestClass()
+ # Replace OtherValidCall with a mock.
+ self.mox.StubOutWithMock(test_obj, 'OtherValidCall')
+ self.assert_(isinstance(test_obj.OtherValidCall, mox.MockAnything))
+ test_obj.OtherValidCall().AndReturn('foo')
+ self.mox.ReplayAll()
+
+ actual = test_obj.OtherValidCall()
+
+ self.mox.VerifyAll()
+ self.mox.UnsetStubs()
+ self.assertEquals('foo', actual)
+ self.failIf(isinstance(test_obj.OtherValidCall, mox.MockAnything))
+
+ def testStubOutObject(self):
+ """Test than object is replaced with a Mock."""
+
+ class Foo(object):
+ def __init__(self):
+ self.obj = TestClass()
+
+ foo = Foo()
+ self.mox.StubOutWithMock(foo, "obj")
+ self.assert_(isinstance(foo.obj, mox.MockObject))
+ foo.obj.ValidCall()
+ self.mox.ReplayAll()
+
+ foo.obj.ValidCall()
+
+ self.mox.VerifyAll()
+ self.mox.UnsetStubs()
+ self.failIf(isinstance(foo.obj, mox.MockObject))
+
+ def testForgotReplayHelpfulMessage(self):
+ """If there is an AttributeError on a MockMethod, give users a helpful msg.
+ """
+ foo = self.mox.CreateMockAnything()
+ bar = self.mox.CreateMockAnything()
+ foo.GetBar().AndReturn(bar)
+ bar.ShowMeTheMoney()
+ # Forgot to replay!
+ try:
+ foo.GetBar().ShowMeTheMoney()
+ except AttributeError, e:
+ self.assertEquals('MockMethod has no attribute "ShowMeTheMoney". '
+ 'Did you remember to put your mocks in replay mode?', str(e))
+
+class ReplayTest(unittest.TestCase):
+ """Verify Replay works properly."""
+
+ def testReplay(self):
+ """Replay should put objects into replay mode."""
+ mock_obj = mox.MockObject(TestClass)
+ self.assertFalse(mock_obj._replay_mode)
+ mox.Replay(mock_obj)
+ self.assertTrue(mock_obj._replay_mode)
+
+class MoxTestBaseTest(unittest.TestCase):
+ """Verify that all tests in a class derived from MoxTestBase are wrapped."""
+
+ def setUp(self):
+ self.mox = mox.Mox()
+ self.test_mox = mox.Mox()
+ self.result = unittest.TestResult()
+
+ def tearDown(self):
+ # In case one of our tests fail before UnsetStubs is called.
+ self.mox.UnsetStubs()
+ self.test_mox.UnsetStubs()
+
+ 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
+ in the test class instance.
+ """
+ self.test.mox = self.test_mox
+
+ def _CreateTest(self, test_name):
+ """Create a test from our example mox class.
+
+ The created test instance is assigned to this instances test attribute.
+ """
+ self.test = mox_test_helper.ExampleMoxTest(test_name)
+ self.mox.stubs.Set(self.test, 'setUp', self._setUpTestClass)
+
+ def _VerifySuccess(self):
+ """Run the checks to confirm test method completed successfully."""
+ self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
+ self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
+ self.test_mox.UnsetStubs()
+ self.test_mox.VerifyAll()
+ self.mox.ReplayAll()
+ self.test.run(result=self.result)
+ self.assertTrue(self.result.wasSuccessful())
+ self.mox.UnsetStubs()
+ self.mox.VerifyAll()
+ self.test_mox.UnsetStubs()
+ self.test_mox.VerifyAll()
+
+ def testSuccess(self):
+ """Successful test method execution test."""
+ self._CreateTest('testSuccess')
+ self._VerifySuccess()
+
+ def testExpectedNotCalled(self):
+ """Stubbed out method is not called."""
+ self._CreateTest('testExpectedNotCalled')
+ self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
+ # Dont stub out VerifyAll - that's what causes the test to fail
+ self.test_mox.UnsetStubs()
+ self.test_mox.VerifyAll()
+ self.mox.ReplayAll()
+ self.test.run(result=self.result)
+ self.failIf(self.result.wasSuccessful())
+ self.mox.UnsetStubs()
+ self.mox.VerifyAll()
+ self.test_mox.UnsetStubs()
+
+ def testUnexpectedCall(self):
+ """Stubbed out method is called with unexpected arguments."""
+ self._CreateTest('testUnexpectedCall')
+ self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
+ # Ensure no calls are made to VerifyAll()
+ self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
+ self.test_mox.UnsetStubs()
+ self.mox.ReplayAll()
+ self.test.run(result=self.result)
+ self.failIf(self.result.wasSuccessful())
+ self.mox.UnsetStubs()
+ self.mox.VerifyAll()
+ self.test_mox.UnsetStubs()
+
+ def testFailure(self):
+ """Failing assertion in test method."""
+ self._CreateTest('testFailure')
+ self.mox.StubOutWithMock(self.test_mox, 'UnsetStubs')
+ # Ensure no calls are made to VerifyAll()
+ self.mox.StubOutWithMock(self.test_mox, 'VerifyAll')
+ self.test_mox.UnsetStubs()
+ self.mox.ReplayAll()
+ self.test.run(result=self.result)
+ self.failIf(self.result.wasSuccessful())
+ self.mox.UnsetStubs()
+ self.mox.VerifyAll()
+ self.test_mox.UnsetStubs()
+
+ def testMixin(self):
+ """Run test from mix-in test class, ensure it passes."""
+ self._CreateTest('testStat')
+ self._VerifySuccess()
+
+ 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.
+ If unsetting of stubs doesn't happen, this will fail.
+ """
+ self._CreateTest('testStatOther')
+ self._VerifySuccess()
+
+
+class VerifyTest(unittest.TestCase):
+ """Verify Verify works properly."""
+
+ def testVerify(self):
+ """Verify should be called for all objects.
+
+ This should throw an exception because the expected behavior did not occur.
+ """
+ mock_obj = mox.MockObject(TestClass)
+ mock_obj.ValidCall()
+ mock_obj._Replay()
+ self.assertRaises(mox.ExpectedMethodCallsError, mox.Verify, mock_obj)
+
+
+class ResetTest(unittest.TestCase):
+ """Verify Reset works properly."""
+
+ def testReset(self):
+ """Should empty all queues and put mocks in record mode."""
+ mock_obj = mox.MockObject(TestClass)
+ mock_obj.ValidCall()
+ self.assertFalse(mock_obj._replay_mode)
+ mock_obj._Replay()
+ self.assertTrue(mock_obj._replay_mode)
+ self.assertEquals(1, len(mock_obj._expected_calls_queue))
+
+ mox.Reset(mock_obj)
+ self.assertFalse(mock_obj._replay_mode)
+ self.assertEquals(0, len(mock_obj._expected_calls_queue))
+
+
+class MyTestCase(unittest.TestCase):
+ """Simulate the use of a fake wrapper around Python's unittest library."""
+
+ def setUp(self):
+ super(MyTestCase, self).setUp()
+ self.critical_variable = 42
+
+
+class MoxTestBaseMultipleInheritanceTest(mox.MoxTestBase, MyTestCase):
+ """Test that multiple inheritance can be used with MoxTestBase."""
+
+ def setUp(self):
+ super(MoxTestBaseMultipleInheritanceTest, self).setUp()
+
+ def testMultipleInheritance(self):
+ """Should be able to access members created by all parent setUp()."""
+ self.assert_(isinstance(self.mox, mox.Mox))
+ self.assertEquals(42, self.critical_variable)
+
+
+class TestClass:
+ """This class is used only for testing the mock framework"""
+
+ SOME_CLASS_VAR = "test_value"
+ _PROTECTED_CLASS_VAR = "protected value"
+
+ def __init__(self, ivar=None):
+ self.__ivar = ivar
+
+ def __eq__(self, rhs):
+ return self.__ivar == rhs
+
+ def __ne__(self, rhs):
+ return not self.__eq__(rhs)
+
+ def ValidCall(self):
+ pass
+
+ def OtherValidCall(self):
+ pass
+
+ def ValidCallWithArgs(self, *args, **kwargs):
+ pass
+
+ @classmethod
+ def MyClassMethod(cls):
+ pass
+
+ @staticmethod
+ def MyStaticMethod():
+ pass
+
+ def _ProtectedCall(self):
+ pass
+
+ def __PrivateCall(self):
+ pass
+
+ def __getitem__(self, key):
+ pass
+
+ def __DoNotMock(self):
+ pass
+
+ def __getitem__(self, key):
+ """Return the value for key."""
+ return self.d[key]
+
+ def __setitem__(self, key, value):
+ """Set the value for key to value."""
+ self.d[key] = value
+
+ def __contains__(self, key):
+ """Returns True if d contains the key."""
+ return key in self.d
+
+
+class ChildClass(TestClass):
+ """This inherits from TestClass."""
+ def __init__(self):
+ TestClass.__init__(self)
+
+ def ChildValidCall(self):
+ pass
+
+
+class CallableClass(object):
+ """This class is callable, and that should be mockable!"""
+
+ def __init__(self):
+ pass
+
+ def __call__(self, param):
+ return param
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/mox_test_helper.py Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,76 @@
+#!/usr/bin/python2.4
+#
+# Copyright 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A very basic test class derived from mox.MoxTestBase, used by mox_test.py.
+
+The class defined in this module is used to test the features of
+MoxTestBase and is not intended to be a standalone test. It needs to
+be in a separate module, because otherwise the tests in this class
+(which should not all pass) would be executed as part of the
+mox_test.py test suite.
+
+See mox_test.MoxTestBaseTest for how this class is actually used.
+"""
+
+import os
+
+import mox
+
+class ExampleMoxTestMixin(object):
+ """Mix-in class for mox test case class.
+
+ It stubs out the same function as one of the test methods in
+ the example test case. Both tests must pass as meta class wraps
+ test methods in all base classes.
+ """
+
+ def testStat(self):
+ self.mox.StubOutWithMock(os, 'stat')
+ os.stat(self.DIR_PATH)
+ self.mox.ReplayAll()
+ os.stat(self.DIR_PATH)
+
+
+class ExampleMoxTest(mox.MoxTestBase, ExampleMoxTestMixin):
+
+ DIR_PATH = '/path/to/some/directory'
+
+ def testSuccess(self):
+ self.mox.StubOutWithMock(os, 'listdir')
+ os.listdir(self.DIR_PATH)
+ self.mox.ReplayAll()
+ os.listdir(self.DIR_PATH)
+
+ def testExpectedNotCalled(self):
+ self.mox.StubOutWithMock(os, 'listdir')
+ os.listdir(self.DIR_PATH)
+ self.mox.ReplayAll()
+
+ def testUnexpectedCall(self):
+ self.mox.StubOutWithMock(os, 'listdir')
+ os.listdir(self.DIR_PATH)
+ self.mox.ReplayAll()
+ os.listdir('/path/to/some/other/directory')
+ os.listdir(self.DIR_PATH)
+
+ def testFailure(self):
+ self.assertTrue(False)
+
+ def testStatOther(self):
+ self.mox.StubOutWithMock(os, 'stat')
+ os.stat(self.DIR_PATH)
+ self.mox.ReplayAll()
+ os.stat(self.DIR_PATH)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/setup.py Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,14 @@
+#!/usr/bin/python2.4
+from distutils.core import setup
+
+setup(name='mox',
+ version='0.5.0',
+ py_modules=['mox', 'stubout'],
+ url='http://code.google.com/p/pymox/',
+ maintainer='pymox maintainers',
+ maintainer_email='mox-discuss@googlegroups.com',
+ license='Apache License, Version 2.0',
+ description='Mock object framework',
+ long_description='''Mox is a mock object framework for Python based on the
+Java mock object framework EasyMock.''',
+ )
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/stubout.py Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,139 @@
+#!/usr/bin/python2.4
+#
+# Copyright 2008 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+
+class StubOutForTesting:
+ """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()
+
+ 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):
+ self.cache = []
+ self.stubs = []
+
+ def __del__(self):
+ self.SmartUnsetAll()
+ 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.
+ """
+ if (inspect.ismodule(obj) or
+ (not inspect.isclass(obj) and obj.__dict__.has_key(attr_name))):
+ orig_obj = obj
+ orig_attr = getattr(obj, attr_name)
+
+ else:
+ if not inspect.isclass(obj):
+ mro = list(inspect.getmro(obj.__class__))
+ else:
+ mro = list(inspect.getmro(obj))
+
+ mro.reverse()
+
+ orig_attr = None
+
+ for cls in mro:
+ try:
+ orig_obj = cls
+ orig_attr = getattr(obj, attr_name)
+ except AttributeError:
+ continue
+
+ 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.
+ old_attribute = obj.__dict__.get(attr_name)
+ 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.
+
+ """
+ self.stubs.reverse()
+
+ for args in self.stubs:
+ setattr(*args)
+
+ 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.
+
+ This method supports the case where child_name is a staticmethod or a
+ classmethod of parent.
+ """
+ old_child = getattr(parent, child_name)
+
+ old_attribute = parent.__dict__.get(child_name)
+ if old_attribute is not None and isinstance(old_attribute, staticmethod):
+ old_child = staticmethod(old_child)
+
+ self.cache.append((parent, old_child, child_name))
+ 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.
+
+ """
+ # 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)
+ self.cache.reverse()
+
+ for (parent, old_child, child_name) in self.cache:
+ setattr(parent, child_name, old_child)
+ self.cache = []
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/stubout_test.py Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,47 @@
+#!/usr/bin/python2.4
+#
+# Unit tests for stubout.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+import mox
+import stubout
+import stubout_testee
+
+
+class StubOutForTestingTest(unittest.TestCase):
+ def setUp(self):
+ self.mox = mox.Mox()
+ self.sample_function_backup = stubout_testee.SampleFunction
+
+ def tearDown(self):
+ stubout_testee.SampleFunction = self.sample_function_backup
+
+ def testSmartSetOnModule(self):
+ mock_function = self.mox.CreateMockAnything()
+ mock_function()
+
+ stubber = stubout.StubOutForTesting()
+ stubber.SmartSet(stubout_testee, 'SampleFunction', mock_function)
+
+ self.mox.ReplayAll()
+
+ stubout_testee.SampleFunction()
+
+ self.mox.VerifyAll()
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/pymox/stubout_testee.py Mon Jan 26 16:04:19 2009 +0000
@@ -0,0 +1,2 @@
+def SampleFunction():
+ raise Exception('I should never be called!')