def test_listener_removal_on_emit(): """Test that a listener removed during an emit is called inside the current emit cycle. """ call_me = Mock() ee = BaseEventEmitter() def should_remove(): ee.remove_listener('remove', call_me) ee.on('remove', should_remove) ee.on('remove', call_me) ee.emit('remove') call_me.assert_called_once() call_me.reset_mock() # Also test with the listeners added in the opposite order ee = BaseEventEmitter() ee.on('remove', call_me) ee.on('remove', should_remove) ee.emit('remove') call_me.assert_called_once()
def test_delete_security_rules(self): # Arrange self.network_security_group = MagicMock() network_client = MagicMock() private_ip_address = Mock() resource_group_name = "group_name" vm_name = "vm_name" security_group = NetworkSecurityGroup() security_group.name = "security_group_name" security_rule = Mock() security_rule.name = "rule_name" security_rule.destination_address_prefix = private_ip_address security_rules = [security_rule] security_group.security_rules = security_rules self.security_group_service.get_network_security_group = MagicMock() self.security_group_service.get_network_security_group.return_value = security_group self.network_service.get_private_ip = Mock( return_value=private_ip_address) contex_enter_mock = Mock() locker = Mock() locker.__enter__ = contex_enter_mock locker.__exit__ = Mock() # Act self.security_group_service.delete_security_rules( network_client, resource_group_name, vm_name, locker, Mock()) # Verify network_client.security_rules.delete.assert_called_once_with( resource_group_name=resource_group_name, network_security_group_name=security_group.name, security_rule_name=security_rule.name) contex_enter_mock.assert_called_once()
def test_update(self, include_prerelease, is_started, start_interval, enabled, interval, start_called, stop_called): checker = NewVersionChecker(False) def start_side_effect(i): checker.interval = i start_mock = Mock(side_effect=start_side_effect) stop_mock = Mock() is_started_mock = Mock(return_value=is_started) checker.interval = start_interval checker.start = start_mock checker.stop = stop_mock checker.is_started = is_started_mock checker.update(include_prerelease, enabled, interval) self.assertEqual(checker.interval, interval) self.assertEqual(checker.include_prereleases, include_prerelease) if start_called: start_mock.assert_called_once_with(interval) else: start_mock.assert_not_called() if stop_called: stop_mock.assert_called_once() else: stop_mock.assert_not_called()
def test_actualizar(self): ''' Prueba el metodo actualizar. ''' # preparo datos self.actualizador.version_actual = 'a' self.actualizador.version_disponible = 'b' mock_descargar = Mock() mock_descargar.return_value = [ { 'nombre': 'foo', 'descripcion': 'bar' }, { 'nombre': 'bar', 'descripcion': 'bar' }, ] self.actualizador.descargar_actualizacion = mock_descargar mock_aplicar = Mock() mock_aplicar.return_value = True self.actualizador.aplicar_actualizacion = mock_aplicar # llamo metodo a probar self.actualizador.actualizar() # verifico que todo este bien mock_descargar.assert_called_once() mock_aplicar.assert_called() assert mock_aplicar.call_count == 2 assert self.actualizador.version_actual == 'b'
def test_handler_passed_to_gio(self, monkeypatch): """Test if handler is correctly passed to Gio""" monkeypatch.setattr( Gio.DBusConnection, 'new_for_address_sync', Mock(return_value=Gio.DBusConnection())) signal_subscribe_mock = Mock() monkeypatch.setattr( Gio.DBusConnection, 'signal_subscribe', signal_subscribe_mock) conn = Connection() conn.connect_dbus() test_cb = lambda: None conn.signal_subscribe(test_cb) # test that Gio's signal_subscribe method is called once # and passed the callback as-is signal_subscribe_mock.assert_called_once() # pylint does not recognize Mock.call_args as sequence and won't # allow us to unpack it. Disabling the warning because we know what # we're doing here # pylint: disable=unpacking-non-sequence args, _ = signal_subscribe_mock.call_args assert args[6] == test_cb
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_using_context_logger_works(): instance = TestContextClass() context_func = Mock(return_value={'some': 'context'}) wrapped = context_logger(context_func, instance.function, instance) wrapped() context_func.assert_called_once()
def test_facet_configuration_with_existing_facet_callable(isolated_app): facet_mock = Mock() facet_mock.return_value = { 'aggs': { 'jessica-jones': { 'terms': { 'field': 'defenders', 'size': 20, }, }, }, } config = { 'RECORDS_REST_FACETS': { 'defenders': facet_mock }, } expected = { 'aggs': { 'jessica-jones': { 'terms': { 'field': 'defenders', 'size': 20 } } } } with isolated_app.test_request_context('?facet_name=defenders'): with patch.dict(isolated_app.config, config): result = get_facet_configuration('records-hep') facet_mock.assert_called_once() assert expected == result
def test_auto_find_correlation(self, mock_start_async: mock.Mock): self.presenter.notify(PresNotification.AUTO_FIND_COR_CORRELATE) mock_start_async.assert_called_once() mock_first_call = mock_start_async.call_args[0] self.assertEqual(self.presenter.view, mock_first_call[0]) self.assertEqual(self.presenter.model.auto_find_correlation, mock_first_call[1]) self.view.set_correlate_buttons_enabled.assert_called_once_with(False)
async def test_initial_plotting_call( mock_endpoint: EndpointConfig, monkeypatch: MonkeyPatch, trackers: List[Text], expected_trackers: List[Text], mock_file_importer: TrainingDataImporter, ): get_training_trackers = Mock(return_value=trackers) monkeypatch.setattr( interactive, "_get_training_trackers", asyncio.coroutine(get_training_trackers) ) monkeypatch.setattr(interactive.utils, "is_limit_reached", lambda _, __: True) plot_trackers = Mock() monkeypatch.setattr(interactive, "_plot_trackers", asyncio.coroutine(plot_trackers)) url = f"{mock_endpoint.url}/domain" with aioresponses() as mocked: mocked.get(url, payload={}) await interactive.record_messages(mock_endpoint, mock_file_importer) get_training_trackers.assert_called_once() plot_trackers.assert_called_once_with( expected_trackers, interactive.DEFAULT_STORY_GRAPH_FILE, mock_endpoint )
def test_ensure_supervisor_started(tmpdir, monkeypatch): m = Mock() monkeypatch.setattr(subprocess, "check_call", m) tmpdir.join("supervisord.pid").write("123123") supconfig = tmpdir.join("etc", "supervisord.conf") ensure_supervisor_started(tmpdir, supconfig) m.assert_called_once()
def test_devpictl(tmpdir, monkeypatch): m = Mock() monkeypatch.setattr(subprocess, "call", m) tmpdir.join("supervisord.pid").write(os.getpid()) tmpdir.ensure("etc", "supervisord.conf") devpictl(str(tmpdir.join("bin", "devpi-ctl"))) m.assert_called_once()
def test_add_cleanup_with_known_layer(self): my_cleanup = Mock(spec=cleanup_func) context = Context(runner=Mock()) with scoped_context_layer(context, layer="scenario"): context.add_cleanup(my_cleanup, layer="scenario") my_cleanup.assert_not_called() # CALLS-HERE: context._pop() my_cleanup.assert_called_once()
def test__del__1(self): self.ftp.connected = Mock(return_value=True) m_disconnect = Mock() self.ftp.disconnect = m_disconnect del (self.ftp) m_disconnect.assert_called_once()
def test_executing_custom_action(self, action_lookup_mock): """Used to test executing custom action when hook setting is set to true.""" action_mock = Mock() action_lookup_mock.return_value = action_mock action_handler(self.trigger_event, self.configuration) action_mock.assert_called_once()
def test__del__1(self): self.ftp.connected = Mock(return_value=True) m_disconnect = Mock() self.ftp.disconnect = m_disconnect del(self.ftp) m_disconnect.assert_called_once()
def test_blank_old_version(): function = Mock() first = VersionUpgrade(old_version="<0.10.1", upgrade=function) with patch("kolibri.core.upgrade.get_upgrades", return_value=[first]): run_upgrades("", "1.1.2") function.assert_called_once()
def test_initialize_telemetry_prints_info(monkeypatch: MonkeyPatch): # Mock actual training mock = Mock() monkeypatch.setattr(telemetry, "print_telemetry_reporting_info", mock) telemetry.initialize_telemetry() mock.assert_called_once()
def test_precheck(self, mock_globals, mock_isfunction): """Test precheck returns correct method""" mock_isfunction.return_value = True mock_precheck_method = Mock(name='mock precheck method') mock_precheck_method.return_value = True mock_globals.return_value = {"precheck_ami_id": mock_precheck_method} self.assertTrue(ef_version.precheck(self)) mock_precheck_method.assert_called_once()
def test_register_active_filter(self, filter_reg_mock: mock.Mock): reg_fun_mock = mock.Mock() filter_reg_mock.return_value = reg_fun_mock self.view.filterSelector.currentIndex.return_value = 0 self.presenter.do_register_active_filter() reg_fun_mock.assert_called_once() filter_reg_mock.assert_called_once()
def testCallCallback(self): f = Mock() self.client.callbacks.test = f self.assertIn("test", self.client._callback_handler._callbacks) self.client.callbacks.test() f.assert_called_once()
def test_not_filter_dev_version(): unfiltered_mock = Mock() not_filtered = VersionUpgrade(old_version="<1.1.1", upgrade=unfiltered_mock) with patch("kolibri.core.upgrade.get_upgrades", return_value=[not_filtered]): run_upgrades("1.1.1.dev0", "1.1.2") unfiltered_mock.assert_called_once()
def test_turn_off(self): flip_switch_mock = Mock() self.patient._flip_switch = flip_switch_mock self.patient.turn_off('MyService', 'ServiceType') flip_switch_mock.assert_called_once() flip_switch_mock.assert_called_with('MyService', 'ServiceType', 'stop')
def test_cleanup_func_is_called_when_context_frame_is_popped(self): my_cleanup = Mock(spec=cleanup_func) context = Context(runner=Mock()) with scoped_context_layer(context): # CALLS-HERE: context._push() context.add_cleanup(my_cleanup) # -- ENSURE: Not called before context._pop() my_cleanup.assert_not_called() # CALLS-HERE: context._pop() my_cleanup.assert_called_once()
class TestDirectoryWatch(fixture.SubManFixture): def setUp(self): super(TestDirectoryWatch, self).setUp() self.mock_cb1 = Mock(return_value=None) self.mock_cb2 = Mock(return_value=None) self.tmp_file1 = tempfile.NamedTemporaryFile( prefix="directory_watcher_test_") self.tmp_file2 = tempfile.NamedTemporaryFile( prefix="directory_watcher_test_") self.testpath1 = self.tmp_file1.name self.testpath2 = self.tmp_file2.name subprocess.call("touch %s" % self.testpath1, shell=True) subprocess.call("touch %s" % self.testpath2, shell=True) self.dw1 = file_monitor.DirectoryWatch(self.testpath1, [], is_glob=True) self.dw2 = file_monitor.DirectoryWatch(self.testpath2, [], is_glob=False) self.dw3 = file_monitor.DirectoryWatch(self.testpath2, [self.mock_cb1, self.mock_cb2], is_glob=False) def tearDown(self): self.tmp_file1.close() self.tmp_file2.close() def test_notify(self): self.dw3.notify() self.mock_cb1.assert_called_once() self.mock_cb2.assert_called_once() @patch("pyinotify.Event") def test_paths_match(self, mock_event): mock_event.path = self.testpath2 mock_event.pathname = self.testpath2 self.assertTrue( self.dw3.paths_match(mock_event.path, mock_event.pathname)) mock_event.pathname = "%s.swp" % self.testpath2 self.assertFalse( self.dw3.paths_match(mock_event.path, mock_event.pathname)) mock_event.pathname = self.testpath2 mock_event.path = self.testpath1 self.assertTrue( self.dw3.paths_match(mock_event.path, mock_event.pathname)) mock_event.pathname = self.testpath1 self.assertFalse( self.dw3.paths_match(mock_event.path, mock_event.pathname)) @patch("pyinotify.Event") def test_file_modified(self, mock_event): mock_event.mask = 1 self.assertFalse(self.dw3.is_file_modified(mock_event.mask)) mock_event.mask = self.dw3.IN_MODIFY self.assertTrue(self.dw3.is_file_modified(mock_event.mask)) mock_event.mask = self.dw3.IN_DELETE self.assertTrue(self.dw3.is_file_modified(mock_event.mask)) mock_event.mask = self.dw3.IN_MOVED_TO self.assertTrue(self.dw3.is_file_modified(mock_event.mask))
def test_flip_switch(self): fetch_mock = Mock() self.patient._fetch = fetch_mock self.patient._flip_switch('MyService', 'ServiceType', 'action') fetch_mock.assert_called_once() fetch_mock.assert_called_with('http://host:6080/arcgis/admin/services/MyService.ServiceType/action')
def test_auth_called(self, mock_service_account: mock.Mock, mock_gspread_oauth: mock.Mock) -> None: """It calls the gspread oauth and service_account methods.""" mock_gspread_oauth.return_value = mock.MagicMock() mock_service_account.return_value = mock.MagicMock() connect("oauth") mock_gspread_oauth.assert_called_once() connect("service_account") mock_service_account.assert_called_once()
def test_should_update_ruleset(self): out = StringIO() err = StringIO() update_mock = Mock() with patch('rules.models.Ruleset.update', update_mock): call_command('refreshprobes', '-u', 'probe1', stdout=out, stderr=err) update_mock.assert_called_once() self.assertIn('Update complete', out.getvalue()) self.assertEqual('', err.getvalue())
def test_areyousure_no(self): yes = Mock() no = Mock() yes_func, no_func = self.sut.areyousure(yes, no) no_func() no.assert_called_once() self.widget.escape.assert_called_once() yes.assert_not_called()
def test_should_build_rules(self): out = StringIO() err = StringIO() build_mock = Mock() with patch('probes.models.Probes.build_rules', build_mock): call_command('refreshprobes', '-b', 'probe1', stdout=out, stderr=err) build_mock.assert_called_once() self.assertIn('Build complete', out.getvalue()) self.assertEqual('', err.getvalue())
def test_has_port_binding_extension_01(self): fake_extensions = [{'name': neutron_api.PORTBINDING_EXT}] client_list_ext_mock = Mock( return_value={'extensions': fake_extensions}) with patch.object(self.neutron_api.client, 'list_extensions', client_list_ext_mock): result = self.neutron_api._has_port_binding_extension() client_list_ext_mock.assert_called_once() self.assertTrue(result)
def test_add_cleanup_with_known_deeper_layer3(self): my_cleanup = Mock(spec=cleanup_func) context = Context(runner=Mock()) with scoped_context_layer(context, layer="testrun"): with scoped_context_layer(context, layer="feature"): with scoped_context_layer(context, layer="scenario"): context.add_cleanup(my_cleanup, layer="feature") my_cleanup.assert_not_called() my_cleanup.assert_called_once() # LEFT: layer="feature" my_cleanup.assert_called_once()
def test_signal_sent(self): handler = Mock() form_submited.connect(handler) self.post(self.ok_data, expect_code=200) handler.assert_called_once() args, kwargs = handler.call_args self.assertIn('message', kwargs) self.assertIsInstance(kwargs['message'], Message) self.assertIn('request', kwargs) self.assertIsInstance(kwargs['request'], HttpRequest)
def test_when_subscribe_raise_exception_then_exception_is_handled(self): callback = Mock() callback.side_effect = Exception() handler = Mock() self.callback_collector._pubsub.set_exception_handler(handler) source_callback = self.callback_collector.new_source() self.callback_collector.subscribe(callback) source_callback() handler.assert_called_once()
def test_ensure_start(self): _execute_mock = Mock() _execute_mock.side_effect = [(True, None)] self.patient._execute = _execute_mock self.patient.ensure('start') _execute_mock.assert_called_once() _execute_mock.assert_called_with(self.patient.switch_url + 'start')
def test_from_image_member_deps(self, assembly_metadata_config: Mock): finder = BuildFinder(MagicMock()) finder._get_builds = MagicMock(return_value=[ { "id": 1, "build_id": 1, "name": "fake1", "nvr": "fake1-1.2.3-1.el8" }, { "id": 2, "build_id": 2, "name": "fake2", "nvr": "fake2-1.2.3-1.el8" }, { "id": 3, "build_id": 3, "name": "fake3", "nvr": "fake3-1.2.3-1.el8" }, ]) assembly_metadata_config.return_value = Model({ "dependencies": { "rpms": [ { "el8": "fake1-1.2.3-1.el8" }, { "el8": "fake2-1.2.3-1.el8" }, { "el8": "fake3-1.2.3-1.el8" }, { "el7": "fake2-1.2.3-1.el7" }, { "el7": "fake2-1.2.3-1.el7" }, ] } }) image_meta = Model({ "distgit_key": "fake-image", }) actual = finder.from_image_member_deps(8, "art1", Model(), image_meta, {}) self.assertEqual( [b["nvr"] for b in actual.values()], ["fake1-1.2.3-1.el8", "fake2-1.2.3-1.el8", "fake3-1.2.3-1.el8"]) finder._get_builds.assert_called_once_with( ["fake1-1.2.3-1.el8", "fake2-1.2.3-1.el8", "fake3-1.2.3-1.el8"]) assembly_metadata_config.assert_called_once()
def test_GIVEN_ioc_driver_with_engineering_correction_WHEN_update_mode_THEN_readback_updated_fired(self): mock_axis = create_mock_axis("mock", 0, 1) driver = IocDriver(Component("comp", PositionAndAngle(0, 0, 0)), ChangeAxis.POSITION, mock_axis, engineering_correction=self.mode_selection_correction) mock_axis.trigger_rbv_change() driver.set_observe_mode_change_on(self.mock_beamline) mock_listener = Mock() driver.add_listener(CorrectionUpdate, mock_listener) self.mock_beamline.trigger_listeners(ActiveModeUpdate(self.mode1)) mock_listener.assert_called_once()
def test_wait_loop_2(self, time_mock, test_fix): """ Message starts with Timeout expired expect func() to be called. func returns with osd.1 is safe to destroy """ test_fix = test_fix() test_func = Mock(return_value="osd.1 is safe to destroy") ret = test_fix._wait_loop(test_func, 'Timeout expired') test_func.assert_called_once() assert ret is True
def test_wait_loop_1(self, time_mock, test_fix): """ Message starts with Timeout expired expect func() to be called. func returns unexpected return output bogus """ test_fix = test_fix() test_func = Mock(return_value="Unexpected return") ret = test_fix._wait_loop(test_func, 'Timeout expired') test_func.assert_called_once() assert ret is None # it breaks (as in continue/break)
def test_get_all_network(self): fake_networks = [{'fake network': 'fake network info'}] client_list_networks_mock = Mock( return_value={'networks': fake_networks}) with patch.object(self.neutron_api.client, 'list_networks', client_list_networks_mock): networks = self.neutron_api.get_all_networks() client_list_networks_mock.assert_called_once() self.assertEqual(networks, fake_networks)
def test_calls_off_when_device_is_found(get_device_mock): power_cmd = PowerCommand('Test Device', 'off') device_mock = Mock(name='Test Device') device_off_method = Mock() get_device_mock.return_value = device_mock device_mock.off = device_off_method power_cmd.execute() device_off_method.assert_called_once()
def test_continuous_integration__custom_config__from_argv(monkeypatch): with in_temp_dir(): write_config("custom/path/to/jasmine.yml") fake_standalone = Mock() cmd = Command(fake_standalone, FakeCI) cmd.run(['ci', '-c', 'custom/path/to/jasmine.yml']) fake_standalone.assert_called_once() standalone_construction_kwargs = fake_standalone.call_args[1] called_with_config = standalone_construction_kwargs['jasmine_config'].yaml_file assert called_with_config.endswith("custom/path/to/jasmine.yml")
def test_should_call_build_image_command_through_CLI( self, read_project_mock: mock.Mock, build_image_mock: mock.Mock, ): # when cli(['build-image']) # then read_project_mock.assert_called_once() build_image_mock.assert_any_call(read_project_mock.return_value)
def test_lazy_prop_called_once(self): """ Ensures that the lazy property is called only once, but returns the same value. """ mock = Mock(return_value=100) prop = UsesLazyProp(mock) val1 = prop.lazy_prop val2 = prop.lazy_prop self.assertEqual(val1, 100) self.assertEqual(val1, val2) mock.assert_called_once()
def test_parse_form(self): on_field = Mock() on_file = Mock() parse_form({"Content-Type": "application/octet-stream"}, BytesIO(b"123456789012345"), on_field, on_file) on_file.assert_called_once() # Assert that the first argument of the call (a File object) has size # 15 - i.e. all data is written. self.assertEqual(on_file.call_args[0][0].size, 15)
def test_fire_with_context(): event_manager = EventManager() def test_listener(bot=None): bot() event_manager.add_listener('test', test_listener, priority=-100) bot = Mock() event_manager.fire_with_context('test', bot) bot.assert_called_once()
def test_dict_hook(): function_mock = Mock(return_value=None) hook = Hook("b", handler=function_mock) assert Schema({hook: str, Optional("b"): object}).validate({"b": "bye"}) == {"b": "bye"} function_mock.assert_called_once() assert Schema({hook: int, Optional("b"): object}).validate({"b": "bye"}) == {"b": "bye"} function_mock.assert_called_once() assert Schema({hook: str, "b": object}).validate({"b": "bye"}) == {"b": "bye"} assert function_mock.call_count == 2
def test_idle(self): imap_client = yield from self.login_user('user', 'pass', select=True, lib=imaplib2.IMAP4) idle_callback = Mock() self.loop.run_in_executor(None, functools.partial(imap_client.idle, callback=idle_callback)) yield from asyncio.wait_for(self.imapserver.get_connection('user').wait(imapserver.IDLE), 1) self.loop.run_in_executor(None, functools.partial(self.imapserver.receive, Mail.create(to=['user'], mail_from='me', subject='hello'))) yield from asyncio.wait_for(self.imapserver.get_connection('user').wait(imapserver.SELECTED), 1) time.sleep(0.1) # eurk hate sleeps but I don't know how to wait for the lib to receive end of IDLE idle_callback.assert_called_once()
def test_run_remember_command_whenSaveDir_shouldWriteLastCommand( self, process_mock: Mock, load_mock: Mock) -> None: with mock.patch('remember.command_store_lib.open', mock.mock_open()) as write_mock: remember_main.run_remember_command("test", 'test_hist', ['grep'], False, False, False, 10) load_mock.assert_called_once() process_mock.assert_called_once() write_mock.assert_called_once_with( os.path.join('test', DEFAULT_LAST_SAVE_FILE_NAME), 'w') handle = write_mock() handle.write.assert_called_with('grep foo\n')
def test_two_factor_check_without_feature_flag(self): mock_fn_to_call = Mock(return_value="Function was called!") mock_fn_to_call.__name__ = 'test_name' if six.PY3 else b'test_name' request = self.request api_key = None view_func = 'dummy_view_func' two_factor_check_fn = two_factor_check(view_func, api_key) function_getting_checked_with_auth = two_factor_check_fn(mock_fn_to_call) with mock.patch('corehq.apps.domain.decorators._ensure_request_couch_user', return_value=request.couch_user): response = function_getting_checked_with_auth(request, self.domain.name) self.assertEqual(response, 'Function was called!') mock_fn_to_call.assert_called_once()
def test_executor_once(): """Test that ExecutorEventEmitters also emit events for once. """ with ExecutorEventEmitter() as ee: should_call = Mock() @ee.once('event') def event_handler(): should_call(True) ee.emit('event') sleep(0.1) should_call.assert_called_once()
def test_standalone__custom_config__when_environment_variable_set(monkeypatch): with in_temp_dir(): write_config("custom/path/to/jasmine.yml") env_vars = {'JASMINE_CONFIG_PATH': "custom/path/to/jasmine.yml"} monkeypatch.setattr(os, 'environ', env_vars) fake_standalone = Mock() cmd = Command(fake_standalone, FakeCI) cmd.run(['server']) fake_standalone.assert_called_once() standalone_construction_kwargs = fake_standalone.call_args[1] called_with_config = standalone_construction_kwargs['jasmine_config'].yaml_file assert called_with_config.endswith("custom/path/to/jasmine.yml")
def test_new_listener_event(): """The 'new_listener' event fires whenever a new listerner is added.""" call_me = Mock() ee = BaseEventEmitter() ee.on('new_listener', call_me) # Should fire new_listener event @ee.on('event') def event_handler(data): pass call_me.assert_called_once()
def test_emit_sync(cls): """Basic synchronous emission works""" call_me = Mock() ee = cls() @ee.on('event') def event_handler(data, **kwargs): call_me() assert data == 'emitter is emitted!' # Making sure data is passed propers ee.emit('event', 'emitter is emitted!', error=False) call_me.assert_called_once()
def test_fetch_requests_token_when_expired(self, request, sleep): post_response_mock = Mock() post_response_mock.raise_for_status = Mock(return_value=False) post_response_mock.json = Mock(return_value={'token': 'token1', 'expires': '123'}) request.post = Mock(return_value=post_response_mock) request_token_mock = Mock() return_false_for_status_mock = Mock(return_value=(True, None)) self.patient._request_token = request_token_mock self.patient._return_false_for_status = return_false_for_status_mock self.patient._fetch('url') request_token_mock.assert_called_once()
def test_cleanup(self, mock_get_database): self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION mock_database = MagicMock(spec=['__getitem__', '__setitem__']) mock_collection = Mock() mock_get_database.return_value = mock_database mock_database.__getitem__.return_value = mock_collection self.backend.cleanup() mock_get_database.assert_called_once_with() mock_database.__getitem__.assert_called_once_with( MONGODB_COLLECTION) mock_collection.assert_called_once()