tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_axis.py

@@ -0,0 +1,199 @@
+import gc
+import pickle
+import shutil
+import tempfile
+import time
+import os
+
+import pytest
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.AxisOW import AxisOW
+from tomwer.core.utils.lbsram import mock_low_memory
+from tomwer.core.process.reconstruction.axis.mode import AxisMode
+from tomwer.core.settings import mock_lsbram
+from tomwer.core.utils.scanutils import MockNXtomo, MockEDF
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestOWAxis(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        self._window = AxisOW()
+        self.recons_params = self._window.recons_params
+        self.tempdir = tempfile.mkdtemp()
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tempdir, "nx_tomo.nx"),
+            n_proj=10,
+            n_ini_proj=10,
+            scan_range=180,
+            dim=20,
+            energy=12.3,
+        ).scan
+
+        self._window.getAxisParams().mode = AxisMode.centered
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        gc.collect()
+
+    def testAxisLock(self):
+        """Test behavior when locking the axis position. Could not be included
+        in the tomwer/gui because the lock action is only available for the OW
+        """
+        assert self._window.getAxisParams().mode in (
+            AxisMode.centered,
+            AxisMode.global_,
+        )
+        radio_axis = self._window._widget._axisWidget
+        main_widget = self._window._widget
+        self.assertFalse(main_widget._controlWidget._lockBut.isLocked())
+        self.assertTrue(radio_axis._settingsWidget._mainWidget.isEnabled())
+        self.mouseClick(main_widget._controlWidget._lockBut, qt.Qt.LeftButton)
+        self.qapp.processEvents()
+        self.assertTrue(main_widget._controlWidget._lockBut.isLocked())
+        # when the lock button is activated we should automatically switch to
+        # the manual mode
+        self.assertTrue(self._window.getAxisParams().mode is AxisMode.manual)
+        self.assertFalse(radio_axis._settingsWidget._mainWidget.isEnabled())
+
+    def test_serializing(self):
+        pickle.dumps(self._window.recons_params.to_dict())
+
+    def test_literal_dumps(self):
+        literal_dumps(self._window.recons_params.to_dict())
+
+
+class TestWindowAxisComputation(TestCaseQt):
+    @staticmethod
+    def _long_computation(scan):
+        time.sleep(5)
+        return -1
+
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self.tempdir = tempfile.mkdtemp()
+        self._mainWindow = AxisOW()
+        self.recons_params = self._mainWindow.recons_params
+        self._window = self._mainWindow._widget
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tempdir, "nx_tomo.nx"),
+            n_proj=10,
+            n_ini_proj=10,
+            scan_range=180,
+            dim=20,
+            energy=12.3,
+        ).scan
+        self._mainWindow.show()
+        self.qWaitForWindowExposed(self._mainWindow)
+        self._mainWindow.setMode("manual")
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+        self._mainWindow.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._mainWindow.close()
+        self._mainWindow = None
+        self._window = None
+        gc.collect()
+
+    def testComputationSucceed(self):
+        """Test gui if the axis position is correctly computed"""
+        self.recons_params.mode = AxisMode.manual
+        radio_axis = self._window._axisWidget
+        self.assertEqual(radio_axis.getMode(), AxisMode.manual)
+        radio_axis.setXShift(2.345)
+        self._mainWindow.process(self.scan)
+        self.qapp.processEvents()
+        self.assertEqual(radio_axis.getMode(), AxisMode.manual)
+        self.assertEqual(self.recons_params.relative_cor_value, 2.345)
+        position_info_widget = self._window._controlWidget._positionInfo
+        self.assertEqual(position_info_widget._relativePositionQLE.text(), "2.345")
+
+
+global _computation_res
+_computation_res = 0
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestAxisStack(TestCaseQt):
+    """Test axis computation of a stack of scan"""
+
+    @staticmethod
+    def _test_computation(scan):
+        global _computation_res
+        _computation_res += 1
+        return _computation_res
+
+    def setUp(self):
+        # not working due to OW
+        TestCaseQt.setUp(self)
+        self._scan1 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
+        self._scan2 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
+        self._scan3 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
+        self._mainWindow = AxisOW()
+        self.recons_params = self._mainWindow._axis_params
+        self._mainWindow._skip_exec(True)
+
+        global _computation_res
+        _computation_res = 0
+
+        self._mainWindow.patch_calc_method(
+            AxisMode.centered, TestAxisStack._test_computation
+        )
+        self.recons_params.mode = AxisMode.centered
+
+        self._mainWindow.show()
+        self.qWaitForWindowExposed(self._mainWindow)
+
+    def tearDown(self):
+        mock_low_memory(False)
+        mock_lsbram(False)
+        self._mainWindow.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._mainWindow.close()
+        self._mainWindow = None
+        self._recons_params = None
+        self.qapp.processEvents()
+        for scan in (self._scan1, self._scan2, self._scan3):
+            shutil.rmtree(scan.path)
+        gc.collect()
+
+    def testLowMemory(self):
+        """Make sure the axis computation will be skip if we are in low memory"""
+        mock_low_memory(True)
+        mock_lsbram(True)
+        for scan in (self._scan1, self._scan2, self._scan3):
+            self.qapp.processEvents()
+            self._mainWindow.new_data_in(scan)
+
+        self.assertEqual(self._scan1.axis_params, None)
+        self.assertEqual(self._scan2.axis_params, None)
+        self.assertEqual(self._scan3.axis_params, None)
+
+    def testLockStack(self):
+        """Check that axis position will be simply copy if we are in a lock
+        stack"""
+        self.recons_params.mode = AxisMode.manual
+        position_value = 0.36
+        self.recons_params.set_relative_value(position_value)
+
+        for scan in (self._scan1, self._scan2, self._scan3):
+            self._mainWindow.process(scan)
+
+        for i in range(5):
+            self.qapp.processEvents()
+            time.sleep(0.2)
+            self.qapp.processEvents()
+
+        self.assertEqual(self._scan1.axis_params.relative_cor_value, position_value)
+        self.assertEqual(self._scan2.axis_params.relative_cor_value, position_value)
+        self.assertEqual(self._scan3.axis_params.relative_cor_value, position_value)

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_cast_volumeow.py

