tomwer 0.2.0a1__tar.gz → 0.4.0__tar.gz

users/payno/.local/share/virtualenvs/tomwer_venc/bin/tomwer

@@ -1,6 +1,6 @@
 #!/users/payno/.local/share/virtualenvs/tomwer_venc/bin/python
-# EASY-INSTALL-ENTRY-SCRIPT: 'tomwer==0.2.0a1','console_scripts','tomwer'
-__requires__ = 'tomwer==0.2.0a1'
+# EASY-INSTALL-ENTRY-SCRIPT: 'tomwer==0.4.0','console_scripts','tomwer'
+__requires__ = 'tomwer==0.4.0'
 import re
 import sys
 from pkg_resources import load_entry_point
@@ -8,5 +8,5 @@ from pkg_resources import load_entry_point
 if __name__ == '__main__':
     sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
     sys.exit(
-        load_entry_point('tomwer==0.2.0a1', 'console_scripts', 'tomwer')()
+        load_entry_point('tomwer==0.4.0', 'console_scripts', 'tomwer')()
     )

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/__init__.py

@@ -1,5 +1,3 @@
-from tomwer.core import processlog
-from tomwer.core.log import colorlogger
 import logging
 
 # orange_logger = logging.getLogger('Orange.canvas')

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/orange/settings.py

@@ -0,0 +1,48 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+
+__authors__ = ["H. Payno", ]
+__license__ = "MIT"
+__date__ = "26/10/2018"
+
+from Orange.widgets import settings
+
+
+class CallbackSettingsHandler(settings.SettingsHandler):
+    """
+    Settings handler used to call some callback before packing data (so before)
+    saving orange :class:`Setting`
+    """
+    def __init__(self):
+        super(CallbackSettingsHandler, self).__init__()
+        self.__callbacks = []
+
+    def addCallback(self, _callback):
+        self.__callbacks.append(_callback)
+    
+    def pack_data(self, widget):
+        for callback in self.__callbacks:
+            callback()
+        return super(CallbackSettingsHandler, self).pack_data(widget)

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/setup.py

@@ -32,8 +32,9 @@ from numpy.distutils.misc_util import Configuration
 
 
 def configuration(parent_package='', top_path=None):
-    config = Configuration('test', parent_package, top_path)
+    config = Configuration('tomwer', parent_package, top_path)
     config.add_subpackage('widgets')
+    config.add_subpackage('test')
 
     return config
 

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/test/TestAcquisition.py

@@ -34,7 +34,7 @@ import logging
 import os
 import shutil
 
-from tomwer.core.utils import ftseriesutils
+from tomwer.core.scan.edfscan import EDFTomoScan
 from silx.gui import qt
 
 from tomwer.test.utils import UtilsTest
@@ -72,7 +72,7 @@ class Simulation(qt.QThread):
         super(Simulation, self).__init__()
 
         self.targetdir = targetdir
-        self.outputFolder = targetdir + '/' + manipulationId
+        self.outputFolder = os.path.sep.join((targetdir, manipulationId))
         self.finalState = finalState
         self.currentState = 'not started'
         self._createFinalXML = False
@@ -83,14 +83,14 @@ class Simulation(qt.QThread):
         self.destPattern = None
 
     def __getOriginalDataSet(self, dataSetID):
