Logo Search packages:      
Sourcecode: chromium-browser version File versions  Download package

mox_test.py

#!/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


00028 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))


00062 class OrTest(unittest.TestCase):
  """Test Or correctly chains Comparators."""

00065   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')

00071   def testInvalidOr(self):
    """Or should be False if both Comparators return False."""
    self.failIf(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)


00076 class AndTest(unittest.TestCase):
  """Test And correctly chains Comparators."""

00079   def testValidAnd(self):
    """And should be True if both Comparators return True."""
    self.assert_(mox.And(mox.IsA(str), mox.IsA(str)) == '1')

00083   def testClauseOneFails(self):
    """And should be False if the first Comparator returns False."""

    self.failIf(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')

00088   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)

00097   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)


00104 class SameElementsAsTest(unittest.TestCase):
  """Test SameElementsAs correctly identifies sequences with same elements."""

00107   def testSortedLists(self):
    """Should return True if two lists are exactly equal."""
    self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c'])

00111   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])

00115   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}])

00120   def testEmptyLists(self):
    """Should return True for two empty lists."""
    self.assert_(mox.SameElementsAs([]) == [])

00124   def testUnequalLists(self):
    """Should return False if the lists are not equal."""
    self.failIf(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c'])

00128   def testUnequalUnhashableLists(self):
    """Should return False if two lists with unhashable elements are unequal."""
    self.failIf(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}])


00133 class ContainsKeyValueTest(unittest.TestCase):
  """Test ContainsKeyValue correctly identifies key/value pairs in a dict.
  """

00137   def testValidPair(self):
    """Should return True if the key value is in the dict."""
    self.assert_(mox.ContainsKeyValue("key", 1) == {"key": 1})

00141   def testInvalidValue(self):
    """Should return False if the value is not correct."""
    self.failIf(mox.ContainsKeyValue("key", 1) == {"key": 2})

00145   def testInvalidKey(self):
    """Should return False if they key is not in the dict."""
    self.failIf(mox.ContainsKeyValue("qux", 1) == {"key": 2})


00150 class InTest(unittest.TestCase):
  """Test In correctly identifies a key in a list/dict"""

00153   def testItemInList(self):
    """Should return True if the item is in the list."""
    self.assert_(mox.In(1) == [1, 2, 3])

00157   def testKeyInDict(self):
    """Should return True if the item is a key in a dict."""
    self.assert_(mox.In("test") == {"test" : "module"})


00162 class NotTest(unittest.TestCase):
  """Test Not correctly identifies False predicates."""

00165   def testItemInList(self):
    """Should return True if the item is NOT in the list."""
    self.assert_(mox.Not(mox.In(42)) == [1, 2, 3])

00169   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})

00173   def testInvalidKeyWithNot(self):
    """Should return False if they key is NOT in the dict."""
    self.assert_(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})


00178 class StrContainsTest(unittest.TestCase):
  """Test StrContains correctly checks for substring occurrence of a parameter.
  """

00182   def testValidSubstringAtStart(self):
    """Should return True if the substring is at the start of the string."""
    self.assert_(mox.StrContains("hello") == "hello world")

00186   def testValidSubstringInMiddle(self):
    """Should return True if the substring is in the middle of the string."""
    self.assert_(mox.StrContains("lo wo") == "hello world")

00190   def testValidSubstringAtEnd(self):
    """Should return True if the substring is at the end of the string."""
    self.assert_(mox.StrContains("ld") == "hello world")

00194   def testInvaildSubstring(self):
    """Should return False if the substring is not in the string."""
    self.failIf(mox.StrContains("AAA") == "hello world")

00198   def testMultipleMatches(self):
    """Should return True if there are multiple occurances of substring."""
    self.assert_(mox.StrContains("abc") == "ababcabcabcababc")


00203 class RegexTest(unittest.TestCase):
  """Test Regex correctly matches regular expressions."""

00206   def testIdentifyBadSyntaxDuringInit(self):
    """The user should know immediately if a regex has bad syntax."""
    self.assertRaises(re.error, mox.Regex, '(a|b')

00210   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")

00217   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")

00221   def testFlagsPassedCorrectly(self):
    """Should return True as we pass IGNORECASE flag."""
    self.assert_(mox.Regex(r"A", re.IGNORECASE) == "a")

