def test_call(self):
mock = Mock()
self.assertTrue(is_instance(mock.return_value, Mock),
"Default return_value should be a Mock")
result = mock()
self.assertEqual(mock(), result,
"different result from consecutive calls")
mock.reset_mock()
ret_val = mock(sentinel.Arg)
self.assertTrue(mock.called, "called not set")
self.assertEqual(mock.call_count, 1, "call_count incoreect")
self.assertEqual(mock.call_args, ((sentinel.Arg,), {}),
"call_args not set")
self.assertEqual(mock.call_args_list, [((sentinel.Arg,), {})],
"call_args_list not initialised correctly")
mock.return_value = sentinel.ReturnValue
ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)
self.assertEqual(ret_val, sentinel.ReturnValue,
"incorrect return value")
self.assertEqual(mock.call_count, 2, "call_count incorrect")
self.assertEqual(mock.call_args,
((sentinel.Arg,), {'key': sentinel.KeyArg}),
"call_args not set")
self.assertEqual(mock.call_args_list, [
((sentinel.Arg,), {}),
((sentinel.Arg,), {'key': sentinel.KeyArg})
],
"call_args_list not set")
def test_no_cache(self):
# Two runs without using the cache shall always run analyze() again.
section = Section('test-section')
filedict = {}
task_args = 3, 4, 5
bear = CustomTasksBear(section, filedict, tasks=[task_args])
with unittest.mock.patch.object(bear, 'analyze',
wraps=bear.analyze) as mock:
# By default, omitting the cache parameter shall mean "no cache".
results = self.execute_run({bear})
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
mock.reset_mock()
results = self.execute_run({bear})
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
mock.reset_mock()
# Passing None for cache shall disable it too explicitly.
results = self.execute_run({bear}, None)
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
def test_arg_lists(self):
mocks = [
Mock(),
MagicMock(),
NonCallableMock(),
NonCallableMagicMock()
]
def assert_attrs(mock):
names = 'call_args_list', 'method_calls', 'mock_calls'
for name in names:
attr = getattr(mock, name)
self.assertIsInstance(attr, _CallList)
self.assertIsInstance(attr, list)
self.assertEqual(attr, [])
for mock in mocks:
assert_attrs(mock)
if callable(mock):
mock()
mock(1, 2)
mock(a=3)
mock.reset_mock()
assert_attrs(mock)
mock.foo()
mock.foo.bar(1, a=3)
mock.foo(1).bar().baz(3)
mock.reset_mock()
assert_attrs(mock)
def test_call(self):
mock = Mock()
self.assertTrue(is_instance(mock.return_value, Mock),
"Default return_value should be a Mock")
result = mock()
self.assertEqual(mock(), result,
"different result from consecutive calls")
mock.reset_mock()
ret_val = mock(sentinel.Arg)
self.assertTrue(mock.called, "called not set")
self.assertEqual(mock.call_count, 1, "call_count incoreect")
self.assertEqual(mock.call_args, ((sentinel.Arg, ), {}),
"call_args not set")
self.assertEqual(mock.call_args_list, [((sentinel.Arg, ), {})],
"call_args_list not initialised correctly")
mock.return_value = sentinel.ReturnValue
ret_val = mock(sentinel.Arg, key=sentinel.KeyArg)
self.assertEqual(ret_val, sentinel.ReturnValue,
"incorrect return value")
self.assertEqual(mock.call_count, 2, "call_count incorrect")
self.assertEqual(mock.call_args, ((sentinel.Arg, ), {
'key': sentinel.KeyArg
}), "call_args not set")
self.assertEqual(mock.call_args_list, [((sentinel.Arg, ), {}),
((sentinel.Arg, ), {
'key': sentinel.KeyArg
})], "call_args_list not set")
def test_arg_lists(self):
mocks = [
Mock(),
MagicMock(),
NonCallableMock(),
NonCallableMagicMock()
]
def assert_attrs(mock):
names = 'call_args_list', 'method_calls', 'mock_calls'
for name in names:
attr = getattr(mock, name)
self.assertIsInstance(attr, _CallList)
self.assertIsInstance(attr, list)
self.assertEqual(attr, [])
for mock in mocks:
assert_attrs(mock)
if callable(mock):
mock()
mock(1, 2)
mock(a=3)
mock.reset_mock()
assert_attrs(mock)
mock.foo()
mock.foo.bar(1, a=3)
mock.foo(1).bar().baz(3)
mock.reset_mock()
assert_attrs(mock)
def test_reset_mock(self):
parent = Mock()
spec = ["something"]
mock = Mock(name="child", parent=parent, spec=spec)
mock(sentinel.Something, something=sentinel.SomethingElse)
something = mock.something
mock.something()
mock.side_effect = sentinel.SideEffect
return_value = mock.return_value
return_value()
mock.reset_mock()
self.assertEqual(mock._mock_name, "child", "name incorrectly reset")
self.assertEqual(mock._mock_parent, parent, "parent incorrectly reset")
self.assertEqual(mock._mock_methods, spec, "methods incorrectly reset")
self.assertFalse(mock.called, "called not reset")
self.assertEqual(mock.call_count, 0, "call_count not reset")
self.assertEqual(mock.call_args, None, "call_args not reset")
self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
self.assertEqual(
mock.method_calls, [], "method_calls not initialised correctly: %r != %r" % (mock.method_calls, [])
)
self.assertEqual(mock.mock_calls, [])
self.assertEqual(mock.side_effect, sentinel.SideEffect, "side_effect incorrectly reset")
self.assertEqual(mock.return_value, return_value, "return_value incorrectly reset")
self.assertFalse(return_value.called, "return value mock not reset")
self.assertEqual(mock._mock_children, {"something": something}, "children reset incorrectly")
self.assertEqual(mock.something, something, "children incorrectly cleared")
self.assertFalse(mock.something.called, "child not reset")
def test_no_cache(self):
# Two runs without using the cache shall always run analyze() again.
section = Section('test-section')
filedict = {}
task_args = 3, 4, 5
bear = CustomTasksBear(section, filedict, tasks=[task_args])
with unittest.mock.patch.object(bear, 'analyze',
wraps=bear.analyze) as mock:
# By default, omitting the cache parameter shall mean "no cache".
results = self.execute_run({bear})
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
mock.reset_mock()
results = self.execute_run({bear})
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
mock.reset_mock()
# Passing None for cache shall disable it too explicitly.
results = self.execute_run({bear}, None)
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
def test_reset_mock(self):
parent = Mock()
spec = ['something']
mock = Mock(name='child', parent=parent, spec=spec)
mock(sentinel.Something, something=sentinel.SomethingElse)
something = mock.something
mock.something()
mock.side_effect = sentinel.SideEffect
return_value = mock.return_value
return_value()
mock.reset_mock()
self.assertEqual(mock._mock_name, 'child', 'name incorrectly reset')
self.assertEqual(mock._mock_parent, parent, 'parent incorrectly reset')
self.assertEqual(mock._mock_methods, spec, 'methods incorrectly reset')
self.assertFalse(mock.called, 'called not reset')
self.assertEqual(mock.call_count, 0, 'call_count not reset')
self.assertEqual(mock.call_args, None, 'call_args not reset')
self.assertEqual(mock.call_args_list, [], 'call_args_list not reset')
self.assertEqual(mock.method_calls, [], 'method_calls not initialised correctly: %r != %r' % (mock.method_calls, []))
self.assertEqual(mock.mock_calls, [])
self.assertEqual(mock.side_effect, sentinel.SideEffect, 'side_effect incorrectly reset')
self.assertEqual(mock.return_value, return_value, 'return_value incorrectly reset')
self.assertFalse(return_value.called, 'return value mock not reset')
self.assertEqual(mock._mock_children, {'something': something}, 'children reset incorrectly')
self.assertEqual(mock.something, something, 'children incorrectly cleared')
self.assertFalse(mock.something.called, 'child not reset')
def test_reset_mock(self):
parent = Mock()
spec = ['something']
mock = Mock(name='child', parent=parent, spec=spec)
mock(sentinel.Something, something=sentinel.SomethingElse)
something = mock.something
mock.something()
mock.side_effect = sentinel.SideEffect
return_value = mock.return_value
return_value()
mock.reset_mock()
self.assertEqual(mock._mock_name, 'child', 'name incorrectly reset')
self.assertEqual(mock._mock_parent, parent, 'parent incorrectly reset')
self.assertEqual(mock._mock_methods, spec, 'methods incorrectly reset')
self.assertFalse(mock.called, 'called not reset')
self.assertEqual(mock.call_count, 0, 'call_count not reset')
self.assertEqual(mock.call_args, None, 'call_args not reset')
self.assertEqual(mock.call_args_list, [], 'call_args_list not reset')
self.assertEqual(mock.method_calls, [],
'method_calls not initialised correctly: %r != %r' % (mock.
method_calls, []))
self.assertEqual(mock.mock_calls, [])
self.assertEqual(mock.side_effect, sentinel.SideEffect,
'side_effect incorrectly reset')
self.assertEqual(mock.return_value, return_value,
'return_value incorrectly reset')
self.assertFalse(return_value.called, 'return value mock not reset')
self.assertEqual(mock._mock_children, {'something': something},
'children reset incorrectly')
self.assertEqual(mock.something, something,
'children incorrectly cleared')
self.assertFalse(mock.something.called, 'child not reset')
def _hard_reset_mock(self, mock):
"""Reset a mock and also clear its return value and side effects.
:param MagicMock mock: mock instance to reset
"""
mock.reset_mock()
mock.return_value = MagicMock(name='mock()')
mock.side_effect = None
def _hard_reset_mock(self, mock):
"""Reset a mock and also clear its return value and side effects.
:param MagicMock mock: mock instance to reset
"""
mock.reset_mock()
mock.return_value = MagicMock(name='mock()')
mock.side_effect = None
def test_assert_called_with(self):
mock = Mock()
mock()
mock.assert_called_with()
self.assertRaises(AssertionError, mock.assert_called_with, 1)
mock.reset_mock()
self.assertRaises(AssertionError, mock.assert_called_with)
mock(1, 2, 3, a='fish', b='nothing')
mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
def test_assert_called_with(self):
mock = Mock()
mock()
mock.assert_called_with()
self.assertRaises(AssertionError, mock.assert_called_with, 1)
mock.reset_mock()
self.assertRaises(AssertionError, mock.assert_called_with)
mock(1, 2, 3, a='fish', b='nothing')
mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
def test_coerce_anything(self):
t = xso.Bool()
mock = unittest.mock.MagicMock()
result = mock.__bool__()
mock.reset_mock()
self.assertEqual(result, t.coerce(mock))
mock.__bool__.assert_called_once_with()
def test_coerce_anything(self):
t = xso.Bool()
mock = unittest.mock.MagicMock()
result = mock.__bool__()
mock.reset_mock()
self.assertEqual(
result,
t.coerce(mock))
mock.__bool__.assert_called_once_with()
def test_cache(self):
section = Section('test-section')
filedict = {}
cache = {}
task_args = 10, 11, 12
bear = CustomTasksBear(section, filedict, tasks=[task_args])
with unittest.mock.patch.object(bear, 'analyze',
wraps=bear.analyze) as mock:
# First time we have a cache miss.
results = self.execute_run({bear}, cache)
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertEqual(next(iter(cache.keys())), CustomTasksBear)
self.assertEqual(len(next(iter(cache.values()))), 1)
# All following times we have a cache hit (we don't modify the
# cache in between).
for i in range(3):
mock.reset_mock()
results = self.execute_run({bear}, cache)
self.assertFalse(mock.called)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertIn(CustomTasksBear, cache)
self.assertEqual(len(next(iter(cache.values()))), 1)
task_args = 500, 11, 12
bear = CustomTasksBear(section, filedict, tasks=[task_args])
with unittest.mock.patch.object(bear, 'analyze',
wraps=bear.analyze) as mock:
# Invocation with different args should add another cache entry,
# and invoke analyze() again because those weren't cached before.
results = self.execute_run({bear}, cache)
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertIn(CustomTasksBear, cache)
self.assertEqual(len(next(iter(cache.values()))), 2)
mock.reset_mock()
results = self.execute_run({bear}, cache)
self.assertFalse(mock.called)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertIn(CustomTasksBear, cache)
self.assertEqual(len(next(iter(cache.values()))), 2)
def test_cache(self):
section = Section('test-section')
filedict = {}
cache = {}
task_args = 10, 11, 12
bear = CustomTasksBear(section, filedict, tasks=[task_args])
with unittest.mock.patch.object(bear, 'analyze',
wraps=bear.analyze) as mock:
# First time we have a cache miss.
results = self.execute_run({bear}, cache)
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertEqual(next(iter(cache.keys())), CustomTasksBear)
self.assertEqual(len(next(iter(cache.values()))), 1)
# All following times we have a cache hit (we don't modify the
# cache in between).
for i in range(3):
mock.reset_mock()
results = self.execute_run({bear}, cache)
self.assertFalse(mock.called)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertIn(CustomTasksBear, cache)
self.assertEqual(len(next(iter(cache.values()))), 1)
task_args = 500, 11, 12
bear = CustomTasksBear(section, filedict, tasks=[task_args])
with unittest.mock.patch.object(bear, 'analyze',
wraps=bear.analyze) as mock:
# Invocation with different args should add another cache entry,
# and invoke analyze() again because those weren't cached before.
results = self.execute_run({bear}, cache)
mock.assert_called_once_with(*task_args)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertIn(CustomTasksBear, cache)
self.assertEqual(len(next(iter(cache.values()))), 2)
mock.reset_mock()
results = self.execute_run({bear}, cache)
self.assertFalse(mock.called)
self.assertEqual(results, list(task_args))
self.assertEqual(len(cache), 1)
self.assertIn(CustomTasksBear, cache)
self.assertEqual(len(next(iter(cache.values()))), 2)
def test_assert_called_once_with(self):
mock = Mock()
mock()
mock.assert_called_once_with()
mock()
self.assertRaises(AssertionError, mock.assert_called_once_with)
mock.reset_mock()
self.assertRaises(AssertionError, mock.assert_called_once_with)
mock('foo', 'bar', baz=2)
mock.assert_called_once_with('foo', 'bar', baz=2)
mock.reset_mock()
mock('foo', 'bar', baz=2)
self.assertRaises(AssertionError, lambda : mock.assert_called_once_with('bob', 'bar', baz=2))
def test_transforms(self, config):
mock = unittest.mock.Mock(wraps=lambda *args: args[0] if len(args) == 1 else args)
for kwarg in self._TRANSFORM_KWARGS:
if kwarg not in self._HAS_SPECIAL_KWARG:
continue
mock.reset_mock()
with self.subTest(kwarg=kwarg):
with self.create_dataset(config, **{kwarg: mock}) as (dataset, _):
dataset[0]
mock.assert_called()
def test(self):
index1 = unittest.mock.Mock()
index1.find = unittest.mock.Mock()
index2 = TypeIgnoringIndex(index1, {EntityType.GPE, EntityType.LOC})
with unittest.mock.patch.object(index1, 'find') as mock:
index2.find('test', EntityType.GPE, 1)
self.assertEqual(mock.call_count, 2)
mock.assert_any_call('test', EntityType.GPE, 1)
mock.assert_any_call('test', EntityType.LOC, 1)
mock.reset_mock()
index2.find('test', EntityType.PER, 1)
mock.assert_called_once_with('test', EntityType.PER, 1)
def test_assert_called_with(self):
mock = Mock()
mock()
# Will raise an exception if it fails
mock.assert_called_with()
self.assertRaises(AssertionError, mock.assert_called_with, 1)
mock.reset_mock()
self.assertRaises(AssertionError, mock.assert_called_with)
mock(1, 2, 3, a="fish", b="nothing")
mock.assert_called_with(1, 2, 3, a="fish", b="nothing")
def test_shutdown(self):
valid_wrapper_2 = deepcopy(self.valid_wrapper)
valid_wrapper_2["payload"]["result"]["hello"] = 25
valid_wrapper_3 = deepcopy(self.valid_wrapper)
valid_wrapper_3["payload"]["result"]["hello"] = 5000
self.producer.produce(self.topic, json.dumps(self.valid_wrapper))
self.producer.produce(self.topic, json.dumps(valid_wrapper_2))
self.producer.produce(self.topic, json.dumps(valid_wrapper_3))
self.producer.flush()
def normalize_payload(payload):
return {
**payload,
"values":
payload["result"],
"timestamp":
parse_date(payload["timestamp"]).replace(tzinfo=pytz.utc),
}
consumer = QuerySubscriptionConsumer("hi",
topic=self.topic,
commit_batch_size=100)
def mock_callback(*args, **kwargs):
if mock.call_count >= len(expected_calls):
consumer.shutdown()
mock = Mock(side_effect=mock_callback)
register_subscriber(self.registration_key)(mock)
sub = self.create_subscription()
expected_calls = [
call(normalize_payload(self.valid_payload), sub),
call(normalize_payload(valid_wrapper_2["payload"]), sub),
]
consumer.run()
mock.assert_has_calls(expected_calls)
expected_calls = [
call(normalize_payload(valid_wrapper_3["payload"]), sub)
]
mock.reset_mock()
consumer.run()
mock.assert_has_calls(expected_calls)
def test_assert_called_once_with(self):
mock = Mock()
mock()
# Will raise an exception if it fails
mock.assert_called_once_with()
mock()
self.assertRaises(AssertionError, mock.assert_called_once_with)
mock.reset_mock()
self.assertRaises(AssertionError, mock.assert_called_once_with)
mock("foo", "bar", baz=2)
mock.assert_called_once_with("foo", "bar", baz=2)
mock.reset_mock()
mock("foo", "bar", baz=2)
self.assertRaises(AssertionError, lambda: mock.assert_called_once_with("bob", "bar", baz=2))
def test_reset_mock(self):
parent = Mock()
spec = ["something"]
mock = Mock(name="child", parent=parent, spec=spec)
mock(sentinel.Something, something=sentinel.SomethingElse)
something = mock.something
mock.something()
mock.side_effect = sentinel.SideEffect
return_value = mock.return_value
return_value()
mock.reset_mock()
self.assertEqual(mock._mock_name, "child",
"name incorrectly reset")
self.assertEqual(mock._mock_parent, parent,
"parent incorrectly reset")
self.assertEqual(mock._mock_methods, spec,
"methods incorrectly reset")
self.assertFalse(mock.called, "called not reset")
self.assertEqual(mock.call_count, 0, "call_count not reset")
self.assertEqual(mock.call_args, None, "call_args not reset")
self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
self.assertEqual(mock.method_calls, [],
"method_calls not initialised correctly: %r != %r" %
(mock.method_calls, []))
self.assertEqual(mock.mock_calls, [])
self.assertEqual(mock.side_effect, sentinel.SideEffect,
"side_effect incorrectly reset")
self.assertEqual(mock.return_value, return_value,
"return_value incorrectly reset")
self.assertFalse(return_value.called, "return value mock not reset")
self.assertEqual(mock._mock_children, {'something': something},
"children reset incorrectly")
self.assertEqual(mock.something, something,
"children incorrectly cleared")
self.assertFalse(mock.something.called, "child not reset")
def test_get_or_insert(self, monkeypatch, model):
"""Test the get_or_insert function"""
reset_mocks = lambda mocks: [mock.reset_mock() for mock in mocks]
mock_model_insert_many = mock.Mock()
insert_many_execute = mock_model_insert_many.return_value.execute
mock_model_select = mock.Mock()
model_select_where = mock_model_select.return_value.where
model_select_where.return_value = [mock.sentinel.rv]
mock_elt_insert = mock.MagicMock()
mock_elt_insert.__getitem__.return_value = mock.sentinel.elt_insert
mocks = [mock_model_insert_many, insert_many_execute, mock_elt_insert,
mock_model_select, model_select_where]
monkeypatch.setattr(model, 'insert_many', mock_model_insert_many)
monkeypatch.setattr(model, 'select', mock_model_select)
elts_insert = [mock_elt_insert]
elts_get = [mock.sentinel.elt_get]
rv = api_recipes.get_or_insert(model, elts_insert, elts_get)
where_exp_get = peewee.Expression(model.id, peewee.OP.IN,
[mock.sentinel.elt_get])
where_exp_insert = peewee.Expression(model.name, peewee.OP.IN,
[mock.sentinel.elt_insert])
where_exp = peewee.Expression(where_exp_get, peewee.OP.OR,
where_exp_insert)
insert_many_calls = [mock.call(elts_insert, model.name)]
get_item_calls = [mock.call('name')]
assert rv == [mock.sentinel.rv]
assert mock_model_insert_many.call_args_list == insert_many_calls
assert insert_many_execute.call_args_list == [mock.call()]
assert mock_elt_insert.__getitem__.call_args_list == get_item_calls
assert mock_model_select.call_args_list == [mock.call()]
assert model_select_where.call_args_list == [mock.call(where_exp)]
reset_mocks(mocks)
rv = api_recipes.get_or_insert(model, elts_insert, None)
assert rv == [mock.sentinel.rv]
assert mock_model_insert_many.call_args_list == insert_many_calls
assert insert_many_execute.call_args_list == [mock.call()]
assert mock_elt_insert.__getitem__.call_args_list == get_item_calls
assert mock_model_select.call_args_list == [mock.call()]
assert model_select_where.call_args_list == [
mock.call(where_exp_insert)
]
reset_mocks(mocks)
rv = api_recipes.get_or_insert(model, None, elts_get)
assert rv == [mock.sentinel.rv]
assert mock_model_insert_many.call_args_list == []
assert insert_many_execute.call_args_list == []
assert mock_elt_insert.__getitem__.call_args_list == []
assert mock_model_select.call_args_list == [mock.call()]
assert model_select_where.call_args_list == [mock.call(where_exp_get)]
reset_mocks(mocks)
rv = api_recipes.get_or_insert(model, None, None)
assert rv == []
assert mock_model_insert_many.call_args_list == []
assert insert_many_execute.call_args_list == []
assert mock_elt_insert.__getitem__.call_args_list == []
assert mock_model_select.call_args_list == []
assert model_select_where.call_args_list == []
def reset_all_mocks():
for mock in [ArgumentParser_mock, Template_mock, apply_dns_version_hack_mock,
find_templates_mock, TinyDB_mock, makedirs_mock, yaml_load_mock,
parse_csv_mock, exit_mock, logging_mock, open_mock]:
mock.reset_mock()
def _reset(*mocks):
for mock in mocks:
mock.reset_mock()
def test_reset_mock_recursion(self):
mock = Mock()
mock.return_value = mock
# used to cause recursion
mock.reset_mock()
def reset_mocks(*mocks):
for mock in mocks:
mock.reset_mock()
def test_reset_mock_recursion(self):
mock = Mock()
mock.return_value = mock
mock.reset_mock()
def test_reset_mock_recursion(self):
mock = Mock()
mock.return_value = mock
mock.reset_mock()
def test_reset_mock_recursion(self):
mock = Mock()
mock.return_value = mock
# used to cause recursion
mock.reset_mock()
async def test_async_gen_fixture_finalized(mock):
try:
assert mock.called
assert mock.call_args_list[-1] == unittest.mock.call(END)
finally:
mock.reset_mock()