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"} )