00225   def testReprWithoutFlags(self):
    """repr should return the regular expression pattern."""
    self.assert_(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>")

00229   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>")


00235 class IsATest(unittest.TestCase):
  """Verify IsA correctly checks equality based upon class type, not value."""

00238   def testEqualityValid(self):
    """Verify that == correctly identifies objects of the same type."""
    self.assert_(mox.IsA(str) == 'test')

00242   def testEqualityInvalid(self):
    """Verify that == correctly identifies objects of different types."""
    self.failIf(mox.IsA(str) == 10)

00246   def testInequalityValid(self):
    """Verify that != identifies objects of different type."""
    self.assert_(mox.IsA(str) != 10)

00250   def testInequalityInvalid(self):
    """Verify that != correctly identifies objects of the same type."""
    self.failIf(mox.IsA(str) != "test")

00254   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)

00260   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)

00266   def testSpecialTypes(self):
    """Verify that IsA can handle objects like cStringIO.StringIO."""
    isA = mox.IsA(cStringIO.StringIO())
    stringIO = cStringIO.StringIO()
    self.assert_(isA == stringIO)


00273 class IsAlmostTest(unittest.TestCase):
  """Verify IsAlmost correctly checks equality of floating point numbers."""

00276   def testEqualityValid(self):
    """Verify that == correctly identifies nearly equivalent floats."""
    self.assertEquals(mox.IsAlmost(1.8999999999), 1.9)

00280   def testEqualityInvalid(self):
    """Verify that == correctly identifies non-equivalent floats."""
    self.assertNotEquals(mox.IsAlmost(1.899), 1.9)

00284   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)

00289   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')


00297 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)

00305   def testAndReturnNoneByDefault(self):
    """Should return None by default."""
    return_value = self.mock_method(['original'])
    self.assert_(return_value == None)

00310   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)

00317   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)

00323   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])

00333   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)

00338   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)

00343   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)

00352   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)

00360   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)

00369   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)

00377   def testEqualityWrongType(self):
    """Method should not be equal to an object of a different type."""
    self.failIfEqual(self.mock_method, "string?")

00381   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})")


00424 class MockAnythingTest(unittest.TestCase):
  """Verify that the MockAnything class works as expected."""

  def setUp(self):
    self.mock_object = mox.MockAnything()

00430   def testRepr(self):
    """Calling repr on a MockAnything instance must work."""
    self.assertEqual('<MockAnything instance>', repr(self.mock_object))

00434   def testSetupMode(self):
    """Verify the mock will accept any call."""
    self.mock_object.NonsenseCall()
    self.assert_(len(self.mock_object._expected_calls_queue) == 1)

00439   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

00445   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)

00452   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()

00459   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)

00466   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()

00474   def testNonzero(self):
    """You should be able to use the mock object in an if."""
    self.mock_object._Replay()
    if self.mock_object:
      pass

00480   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

00489   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)

00494   def testEqualsMockFailure(self):
    """Verify equals identifies unequal objects."""
    self.mock_object.SillyCall()
    self.mock_object._Replay()
    self.assertNotEquals(self.mock_object, mox.MockAnything())

00500   def testEqualsInstanceFailure(self):
    """Verify equals identifies that objects are different instances."""
    self.mock_object._Replay()
    self.assertNotEquals(self.mock_object, TestClass())

00505   def testNotEquals(self):
    """Verify not equals works."""
    self.mock_object._Replay()
    self.assertFalse(self.mock_object != self.mock_object)

00510   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()

00520   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()

00529   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()

00542   def testIsReprable(self):
    """Test that MockAnythings can be repr'd without causing a failure."""
    self.failUnless('MockAnything' in repr(self.mock_object))


00547 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


00685 class MockObjectTest(unittest.TestCase):
  """Verify that the MockObject class works as exepcted."""

  def setUp(self):
    self.mock_object = mox.MockObject(TestClass)

00691   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)

00696   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")

00709   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")

00724   def testIsInstance(self):
    """Mock should be able to pass as an instance of the mocked class."""
    self.assert_(isinstance(self.mock_object, TestClass))

00728   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)

00738   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)

00746   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)

00752   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)

00757   def testEqualsMockFailure(self):
    """Verify equals identifies unequal objects."""
    self.mock_object.ValidCall()
    self.mock_object._Replay()
    self.assertNotEquals(self.mock_object, mox.MockObject(TestClass))

00763   def testEqualsInstanceFailure(self):
    """Verify equals identifies that objects are different instances."""
    self.mock_object._Replay()
    self.assertNotEquals(self.mock_object, TestClass())

00768   def testNotEquals(self):
    """Verify not equals works."""
    self.mock_object._Replay()
    self.assertFalse(self.mock_object != self.mock_object)

00773   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()

00787   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)

