Fixed deprecation warnings in mox_test.py
This commit is contained in:
parent
958cb59b11
commit
3e5ffa1803
325
mox_test.py
325
mox_test.py
|
@ -67,13 +67,13 @@ class OrTest(unittest.TestCase):
|
|||
|
||||
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')
|
||||
self.assertTrue(mox.Or(mox.IsA(dict), mox.IsA(str)) == {})
|
||||
self.assertTrue(mox.Or(mox.IsA(dict), mox.IsA(str)) == 'test')
|
||||
self.assertTrue(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)
|
||||
self.assertFalse(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)
|
||||
|
||||
|
||||
class AndTest(unittest.TestCase):
|
||||
|
@ -81,12 +81,12 @@ class AndTest(unittest.TestCase):
|
|||
|
||||
def testValidAnd(self):
|
||||
"""And should be True if both Comparators return True."""
|
||||
self.assert_(mox.And(mox.IsA(str), mox.IsA(str)) == '1')
|
||||
self.assertTrue(mox.And(mox.IsA(str), mox.IsA(str)) == '1')
|
||||
|
||||
def testClauseOneFails(self):
|
||||
"""And should be False if the first Comparator returns False."""
|
||||
|
||||
self.failIf(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')
|
||||
self.assertFalse(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')
|
||||
|
||||
def testAdvancedUsage(self):
|
||||
"""And should work with other Comparators.
|
||||
|
@ -94,13 +94,13 @@ class AndTest(unittest.TestCase):
|
|||
Note: this test is reliant on In and ContainsKeyValue.
|
||||
"""
|
||||
test_dict = {"mock" : "obj", "testing" : "isCOOL"}
|
||||
self.assert_(mox.And(mox.In("testing"),
|
||||
self.assertTrue(mox.And(mox.In("testing"),
|
||||
mox.ContainsKeyValue("mock", "obj")) == test_dict)
|
||||
|
||||
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"),
|
||||
self.assertFalse(mox.And(mox.In("NOTFOUND"),
|
||||
mox.ContainsKeyValue("mock", "obj")) == test_dict)
|
||||
|
||||
class FuncTest(unittest.TestCase):
|
||||
|
@ -111,13 +111,12 @@ class FuncTest(unittest.TestCase):
|
|||
equals_one = lambda x: x == 1
|
||||
always_none = lambda x: None
|
||||
|
||||
self.assert_(mox.Func(equals_one) == 1)
|
||||
self.failIf(mox.Func(equals_one) == 0)
|
||||
self.assertTrue(mox.Func(equals_one) == 1)
|
||||
self.assertFalse(mox.Func(equals_one) == 0)
|
||||
|
||||
|
||||
self.failIf(mox.Func(always_none) == 1)
|
||||
self.failIf(mox.Func(always_none) == 0)
|
||||
self.failIf(mox.Func(always_none) == None)
|
||||
self.assertFalse(mox.Func(always_none) == 1)
|
||||
self.assertFalse(mox.Func(always_none) == 0)
|
||||
self.assertFalse(mox.Func(always_none) == None)
|
||||
|
||||
def testFuncExceptionPropagation(self):
|
||||
"""Exceptions within the validating function should propagate."""
|
||||
|
@ -130,7 +129,7 @@ class FuncTest(unittest.TestCase):
|
|||
else:
|
||||
return True
|
||||
|
||||
self.assert_(mox.Func(raiseExceptionOnNotOne) == 1)
|
||||
self.assertTrue(mox.Func(raiseExceptionOnNotOne) == 1)
|
||||
self.assertRaises(TestException, mox.Func(raiseExceptionOnNotOne).__eq__, 2)
|
||||
|
||||
class SameElementsAsTest(unittest.TestCase):
|
||||
|
@ -138,32 +137,32 @@ class SameElementsAsTest(unittest.TestCase):
|
|||
|
||||
def testSortedLists(self):
|
||||
"""Should return True if two lists are exactly equal."""
|
||||
self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c'])
|
||||
self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c'])
|
||||
|
||||
def testUnsortedLists(self):
|
||||
"""Should return True if two lists are unequal but have same elements."""
|
||||
self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1])
|
||||
self.assertTrue(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1])
|
||||
|
||||
def testUnhashableLists(self):
|
||||
"""Should return True if two lists have the same unhashable elements."""
|
||||
self.assert_(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) ==
|
||||
self.assertTrue(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) ==
|
||||
[{2: 'b'}, {'a': 1}])
|
||||
|
||||
def testEmptyLists(self):
|
||||
"""Should return True for two empty lists."""
|
||||
self.assert_(mox.SameElementsAs([]) == [])
|
||||
self.assertTrue(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'])
|
||||
self.assertFalse(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'}])
|
||||
self.assertFalse(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}])
|
||||
|
||||
def testActualIsNotASequence(self):
|
||||
"""Should return False if the actual object is not a sequence."""
|
||||
self.failIf(mox.SameElementsAs([1]) == object())
|
||||
self.assertFalse(mox.SameElementsAs([1]) == object())
|
||||
|
||||
def testOneUnhashableObjectInActual(self):
|
||||
"""Store the entire iterator for a correct comparison.
|
||||
|
@ -172,7 +171,7 @@ class SameElementsAsTest(unittest.TestCase):
|
|||
unhashable object was encountered and then was restarted, so the actual list
|
||||
appeared smaller than it was.
|
||||
"""
|
||||
self.failIf(mox.SameElementsAs([1, 2]) == iter([{}, 1, 2]))
|
||||
self.assertFalse(mox.SameElementsAs([1, 2]) == iter([{}, 1, 2]))
|
||||
|
||||
|
||||
class ContainsKeyValueTest(unittest.TestCase):
|
||||
|
@ -181,15 +180,15 @@ class ContainsKeyValueTest(unittest.TestCase):
|
|||
|
||||
def testValidPair(self):
|
||||
"""Should return True if the key value is in the dict."""
|
||||
self.assert_(mox.ContainsKeyValue("key", 1) == {"key": 1})
|
||||
self.assertTrue(mox.ContainsKeyValue("key", 1) == {"key": 1})
|
||||
|
||||
def testInvalidValue(self):
|
||||
"""Should return False if the value is not correct."""
|
||||
self.failIf(mox.ContainsKeyValue("key", 1) == {"key": 2})
|
||||
self.assertFalse(mox.ContainsKeyValue("key", 1) == {"key": 2})
|
||||
|
||||
def testInvalidKey(self):
|
||||
"""Should return False if they key is not in the dict."""
|
||||
self.failIf(mox.ContainsKeyValue("qux", 1) == {"key": 2})
|
||||
self.assertFalse(mox.ContainsKeyValue("qux", 1) == {"key": 2})
|
||||
|
||||
|
||||
class ContainsAttributeValueTest(unittest.TestCase):
|
||||
|
@ -207,15 +206,15 @@ class ContainsAttributeValueTest(unittest.TestCase):
|
|||
|
||||
def testValidPair(self):
|
||||
"""Should return True if the object has the key attribute and it matches."""
|
||||
self.assert_(mox.ContainsAttributeValue("key", 1) == self.test_object)
|
||||
self.assertTrue(mox.ContainsAttributeValue("key", 1) == self.test_object)
|
||||
|
||||
def testInvalidValue(self):
|
||||
"""Should return False if the value is not correct."""
|
||||
self.failIf(mox.ContainsKeyValue("key", 2) == self.test_object)
|
||||
self.assertFalse(mox.ContainsKeyValue("key", 2) == self.test_object)
|
||||
|
||||
def testInvalidKey(self):
|
||||
"""Should return False if they the object doesn't have the property."""
|
||||
self.failIf(mox.ContainsKeyValue("qux", 1) == self.test_object)
|
||||
self.assertFalse(mox.ContainsKeyValue("qux", 1) == self.test_object)
|
||||
|
||||
|
||||
class InTest(unittest.TestCase):
|
||||
|
@ -223,24 +222,24 @@ class InTest(unittest.TestCase):
|
|||
|
||||
def testItemInList(self):
|
||||
"""Should return True if the item is in the list."""
|
||||
self.assert_(mox.In(1) == [1, 2, 3])
|
||||
self.assertTrue(mox.In(1) == [1, 2, 3])
|
||||
|
||||
def testKeyInDict(self):
|
||||
"""Should return True if the item is a key in a dict."""
|
||||
self.assert_(mox.In("test") == {"test" : "module"})
|
||||
self.assertTrue(mox.In("test") == {"test" : "module"})
|
||||
|
||||
def testItemInTuple(self):
|
||||
"""Should return True if the item is in the list."""
|
||||
self.assert_(mox.In(1) == (1, 2, 3))
|
||||
self.assertTrue(mox.In(1) == (1, 2, 3))
|
||||
|
||||
def testTupleInTupleOfTuples(self):
|
||||
self.assert_(mox.In((1, 2, 3)) == ((1, 2, 3), (1, 2)))
|
||||
self.assertTrue(mox.In((1, 2, 3)) == ((1, 2, 3), (1, 2)))
|
||||
|
||||
def testItemNotInList(self):
|
||||
self.failIf(mox.In(1) == [2, 3])
|
||||
self.assertFalse(mox.In(1) == [2, 3])
|
||||
|
||||
def testTupleNotInTupleOfTuples(self):
|
||||
self.failIf(mox.In((1, 2)) == ((1, 2, 3), (4, 5)))
|
||||
self.assertFalse(mox.In((1, 2)) == ((1, 2, 3), (4, 5)))
|
||||
|
||||
|
||||
class NotTest(unittest.TestCase):
|
||||
|
@ -248,15 +247,15 @@ class NotTest(unittest.TestCase):
|
|||
|
||||
def testItemInList(self):
|
||||
"""Should return True if the item is NOT in the list."""
|
||||
self.assert_(mox.Not(mox.In(42)) == [1, 2, 3])
|
||||
self.assertTrue(mox.Not(mox.In(42)) == [1, 2, 3])
|
||||
|
||||
def testKeyInDict(self):
|
||||
"""Should return True if the item is NOT a key in a dict."""
|
||||
self.assert_(mox.Not(mox.In("foo")) == {"key" : 42})
|
||||
self.assertTrue(mox.Not(mox.In("foo")) == {"key" : 42})
|
||||
|
||||
def testInvalidKeyWithNot(self):
|
||||
"""Should return False if they key is NOT in the dict."""
|
||||
self.assert_(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})
|
||||
self.assertTrue(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})
|
||||
|
||||
|
||||
class StrContainsTest(unittest.TestCase):
|
||||
|
@ -265,23 +264,23 @@ class StrContainsTest(unittest.TestCase):
|
|||
|
||||
def testValidSubstringAtStart(self):
|
||||
"""Should return True if the substring is at the start of the string."""
|
||||
self.assert_(mox.StrContains("hello") == "hello world")
|
||||
self.assertTrue(mox.StrContains("hello") == "hello world")
|
||||
|
||||
def testValidSubstringInMiddle(self):
|
||||
"""Should return True if the substring is in the middle of the string."""
|
||||
self.assert_(mox.StrContains("lo wo") == "hello world")
|
||||
self.assertTrue(mox.StrContains("lo wo") == "hello world")
|
||||
|
||||
def testValidSubstringAtEnd(self):
|
||||
"""Should return True if the substring is at the end of the string."""
|
||||
self.assert_(mox.StrContains("ld") == "hello world")
|
||||
self.assertTrue(mox.StrContains("ld") == "hello world")
|
||||
|
||||
def testInvaildSubstring(self):
|
||||
"""Should return False if the substring is not in the string."""
|
||||
self.failIf(mox.StrContains("AAA") == "hello world")
|
||||
self.assertFalse(mox.StrContains("AAA") == "hello world")
|
||||
|
||||
def testMultipleMatches(self):
|
||||
"""Should return True if there are multiple occurances of substring."""
|
||||
self.assert_(mox.StrContains("abc") == "ababcabcabcababc")
|
||||
self.assertTrue(mox.StrContains("abc") == "ababcabcabcababc")
|
||||
|
||||
|
||||
class RegexTest(unittest.TestCase):
|
||||
|
@ -296,23 +295,23 @@ class RegexTest(unittest.TestCase):
|
|||
|
||||
This ensures that re.search is used (instead of re.find).
|
||||
"""
|
||||
self.assert_(mox.Regex(r"a\s+b") == "x y z a b c")
|
||||
self.assertTrue(mox.Regex(r"a\s+b") == "x y z a b c")
|
||||
|
||||
def testNonMatchPattern(self):
|
||||
"""Should return False if the pattern does not match the string."""
|
||||
self.failIf(mox.Regex(r"a\s+b") == "x y z")
|
||||
self.assertFalse(mox.Regex(r"a\s+b") == "x y z")
|
||||
|
||||
def testFlagsPassedCorrectly(self):
|
||||
"""Should return True as we pass IGNORECASE flag."""
|
||||
self.assert_(mox.Regex(r"A", re.IGNORECASE) == "a")
|
||||
self.assertTrue(mox.Regex(r"A", re.IGNORECASE) == "a")
|
||||
|
||||
def testReprWithoutFlags(self):
|
||||
"""repr should return the regular expression pattern."""
|
||||
self.assert_(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>")
|
||||
self.assertTrue(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>")
|
||||
|
||||
def testReprWithFlags(self):
|
||||
"""repr should return the regular expression pattern and flags."""
|
||||
self.assert_(repr(mox.Regex(r"a\s+b", flags=4)) ==
|
||||
self.assertTrue(repr(mox.Regex(r"a\s+b", flags=4)) ==
|
||||
"<regular expression 'a\s+b', flags=4>")
|
||||
|
||||
|
||||
|
@ -367,37 +366,37 @@ class IsATest(unittest.TestCase):
|
|||
|
||||
def testEqualityValid(self):
|
||||
"""Verify that == correctly identifies objects of the same type."""
|
||||
self.assert_(mox.IsA(str) == 'test')
|
||||
self.assertTrue(mox.IsA(str) == 'test')
|
||||
|
||||
def testEqualityInvalid(self):
|
||||
"""Verify that == correctly identifies objects of different types."""
|
||||
self.failIf(mox.IsA(str) == 10)
|
||||
self.assertFalse(mox.IsA(str) == 10)
|
||||
|
||||
def testInequalityValid(self):
|
||||
"""Verify that != identifies objects of different type."""
|
||||
self.assert_(mox.IsA(str) != 10)
|
||||
self.assertTrue(mox.IsA(str) != 10)
|
||||
|
||||
def testInequalityInvalid(self):
|
||||
"""Verify that != correctly identifies objects of the same type."""
|
||||
self.failIf(mox.IsA(str) != "test")
|
||||
self.assertFalse(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)
|
||||
self.assertTrue(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)
|
||||
self.assertFalse(isa_list == mixed_list)
|
||||
|
||||
def testSpecialTypes(self):
|
||||
"""Verify that IsA can handle objects like io.StringIO."""
|
||||
isA = mox.IsA(io.StringIO())
|
||||
stringIO = io.StringIO()
|
||||
self.assert_(isA == stringIO)
|
||||
self.assertTrue(isA == stringIO)
|
||||
|
||||
|
||||
class IsAlmostTest(unittest.TestCase):
|
||||
|
@ -405,23 +404,23 @@ class IsAlmostTest(unittest.TestCase):
|
|||
|
||||
def testEqualityValid(self):
|
||||
"""Verify that == correctly identifies nearly equivalent floats."""
|
||||
self.assertEquals(mox.IsAlmost(1.8999999999), 1.9)
|
||||
self.assertEqual(mox.IsAlmost(1.8999999999), 1.9)
|
||||
|
||||
def testEqualityInvalid(self):
|
||||
"""Verify that == correctly identifies non-equivalent floats."""
|
||||
self.assertNotEquals(mox.IsAlmost(1.899), 1.9)
|
||||
self.assertNotEqual(mox.IsAlmost(1.899), 1.9)
|
||||
|
||||
def testEqualityWithPlaces(self):
|
||||
"""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)
|
||||
self.assertNotEqual(mox.IsAlmost(1.899), 1.9)
|
||||
self.assertEqual(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')
|
||||
self.assertNotEqual(mox.IsAlmost(1.8999999999), '1.9')
|
||||
self.assertNotEqual(mox.IsAlmost('1.8999999999'), 1.9)
|
||||
self.assertNotEqual(mox.IsAlmost('1.8999999999'), '1.9')
|
||||
|
||||
|
||||
class ValueRememberTest(unittest.TestCase):
|
||||
|
@ -431,28 +430,28 @@ class ValueRememberTest(unittest.TestCase):
|
|||
"""Verify that value will compare to stored value."""
|
||||
value = mox.Value()
|
||||
value.store_value('hello world')
|
||||
self.assertEquals(value, 'hello world')
|
||||
self.assertEqual(value, 'hello world')
|
||||
|
||||
def testNoValue(self):
|
||||
"""Verify that uninitialized value does not compare to "empty" values."""
|
||||
value = mox.Value()
|
||||
self.assertNotEquals(value, None)
|
||||
self.assertNotEquals(value, False)
|
||||
self.assertNotEquals(value, 0)
|
||||
self.assertNotEquals(value, '')
|
||||
self.assertNotEquals(value, ())
|
||||
self.assertNotEquals(value, [])
|
||||
self.assertNotEquals(value, {})
|
||||
self.assertNotEquals(value, object())
|
||||
self.assertNotEquals(value, set())
|
||||
self.assertNotEqual(value, None)
|
||||
self.assertNotEqual(value, False)
|
||||
self.assertNotEqual(value, 0)
|
||||
self.assertNotEqual(value, '')
|
||||
self.assertNotEqual(value, ())
|
||||
self.assertNotEqual(value, [])
|
||||
self.assertNotEqual(value, {})
|
||||
self.assertNotEqual(value, object())
|
||||
self.assertNotEqual(value, set())
|
||||
|
||||
def testRememberValue(self):
|
||||
"""Verify that comparing against remember will store argument."""
|
||||
value = mox.Value()
|
||||
remember = mox.Remember(value)
|
||||
self.assertNotEquals(value, 'hello world') # value not yet stored.
|
||||
self.assertEquals(remember, 'hello world') # store value here.
|
||||
self.assertEquals(value, 'hello world') # compare against stored value.
|
||||
self.assertNotEqual(value, 'hello world') # value not yet stored.
|
||||
self.assertEqual(remember, 'hello world') # store value here.
|
||||
self.assertEqual(value, 'hello world') # compare against stored value.
|
||||
|
||||
|
||||
class MockMethodTest(unittest.TestCase):
|
||||
|
@ -465,19 +464,19 @@ class MockMethodTest(unittest.TestCase):
|
|||
|
||||
def testNameAttribute(self):
|
||||
"""Should provide a __name__ attribute."""
|
||||
self.assertEquals('testMethod', self.mock_method.__name__)
|
||||
self.assertEqual('testMethod', self.mock_method.__name__)
|
||||
|
||||
def testAndReturnNoneByDefault(self):
|
||||
"""Should return None by default."""
|
||||
return_value = self.mock_method(['original'])
|
||||
self.assert_(return_value == None)
|
||||
self.assertTrue(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)
|
||||
self.assertTrue(return_value == expected_return_value)
|
||||
|
||||
def testAndRaiseException(self):
|
||||
"""Should raise a specified exception."""
|
||||
|
@ -493,7 +492,7 @@ class MockMethodTest(unittest.TestCase):
|
|||
mutable_list[0] = 'mutation'
|
||||
self.expected_method.WithSideEffects(modifier).AndReturn(1)
|
||||
self.mock_method(local_list)
|
||||
self.assertEquals('mutation', local_list[0])
|
||||
self.assertEqual('mutation', local_list[0])
|
||||
|
||||
def testWithReturningSideEffects(self):
|
||||
"""Should call state modifier and propagate its return value."""
|
||||
|
@ -505,8 +504,8 @@ class MockMethodTest(unittest.TestCase):
|
|||
return expected_return
|
||||
self.expected_method.WithSideEffects(modifier_with_return)
|
||||
actual_return = self.mock_method(local_list)
|
||||
self.assertEquals('mutation', local_list[0])
|
||||
self.assertEquals(expected_return, actual_return)
|
||||
self.assertEqual('mutation', local_list[0])
|
||||
self.assertEqual(expected_return, actual_return)
|
||||
|
||||
def testWithReturningSideEffectsWithAndReturn(self):
|
||||
"""Should call state modifier and ignore its return value."""
|
||||
|
@ -520,8 +519,8 @@ class MockMethodTest(unittest.TestCase):
|
|||
self.expected_method.WithSideEffects(modifier_with_return).AndReturn(
|
||||
expected_return)
|
||||
actual_return = self.mock_method(local_list)
|
||||
self.assertEquals('mutation', local_list[0])
|
||||
self.assertEquals(expected_return, actual_return)
|
||||
self.assertEqual('mutation', local_list[0])
|
||||
self.assertEqual(expected_return, actual_return)
|
||||
|
||||
def testEqualityNoParamsEqual(self):
|
||||
"""Methods with the same name and without params should be equal."""
|
||||
|
@ -531,7 +530,7 @@ class MockMethodTest(unittest.TestCase):
|
|||
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)
|
||||
self.assertNotEqual(self.mock_method, expected_method)
|
||||
|
||||
def testEqualityParamsEqual(self):
|
||||
"""Methods with the same name and parameters should be equal."""
|
||||
|
@ -548,7 +547,7 @@ class MockMethodTest(unittest.TestCase):
|
|||
expected_method._params = [1, 2, 3]
|
||||
|
||||
self.mock_method._params = ['a', 'b', 'c']
|
||||
self.failIfEqual(self.mock_method, expected_method)
|
||||
self.assertNotEqual(self.mock_method, expected_method)
|
||||
|
||||
def testEqualityNamedParamsEqual(self):
|
||||
"""Methods with the same name and same named params should be equal."""
|
||||
|
@ -565,11 +564,11 @@ class MockMethodTest(unittest.TestCase):
|
|||
expected_method._named_params = {"input1": "test", "input2": "params"}
|
||||
|
||||
self.mock_method._named_params = {"input1": "test2", "input2": "params2"}
|
||||
self.failIfEqual(self.mock_method, expected_method)
|
||||
self.assertNotEqual(self.mock_method, expected_method)
|
||||
|
||||
def testEqualityWrongType(self):
|
||||
"""Method should not be equal to an object of a different type."""
|
||||
self.failIfEqual(self.mock_method, "string?")
|
||||
self.assertNotEqual(self.mock_method, "string?")
|
||||
|
||||
def testObjectEquality(self):
|
||||
"""Equality of objects should work without a Comparator"""
|
||||
|
@ -629,12 +628,12 @@ class MockAnythingTest(unittest.TestCase):
|
|||
self.mock_object._Replay()
|
||||
actual = str(self.mock_object)
|
||||
self.mock_object._Verify();
|
||||
self.assertEquals("foo", actual)
|
||||
self.assertEqual("foo", actual)
|
||||
|
||||
def testSetupMode(self):
|
||||
"""Verify the mock will accept any call."""
|
||||
self.mock_object.NonsenseCall()
|
||||
self.assert_(len(self.mock_object._expected_calls_queue) == 1)
|
||||
self.assertTrue(len(self.mock_object._expected_calls_queue) == 1)
|
||||
|
||||
def testReplayWithExpectedCall(self):
|
||||
"""Verify the mock replays method calls as expected."""
|
||||
|
@ -668,7 +667,7 @@ class MockAnythingTest(unittest.TestCase):
|
|||
self.mock_object[1].AndReturn(True)
|
||||
self.mock_object._Replay()
|
||||
returned_val = self.mock_object[1]
|
||||
self.assert_(returned_val)
|
||||
self.assertTrue(returned_val)
|
||||
self.mock_object._Verify()
|
||||
|
||||
def testNonzero(self):
|
||||
|
@ -689,18 +688,18 @@ class MockAnythingTest(unittest.TestCase):
|
|||
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)
|
||||
self.assertEqual(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())
|
||||
self.assertNotEqual(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())
|
||||
self.assertNotEqual(self.mock_object, TestClass())
|
||||
|
||||
def testNotEquals(self):
|
||||
"""Verify not equals works."""
|
||||
|
@ -735,13 +734,13 @@ class MockAnythingTest(unittest.TestCase):
|
|||
self.mock_object().AndReturn('mox0rd')
|
||||
self.mock_object._Replay()
|
||||
|
||||
self.assertEquals('mox0rd', self.mock_object())
|
||||
self.assertEqual('mox0rd', self.mock_object())
|
||||
|
||||
self.mock_object._Verify()
|
||||
|
||||
def testIsReprable(self):
|
||||
"""Test that MockAnythings can be repr'd without causing a failure."""
|
||||
self.failUnless('MockAnything' in repr(self.mock_object))
|
||||
self.assertTrue('MockAnything' in repr(self.mock_object))
|
||||
|
||||
|
||||
class MethodCheckerTest(unittest.TestCase):
|
||||
|
@ -899,7 +898,7 @@ class MockObjectTest(unittest.TestCase):
|
|||
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)
|
||||
self.assertTrue(len(self.mock_object._expected_calls_queue) == 1)
|
||||
|
||||
def testSetupModeWithInvalidCall(self):
|
||||
"""UnknownMethodCallError should be raised if a non-member method is called.
|
||||
|
@ -931,47 +930,47 @@ class MockObjectTest(unittest.TestCase):
|
|||
|
||||
def testIsInstance(self):
|
||||
"""Mock should be able to pass as an instance of the mocked class."""
|
||||
self.assert_(isinstance(self.mock_object, TestClass))
|
||||
self.assertTrue(isinstance(self.mock_object, TestClass))
|
||||
|
||||
def testFindValidMethods(self):
|
||||
"""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)
|
||||
self.assertTrue('ValidCall' in self.mock_object._known_methods)
|
||||
self.assertTrue('OtherValidCall' in self.mock_object._known_methods)
|
||||
self.assertTrue('MyClassMethod' in self.mock_object._known_methods)
|
||||
self.assertTrue('MyStaticMethod' in self.mock_object._known_methods)
|
||||
self.assertTrue('_ProtectedCall' in self.mock_object._known_methods)
|
||||
self.assertTrue('__PrivateCall' not in self.mock_object._known_methods)
|
||||
self.assertTrue('_TestClass__PrivateCall' in self.mock_object._known_methods)
|
||||
|
||||
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)
|
||||
self.assertTrue('ValidCall' in self.mock_object._known_methods)
|
||||
self.assertTrue('OtherValidCall' in self.mock_object._known_methods)
|
||||
self.assertTrue('MyClassMethod' in self.mock_object._known_methods)
|
||||
self.assertTrue('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)
|
||||
self.assertTrue('SOME_CLASS_VAR' in self.mock_object._known_vars)
|
||||
self.assertTrue('_PROTECTED_CLASS_VAR' in self.mock_object._known_vars)
|
||||
self.assertEqual('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)
|
||||
self.assertEqual(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))
|
||||
self.assertNotEqual(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())
|
||||
self.assertNotEqual(self.mock_object, TestClass())
|
||||
|
||||
def testNotEquals(self):
|
||||
"""Verify not equals works."""
|
||||
|
@ -1123,7 +1122,7 @@ class MockObjectTest(unittest.TestCase):
|
|||
dummy[1].AndReturn('3')
|
||||
|
||||
dummy._Replay()
|
||||
self.assertEquals('3', dummy.__getitem__(1))
|
||||
self.assertEqual('3', dummy.__getitem__(1))
|
||||
dummy._Verify()
|
||||
|
||||
def testMockIter_ExpectedIter_Success(self):
|
||||
|
@ -1150,7 +1149,7 @@ class MockObjectTest(unittest.TestCase):
|
|||
|
||||
dummy._Replay()
|
||||
|
||||
self.failUnless('X' in dummy)
|
||||
self.assertTrue('X' in dummy)
|
||||
|
||||
dummy._Verify()
|
||||
|
||||
|
@ -1213,7 +1212,7 @@ class MockObjectTest(unittest.TestCase):
|
|||
dummy[2].AndRaise(IndexError)
|
||||
|
||||
dummy._Replay()
|
||||
self.assertEquals(['a', 'b'], [x for x in dummy])
|
||||
self.assertEqual(['a', 'b'], [x for x in dummy])
|
||||
dummy._Verify()
|
||||
|
||||
def testMockIter_ExpectedNoGetItem_NoSuccess(self):
|
||||
|
@ -1236,12 +1235,12 @@ class MockObjectTest(unittest.TestCase):
|
|||
dummy = mox.MockObject(TestSubClass)
|
||||
iter(dummy).AndReturn(iter(['a', 'b']))
|
||||
dummy._Replay()
|
||||
self.assertEquals(['a', 'b'], [x for x in dummy])
|
||||
self.assertEqual(['a', 'b'], [x for x in dummy])
|
||||
dummy._Verify()
|
||||
|
||||
def testInstantiationWithAdditionalAttributes(self):
|
||||
mock_object = mox.MockObject(TestClass, attrs={"attr1": "value"})
|
||||
self.assertEquals(mock_object.attr1, "value")
|
||||
self.assertEqual(mock_object.attr1, "value")
|
||||
|
||||
def testCantOverrideMethodsWithAttributes(self):
|
||||
self.assertRaises(ValueError, mox.MockObject, TestClass,
|
||||
|
@ -1289,7 +1288,7 @@ class MoxTest(unittest.TestCase):
|
|||
self.mox.ReplayAll()
|
||||
|
||||
ret_val = mock_obj.ValidCall()
|
||||
self.assertEquals("yes", ret_val)
|
||||
self.assertEqual("yes", ret_val)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def testSignatureMatchingWithComparatorAsFirstArg(self):
|
||||
|
@ -1320,7 +1319,7 @@ class MoxTest(unittest.TestCase):
|
|||
self.mox.ReplayAll()
|
||||
|
||||
ret_val = mock_obj("foo")
|
||||
self.assertEquals("qux", ret_val)
|
||||
self.assertEqual("qux", ret_val)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def testInheritedCallableObject(self):
|
||||
|
@ -1330,7 +1329,7 @@ class MoxTest(unittest.TestCase):
|
|||
self.mox.ReplayAll()
|
||||
|
||||
ret_val = mock_obj("foo")
|
||||
self.assertEquals("qux", ret_val)
|
||||
self.assertEqual("qux", ret_val)
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def testCallOnNonCallableObject(self):
|
||||
|
@ -1421,8 +1420,8 @@ class MoxTest(unittest.TestCase):
|
|||
actual_one = mock_obj.Method(1)
|
||||
mock_obj.Close()
|
||||
|
||||
self.assertEquals(9, actual_one)
|
||||
self.assertEquals(10, actual_two)
|
||||
self.assertEqual(9, actual_one)
|
||||
self.assertEqual(10, actual_two)
|
||||
|
||||
self.mox.VerifyAll()
|
||||
|
||||
|
@ -1467,10 +1466,10 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
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)
|
||||
self.assertEqual(9, actual_one)
|
||||
self.assertEqual(9, second_one) # Repeated calls should return same number.
|
||||
self.assertEqual(10, actual_two)
|
||||
self.assertEqual(42, actual_three)
|
||||
|
||||
def testMultipleTimesUsingIsAParameter(self):
|
||||
"""Test if MultipleTimesGroup works with a IsA parameter."""
|
||||
|
@ -1487,8 +1486,8 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
|
||||
self.assertEquals(9, actual_one)
|
||||
self.assertEquals(9, second_one) # Repeated calls should return same number.
|
||||
self.assertEqual(9, actual_one)
|
||||
self.assertEqual(9, second_one) # Repeated calls should return same number.
|
||||
|
||||
def testMutlipleTimesUsingFunc(self):
|
||||
"""Test that the Func is not evaluated more times than necessary.
|
||||
|
@ -1517,7 +1516,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
|
||||
self.assertEquals(2, self.counter)
|
||||
self.assertEqual(2, self.counter)
|
||||
|
||||
def testMultipleTimesThreeMethods(self):
|
||||
"""Test if MultipleTimesGroup works with three or more methods."""
|
||||
|
@ -1539,10 +1538,10 @@ class MoxTest(unittest.TestCase):
|
|||
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.assertEqual(9, actual_one)
|
||||
self.assertEqual(8, actual_two)
|
||||
self.assertEqual(7, actual_three)
|
||||
self.assertEqual(10, actual_four)
|
||||
|
||||
self.mox.VerifyAll()
|
||||
|
||||
|
@ -1584,8 +1583,8 @@ class MoxTest(unittest.TestCase):
|
|||
mock_obj.Method(3)
|
||||
mock_obj.Close()
|
||||
|
||||
self.assertEquals(9, actual_one)
|
||||
self.assertEquals(42, actual_three)
|
||||
self.assertEqual(9, actual_one)
|
||||
self.assertEqual(42, actual_three)
|
||||
|
||||
self.mox.VerifyAll()
|
||||
|
||||
|
@ -1633,7 +1632,7 @@ class MoxTest(unittest.TestCase):
|
|||
self.mox.ReplayAll()
|
||||
|
||||
local_list = ['original']
|
||||
self.failUnlessRaises(Exception,
|
||||
self.assertRaises(Exception,
|
||||
mock_obj.ConfigureInOutParameter,
|
||||
local_list)
|
||||
mock_obj.WorkWithParameter(local_list)
|
||||
|
@ -1656,7 +1655,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
self.mox.UnsetStubs()
|
||||
self.assertEquals('foo', actual)
|
||||
self.assertEqual('foo', actual)
|
||||
self.assertTrue(type(test_obj.OtherValidCall) is method_type)
|
||||
|
||||
def testStubOutMethod_Unbound_Comparator(self):
|
||||
|
@ -1670,7 +1669,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
self.mox.UnsetStubs()
|
||||
self.assertEquals('foo', actual)
|
||||
self.assertEqual('foo', actual)
|
||||
|
||||
def testStubOutMethod_Unbound_Subclass_Comparator(self):
|
||||
self.mox.StubOutWithMock(mox_test_helper.TestClassFromAnotherModule, 'Value')
|
||||
|
@ -1683,7 +1682,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
self.mox.UnsetStubs()
|
||||
self.assertEquals('foo', actual)
|
||||
self.assertEqual('foo', actual)
|
||||
|
||||
def testStubOuMethod_Unbound_WithOptionalParams(self):
|
||||
self.mox = mox.Mox()
|
||||
|
@ -1708,7 +1707,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
self.mox.UnsetStubs()
|
||||
self.assertEquals('foo', actual)
|
||||
self.assertEqual('foo', actual)
|
||||
|
||||
def testStubOutMethod_Unbound_DifferentInstance(self):
|
||||
instance = TestClass()
|
||||
|
@ -1769,7 +1768,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
self.mox.UnsetStubs()
|
||||
self.assertEquals('foo', actual)
|
||||
self.assertEqual('foo', actual)
|
||||
|
||||
def testStubOutMethod_Bound_NamedUsingPositional(self):
|
||||
"""Check positional parameters can be matched to keyword arguments."""
|
||||
|
@ -1848,7 +1847,7 @@ class MoxTest(unittest.TestCase):
|
|||
def testStubOutClass_OldStyle(self):
|
||||
"""Test a mocked class whose __init__ returns a Mock."""
|
||||
self.mox.StubOutWithMock(mox_test_helper, 'TestClassFromAnotherModule')
|
||||
self.assert_(isinstance(mox_test_helper.TestClassFromAnotherModule,
|
||||
self.assertTrue(isinstance(mox_test_helper.TestClassFromAnotherModule,
|
||||
mox.MockObject))
|
||||
|
||||
mock_instance = self.mox.CreateMock(
|
||||
|
@ -1863,7 +1862,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
self.mox.UnsetStubs()
|
||||
self.assertEquals('mock instance', actual)
|
||||
self.assertEqual('mock instance', actual)
|
||||
|
||||
def testStubOutClass(self):
|
||||
self.mox.StubOutClassWithMocks(mox_test_helper, 'CallableClass')
|
||||
|
@ -1888,12 +1887,12 @@ class MoxTest(unittest.TestCase):
|
|||
self.mox.UnsetStubs()
|
||||
|
||||
# Verify the correct mocks were returned
|
||||
self.assertEquals(mock_one, one)
|
||||
self.assertEquals(mock_two, two)
|
||||
self.assertEqual(mock_one, one)
|
||||
self.assertEqual(mock_two, two)
|
||||
|
||||
# Verify
|
||||
self.assertEquals('mock', actual_one)
|
||||
self.assertEquals('called mock', actual_two)
|
||||
self.assertEqual('mock', actual_one)
|
||||
self.assertEqual('called mock', actual_two)
|
||||
|
||||
def testStubOutClass_NotAClass(self):
|
||||
self.assertRaises(TypeError, self.mox.StubOutClassWithMocks,
|
||||
|
@ -1987,7 +1986,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
foo = Foo()
|
||||
self.mox.StubOutWithMock(foo, "obj")
|
||||
self.assert_(isinstance(foo.obj, mox.MockObject))
|
||||
self.assertTrue(isinstance(foo.obj, mox.MockObject))
|
||||
foo.obj.ValidCall()
|
||||
self.mox.ReplayAll()
|
||||
|
||||
|
@ -1995,7 +1994,7 @@ class MoxTest(unittest.TestCase):
|
|||
|
||||
self.mox.VerifyAll()
|
||||
self.mox.UnsetStubs()
|
||||
self.failIf(isinstance(foo.obj, mox.MockObject))
|
||||
self.assertFalse(isinstance(foo.obj, mox.MockObject))
|
||||
|
||||
def testForgotReplayHelpfulMessage(self):
|
||||
"""If there is an AttributeError on a MockMethod, give users a helpful msg.
|
||||
|
@ -2008,7 +2007,7 @@ class MoxTest(unittest.TestCase):
|
|||
try:
|
||||
foo.GetBar().ShowMeTheMoney()
|
||||
except AttributeError as e:
|
||||
self.assertEquals('MockMethod has no attribute "ShowMeTheMoney". '
|
||||
self.assertEqual('MockMethod has no attribute "ShowMeTheMoney". '
|
||||
'Did you remember to put your mocks in replay mode?', str(e))
|
||||
|
||||
|
||||
|
@ -2109,14 +2108,14 @@ class MoxTestBaseTest(unittest.TestCase):
|
|||
self.test_stubs.SmartUnsetAll()
|
||||
self.mox.ReplayAll()
|
||||
self.test.run(result=self.result)
|
||||
self.failIf(self.result.wasSuccessful())
|
||||
self.assertFalse(self.result.wasSuccessful())
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def testExpectedNotCalledNoMocks(self):
|
||||
"""Let testExpectedNotCalled() unset all the mocks by itself."""
|
||||
self._CreateTest('testExpectedNotCalled')
|
||||
self.test.run(result=self.result)
|
||||
self.failIf(self.result.wasSuccessful())
|
||||
self.assertFalse(self.result.wasSuccessful())
|
||||
self.assertEqual(OS_LISTDIR, mox_test_helper.os.listdir)
|
||||
|
||||
def testUnexpectedCall(self):
|
||||
|
@ -2132,7 +2131,7 @@ class MoxTestBaseTest(unittest.TestCase):
|
|||
self.test_stubs.SmartUnsetAll()
|
||||
self.mox.ReplayAll()
|
||||
self.test.run(result=self.result)
|
||||
self.failIf(self.result.wasSuccessful())
|
||||
self.assertFalse(self.result.wasSuccessful())
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def testFailure(self):
|
||||
|
@ -2148,7 +2147,7 @@ class MoxTestBaseTest(unittest.TestCase):
|
|||
self.test_stubs.SmartUnsetAll()
|
||||
self.mox.ReplayAll()
|
||||
self.test.run(result=self.result)
|
||||
self.failIf(self.result.wasSuccessful())
|
||||
self.assertFalse(self.result.wasSuccessful())
|
||||
self.mox.VerifyAll()
|
||||
|
||||
def testMixin(self):
|
||||
|
@ -2190,11 +2189,11 @@ class ResetTest(unittest.TestCase):
|
|||
self.assertFalse(mock_obj._replay_mode)
|
||||
mock_obj._Replay()
|
||||
self.assertTrue(mock_obj._replay_mode)
|
||||
self.assertEquals(1, len(mock_obj._expected_calls_queue))
|
||||
self.assertEqual(1, len(mock_obj._expected_calls_queue))
|
||||
|
||||
mox.Reset(mock_obj)
|
||||
self.assertFalse(mock_obj._replay_mode)
|
||||
self.assertEquals(0, len(mock_obj._expected_calls_queue))
|
||||
self.assertEqual(0, len(mock_obj._expected_calls_queue))
|
||||
|
||||
|
||||
class MyTestCase(unittest.TestCase):
|
||||
|
@ -2207,7 +2206,7 @@ class MyTestCase(unittest.TestCase):
|
|||
|
||||
def testMethodOverride(self):
|
||||
"""Should be properly overriden in a derived class."""
|
||||
self.assertEquals(42, self.another_critical_variable)
|
||||
self.assertEqual(42, self.another_critical_variable)
|
||||
self.another_critical_variable += 1
|
||||
|
||||
|
||||
|
@ -2220,15 +2219,15 @@ class MoxTestBaseMultipleInheritanceTest(mox.MoxTestBase, MyTestCase):
|
|||
|
||||
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)
|
||||
self.assertTrue(isinstance(self.mox, mox.Mox))
|
||||
self.assertEqual(42, self.critical_variable)
|
||||
|
||||
def testMethodOverride(self):
|
||||
"""Should run before MyTestCase.testMethodOverride."""
|
||||
self.assertEquals(99, self.another_critical_variable)
|
||||
self.assertEqual(99, self.another_critical_variable)
|
||||
self.another_critical_variable = 42
|
||||
super(MoxTestBaseMultipleInheritanceTest, self).testMethodOverride()
|
||||
self.assertEquals(43, self.another_critical_variable)
|
||||
self.assertEqual(43, self.another_critical_variable)
|
||||
|
||||
class MoxTestDontMockProperties(MoxTestBaseTest):
|
||||
def testPropertiesArentMocked(self):
|
||||
|
|
Loading…
Reference in New Issue