def test_data_ready_constructs_reduction_record(self, patched_record, patched_db): """ Tests the calling data ready with an instrument that does not exist in the DB creates the record """ self.mocked_utils.reduction_run. \ get_script_and_arguments.return_value = (mock.NonCallableMock(), mock.NonCallableMock()) mock_inst = mock.Mock() mock_inst.is_paused = False patched_db.configure_mock(**self._get_mocked_db_return_vals( mock_instrument=mock_inst, mock_data_location=mock.NonCallableMock())) # This method should not cap our highest version test_inputs = [-1, 100] for i in test_inputs: patched_db.find_highest_run_version = mock.Mock(return_value=i) mock_message = self._get_mock_message() self.handler.data_ready(message=mock_message) patched_record.create_reduction_run_record\ .assert_called_once_with( experiment=patched_db.get_experiment.return_value, instrument=mock_inst, message=mock_message, run_version=i + 1, script_text=self.mocked_utils. instrument_variable.get_current_script_text()[0], status=self.mocked_utils.status.get_queued() ) patched_record.reset_mock()
def test_beam_centre_errors_with_no_direction(self, mocked_alg): state = mock.NonCallableMock() fields = mock.NonCallableMock() fields.find_direction = None self.worker._logger = mock.create_autospec(self.worker._logger) self.worker.find_beam_centre(state, fields) self.assertEqual(0, mocked_alg.return_value.call_count) self.worker._logger.error.assert_called_once()
class V: fltr = mock.NonCallableMock(name="fltr", spec=[]) sender = mock.NonCallableMock(name="sender", spec=[]) @hp.memoized_property def finder(s): finder = mock.Mock(name="finder", spec=["finish"]) finder.finish = pytest.helpers.AsyncMock(name="finish") return finder
def test_init_monitor_names_forwards_invalid(self, set_monitor_names, get_invalid_names): expected = mock.NonCallableMock() get_invalid_names.return_value = expected state_instrument_info._init_monitor_names( data_info=mock.NonCallableMock(), inst_info=mock.NonCallableMock()) set_monitor_names.assert_called_once_with( mock.ANY, mock.ANY, invalid_monitor_names=expected)
def setUp(self): super(TC_00_API_Misc, self).setUp() self.src = mock.NonCallableMagicMock() self.app = mock.NonCallableMock() self.dest = mock.NonCallableMock() self.dest.name = 'dom0' self.app.configure_mock(domains={ 'dom0': self.dest, 'test-vm': self.src, })
def test_ws_name_passed_in_constructor(self, mock_view, mock_ads): mock_ads.retrieve.return_value = mock.NonCallableMock() ws = mock.NonCallableMock() presenter = InstrumentViewPresenter(ws) mock_view.assert_called_once_with(parent=mock.ANY, presenter=presenter, name=str(ws), window_flags=mock.ANY)
def _prep_mock_det_ipf(self): lab_short, lab_full = mock.NonCallableMock(), mock.NonCallableMock() hab_short, hab_full = mock.NonCallableMock(), mock.NonCallableMock() ipf_names = self._get_ipf_names() mocked_ipf = { ipf_names["lab_short"]: lab_short, ipf_names["lab_full"]: lab_full, ipf_names["hab_short"]: hab_short, ipf_names["hab_full"]: hab_full } return mocked_ipf
def test_replace_workspace_replaces_model(self): mock_model = mock.MagicMock() mock_view = mock.MagicMock() pres = SliceViewer(mock.Mock(), model=mock_model, view=mock_view) mock_model.workspace_equals.return_value = True with mock.patch( "mantidqt.widgets.sliceviewer.presenters.presenter.SliceViewerModel" ) as mock_model_class: pres.replace_workspace(mock.NonCallableMock(), mock.NonCallableMock()) self.assertEqual(mock_model_class.return_value, pres.model)
def setUp(self): super(TC_00_API_Misc, self).setUp() self.tpl = mock.NonCallableMagicMock(name='template') del self.tpl.template self.src = mock.NonCallableMagicMock(name='appvm', template=self.tpl) self.app = mock.NonCallableMock() self.dest = mock.NonCallableMock() self.dest.name = 'dom0' self.app.configure_mock(domains={ 'dom0': self.dest, 'test-vm': self.src, })
def setUp(self): super().setUp() self.app = mock.NonCallableMock() self.dom0 = mock.NonCallableMock(spec=qubes.vm.adminvm.AdminVM) self.dom0.name = 'dom0' self.domains = { 'dom0': self.dom0, } self.app.domains = mock.MagicMock(**{ '__iter__.side_effect': lambda: iter(self.domains.values()), '__getitem__.side_effect': self.domains.get, })
def test_clear_figure(self): self.view.ax = mock.NonCallableMock() self.view.image = mock.NonCallableMock() self.view.canvas = mock.Mock() self.view.fig = mock.Mock() self.view.clear_figure() self.assertIsNone(self.view.image) self.assertIsNone(self.view.ax) self.view.canvas.disable_zoom_on_scroll.assert_called_once() self.view.fig.clf.assert_called_once()
def test_returned_value_is_forwarded_on_success(self, mocked_alg): state = mock.NonCallableMock() fields = mock.NonCallableMock() fields.centre_of_mass = True fields.component = DetectorType.HAB mocked_instance = mocked_alg.return_value expected = {"pos1": 1.0, "pos2": 3.0} mocked_instance.return_value = expected self.worker.find_beam_centre(state, settings=fields) self.mocked_presenter.on_update_centre_values.assert_called_once_with( expected)
def test_construct_and_send_skipped(self, _): """ Tests that the message contents is updated with the passed in msg then send onwards to the skipped queue """ expected_msg = self._get_mock_message() self.handler._construct_and_send_skipped( rb_number=mock.NonCallableMock(), reason=mock.NonCallableMock(), message=expected_msg) self.mocked_client.send_message.assert_called_once_with( ACTIVEMQ_SETTINGS.reduction_skipped, expected_msg)
def test_that_can_get_state_for_index_if_index_exists(self): state_key = mock.NonCallableMock() self._mock_table.get_row.return_value = state_key expected_states, expected_errs = { state_key: mock.NonCallableMock(spec=StateGuiModel) }, None self.presenter.get_states = mock.Mock(return_value=(expected_states, expected_errs)) self.presenter.sans_logger = mock.Mock() state = self.presenter.get_state_for_row(0) self.assertEqual(expected_states[state_key].all_states, state)
def test_replace_workspace_does_nothing_if_workspace_is_unchanged(self): mock_model = mock.MagicMock() mock_view = mock.MagicMock() pres = SliceViewer(mock.Mock(), model=mock_model, view=mock_view) # TODO The return value here should be True but there is a bug in the # presenter where the condition is always incorrect (see the TODO on # replace_workspace in the presenter) mock_model.workspace_equals.return_value = False pres._close_view_with_message = mock.Mock() pres.replace_workspace(mock.NonCallableMock(), mock.NonCallableMock()) pres._close_view_with_message.assert_not_called() self.assertEqual(mock_model, pres.model)
def test_can_parse_toml_file(self): mock_path = mock.NonCallableMock() with mock.patch("sans.gui_logic.models.file_loading.TomlParser" ) as mocked_module: mocked_parser = mock.Mock() mocked_module.return_value = mocked_parser file_info = mock.NonCallableMock() result = FileLoading.load_user_file(file_path=mock_path, file_information=file_info) mocked_parser.parse_toml_file.assert_called_once_with( mock_path, file_information=file_info) self.assertEqual(result, mocked_parser.parse_toml_file.return_value)
def setUp(self): super(DracWSManBIOSConfigurationTestCase, self).setUp() self.node = obj_utils.create_test_node(self.context, driver='idrac', driver_info=INFO_DICT) patch_get_drac_client = mock.patch.object( drac_common, 'get_drac_client', spec_set=True, autospec=True) mock_get_drac_client = patch_get_drac_client.start() self.mock_client = mock_get_drac_client.return_value self.addCleanup(patch_get_drac_client.stop) proc_virt_attr = { 'current_value': 'Enabled', 'pending_value': None, 'read_only': False, 'possible_values': ['Enabled', 'Disabled']} mock_proc_virt_attr = mock.NonCallableMock(spec=[], **proc_virt_attr) mock_proc_virt_attr.name = 'ProcVirtualization' self.bios_attrs = {'ProcVirtualization': mock_proc_virt_attr} self.mock_client.set_lifecycle_settings.return_value = { "is_commit_required": True } self.mock_client.commit_pending_lifecycle_changes.return_value = \ "JID_1234" self.mock_client.set_bios_settings.return_value = { "is_commit_required": True, "is_reboot_required": True } self.mock_client.commit_pending_bios_changes.return_value = \ "JID_5678"
def test_impose_rate_limit(self, mock_sleep): mock_rlcache = mock.NonCallableMock(blocked=False, interval=13) max_sleep = 69 backoff = 11 api = PushshiftAPIMinimal(max_sleep=max_sleep, backoff=backoff, rate_limit_per_minute=self._rate_limit) api._rlcache = mock_rlcache api._impose_rate_limit() mock_sleep.assert_not_called() mock_rlcache.blocked = True api._impose_rate_limit() mock_sleep.assert_called_with(13) mock_rlcache.interval = 87 api._impose_rate_limit() mock_sleep.assert_called_with(max_sleep) mock_rlcache.interval = 0 api._impose_rate_limit(6) mock_sleep.assert_called_with(6 * backoff)
def test_raise_from_healthy_response(self): res = mock.NonCallableMock(requests.Response) res.status_code = 200 res.json = mock.MagicMock(return_value={"vegetables": "are healthy."}) res.text = json.dumps(res.json()) self.assertIs(_raise_from_response(res), None)
def test_reduction_error_retry_mechanism(self, patched_db): """ Tests the reduction error method retries a set number of times before backing off. """ mock_reduction_record = mock.NonCallableMock() self.handler.find_run = mock.Mock(return_value=mock_reduction_record) # Valid value *not* including 5 for i in range(0, 5): mocked_msg = self._get_mock_message() patched_db.find_highest_run_version = mock.Mock(return_value=i) self.handler.retry_run = mock.Mock() self.handler.reduction_error(message=mocked_msg) patched_db.get_experiment.assert_called_with(mocked_msg.rb_number) self.handler.retry_run.assert_called_once_with( mocked_msg.started_by, mock_reduction_record, mocked_msg.retry_in) # 5 and above should never retry for i in range(5, 7): mocked_msg = self._get_mock_message() self.handler.retry_run = mock.Mock() patched_db.find_highest_run_version = mock.Mock(return_value=i) self.handler.reduction_error(mocked_msg) # As we are > limit the retry should be set to None self.assertIsNone(mocked_msg.retry_in) self.handler.retry_run.assert_not_called()
def test_find_run(self, patched_db): """ Tests fiind run makes the expected DB calls when invoked """ mocked_msg = self._get_mock_message() mocked_msg.run_number = 100 mocked_msg.run_version = 200 mocked_experiment = mock.NonCallableMock() patched_db.get_experiment.return_value = mocked_experiment return_val = patched_db.start_database.return_value \ .data_model.ReductionRun.objects \ .filter.return_value \ .filter.return_value \ .filter.return_value \ .first.return_value self.assertEqual(return_val, self.handler.find_run(message=mocked_msg)) top_level_query = patched_db.start_database.return_value.data_model \ .ReductionRun.objects top_level_query.filter \ .assert_called_once_with(experiment_id=mocked_experiment.id) top_level_query.filter.return_value.filter \ .assert_called_once_with(run_number=100) top_level_query.filter.return_value.filter.return_value.filter \ .assert_called_once_with(run_version=200)
def setUp(self): msg = mock.NonCallableMock() msg.content = 'Test message' msg.author.name = 'Test author name' msg.author.id = 123456789 msg.guild = None self.msg = msg
def _pack_reduction_package(create_method): package = mock.NonCallableMock() package.calculated_transmission = create_method() package.calculated_transmission_can = create_method() package.unfitted_transmission = create_method() package.unfitted_transmission_can = create_method() return package
def wait_on_result( ack_required, res_required, retry_options, now, last_ack_received, last_res_received, results, num_results, ): V.request.ack_required = ack_required V.request.res_required = res_required retry_options = mock.NonCallableMock( name="retry_options", spec=retry_options.keys(), **retry_options ) with mock.patch.object(Result, "num_results", num_results): result = Result(V.request, False, retry_options) result.results = results result.last_ack_received = last_ack_received result.last_res_received = last_res_received t = mock.Mock(name="time", return_value=now) with mock.patch("time.time", t): return result.wait_for_result()
def test_switching_dimensionality_updates_model(self): expected_dim = mock.NonCallableMock() self._mock_view.reduction_dimensionality = expected_dim self.presenter.on_reduction_dimensionality_changed(is_1d=False) self.assertEqual(expected_dim, self._mock_model.reduction_dimensionality)
def test_should_use_url_from_config_if_catalog_config_missing(self): keystone.Keystone.instance = None with mock.patch('keystoneauth1.identity.Password') as password, \ mock.patch('keystoneauth1.session.Session') as session, \ mock.patch('keystoneclient.discover.Discover') as discover: client = mock.Mock() discover.return_value = d = mock.Mock() d.create_client = mock.Mock(return_value=client) monasca_url = mock.NonCallableMock() config = base_config.get_config('Api') config.update({ 'url': monasca_url, 'service_type': None, 'endpoint_type': None, 'region_name': None }) k = keystone.Keystone(config) k.get_monasca_url() password.assert_not_called() session.assert_not_called() discover.assert_not_called() client.auth_ref.service_catalog.url_for.assert_not_called()
def _get_header(): return { "destination": '/queue/DataReady', "priority": mock.NonCallableMock(), "message-id": str(uuid.uuid4()), "subscription": str(uuid.uuid4()) }
def __init__(self, unit_test_mode=True): super().__init__() super().set_unit_test_mode(unit_test_mode) self.finished_called = False self.success_called = False self.mocked_return = mock.NonCallableMock() self.cb_returned = None
def _do_test(self, instrument_name, mover_type): # Arrange workspace = load_empty_instrument(instrument_name) # Act mover = create_mover(workspace, state=mock.NonCallableMock()) # Assert self.assertTrue(isinstance(mover, mover_type))
def test_get_val_with_existing_dict(self): expected = mock.NonCallableMock() input_dict = {"there": None} injected_dict = {"there": expected} ret = TomlParserImplBase(input_dict).get_val("there", injected_dict) self.assertEqual(expected, ret, "Using internal dict instead of injected")