00801   def testMockSetItem_ExpectedNoSetItem_Success(self):
    """Test that __setitem__() gets mocked in Dummy."""
    dummy = mox.MockObject(TestClass)
    # NOT doing dummy['X'] = 'Y'

    dummy._Replay()

    def call(): dummy['X'] = 'Y'
    self.assertRaises(mox.UnexpectedMethodCallError, call)

00811   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()

00825   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 testMockSetItem_WithSubClassOfNewStyleClass(self):
    class NewStyleTestClass(object):
      def __init__(self):
        self.my_dict = {}

      def __setitem__(self, key, value):
        self.my_dict[key], value

    class TestSubClass(NewStyleTestClass):
      pass

    dummy = mox.MockObject(TestSubClass)
    dummy[1] = 2
    dummy._Replay()
    dummy[1] = 2
    dummy._Verify()

00855   def testMockGetItem_ExpectedGetItem_Success(self):
    """Test that __getitem__() 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()

00869   def testMockGetItem_ExpectedGetItem_NoSuccess(self):
    """Test that __getitem__() 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)

00883   def testMockGetItem_ExpectedNoGetItem_NoSuccess(self):
    """Test that __getitem__() gets mocked in Dummy."""
    dummy = mox.MockObject(TestClass)
    # NOT doing dummy['X']

    dummy._Replay()

    def call(): return dummy['X']
    self.assertRaises(mox.UnexpectedMethodCallError, call)

