Changeset 811bec1 in sasview

Timestamp:

Mar 17, 2017 2:22:23 AM (8 years ago)

Author:

Piotr Rozyczko <rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

4d457df

Parents:

cd31251

Message:

Started with unit tests for fitting widget SASVIEW-499

Location:

src/sas

Files:

• qtgui/GUITests.py (modified) (2 diffs)
• qtgui/GuiManager.py (modified) (1 diff)
• qtgui/Perspectives/Fitting/FittingPerspective.py (modified) (3 diffs)
• qtgui/Perspectives/Fitting/FittingWidget.py (modified) (7 diffs)
• qtgui/Perspectives/Fitting/UnitTesting/FittingPerspectiveTest.py (modified) (2 diffs, 1 prop)
• qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py (added)
• sasgui/perspectives/fitting/fitting.py (modified) (1 diff, 1 prop)

src/sas/qtgui/GUITests.py

@@ -28 +28 @@
 from UnitTesting import SlicerParametersTest
 
+# Perspectives
+import path_prepare
+from Perspectives.Fitting.UnitTesting import FittingWidgetTest
+from Perspectives.Fitting.UnitTesting import FittingPerspectiveTest
+
+
 def suite():
     suites = (
@@ -56 +62 @@
         unittest.makeSuite(SlicerModelTest.SlicerModelTest, 'test'),
         unittest.makeSuite(SlicerParametersTest.SlicerParametersTest, 'test'),
+        unittest.makeSuite(FittingPerspectiveTest.FittingPerspectiveTest, 'test'),
+        unittest.makeSuite(FittingWidgetTest.FittingWidgetTest, 'test'),
     )
     return unittest.TestSuite(suites)

src/sas/qtgui/GuiManager.py

@@ -182 +182 @@
             self._current_perspective.close()
         # Default perspective
-        self._current_perspective = Perspectives.PERSPECTIVES[str(perspective_name)](manager=self, parent=self)
+        self._current_perspective = Perspectives.PERSPECTIVES[str(perspective_name)](parent=self)
         self._workspace.workspace.addWindow(self._current_perspective)
         self._current_perspective.show()

src/sas/qtgui/Perspectives/Fitting/FittingPerspective.py

@@ -13 +13 @@
     """
     name = "Fitting" # For displaying in the combo box in DataExplorer
-    def __init__(self, manager=None, parent=None, data=None):
+    def __init__(self, parent=None, data=None):
         super(FittingWindow, self).__init__()
 
-        self.manager = manager
         self.parent = parent
         self._data = data
@@ -35 +34 @@
         self.setTabsClosable(True)
 
+        self.communicate = self.parent.communicator()
+
         # Initialize the first tab
         self.addFit(None)
@@ -43 +44 @@
         self.setWindowTitle('Fit panel - Active Fitting Optimizer: %s' % self.optimizer)
 
-        #self.communicate = GuiUtils.Communicate()
-        self.communicate = self.parent.communicator()
-
     def addFit(self, data):
         """
         Add a new tab for passed data
         """
-        tab     = FittingWidget(manager=self.manager, parent=self.parent, data=data, id=self.maxIndex+1)
+        tab     = FittingWidget(parent=self.parent, data=data, id=self.maxIndex+1)
         self.tabs.append(tab)
         self.maxIndex += 1

src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

@@ -38 +38 @@
     Main widget for selecting form and structure factor models
     """
-    def __init__(self, manager=None, parent=None, data=None, id=1):
-        """
-
-        :param manager:
-        :param parent:
-        :return:
-        """
+    def __init__(self, parent=None, data=None, id=1):
+
         super(FittingWidget, self).__init__()
 
@@ -69 +64 @@
         self.tab_id = id
 
-        # Parameters
+        # Range parameters
         self.q_range_min = QMIN_DEFAULT
         self.q_range_max = QMAX_DEFAULT
         self.npts = NPTS_DEFAULT
+
         # Main Data[12]D holder
         self._data = None
@@ -88 +84 @@
         self._magnet_model = QtGui.QStandardItemModel()
 
-        # Set the proxy models for display
-        #   Main display
-        self._model_proxy = QtGui.QSortFilterProxyModel()
-        self._model_proxy.setSourceModel(self._model_model)
-        #self._model_proxy.setFilterRegExp(r"[^()]")
-
-        #   Proxy display
-        self._poly_proxy = QtGui.QSortFilterProxyModel()
-        self._poly_proxy.setSourceModel(self._poly_model)
-        self._poly_proxy.setFilterRegExp(r"[^()]")
-
-        #   Magnetism display
-        self._magnet_proxy = QtGui.QSortFilterProxyModel()
-        self._magnet_proxy.setSourceModel(self._magnet_model)
-        #self._magnet_proxy.setFilterRegExp(r"[^()]")
-
         # Param model displayed in param list
         self.lstParams.setModel(self._model_model)
