def runTest(self):
HelperTestingClass.__init__(self)
limits = (-10.0, 10.0, -9.0, 9.0)
ws_nonrotho = CreateMDWorkspace(
Dimensions=3,
Extents=','.join([str(lim) for lim in limits]) + ',-8,8',
Names='A,B,C',
Units='r.l.u.,r.l.u.,r.l.u.',
Frames='HKL,HKL,HKL')
expt_info_nonortho = CreateSampleWorkspace()
ws_nonrotho.addExperimentInfo(expt_info_nonortho)
SetUB(ws_nonrotho, 1, 1, 2, 90, 90, 120)
pres = SliceViewer(ws_nonrotho)
# assert limits of orthog
limits_orthog = pres.view.data_view.get_axes_limits()
self.assertEqual(limits_orthog[0], limits[0:2])
self.assertEqual(limits_orthog[1], limits[2:])
# set nonorthog view and retrieve new limits
pres.nonorthogonal_axes(True)
limits_nonorthog = pres.view.data_view.get_axes_limits()
self.assertAlmostEqual(limits_nonorthog[0][0], -19, delta=1e-5)
self.assertAlmostEqual(limits_nonorthog[0][1], 19, delta=1e-5)
self.assertEqual(limits_nonorthog[1], limits[2:])
pres.view.close()
def test_on_close(self):
pres = SliceViewer(mock.Mock(),
model=mock.MagicMock(),
view=mock.MagicMock())
self.assertIsNotNone(pres.ads_observer)
pres.clear_observer()
self.assertEqual(pres.ads_observer, None)
def test_delete_workspace(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
pres.delete_workspace("test_name")
mock_view.emit_close.assert_called_once()
def _create_presenter(model: SliceViewerModel, view, mock_sliceinfo_cls,
enable_nonortho_axes, supports_nonortho):
data_view_mock = view.data_view
data_view_mock.plot_MDH = mock.Mock()
presenter = SliceViewer(None, model=model, view=view)
# Patch out things from the base presenter
presenter.show_all_data_clicked = mock.Mock()
if enable_nonortho_axes:
data_view_mock.nonorthogonal_mode = True
data_view_mock.nonortho_transform = mock.MagicMock(
NonOrthogonalTransform)
data_view_mock.nonortho_transform.tr.return_value = (0, 1)
presenter.nonorthogonal_axes(True)
else:
data_view_mock.nonorthogonal_mode = False
data_view_mock.nonortho_transform = None
data_view_mock.disable_tool_button.reset_mock()
data_view_mock.create_axes_orthogonal.reset_mock()
data_view_mock.create_axes_nonorthogonal.reset_mock()
mock_sliceinfo_instance = mock_sliceinfo_cls.return_value
mock_sliceinfo_instance.can_support_nonorthogonal_axes.return_value = supports_nonortho
return presenter, data_view_mock
def test_workspace_not_deleted_with_different_name(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 = False
pres.delete_workspace("different_name")
mock_view.emit_close.assert_not_called()
def test_rename_workspace_not_renamed_with_different_name(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 = False
pres.rename_workspace("old_name", "new_name")
mock_model.set_ws_name.assert_not_called()
mock_view.emit_rename.assert_not_called()
def test_rename_workspace(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
pres.rename_workspace("old_name", "new_name")
mock_model.set_ws_name.assert_called_with("new_name")
mock_view.emit_rename.assert_called_once_with(
mock_model.get_title.return_value)
def test_normalization_change_set_correct_normalization(self):
self.patched_deps[
"WorkspaceInfo"].get_ws_type.return_value = WS_TYPE.MATRIX
self.view.data_view.plot_matrix = mock.Mock()
presenter = SliceViewer(None, model=self.model, view=self.view)
presenter.normalization_changed("By bin width")
self.view.data_view.plot_matrix.assert_called_with(self.model.ws,
distribution=False)
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 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_cut_view_toggled_off(self, mock_get_sliceinfo):
presenter = SliceViewer(None, model=self.model, view=self.view)
presenter._cutviewer_presenter = mock.MagicMock()
mock_get_sliceinfo.return_value.can_support_nonorthogonal_axes.return_value = True
presenter.non_axis_aligned_cut(False)
presenter._cutviewer_presenter.hide_view.assert_called_once()
# test correct buttons disabled
self.view.data_view.enable_tool_button.assert_has_calls([
mock.call(tool)
for tool in (ToolItemText.REGIONSELECTION, ToolItemText.LINEPLOTS,
ToolItemText.NONORTHOGONAL_AXES)
])
def runTest(self):
HelperTestingClass.__init__(self)
conf = MockConfig()
histo_ws = create_histo_ws()
pres = SliceViewer(histo_ws, conf=conf)
colorbar = pres.view.data_view.colorbar
self.assertTrue(isinstance(colorbar.get_norm(), Normalize))
pres.view.close()
def peaks_button_not_disabled_if_model_can_support_it(self):
self.patched_deps[
"WorkspaceInfo"].get_ws_type.return_value = WS_TYPE.MATRIX
self.model.can_support_peaks_overlay.return_value = True
SliceViewer(None, model=self.model, view=self.view)
self.view.data_view.disable_tool_button.assert_not_called()
def runTest(self):
HelperTestingClass.__init__(self)
ws = CreateSampleWorkspace()
SliceViewer(ws)
AnalysisDataService.clear()
self._qapp.sendPostedEvents()
self.assert_no_toplevel_widgets()
def peaks_button_disabled_if_model_cannot_support_it(self):
self.patched_deps[
"WorkspaceInfo"].get_ws_type.return_value = WS_TYPE.MATRIX
self.model.can_support_peaks_overlay.return_value = False
SliceViewer(None, model=self.model, view=self.view)
self.view.data_view.disable_tool_button.assert_called_once_with(
ToolItemText.OVERLAY_PEAKS)
def test_cut_view_toggled_on(self, mock_cv_pres):
presenter = SliceViewer(None, model=self.model, view=self.view)
self.view.data_view.track_cursor = mock.MagicMock()
presenter.non_axis_aligned_cut(True)
mock_cv_pres.assert_called_once_with(presenter,
self.view.data_view.canvas)
# test correct buttons disabled
self.view.data_view.deactivate_and_disable_tool.assert_has_calls([
mock.call(tool)
for tool in (ToolItemText.REGIONSELECTION, ToolItemText.LINEPLOTS,
ToolItemText.NONORTHOGONAL_AXES)
])
self.view.data_view.deactivate_tool.assert_called_once_with(
ToolItemText.ZOOM)
self.view.data_view.track_cursor.setChecked.assert_called_once_with(
False)
def test_cut_view_button_disabled_if_model_cannot_support_it(self):
self.patched_deps[
"WorkspaceInfo"].get_ws_type.return_value = WS_TYPE.MATRIX
self.model.can_support_non_axis_cuts.return_value = False
SliceViewer(None, model=self.model, view=self.view)
self.view.data_view.disable_tool_button.assert_has_calls(
[mock.call(ToolItemText.NONAXISALIGNEDCUTS)])
def runTest(self):
HelperTestingClass.__init__(self)
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
ConvertToDistribution(ws)
self._qapp.sendPostedEvents()
self.assert_no_toplevel_widgets()
self.assertEqual(pres.ads_observer, None)
def runTest(self):
HelperTestingClass.__init__(self)
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
title = pres.model.get_title()
other_workspace = CreateSampleWorkspace()
other_renamed = RenameWorkspace(other_workspace) # noqa F841
self.assertEqual(pres.model.get_title(), title)
self.assertEqual(pres.view.windowTitle(), pres.model.get_title())
def test_sliceviewer_matrix(self):
self.patched_deps[
"WorkspaceInfo"].get_ws_type.return_value = WS_TYPE.MATRIX
presenter = SliceViewer(None, model=self.model, view=self.view)
# setup calls
self.assertEqual(self.model.get_properties.call_count, 1)
self.assertEqual(
self.view.data_view.dimensions.get_slicepoint.call_count,
1) # extra call during init of pres
self.assertEqual(self.view.data_view.plot_matrix.call_count, 1)
# new_plot
self.model.reset_mock()
self.view.reset_mock()
presenter.new_plot()
self.assertEqual(
self.view.data_view.dimensions.get_slicepoint.call_count, 0)
self.assertEqual(self.view.data_view.plot_matrix.call_count, 1)
def runTest(self, mock_update_slider):
HelperTestingClass.__init__(self)
xmin = 5000
xmax = 10000
ws = CreateSampleWorkspace(NumBanks=2, BankPixelWidth=2, XMin=xmin, XMax=xmax) # two non-monitor spectra
ws.setX(0, hstack([2 * ws.readX(0)[0:-1], inf])) # change x limits of spectrum and put inf in last element
pres = SliceViewer(ws)
pres.view.data_view.plot_matrix(ws)
self.assertEqual(pres.view.data_view.get_axes_limits()[0], (xmin, xmax))
def runTest(self):
HelperTestingClass.__init__(self)
xmin = 5000
xmax = 10000
ws = CreateSampleWorkspace(NumBanks=1, NumMonitors=1, BankPixelWidth=1, XMin=xmin, XMax=xmax)
ws.setX(0, 2 * ws.readX(0)) # change x limits of monitor spectrum
pres = SliceViewer(ws)
pres.view.data_view.plot_matrix(ws)
self.assertEqual(pres.view.data_view.get_axes_limits()[0], (xmin, xmax))
def runTest(self):
HelperTestingClass.__init__(self)
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
self.assert_widget_created()
pres.view.close()
pres = None
self._qapp.sendPostedEvents()
self.assert_no_toplevel_widgets()
def runTest(self):
HelperTestingClass.__init__(self)
histo_ws = create_histo_ws()
pres = SliceViewer(histo_ws)
self.assert_widget_created()
pres.view.close()
self._qapp.sendPostedEvents()
self._qapp.sendPostedEvents()
self.assert_no_toplevel_widgets()
self.assertEqual(pres.ads_observer, None)
def test_sliceviewer_MDH(self):
presenter = SliceViewer(None, model=self.model, view=self.view)
# setup calls
self.assertEqual(self.model.get_ws.call_count, 1)
self.assertEqual(self.model.get_properties.call_count, 1)
self.assertEqual(
self.view.data_view.dimensions.get_slicepoint.call_count,
2) # extra call during init of pres
self.assertEqual(self.view.data_view.plot_MDH.call_count, 1)
# new_plot
self.model.reset_mock()
self.view.reset_mock()
presenter.new_plot()
self.assertEqual(self.model.get_ws.call_count, 1)
self.assertEqual(
self.view.data_view.dimensions.get_slicepoint.call_count, 1)
self.assertEqual(self.view.data_view.plot_MDH.call_count, 1)
# update_plot_data
self.model.reset_mock()
self.view.reset_mock()
presenter.update_plot_data()
self.assertEqual(self.model.get_data.call_count, 1)
self.assertEqual(
self.view.data_view.dimensions.get_slicepoint.call_count, 1)
self.assertEqual(self.view.data_view.update_plot_data.call_count, 1)
def test_non_orthogonal_axes_toggled_on(self):
self.patched_deps[
"WorkspaceInfo"].get_ws_type.return_value = WS_TYPE.MDE
self.patched_deps[
"Dimensions"].return_value.get_dim_limits.return_value = ((-1, 1),
(-2, 2))
data_view_mock = self.view.data_view
data_view_mock.plot_MDH = mock.Mock()
presenter = SliceViewer(None, model=self.model, view=self.view)
presenter.show_all_data_clicked = mock.Mock()
presenter.new_plot = mock.Mock()
data_view_mock.plot_MDH.reset_mock() # clear initial plot call
data_view_mock.create_axes_orthogonal.reset_mock()
presenter.nonorthogonal_axes(True)
data_view_mock.deactivate_and_disable_tool.assert_called_once_with(
ToolItemText.REGIONSELECTION)
data_view_mock.create_axes_nonorthogonal.assert_called_once()
data_view_mock.create_axes_orthogonal.assert_not_called()
data_view_mock.disable_tool_button.assert_has_calls(
[mock.call(ToolItemText.LINEPLOTS)])
presenter.show_all_data_clicked.assert_called_once()
presenter.new_plot.assert_called_once()
def runTest(self):
HelperTestingClass.__init__(self)
ws_4D = CreateMDWorkspace(Dimensions=4, Extents=[-1, 1, -1, 1, -1, 1, -1, 1], Names="E,H,K,L",
Frames='General Frame,HKL,HKL,HKL', Units='meV,r.l.u.,r.l.u.,r.l.u.')
expt_info_4D = CreateSampleWorkspace()
ws_4D.addExperimentInfo(expt_info_4D)
SetUB(ws_4D, 1, 1, 2, 90, 90, 120)
pres = SliceViewer(ws_4D)
self._qapp.sendPostedEvents()
non_ortho_action = toolbar_actions(pres, [ToolItemText.NONORTHOGONAL_AXES])[0]
self.assertFalse(non_ortho_action.isEnabled())
pres.view.close()
def runTest(self):
HelperTestingClass.__init__(self)
histo_ws_positive = create_histo_ws_positive()
pres = SliceViewer(histo_ws_positive)
colorbar = pres.view.data_view.colorbar
colorbar.autoscale.setChecked(False)
colorbar.norm.setCurrentText("Log")
self.assertEqual(colorbar.cmin.validator().bottom(), MIN_LOG_VALUE)
colorbar.norm.setCurrentText("Linear")
self.assertEqual(colorbar.cmin.validator().bottom(), -inf)
pres.view.close()
def runTest(self):
HelperTestingClass.__init__(self)
def scale_ws(ws):
ws = Scale(ws, 100, "Multiply")
ws = CreateSampleWorkspace()
pres = SliceViewer(ws)
self._assertNoErrorInADSHandlerFromSeparateThread(partial(scale_ws, ws))
self._qapp.sendPostedEvents()
self.assertTrue(pres.view in self.find_widgets_of_type(str(type(pres.view))))
self.assertNotEqual(pres.ads_observer, None)
pres.view.close()
def runTest(self):
HelperTestingClass.__init__(self)
ws_non_ortho = CreateMDWorkspace(Dimensions='3', Extents='-6,6,-4,4,-0.5,0.5',
Names='H,K,L', Units='r.l.u.,r.l.u.,r.l.u.',
Frames='HKL,HKL,HKL',
SplitInto='2', SplitThreshold='50')
expt_info_nonortho = CreateSampleWorkspace()
ws_non_ortho.addExperimentInfo(expt_info_nonortho)
SetUB(ws_non_ortho, 1, 1, 2, 90, 90, 120)
pres = SliceViewer(ws_non_ortho)
ClearUB(ws_non_ortho)
self._qapp.sendPostedEvents()
self.assert_no_toplevel_widgets()
self.assertEqual(pres.ads_observer, None)
