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