def test_iterable_factory_outgoing(self):
values = [Mock(name="value1", bar=1), Mock(name="value2", bar=2), Mock(name="value3", bar=3)]
iterable = MagicMock(name="iterable")
iterable.__iter__.return_value = iter(values)
class MockResource(ModelResource):
model_class = Mock()
fields = [AttributeField(attribute="bar", type=int)]
iterable_factory = Mock(name="iterable_factory", return_value=iterable)
source_object = Mock(name="source_object")
target_dict = {}
field = IterableField(attribute="foo", resource_class=MockResource, iterable_factory=iterable_factory)
field.handle_outgoing(mock_context(), source_object, target_dict)
self.assertEqual(
target_dict["foo"],
[
{"bar": 1, "_id": str(values[0].pk)},
{"bar": 2, "_id": str(values[1].pk)},
{"bar": 3, "_id": str(values[2].pk)},
],
)
iterable_factory.assert_called_with(source_object.foo)
def test_annotate_decorator(self):
from celery.app.task import Task
class adX(Task):
abstract = True
def run(self, y, z, x):
return y, z, x
check = Mock()
def deco(fun):
def _inner(*args, **kwargs):
check(*args, **kwargs)
return fun(*args, **kwargs)
return _inner
app = Celery(set_as_current=False)
app.conf.CELERY_ANNOTATIONS = {
adX.name: {"@__call__": deco}
}
adX.bind(app)
self.assertIs(adX.app, app)
i = adX()
i(2, 4, x=3)
check.assert_called_with(i, 2, 4, x=3)
i.annotate()
i.annotate()
def test_load(self):
with patch('pkg_resources.iter_entry_points') as iterep:
with patch('celery.bin.base.symbol_by_name') as symbyname:
ep = Mock()
ep.name = 'ep'
ep.module_name = 'foo'
ep.attrs = ['bar', 'baz']
iterep.return_value = [ep]
cls = symbyname.return_value = Mock()
register = Mock()
e = Extensions('unit', register)
e.load()
symbyname.assert_called_with('foo:bar')
register.assert_called_with(cls, name='ep')
with patch('celery.bin.base.symbol_by_name') as symbyname:
symbyname.side_effect = SyntaxError()
with patch('warnings.warn') as warn:
e.load()
self.assertTrue(warn.called)
with patch('celery.bin.base.symbol_by_name') as symbyname:
symbyname.side_effect = KeyError('foo')
with self.assertRaises(KeyError):
e.load()
def test_create_param_callable_returns_return_value(self, layer):
array = numpy.array([[1, 2, 3], [4, 5, 6]])
factory = Mock()
factory.return_value = array
result = layer.create_param(factory, (2, 3))
assert (result.get_value() == array).all()
factory.assert_called_with((2, 3))
def test_getpids(self, gethostname, Pidfile):
gethostname.return_value = 'e.com'
self.prepare_pidfile_for_getpids(Pidfile)
callback = Mock()
p = NamespacedOptionParser(['foo', 'bar', 'baz'])
nodes = self.t.getpids(p, 'celeryd', callback=callback)
self.assertEqual(nodes, [
('foo.e.com',
('celeryd', '[email protected]', '-n foo.e.com', ''),
10),
('bar.e.com',
('celeryd', '[email protected]', '-n bar.e.com', ''),
11),
])
self.assertTrue(callback.called)
callback.assert_called_with(
'baz.e.com',
['celeryd', '[email protected]', '-n baz.e.com', ''],
None,
)
self.assertIn('DOWN', self.fh.getvalue())
# without callback, should work
nodes = self.t.getpids(p, 'celeryd', callback=None)
def test_create_stack_during_launch(self):
task = LaunchStackTask()
mock_heat_client = Mock()
mock_heat_client.stacks.get.side_effect = [
HTTPNotFound,
self.stacks['CREATE_IN_PROGRESS'],
self.stacks['CREATE_IN_PROGRESS'],
self.stacks['CREATE_COMPLETE']
]
mock_heat_client.stacks.create.return_value = {
'stack': {'id': self.stack_name}
}
mock_verify_stack = Mock(return_value=('VERIFY_COMPLETE', None, self.stack_ip))
with patch.multiple(task,
get_heat_client=Mock(return_value=mock_heat_client),
verify_stack=mock_verify_stack
):
res = task.run(
self.configuration,
self.stack_name,
self.stack_template,
self.stack_user,
False
)
assert res['status'] == 'CREATE_COMPLETE'
mock_heat_client.stacks.create.assert_called_with(
stack_name=self.stack_name,
template=self.stack_template
)
mock_verify_stack.assert_called_with(
self.configuration,
self.stacks['CREATE_COMPLETE'],
self.stack_name,
self.stack_user
)
def test_initialization_with_tuples(self, NeuralNet):
input = Mock(__name__='InputLayer', __bases__=(InputLayer,))
hidden1, hidden2, output = [
Mock(__name__='MockLayer', __bases__=(Layer,)) for i in range(3)]
nn = NeuralNet(
layers=[
(input, {'shape': (10, 10), 'name': 'input'}),
(hidden1, {'some': 'param', 'another': 'param'}),
(hidden2, {}),
(output, {'name': 'output'}),
],
input_shape=(10, 10),
mock1_some='iwin',
)
out = nn.initialize_layers(nn.layers)
input.assert_called_with(
name='input', shape=(10, 10))
assert nn.layers_['input'] is input.return_value
hidden1.assert_called_with(
incoming=input.return_value, name='mock1',
some='iwin', another='param')
assert nn.layers_['mock1'] is hidden1.return_value
hidden2.assert_called_with(
incoming=hidden1.return_value, name='mock2')
assert nn.layers_['mock2'] is hidden2.return_value
output.assert_called_with(
incoming=hidden2.return_value, name='output')
assert out[0] is nn.layers_['output']
def test_proc_state_change_callback(self):
self._start_container()
m = Mock()
pm = self.container.proc_manager
pm.add_proc_state_changed_callback(m)
pid = self._spawnproc(pm, 'service')
m.assert_called_with(ANY, ProcessStateEnum.RUNNING, self.container)
self.assertIsInstance(m.call_args[0][0], SampleProcess)
self.container.terminate_process(pid)
m.assert_called_with(ANY, ProcessStateEnum.TERMINATED, self.container)
self.assertIsInstance(m.call_args[0][0], SampleProcess)
pm.remove_proc_state_changed_callback(m)
cur_call_count = m.call_count
pid = self._spawnproc(pm, 'service')
self.assertEquals(m.call_count, cur_call_count) # should not have been touched
self.container.terminate_process(pid)
self.assertEquals(m.call_count, cur_call_count) # should not have been touched
class TestRegisterSyncStrategy(unittest.TestCase):
def setUp(self):
self.session = Mock()
self.strategy_cls = Mock()
self.strategy_object = Mock()
self.strategy_cls.return_value = self.strategy_object
def test_register_sync_strategy(self):
"""
Ensure that registering a single strategy class works as expected
when ``sync_type`` is specified.
"""
register_sync_strategy(self.session, self.strategy_cls, 'sync_type')
# Ensure sync strategy class is instantiated
self.strategy_cls.assert_called_with('sync_type')
# Ensure the sync strategy's ``register_strategy`` method is
# called correctly.
self.strategy_object.register_strategy.assert_called_with(self.session)
def test_register_sync_strategy_default_sync_type(self):
"""
Ensure that registering a single strategy class works as expected
when the ``sync_type`` is not specified.
"""
register_sync_strategy(self.session, self.strategy_cls)
# Ensure sync strategy class is instantiated
self.strategy_cls.assert_called_with('file_at_src_and_dest')
# Ensure the sync strategy's ``register_strategy`` method is
# called correctly.
self.strategy_object.register_strategy.assert_called_with(self.session)
def test_execute_fails(self):
engine = Mock()
engine.log = Mock()
engine.log.info = MagicMock()
engine.log.failed = MagicMock()
topics = [Mock()]
get_topics_mock = Mock(return_value=topics)
execute_mock1 = MagicMock(side_effect=Exception)
execute_mock2 = MagicMock(side_effect=Exception)
self.tracker1.execute = execute_mock1
self.tracker1.get_topics = get_topics_mock
self.tracker2.execute = execute_mock2
self.tracker2.get_topics = get_topics_mock
self.trackers_manager.execute(engine, None)
self.assertTrue(engine.log.info.called)
self.assertTrue(engine.log.failed.called)
get_topics_mock.assert_called_with(None)
execute_mock1.assert_called_with(topics, engine)
execute_mock2.assert_called_with(topics, engine)
class TestRepeatTimer(unittest.TestCase):
def setUp(self):
self.mock_func = Mock()
def test_run_timer(self):
self.timer = RepeatTimer('test_timer', 1, self.mock_func)
self.timer.start()
time.sleep(3)
self.assertTrue(self.mock_func.call_count >= 2)
def test_args(self):
self.timer = RepeatTimer('test_timer', 1, self.mock_func, args=[1, 2])
self.timer.start()
time.sleep(2)
self.mock_func.assert_called_with(1, 2)
def test_kwargs(self):
self.timer = RepeatTimer('test_timer', 1, self.mock_func,
kwargs={'arg1': 3, 'arg2': 'foo'})
self.timer.start()
time.sleep(2)
self.mock_func.assert_called_with(arg1=3, arg2='foo')
def tearDown(self):
self.timer.stop_timer()
self.timer.join()
def test_correct_authentication_updates_session(api, monkeypatch,
fake_cn_client):
session_auth_mock = Mock(return_value=None)
monkeypatch.setattr(SessionAuthentication, 'authenticate',
session_auth_mock)
api.get('/auth', headers=_auth_headers())
session_auth_mock.assert_called_with('usrname', 'LSSJK-28SJS')
def test_transmit_delete_item(self):
queue_item = self.get_queue_item()
find_one = Mock(return_value={'item_id': '1', 'state': 'killed'})
get_subscriber_reference = Mock(return_value={
'item_id': '1',
'subscriber_id': 'foo bar',
'reference_id': 'foo',
'extra': {
'data': {
'revision': 'test'
}
}
})
insert_update_reference = Mock()
mocked_service = MagicMock()
mocked_service.return_value = MockedResourceService(
find_one=find_one,
get_subscriber_reference=get_subscriber_reference,
insert_update_reference=insert_update_reference
)
with patch('aap.publish.transmitters.http_push_apple_news.get_resource_service', mocked_service):
with HTTMock(self.delete_item_response):
self.http_push._push_item(queue_item)
find_one.assert_called_once()
find_one.assert_called_with(req=None,
item_id=queue_item.get('item_id'),
_current_version=queue_item.get('item_version'))
get_subscriber_reference.assert_called_once()
get_subscriber_reference.assert_called_with('1', 'foo bar')
def test_enter__exit(self):
hub = Hub()
P = hub.poller = Mock()
hub.init = Mock()
on_close = Mock()
hub.on_close.append(on_close)
with hub:
hub.init.assert_called_with()
read_A = Mock()
read_B = Mock()
hub.update_readers({10: read_A, File(11): read_B})
write_A = Mock()
write_B = Mock()
hub.update_writers({20: write_A, File(21): write_B})
self.assertTrue(hub.readers)
self.assertTrue(hub.writers)
self.assertFalse(hub.readers)
self.assertFalse(hub.writers)
P.unregister.assert_has_calls([call(10), call(11), call(20), call(21)], any_order=True)
on_close.assert_called_with(hub)
def testSideEffect(self):
mock = Mock()
def effect(*args, **kwargs):
raise SystemError('kablooie')
mock.side_effect = effect
self.assertRaises(SystemError, mock, 1, 2, fish=3)
mock.assert_called_with(1, 2, fish=3)
results = [1, 2, 3]
def effect():
return results.pop()
mock.side_effect = effect
self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
"side effect not used correctly")
mock = Mock(side_effect=sentinel.SideEffect)
self.assertEqual(mock.side_effect, sentinel.SideEffect,
"side effect in constructor not used")
def side_effect():
return DEFAULT
mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
self.assertEqual(mock(), sentinel.RETURN)
def test_with_defaults(self, objective, get_output):
loss_function, target = Mock(), Mock()
loss_function.return_value = np.array([1, 2, 3])
result = objective([1, 2, 3], loss_function=loss_function, target=target)
assert result == 2.0
get_output.assert_called_with(3, deterministic=False)
loss_function.assert_called_with(get_output.return_value, target)
class URLTestCase(ConnectionTestMixin, TestCase):
def setUp(self):
super(URLTestCase, self).setUp()
self.plugin = self.connection.settings.enable(Default.name, [])
self.fetch_title = Mock(return_value=succeed('title'))
self.plugin.fetcher.fetch_title = self.fetch_title
self.outgoing = self.connection.settings.enable(
OutgoingPlugin.name, [])
def test_simple(self):
self.receive('PRIVMSG {} :http://www.example.com/'
.format(self.connection.nickname))
self.fetch_title.assert_called_with(
u'http://www.example.com/',
hostname_tag=True, friendly_errors=True)
self.assertEqual(self.outgoing.last_seen.content, 'title')
def test_multiple_iris(self):
self.receive('PRIVMSG {} :http://foo.test/ http://bar.test/'
.format(self.connection.nickname))
self.fetch_title.assert_has_calls([
call(u'http://foo.test/', hostname_tag=True, friendly_errors=True),
call(u'http://bar.test/', hostname_tag=True, friendly_errors=True),
])
self.assertEqual(self.outgoing.last_seen.content, 'title')
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_a_listener_is_passed_right_parameters(self):
""""""
listener = Mock()
event = Event()
event.connect(listener)
event.fire(5, shape="square")
listener.assert_called_with(5, shape="square")
def test_retry(self, sleep_moc):
# BackupManager setup
backup_manager = self.build_backup_manager()
backup_manager.config.basebackup_retry_times = 5
backup_manager.config.basebackup_retry_sleep = 10
f = Mock()
# check for correct return value
r = backup_manager.retry_backup_copy(f, 'test string')
f.assert_called_with('test string')
assert f.return_value == r
# check for correct number of calls
expected = Mock()
f = Mock(side_effect=[DataTransferFailure('testException'), expected])
r = backup_manager.retry_backup_copy(f, 'test string')
assert f.call_count == 2
# check for correct number of tries and invocations of sleep method
sleep_moc.reset_mock()
e = DataTransferFailure('testException')
f = Mock(side_effect=[e, e, e, e, e, e])
with pytest.raises(DataTransferFailure):
backup_manager.retry_backup_copy(f, 'test string')
assert sleep_moc.call_count == 5
assert f.call_count == 6
def test_should_passthrough_args_and_kwargs(self):
function = Mock(__name__="function")
decorated_function = log_exceptions(Mock())(function)
decorated_function("any-positional-argument", any_keyword_argument="foo")
function.assert_called_with("any-positional-argument", any_keyword_argument="foo")
def test_diamond(self, NeuralNet):
input = Mock(__name__='InputLayer', __bases__=(InputLayer,))
hidden1, hidden2, concat, output = [
Mock(__name__='MockLayer', __bases__=(Layer,)) for i in range(4)]
nn = NeuralNet(
layers=[
('input', input),
('hidden1', hidden1),
('hidden2', hidden2),
('concat', concat),
('output', output),
],
input_shape=(10, 10),
hidden2_incoming='input',
concat_incomings=['hidden1', 'hidden2'],
)
nn.initialize_layers(nn.layers)
input.assert_called_with(name='input', shape=(10, 10))
hidden1.assert_called_with(incoming=input.return_value, name='hidden1')
hidden2.assert_called_with(incoming=input.return_value, name='hidden2')
concat.assert_called_with(
incomings=[hidden1.return_value, hidden2.return_value],
name='concat'
)
output.assert_called_with(incoming=concat.return_value, name='output')
def test_recv_edu(self):
recv_observer = Mock()
recv_observer.return_value = defer.succeed(())
self.federation.register_edu_handler("m.test", recv_observer)
yield self.mock_resource.trigger(
"PUT",
"/_matrix/federation/v1/send/1001000/",
"""{
"origin": "remote",
"origin_server_ts": 1001000,
"pdus": [],
"edus": [
{
"origin": "remote",
"destination": "test",
"edu_type": "m.test",
"content": {"testing": "reply here"}
}
]
}"""
)
recv_observer.assert_called_with(
"remote", {"testing": "reply here"}
)
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_rmtree_ignore_unlink_rmdir_exception(self):
dir1_list = ["dir2", "file"]
empty_list = []
mock_listdir = Mock()
mock_listdir.side_effect = [dir1_list, empty_list]
mock_isdir = Mock()
mock_isdir.side_effect = [True, False]
mock_unlink = Mock()
mock_unlink.side_effect = [OSError]
mock_rmdir = Mock()
mock_rmdir.side_effect = [0, OSError]
mock_islink = Mock()
mock_islink.return_value = False
with nested(patch("gluster.gfapi.Volume.listdir", mock_listdir),
patch("gluster.gfapi.Volume.isdir", mock_isdir),
patch("gluster.gfapi.Volume.islink", mock_islink),
patch("gluster.gfapi.Volume.unlink", mock_unlink),
patch("gluster.gfapi.Volume.rmdir", mock_rmdir)):
self.vol.rmtree("dir1", True)
mock_rmdir.assert_any_call("dir1/dir2")
mock_unlink.assert_called_once_with("dir1/file")
mock_rmdir.assert_called_with("dir1")
def test_walktree_cbmock(sftpserver):
'''test the walktree function, with mocked callbacks (standalone functions)
'''
file_cb = Mock(return_value=None)
dir_cb = Mock(return_value=None)
unk_cb = Mock(return_value=None)
with sftpserver.serve_content(VFS):
with pysftp.Connection(**conn(sftpserver)) as sftp:
sftp.walktree('.',
fcallback=file_cb,
dcallback=dir_cb,
ucallback=unk_cb)
# check calls to the file callback
file_cb.assert_called_with('./read.me')
thecall = call('./pub/foo2/bar1/bar1.txt')
assert thecall in file_cb.mock_calls
assert file_cb.call_count > 3
# check calls to the directory callback
assert [call('./pub'),
call('./pub/foo1'),
call('./pub/foo2'),
call('./pub/foo2/bar1')] == dir_cb.mock_calls
# check calls to the unknown callback
assert [] == unk_cb.mock_calls
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_build_create():
population_class = Mock()
create_function = common.build_create(population_class)
assert isfunction(create_function)
p = create_function("cell class", "cell params", n=999)
population_class.assert_called_with(999, "cell class", "cell params")
def test_initialization_legacy(self, NeuralNet):
input = Mock(__name__='InputLayer', __bases__=(InputLayer,))
hidden1, hidden2, output = [
Mock(__name__='MockLayer', __bases__=(Layer,)) for i in range(3)]
nn = NeuralNet(
layers=[
('input', input),
('hidden1', hidden1),
('hidden2', hidden2),
('output', output),
],
input_shape=(10, 10),
hidden1_some='param',
)
out = nn.initialize_layers(nn.layers)
input.assert_called_with(
name='input', shape=(10, 10))
assert nn.layers_['input'] is input.return_value
hidden1.assert_called_with(
incoming=input.return_value, name='hidden1', some='param')
assert nn.layers_['hidden1'] is hidden1.return_value
hidden2.assert_called_with(
incoming=hidden1.return_value, name='hidden2')
assert nn.layers_['hidden2'] is hidden2.return_value
output.assert_called_with(
incoming=hidden2.return_value, name='output')
assert out[0] is nn.layers_['output']
def test_initialization_with_tuples(self, NeuralNet):
input = Mock(__name__="InputLayer", __bases__=(InputLayer,))
hidden1, hidden2, output = [Mock(__name__="MockLayer", __bases__=(Layer,)) for i in range(3)]
nn = NeuralNet(
layers=[
(input, {"shape": (10, 10), "name": "input"}),
(hidden1, {"some": "param", "another": "param"}),
(hidden2, {}),
(output, {"name": "output"}),
],
input_shape=(10, 10),
mock1_some="iwin",
)
out = nn.initialize_layers(nn.layers)
input.assert_called_with(name="input", shape=(10, 10))
assert nn.layers_["input"] is input.return_value
hidden1.assert_called_with(incoming=input.return_value, name="mock1", some="iwin", another="param")
assert nn.layers_["mock1"] is hidden1.return_value
hidden2.assert_called_with(incoming=hidden1.return_value, name="mock2")
assert nn.layers_["mock2"] is hidden2.return_value
output.assert_called_with(incoming=hidden2.return_value, name="output")
assert out is nn.layers_["output"]
def test_stop_timezone(
self,
mock_sessions: Mock,
mock_close: Mock,
mock_phase: Mock,
mock_task_manager: Mock,
mock_region: Mock,
mock_supported: Mock,
) -> None:
session = sessions.ScrapeSession.new(
key=None,
region="us_ut",
scrape_type=constants.ScrapeType.BACKGROUND,
phase=scrape_phase.ScrapePhase.SCRAPE,
)
mock_sessions.return_value = session
mock_close.return_value = [session]
mock_scraper = create_autospec(BaseScraper)
mock_region.return_value = fake_region(scraper=mock_scraper)
mock_supported.side_effect = _MockSupported
request_args = {
"region": "all",
"scrape_type": "all",
"timezone": "America/New_York",
"respect_is_stoppable": "false",
}
headers = {"X-Appengine-Cron": "test-cron"}
response = self.client.get("/stop",
query_string=request_args,
headers=headers)
assert response.status_code == 200
mock_sessions.assert_has_calls([
call(ScrapeKey("us_ut", constants.ScrapeType.BACKGROUND)),
call(ScrapeKey("us_ut", constants.ScrapeType.SNAPSHOT)),
])
mock_phase.assert_has_calls(
[call(session, scrape_phase.ScrapePhase.PERSIST)] * 2)
mock_region.assert_has_calls([call("us_ut")])
mock_scraper.stop_scrape.assert_called_with(
constants.ScrapeType.SNAPSHOT, "false")
mock_supported.assert_called_with(
stripes=[], timezone=pytz.timezone("America/New_York"))
mock_task_manager.return_value.create_scraper_phase_task.assert_called_with(
region_code="us_ut", url="/read_and_persist")
def test_resume_scrape_background_no_recent_sessions(
self, mock_get_region: Mock, mock_sessions: Mock,
mock_task_manager: Mock) -> None:
region = "us_nd"
scrape_type = constants.ScrapeType.BACKGROUND
queue_name = "us_nd_scraper"
initial_task = "zoom_it"
mock_get_region.return_value = mock_region(region, queue_name)
mock_sessions.return_value = []
scraper = FakeScraper(region, initial_task)
scraper.resume_scrape(scrape_type)
mock_get_region.assert_called_with(region)
mock_sessions.assert_called_with(ScrapeKey(region, scrape_type))
mock_task_manager.return_value.create_scrape_task.assert_not_called()
def test_delete_persistent_menu(client, monkeypatch):
mock_delete = Mock()
mock_delete.return_value.status_code = 200
monkeypatch.setattr('requests.Session.delete', mock_delete)
client = MessengerClient(page_access_token=12345678)
client.delete_persistent_menu()
assert mock_delete.call_count == 1
mock_delete.assert_called_with(
'https://graph.facebook.com/v2.11/me/messenger_profile',
params={'access_token': 12345678},
json={
'fields': [
'persistent_menu',
],
}
)
def test_observer_notified(self):
""" Confirm observers are notified as expected """
o_list = ObservableList()
mock_method = Mock()
o_list.add_observer(mock_method)
self.assertSetEqual({mock_method}, o_list.observers)
self.assertEqual(1, len(o_list.observers))
o_list.append('b')
mock_method.assert_called_once_with(o_list)
o_list.insert(0, 'a')
self.assertEqual(2, mock_method.call_count)
mock_method.assert_called_with(o_list)
self.assertListEqual(['a', 'b'], o_list._list)
o_list[1] = 'c'
mock_method.assert_called_with(o_list)
self.assertEqual(3, mock_method.call_count)
self.assertListEqual(['a', 'c'], o_list._list)
def test_rmtree_errorhandler_readonly_directory(tmpdir):
"""
Test rmtree_errorhandler makes the given read-only directory writable.
"""
# Create read only directory
subdir_path = tmpdir / 'subdir'
subdir_path.mkdir()
path = str(subdir_path)
os.chmod(path, stat.S_IREAD)
# Make sure mock_func is called with the given path
mock_func = Mock()
rmtree_errorhandler(mock_func, path, None)
mock_func.assert_called_with(path)
# Make sure the path is now writable
assert os.stat(path).st_mode & stat.S_IWRITE
def test_must_return_many_functions_to_build(self, ContainerManagerMock, pathlib_mock, SamFunctionProviderMock,
get_template_data_mock):
template_dict = get_template_data_mock.return_value = "template dict"
func_provider_mock = Mock()
func_provider_mock.get_all.return_value = ["function to build", "and another function"]
funcprovider = SamFunctionProviderMock.return_value = func_provider_mock
base_dir = pathlib_mock.Path.return_value.resolve.return_value.parent = "basedir"
container_mgr_mock = ContainerManagerMock.return_value = Mock()
context = BuildContext(None,
"template_file",
None, # No base dir is provided
"build_dir",
manifest_path="manifest_path",
clean=True,
use_container=True,
docker_network="network",
parameter_overrides="overrides",
skip_pull_image=True,
mode="buildmode")
setup_build_dir_mock = Mock()
build_dir_result = setup_build_dir_mock.return_value = "my/new/build/dir"
context._setup_build_dir = setup_build_dir_mock
# call the enter method
result = context.__enter__()
self.assertEquals(result, context) # __enter__ must return self
self.assertEquals(context.template_dict, template_dict)
self.assertEquals(context.function_provider, funcprovider)
self.assertEquals(context.base_dir, base_dir)
self.assertEquals(context.container_manager, container_mgr_mock)
self.assertEquals(context.build_dir, build_dir_result)
self.assertEquals(context.use_container, True)
self.assertEquals(context.output_template_path, os.path.join(build_dir_result, "template.yaml"))
self.assertEquals(context.manifest_path_override, os.path.abspath("manifest_path"))
self.assertEqual(context.mode, "buildmode")
self.assertEquals(context.functions_to_build, ["function to build", "and another function"])
get_template_data_mock.assert_called_once_with("template_file")
SamFunctionProviderMock.assert_called_once_with(template_dict, "overrides")
pathlib_mock.Path.assert_called_once_with("template_file")
setup_build_dir_mock.assert_called_with("build_dir", True)
ContainerManagerMock.assert_called_once_with(docker_network_id="network",
skip_pull_image=True)
func_provider_mock.get_all.assert_called_once()
def test_permissions(mock):
mock.return_value = {
'data': [{
'user_location': 1,
'user_relationships': 1
}]
}
with facebook.session('<token>') as session:
user = session.User('johannes.gorset')
permissions = user.permissions
mock.assert_called_with('johannes.gorset/permissions')
assert_in('user_location', permissions)
assert_in('user_relationships', permissions)
def testExistsIsNyUpload(
self, mock_get_all_tx: Mock, mock_open: Mock, mock_get: Mock
) -> None:
historical_path = build_path(HISTORICAL_BUCKET, "new_york", EXISTING_PDF_NAME)
upload_path = build_path(UPLOAD_BUCKET, "new_york", EXISTING_PDF_NAME)
# Make the info call return an older modified time than the server time.
self.fs.test_add_path(historical_path, local_path=None)
mock_get_all_tx.return_value = {EXISTING_TEST_URL}
mock_get.side_effect = _MockGet
headers = {"X-Appengine-Cron": "test-cron"}
response = self.client.get("/scrape_state?state=new_york", headers=headers)
self.assertEqual(response.status_code, 200)
self.assertListEqual(self.fs.all_paths, [historical_path, upload_path])
mock_open.assert_called_with(ANY, "wb")
mock_get.assert_called_with(EXISTING_TEST_URL, verify=True)
def testCaNoExistsUpload200(
self, mock_get_all_ca: Mock, mock_open: Mock, mock_post: Mock
) -> None:
upload_path = build_path(UPLOAD_BUCKET, "california", EXISTING_CA_NAME)
# Make the info call return an older modified time than the server time.
mock_get_all_ca.return_value = [(EXISTING_TEST_URL_CA, CA_POST_DATA)]
mock_post.side_effect = _MockGet
headers = {"X-Appengine-Cron": "test-cron"}
response = self.client.get("/scrape_state?state=california", headers=headers)
self.assertEqual(response.status_code, 200)
self.assertListEqual(self.fs.all_paths, [upload_path])
mock_open.assert_called_with(ANY, "wb")
mock_post.assert_called_with(
EXISTING_TEST_URL_CA, data=CA_POST_DATA, verify=True
)
def test_do_work():
faux_data = MockAnalysis()
faux_upload = Mock()
faux_analyze = Mock(return_value=faux_data)
filepath = "faux/filepath.wav"
audio_filename = "filepath.wav"
analysis_filename = "filepath.analysis.json"
do_work([
filepath, "filepath.wav", "filepath.analysis.json", faux_upload,
faux_analyze
])
faux_analyze.assert_called_with(filepath)
faux_upload.assert_any_call(ANY, analysis_filename)
faux_upload.assert_any_call(filepath, audio_filename)
def test_consume_calls_callback(self, mock_channel):
mock_start_consuming = Mock()
mock_basic_consume = Mock()
method = type('method', (object, ),
{'delivery_tag': 'mock_delivery_tag'})
mock_channel.return_value = MagicMock(
basic_get=lambda self, queue: (method, "", ""),
basic_ack=lambda self, delivery_tag: None,
basic_consume=mock_basic_consume,
start_consuming=mock_start_consuming)
self.mq_manager.consume()
self.assertTrue(mock_start_consuming.called)
mock_basic_consume.assert_called_with(self.mq_manager.callback,
mock_routes['default'])
def test_authorized(self):
def adapter(*args):
self.assertEqual((field, 'ctx', 'source_dict', 'target_object'),
args)
return 'field', 'source', 'target'
function = Mock()
auth = authorization(adapter)
field = Mock(name='field', spec=['permission'])
field.permission.auth_adapter = None
field.permission.is_write_authorized.return_value = True
value = auth(function)
value(field, 'ctx', 'source_dict', 'target_object')
field.permission.is_write_authorized.assert_called_with(
'ctx', 'target_object', 'source', 'target')
function.assert_called_with(field, 'ctx', 'source_dict',
'target_object')
def test_alert_is_turned_off():
mocked_callback = Mock()
today_epoch = int(datetime.datetime.now().timestamp())
avg_stats = PriorityQueue()
avg_stats.put((today_epoch + 0, 1 / 2))
avg_stats.put((today_epoch + 1, 3 / 2))
avg_stats.put((today_epoch + 2, 2))
avg_stats.put((today_epoch + 3, 3 / 2))
alert_worker = MaxAvgTransactionsAlertWorker(2, avg_stats, mocked_callback,
0.1)
while not avg_stats.empty():
alert_worker._iteration()
iso_expected_time = datetime.datetime.fromtimestamp(today_epoch +
3).isoformat('T')
mocked_callback.assert_called_with(
"High traffic alert recovered at {time}".format(
time=iso_expected_time))
class TestParser(unittest.TestCase):
def setUp(self):
self.invalid_option_callback = Mock()
self.on_raw = Mock()
self.on_help = Mock()
self.on_option = Mock()
self.parser = Parser()
self.parser.on_invalid_option(self.invalid_option_callback)
self.parser.add_option('raw', self.on_raw)
self.parser.add_option('opt=', self.on_option)
self.parser.on_help(self.on_help)
def test_argument_option_called_without_argument(self):
self.parser(['trash-list', '--opt'])
assert [] == self.on_option.mock_calls
self.invalid_option_callback.assert_called_with('trash-list', 'opt')
def test_argument_option_called_with_argument(self):
self.parser(['trash-list', '--opt=', 'arg'])
assert [call('')] == self.on_option.mock_calls
def test_argument_option_called_with_argument(self):
self.parser(['trash-list', '--opt=arg'])
assert [call('arg')] == self.on_option.mock_calls
def test_argument_option_called_with_argument(self):
self.parser(['trash-list', '--opt', 'arg'])
assert [call('arg')] == self.on_option.mock_calls
def test_it_calls_help(self):
self.parser(['trash-list', '--help'])
self.on_help.assert_called_with('trash-list')
def test_it_calls_the_actions_passing_the_program_name(self):
self.parser(['trash-list', '--raw'])
self.on_raw.assert_called_with('')
def test_how_getopt_works_with_an_invalid_option(self):
self.parser(['command-name', '-x'])
self.invalid_option_callback.assert_called_with('command-name', 'x')
def test_scaleuplist(self):
_ctx = self._gen_ctx()
client = self._gen_rest_client()
with patch(
"cloudify_scalelist.workflows.get_rest_client",
Mock(return_value=client)
):
# can downscale without errors, stop on failure
fake_run_scale = Mock(return_value=None)
with patch(
"cloudify_scalelist.workflows._run_scale_settings",
fake_run_scale
):
workflows.scaleuplist(
ctx=_ctx,
scale_compute=True,
scale_transaction_field="_transaction",
scale_transaction_value="transaction_value",
ignore_rollback_failure=False,
scalable_entity_properties={
'one': [{'name': 'one'}],
})
fake_run_scale.assert_called_with(
_ctx, {'one_scale': {'instances': 11}},
{'one': [{'name': 'one'}]}, '_transaction',
'transaction_value', False, False)
# can downscale without errors, ignore failure
fake_run_scale = Mock(return_value=None)
with patch(
"cloudify_scalelist.workflows._run_scale_settings",
fake_run_scale
):
workflows.scaleuplist(
ctx=_ctx,
scale_compute=True,
scale_transaction_field="_transaction",
scale_transaction_value="transaction_value",
scalable_entity_properties={
'one': [{'name': 'one'}],
})
fake_run_scale.assert_called_with(
_ctx, {'one_scale': {'instances': 11}},
{'one': [{'name': 'one'}]}, '_transaction',
'transaction_value', False, True)
def test_get_random_line_with_author(db):
result = Mock()
result.sort = result
result.count.return_value = 1
result.limit.return_value = result
result.skip.return_value = result
result.next.return_value = {'message': u'fives☃'} # Ensure unicode test
fake_find = Mock(return_value=result)
db.haiku.find = fake_find
poems.get_random_line(5, by='me')
fake_find.assert_called_with({
'syllables': 5,
'author': {
'$regex': re.compile('me', re.I)
}
})
def test_get_random_line_with_search(db):
result = Mock()
result.sort = result
result.count.return_value = 1
result.limit.return_value = result
result.skip.return_value = result
result.next.return_value = {'message': 'fives1'}
fake_find = Mock(return_value=result)
db.haiku.find = fake_find
poems.get_random_line(5, about='me')
fake_find.assert_called_with({
'syllables': 5,
'message': {
'$regex': re.compile('me', re.I)
}
})
def test_set_greeting_text(client, monkeypatch):
mock_post = Mock()
mock_post.return_value.status_code = 200
mock_post.return_value.json.return_value = {"result": "success"}
monkeypatch.setattr('requests.Session.post', mock_post)
welcome_message = thread_settings.GreetingText(text='Welcome message')
profile = thread_settings.MessengerProfile(greetings=[welcome_message])
resp = client.set_messenger_profile(profile.to_dict())
assert resp == {"result": "success"}
assert mock_post.call_count == 1
mock_post.assert_called_with(
'https://graph.facebook.com/v2.11/me/messenger_profile',
params={'access_token': 12345678},
json={'greeting': [{
'locale': 'default',
'text': 'Welcome message'
}]})
def test_add_whitelisted_domains_not_as_list(client, monkeypatch):
mock_post = Mock()
mock_post.return_value.status_code = 200
mock_post.return_value.json.return_value = {
"result": "success",
}
monkeypatch.setattr('requests.Session.post', mock_post)
res = client.update_whitelisted_domains('https://facebook.com')
assert res == {"result": "success"}
assert mock_post.call_count == 1
mock_post.assert_called_with(
'https://graph.facebook.com/v2.11/me/messenger_profile',
params={
'access_token': 12345678,
},
json={
'whitelisted_domains': ['https://facebook.com'],
})
def test_invite_users(self):
"""invite_users() makes a PUT request to /invite_users<id>"""
uaac = UAAClient('http://example.com', 'foo', False)
m = Mock()
uaac._request = m
email = '*****@*****.**'
redirect_uri = 'http://www.example.com'
uaac.invite_users(email, redirect_uri)
m.assert_called_with(
'/invite_users',
'POST',
body={'emails': [email]},
params={'redirect_uri': redirect_uri}
)
def test_retry_on_503(self):
mock_response = Mock(status_code=503,
headers={'retry-after': '10'},
raise_for_status=Mock(side_effect=HTTPError))
mock_get = Mock(return_value=mock_response)
sleep_mock = Mock()
with patch('time.sleep', sleep_mock):
with patch.object(Session, 'get', mock_get):
sickle = Sickle('url', max_retries=3, default_retry_after=0)
try:
sickle.ListRecords()
except HTTPError:
pass
mock_get.assert_called_with('url',
params={'verb': 'ListRecords'})
self.assertEqual(4, mock_get.call_count)
self.assertEqual(3, sleep_mock.call_count)
sleep_mock.assert_called_with(10)
def test_types_observer(self):
observer = Mock()
info_inst = MockInfo()
kb.add_types_observer(Info, observer)
kb.append('a', 'b', info_inst)
observer.assert_called_once_with('a', 'b', info_inst)
observer.reset_mock()
info_inst = MockInfo()
kb.append('a', 'c', info_inst)
observer.assert_called_with('a', 'c', info_inst)
observer.reset_mock()
# Should NOT call it because it is NOT an Info instance
some_int = 3
kb.raw_write('a', 'd', some_int)
self.assertEqual(observer.call_count, 0)
def test_build_with_fpm_extra_args(monkeypatch, mock_logger):
mock_fpm_command = Mock(return_value='fpm -s python -t deb')
monkeypatch.setattr('vdt.versionplugin.buildout.shared.fpm_command',
mock_fpm_command)
mock_subprocess_check_output = Mock()
monkeypatch.setattr('vdt.versionplugin.buildout.shared.subprocess.check_output',
mock_subprocess_check_output)
build_with_fpm('puka', setup_py='setup.py', extra_args=['-d', 'python-fabric >= 1.0.0',
'-d', 'python-setuptools >= 2.0.0'])
mock_fpm_command.assert_called_with('puka', 'setup.py',
extra_args=['-d', 'python-fabric >= 1.0.0',
'-d', 'python-setuptools >= 2.0.0'],
no_python_dependencies=True,
version=None)
mock_subprocess_check_output.assert_called_with('fpm -s python -t deb')
def test_xsrf_input_tag_from_token(self):
""" Return input tag with escaped `self.xsrf_token` as value
and cache it as self._xsrf_input.
"""
import weblayer.request
__xhtml_escape = weblayer.request
xhtml_escape = Mock()
xhtml_escape.return_value = 'digest & sons'
weblayer.request.xhtml_escape = xhtml_escape
self.handler._xsrf_token = 'digest & sons'
self.assertTrue(
self.handler.xsrf_input ==
u'<input type="hidden" name="_xsrf" value="digest & sons" />')
xhtml_escape.assert_called_with('digest & sons')
weblayer.request.xhtml_escape = __xhtml_escape
def test_custom_logger():
loggerMethod = Mock()
#Register custom callback method for simav logs
logger.init_simavr_logger(loggerMethod)
avr = Avr(mcu='atmega48', f_cpu=8000000)
#Let the simavr run in background until it sadly crashes on ramend
avr.run()
while avr.cycle < 8000 and avr.state == cpu_Running:
time.sleep(0.1)
# Expected:
#('Starting atmega48 - flashend 0fff ramend 02ff e2end 00ff\n', 3)
#('atmega48 init\n', 3)
#('atmega48 reset\n', 3)
#('avr_sadly_crashed\n', 1)
eq_(loggerMethod.call_count, 4, "number of callback invocations")
loggerMethod.assert_called_with('avr_sadly_crashed\n', 1)
avr.terminate()
def test_calvin_cb_class():
func = Mock()
cb = CalvinCB(func)
func2 = Mock()
cb2 = CalvinCB(func2)
cb = CalvinCBClass(callbacks={'f': [cb]})
assert 'f' in cb.callback_valid_names()
cb.callback_register('f2', cb2)
assert 'f2' in cb.callback_valid_names()
cb.callback_unregister(cb2.id)
assert 'f2' not in cb.callback_valid_names()
cb._callback_execute('f', 1, 2, a=3)
func.assert_called_with(1, 2, a=3)
def test_get_station_particles(self):
# mock station
detectors = [sentinel.detector1, sentinel.detector2]
station = Mock()
station.detectors = detectors
# mock get_detector_particles
results = [sentinel.result2, sentinel.result1]
get_detector_particles = Mock(side_effect=lambda *args: results.pop())
self.simulation.get_detector_particles = get_detector_particles
particles = self.simulation.get_station_particles(station)
# assertions
get_detector_particles.assert_called_with(detectors[1])
pop_last_call(get_detector_particles)
get_detector_particles.assert_called_with(detectors[0])
self.assertEqual(particles, [sentinel.result1, sentinel.result2])
def test_wind_velocity(self, timegm, make_interpolator):
ds = Mock()
timegm.return_value = 10.0
get_wind = Mock()
get_wind.return_value = 3.0, -5.0
make_interpolator.return_value = get_wind
w = warnings.WarningCounts()
f = models.make_wind_velocity(ds, w)
dlat, dlng, zero = f(10.0, 52.0, 0.5, 1000.0)
assert_equal(zero, 0.0)
get_wind.assert_called_with(0.0, 52.0, 0.5, 1000.0)
# Computed by hand
assert_almost_equal(dlat, -4.495895997e-5)
assert_almost_equal(dlng, 4.381527359e-5)
assert not w.any
def test_execute_conditionally(self):
_ctx = self._gen_ctx()
_ctx.node_instances = []
rest_client = Mock()
manager_mock = Mock()
manager_mock.get_rest_client = Mock(return_value=rest_client)
engine = Mock()
engine_gen = Mock(return_value=engine)
with patch("resource_management_plugin.tasks.manager", manager_mock):
with patch("resource_management_plugin.tasks.Engine", engine_gen):
tasks.execute_conditionally(ctx=_ctx,
execution_dict={'a': 'b'},
project_id='project_id',
profile_str='abc')
engine_gen.assert_called_with(_ctx, rest_client)
engine.validate_profile.assert_called_with('project_id', 'abc')
rest_client.executions.start.assert_called_with(a='b')
def test_recv_query(self):
recv_handler = Mock()
recv_handler.return_value = defer.succeed({"another": "response"})
self.federation.register_query_handler("a-question", recv_handler)
code, response = yield self.mock_resource.trigger(
"GET",
"/_matrix/federation/v1/query/a-question?three=3&four=4",
None
)
self.assertEquals(200, code)
self.assertEquals({"another": "response"}, response)
recv_handler.assert_called_with(
{"three": "3", "four": "4"}
)