-        #self.lstParams.setModel(self._model_proxy)
         self.readCategoryInfo()
         self.model_parameters = None
@@ -112 +91 @@
 
         # Poly model displayed in poly list
-        self.lstPoly.setModel(self._poly_proxy)
+        self.lstPoly.setModel(self._poly_model)
         self.setPolyModel()
         self.setTableProperties(self.lstPoly)
@@ -251 +230 @@
         structure_factors = ["None"]
         self.cbStructureFactor.clear()
-        for (structure_factor, _) in structure_factor_list:
-            structure_factors.append(structure_factor)
+        structure_factors = [factor[0] for factor in structure_factor_list]
         self.cbStructureFactor.addItems(sorted(structure_factors))
 
@@ -365 +343 @@
         If so, returns the name of the counter parameter and the number of shells
         """
-        iter_param = ""
-        iter_length = 0
-
         iter_params = self.getIterParams(model)
-        # pull out the iterator parameter name and length
-        if iter_params:
-            iter_length = iter_params[0].length
-            iter_param = iter_params[0].length_control
-        return (iter_param, iter_length)
+        # return the iterator parameter name and length
+        return (iter_params[0].length_control if iter_params else "",
+                iter_params[0].length if iter_params else 0)
 
     def addBackgroundToModel(self, model):
@@ -392 +365 @@
 
     def addCheckedListToModel(self, model, param_list):
+        """
+        Add a QItem to model. Makes the QItem checkable
+        """
         assert isinstance(model, QtGui.QStandardItemModel)
         item_list = [QtGui.QStandardItem(item) for item in param_list]

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingPerspectiveTest.py

@@ -1 +1 @@
 import sys
 import unittest
+import webbrowser
 
 from PyQt4 import QtGui
@@ -7 +8 @@
 from mock import MagicMock
 
+# set up import paths
+import sas.qtgui.path_prepare
+
 # Local
-from FittingPerspective import FittingWindow
+import sas.qtgui.GuiUtils as GuiUtils
+from sas.sasgui.guiframe.dataFitting import Data1D
+
+from sas.qtgui.Perspectives.Fitting.FittingPerspective import FittingWindow
 
 app = QtGui.QApplication(sys.argv)
 
 class FittingPerspectiveTest(unittest.TestCase):
-    """Test the Main Window GUI"""
+    '''Test the Fitting Perspective'''
     def setUp(self):
-        """Create the GUI"""
+        class dummy_manager(object):
+            def communicator(self):
+                return GuiUtils.Communicate()
+            def communicate(self):
+                return GuiUtils.Communicate()
 
-        self.widget = FittingWindow(None)
+        '''Create the perspective'''
+        self.widget = FittingWindow(dummy_manager())
 
     def tearDown(self):
-        """Destroy the GUI"""
+        '''Destroy the perspective'''
         self.widget.close()
         self.widget = None
 
     def testDefaults(self):
-        """Test the GUI in its default state"""
+        '''Test the GUI in its default state'''
         self.assertIsInstance(self.widget, QtGui.QWidget)
-        self.assertEqual(self.widget.windowTitle(), "Fitting")
-        self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed)
+        self.assertIn("Fit panel", self.widget.windowTitle())
+        self.assertEqual(self.widget.optimizer, "DREAM")
+        self.assertEqual(len(self.widget.tabs), 1)
+        self.assertEqual(self.widget.maxIndex, 1)
+        self.assertEqual(self.widget.tabName(), "FitPage1")
 
-    def testSelectCategory(self):
-        """
-        Test if categories have been load properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+    def testAddTab(self):
+        '''Add a tab and test it'''
 
-        #Test loading from json categories
-        category_list = fittingWindow.master_category_dict.keys()
-        self.assertTrue("Cylinder" in category_list)
-        self.assertTrue("Ellipsoid" in category_list)
-        self.assertTrue("Lamellae" in category_list)
-        self.assertTrue("Paracrystal" in category_list)
-        self.assertTrue("Parallelepiped" in category_list)
-        self.assertTrue("Shape Independent" in category_list)
-        self.assertTrue("Sphere" in category_list)
+        # Add an empty tab
+        self.widget.addFit(None)
+        self.assertEqual(len(self.widget.tabs), 2)
+        self.assertEqual(self.widget.tabName(), "FitPage2")
+        self.assertEqual(self.widget.maxIndex, 2)
 
-        #Test for existence in combobox
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Ellipsoid"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Lamellae"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Paracrystal"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Parallelepiped"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Shape Independent"),-1)
-        self.assertNotEqual(fittingWindow.cbCategory.findText("Sphere"),-1)
+    def testCloseTab(self):
+        '''Delete a tab and test'''
+        # Add an empty tab
+        self.widget.addFit(None)
 
