Ignore:
Timestamp:
Mar 16, 2018 2:05:42 PM (7 years ago)
Author:
krzywon
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:
47bf906
Parents:
477c473 (diff), e4c475b7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'ESS_GUI' into ESS_GUI_Pr

Location:
src/sas/qtgui/Perspectives/Fitting/UnitTesting
Files:
3 added
5 edited

Legend:

Unmodified
Added
Removed

  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingLogicTest.py

    r464cd07 r53c771e  
    33 
    44import numpy 
    5 from mock import MagicMock 
     5from unittest.mock import MagicMock 
    66 
    77# set up import paths 
    … …  
    1212from sas.qtgui.Perspectives.Fitting.FittingWidget import * 
    1313from sas.qtgui.Plotting.PlotterData import Data1D 
    14  
    15 if not QtGui.QApplication.instance(): 
    16     app = QtGui.QApplication(sys.argv) 
    1714 
    1815 

  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingOptionsTest.py

    r464cd07 r725d9c06  
    11import sys 
    22import unittest 
     3import webbrowser 
    34from bumps import options 
    45 
    5 from PyQt4 import QtGui 
    6 from PyQt4 import QtWebKit 
     6from PyQt5 import QtGui, QtWidgets 
    77 
    8 from mock import MagicMock 
     8from unittest.mock import MagicMock 
    99 
    1010# set up import paths 
    … …  
    1616from sas.qtgui.Perspectives.Fitting.FittingOptions import FittingOptions 
    1717 
    18 if not QtGui.QApplication.instance(): 
    19     app = QtGui.QApplication(sys.argv) 
     18if not QtWidgets.QApplication.instance(): 
     19    app = QtWidgets.QApplication(sys.argv) 
    2020 
    2121class FittingOptionsTest(unittest.TestCase): 
    … …  
    3232    def testDefaults(self): 
    3333        '''Test the GUI in its default state''' 
    34         self.assertIsInstance(self.widget, QtGui.QDialog) 
     34        self.assertIsInstance(self.widget, QtWidgets.QDialog) 
    3535        # Default title 
    3636        self.assertEqual(self.widget.windowTitle(), "Fit Algorithms") 
    3737 
    3838        # The combo box 
    39         self.assertIsInstance(self.widget.cbAlgorithm, QtGui.QComboBox) 
     39        self.assertIsInstance(self.widget.cbAlgorithm, QtWidgets.QComboBox) 
    4040        self.assertEqual(self.widget.cbAlgorithm.count(), 5) 
    4141        self.assertEqual(self.widget.cbAlgorithm.itemText(0), 'Nelder-Mead Simplex') 
    … …  
    7575        self.widget.steps_de.setText("1") 
    7676        # This should enable the OK button 
    77         self.assertTrue(self.widget.buttonBox.button(QtGui.QDialogButtonBox.Ok).isEnabled()) 
     77        self.assertTrue(self.widget.buttonBox.button(QtWidgets.QDialogButtonBox.Ok).isEnabled()) 
    7878 
    7979    def testOnAlgorithmChange(self): 
    … …  
    113113        self.assertEqual(options.FIT_CONFIG.values['dream']['init'], 'cov') 
    114114 
     115    # test disabled until pyQt5 works well 
    115116    def testOnHelp(self): 
    116117        ''' Test help display''' 
    117         #Mock the QWebView method 
    118         QtWebKit.QWebView.show = MagicMock() 
    119         QtWebKit.QWebView.load = MagicMock() 
     118        webbrowser.open = MagicMock() 
    120119 
    121120        # Invoke the action on default tab 
    122121        self.widget.onHelp() 
    123122        # Check if show() got called 
    124         self.assertTrue(QtWebKit.QWebView.show.called) 
     123        self.assertTrue(webbrowser.open.called) 
    125124        # Assure the filename is correct 
    126         self.assertIn("optimizer.html", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     125        self.assertIn("optimizer.html", webbrowser.open.call_args[0][0]) 
    127126 
    128127        # Change the combo index 
    … …  
    130129        self.widget.onHelp() 
    131130        # Check if show() got called 
    132         self.assertEqual(QtWebKit.QWebView.show.call_count, 2) 
     131        self.assertEqual(webbrowser.open.call_count, 2) 
    133132        # Assure the filename is correct 
    134         self.assertIn("fit-dream", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     133        self.assertIn("fit-dream", webbrowser.open.call_args[0][0]) 
    135134 
    136135        # Change the index again 
    … …  
    138137        self.widget.onHelp() 
    139138        # Check if show() got called 
    140         self.assertEqual(QtWebKit.QWebView.show.call_count, 3) 
     139        self.assertEqual(webbrowser.open.call_count, 3) 
    141140        # Assure the filename is correct 
    142         self.assertIn("fit-lm", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     141        self.assertIn("fit-lm", webbrowser.open.call_args[0][0]) 
    143142 
    144143    def testWidgetFromOptions(self): 
    … …  
    148147        # test silly call 
    149148        self.assertIsNone(self.widget.widgetFromOption('poop')) 
    150         self.assertIsNone(self.widget.widgetFromOption(QtGui.QMainWindow())) 
     149        self.assertIsNone(self.widget.widgetFromOption(QtWidgets.QMainWindow())) 
    151150 
    152151        # Switch to DREAM 
    153152        self.widget.cbAlgorithm.setCurrentIndex(2) 
    154153        # test smart call 
    155         self.assertIsInstance(self.widget.widgetFromOption('samples'), QtGui.QLineEdit) 
    156         self.assertIsInstance(self.widget.widgetFromOption('init'), QtGui.QComboBox) 
     154        self.assertIsInstance(self.widget.widgetFromOption('samples'), QtWidgets.QLineEdit) 
     155        self.assertIsInstance(self.widget.widgetFromOption('init'), QtWidgets.QComboBox) 
    157156 
    158157    def testUpdateWidgetFromBumps(self): 

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

    r464cd07 r63319b0  
    33import webbrowser 
    44 
    5 from PyQt4 import QtGui 
    6 from PyQt4 import QtTest 
    7 from PyQt4 import QtCore 
    8 from mock import MagicMock 
     5from PyQt5 import QtGui 
     6from PyQt5 import QtWidgets 
     7from PyQt5 import QtTest 
     8from PyQt5 import QtCore 
     9from unittest.mock import MagicMock 
    910 
    1011# set up import paths 
    … …  
    1617from sas.qtgui.Perspectives.Fitting.FittingPerspective import FittingWindow 
    1718 
    18 if not QtGui.QApplication.instance(): 
    19     app = QtGui.QApplication(sys.argv) 
     19if not QtWidgets.QApplication.instance(): 
     20    app = QtWidgets.QApplication(sys.argv) 
     21 
    2022 
    2123class FittingPerspectiveTest(unittest.TestCase): 
    … …  
    3840    def testDefaults(self): 
    3941        '''Test the GUI in its default state''' 
    40         self.assertIsInstance(self.widget, QtGui.QWidget) 
     42        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    4143        self.assertIn("Fit panel", self.widget.windowTitle()) 
    4244        self.assertEqual(self.widget.optimizer, "Levenberg-Marquardt") 
    4345        self.assertEqual(len(self.widget.tabs), 1) 
    4446        self.assertEqual(self.widget.maxIndex, 1) 
    45         self.assertEqual(self.widget.tabName(), "FitPage1") 
     47        self.assertEqual(self.widget.maxCSIndex, 0) 
     48        self.assertEqual(self.widget.getTabName(), "FitPage1") 
    4649 
    4750    def testAddTab(self): 
    … …  
    5154        self.widget.addFit(None) 
    5255        self.assertEqual(len(self.widget.tabs), 2) 
    53         self.assertEqual(self.widget.tabName(), "FitPage2") 
     56        self.assertEqual(self.widget.getTabName(), "FitPage2") 
    5457        self.assertEqual(self.widget.maxIndex, 2) 
    5558        # Add an empty batch tab 
    5659        self.widget.addFit(None, is_batch=True) 
    5760        self.assertEqual(len(self.widget.tabs), 3) 
    58         self.assertEqual(self.widget.tabName(2), "BatchPage3") 
     61        self.assertEqual(self.widget.getTabName(2), "BatchPage3") 
    5962        self.assertEqual(self.widget.maxIndex, 3) 
     63 
     64    def testAddCSTab(self): 
     65        ''' Add a constraint/simult tab''' 
     66        self.widget.addConstraintTab() 
     67        self.assertEqual(len(self.widget.tabs), 2) 
     68        self.assertEqual(self.widget.getCSTabName(), "Const. & Simul. Fit1") 
     69        self.assertEqual(self.widget.maxCSIndex, 1) 
    6070 
    6171    def testResetTab(self): 
    6272        ''' Remove data from last tab''' 
    6373        self.assertEqual(len(self.widget.tabs), 1) 
    64         self.assertEqual(self.widget.tabName(), "FitPage1") 
     74        self.assertEqual(self.widget.getTabName(), "FitPage1") 
    6575        self.assertEqual(self.widget.maxIndex, 1) 
    6676 
    … …  
    7080        # see that the tab didn't disappear, just changed the name/id 
    7181        self.assertEqual(len(self.widget.tabs), 1) 
    72         self.assertEqual(self.widget.tabName(), "FitPage2") 
     82        self.assertEqual(self.widget.getTabName(), "FitPage2") 
    7383        self.assertEqual(self.widget.maxIndex, 2) 
    7484 
    … …  
    94104        self.assertEqual(len(self.widget.tabs), 1) 
    95105        self.assertEqual(self.widget.maxIndex, 2) 
    96         self.assertEqual(self.widget.tabName(), "FitPage2") 
     106        self.assertEqual(self.widget.getTabName(), "FitPage2") 
    97107 
    98108        # Attemtp to remove the last tab 
    … …  
    101111        self.assertEqual(len(self.widget.tabs), 1) 
    102112        self.assertEqual(self.widget.maxIndex, 3) 
    103         self.assertEqual(self.widget.tabName(), "FitPage3") 
     113        self.assertEqual(self.widget.getTabName(), "FitPage3") 
    104114 
    105115    def testAllowBatch(self): 
    … …  
    137147        self.assertEqual(len(self.widget.tabs), 4) 
    138148 
     149    def testSetBatchData(self): 
     150        ''' Assure that setting batch data is correct''' 
     151 
     152        # Mock the datafromitem() call from FittingWidget 
     153        data1 = Data1D(x=[1,2], y=[1,2]) 
     154        data2 = Data1D(x=[1,2], y=[1,2]) 
     155        data_batch = [data1, data2] 
     156        GuiUtils.dataFromItem = MagicMock(return_value=data1) 
     157 
     158        item = QtGui.QStandardItem("test") 
     159        self.widget.setData([item, item], is_batch=True) 
     160 
     161        # First tab should not accept data 
     162        self.assertEqual(len(self.widget.tabs), 2) 
     163 
     164        # Add another set of data 
     165        self.widget.setData([item, item], is_batch=True) 
     166 
     167        # Now we should have two batch tabs 
     168        self.assertEqual(len(self.widget.tabs), 3) 
     169 
     170        # Check the names of the new tabs 
     171        self.assertEqual(self.widget.tabText(1), "BatchPage1") 
     172        self.assertEqual(self.widget.tabText(2), "BatchPage2") 
    139173 
    140174if __name__ == "__main__": 

  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingUtilitiesTest.py

    • Property mode changed from 100755 to 100644
    r06b0138 rfde5bcd  
    11import sys 
    22import unittest 
    3 from PyQt4 import QtGui 
     3from PyQt5 import QtGui, QtCore 
    44 
    55from sas.qtgui.Plotting.PlotterData import Data1D 
    … …  
    266266            chi = FittingUtilities.calculateChi2(reference_data, current_data) 
    267267 
     268    def notestAddHeadersToModel(self): 
     269        '''Check to see if headers are correctly applied''' 
     270        #test model 
     271        model = QtGui.QStandardItemModel() 
     272        FittingUtilities.addHeadersToModel(model) 
     273 
     274        # Assure we have properly named columns 
     275        names = FittingUtilities.model_header_captions 
     276        names_from_model = [model.headerData(i, QtCore.Qt.Horizontal) for i in range(len(names))] 
     277        self.assertEqual(names, names_from_model) 
     278 
     279        # Add another model 
     280        model2 = QtGui.QStandardItemModel() 
     281        # Add headers again 
     282        FittingUtilities.addHeadersToModel(model2) 
     283        # We still should have only the original names 
     284        names_from_model2 = [model2.headerData(i, QtCore.Qt.Horizontal) for i in range(len(names))] 
     285        self.assertEqual(names, names_from_model2) 
     286 
     287 
    268288if __name__ == "__main__": 
    269289    unittest.main() 

  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py

    r9ea43c82 r14ec91c5  
    22import unittest 
    33import time 
    4  
    5 from PyQt4 import QtGui 
    6 from PyQt4 import QtTest 
    7 from PyQt4 import QtCore 
    8 from mock import MagicMock 
     4import logging 
     5 
     6from PyQt5 import QtGui 
     7from PyQt5 import QtWidgets 
     8from PyQt5 import QtTest 
     9from PyQt5 import QtCore 
     10from unittest.mock import MagicMock 
    911from twisted.internet import threads 
    1012 
    … …  
    1517from sas.qtgui.Utilities.GuiUtils import * 
    1618from sas.qtgui.Perspectives.Fitting.FittingWidget import * 
     19from sas.qtgui.Perspectives.Fitting.Constraint import Constraint 
     20 
    1721from sas.qtgui.UnitTesting.TestUtils import QtSignalSpy 
    1822 
    … …  
    2024from sas.qtgui.Plotting.PlotterData import Data2D 
    2125 
    22 #if not QtGui.QApplication.instance(): 
    23 app = QtGui.QApplication(sys.argv) 
     26if not QtWidgets.QApplication.instance(): 
     27    app = QtWidgets.QApplication(sys.argv) 
    2428 
    2529class dummy_manager(object): 
    … …  
    4145    def testDefaults(self): 
    4246        """Test the GUI in its default state""" 
    43         self.assertIsInstance(self.widget, QtGui.QWidget) 
     47        self.assertIsInstance(self.widget, QtWidgets.QWidget) 
    4448        self.assertEqual(self.widget.windowTitle(), "Fitting") 
    45         self.assertEqual(self.widget.sizePolicy().Policy(), QtGui.QSizePolicy.Fixed) 
     49        self.assertEqual(self.widget.sizePolicy().Policy(), QtWidgets.QSizePolicy.Fixed) 
    4650        self.assertIsInstance(self.widget.lstParams.model(), QtGui.QStandardItemModel) 
    4751        self.assertIsInstance(self.widget.lstPoly.model(), QtGui.QStandardItemModel) 
    … …  
    6064 
    6165        #Test loading from json categories 
    62         category_list = fittingWindow.master_category_dict.keys() 
     66        category_list = list(fittingWindow.master_category_dict.keys()) 
    6367 
    6468        for category in category_list: 
    … …  
    8993        fittingWindow =  self.widget 
    9094 
    91         self.assertIsInstance(fittingWindow.lstPoly.itemDelegate(), QtGui.QStyledItemDelegate) 
     95        self.assertIsInstance(fittingWindow.lstPoly.itemDelegate(), QtWidgets.QStyledItemDelegate) 
    9296        #Test loading from json categories 
    9397        fittingWindow.SASModelToQModel("cylinder") 
    9498        pd_index = fittingWindow.lstPoly.model().index(0,0) 
    95         self.assertEqual(str(pd_index.data().toString()), "Distribution of radius") 
     99        self.assertEqual(str(pd_index.data()), "Distribution of radius") 
    96100        pd_index = fittingWindow.lstPoly.model().index(1,0) 
    97         self.assertEqual(str(pd_index.data().toString()), "Distribution of length") 
     101        self.assertEqual(str(pd_index.data()), "Distribution of length") 
    98102 
    99103        # test the delegate a bit 
    … …  
    110114        fittingWindow =  self.widget 
    111115 
    112         self.assertIsInstance(fittingWindow.lstMagnetic.itemDelegate(), QtGui.QStyledItemDelegate) 
     116        self.assertIsInstance(fittingWindow.lstMagnetic.itemDelegate(), QtWidgets.QStyledItemDelegate) 
    113117        #Test loading from json categories 
    114118        fittingWindow.SASModelToQModel("cylinder") 
    115119        mag_index = fittingWindow.lstMagnetic.model().index(0,0) 
    116         self.assertEqual(str(mag_index.data().toString()), "up:frac_i") 
     120        self.assertEqual(mag_index.data(), "up:frac_i") 
    117121        mag_index = fittingWindow.lstMagnetic.model().index(1,0) 
    118         self.assertEqual(str(mag_index.data().toString()), "up:frac_f") 
     122        self.assertEqual(mag_index.data(), "up:frac_f") 
    119123        mag_index = fittingWindow.lstMagnetic.model().index(2,0) 
    120         self.assertEqual(str(mag_index.data().toString()), "up:angle") 
     124        self.assertEqual(mag_index.data(), "up:angle") 
    121125        mag_index = fittingWindow.lstMagnetic.model().index(3,0) 
    122         self.assertEqual(str(mag_index.data().toString()), "M0:sld") 
     126        self.assertEqual(mag_index.data(), "M0:sld") 
    123127        mag_index = fittingWindow.lstMagnetic.model().index(4,0) 
    124         self.assertEqual(str(mag_index.data().toString()), "mtheta:sld") 
     128        self.assertEqual(mag_index.data(), "mtheta:sld") 
    125129        mag_index = fittingWindow.lstMagnetic.model().index(5,0) 
    126         self.assertEqual(str(mag_index.data().toString()), "mphi:sld") 
     130        self.assertEqual(mag_index.data(), "mphi:sld") 
    127131        mag_index = fittingWindow.lstMagnetic.model().index(6,0) 
    128         self.assertEqual(str(mag_index.data().toString()), "M0:sld_solvent") 
     132        self.assertEqual(mag_index.data(), "M0:sld_solvent") 
    129133        mag_index = fittingWindow.lstMagnetic.model().index(7,0) 
    130         self.assertEqual(str(mag_index.data().toString()), "mtheta:sld_solvent") 
     134        self.assertEqual(mag_index.data(), "mtheta:sld_solvent") 
    131135        mag_index = fittingWindow.lstMagnetic.model().index(8,0) 
    132         self.assertEqual(str(mag_index.data().toString()), "mphi:sld_solvent") 
     136        self.assertEqual(mag_index.data(), "mphi:sld_solvent") 
    133137 
    134138        # test the delegate a bit 
    135139        delegate = fittingWindow.lstMagnetic.itemDelegate() 
    136140        self.assertEqual(delegate.editableParameters(), [1, 2, 3]) 
    137         self.assertIsInstance(delegate.combo_updated, QtCore.pyqtBoundSignal) 
    138141 
    139142    def testSelectStructureFactor(self): 
    … …  
    394397 
    395398        # Test presence of comboboxes in last column 
    396         for row in xrange(self.widget._poly_model.rowCount()): 
     399        for row in range(self.widget._poly_model.rowCount()): 
    397400            func_index = self.widget._poly_model.index(row, 6) 
    398             self.assertTrue(isinstance(self.widget.lstPoly.indexWidget(func_index), QtGui.QComboBox)) 
     401            self.assertTrue(isinstance(self.widget.lstPoly.indexWidget(func_index), QtWidgets.QComboBox)) 
    399402            self.assertIn('Distribution of', self.widget._poly_model.item(row, 0).text()) 
    400403        #self.widget.close() 
    … …  
    462465        # check values 
    463466        self.assertEqual(self.widget.kernel_module.getParam('radius_bell.npts'), 35) 
    464         self.assertEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 1.70325) 
     467        self.assertAlmostEqual(self.widget.kernel_module.getParam('radius_bell.nsigmas'), 1.70325, 5) 
    465468        # Change the index 
    466469        self.widget.onPolyComboIndexChange('lognormal', 0) 
    … …  
    486489        """ 
    487490        filename = os.path.join("UnitTesting", "testdata_noexist.txt") 
    488         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     491        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=(filename,'')) 
    489492        self.widget.show() 
    490493        # Change the category index so we have a model with polydisp 
    … …  
    500503        # good file 
    501504        filename = os.path.join("UnitTesting", "testdata.txt") 
    502         QtGui.QFileDialog.getOpenFileName = MagicMock(return_value=filename) 
     505        QtWidgets.QFileDialog.getOpenFileName = MagicMock(return_value=(filename,'')) 
    503506 
    504507        self.widget.onPolyComboIndexChange('array', 0) 
    … …  
    542545 
    543546        # Test rows 
    544         for row in xrange(self.widget._magnet_model.rowCount()): 
     547        for row in range(self.widget._magnet_model.rowCount()): 
    545548            func_index = self.widget._magnet_model.index(row, 0) 
    546549            self.assertIn(':', self.widget._magnet_model.item(row, 0).text()) 
    … …  
    567570        last_row = self.widget._last_model_row 
    568571        func_index = self.widget._model_model.index(last_row-1, 1) 
    569         self.assertIsInstance(self.widget.lstParams.indexWidget(func_index), QtGui.QComboBox) 
     572        self.assertIsInstance(self.widget.lstParams.indexWidget(func_index), QtWidgets.QComboBox) 
    570573 
    571574        # Change the combo box index 
    … …  
    653656        self.assertEqual(spy.count(), 1) 
    654657 
    655     def testOnFit1D(self): 
    656         """ 
    657         Test the threaded fitting call 
     658    def testOnEmptyFit(self): 
     659        """ 
     660        Test a 1D/2D fit with no parameters 
    658661        """ 
    659662        # Set data 
    660663        test_data = Data1D(x=[1,2], y=[1,2]) 
    661664        item = QtGui.QStandardItem() 
    662         updateModelItem(item, [test_data], "test") 
     665        updateModelItem(item, test_data, "test") 
    663666        # Force same data into logic 
    664667        self.widget.data = item 
    … …  
    671674        self.widget.parameters_to_fit = [] 
    672675 
    673         with self.assertRaises(ValueError) as error: 
    674             self.widget.onFit() 
    675         self.assertEqual(str(error.exception), 'no fitting parameters') 
     676        logging.error = MagicMock() 
     677 
     678        self.widget.onFit() 
     679        self.assertTrue(logging.error.called_with('no fitting parameters')) 
     680        self.widget.close() 
     681 
     682        test_data = Data2D(image=[1.0, 2.0, 3.0], 
     683                           err_image=[0.01, 0.02, 0.03], 
     684                           qx_data=[0.1, 0.2, 0.3], 
     685                           qy_data=[0.1, 0.2, 0.3], 
     686                           xmin=0.1, xmax=0.3, ymin=0.1, ymax=0.3, 
     687                           mask=[True, True, True]) 
     688 
     689        # Force same data into logic 
     690        item = QtGui.QStandardItem() 
     691        updateModelItem(item, test_data, "test") 
     692        # Force same data into logic 
     693        self.widget.data = item 
     694        category_index = self.widget.cbCategory.findText("Sphere") 
     695        self.widget.cbCategory.setCurrentIndex(category_index) 
     696 
     697        self.widget.show() 
     698 
     699        # Test no fitting params 
     700        self.widget.parameters_to_fit = [] 
     701 
     702        logging.error = MagicMock() 
     703 
     704        self.widget.onFit() 
     705        self.assertTrue(logging.error.called_once()) 
     706        self.assertTrue(logging.error.called_with('no fitting parameters')) 
     707        self.widget.close() 
     708 
     709 
     710    def testOnFit1D(self): 
     711        """ 
     712        Test the threaded fitting call 
     713        """ 
     714        # Set data 
     715        test_data = Data1D(x=[1,2], y=[1,2]) 
     716        item = QtGui.QStandardItem() 
     717        updateModelItem(item, test_data, "test") 
     718        # Force same data into logic 
     719        self.widget.data = item 
     720        category_index = self.widget.cbCategory.findText("Sphere") 
     721        self.widget.cbCategory.setCurrentIndex(category_index) 
     722 
     723        self.widget.show() 
    676724 
    677725        # Assing fitting params 
    … …  
    694742            # Signal pushed up 
    695743            self.assertEqual(update_spy.count(), 1) 
     744 
     745        self.widget.close() 
    696746 
    697747    def testOnFit2D(self): 
    … …  
    709759        # Force same data into logic 
    710760        item = QtGui.QStandardItem() 
    711         updateModelItem(item, [test_data], "test") 
     761        updateModelItem(item, test_data, "test") 
    712762        # Force same data into logic 
    713763        self.widget.data = item 
    … …  
    716766 
    717767        self.widget.show() 
    718  
    719         # Test no fitting params 
    720         self.widget.parameters_to_fit = [] 
    721  
    722         with self.assertRaises(ValueError) as error: 
    723             self.widget.onFit() 
    724         self.assertEqual(str(error.exception), 'no fitting parameters') 
    725768 
    726769        # Assing fitting params 
    … …  
    748791        Test various help pages shown in this widget 
    749792        """ 
    750         #Mock the QWebView method 
    751         QtWebKit.QWebView.show = MagicMock() 
    752         QtWebKit.QWebView.load = MagicMock() 
     793        #Mock the webbrowser.open method 
     794        self.widget.parent.showHelp = MagicMock() 
     795        #webbrowser.open = MagicMock() 
    753796 
    754797        # Invoke the action on default tab 
    755798        self.widget.onHelp() 
    756799        # Check if show() got called 
    757         self.assertTrue(QtWebKit.QWebView.show.called) 
     800        self.assertTrue(self.widget.parent.showHelp.called) 
    758801        # Assure the filename is correct 
    759         self.assertIn("fitting_help.html", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     802        self.assertIn("fitting_help.html", self.widget.parent.showHelp.call_args[0][0]) 
    760803 
    761804        # Change the tab to options 
    … …  
    763806        self.widget.onHelp() 
    764807        # Check if show() got called 
    765         self.assertEqual(QtWebKit.QWebView.show.call_count, 2) 
     808        self.assertEqual(self.widget.parent.showHelp.call_count, 2) 
    766809        # Assure the filename is correct 
    767         self.assertIn("residuals_help.html", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     810        self.assertIn("residuals_help.html", self.widget.parent.showHelp.call_args[0][0]) 
    768811 
    769812        # Change the tab to smearing 
    … …  
    771814        self.widget.onHelp() 
    772815        # Check if show() got called 
    773         self.assertEqual(QtWebKit.QWebView.show.call_count, 3) 
     816        self.assertEqual(self.widget.parent.showHelp.call_count, 3) 
    774817        # Assure the filename is correct 
    775         self.assertIn("sm_help.html", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     818        self.assertIn("resolution.html", self.widget.parent.showHelp.call_args[0][0]) 
    776819 
    777820        # Change the tab to poly 
    … …  
    779822        self.widget.onHelp() 
    780823        # Check if show() got called 
    781         self.assertEqual(QtWebKit.QWebView.show.call_count, 4) 
     824        self.assertEqual(self.widget.parent.showHelp.call_count, 4) 
    782825        # Assure the filename is correct 
    783         self.assertIn("pd_help.html", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     826        self.assertIn("polydispersity.html", self.widget.parent.showHelp.call_args[0][0]) 
    784827 
    785828        # Change the tab to magnetism 
    … …  
    787830        self.widget.onHelp() 
    788831        # Check if show() got called 
    789         self.assertEqual(QtWebKit.QWebView.show.call_count, 5) 
     832        self.assertEqual(self.widget.parent.showHelp.call_count, 5) 
    790833        # Assure the filename is correct 
    791         self.assertIn("mag_help.html", QtWebKit.QWebView.load.call_args[0][0].toString()) 
     834        self.assertIn("magnetism.html", self.widget.parent.showHelp.call_args[0][0]) 
    792835 
    793836    def testReadFitPage(self): 
    … …  
    9811024 
    9821025        # check that range of variation for this parameter has NOT been changed 
    983         print self.widget.kernel_module.details[name_modified_param] 
    9841026        self.assertNotIn(new_value, self.widget.kernel_module.details[name_modified_param] ) 
     1027 
     1028    def testModelContextMenu(self): 
     1029        """ 
     1030        Test the right click context menu in the parameter table 
     1031        """ 
     1032        # select model: cylinder / cylinder 
     1033        category_index = self.widget.cbCategory.findText("Cylinder") 
     1034        self.widget.cbCategory.setCurrentIndex(category_index) 
     1035 
     1036        model_index = self.widget.cbModel.findText("cylinder") 
     1037        self.widget.cbModel.setCurrentIndex(model_index) 
     1038 
     1039        # no rows selected 
     1040        menu = self.widget.modelContextMenu([]) 
     1041        self.assertEqual(len(menu.actions()), 0) 
     1042 
     1043        # 1 row selected 
     1044        menu = self.widget.modelContextMenu([1]) 
     1045        self.assertEqual(len(menu.actions()), 4) 
     1046 
     1047        # 2 rows selected 
     1048        menu = self.widget.modelContextMenu([1,3]) 
     1049        self.assertEqual(len(menu.actions()), 5) 
     1050 
     1051        # 3 rows selected 
     1052        menu = self.widget.modelContextMenu([1,2,3]) 
     1053        self.assertEqual(len(menu.actions()), 4) 
     1054 
     1055        # over 9000 
     1056        with self.assertRaises(AttributeError): 
     1057            menu = self.widget.modelContextMenu([i for i in range(9001)]) 
     1058        self.assertEqual(len(menu.actions()), 4) 
     1059 
     1060    def testShowModelContextMenu(self): 
     1061        # select model: cylinder / cylinder 
     1062        category_index = self.widget.cbCategory.findText("Cylinder") 
     1063        self.widget.cbCategory.setCurrentIndex(category_index) 
     1064 
     1065        model_index = self.widget.cbModel.findText("cylinder") 
     1066        self.widget.cbModel.setCurrentIndex(model_index) 
     1067 
     1068        # No selection 
     1069        logging.error = MagicMock() 
     1070        self.widget.showModelDescription = MagicMock() 
     1071        # Show the menu 
     1072        self.widget.showModelContextMenu(QtCore.QPoint(10,20)) 
     1073 
     1074        # Assure the description menu is shown 
     1075        self.assertTrue(self.widget.showModelDescription.called) 
     1076        self.assertFalse(logging.error.called) 
     1077 
     1078        # "select" two rows 
     1079        index1 = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex()) 
     1080        index2 = self.widget.lstParams.model().index(2, 0, QtCore.QModelIndex()) 
     1081        selection_model = self.widget.lstParams.selectionModel() 
     1082        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1083        selection_model.select(index2, selection_model.Select | selection_model.Rows) 
     1084 
     1085        QtWidgets.QMenu.exec_ = MagicMock() 
     1086        logging.error = MagicMock() 
     1087        # Show the menu 
     1088        self.widget.showModelContextMenu(QtCore.QPoint(10,20)) 
     1089 
     1090        # Assure the menu is shown 
     1091        self.assertFalse(logging.error.called) 
     1092        self.assertTrue(QtWidgets.QMenu.exec_.called) 
     1093 
     1094    def testShowMultiConstraint(self): 
     1095        """ 
     1096        Test the widget update on new multi constraint 
     1097        """ 
     1098        # select model: cylinder / cylinder 
     1099        category_index = self.widget.cbCategory.findText("Cylinder") 
     1100        self.widget.cbCategory.setCurrentIndex(category_index) 
     1101 
     1102        model_index = self.widget.cbModel.findText("cylinder") 
     1103        self.widget.cbModel.setCurrentIndex(model_index) 
     1104 
     1105        # nothing selected 
     1106        with self.assertRaises(AssertionError): 
     1107            self.widget.showMultiConstraint() 
     1108 
     1109        # one row selected 
     1110        index = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex()) 
     1111        selection_model = self.widget.lstParams.selectionModel() 
     1112        selection_model.select(index, selection_model.Select | selection_model.Rows) 
     1113        with self.assertRaises(AssertionError): 
     1114            # should also throw 
     1115            self.widget.showMultiConstraint() 
     1116 
     1117        # two rows selected 
     1118        index1 = self.widget.lstParams.model().index(1, 0, QtCore.QModelIndex()) 
     1119        index2 = self.widget.lstParams.model().index(2, 0, QtCore.QModelIndex()) 
     1120        selection_model = self.widget.lstParams.selectionModel() 
     1121        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1122        selection_model.select(index2, selection_model.Select | selection_model.Rows) 
     1123 
     1124        # return non-OK from dialog 
     1125        QtWidgets.QDialog.exec_ = MagicMock() 
     1126        self.widget.showMultiConstraint() 
     1127        # Check the dialog called 
     1128        self.assertTrue(QtWidgets.QDialog.exec_.called) 
     1129 
     1130        # return OK from dialog 
     1131        QtWidgets.QDialog.exec_ = MagicMock(return_value=QtWidgets.QDialog.Accepted) 
     1132        spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal) 
     1133 
     1134        self.widget.showMultiConstraint() 
     1135 
     1136        # Make sure the signal has been emitted 
     1137        self.assertEqual(spy.count(), 1) 
     1138 
     1139        # Check the argument value - should be row '1' 
     1140        self.assertEqual(spy.called()[0]['args'][0], [1]) 
     1141 
     1142    def testGetRowFromName(self): 
     1143        """ 
     1144        Helper function for parameter table 
     1145        """ 
     1146        # select model: cylinder / cylinder 
     1147        category_index = self.widget.cbCategory.findText("Cylinder") 
     1148        self.widget.cbCategory.setCurrentIndex(category_index) 
     1149 
     1150        model_index = self.widget.cbModel.findText("cylinder") 
     1151        self.widget.cbModel.setCurrentIndex(model_index) 
     1152 
     1153        # several random parameters 
     1154        self.assertEqual(self.widget.getRowFromName('scale'), 0) 
     1155        self.assertEqual(self.widget.getRowFromName('length'), 5) 
     1156 
     1157    def testGetParamNames(self): 
     1158        """ 
     1159        Helper function for parameter table 
     1160        """ 
     1161        # select model: cylinder / cylinder 
     1162        category_index = self.widget.cbCategory.findText("Cylinder") 
     1163        self.widget.cbCategory.setCurrentIndex(category_index) 
     1164 
     1165        model_index = self.widget.cbModel.findText("cylinder") 
     1166        self.widget.cbModel.setCurrentIndex(model_index) 
     1167 
     1168        cylinder_params = ['scale','background','sld','sld_solvent','radius','length'] 
     1169        # assure all parameters are returned 
     1170        self.assertEqual(self.widget.getParamNames(), cylinder_params) 
     1171 
     1172        # Switch to another model 
     1173        model_index = self.widget.cbModel.findText("pringle") 
     1174        self.widget.cbModel.setCurrentIndex(model_index) 
     1175 
     1176        # make sure the parameters are different than before 
     1177        self.assertFalse(self.widget.getParamNames() == cylinder_params) 
     1178 
     1179    def testAddConstraintToRow(self): 
     1180        """ 
     1181        Test the constraint row add operation 
     1182        """ 
     1183        # select model: cylinder / cylinder 
     1184        category_index = self.widget.cbCategory.findText("Cylinder") 
     1185        self.widget.cbCategory.setCurrentIndex(category_index) 
     1186 
     1187        model_index = self.widget.cbModel.findText("cylinder") 
     1188        self.widget.cbModel.setCurrentIndex(model_index) 
     1189 
     1190        # Create a constraint object 
     1191        const = Constraint(parent=None, value=7.0) 
     1192        row = 2 
     1193 
     1194        spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal) 
     1195 
     1196        # call the method tested 
     1197        self.widget.addConstraintToRow(constraint=const, row=row) 
     1198 
     1199        # Make sure the signal has been emitted 
     1200        self.assertEqual(spy.count(), 1) 
     1201 
     1202        # Check the argument value - should be row 'row' 
     1203        self.assertEqual(spy.called()[0]['args'][0], [row]) 
     1204 
     1205        # Assure the row has the constraint 
     1206        self.assertEqual(self.widget.getConstraintForRow(row), const) 
     1207        # but not complex constraint! 
     1208        self.assertFalse(self.widget.rowHasConstraint(row)) 
     1209 
     1210        # assign complex constraint now 
     1211        const = Constraint(parent=None, param='radius', func='5*sld') 
     1212        row = 4 
     1213        # call the method tested 
     1214        self.widget.addConstraintToRow(constraint=const, row=row) 
     1215 
     1216        # Make sure the signal has been emitted 
     1217        self.assertEqual(spy.count(), 2) 
     1218 
     1219        # Check the argument value - should be row 'row' 
     1220        self.assertEqual(spy.called()[1]['args'][0], [row]) 
     1221 
     1222        # Assure the row has the constraint 
     1223        self.assertEqual(self.widget.getConstraintForRow(row), const) 
     1224        # and it is a complex constraint 
     1225        self.assertTrue(self.widget.rowHasConstraint(row)) 
     1226 
     1227    def testAddSimpleConstraint(self): 
     1228        """ 
     1229        Test the constraint add operation 
     1230        """ 
     1231        # select model: cylinder / cylinder 
     1232        category_index = self.widget.cbCategory.findText("Cylinder") 
     1233        self.widget.cbCategory.setCurrentIndex(category_index) 
     1234 
     1235        model_index = self.widget.cbModel.findText("cylinder") 
     1236        self.widget.cbModel.setCurrentIndex(model_index) 
     1237 
     1238        # select two rows 
     1239        row1 = 1 
     1240        row2 = 4 
     1241        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
     1242        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     1243        selection_model = self.widget.lstParams.selectionModel() 
     1244        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1245        selection_model.select(index2, selection_model.Select | selection_model.Rows) 
     1246 
     1247        # define the signal spy 
     1248        spy = QtSignalSpy(self.widget, self.widget.constraintAddedSignal) 
     1249 
     1250        # call the method tested 
     1251        self.widget.addSimpleConstraint() 
     1252 
     1253        # Make sure the signal has been emitted 
     1254        self.assertEqual(spy.count(), 2) 
     1255 
     1256        # Check the argument value 
     1257        self.assertEqual(spy.called()[0]['args'][0], [row1]) 
     1258        self.assertEqual(spy.called()[1]['args'][0], [row2]) 
     1259 
     1260        # Other properties 
     1261        self.assertEqual(self.widget.getConstraintsForModel(), [('background', '0.001'), ('radius', '20')]) 
     1262 
     1263    def testDeleteConstraintOnParameter(self): 
     1264        """ 
     1265        Test the constraint deletion in model/view 
     1266        """ 
     1267        # select model: cylinder / cylinder 
     1268        category_index = self.widget.cbCategory.findText("Cylinder") 
     1269        self.widget.cbCategory.setCurrentIndex(category_index) 
     1270 
     1271        model_index = self.widget.cbModel.findText("cylinder") 
     1272        self.widget.cbModel.setCurrentIndex(model_index) 
     1273 
     1274        # select two rows 
     1275        row1 = 1 
     1276        row2 = 4 
     1277        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
     1278        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     1279        selection_model = self.widget.lstParams.selectionModel() 
     1280        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1281        selection_model.select(index2, selection_model.Select | selection_model.Rows) 
     1282 
     1283        # add constraints 
     1284        self.widget.addSimpleConstraint() 
     1285 
     1286        # deselect the model 
     1287        selection_model.clear() 
     1288 
     1289        # select a single row 
     1290        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1291 
     1292        # delete one of the constraints 
     1293        self.widget.deleteConstraintOnParameter(param='background') 
     1294 
     1295        # see that the other constraint is still present 
     1296        self.assertEqual(self.widget.getConstraintsForModel(), [('radius', '20')]) 
     1297 
     1298        # kill the other constraint 
     1299        self.widget.deleteConstraint() 
     1300 
     1301        # see that the other constraint is still present 
     1302        self.assertEqual(self.widget.getConstraintsForModel(), []) 
     1303 
     1304    def testGetConstraintForRow(self): 
     1305        """ 
     1306        Helper function for parameter table 
     1307        """ 
     1308        # tested extensively elsewhere 
     1309        pass 
     1310 
     1311    def testRowHasConstraint(self): 
     1312        """ 
     1313        Helper function for parameter table 
     1314        """ 
     1315        # select model: cylinder / cylinder 
     1316        category_index = self.widget.cbCategory.findText("Cylinder") 
     1317        self.widget.cbCategory.setCurrentIndex(category_index) 
     1318 
     1319        model_index = self.widget.cbModel.findText("cylinder") 
     1320        self.widget.cbModel.setCurrentIndex(model_index) 
     1321 
     1322        # select two rows 
     1323        row1 = 1 
     1324        row2 = 4 
     1325        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
     1326        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     1327        selection_model = self.widget.lstParams.selectionModel() 
     1328        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1329        selection_model.select(index2, selection_model.Select | selection_model.Rows) 
     1330 
     1331        # add constraints 
     1332        self.widget.addSimpleConstraint() 
     1333 
     1334        con_list = [False, True, False, False, True, False] 
     1335        new_list = [] 
     1336        for row in range(self.widget._model_model.rowCount()): 
     1337            new_list.append(self.widget.rowHasConstraint(row)) 
     1338 
     1339        self.assertEqual(new_list, con_list) 
     1340 
     1341    def testRowHasActiveConstraint(self): 
     1342        """ 
     1343        Helper function for parameter table 
     1344        """ 
     1345        # select model: cylinder / cylinder 
     1346        category_index = self.widget.cbCategory.findText("Cylinder") 
     1347        self.widget.cbCategory.setCurrentIndex(category_index) 
     1348 
     1349        model_index = self.widget.cbModel.findText("cylinder") 
     1350        self.widget.cbModel.setCurrentIndex(model_index) 
     1351 
     1352        # select two rows 
     1353        row1 = 1 
     1354        row2 = 4 
     1355        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
     1356        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     1357        selection_model = self.widget.lstParams.selectionModel() 
     1358        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1359        selection_model.select(index2, selection_model.Select | selection_model.Rows) 
     1360 
     1361        # add constraints 
     1362        self.widget.addSimpleConstraint() 
     1363 
     1364        # deactivate the first constraint 
     1365        constraint_objects = self.widget.getConstraintObjectsForModel() 
     1366        constraint_objects[0].active = False 
     1367 
     1368        con_list = [False, False, False, False, True, False] 
     1369        new_list = [] 
     1370        for row in range(self.widget._model_model.rowCount()): 
     1371            new_list.append(self.widget.rowHasActiveConstraint(row)) 
     1372 
     1373        self.assertEqual(new_list, con_list) 
     1374 
     1375    def testGetConstraintsForModel(self): 
     1376        """ 
     1377        Test the constraint getter for constraint texts 
     1378        """ 
     1379        # select model: cylinder / cylinder 
     1380        category_index = self.widget.cbCategory.findText("Cylinder") 
     1381        self.widget.cbCategory.setCurrentIndex(category_index) 
     1382 
     1383        model_index = self.widget.cbModel.findText("cylinder") 
     1384        self.widget.cbModel.setCurrentIndex(model_index) 
     1385 
     1386        # no constraints 
     1387        self.assertEqual(self.widget.getConstraintsForModel(),[]) 
     1388 
     1389        # select two rows 
     1390        row1 = 1 
     1391        row2 = 4 
     1392        index1 = self.widget.lstParams.model().index(row1, 0, QtCore.QModelIndex()) 
     1393        index2 = self.widget.lstParams.model().index(row2, 0, QtCore.QModelIndex()) 
     1394        selection_model = self.widget.lstParams.selectionModel() 
     1395        selection_model.select(index1, selection_model.Select | selection_model.Rows) 
     1396        selection_model.select(index2, selection_model.Select | selection_model.Rows) 
     1397 
     1398        # add constraints 
     1399        self.widget.addSimpleConstraint() 
     1400 
     1401        # simple constraints 
     1402        self.assertEqual(self.widget.getConstraintsForModel(), [('background', '0.001'), ('radius', '20')]) 
     1403        objects = self.widget.getConstraintObjectsForModel() 
     1404        self.assertEqual(len(objects), 2) 
     1405        self.assertEqual(objects[1].value, '20') 
     1406        self.assertEqual(objects[0].param, 'background') 
     1407 
     1408 
     1409        # add complex constraint 
     1410        const = Constraint(parent=None, param='scale', func='5*sld') 
     1411        row = 0 
     1412        self.widget.addConstraintToRow(constraint=const, row=row) 
     1413        self.assertEqual(self.widget.getConstraintsForModel(),[('scale', '5*sld'), ('background', '0.001'), ('radius', '20')]) 
     1414        objects = self.widget.getConstraintObjectsForModel() 
     1415        self.assertEqual(len(objects), 3) 
     1416        self.assertEqual(objects[0].func, '5*sld') 
     1417 
     1418    def testReplaceConstraintName(self): 
     1419        """ 
     1420        Test the replacement of constraint moniker 
     1421        """ 
     1422        # select model: cylinder / cylinder 
     1423        category_index = self.widget.cbCategory.findText("Cylinder") 
     1424        self.widget.cbCategory.setCurrentIndex(category_index) 
     1425 
     1426        model_index = self.widget.cbModel.findText("cylinder") 
     1427        self.widget.cbModel.setCurrentIndex(model_index) 
     1428 
     1429        old_name = 'M5' 
     1430        new_name = 'poopy' 
     1431        # add complex constraint 
     1432        const = Constraint(parent=None, param='scale', func='%s.5*sld'%old_name) 
     1433        row = 0 
     1434        self.widget.addConstraintToRow(constraint=const, row=row) 
     1435 
     1436        # Replace 'm5' with 'poopy' 
     1437        self.widget.replaceConstraintName(old_name, new_name) 
     1438 
     1439        self.assertEqual(self.widget.getConstraintsForModel(),[('scale', 'poopy.5*sld')]) 
    9851440 
    9861441 
Note: See TracChangeset for help on using the changeset viewer.