@@ -0,0 +1,58 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import os
+import pickle
+import tempfile
+import time
+
+import numpy
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.CastNabuVolumeOW import (
+    CastNabuVolumeOW,
+)
+from tomwer.core.volume.rawvolume import RawVolume
+
+
+class TestCastVolumeOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self._window = CastNabuVolumeOW()
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)
+
+    def test_serializing(self):
+        pickle.dumps(self._window.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self._window.getConfiguration())
+
+    def test_cast_volume(self):
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            input_dir = os.path.join(tmp_dir, "input")
+            os.makedirs(input_dir)
+
+            volume = RawVolume(
+                file_path=os.path.join(input_dir, "vol_file.vol"),
+                data=numpy.linspace(0, 10, 100 * 100 * 3, dtype=numpy.float32).reshape(
+                    3, 100, 100
+                ),
+            )
+            volume.save()
+
+            self._window.process_volume(volume)
+            while self._window._processingStack.is_computing():
+                time.sleep(0.1)
+                self.qapp.processEvents()

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_dark_refs_widget.py

@@ -0,0 +1,136 @@
+import gc
+import logging
+import os
+import pickle
+import tempfile
+
+import numpy
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.DarkRefAndCopyOW import (
+    DarkRefAndCopyOW,
+)
+from tomwer.core.utils.scanutils import MockNXtomo
+
+logging.disable(logging.INFO)
+
+
+class TestDarkRefWidget(TestCaseQt):
+    """class testing the DarkRefWidget"""
+
+    def setUp(self):
+        self._tmp_path = tempfile.mkdtemp()
+        scan_folder_with_raw = os.path.join(self._tmp_path, "test_dir_1")
+        scan_folder_without_raw = os.path.join(self._tmp_path, "test_dir_2")
+        for my_dir in (scan_folder_with_raw, scan_folder_without_raw):
+            os.makedirs(my_dir)
+
+        self._scan_with_raw = MockNXtomo(
+            scan_path=scan_folder_with_raw,
+            create_ini_dark=True,
+            create_ini_flat=True,
+            create_final_flat=False,
+            n_proj=10,
+            n_ini_proj=10,
+            dim=12,
+        ).scan
+        self._scan_without_raw = MockNXtomo(
+            scan_path=scan_folder_without_raw,
+            create_ini_dark=False,
+            create_ini_flat=False,
+            create_final_flat=False,
+            n_proj=10,
+            n_ini_proj=10,
+            dim=12,
+        ).scan
+
+        self.widget = DarkRefAndCopyOW()
+        return super().setUp()
+
+    def tearDown(self):
+        # shutil.rmtree(self._tmp_path)
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        gc.collect()
+
+    def test_serializing(self):
+        self.widget._updateSettingsVals()
+        pickle.dumps(self.widget._ewoks_default_inputs)
+
+    def test_literal_dumps(self):
+        self.widget._updateSettingsVals()
+        literal_dumps(self.widget._ewoks_default_inputs)
+
+    def test_copy(self):
+        self.widget.setCopyActive(True)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 0
+
+        self.widget.process(self._scan_with_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._scan_with_raw.load_reduced_darks() not in (None, {})
+        assert self._scan_with_raw.load_reduced_flats() not in (None, {})
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 1
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 1
+
+        self.widget.setCopyActive(False)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.widget.process(self._scan_without_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._scan_without_raw.load_reduced_darks() in (None, {})
+        assert self._scan_without_raw.load_reduced_flats() in (None, {})
+
+        self.widget.setCopyActive(True)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.widget.process(self._scan_without_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._scan_without_raw.load_reduced_darks() not in (None, {})
+        assert self._scan_without_raw.load_reduced_flats() not in (None, {})
+
+    def test_set_darks_and_flats(self):
+        """
+        Test settings darks and flats.
+        """
+        self.widget.setCopyActive(True)
+
+        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 0
+        self.widget.setReducedFlats(
+            {
+                "0.0r": numpy.linspace(12, 12 + 12 * 12, 12 * 12).reshape(12, 12),
+                "1.0r": numpy.linspace(24, 24 + 12 * 12, 12 * 12).reshape(12, 12),
+            }
+        )
+        self.widget.setReducedDarks(
+            {
+                "0.0r": numpy.linspace(0, 12 * 12, 12 * 12).reshape(12, 12),
+            }
+        )
+        self.widget.process(self._scan_without_raw)
+        self.widget._processing_stack.wait_computation_finished()
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+
+        loaded_reduced_darks = self._scan_without_raw.load_reduced_darks()
+        assert tuple(loaded_reduced_darks.keys()) == (0,)
+        numpy.testing.assert_allclose(
+            loaded_reduced_darks[0],
+            numpy.linspace(0, 12 * 12, 12 * 12).reshape(12, 12),
+        )
+
+        loaded_reduced_flats = self._scan_without_raw.load_reduced_flats()
+        assert tuple(loaded_reduced_flats.keys()) == (0, 9)
+        numpy.testing.assert_allclose(
+            loaded_reduced_flats[9],
+            numpy.linspace(24, 24 + 12 * 12, 12 * 12).reshape(12, 12),
+        )

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_delta_beta_selector.py

@@ -0,0 +1,15 @@
+import numpy
+
+from orangecontrib.tomwer.widgets.reconstruction.NabuVolumeOW import (
+    _DeltaBetaSelectorDialog,
+)
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_DeltaBetaSelector(
+    qtapp,  # noqa F811
+):
+    """simple test of the _DeltaBetaSelectorDialog"""
+    dialog = _DeltaBetaSelectorDialog(values=(12, 45))
+    dialog.show()
+    assert numpy.isscalar(dialog.getSelectedValue())

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_i_norm.py

@@ -0,0 +1,200 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import logging
+import os
+import pickle
+import shutil
+import tempfile
+
+from orangecanvas.scheme.readwrite import literal_dumps
+from processview.core.manager import DatasetState, ProcessManager
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+from silx.io.utils import h5py_read_dataset
+
+from orangecontrib.tomwer.widgets.reconstruction.SinoNormOW import (
+    SinoNormOW as _NormIOW,
+)
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import mock_low_memory
+from tomwer.core.process.reconstruction.normalization import SinoNormalizationTask
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.io.utils.h5pyutils import EntryReader
+
+logger = logging.getLogger(__name__)
+
+
+class NormIOW(_NormIOW):
+    def __init__(self, parent=None):
+        self._scans_finished = []
+        super().__init__(parent)
+
+    def processing_finished(self, scan):
+        self._scans_finished.append(scan)
+
+    def wait_processing(self, wait_time):
+        self._window._processing_stack._computationThread.wait(wait_time)
+
+    @property
+    def scans_finished(self):
+        return self._scans_finished
+
+    def compute(self):
+        self._window._processCurrentScan()
+
+    def setROI(self, start_x, end_x, start_y, end_y):
+        self._window.setROI(start_x=start_x, end_x=end_x, start_y=start_y, end_y=end_y)
+
+    def close(self):
+        self._scans_finished = {}
+        super().close()
+
+
+class TestProcessing(TestCaseQt):
+    DIM = 100
+
+    def setUp(self):
+        super().setUp()
+        self._source_dir = tempfile.mkdtemp()
+
+        def create_scan(folder_name):
+            _dir = os.path.join(self._source_dir, folder_name)
+            return MockNXtomo(
+                scan_path=_dir,
+                n_ini_proj=20,
+                n_proj=20,
+                n_alignement_proj=2,
+                create_final_flat=False,
+                create_ini_dark=True,
+                create_ini_flat=True,
+                n_refs=1,
+                dim=self.DIM,
+            ).scan
+
+        # create scans
+        self.scan_1 = create_scan("scan_1")
+        self.scan_2 = create_scan("scan_2")
+        self.scan_3 = create_scan("scan_3")
+        self._process_manager = ProcessManager()
+
+        self.widget = NormIOW()
+        self.widget.show()
+
+    def tearDown(self):
+        mock_low_memory(False)
+        settings.mock_lsbram(False)
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        self.qapp.processEvents()
+        shutil.rmtree(self._source_dir)
+        gc.collect()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        self.widget._updateSettings()
+        literal_dumps(self.widget._ewoks_default_inputs)
+
+    def testUnlocked(self):
+        """Test result when used with some interaction"""
+        self.widget.setLocked(False)
+
+        def process_scalar_manually():
+            self.widget.setCurrentMethod("division")
+            self.widget.setCurrentSource("manual ROI")
+
+            self.qapp.processEvents()
+            self.widget.setROI(start_x=0, end_x=10, start_y=0, end_y=10)
+            self.qapp.processEvents()
+            self.widget.compute()
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        self.widget.process(self.scan_1)
+        process_scalar_manually()
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_1.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.WAIT_USER_VALIDATION,
+        )
+
+        self.widget.process(self.scan_2)
+        process_scalar_manually()
+        self.assertEqual(len(self.widget.scans_finished), 0)
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_1.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.SKIPPED,
+        )
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_2.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.WAIT_USER_VALIDATION,
+        )
+
+        self.widget.process(self.scan_3)
+        process_scalar_manually()
+        self.widget.validateCurrentScan()
+        self.assertEqual(
+            self._process_manager.get_dataset_state(
+                dataset_id=self.scan_3.get_identifier(),
+                process=self.widget,
+            ),
+            DatasetState.SUCCEED,
+        )
+
+    def testTestLbsram(self):
+        """Test scan are all validated if 'low memory on lbsram' scenario is
+        activated"""
+        mock_low_memory(True)
+        settings.mock_lsbram(True)
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            self.widget.process(scan)
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            with self.subTest(scan=str(scan)):
+                self.assertEqual(
+                    self._process_manager.get_dataset_state(
+                        dataset_id=scan.get_identifier(),
+                        process=self.widget,
+                    ),
+                    DatasetState.SKIPPED,
+                )
+
+    def testLocked(self):
+        """Test scan are all validated if the widget is lock"""
+        self.widget.setLocked(True)
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            self.widget.process(scan)
+            self.widget.wait_processing(5000)
+            self.qapp.processEvents()
+
+        for scan in (self.scan_1, self.scan_2, self.scan_3):
+            # test status is SUCCEED
+            with self.subTest(scan=str(scan)):
+                self.assertEqual(
+                    self._process_manager.get_dataset_state(
+                        dataset_id=scan.get_identifier(),
+                        process=self.widget,
+                    ),
+                    DatasetState.SUCCEED,
+                )
+            # test process file has been updated
+            with EntryReader(scan.process_file_url) as entry:
+                self.assertTrue("tomwer_process_0" in entry)
+                self.assertEqual(
+                    h5py_read_dataset(entry["tomwer_process_0"]["program"]),
+                    SinoNormalizationTask.program_name(),
+                )

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_nabu_helical_prepare_weights_double.py