00893   def testMockGetItem_ExpectedGetItem_NonmatchingParameters(self):
    """Test that __getitem__() 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 testMockGetItem_WithSubClassOfNewStyleClass(self):
    class NewStyleTestClass(object):
      def __getitem__(self, key):
        return {1: '1', 2: '2'}[key]

    class TestSubClass(NewStyleTestClass):
      pass

    dummy = mox.MockObject(TestSubClass)
    dummy[1].AndReturn('3')

    dummy._Replay()
    self.assertEquals('3', dummy.__getitem__(1))
    dummy._Verify()

00921   def testMockIter_ExpectedIter_Success(self):
    """Test that __iter__() gets mocked in Dummy.

    In this test, _Verify() succeeds.
    """
    dummy = mox.MockObject(TestClass)
    iter(dummy).AndReturn(iter(['X', 'Y']))

    dummy._Replay()

    self.assertEqual([x for x in dummy], ['X', 'Y'])

    dummy._Verify()
00934   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()

00948   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)

00962   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()

00975   def testMockIter_ExpectedIter_NoSuccess(self):
    """Test that __iter__() gets mocked in Dummy.

    In this test, _Verify() fails.
    """
    dummy = mox.MockObject(TestClass)
    iter(dummy).AndReturn(iter(['X', 'Y']))

    dummy._Replay()

    # NOT doing self.assertEqual([x for x in dummy], ['X', 'Y'])

    self.assertRaises(mox.ExpectedMethodCallsError, dummy._Verify)

00989   def testMockIter_ExpectedNoIter_NoSuccess(self):
    """Test that __iter__() gets mocked in Dummy."""
    dummy = mox.MockObject(TestClass)
    # NOT doing iter(dummy)

    dummy._Replay()

    def call(): return [x for x in dummy]
    self.assertRaises(mox.UnexpectedMethodCallError, call)

00999   def testMockIter_ExpectedGetItem_Success(self):
    """Test that __iter__() gets mocked in Dummy using getitem."""
    dummy = mox.MockObject(SubscribtableNonIterableClass)
    dummy[0].AndReturn('a')
    dummy[1].AndReturn('b')
    dummy[2].AndRaise(IndexError)

    dummy._Replay()
    self.assertEquals(['a', 'b'], [x for x in dummy])
    dummy._Verify()

01010   def testMockIter_ExpectedNoGetItem_NoSuccess(self):
    """Test that __iter__() gets mocked in Dummy using getitem."""
    dummy = mox.MockObject(SubscribtableNonIterableClass)
    # NOT doing dummy[index]

    dummy._Replay()
    function = lambda: [x for x in dummy]
    self.assertRaises(mox.UnexpectedMethodCallError, function)

  def testMockGetIter_WithSubClassOfNewStyleClass(self):
    class NewStyleTestClass(object):
      def __iter__(self):
        return iter([1, 2, 3])

    class TestSubClass(NewStyleTestClass):
      pass

    dummy = mox.MockObject(TestSubClass)
    iter(dummy).AndReturn(iter(['a', 'b']))
    dummy._Replay()
    self.assertEquals(['a', 'b'], [x for x in dummy])
    dummy._Verify()


01034 class MoxTest(unittest.TestCase):
  """Verify Mox works correctly."""

  def setUp(self):
    self.mox = mox.Mox()

01040   def testCreateObject(self):
    """Mox should create a mock object."""
    mock_obj = self.mox.CreateMock(TestClass)

01044   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()

01054   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)

01062   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()

01072   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()

01082   def testInheritedCallableObject(self):
    """Test recording calls to an object inheriting from a callable object."""
    mock_obj = self.mox.CreateMock(InheritsFromCallable)
    mock_obj("foo").AndReturn("qux")
    self.mox.ReplayAll()

    ret_val = mock_obj("foo")
    self.assertEquals("qux", ret_val)
    self.mox.VerifyAll()

01092   def testCallOnNonCallableObject(self):
    """Test that you cannot call a non-callable object."""
    mock_obj = self.mox.CreateMock(TestClass)
    self.assertRaises(TypeError, mock_obj)

01097   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")

01105   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()

01117   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()

01133   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()

01149   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)

01161   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()

01180   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()

01204   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.mox.VerifyAll()

    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)

01226   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.mox.VerifyAll()

    self.assertEquals(9, actual_one)
    self.assertEquals(9, second_one) # Repeated calls should return same number.

01244   def testMutlipleTimesUsingFunc(self):
    """Test that the Func is not evaluated more times than necessary.

    If a Func() has side effects, it can cause a passing test to fail.
    """

    self.counter = 0
    def MyFunc(actual_str):
      """Increment the counter if actual_str == 'foo'."""
      if actual_str == 'foo':
        self.counter += 1
      return True

    mock_obj = self.mox.CreateMockAnything()
    mock_obj.Open()
    mock_obj.Method(mox.Func(MyFunc)).MultipleTimes()
    mock_obj.Close()
    self.mox.ReplayAll()

    mock_obj.Open()
    mock_obj.Method('foo')
    mock_obj.Method('foo')
    mock_obj.Method('not-foo')
    mock_obj.Close()

    self.mox.VerifyAll()

    self.assertEquals(2, self.counter)

01273   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()

01300   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)

01320   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()

01343   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)

01361   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()

01376   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()

01394   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))

01410   def testWarnsUserIfMockingMock(self):
    """Test that user is warned if they try to stub out a MockAnything."""
    self.mox.StubOutWithMock(TestClass, 'MyStaticMethod')
    self.assertRaises(TypeError, self.mox.StubOutWithMock, TestClass,
                      'MyStaticMethod')

01416   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))

01435   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))


01450 class ReplayTest(unittest.TestCase):
  """Verify Replay works properly."""

01453   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)


01461 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()

01474   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

01483   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)

01491   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()

01505   def testSuccess(self):
    """Successful test method execution test."""
    self._CreateTest('testSuccess')
    self._VerifySuccess()

01510   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()

01524   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()

01538   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()

01552   def testMixin(self):
    """Run test from mix-in test class, ensure it passes."""
    self._CreateTest('testStat')
    self._VerifySuccess()

01557   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()


01567 class VerifyTest(unittest.TestCase):
  """Verify Verify works properly."""

01570   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)


01581 class ResetTest(unittest.TestCase):
  """Verify Reset works properly."""

01584   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))


01598 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


01606 class MoxTestBaseMultipleInheritanceTest(mox.MoxTestBase, MyTestCase):
  """Test that multiple inheritance can be used with MoxTestBase."""

  def setUp(self):
    super(MoxTestBaseMultipleInheritanceTest, self).setUp()

01612   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)


01618 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

01662   def __getitem__(self, key):
    """Return the value for key."""
    return self.d[key]

01666   def __setitem__(self, key, value):
    """Set the value for key to value."""
    self.d[key] = value

01670   def __contains__(self, key):
     """Returns True if d contains the key."""
     return key in self.d

  def __iter__(self):
    pass

01677 class ChildClass(TestClass):
  """This inherits from TestClass."""
  def __init__(self):
    TestClass.__init__(self)

  def ChildValidCall(self):
    pass


01686 class CallableClass(object):
  """This class is callable, and that should be mockable!"""

  def __init__(self):
    pass

  def __call__(self, param):
    return param


class SubscribtableNonIterableClass(object):
  def __getitem__(self, index):
    raise IndexError


01701 class InheritsFromCallable(CallableClass):
  """This class should also be mockable; it inherits from a callable class."""

  pass


if __name__ == '__main__':
  unittest.main()

Generated by  Doxygen 1.6.0   Back to index