-        """Return paths to the requested dataset
+        """Return paths to the requested scan
         """
         assert(dataSetID in self.__definedDataset)
         dataDir = UtilsTest.getDataset(dataSetID)
 
         assert(os.path.isdir(dataDir))
         assert(os.path.isfile(os.path.join(dataDir, dataSetID + ".info")))
-        slices = ftseriesutils.getRadioPaths(dataDir)
+        slices = EDFTomoScan.getRadioPaths(dataDir)
         nbSlices = len(slices)
         manipulationID = dataSetID
 
@@ -114,7 +114,7 @@ class Simulation(qt.QThread):
         if srcPattern is not None or destPattern is not None:
             assert(os.path.isdir(srcPattern))
             assert(os.path.isdir(destPattern))
-            targettedFolder =  self.outputFolder.replace(self.srcPattern, self.destPattern, 1)
+            targettedFolder = self.outputFolder.replace(self.srcPattern, self.destPattern, 1)
             if not os.path.isdir(targettedFolder):
                 os.mkdir(targettedFolder)
 

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/test/__init__.py

@@ -28,20 +28,28 @@ __license__ = "MIT"
 __date__ = "15/05/2017"
 
 import unittest
+from . import test_axis_ftseries
 from . import test_scanlist_samplemoved
 from . import test_scanlist_ftserie
-from . import test_workflows
 from . import test_dark_flat_field
+from . import test_lamino
+from . import test_owidgets
+from . import test_dump_widget_canvas
+from . import test_folder_transfert
 from ..widgets import test as test_widgets
 
 
 def suite(loader=None, pattern='test*.py'):
     test_suite = unittest.TestSuite()
+    test_suite.addTest(test_axis_ftseries.suite())
     test_suite.addTest(test_widgets.suite())
     test_suite.addTest(test_scanlist_ftserie.suite())
-    test_suite.addTests(test_workflows.suite())
     test_suite.addTest(test_dark_flat_field.suite())
+    test_suite.addTest(test_lamino.suite())
     test_suite.addTest(test_scanlist_samplemoved.suite())
+    test_suite.addTest(test_owidgets.suite())
+    test_suite.addTest(test_dump_widget_canvas.suite())
+    test_suite.addTests(test_folder_transfert.suite())
     return test_suite
 
 

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/test/test_axis_ftseries.py

@@ -0,0 +1,253 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+"""contains test for relation between axis and ftseries"""
+
+
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "23/10/2019"
+
+
+import unittest
+from orangecontrib.tomwer.test.utils import OrangeWorflowTest
+from tomwer.test.utils import skip_gui_test
+from tomwer.core.utils.scanutils import MockEDF
+from silx.gui.utils.testutils import SignalListener
+import tempfile
+import shutil
+import time
+import os
+
+
+TIMEOUT_TEST = 10
+
+@unittest.skipIf(skip_gui_test(), reason='skip gui test')
+@unittest.skip('Fail on CI...')
+class TestAxisFtseries(OrangeWorflowTest):
+    """
+    Create the following workflow:
+    datawatcherOW -> axisOW -> ftseriesOW
+    """
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.nodeDataWatcher = cls.addWidget(cls,
+                                        'orangecontrib.tomwer.widgets.control.DataWatcherOW.DataWatcherOW')
+        cls.nodeAxis = cls.addWidget(cls,
+                                     'orangecontrib.tomwer.widgets.reconstruction.AxisOW.AxisOW')
+        cls.nodeFTSerie = cls.addWidget(cls,
+                                        'orangecontrib.tomwer.widgets.reconstruction.FtseriesOW.FtseriesOW')
+
+        # Let Orange process events (node creations)
+        cls.processOrangeEvents(cls)
+
+        # linking the workflow
+        cls.link(cls,
+                 cls.nodeDataWatcher, "data",
+                 cls.nodeAxis, "data")
+        cls.link(cls,
+                 cls.nodeAxis, "data",
+                 cls.nodeFTSerie, "data")
+
+        # Let Orange process events (node creations)
+        cls.processOrangeEvents(cls)
+
+        # getting the widgets
+        cls.datawatcherWidget = cls.getWidgetForNode(cls, cls.nodeDataWatcher)
+        cls.axisWidget = cls.getWidgetForNode(cls, cls.nodeAxis)
+        cls.ftserieWidget = cls.getWidgetForNode(cls, cls.nodeFTSerie)
+
+    @classmethod
+    def tearDownClass(cls):
+        for node in (cls.nodeAxis, cls.nodeFTSerie, cls.nodeDataWatcher):
+            cls.removeNode(cls, node)
+        cls.app.processEvents()
+        del cls.nodeFTSerie
+        del cls.nodeAxis
+        del cls.nodeDataWatcher
+        super().tearDownClass()
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.root_dir = tempfile.mkdtemp()
+        self.scan_1_path = tempfile.mkdtemp(dir=self.root_dir)
+        self.scan_2_path = tempfile.mkdtemp(dir=self.root_dir)
+        self.scan_3_path = tempfile.mkdtemp(dir=self.root_dir)
+        self.scan_dirs = [
+            self.scan_1_path,
+            self.scan_2_path,
+            self.scan_3_path,
+        ]
+
+        self.mocks = []
+        for scan_dir in self.scan_dirs:
+            mock = MockEDF(scan_path=scan_dir, n_radio=20, n_ini_radio=20)
+            assert os.path.exists(scan_dir)
+            self.mocks.append(mock)
+
+        # set up axis, ftseries and data watcher
+        self.datawatcherWidget.setFolderObserved(self.root_dir)
+        assert os.path.exists(self.root_dir)
+        self.axisWidget._axis_params.mode = 'manual'
+        self.ftserieWidget._ftserie.dry_run = True
+        # self.ftserieWidget._ftserie.reconsStack.dry_run = True
+        self.ftserieWidget.recons_params.axis.do_axis_correction = True
+        self.ftserieWidget.recons_params.axis.use_tomwer_axis = True
+        self.ftserieWidget.recons_params.axis.use_old_tomwer_axis = False
+
+        self.axisWidget._skip_exec(True)
+
+        # create listeners
+        self.axisListener = SignalListener()
+        self.ftseriesListener = SignalListener()
+
+        # signal / slot connection
+        self.axisWidget.sigScanReady.connect(self.axisListener)
+        self.ftserieWidget.sigScanReady.connect(self.ftseriesListener)
+
+    def tearDown(self) -> None:
+        shutil.rmtree(self.root_dir)
+        super().tearDown()
+
+    def testAxisConsequence(self):
+        """
+        scenario:
+        1. scan1 is detected, axis should wait for an answer, then the axis is
+           computed but not locked, ftseries should use the axis value computed.
+        2. scan2 is detected, axis should wait for an answer, then axis is
+           computed and lock this time, ftseries should use the axis value
+           computed.
+        3. scan3 is detected, it should pass directly through axis and the
+           cor value set and used by ftseries
+        """
+        assert os.path.exists(self.scan_1_path)
+        assert os.path.exists(self.scan_2_path)
+        assert os.path.exists(self.scan_3_path)
+
+        def _wait(timeout):
+            timeout = timeout - 0.1
+            self.app.processEvents()
+            self.processOrangeEventsStack()
+            time.sleep(0.1)
+            return timeout
+
+        def getCORFrmFile(file_path):
+            assert os.path.exists(file_path)
+            with open(file_path) as fd:
+                v = fd.readline()
+                try:
+                    v = float(v)
+                except:
+                    v = None
+                finally:
+                    return v
+
+        # 1.
+        self.datawatcherWidget.startObservation()
+        self.axisWidget._axis_params.value = 12.0
+        self.mocks[0].end_acquisition()
+
+        # wait until we can validate
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.axisWidget._n_skip == 0:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('axis never ended calculation')
+        validate_btn = self.axisWidget._widget._radioAxis._applyBut
+        validate_btn.click()
+
+        # wait until the axis windows expose (so scan should have been received)
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.axisListener.callCount() < 1:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('axis was never validated')
+
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.ftseriesListener.callCount() < 1:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('ftserie never ended recosntruction')
+
+        scan_1_correct_file = os.path.join(self.scan_1_path, 'correct.txt')
+        self.assertTrue(os.path.exists(scan_1_correct_file))
+        self.assertEqual(getCORFrmFile(scan_1_correct_file), 12.0)
+
+        # 2.
+        self.axisWidget._axis_params.value = -6.369
+        self.mocks[1].end_acquisition()
+
+        # wait until we can validate
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.axisWidget._n_skip == 1:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('axis never ended calculation')
+        validate_btn = self.axisWidget._widget._radioAxis._applyBut
+        validate_btn.click()
+
+        # wait until the axis windows expose (so scan should have been received)
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.axisListener.callCount() < 2:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('axis was never validated')
+
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.ftseriesListener.callCount() < 2:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('ftserie never ended recosntruction')
+        scan_2_correct_file = os.path.join(self.scan_2_path, 'correct.txt')
+        self.assertTrue(os.path.exists(scan_2_correct_file))
+        self.assertEqual(getCORFrmFile(scan_2_correct_file), -6.369)
+
+        # 3.
+        # lock the result
+        self.axisWidget._lock_axis_controls(True)
+        self.mocks[2].end_acquisition()
+
+        # wait until the axis windows expose (so scan should have been received)
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.axisListener.callCount() < 3:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('axis was never validated')
+
+        timeout = TIMEOUT_TEST
+        while timeout > 0 and self.ftseriesListener.callCount() < 3:
+            timeout = _wait(timeout)
+        if timeout < 0:
+            raise TimeoutError('ftserie never ended recosntruction')
+        scan_3_correct_file = os.path.join(self.scan_3_path, 'correct.txt')
+        self.assertTrue(os.path.exists(scan_3_correct_file))
+        self.assertEqual(getCORFrmFile(scan_3_correct_file), -6.369)
+
+
+def suite():
+    test_suite = unittest.TestSuite()
+    for ui in (TestAxisFtseries, ):
+        test_suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(ui))
+    return test_suite

users/payno/.local/share/virtualenvs/tomwer_venc/lib/python3.7/site-packages/orangecontrib/tomwer/test/test_dark_flat_field.py

@@ -27,78 +27,89 @@ __license__ = "MIT"
 __date__ = "09/02/2018"
 
 import logging
-import time
 import os
 import shutil
 import tempfile
+import time
 import unittest
+from glob import glob
+
+from orangecontrib.tomwer.test.utils import OrangeWorflowTest
 from tomwer.core import utils
-from tomwer.core.qtApplicationManager import QApplicationManager
+from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefs
 from tomwer.core.settings import mock_lsbram
-from tomwer.core.darkref.DarkRefs import DarkRefs
-from orangecontrib.tomwer.test.OrangeWorkflowTest import OrangeWorflowTest
 from tomwer.test.utils import UtilsTest
+from tomwer.test.utils import skip_gui_test
+from silx.gui.utils.testutils import SignalListener
 
 logging.disable(logging.INFO)
 
-app = QApplicationManager()
-
 
+@unittest.skipIf(skip_gui_test(), reason='skip gui test')
+@unittest.skip('Fail on CI')
 class TestConstructionDarkAndFlatField(OrangeWorflowTest):
     """
     test the workflow composed of the following widgets :
