def test_invalidate_function_with_args(self):
def my_func(name): # pragma: nocover
return "Hello %s" % name
my_func._region = 'short_term'
my_func._namespace = 'retools:a_key decarg'
mock_redis = Mock(spec=redis.client.Redis)
mock_redis.smembers.return_value = set(['1'])
invalidate_function = self._makeOne()
with patch('retools.global_connection._redis', mock_redis):
CR = self._makeCR()
CR.add_region('short_term', expires=600)
invalidate_function(my_func, 'fred')
calls = mock_redis.method_calls
eq_(calls[0][1][0], 'retools:short_term:retools:a_key decarg:fred')
eq_(calls[0][0], 'hset')
eq_(len(calls), 1)
# And a unicode key
mock_redis.reset_mock()
invalidate_function(my_func,
u"\u03b5\u03bb\u03bb\u03b7\u03bd\u03b9\u03ba\u03ac")
calls = mock_redis.method_calls
eq_(calls[0][1][0],
u'retools:short_term:retools:a_key' \
u' decarg:\u03b5\u03bb\u03bb\u03b7\u03bd\u03b9\u03ba\u03ac')
eq_(calls[0][0], 'hset')
eq_(len(calls), 1)
def test_properties_preserved():
"""Test that the properties of decorated functions are preserved."""
call_me = Mock()
call_me_also = Mock()
ee = BaseEventEmitter()
@ee.on('always')
def always_event_handler():
"""An event handler."""
call_me()
@ee.once('once')
def once_event_handler():
"""Another event handler."""
call_me_also()
assert always_event_handler.__doc__ == 'An event handler.'
assert once_event_handler.__doc__ == 'Another event handler.'
always_event_handler()
call_me.assert_called_once()
once_event_handler()
call_me_also.assert_called_once()
call_me_also.reset_mock()
# Calling the event handler directly doesn't clear the handler
ee.emit('once')
call_me_also.assert_called_once()
def test_save(self, mock_dump, mock_open):
core = Mock()
ts = self.get_obj(core)
queue = Mock()
queue.empty = Mock(side_effect=Empty)
ts.work_queue = queue
mock_open.side_effect = IOError
# test that save does _not_ raise an exception even when
# everything goes pear-shaped
ts._save()
queue.empty.assert_any_call()
mock_open.assert_called_with(ts.pending_file, 'w')
queue.reset_mock()
mock_open.reset_mock()
queue.data = []
for hostname, xml in self.data:
md = Mock()
md.hostname = hostname
queue.data.append((md, lxml.etree.XML(xml)))
queue.empty.side_effect = lambda: len(queue.data) == 0
queue.get_nowait = Mock(side_effect=lambda: queue.data.pop())
mock_open.side_effect = None
ts._save()
queue.empty.assert_any_call()
queue.get_nowait.assert_any_call()
mock_open.assert_called_with(ts.pending_file, 'w')
mock_open.return_value.close.assert_any_call()
# the order of the queue data gets changed, so we have to
# verify this call in an ugly way
self.assertItemsEqual(mock_dump.call_args[0][0], self.data)
self.assertEqual(mock_dump.call_args[0][1], mock_open.return_value)
def test_cached_parent():
class HasParent(XBlock):
pass
runtime = Mock()
block = HasParent(runtime, DictFieldData({}), Mock())
# block has no parent yet, and we don't need to call the runtime to find
# that out.
assert_equals(block.get_parent(), None)
assert not runtime.get_block.called
# Set a parent id for the block. Get the parent. Now we have one, and we
# used runtime.get_block to get it.
block.parent = "some_parent_id"
parent = block.get_parent()
assert_not_equals(parent, None)
assert runtime.get_block.called_with("some_parent_id")
# Get the parent again. It will be the same parent, and we didn't call the
# runtime.
runtime.reset_mock()
parent2 = block.get_parent()
assert parent2 is parent
assert not runtime.get_block.called
def test_validate_dict_appends_the_key_to_the_current_path(self):
# TODO: Should we be checking this, or just the output?
# TODO: If we do decide to keep this, it should be combined with above
mocked = Mock(return_value={})
with patch.object(Schema, "_validate", mocked):
schema = {"a": int, "b": int, "c": int}
data = {"a": 1, "b": 2, "c": 3}
Schema._validate_dict(schema, data, [])
mocked.assert_has_calls([
call(int, 1, ["a"]),
call(int, 2, ["b"]),
call(int, 3, ["c"])
], any_order=True)
mocked.reset_mock()
Schema._validate_dict(schema, data, ["f"])
mocked.assert_has_calls([
call(int, 1, ["f", "a"]),
call(int, 2, ["f", "b"]),
call(int, 3, ["f", "c"])
], any_order=True)
mocked.reset_mock()
Schema._validate_dict(schema, data, ["f", "g", 1])
mocked.assert_has_calls([
call(int, 1, ["f", "g", 1, "a"]),
call(int, 2, ["f", "g", 1, "b"]),
call(int, 3, ["f", "g", 1, "c"])
], any_order=True)
def test01_send_mailing(self):
# Mock the SMTP connection
mock_smtp = Mock()
def mock_get_connection(*args, **kargs):
return mock_smtp
send.get_connection = mock_get_connection
# Capture sent emails
self.msg_list = None
def send_messages(msg_list):
self.msg_list = msg_list
mock_smtp.send_messages.side_effect = send_messages
send.send_mailing()
mock_smtp.open.assert_called_once()
mock_smtp.close.assert_called_once()
mock_smtp.reset_mock()
self.assertEqual(len(self.msg_list), 1)
msg_formatted = str(self.msg_list[0].message())
self.assertTrue('From: Card Stories <*****@*****.**>' in msg_formatted)
self.assertTrue('Content-Type: multipart/mixed' in msg_formatted)
self.assertTrue('Content-Type: text/plain' in msg_formatted)
self.assertTrue('Content-Type: text/html' in msg_formatted)
self.assertTrue('Content-Type: image/jpeg' in msg_formatted)
def testReset(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._name, "child", "name incorrectly reset")
self.assertEqual(mock._parent, parent, "parent incorrectly reset")
self.assertEqual(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.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._children, {'something': something},
"children reset incorrectly")
self.assertEqual(mock.something, something,
"children incorrectly cleared")
self.assertFalse(mock.something.called, "child not reset")
def testCall(self):
mock = Mock()
self.assertTrue(isinstance(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_deserialize_metadata_pickle(self):
orig_md = {'key1': 'value1', 'key2': 'value2'}
pickled_md = pickle.dumps(orig_md, PICKLE_PROTOCOL)
_m_pickle_loads = Mock(return_value={})
utils.read_pickled_metadata = True
with patch('swiftonfile.swift.common.utils.pickle.loads',
_m_pickle_loads):
# pickled
md = utils.deserialize_metadata(pickled_md)
self.assertTrue(_m_pickle_loads.called)
self.assertTrue(isinstance(md, dict))
_m_pickle_loads.reset_mock()
# not pickled
utils.deserialize_metadata("not_pickle")
self.assertFalse(_m_pickle_loads.called)
_m_pickle_loads.reset_mock()
# pickled but conf does not allow loading
utils.read_pickled_metadata = False
md = utils.deserialize_metadata(pickled_md)
self.assertFalse(_m_pickle_loads.called)
# malformed pickle
_m_pickle_loads.side_effect = pickle.UnpicklingError
md = utils.deserialize_metadata("malformed_pickle")
self.assertTrue(isinstance(md, dict))
def test_diff(self, mock_time):
content1 = "line1\nline2"
content2 = "line3"
self.now = 1345640723
def time_rv():
self.now += 1
return self.now
mock_time.side_effect = time_rv
rv = ["line1", "line2", "line3"]
func = Mock()
func.return_value = rv
self.assertItemsEqual(self.ptool._diff(content1, content2, func), rv)
func.assert_called_with(["line1", "line2"], ["line3"])
func.reset_mock()
mock_time.reset_mock()
def time_rv():
self.now += 5
return self.now
mock_time.side_effect = time_rv
def slow_diff(content1, content2):
for i in range(1, 10):
yield "line%s" % i
func.side_effect = slow_diff
self.assertFalse(self.ptool._diff(content1, content2, func), rv)
func.assert_called_with(["line1", "line2"], ["line3"])
def test_context_manager(self):
m = Mock()
class CM1(object):
def __enter__(self):
m.cm1.enter()
return self
def __exit__(self, type, obj, tb):
m.cm1.exit(type, obj)
return True
class CM2Context(object): pass
class CM2(object):
def __enter__(self):
m.cm2.enter()
return CM2Context()
def __exit__(self, type, obj, tb):
m.cm2.exit(type, obj)
@requires(CM1)
def func1(obj):
m.func1(type(obj))
@requires(CM1, CM2, CM2Context)
def func2(obj1, obj2, obj3):
m.func2(type(obj1),
type(obj2),
type(obj3))
runner = Runner(
CM1,
CM2,
func1,
func2,
)
runner()
compare([
call.cm1.enter(),
call.cm2.enter(),
call.func1(CM1),
call.func2(CM1, CM2, CM2Context),
call.cm2.exit(None, None),
call.cm1.exit(None, None)
], m.mock_calls)
# now check with an exception
m.reset_mock()
m.func2.side_effect = e = Exception()
runner()
compare([
call.cm1.enter(),
call.cm2.enter(),
call.func1(CM1),
call.func2(CM1, CM2, CM2Context),
call.cm2.exit(Exception, e),
call.cm1.exit(Exception, e)
], m.mock_calls)
def test_keyspace_written_with_length(self):
io = Mock(name='io')
base_expected = [
(b'\x00\x00\x00\x01',),
(b'a',),
(b'\x00\x03',),
(b'\x00\x00\x00\x80',), # options w/ keyspace flag
]
QueryMessage('a', consistency_level=3, keyspace='ks').send_body(
io, protocol_version=5
)
self._check_calls(io, base_expected + [
(b'\x00\x02',), # length of keyspace string
(b'ks',),
])
io.reset_mock()
QueryMessage('a', consistency_level=3, keyspace='keyspace').send_body(
io, protocol_version=5
)
self._check_calls(io, base_expected + [
(b'\x00\x08',), # length of keyspace string
(b'keyspace',),
])
def test_new_mode_callback(self):
"""Create a Controller object, call on_new_mode_online method and
check that the callback fires when set_composite_mode is called
"""
self.setup_server()
self.setup_controller()
self.log.info("setting callback")
test_cb = Mock(side_effect=self.quit_mainloop)
self.controller.on_new_mode_online(test_cb)
self.log.info("starting test-sources")
self.setup_video_sources(count=2)
self.log.info("waiting for initial callback with default-mode"
"COMPOSITE_DUAL_EQUAL")
self.run_mainloop(timeout=5)
test_cb.assert_called_once_with(Controller.COMPOSITE_DUAL_EQUAL)
test_cb.reset_mock()
self.log.info("setting new composite mode COMPOSITE_NONE")
assert self.controller.set_composite_mode(Controller.COMPOSITE_NONE)
self.run_mainloop(timeout=5)
self.log.info("waiting for callback with new mode COMPOSITE_NONE")
test_cb.assert_called_once_with(Controller.COMPOSITE_NONE)
def test_poll_store(tmpdir):
fakemodel = tmpdir.join("fakemodel.json")
app = CriticApp(ios=['app1', 'app2'], language=['ru'], persist=True, slack_webhook='http://www')
app.model_file = fakemodel.strpath
fake_fetcher = Mock(return_value=[Review(
id=u'xfkew4ytwqqddid:2e22wdad',
platform='ios',
title=u'Great app! ♡',
rating=2,
summary=u'Here be\nDragons!',
url=u'http://www',
author=u'Here comes more BS',
date='bull',
language='en',
version=None
)])
app.fetchers['ios'] = fake_fetcher
fake_notifier = Mock()
app.notifiers['slack'] = fake_notifier
app.poll_store(platform='ios')
assert fake_fetcher.call_count == 2
assert fake_notifier.call_count == 1
assert len(app.reviews['ios']) == 1
fake_fetcher.reset_mock()
fake_notifier.reset_mock()
app.poll_store(platform='ios')
assert fake_fetcher.call_count == 2
assert fake_notifier.call_count == 0
assert len(app.reviews['ios']) == 1
def test_utime(self):
# Test times arg being invalid.
for junk in ('a', 1234.1234, (1, 2, 3), (1)):
self.assertRaises(TypeError, self.vol.utime, '/path', junk)
# Test times = None
mock_glfs_utimens = Mock(return_value=1)
mock_time = Mock(return_value=12345.6789)
with patch("gluster.gfapi.api.glfs_utimens", mock_glfs_utimens):
with patch("time.time", mock_time):
self.vol.utime('/path', None)
self.assertTrue(mock_glfs_utimens.called)
self.assertTrue(mock_time.called)
# Test times passed as arg
mock_glfs_utimens.reset_mock()
atime = time.time()
mtime = time.time()
with patch("gluster.gfapi.api.glfs_utimens", mock_glfs_utimens):
self.vol.utime('/path', (atime, mtime))
self.assertTrue(mock_glfs_utimens.called)
self.assertEqual(mock_glfs_utimens.call_args[0][1], b'/path')
# verify atime and mtime
self.assertEqual(mock_glfs_utimens.call_args[0][2][0].tv_sec,
int(atime))
self.assertEqual(mock_glfs_utimens.call_args[0][2][0].tv_nsec,
int(math.modf(atime)[0] * 1e9))
self.assertEqual(mock_glfs_utimens.call_args[0][2][1].tv_sec,
int(mtime))
self.assertEqual(mock_glfs_utimens.call_args[0][2][1].tv_nsec,
int(math.modf(mtime)[0] * 1e9))
class BobbleHeadPresenterTest(unittest.TestCase):
def setUp(self):
BobbleHeadPresenter.timer_util = TestyTimerUtil
Song.music_player = QuietMusicPlayer
self.view = Mock()
self.view.song_actions = []
self.view.speed_actions = []
self.presenter = BobbleHeadPresenter(self.view)
def tearDown(self):
QuietMusicPlayer.CURRENTLY_PLAYING = None
def test_initialize_everything(self):
self.presenter.initialize()
self.assertEquals(3, len(self.view.method_calls))
self.view.render.assert_called_once_with()
self.view.set_head_location.assert_called_once_with(Point(210, 0), 0)
self.view.show.assert_called_once_with()
self.assertEquals(20, self.presenter.timer.speed)
self.assertEquals(FileLocation.MIDI, QuietMusicPlayer.CURRENTLY_PLAYING)
def test_bobbling_a_few_times(self):
self.presenter.initialize()
self.view.reset_mock()
self.presenter.bobble_the_head()
self.view.set_head_location.assert_called_with(Point(210, 1), 1)
self.presenter.bobble_the_head()
self.view.set_head_location.assert_called_with(Point(210, 2), 2)
def test_pool_restart_relaod_modules(self):
consumer = Consumer()
consumer.controller = _WC(app=current_app)
consumer.controller.pool.restart = Mock()
panel = self.create_panel(consumer=consumer)
panel.app = self.app
_import = panel.app.loader.import_from_cwd = Mock()
_reload = Mock()
with patch.dict(sys.modules, {'foo': None}):
panel.handle('pool_restart', {'modules': ['foo'],
'reload': False,
'reloader': _reload})
self.assertTrue(consumer.controller.pool.restart.called)
self.assertFalse(_reload.called)
self.assertFalse(_import.called)
_import.reset_mock()
_reload.reset_mock()
consumer.controller.pool.restart.reset_mock()
panel.handle('pool_restart', {'modules': ['foo'],
'reload': True,
'reloader': _reload})
self.assertTrue(consumer.controller.pool.restart.called)
self.assertTrue(_reload.called)
self.assertFalse(_import.called)
def test_canInstall(self, mock_canInstall):
posix = self.get_obj()
entry = lxml.etree.Element("Path", name="test", type="file")
# first, test superclass canInstall failure
mock_canInstall.return_value = False
self.assertFalse(posix.canInstall(entry))
mock_canInstall.assert_called_with(posix, entry)
# next, test fully_specified failure
posix.logger.error.reset_mock()
mock_canInstall.reset_mock()
mock_canInstall.return_value = True
mock_fully_spec = Mock()
mock_fully_spec.return_value = False
posix._handlers[entry.get("type")].fully_specified = \
mock_fully_spec
self.assertFalse(posix.canInstall(entry))
mock_canInstall.assert_called_with(posix, entry)
mock_fully_spec.assert_called_with(entry)
self.assertTrue(posix.logger.error.called)
# finally, test success
posix.logger.error.reset_mock()
mock_canInstall.reset_mock()
mock_fully_spec.reset_mock()
mock_fully_spec.return_value = True
self.assertTrue(posix.canInstall(entry))
mock_canInstall.assert_called_with(posix, entry)
mock_fully_spec.assert_called_with(entry)
self.assertFalse(posix.logger.error.called)
def test_handles(self, mock_get_regex):
match = Mock()
mock_get_regex.return_value = Mock()
mock_get_regex.return_value.match = match
evt = Mock()
evt.filename = "event.txt"
if self.test_obj.__basenames__:
match.return_value = False
self.assertFalse(self.test_obj.handles(evt))
mock_get_regex.assert_called_with([b for b in self.test_obj.__basenames__])
print("match calls: %s" % match.call_args_list)
print("expected: %s" % [call(evt.filename) for b in self.test_obj.__basenames__])
match.assert_called_with(evt.filename)
mock_get_regex.reset_mock()
match.reset_mock()
match.return_value = True
self.assertTrue(self.test_obj.handles(evt))
match.assert_called_with(evt.filename)
else:
match.return_value = False
self.assertFalse(self.test_obj.handles(evt, basename=os.path.basename(self.path)))
mock_get_regex.assert_called_with([os.path.basename(self.path)])
match.assert_called_with(evt.filename)
mock_get_regex.reset_mock()
match.reset_mock()
match.return_value = True
self.assertTrue(self.test_obj.handles(evt, basename=os.path.basename(self.path)))
mock_get_regex.assert_called_with([os.path.basename(self.path)])
match.assert_called_with(evt.filename)
def test_sbotools_available():
if not is_slackware():
print("Skipping not Slackware")
return
from rosdep2.platforms.slackware import sbotools_available
original_exists = os.path.exists
path_overrides = {}
def mock_path(path):
if path in path_overrides:
return path_overrides[path]
else:
return original_exists(path)
m = Mock(side_effect=mock_path)
os.path.exists = m
#Test with sbotools missing
m.reset_mock()
path_overrides = {}
path_overrides['/usr/sbin/sboinstall'] = False
val = sbotools_available()
assert val==False, "Sbotools should not be available"
#Test with sbotools installed
m.reset_mock()
path_overrides = {}
path_overrides['/usr/sbin/sboinstall'] = True
val = sbotools_available()
assert val==True, "Sbotools should be available"
os.path.exists = original_exists
def test_get_versions(self):
"""Tests if getting picked versions works"""
with mockPackage(
setup="""
from setuptools import setup
setup(name="abc", version="1.2.3")
"""
) as m:
spec = Spec.from_line("abc==1.2.3")
spec_version = Spec.from_line("def==2.3.4")
version_hook = Mock(
side_effect=lambda o, s, p: [spec_version])
package = Package(fullname=spec.fullname, dist_dir=m)
override = hashabledict({"spec": "somespec"})
pkgmgr = PackageManager(
version_hook=version_hook, overrides={"abc": override})
pkgmgr.get_package = Mock(return_value=package)
vers = pkgmgr.get_versions(spec.name, spec.pinned)
version_hook.assert_called_with(override, spec, package)
self.assertEqual(vers, [spec_version])
self.assertEqual(pkgmgr._version_cache, {(spec, override): vers})
version_hook.reset_mock()
vers = pkgmgr.get_versions(spec.name, spec.pinned)
self.assertFalse(version_hook.called)
def test_entry_init(self, mock_entry_init):
eset = self.get_obj()
eset.entries = dict()
evt = Mock()
evt.filename = "test.txt"
handler = Mock()
handler.__basenames__ = []
handler.__extensions__ = []
handler.deprecated = False
handler.experimental = False
handler.__specific__ = True
# test handling an event with the parent entry_init
eset.entry_init(evt, handler)
mock_entry_init.assert_called_with(eset, evt, entry_type=handler, specific=handler.get_regex.return_value)
self.assertItemsEqual(eset.entries, dict())
# test handling the event with a Cfg handler
handler.__specific__ = False
eset.entry_init(evt, handler)
handler.assert_called_with(os.path.join(eset.path, evt.filename))
self.assertItemsEqual(eset.entries, {evt.filename: handler.return_value})
handler.return_value.handle_event.assert_called_with(evt)
# test handling an event for an entry that already exists with
# a Cfg handler
handler.reset_mock()
eset.entry_init(evt, handler)
self.assertFalse(handler.called)
self.assertItemsEqual(eset.entries, {evt.filename: handler.return_value})
eset.entries[evt.filename].handle_event.assert_called_with(evt)
def test_when_base_returns_function_value_when_passed_a_function(self):
mocked = Mock(return_value=8)
self.assertEqual(_when_base(None, mocked), 8)
mocked.assert_called_once_with(None)
mocked.reset_mock()
self.assertEqual(_when_base("abc", mocked), 8)
mocked.assert_called_once_with("abc")
def test_machine(monkeypatch):
# Make sure requesting the machine works, is read-only and produces a
# deprecation warning.
from network_tester import experiment
mock_system_info = Mock()
mock_machine = Mock()
mock_build_machine = Mock(return_value=mock_machine)
mock_mc = Mock()
monkeypatch.setattr(experiment, "build_machine", mock_build_machine)
e = Experiment(mock_mc)
e.system_info = mock_system_info
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
# Machine object should be returned built from the system info.
assert not mock_build_machine.called
assert e.machine is mock_machine
mock_build_machine.called_once_with(mock_system_info)
# Should be flagged as deprecated
assert len(w) == 1
assert issubclass(w[0].category, DeprecationWarning)
# Machine should be regenerated every time (i.e. is explicitly read-only)
mock_build_machine.reset_mock()
assert e.machine is mock_machine
mock_build_machine.called_once_with(mock_system_info)
def test_passphrase(self, mock_get_passphrases):
pkc = self.get_obj()
cfp = Mock()
cfp.has_section.return_value = False
cfp.has_option.return_value = False
Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP = Mock()
Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP.cfp = cfp
self.assertIsNone(pkc.passphrase)
cfp.has_section.assert_called_with("sshkeys")
cfp.reset_mock()
cfp.has_section.return_value = True
self.assertIsNone(pkc.passphrase)
cfp.has_section.assert_called_with("sshkeys")
cfp.has_option.assert_called_with("sshkeys", "passphrase")
cfp.reset_mock()
cfp.get.return_value = "test"
mock_get_passphrases.return_value = dict(test="foo", test2="bar")
cfp.has_option.return_value = True
self.assertEqual(pkc.passphrase, "foo")
cfp.has_section.assert_called_with("sshkeys")
cfp.has_option.assert_called_with("sshkeys", "passphrase")
cfp.get.assert_called_with("sshkeys", "passphrase")
mock_get_passphrases.assert_called_with(Bcfg2.Server.Plugins.Cfg.CfgPrivateKeyCreator.SETUP)
def test_validate_list_calls_validate_for_each_schema_data_combo(self):
def mock_return(schema, data, path):
if not isinstance(data, schema):
raise Invalid("")
return data
mocked = Mock(side_effect=mock_return)
with patch.object(Schema, "_validate", mocked):
Schema._validate_list([int, unicode], ["a", "b"], [])
mocked.assert_has_calls([
call(int, "a", [0]),
call(unicode, "a", [0]),
call(int, "b", [1]),
call(unicode, "b", [1])
])
mocked.reset_mock()
with self.assertRaises(InvalidGroup):
Schema._validate_list([int, unicode], ["a", 1, None], [])
mocked.assert_has_calls([
call(int, "a", [0]),
call(unicode, "a", [0]),
call(int, 1, [1]),
call(int, None, [2]),
call(unicode, None, [2])
])
mocked.reset_mock()
Schema._validate_list([int, unicode], [1, 2], [])
mocked.assert_has_calls([
call(int, 1, [0]),
call(int, 2, [1]),
])
def test_pool_restart_relaod_modules(self):
consumer = Consumer()
consumer.pool.restart = Mock()
panel = self.create_panel(consumer=consumer)
panel.app = self.app
_import = panel.app.loader.import_from_cwd = Mock()
_reload = Mock()
with patch.dict(sys.modules, {"foo": None}):
panel.handle("pool_restart", {"imports": ["foo"],
"reload_imports": False,
"reload": _reload})
self.assertTrue(consumer.pool.restart.called)
self.assertFalse(_reload.called)
self.assertFalse(_import.called)
_import.reset_mock()
_reload.reset_mock()
consumer.pool.restart.reset_mock()
panel.handle("pool_restart", {"imports": ["foo"],
"reload_imports": True,
"reload": _reload})
self.assertTrue(consumer.pool.restart.called)
self.assertTrue(_reload.called)
self.assertFalse(_import.called)
def it_supplies_the_foreign_model_instance_when_saving_a_foreign_key(self):
# prepare the app structure
Doc1Model = Mock(name="doc1_model")
class Doc1(Document):
id = fields.NumberField()
class Meta:
backend_type = 'django'
model = Doc1Model
Doc2Model = Mock(name="doc2_model")
class Doc2(Document):
id = fields.NumberField()
doc1 = fields.ForeignDocument(Doc1)
class Meta:
backend_type = 'django'
model = Doc2Model
# First return an existing model instance
mock_doc1 = Mock()
mock_doc2 = Mock()
Doc1Model.objects.get.return_value = mock_doc1
Doc2Model.objects.get_or_create.return_value = (mock_doc2, True)
request = {
"id": 1,
"doc1": {
"id": 1
}
}
doc = Doc2(request)
doc.save()
ok_(isinstance(doc.doc1, Document))
eq_(True, Doc1Model.objects.get.called)
# Now save a non existing model
mock_doc1.reset_mock()
mock_doc2.reset_mock()
Doc1Model.DoesNotExist = Exception
Doc1Model.objects.get.side_effect = Doc1Model.DoesNotExist
Doc1Model.objects.get_or_create.return_value = (mock_doc1, True)
Doc2Model.objects.get_or_create.return_value = (mock_doc2, True)
request = {
"id": 1,
"doc1": {
"id": 1
}
}
doc = Doc2(request)
doc.save()
ok_(isinstance(doc.doc1, Document))
eq_(True, Doc1Model.objects.get.called)
def test_trigger_on_huddle_message_from_user(self, mock_queue_json_publish: mock.Mock) -> None:
for bot_type, expected_queue_name in BOT_TYPE_TO_QUEUE_NAME.items():
self.bot_profile.bot_type = bot_type
self.bot_profile.save()
self.second_bot_profile.bot_type = bot_type
self.second_bot_profile.save()
sender_email = self.user_profile.email
recipient_emails = [self.bot_profile.email, self.second_bot_profile.email]
profile_ids = [self.bot_profile.id, self.second_bot_profile.id]
def check_values_passed(queue_name: Any,
trigger_event: Union[Mapping[Any, Any], Any],
x: Callable[[Any], None]=None) -> None:
self.assertEqual(queue_name, expected_queue_name)
self.assertIn(trigger_event["user_profile_id"], profile_ids)
profile_ids.remove(trigger_event["user_profile_id"])
self.assertEqual(trigger_event["trigger"], "private_message")
self.assertEqual(trigger_event["message"]["sender_email"], sender_email)
self.assertEqual(trigger_event["message"]["type"], u'private')
mock_queue_json_publish.side_effect = check_values_passed
self.send_huddle_message(sender_email, recipient_emails, 'test')
self.assertEqual(mock_queue_json_publish.call_count, 2)
mock_queue_json_publish.reset_mock()
def test15_poll_notification(self):
args = { 'type': ['tabs'],
'action': ['poll'],
'player_id': [13],
'game_id': [20],
'modified': [10000000000000000] }
# Fake poll controlled from the test
poll = defer.Deferred()
mock_poll_tabs = Mock()
mock_poll_tabs.return_value = poll
orig_service_poll_tabs = self.service.poll_tabs
self.service.poll_tabs = mock_poll_tabs
mock_listener = Mock()
self.service.listen().addCallback(mock_listener)
self.service.poll(args)
mock_listener.assert_called_once_with({'player_id': 13, 'type': 'poll_start'})
mock_listener.reset_mock()
self.service.listen().addCallback(mock_listener)
poll.callback(args)
mock_listener.assert_called_once_with({'player_id': 13, 'type': 'poll_end'})
self.service.poll_tabs = orig_service_poll_tabs
def test_finalize_notifies_about_valid_message(self, mock_hash):
storage = Mock()
storage.read_status = Mock(return_value=LongMessageStatusInfo(
LongMessageStatus.READY, 'new_md5', 123))
mock_hash.return_value = mock_hash
mock_hash.update = Mock()
mock_hash.hexdigest = Mock()
mock_callback = Mock()
handler = LongMessageHandler(storage)
handler.on_message_updated(mock_callback)
# message invalid
for mt in self.known_message_types:
mock_hash.reset_mock()
mock_hash.hexdigest.return_value = 'invalid_md5'
with self.subTest(mt='invalid ({})'.format(mt)):
handler.select_long_message_type(mt)
handler.init_transfer('new_md5')
handler.upload_message(b'12345')
handler.finalize_message()
self.assertEqual(0, mock_callback.call_count)
# message valid
for mt in self.known_message_types:
mock_callback.reset_mock()
mock_hash.hexdigest.return_value = 'new_md5'
with self.subTest(mt='valid ({})'.format(mt)):
handler.select_long_message_type(mt)
handler.init_transfer('new_md5')
handler.upload_message(b'12345')
handler.finalize_message()
self.assertEqual(1, mock_callback.call_count)
def test_script_deployment_with_arguments(self):
client = Mock()
client.put.return_value = FILE_PATH
client.run.return_value = ('', '', 0)
file_path = '{0}root{0}relative.sh'.format(os.path.sep)
args = ['arg1', 'arg2', '--option1=test']
sd = ScriptDeployment(script='echo "foo"', args=args, name=file_path)
sd.run(self.node, client)
expected = '%s arg1 arg2 --option1=test' % (file_path)
client.run.assert_called_once_with(expected, timeout=None)
client.reset_mock()
args = []
sd = ScriptDeployment(script='echo "foo"', args=args, name=file_path)
sd.run(self.node, client)
expected = file_path
client.run.assert_called_once_with(expected, timeout=None)
def test_script_deployment_with_arguments(self):
client = Mock()
client.put.return_value = '/home/ubuntu/relative.sh'
client.run.return_value = ('', '', 0)
args = ['arg1', 'arg2', '--option1=test']
sd = ScriptDeployment(script='echo "foo"', args=args,
name='/root/relative.sh')
sd.run(self.node, client)
expected = '/root/relative.sh arg1 arg2 --option1=test'
client.run.assert_called_once_with(expected)
client.reset_mock()
args = []
sd = ScriptDeployment(script='echo "foo"', args=args,
name='/root/relative.sh')
sd.run(self.node, client)
expected = '/root/relative.sh'
client.run.assert_called_once_with(expected)
def test_attach_discount_to_realm(
self, mock_create_customer: mock.Mock,
mock_retrieve_customer: mock.Mock) -> None:
user = self.example_user('hamlet')
# Before customer exists
attach_discount_to_realm(user, 85)
mock_create_customer.assert_called_once_with(
description=Kandra(),
email=self.example_email('hamlet'),
metadata=Kandra(),
source=None,
coupon=self.stripe_coupon_id)
mock_create_customer.reset_mock()
# For existing customer
Coupon.objects.create(percent_off=25, stripe_coupon_id='25OFF')
with mock.patch.object(stripe.Customer,
'save',
autospec=True,
side_effect=lambda stripe_customer: self.
assertEqual(stripe_customer.coupon, '25OFF')):
attach_discount_to_realm(user, 25)
mock_create_customer.assert_not_called()
class _BaseTestCase(unittest.TestCase):
def setUp(self):
self.endpoint_notifier = Mock(EndpointNotifier)
self.call_notifier = Mock(CallNotifier)
self.storage = CallStorage(self.endpoint_notifier, self.call_notifier)
def _create_call(self,
uniqueid=None,
destuniqueid=None,
source_exten=Mock(Extension),
destination_exten=Mock(Extension),
source_channel=sentinel.source_channel,
destination_channel=sentinel.destination_channel):
source = _Channel(source_exten, source_channel)
destination = _Channel(destination_exten, destination_channel)
self.storage.new_call(uniqueid, destuniqueid, source, destination)
self.call_notifier.reset_mock()
self.endpoint_notifier.reset_mock()
return Call(source, destination)
class BackgroundUpdateTestCase(unittest.TestCase):
@defer.inlineCallbacks
def setUp(self):
hs = yield setup_test_homeserver()
self.store = hs.get_datastore()
self.clock = hs.get_clock()
self.update_handler = Mock()
yield self.store.register_background_update_handler(
"test_update", self.update_handler)
@defer.inlineCallbacks
def test_do_background_update(self):
desired_count = 1000
duration_ms = 42
@defer.inlineCallbacks
def update(progress, count):
self.clock.advance_time_msec(count * duration_ms)
progress = {"my_key": progress["my_key"] + 1}
yield self.store.runInteraction(
"update_progress",
self.store._background_update_progress_txn,
"test_update",
progress,
)
defer.returnValue(count)
self.update_handler.side_effect = update
yield self.store.start_background_update("test_update", {"my_key": 1})
self.update_handler.reset_mock()
result = yield self.store.do_background_update(duration_ms *
desired_count)
self.assertIsNotNone(result)
self.update_handler.assert_called_once_with(
{"my_key": 1}, self.store.DEFAULT_BACKGROUND_BATCH_SIZE)
@defer.inlineCallbacks
def update(progress, count):
yield self.store._end_background_update("test_update")
defer.returnValue(count)
self.update_handler.side_effect = update
self.update_handler.reset_mock()
result = yield self.store.do_background_update(duration_ms *
desired_count)
self.assertIsNotNone(result)
self.update_handler.assert_called_once_with({"my_key": 2},
desired_count)
self.update_handler.reset_mock()
result = yield self.store.do_background_update(duration_ms *
desired_count)
self.assertIsNone(result)
self.assertFalse(self.update_handler.called)
def multiple_interfaces_test(self):
"""Test template with multiple inheritance."""
test5implementation = self.Test5Implementation()
test5 = self.Test5(test5implementation)
callback = Mock()
test5.PropertiesChanged.connect(callback)
self.assertEqual(test5.A, 1)
self.assertEqual(test5.B, 2)
test5.SetA(10)
self.assertEqual(test5.A, 10)
callback.assert_called_once_with("I4", {"A": 10}, [])
callback.reset_mock()
test5.B = 20
self.assertEqual(test5.B, 20)
callback.assert_called_once_with("I5", {"B": 20}, [])
callback.reset_mock()
test5.DoChanges(1, 2)
self.assertEqual(test5.A, 1)
self.assertEqual(test5.B, 2)
callback.assert_has_calls(
[call("I4", {"A": 1}, []),
call("I5", {"B": 2}, [])],
any_order=True)
callback.reset_mock()
test5implementation.do_external_changes(100, 200)
self.assertEqual(test5.A, 100)
self.assertEqual(test5.B, 200)
callback.assert_not_called()
test5implementation.module_properties_changed.emit()
callback.assert_has_calls(
[call("I4", {"A": 100}, []),
call("I5", {"B": 200}, [])],
any_order=True)
callback.reset_mock()
test5implementation.do_secret_changes(1000, 2000)
self.assertEqual(test5.A, 1000)
self.assertEqual(test5.B, 2000)
callback.assert_not_called()
test5implementation.module_properties_changed.emit()
callback.assert_not_called()
def test_handles(self, mock_get_regex):
match = Mock()
mock_get_regex.return_value = Mock()
mock_get_regex.return_value.match = match
evt = Mock()
evt.filename = "event.txt"
if self.test_obj.__basenames__:
match.return_value = False
self.assertFalse(self.test_obj.handles(evt))
mock_get_regex.assert_called_with(
[b for b in self.test_obj.__basenames__])
print("match calls: %s" % match.call_args_list)
print("expected: %s" %
[call(evt.filename) for b in self.test_obj.__basenames__])
match.assert_called_with(evt.filename)
mock_get_regex.reset_mock()
match.reset_mock()
match.return_value = True
self.assertTrue(self.test_obj.handles(evt))
match.assert_called_with(evt.filename)
else:
match.return_value = False
self.assertFalse(
self.test_obj.handles(evt,
basename=os.path.basename(self.path)))
mock_get_regex.assert_called_with([os.path.basename(self.path)])
match.assert_called_with(evt.filename)
mock_get_regex.reset_mock()
match.reset_mock()
match.return_value = True
self.assertTrue(
self.test_obj.handles(evt,
basename=os.path.basename(self.path)))
mock_get_regex.assert_called_with([os.path.basename(self.path)])
match.assert_called_with(evt.filename)
def test_script_deployment_with_arguments(self):
file_path = "{0}root{0}relative.sh".format(os.path.sep)
client = Mock()
client.put.return_value = file_path
client.run.return_value = ("", "", 0)
args = ["arg1", "arg2", "--option1=test"]
sd = ScriptDeployment(script='echo "foo"', args=args, name=file_path)
sd.run(self.node, client)
expected = "%s arg1 arg2 --option1=test" % (file_path)
client.run.assert_called_once_with(expected, timeout=None)
client.reset_mock()
args = []
sd = ScriptDeployment(script='echo "foo"', args=args, name=file_path)
sd.run(self.node, client)
expected = file_path
client.run.assert_called_once_with(expected, timeout=None)
def test_download_folder(makedirs):
boto_mock = Mock(name='boto_session')
boto_mock.client('sts').get_caller_identity.return_value = {
'Account': '123'
}
session = sagemaker.Session(boto_session=boto_mock,
sagemaker_client=Mock())
train_data = Mock()
validation_data = Mock()
train_data.bucket_name.return_value = BUCKET_NAME
train_data.key = 'prefix/train/train_data.csv'
validation_data.bucket_name.return_value = BUCKET_NAME
validation_data.key = 'prefix/train/validation_data.csv'
s3_files = [train_data, validation_data]
boto_mock.resource('s3').Bucket(
BUCKET_NAME).objects.filter.return_value = s3_files
obj_mock = Mock()
boto_mock.resource('s3').Object.return_value = obj_mock
# all the S3 mocks are set, the test itself begins now.
sagemaker.utils.download_folder(BUCKET_NAME, '/prefix', '/tmp', session)
obj_mock.download_file.assert_called()
calls = [
call(os.path.join('/tmp', 'train/train_data.csv')),
call(os.path.join('/tmp', 'train/validation_data.csv'))
]
obj_mock.download_file.assert_has_calls(calls)
obj_mock.reset_mock()
# Testing with a trailing slash for the prefix.
sagemaker.utils.download_folder(BUCKET_NAME, '/prefix/', '/tmp', session)
obj_mock.download_file.assert_called()
obj_mock.download_file.assert_has_calls(calls)
def test_runner_replaced_on_exception(monkeypatch):
monkeypatch.setenv('PYTHONPATH', BUILDSYS_PKGS)
runner = Mock(wraps=default_subprocess_runner)
hooks = get_hooks('pkg1', runner=runner)
hooks.get_requires_for_build_wheel()
runner.assert_called_once()
runner.reset_mock()
runner2 = Mock(wraps=default_subprocess_runner)
try:
with hooks.subprocess_runner(runner2):
hooks.get_requires_for_build_wheel()
runner2.assert_called_once()
runner2.reset_mock()
raise RuntimeError()
except RuntimeError:
pass
hooks.get_requires_for_build_wheel()
runner.assert_called_once()
def test_configure_band_x(self):
timestamp1 = '2134231.30131'
timestamp2 = '2242522.58271'
dish_mode_quant = self.model.sim_quantities['dishMode']
dish_mode_enum_labels = dish_mode_quant.meta['enum_labels']
mock_time = Mock(return_value=float(timestamp2))
self.model.time_func = mock_time
mock_set_val = Mock(side_effect=dish_mode_quant.set_val)
dish_mode_quant.set_val = mock_set_val
for allowed_mode in ['OPERATE', 'STANDBY-FP']:
dish_mode_quant.last_val = dish_mode_enum_labels.index(
allowed_mode)
calls = [
call(dish_mode_enum_labels.index('CONFIG'), float(timestamp1)),
call(dish_mode_enum_labels.index(allowed_mode),
float(timestamp2))
]
for cmd_name in [
'ConfigureBand1', 'ConfigureBand2', 'ConfigureBand3',
'ConfigureBand4', 'ConfigureBand5'
]:
self.model.sim_actions[cmd_name](data_input=timestamp1)
num_method_calls = mock_set_val.call_count
self.assertEquals(num_method_calls, 2)
self.assertEquals(calls, mock_set_val.mock_calls)
mock_set_val.reset_mock()
for not_allowed_mode in [
'OFF', 'STARTUP', 'SHUTDOWN', 'STANDBY-LP', 'MAINTENANCE',
'STOW', 'CONFIG'
]:
for cmd_name in [
'ConfigureBand1', 'ConfigureBand2', 'ConfigureBand3',
'ConfigureBand4', 'ConfigureBand5'
]:
dish_mode_quant.last_val = dish_mode_enum_labels.index(
not_allowed_mode)
self.assertRaises(DevFailed, self.model.sim_actions[cmd_name])
class TestResourceLCSPolicy(PyonTestCase):
def setUp(self):
self.clients = DotDict()
self.rr = Mock()
self.RR2 = EnhancedResourceRegistryClient(self.rr)
self.clients.resource_registry = self.rr
self.policy = ResourceLCSPolicy(self.clients)
def test_events(self):
self.rr.read.return_value = Mock()
#if True: self.fail("%s" % LCE.keys())
for event in LCE.values():
self.rr.reset_mock()
success, msg = self.policy.check_lcs_precondition_satisfied(
"rsrc_id", event)
self.assertTrue(success)
self.assertEqual("ResourceLCSPolicy base class not overridden!",
msg)
def test_download_folder(makedirs):
boto_mock = Mock(name="boto_session")
boto_mock.client("sts").get_caller_identity.return_value = {
"Account": "123"
}
session = sagemaker.Session(boto_session=boto_mock,
sagemaker_client=Mock())
train_data = Mock()
validation_data = Mock()
train_data.bucket_name.return_value = BUCKET_NAME
train_data.key = "prefix/train/train_data.csv"
validation_data.bucket_name.return_value = BUCKET_NAME
validation_data.key = "prefix/train/validation_data.csv"
s3_files = [train_data, validation_data]
boto_mock.resource("s3").Bucket(
BUCKET_NAME).objects.filter.return_value = s3_files
obj_mock = Mock()
boto_mock.resource("s3").Object.return_value = obj_mock
# all the S3 mocks are set, the test itself begins now.
sagemaker.utils.download_folder(BUCKET_NAME, "/prefix", "/tmp", session)
obj_mock.download_file.assert_called()
calls = [
call(os.path.join("/tmp", "train/train_data.csv")),
call(os.path.join("/tmp", "train/validation_data.csv")),
]
obj_mock.download_file.assert_has_calls(calls)
obj_mock.reset_mock()
# Testing with a trailing slash for the prefix.
sagemaker.utils.download_folder(BUCKET_NAME, "/prefix/", "/tmp", session)
obj_mock.download_file.assert_called()
obj_mock.download_file.assert_has_calls(calls)
def test_regtext_for_part(monkeypatch):
"""Finds the correct xml"""
logger = Mock()
monkeypatch.setattr(full_issuance, 'logger', logger)
with XMLBuilder() as ctx:
ctx.THING('a')
ctx.REGTEXT('b', TITLE='T1', PART='P1')
with ctx.CONTAINER():
ctx.REGTEXT('c', TITLE='T1', PART='P2')
ctx.THING('d')
ctx.REGTEXT('e', TITLE='T2', PART='P1')
ctx.REGTEXT('T1-P1 again', TITLE='T1', PART='P1')
assert full_issuance.regtext_for_part(ctx.xml, 'T1', 'P2').text == 'c'
assert not logger.warning.called
assert full_issuance.regtext_for_part(ctx.xml, 'T1', 'P1').text == 'b'
assert logger.warning.called
logger.reset_mock()
assert full_issuance.regtext_for_part(ctx.xml, 'T1', 'P3') is None
assert logger.warning.called
def test_check_mod_ipip(self, m_command):
# Mock out sh.Command._create
m_modprobe = Mock(Command)
m_ip6tables = Mock(Command)
def _create(cmd):
if cmd == "modprobe":
return m_modprobe
elif cmd == "ip6tables":
return m_ip6tables
else:
raise ValueError()
m_command._create = _create
def m_module_loaded(module):
return module == "xt_set"
with patch("calico_ctl.checksystem.module_loaded", m_module_loaded):
result = _check_kernel_modules(False)
# Fix = false means system is not OK.
self.assertFalse(result)
self.assertFalse(m_modprobe.called)
m_ip6tables.assert_called_once_with("-L")
# Reset mocks
m_modprobe.reset_mock()
m_ip6tables.reset_mock()
result = _check_kernel_modules(True)
# Fix = true should attempt to fix with modprobe.
self.assertTrue(result)
m_modprobe.assert_called_once_with("ipip")
m_ip6tables.assert_called_once_with("-L")
# Reset mocks
m_modprobe.reset_mock()
m_ip6tables.reset_mock()
# Fix = true, but modprobe fails.
m_modprobe.side_effect = ErrorReturnCode("modprobe ipip", "", "")
result = _check_kernel_modules(True)
self.assertFalse(result)
m_modprobe.assert_called_once_with("ipip")
m_ip6tables.assert_called_once_with("-L")
def test_main(monkeypatch):
# Check that questions are asked and a config file generated
mock_cli_wrapper = Mock(return_value={
"dimensions": (2, 2),
"ip_address": "127.0.0.1"
})
monkeypatch.setattr(wizard, "cli_wrapper", mock_cli_wrapper)
# Temporarily any existing project config file out of the way
config = nengo_spinnaker_rc["project"]
if os.path.isfile(config): # pragma: no cover
_, temp = tempfile.mkstemp()
print(config, temp)
shutil.move(config, temp)
else:
temp = None
# Create a project config file in the test runner's directory (which
# shouldn't exist yet).
assert main("-p".split()) == 0
assert mock_cli_wrapper.called
mock_cli_wrapper.reset_mock()
assert os.path.isfile(config)
# Should fail to create a config file when one already exists
assert main("-p".split()) != 0
assert not mock_cli_wrapper.called
# ...unless forced
assert main("-p --force".split()) == 0
assert mock_cli_wrapper.called
mock_cli_wrapper.reset_mock()
# Restore the old config file
if temp is not None: # pragma: no cover
shutil.move(temp, config)
else:
os.remove(config)
def test_write_motor_parameters():
oms_dp_mock = Mock()
zmx_dp_mock = Mock()
zmx_dp_mock.WriteEPROM.return_value = 1
motor_params = {
'oms:oattr1': 2,
'oms:oattr2': 6,
'zmx:zattra': 24,
'zmx:zattrb': 10,
'zmx:Deactivation': 0
}
write_parameters(oms_dp_mock,
zmx_dp_mock,
motor_params,
reduced_params_list=[
'oms:oattr1', 'oms:oattr2', 'zmx:zattra', 'zmx:zattrb'
])
oms_calls = [call('oattr1', 2), call('oattr2', 6)]
zmx_calls = [call('zattra', 24), call('zattrb', 10)]
oms_dp_mock.write_attribute.assert_has_calls(oms_calls)
zmx_dp_mock.write_attribute.assert_has_calls(zmx_calls)
assert zmx_dp_mock.write_attribute.call_count == 2
# Try again with a reduced parameter list
oms_dp_mock.reset_mock()
zmx_dp_mock.reset_mock()
write_parameters(
oms_dp_mock,
zmx_dp_mock,
motor_params,
reduced_params_list=['oms:oattr1', 'oms:oattr2', 'zmx:zattra'])
zmx_calls_2 = [call('zattra', 24)]
oms_dp_mock.write_attribute.assert_has_calls(oms_calls)
zmx_dp_mock.write_attribute.assert_has_calls(zmx_calls_2)
assert zmx_dp_mock.write_attribute.call_count == 1
def test_transfer_error(self):
session = Mock()
conn_mock = MagicMock(spec=Connection)
conn_mock.session.return_value = session
end_point_mock = Mock(session=session)
vospace_url = 'https://somevospace.server/vospace'
session.get.side_effect = [Mock(text='COMPLETED'),
Mock(text='COMPLETED')]
test_transfer = vos.Transfer(end_point_mock)
# job successfully completed
self.assertFalse(test_transfer.get_transfer_error(
vospace_url + '/results/transferDetails', 'vos://vospace'))
session.get.assert_called_with(vospace_url + '/phase',
allow_redirects=True)
# job suspended
session.reset_mock()
session.get.side_effect = [Mock(text='COMPLETED'),
Mock(text='ABORTED')]
with self.assertRaises(OSError):
test_transfer.get_transfer_error(
vospace_url + '/results/transferDetails', 'vos://vospace')
# check arguments for session.get calls
self.assertEqual(
[call(vospace_url + '/phase', allow_redirects=True),
call(vospace_url + '/phase', allow_redirects=True)],
session.get.call_args_list)
# job encountered an internal error
session.reset_mock()
session.get.side_effect = [Mock(text='COMPLETED'),
Mock(text='ERROR'),
Mock(text='InternalFault')]
with self.assertRaises(OSError):
test_transfer.get_transfer_error(
vospace_url + '/results/transferDetails', 'vos://vospace')
self.assertEqual([call(vospace_url + '/phase', allow_redirects=True),
call(vospace_url + '/phase', allow_redirects=True),
call(vospace_url + '/error')],
session.get.call_args_list)
# job encountered an unsupported link error
session.reset_mock()
link_file = 'testlink.fits'
session.get.side_effect = [Mock(text='COMPLETED'),
Mock(text='ERROR'),
Mock(
text="Unsupported link target: " +
link_file)]
self.assertEqual(link_file, test_transfer.get_transfer_error(
vospace_url + '/results/transferDetails', 'vos://vospace'))
self.assertEqual([call(vospace_url + '/phase', allow_redirects=True),
call(vospace_url + '/phase', allow_redirects=True),
call(vospace_url + '/error')],
session.get.call_args_list)
def cached_observer_advanced_test(self, proxy_getter):
"""Advanced test for the cached observer."""
observer = DBusCachedObserver("SERVICE", "OBJECT", ["I"])
callback = Mock()
observer.cached_properties_changed.connect(callback)
proxy = Mock()
proxy.GetAll.return_value = {}
proxy_getter.return_value = proxy
# Set up the observer.
self._setup_observer(observer)
# Enable service.
self._make_service_available(observer)
proxy.PropertiesChanged.connect.assert_called()
callback.assert_not_called()
callback.reset_mock()
# Change values.
observer._properties_changed_callback("I", {"A": 1}, [])
callback.assert_called_once_with(observer, {"A"}, set())
callback.reset_mock()
self.assertEqual(observer.cache.A, 1)
with self.assertRaises(AttributeError):
getattr(observer.cache, "B")
observer._properties_changed_callback("I", {"A": 10, "B": 2}, [])
callback.assert_called_once_with(observer, {"A", "B"}, set())
callback.reset_mock()
self.assertEqual(observer.cache.A, 10)
self.assertEqual(observer.cache.B, 2)
observer._properties_changed_callback("I", {"B": 20}, ["A"])
callback.assert_called_once_with(observer, {"B"}, {"A"})
callback.reset_mock()
self.assertEqual(observer.cache.A, 10)
self.assertEqual(observer.cache.B, 20)
observer._properties_changed_callback("I2", {"A": 200, "B": 300}, [])
callback.assert_not_called()
self.assertEqual(observer.cache.A, 10)
self.assertEqual(observer.cache.B, 20)
# Disable service.
self._make_service_unavailable(observer)
def test_rebase_and_build_rpm(self, cmd_assert_async: Mock, open: Mock):
runtime = MagicMock(dry_run=False,
working_dir=Path("/path/to/working"))
pipeline = RebuildPipeline(runtime,
group="openshift-4.9",
assembly="art0001",
type=RebuildType.RPM,
dg_key="foo")
release = "202107160000.p?"
open.return_value.__enter__.return_value = StringIO(
"build_rpm|nvrs=foo-v1.2.3-202107160000.p0.assembly.art0001.el8,foo-v1.2.3-202107160000.p0.assembly.art0001.el7|"
)
nvrs = get_event_loop().run_until_complete(
pipeline._rebase_and_build_rpm(release))
self.assertEqual(nvrs, [
"foo-v1.2.3-202107160000.p0.assembly.art0001.el8",
"foo-v1.2.3-202107160000.p0.assembly.art0001.el7"
])
excepted_doozer_cmd = [
"doozer", "--group", "openshift-4.9", "--assembly", "art0001",
"-r", "foo", "rpms:rebase-and-build", "--version", "4.9",
"--release", release
]
cmd_assert_async.assert_called_once_with(excepted_doozer_cmd, env=ANY)
open.assert_called_once_with(
runtime.working_dir / "doozer-working/record.log", "r")
runtime.dry_run = True
cmd_assert_async.reset_mock()
nvrs = get_event_loop().run_until_complete(
pipeline._rebase_and_build_rpm(release))
self.assertEqual(nvrs, [])
excepted_doozer_cmd = [
"doozer", "--group", "openshift-4.9", "--assembly", "art0001",
"-r", "foo", "rpms:rebase-and-build", "--version", "4.9",
"--release", release, "--dry-run"
]
cmd_assert_async.assert_called_once_with(excepted_doozer_cmd, env=ANY)
def test_none_but_existing(self):
mock_sess = Mock()
with patch('%s.inspect' % pbm) as mock_inspect:
type(mock_inspect.return_value).session = mock_sess
b1 = Budget(name='my_budg')
b2 = Budget(name='my_budg2')
t = Transaction(budget_amounts={
b1: Decimal('10.00'),
b2: Decimal('90.00')
})
assert len(t.budget_transactions) == 2
for bt in t.budget_transactions:
assert isinstance(bt, BudgetTransaction)
assert bt.transaction == t
assert {bt.budget: bt.amount
for bt in t.budget_transactions} == {
b1: Decimal('10.00'),
b2: Decimal('90.00')
}
mock_sess.reset_mock()
with pytest.raises(AssertionError):
t.set_budget_amounts({})
assert mock_sess.mock_calls == []
def test_map(self):
mock_client = Mock(spec=Client, name="client")
self.console.changeMap = Mock()
# no data
self.p.cmd_map(data=None, client=mock_client, cmd=Mock(spec=Command))
mock_client.message.assert_called_once_with(
'^7You must supply a map to change to.')
assert not self.console.changeMap.called
# correct data
mock_client.reset_mock()
self.console.changeMap = Mock(return_value='foo')
self.p.cmd_map(data='bar', client=mock_client, cmd=Mock(spec=Command))
self.console.changeMap.assert_called_once_with('bar')
assert not mock_client.message.called
# incorrect data
mock_client.reset_mock()
self.console.changeMap = Mock(return_value=['foo1', 'foo2', 'foo3'])
self.p.cmd_map(data='bar', client=mock_client, cmd=Mock(spec=Command))
self.console.changeMap.assert_called_once_with('bar')
assert mock_client.message.called
def test_stopping_a_starting_thread_stops_thread(self):
mock = Mock()
def test_fn(ctx):
evt = Event()
ctx.on_stopped(evt.set)
if not evt.wait(2):
self.fail('Thread stop was not called')
mock()
tw = ThreadWrapper(test_fn)
try:
# this is a probabilistic failure, false positives may happen still if the implementation is incorrect
for i in range(1000):
mock.reset_mock()
tw.start()
if not tw.stop().wait(2):
self.fail('Failed to stop thread')
self.assertEqual(1, mock.call_count)
finally:
tw.exit()
def test_any_mock_calls_comparison_order(self):
mock = Mock()
d = datetime.utcnow()
class Foo(object):
def __eq__(self, other):
return False
def __ne__(self, other):
return True
for d in datetime.utcnow(), Foo():
mock.reset_mock()
mock(d, foo=d, bar=d)
mock.method(d, zinga=d, alpha=d)
mock().method(a1=d, z99=d)
expected = [
call(ANY, foo=ANY, bar=ANY),
call.method(ANY, zinga=ANY, alpha=ANY),
call(), call().method(a1=ANY, z99=ANY)
]
self.assertEqual(expected, mock.mock_calls)
self.assertEqual(mock.mock_calls, expected)
def test_stop(self, mock_is_running):
# Postmaster is not running
mock_callback = Mock()
mock_is_running.return_value = None
self.assertTrue(self.p.stop(on_safepoint=mock_callback))
mock_callback.assert_called()
# Is running, stopped successfully
mock_is_running.return_value = mock_postmaster = MockPostmaster()
mock_callback.reset_mock()
self.assertTrue(self.p.stop(on_safepoint=mock_callback))
mock_callback.assert_called()
mock_postmaster.signal_stop.assert_called()
# Stop signal failed
mock_postmaster.signal_stop.return_value = False
self.assertFalse(self.p.stop())
# Stop signal failed to find process
mock_postmaster.signal_stop.return_value = True
mock_callback.reset_mock()
self.assertTrue(self.p.stop(on_safepoint=mock_callback))
mock_callback.assert_called()
class TestScalingPolicy_load_yaml(unittest.TestCase):
def setUp(self):
aws_data = {'ScalingPolicies': [], 'NextToken': None}
metric_aws_data = {'MetricAlarms': [], 'NextToken': None}
appscaling_client = Mock()
appscaling_client.describe_scaling_policies = Mock(
return_value=aws_data)
appscaling_client.describe_alarms = Mock(return_value=metric_aws_data)
client = Mock(return_value=appscaling_client)
self.init = Mock(return_value=None)
with Replacer() as r:
r.replace('boto3.client', client)
self.policy = ScalingPolicy('my_service', 'my_cluster', YML)
def tearDown(self):
self.init.reset_mock()
def test_exists(self):
self.assertEqual(self.policy.exists(), False)
def test_arn(self):
self.assertEqual(self.policy.arn, None)
def test_cpu(self):
self.assertEqual(self.policy.cpu, ">=60.5")
def test_name(self):
self.assertEqual(self.policy.name, 'my_cluster-my_service-scale-up')
def test_scale_by(self):
self.assertEqual(self.policy.scale_by, 1)
def test_cooldown(self):
self.assertEqual(self.policy.cooldown, 60)
def test_alarm(self):
self.assertTrue(self.policy.alarm is not None)
def test_entry_init(self, mock_entry_init):
eset = self.get_obj()
eset.entries = dict()
evt = Mock()
evt.filename = "test.txt"
handler = Mock()
handler.__basenames__ = []
handler.__extensions__ = []
handler.deprecated = False
handler.experimental = False
handler.__specific__ = True
# test handling an event with the parent entry_init
eset.entry_init(evt, handler)
mock_entry_init.assert_called_with(
eset,
evt,
entry_type=handler,
specific=handler.get_regex.return_value)
self.assertItemsEqual(eset.entries, dict())
# test handling the event with a Cfg handler
handler.__specific__ = False
eset.entry_init(evt, handler)
handler.assert_called_with(os.path.join(eset.path, evt.filename))
self.assertItemsEqual(eset.entries,
{evt.filename: handler.return_value})
handler.return_value.handle_event.assert_called_with(evt)
# test handling an event for an entry that already exists with
# a Cfg handler
handler.reset_mock()
eset.entry_init(evt, handler)
self.assertFalse(handler.called)
self.assertItemsEqual(eset.entries,
{evt.filename: handler.return_value})
eset.entries[evt.filename].handle_event.assert_called_with(evt)
def test_pool_restart_reload_modules(self):
consumer = Consumer(self.app)
consumer.controller = _WC(app=self.app)
consumer.controller.pool.restart = Mock()
panel = self.create_panel(consumer=consumer)
panel.app = self.app
_import = panel.app.loader.import_from_cwd = Mock()
_reload = Mock()
self.app.conf.CELERYD_POOL_RESTARTS = True
try:
with patch.dict(sys.modules, {'foo': None}):
panel.handle('pool_restart', {
'modules': ['foo'],
'reload': False,
'reloader': _reload
})
self.assertTrue(consumer.controller.pool.restart.called)
self.assertFalse(_reload.called)
self.assertFalse(_import.called)
_import.reset_mock()
_reload.reset_mock()
consumer.controller.pool.restart.reset_mock()
panel.handle('pool_restart', {
'modules': ['foo'],
'reload': True,
'reloader': _reload
})
self.assertTrue(consumer.controller.pool.restart.called)
self.assertTrue(_reload.called)
self.assertFalse(_import.called)
finally:
self.app.conf.CELERYD_POOL_RESTARTS = False
def test_post_web(self):
client = Client()
with Replacer() as r:
mock_response = Mock(return_value=HttpResponse(status=200))
r.replace(
'exchange_platform.spare_part.views.FormView.render_to_response',
mock_response)
r.replace('django.shortcuts.redirect', Mock())
client.post('/spare-part/',
data=dict(name='Pedal',
model='FooFoo',
contacts='*****@*****.**',
price=100))
spare_part = SparePart.objects.get(name='Pedal')
self.assertEqual(spare_part.name, 'Pedal')
self.assertEqual(spare_part.model, 'FooFoo')
self.assertEqual(spare_part.contacts, '*****@*****.**')
self.assertEqual(spare_part.price, 100)
client.post('/spare-part/', data=dict())
context = self.get_context(mock_response)
self.assertDictEqual(
context.get('errors', {}), {
u'name': [u"This field is required."],
u'model': [u"This field is required."],
u'contacts': [u"This field is required."]
})
mock_response.reset_mock()
client.post('/spare-part/',
data=dict(name='Pedal',
model='FooFoo',
contacts='*****@*****.**',
price='a'))
context = self.get_context(mock_response)
self.assertDictEqual(context.get('errors', {}),
{u'price': [u'A valid number is required.']})
