def test_replay_emits():
emissions = (
('foo', {
'args': (123, ),
'kwargs': {}
}),
('bar', {
'args': ('hello', 'world'),
'kwargs': {}
}),
('foo', {
'args': ('and', ),
'kwargs': {
'this': 'that'
}
}),
('bar', {
'args': (),
'kwargs': {
'four': 56
}
}),
)
s = Signal('foo', 'bar', 'baz')
cb = Mock()
s.register('foo', cb.foo)
s.register('bar', cb.bar)
s.register('baz', cb.baz)
s.replay(emissions)
assert cb.mock_calls == [
call.foo(123),
call.bar('hello', 'world'),
call.foo('and', this='that'),
call.bar(four=56),
]
def test_suspend_blocks_emissions():
s = Signal('foo', 'bar', 'baz')
cb = Mock()
s.register('foo', cb.foo)
s.register('bar', cb.bar)
s.register('baz', cb.baz)
s.emit('foo', 123, this='that')
s.emit('bar', 456, hey='ho')
s.emit('baz', 789, zip='zop')
assert cb.mock_calls == [
call.foo(123, this='that'),
call.bar(456, hey='ho'),
call.baz(789, zip='zop'),
]
cb.reset_mock()
with s.suspend('bar', 'foo'):
s.emit('foo', 123, this='that')
s.emit('bar', 456, hey='ho')
s.emit('baz', 789, zip='zop')
assert cb.mock_calls == [
call.baz(789, zip='zop'),
]
cb.reset_mock()
s.emit('foo', 123, this='that')
s.emit('bar', 456, hey='ho')
s.emit('baz', 789, zip='zop')
assert cb.mock_calls == [
call.foo(123, this='that'),
call.bar(456, hey='ho'),
call.baz(789, zip='zop'),
]
def test_attribute_call(self):
self.assertEqual(call.foo(1), ('foo', (1,), {}))
self.assertEqual(call.bar.baz(fish='eggs'), ('bar.baz', (), {'fish': 'eggs'}))
mock = Mock()
mock.foo(1, 2, 3)
mock.bar.baz(a=3, b=6)
self.assertEqual(mock.method_calls, [call.foo(1, 2, 3), call.bar.baz(a=3, b=6)])
def test_compute(self):
"""Unit test for MyClassA.compute"""
myobj = MyClassA()
# Create a mock object and mock methods of MyClassA
mockobj = Mock()
myobj.foo = mockobj.foo
myobj.foo2 = mockobj.foo2
# Assuming you know the return values, set those for the mocks
myobj.foo.return_value = 120
myobj.foo2.return_value = 170
# Run the computation. Calls to foo and foo2 in compute method are
# now replaced with mock object calls that return the desired values
result = myobj.compute()
# Verify the results
self.assertEqual(result, 290)
# Get info on how the mock objects are actually called by compute
test_call_list = mockobj.mock_calls
print("test_call_list = {0}".format(test_call_list))
# Compare it against some reference calling order
reference_call_list = [call.foo(), call.foo2(120)]
self.assertEqual(test_call_list, reference_call_list)
def test_compute(self):
"""Unit test for MyClassA.compute."""
a = MyClassA()
# Create a mock object and mock methods of MyClassA
mockObj = Mock()
a.foo = mockObj.foo
a.foo2 = mockObj.foo2
# Assuming you know the return values, set those for the mocks
a.foo.return_value = 100
a.foo2.return_value = 300
# Run the computation. Calls the foo and foo2 in compute method are
# now replace with mock object calls that return the desired value
result = a.compute()
# Verify the results
self.assertEqual(result, 400)
# Get info on how the mock objects are actually called by compute
test_call_list = mockObj.mock_calls
print("test_call_list=", test_call_list)
# Compare it against some reference calling order
reference_call_list = [call.foo(), call.foo2()]
self.assertEqual(test_call_list, reference_call_list)
def test_assert_has_calls(self):
kalls1 = [call(1, 2), ({"a": 3},), ((3, 4),), call(b=6), ("", (1,), {"b": 6})]
kalls2 = [call.foo(), call.bar(1)]
kalls2.extend(call.spam().baz(a=3).call_list())
kalls2.extend(call.bam(set(), foo={}).fish([1]).call_list())
mocks = []
for mock in Mock(), MagicMock():
mock(1, 2)
mock(a=3)
mock(3, 4)
mock(b=6)
mock(1, b=6)
mocks.append((mock, kalls1))
mock = Mock()
mock.foo()
mock.bar(1)
mock.spam().baz(a=3)
mock.bam(set(), foo={}).fish([1])
mocks.append((mock, kalls2))
for mock, kalls in mocks:
for i in range(len(kalls)):
for step in 1, 2, 3:
these = kalls[i : i + step]
mock.assert_has_calls(these)
if len(these) > 1:
self.assertRaises(AssertionError, mock.assert_has_calls, list(reversed(these)))
def test_compute(self):
a = MyClassA()
mockObj = Mock()
a.foo = mockObj.foo
a.foo2 = mockObj.foo2
#Assuming you know the return values, set for the mocks
a.foo.return_value = 100
a.foo2.return_value = 300
#Run computation
#Calls to foo and foo2 in compute methood are now replaces with mock objects calls that return the desire value
result = a.compute()
#Veryfiy
self.assertEqual(result, 400)
# Get info on how the mock objects are actually called by compute
test_call_list = mockObj.mock_calls
print("test_call_list", test_call_list)
#Compare it against some reference calling order
reference_call_list = [call.foo(), call.foo2()]
self.assertEqual(test_call_list, reference_call_list)
def test_assert_has_calls(self):
kalls1 = [call(1, 2), ({'a': 3},), ((3, 4),), call(b=6), ('', (1,),
{'b': 6})]
kalls2 = [call.foo(), call.bar(1)]
kalls2.extend(call.spam().baz(a=3).call_list())
kalls2.extend(call.bam(set(), foo={}).fish([1]).call_list())
mocks = []
for mock in (Mock(), MagicMock()):
mock(1, 2)
mock(a=3)
mock(3, 4)
mock(b=6)
mock(1, b=6)
mocks.append((mock, kalls1))
mock = Mock()
mock.foo()
mock.bar(1)
mock.spam().baz(a=3)
mock.bam(set(), foo={}).fish([1])
mocks.append((mock, kalls2))
for mock, kalls in mocks:
for i in range(len(kalls)):
for step in (1, 2, 3):
these = kalls[i:i + step]
mock.assert_has_calls(these)
if len(these) > 1:
self.assertRaises(AssertionError, mock.
assert_has_calls, list(reversed(these)))
def test_adding_child_mock(self):
for Klass in (NonCallableMock, Mock, MagicMock, NonCallableMagicMock):
mock = Klass()
mock.foo = Mock()
mock.foo()
self.assertEqual(mock.method_calls, [call.foo()])
self.assertEqual(mock.mock_calls, [call.foo()])
mock = Klass()
mock.bar = Mock(name='name')
mock.bar()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
mock = Klass()
mock.baz = MagicMock()()
mock.baz()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
def test_adding_child_mock(self):
for Klass in (NonCallableMock, Mock, MagicMock, NonCallableMagicMock):
mock = Klass()
mock.foo = Mock()
mock.foo()
self.assertEqual(mock.method_calls, [call.foo()])
self.assertEqual(mock.mock_calls, [call.foo()])
mock = Klass()
mock.bar = Mock(name='name')
mock.bar()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
mock = Klass()
mock.baz = MagicMock()()
mock.baz()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
def test_mock_calls(self):
mock = MagicMock()
self.assertIs(mock.mock_calls == [], True)
mock = MagicMock()
mock()
expected = [('', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock.foo()
expected.append(call.foo())
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.foo.mock_calls, [('', (), {})])
mock = MagicMock()
mock().foo(1, 2, 3, a=4, b=5)
expected = [('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5))]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.return_value.foo.mock_calls, [('', (1, 2, 3),
dict(a=4, b=5))])
self.assertEqual(mock.return_value.mock_calls, [('foo', (1, 2, 3),
dict(a=4, b=5))])
mock = MagicMock()
mock().foo.bar().baz()
expected = [('', (), {}), ('().foo.bar', (), {}), (
'().foo.bar().baz', (), {})]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock().mock_calls, call.foo.bar().baz().call_list())
for kwargs in (dict(), dict(name='bar')):
mock = MagicMock(**kwargs)
int(mock.foo)
expected = [('foo.__int__', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock = MagicMock(**kwargs)
mock.a()()
expected = [('a', (), {}), ('a()', (), {})]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.a().mock_calls, [call()])
mock = MagicMock(**kwargs)
mock(1)(2)(3)
self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
self.assertEqual(mock().mock_calls, call(2)(3).call_list())
self.assertEqual(mock()().mock_calls, call(3).call_list())
mock = MagicMock(**kwargs)
mock(1)(2)(3).a.b.c(4)
self.assertEqual(mock.mock_calls, call(1)(2)(3).a.b.c(4).
call_list())
self.assertEqual(mock().mock_calls, call(2)(3).a.b.c(4).call_list()
)
self.assertEqual(mock()().mock_calls, call(3).a.b.c(4).call_list())
mock = MagicMock(**kwargs)
int(mock().foo.bar().baz())
last_call = '().foo.bar().baz().__int__', (), {}
self.assertEqual(mock.mock_calls[-1], last_call)
self.assertEqual(mock().mock_calls, call.foo.bar().baz().
__int__().call_list())
self.assertEqual(mock().foo.bar().mock_calls, call.baz().
__int__().call_list())
self.assertEqual(mock().foo.bar().baz.mock_calls, call().
__int__().call_list())
def test_adding_child_mock(self):
for Klass in NonCallableMock, Mock, MagicMock, NonCallableMagicMock:
mock = Klass()
mock.foo = Mock()
mock.foo()
self.assertEqual(mock.method_calls, [call.foo()])
self.assertEqual(mock.mock_calls, [call.foo()])
mock = Klass()
mock.bar = Mock(name='name')
mock.bar()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
# mock with an existing _new_parent but no name
mock = Klass()
mock.baz = MagicMock()()
mock.baz()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
def test_adding_child_mock(self):
for Klass in NonCallableMock, Mock, MagicMock, NonCallableMagicMock:
mock = Klass()
mock.foo = Mock()
mock.foo()
self.assertEqual(mock.method_calls, [call.foo()])
self.assertEqual(mock.mock_calls, [call.foo()])
mock = Klass()
mock.bar = Mock(name='name')
mock.bar()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
# mock with an existing _new_parent but no name
mock = Klass()
mock.baz = MagicMock()()
mock.baz()
self.assertEqual(mock.method_calls, [])
self.assertEqual(mock.mock_calls, [])
def test_extended_call(self):
result = call(1).foo(2).bar(3, a=4)
self.assertEqual(result, ('().foo().bar', (3,), dict(a=4)))
mock = MagicMock()
mock(1, 2, a=3, b=4)
self.assertEqual(mock.call_args, call(1, 2, a=3, b=4))
self.assertNotEqual(mock.call_args, call(1, 2, 3))
self.assertEqual(mock.call_args_list, [call(1, 2, a=3, b=4)])
self.assertEqual(mock.mock_calls, [call(1, 2, a=3, b=4)])
mock = MagicMock()
mock.foo(1).bar()().baz.beep(a=6)
last_call = call.foo(1).bar()().baz.beep(a=6)
self.assertEqual(mock.mock_calls[-1], last_call)
self.assertEqual(mock.mock_calls, last_call.call_list())
def test_extended_call(self):
result = call(1).foo(2).bar(3, a=4)
self.assertEqual(result, ('().foo().bar', (3, ), dict(a=4)))
mock = MagicMock()
mock(1, 2, a=3, b=4)
self.assertEqual(mock.call_args, call(1, 2, a=3, b=4))
self.assertNotEqual(mock.call_args, call(1, 2, 3))
self.assertEqual(mock.call_args_list, [call(1, 2, a=3, b=4)])
self.assertEqual(mock.mock_calls, [call(1, 2, a=3, b=4)])
mock = MagicMock()
mock.foo(1).bar()().baz.beep(a=6)
last_call = call.foo(1).bar()().baz.beep(a=6)
self.assertEqual(mock.mock_calls[-1], last_call)
self.assertEqual(mock.mock_calls, last_call.call_list())
def test_mock_calls(self):
mock = MagicMock()
self.assertIs(mock.mock_calls == [], True)
mock = MagicMock()
mock()
expected = [('', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock.foo()
expected.append(call.foo())
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.foo.mock_calls, [('', (), {})])
mock = MagicMock()
mock().foo(1, 2, 3, a=4, b=5)
expected = [('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5))]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.return_value.foo.mock_calls, [('', (1, 2, 3), dict(a=4, b=5))])
self.assertEqual(mock.return_value.mock_calls, [('foo', (1, 2, 3), dict(a=4, b=5))])
mock = MagicMock()
mock().foo.bar().baz()
expected = [('', (), {}), ('().foo.bar', (), {}), ('().foo.bar().baz', (), {})]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock().mock_calls, call.foo.bar().baz().call_list())
for kwargs in (dict(), dict(name='bar')):
mock = MagicMock(**kwargs)
int(mock.foo)
expected = [('foo.__int__', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock = MagicMock(**kwargs)
mock.a()()
expected = [('a', (), {}), ('a()', (), {})]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.a().mock_calls, [call()])
mock = MagicMock(**kwargs)
mock(1)(2)(3)
self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
self.assertEqual(mock().mock_calls, call(2)(3).call_list())
self.assertEqual(mock()().mock_calls, call(3).call_list())
mock = MagicMock(**kwargs)
mock(1)(2)(3).a.b.c(4)
self.assertEqual(mock.mock_calls, call(1)(2)(3).a.b.c(4).call_list())
self.assertEqual(mock().mock_calls, call(2)(3).a.b.c(4).call_list())
self.assertEqual(mock()().mock_calls, call(3).a.b.c(4).call_list())
mock = MagicMock(**kwargs)
int(mock().foo.bar().baz())
last_call = ('().foo.bar().baz().__int__', (), {})
self.assertEqual(mock.mock_calls[-1], last_call)
self.assertEqual(mock().mock_calls, call.foo.bar().baz().__int__().call_list())
self.assertEqual(mock().foo.bar().mock_calls, call.baz().__int__().call_list())
self.assertEqual(mock().foo.bar().baz.mock_calls, call().__int__().call_list())
def test_should_call_functions_in_process_special_settings(self):
funcs = MagicMock()
settings_dict = {
'SIMPLE_SETTINGS': {
'bar': 'bar_value',
'foo': 'foo_value'
}
}
with patch('simple_settings.special_settings.SPECIAL_SETTINGS_MAPPING',
OrderedDict((('foo', funcs.foo), ('bar', funcs.bar)))):
process_special_settings(settings_dict)
assert funcs.mock_calls == [
call.foo(settings_dict),
call.bar(settings_dict)
]
def test_mock_calls(self):
mock = MagicMock()
# need to do this because MagicMock.mock_calls used to just return
# a MagicMock which also returned a MagicMock when __eq__ was called
self.assertIs(mock.mock_calls == [], True)
mock = MagicMock()
mock()
expected = [('', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock.foo()
expected.append(call.foo())
self.assertEqual(mock.mock_calls, expected)
# intermediate mock_calls work too
self.assertEqual(mock.foo.mock_calls, [('', (), {})])
mock = MagicMock()
mock().foo(1, 2, 3, a=4, b=5)
expected = [
('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5))
]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.return_value.foo.mock_calls,
[('', (1, 2, 3), dict(a=4, b=5))])
self.assertEqual(mock.return_value.mock_calls,
[('foo', (1, 2, 3), dict(a=4, b=5))])
mock = MagicMock()
mock().foo.bar().baz()
expected = [
('', (), {}), ('().foo.bar', (), {}),
('().foo.bar().baz', (), {})
]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock().mock_calls,
call.foo.bar().baz().call_list())
for kwargs in dict(), dict(name='bar'):
mock = MagicMock(**kwargs)
int(mock.foo)
expected = [('foo.__int__', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock = MagicMock(**kwargs)
mock.a()()
expected = [('a', (), {}), ('a()', (), {})]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.a().mock_calls, [call()])
mock = MagicMock(**kwargs)
mock(1)(2)(3)
self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
self.assertEqual(mock().mock_calls, call(2)(3).call_list())
self.assertEqual(mock()().mock_calls, call(3).call_list())
mock = MagicMock(**kwargs)
mock(1)(2)(3).a.b.c(4)
self.assertEqual(mock.mock_calls,
call(1)(2)(3).a.b.c(4).call_list())
self.assertEqual(mock().mock_calls,
call(2)(3).a.b.c(4).call_list())
self.assertEqual(mock()().mock_calls,
call(3).a.b.c(4).call_list())
mock = MagicMock(**kwargs)
int(mock().foo.bar().baz())
last_call = ('().foo.bar().baz().__int__', (), {})
self.assertEqual(mock.mock_calls[-1], last_call)
self.assertEqual(mock().mock_calls,
call.foo.bar().baz().__int__().call_list())
self.assertEqual(mock().foo.bar().mock_calls,
call.baz().__int__().call_list())
self.assertEqual(mock().foo.bar().baz.mock_calls,
call().__int__().call_list())
def test_promise_errback_shortcircuit(p, mock):
e = Exception()
p.then(mock.foo) # also used as errback
p.set_exception(e)
assert mock.mock_calls == [call.foo(e)]
def test_promise_callback_added_late(p, mock):
p.set_result(1)
p.then(mock.foo)
assert mock.mock_calls == [call.foo(1)]
def test_mock_calls(self):
mock = MagicMock()
# need to do this because MagicMock.mock_calls used to just return
# a MagicMock which also returned a MagicMock when __eq__ was called
self.assertIs(mock.mock_calls == [], True)
mock = MagicMock()
mock()
expected = [('', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock.foo()
expected.append(call.foo())
self.assertEqual(mock.mock_calls, expected)
# intermediate mock_calls work too
self.assertEqual(mock.foo.mock_calls, [('', (), {})])
mock = MagicMock()
mock().foo(1, 2, 3, a=4, b=5)
expected = [('', (), {}), ('().foo', (1, 2, 3), dict(a=4, b=5))]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.return_value.foo.mock_calls,
[('', (1, 2, 3), dict(a=4, b=5))])
self.assertEqual(mock.return_value.mock_calls,
[('foo', (1, 2, 3), dict(a=4, b=5))])
mock = MagicMock()
mock().foo.bar().baz()
expected = [('', (), {}), ('().foo.bar', (), {}),
('().foo.bar().baz', (), {})]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock().mock_calls, call.foo.bar().baz().call_list())
for kwargs in dict(), dict(name='bar'):
mock = MagicMock(**kwargs)
int(mock.foo)
expected = [('foo.__int__', (), {})]
self.assertEqual(mock.mock_calls, expected)
mock = MagicMock(**kwargs)
mock.a()()
expected = [('a', (), {}), ('a()', (), {})]
self.assertEqual(mock.mock_calls, expected)
self.assertEqual(mock.a().mock_calls, [call()])
mock = MagicMock(**kwargs)
mock(1)(2)(3)
self.assertEqual(mock.mock_calls, call(1)(2)(3).call_list())
self.assertEqual(mock().mock_calls, call(2)(3).call_list())
self.assertEqual(mock()().mock_calls, call(3).call_list())
mock = MagicMock(**kwargs)
mock(1)(2)(3).a.b.c(4)
self.assertEqual(mock.mock_calls,
call(1)(2)(3).a.b.c(4).call_list())
self.assertEqual(mock().mock_calls,
call(2)(3).a.b.c(4).call_list())
self.assertEqual(mock()().mock_calls, call(3).a.b.c(4).call_list())
mock = MagicMock(**kwargs)
int(mock().foo.bar().baz())
last_call = ('().foo.bar().baz().__int__', (), {})
self.assertEqual(mock.mock_calls[-1], last_call)
self.assertEqual(mock().mock_calls,
call.foo.bar().baz().__int__().call_list())
self.assertEqual(mock().foo.bar().mock_calls,
call.baz().__int__().call_list())
self.assertEqual(mock().foo.bar().baz.mock_calls,
call().__int__().call_list())