-        - TomoDirWidget
-        - RefCopy : Make sure the refCopy is correctly make
-        - DarkRefs : Make sure dark and flat field are skipped if already
-                     existing
+        - DataWatcherOW
+        - DarkRefsCopy : Make sure the refCopy is correctly make
     """
 
+    TIMEOUT = 20
+
     @classmethod
     def setUpClass(cls):
         OrangeWorflowTest.setUpClass()
         # create widgets
-        nodeTomodir = cls.addWidget(cls,
-                                    'orangecontrib.tomwer.widgets.TomoDirWidget.TomoDirWidget')
-        nodeDarkRefs = cls.addWidget(cls,
-                                     'orangecontrib.tomwer.widgets.DarkRefAndCopyWidget.DarkRefAndCopyOW')
-
+        cls.nodeDataWatcher = cls.addWidget(cls,
+                                            'orangecontrib.tomwer.widgets.control.DataWatcherOW.DataWatcherOW')
+        cls.nodeDarkRefs = cls.addWidget(cls,
+                                         'orangecontrib.tomwer.widgets.reconstruction.DarkRefAndCopyOW.DarkRefAndCopyOW')
+        cls.darkRefListener = SignalListener()
+        cls.datawatcherListener = SignalListener()
         # Let Orange process events (node creations)
         cls.processOrangeEvents(cls)
 
         # linking the workflow
-        cls.link(cls,
-                 nodeTomodir, "data",
-                 nodeDarkRefs, "data")
+        cls.link(cls, cls.nodeDataWatcher, "data", cls.nodeDarkRefs, "data")
 
         # Let Orange process events (node creations)
         cls.processOrangeEvents(cls)
 
         # getting the widgets
-        cls.tomodirWidget = cls.getWidgetForNode(cls, nodeTomodir)
-        cls.darkRefsWidget = cls.getWidgetForNode(cls, nodeDarkRefs)
+        cls.datawatcherWidget = cls.getWidgetForNode(cls, cls.nodeDataWatcher)
+        cls.darkRefsWidget = cls.getWidgetForNode(cls, cls.nodeDarkRefs)
 
         # set mock mode for FTSerieWidget
-        # set tomodir ready for observation
-        cls.tomodirWidget.displayAdvancement = False
+        # set data watcher ready for observation
+        cls.datawatcherWidget.displayAdvancement = False
         # force Dark ref to be sync
         cls.darkRefsWidget.setForceSync(True)
+        cls.darkRefsWidget.widget.sigScanReady.connect(cls.darkRefListener)
+        cls.datawatcherWidget._widget.sigScanReady.connect(cls.datawatcherListener)
 
     @classmethod
     def tearDownClass(cls):
-        del cls.tomodirWidget
+        for node in (cls.nodeDataWatcher, cls.nodeDarkRefs):
+            cls.removeNode(cls, node)
+        cls.app.processEvents()
+        del cls.datawatcherWidget
         del cls.darkRefsWidget
         OrangeWorflowTest.tearDownClass()
 
     def setUp(self):
+        OrangeWorflowTest.setUp(self)
+
         def prepareRefFolder():
             datasetID = 'test10'
             self.inputFolder = tempfile.mkdtemp()
             self.scanFolder = os.path.join(self.inputFolder, datasetID)
-            shutil.copytree(src=UtilsTest().getDataset(datasetID),
-                            dst=self.scanFolder)
+            self.copytree = shutil.copytree(
+                src=UtilsTest().getDataset(datasetID), dst=self.scanFolder)
+
+            [os.remove(f) for f in DarkRefs.getRefHSTFiles(self.scanFolder, prefix='refHST')]
+            [os.remove(f) for f in DarkRefs.getDarkHSTFiles(self.scanFolder, prefix='darkHST')]
 
-            [os.remove(f) for f in DarkRefs.getRefHSTFiles(self.scanFolder)]
-            [os.remove(f) for f in DarkRefs.getDarkHSTFiles(self.scanFolder)]
+        prepareRefFolder()
 
         def prepareScanToProcess():
             self._refParentFolder = tempfile.mkdtemp()
@@ -111,33 +122,63 @@ class TestConstructionDarkAndFlatField(OrangeWorflowTest):
                     src=os.path.join(self._refParentFolder, 'test01',
                                      'test01.info'),
                     dst=os.path.join(self.scanFolder, 'test10.info'))
+            assert len(glob(os.path.join(self.refFolder, 'refHST*'))) > 0
+            # dark file should be dark.edf and not darkHST.edf
+            dark_HST = os.path.join(self.refFolder, 'darkHST0000.edf')
+            if os.path.exists(dark_HST):
+                os.rename(dark_HST, os.path.join(self.refFolder, 'dark.edf'))
+            assert len(glob(os.path.join(self.refFolder, 'dark.edf'))) == 1
 
-        OrangeWorflowTest.setUp(self)
-        prepareRefFolder()
         prepareScanToProcess()
 
-        self.tomodirWidget.setFolderObserved(self.inputFolder)
-        self.darkRefsWidget.setSkipIfExisting(True)
+        self.datawatcherWidget.setFolderObserved(self.inputFolder)
+        self.darkRefsWidget.recons_params._set_skip_if_exist(True)
         self.darkRefsWidget.setRefsFromScan(self.refFolder)
         self.darkRefsWidget.setModeAuto(False)
         utils.mockLowMemory(False)
         mock_lsbram(True)
 
+        # reset listeners
+        self.darkRefListener.clear()
+        self.datawatcherListener.clear()
+
     def tearDown(self):
+        self.datawatcherWidget._widget.stop()
         shutil.rmtree(self._refParentFolder)
         shutil.rmtree(self.inputFolder)
         OrangeWorflowTest.tearDown(self)
 
     def testWorkflow(self):
-        self.tomodirWidget._widget.mockObservation(self.scanFolder)
+        assert not self.datawatcherWidget._widget.isObserving
+        self.datawatcherWidget.startObservation()
+        timeout = TestConstructionDarkAndFlatField.TIMEOUT
+        # wait until find the scan
+        while self.datawatcherListener.callCount() < 1 and timeout > 0:
+            self.app.processEvents()
+            timeout -= 0.2
+            time.sleep(0.2)
+
+        if timeout < 0:
+            raise TimeoutError("data watcher can't find any scan")
 
         # let dark ref process time to end
-        for _t in (1, 1):
-            app.processEvents()
-            time.sleep(_t)
-
-        self.assertTrue(len(DarkRefs.getDarkHSTFiles(self.scanFolder)) > 0)
-        self.assertTrue(len(DarkRefs.getRefHSTFiles(self.scanFolder)) > 0)
+        timeout = TestConstructionDarkAndFlatField.TIMEOUT
+        while(timeout > 0 and self.darkRefListener.callCount() < 1):
+            self.app.processEvents()
+            timeout -= 0.2
+            time.sleep(0.2)
+
+        self.app.processEvents()
+        if timeout < 0:
+            raise TimeoutError("darkef didn't process")
+
+        self.assertTrue(len(DarkRefs.getDarkHSTFiles(self.scanFolder, prefix='refHST')) > 0)
+        self.assertTrue(len(DarkRefs.getRefHSTFiles(self.scanFolder, prefix='dark.edf')) > 0)
+        while(self.app.hasPendingEvents()):
+            self.app.processEvents()
+
+        self.assertTrue(self.darkRefListener.callCount() == 1)
+        self.assertTrue(self.datawatcherListener.callCount() == 1)
 
 
 def suite():