@@ -0,0 +1,20 @@
+# import pickle
+
+# from orangecanvas.scheme.readwrite import literal_dumps
+
+# from tomwer.tests.conftest import qtapp  # noqa F401
+
+# from orangecontrib.tomwer.widgets.reconstruction.NabuHelicalPrepareWeightsDoubleOW import (
+#     NabuHelicalPrepareWeightsDoubleOW,
+# )
+
+
+# def test_NabuHelicalPrepareWeightsDoubleOW(
+#     qtapp,  # noqa F811
+# ):
+#     """simple test of the _DeltaBetaSelectorDialog"""
+#     widget = NabuHelicalPrepareWeightsDoubleOW()
+#     widget._loadSettings()
+#     # test settings serialization
+#     pickle.dumps(widget._ewoks_default_inputs)
+#     literal_dumps(widget._ewoks_default_inputs)

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_nabu_volume.py

@@ -0,0 +1,74 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import gc
+import os
+import pickle
+import shutil
+import tempfile
+from time import sleep
+
+from nabu.pipeline.config import get_default_nabu_config
+from nabu.pipeline.fullfield.nabu_config import (
+    nabu_config as nabu_fullfield_default_config,
+)
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.NabuVolumeOW import NabuVolumeOW
+from tomwer.core.utils.scanutils import MockNXtomo
+
+
+class TestNabuVolumeOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self.tmp_dir = tempfile.mkdtemp()
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tmp_dir, "myscan"),
+            n_proj=20,
+            n_ini_proj=20,
+            dim=10,
+        ).scan
+        self.widget = NabuVolumeOW()
+        self.widget._processingStack.setDryRun(True)
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self.tmp_dir)
+        self.qapp.processEvents()
+        gc.collect()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self.widget.getConfiguration())
+
+    def test_scan_as_None(self):
+        "test if scan is None"
+        self.widget.process(None)
+
+    def test_scan_un_preprocessed(self):
+        "test when scan is unconfigured (No nabu_recons_params defined)"
+        assert self.scan.nabu_recons_params is None
+        self.widget.process(self.scan)
+
+    def test_scan_ready_to_be_processed(self):
+        "test if scan has valid reconstruction parameters to be runned"
+        self.scan.nabu_recons_params = get_default_nabu_config(
+            nabu_fullfield_default_config
+        )
+        self.widget.process(self.scan)
+        timeout = 3
+        loop_sleep_time = 0.05
+        while not self.widget._processingStack.can_process_next():
+            self.qapp.processEvents()
+            timeout -= loop_sleep_time
+            if timeout <= 0.0:
+                raise TimeoutError("volume not process within expected time")
+            else:
+                sleep(loop_sleep_time)