-        #Test what is current text in the combobox
-        self.assertTrue(fittingWindow.cbCategory.currentText(), "Cylinder")
+        # Remove the original tab
+        self.widget.tabCloses(1)
+        self.assertEqual(len(self.widget.tabs), 1)
+        self.assertEqual(self.widget.maxIndex, 2)
+        self.assertEqual(self.widget.tabName(), "FitPage2")
 
-    def testSelectModel(self):
-        """
-        Test if models have been loaded properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+        # Attemtp to remove the last tab
+        self.widget.tabCloses(1)
+        # The tab should still be there
+        self.assertEqual(len(self.widget.tabs), 1)
+        self.assertEqual(self.widget.maxIndex, 2)
+        self.assertEqual(self.widget.tabName(), "FitPage2")
 
-        #Test loading from json categories
-        model_list = fittingWindow.master_category_dict["Cylinder"]
-        self.assertTrue(['cylinder', True] in model_list)
-        self.assertTrue(['core_shell_cylinder', True] in model_list)
-        self.assertTrue(['barbell', True] in model_list)
-        self.assertTrue(['core_shell_bicelle', True] in model_list)
-        self.assertTrue(['flexible_cylinder', True] in model_list)
-        self.assertTrue(['flexible_cylinder_elliptical', True] in model_list)
-        self.assertTrue(['pearl_necklace', True] in model_list)
-        self.assertTrue(['capped_cylinder', True] in model_list)
-        self.assertTrue(['elliptical_cylinder', True] in model_list)
-        self.assertTrue(['pringle', True] in model_list)
-        self.assertTrue(['hollow_cylinder', True] in model_list)
-        self.assertTrue(['core_shell_bicelle_elliptical', True] in model_list)
-        self.assertTrue(['stacked_disks', True] in model_list)
+    def testAllowBatch(self):
+        '''Assure the perspective allows multiple datasets'''
+        self.assertTrue(self.widget.allowBatch())
 
-        #Test for existence in combobox
-        self.assertNotEqual(fittingWindow.cbModel.findText("cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("barbell"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_bicelle"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("flexible_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("flexible_cylinder_elliptical"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("pearl_necklace"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("capped_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("elliptical_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("pringle"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("hollow_cylinder"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("core_shell_bicelle_elliptical"),-1)
-        self.assertNotEqual(fittingWindow.cbModel.findText("stacked_disks"),-1)
+    def testSetData(self):
+        ''' Assure that setting data is correct'''
+        with self.assertRaises(AssertionError):
+            self.widget.setData(None)
 
+        with self.assertRaises(AttributeError):
+            self.widget.setData("BOOP")
 
-    def testSelectPolydispersity(self):
-        """
-        Test if models have been loaded properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+        # Mock the datafromitem() call from FittingWidget
+        data = Data1D(x=[1,2], y=[1,2])
+        GuiUtils.dataFromItem = MagicMock(return_value=data)
 
-        #Test loading from json categories
-        fittingWindow.setModelModel("cylinder")
-        pd_index = fittingWindow.tableView_2.model().index(0,0)
-        self.assertEqual(str(pd_index.data().toString()), "Distribution of radius")
-        pd_index = fittingWindow.tableView_2.model().index(1,0)
-        self.assertEqual(str(pd_index.data().toString()), "Distribution of length")
+        item = QtGui.QStandardItem("test")
+        self.widget.setData([item])
 
-    def testSelectStructureFactor(self):
-        """
-        Test if structure factors have been loaded properly
-        :return:
-        """
-        fittingWindow =  FittingWindow(None)
+        # Look at the data in tab
+        self.assertEqual(self.widget._model_item, item)
 
-        #Test for existence in combobox
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("stickyhardsphere"),-1)
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("hayter_msa"),-1)
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("squarewell"),-1)
-        self.assertNotEqual(fittingWindow.cbStructureFactor.findText("hardsphere"),-1)
+        # First tab should accept data
+        self.assertEqual(len(self.widget.tabs), 1)
 
-        #Test what is current text in the combobox
-        self.assertTrue(fittingWindow.cbCategory.currentText(), "None")
+        # Add another set of data
+        self.widget.setData([item])
+
+        # Now we should have two tabs
+        self.assertEqual(len(self.widget.tabs), 2)
+
 
 if __name__ == "__main__":

src/sas/sasgui/perspectives/fitting/fitting.py

@@ -41 +41 @@
 from sas.sasgui.perspectives.fitting.pagestate import Reader
 from sas.sasgui.perspectives.fitting.fitpage import Chi2UpdateEvent
-from sas.sasgui.perspectives.calculator.model_editor import TextDialog
-from sas.sasgui.perspectives.calculator.model_editor import EditorWindow
+#from sas.sasgui.perspectives.calculator.model_editor import TextDialog
+#from sas.sasgui.perspectives.calculator.model_editor import EditorWindow
 from sas.sasgui.guiframe.gui_manager import MDIFrame
 from sas.sasgui.guiframe.documentation_window import DocumentationWindow