Merge pull request #1470 from VesnaT/widget_learner_tests

astaric · web-flow · commit 5fcb75c92ebf · 2016-07-19T15:31:52.000+02:00
[ENH] Support learner widgets testing
diff --git a/Orange/widgets/classify/owknn.py b/Orange/widgets/classify/owknn.py
@@ -25,16 +25,17 @@ class OWKNNLearner(OWBaseLearner):
 
     def add_main_layout(self):
         box = gui.vBox(self.controlArea, "Neighbors")
-        gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors:",
-                 alignment=Qt.AlignRight, callback=self.settings_changed)
-        gui.comboBox(box, self, "metric_index", label="Metric:",
-                     orientation=Qt.Horizontal,
-                     items=[i.capitalize() for i in self.metrics],
-                     callback=self.settings_changed)
-        gui.comboBox(box, self, "weight_type", label="Weight:",
-                     orientation=Qt.Horizontal,
-                     items=[i.capitalize() for i in self.weights],
-                     callback=self.settings_changed)
+        self.n_neighbors_spin = gui.spin(
+            box, self, "n_neighbors", 1, 100, label="Number of neighbors:",
+            alignment=Qt.AlignRight, callback=self.settings_changed)
+        self.metrics_combo = gui.comboBox(
+            box, self, "metric_index", orientation=Qt.Horizontal,
+            label="Metric:", items=[i.capitalize() for i in self.metrics],
+            callback=self.settings_changed)
+        self.weights_combo = gui.comboBox(
+            box, self, "weight_type", orientation=Qt.Horizontal,
+            label="Weight:", items=[i.capitalize() for i in self.weights],
+            callback=self.settings_changed)
 
     def create_learner(self):
         return self.LEARNER(
diff --git a/Orange/widgets/classify/tests/test_owclassificationtree.py b/Orange/widgets/classify/tests/test_owclassificationtree.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.classify.owclassificationtree import OWClassificationTree
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWClassificationTree(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWClassificationTree,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/classify/tests/test_owlogisticregression.py b/Orange/widgets/classify/tests/test_owlogisticregression.py
@@ -5,8 +5,9 @@
 from Orange.data import Table
 from Orange.statistics.util import stats
 from Orange.classification import LogisticRegressionLearner
-from Orange.widgets.classify.owlogisticregression import create_coef_table, OWLogisticRegression
-from Orange.widgets.tests.base import WidgetTest
+from Orange.widgets.classify.owlogisticregression import (create_coef_table,
+                                                          OWLogisticRegression)
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
 
 
 class LogisticRegressionTest(unittest.TestCase):
@@ -30,7 +31,8 @@ def test_coef_table_multiple(self):
                          len(classifier.domain.class_var.values))
 
 
-class TestOWLogisticRegression(WidgetTest):
-    def test_data_before_apply(self):
-        widget = self.create_widget(OWLogisticRegression)
-        widget.set_data(Table("iris"))
+class TestOWLogisticRegression(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWLogisticRegression,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/classify/tests/test_owmajority.py b/Orange/widgets/classify/tests/test_owmajority.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.classify.owmajority import OWMajority
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWMajority(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWMajority,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/classify/tests/test_ownaivebayes.py b/Orange/widgets/classify/tests/test_ownaivebayes.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.classify.ownaivebayes import OWNaiveBayes
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWNaiveBayes(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWNaiveBayes,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/classify/tests/test_owrandomforest.py b/Orange/widgets/classify/tests/test_owrandomforest.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.classify.owrandomforest import OWRandomForest
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWRandomForest(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWRandomForest,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/regression/tests/__init__.py b/Orange/widgets/regression/tests/__init__.py
diff --git a/Orange/widgets/regression/tests/test_owknnregression.py b/Orange/widgets/regression/tests/test_owknnregression.py
@@ -0,0 +1,32 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.regression.owknnregression import OWKNNRegression
+from Orange.widgets.tests.base import (WidgetTest, WidgetLearnerTestMixin,
+                                       GuiToParam)
+
+
+class TestOWKNNRegression(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWKNNRegression,
+                                         stored_settings={"auto_apply": False})
+        self.init()
+
+        def combo_set_value(i, x):
+            x.activated.emit(i)
+            x.setCurrentIndex(i)
+
+        # FIXME: widget crashes when Mahalanobis metric is chosen.
+        # When fixed, remove metrics slicing
+        metrics = self.widget.metrics[:-1]
+        weights = self.widget.weights
+        nn_spin = self.widget.n_neighbors_spin
+        nn_min_max = [nn_spin.minimum(), nn_spin.maximum()]
+        self.gui_to_params = [
+            GuiToParam('metric', self.widget.metrics_combo,
+                       lambda x: x.currentText().lower(),
+                       combo_set_value, metrics, list(range(len(metrics)))),
+            GuiToParam('weights', self.widget.weights_combo,
+                       lambda x: x.currentText().lower(),
+                       combo_set_value, weights, list(range(len(weights)))),
+            GuiToParam('n_neighbors', nn_spin, lambda x: x.value(),
+                       lambda i, x: x.setValue(i), nn_min_max, nn_min_max)]
diff --git a/Orange/widgets/regression/tests/test_owmean.py b/Orange/widgets/regression/tests/test_owmean.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.regression.owmean import OWMean
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWMean(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWMean,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/regression/tests/test_owrandomforestregression.py b/Orange/widgets/regression/tests/test_owrandomforestregression.py
@@ -0,0 +1,12 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.regression.owrandomforestregression import \
+    OWRandomForestRegression
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWRandomForestRegression(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWRandomForestRegression,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/regression/tests/test_owregressiontree.py b/Orange/widgets/regression/tests/test_owregressiontree.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.regression.owregressiontree import OWRegressionTree
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWRegressionTree(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWRegressionTree,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/regression/tests/test_owsgdregression.py b/Orange/widgets/regression/tests/test_owsgdregression.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.regression.owsgdregression import OWSGDRegression
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWSGDRegression(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWSGDRegression,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/regression/tests/test_owsvmregression.py b/Orange/widgets/regression/tests/test_owsvmregression.py
@@ -0,0 +1,11 @@
+# Test methods with long descriptive names can omit docstrings
+# pylint: disable=missing-docstring
+from Orange.widgets.regression.owsvmregression import OWSVMRegression
+from Orange.widgets.tests.base import WidgetTest, WidgetLearnerTestMixin
+
+
+class TestOWSVMRegression(WidgetTest, WidgetLearnerTestMixin):
+    def setUp(self):
+        self.widget = self.create_widget(OWSVMRegression,
+                                         stored_settings={"auto_apply": False})
+        self.init()
diff --git a/Orange/widgets/tests/base.py b/Orange/widgets/tests/base.py
@@ -1,8 +1,16 @@
 import unittest
+from collections import namedtuple
+from PyQt4 import QtGui
 
 from PyQt4.QtGui import QApplication
 import sip
 
+from Orange.data import Table
+from Orange.preprocess import RemoveNaNColumns, Randomize
+from Orange.preprocess.preprocess import PreprocessorList
+from Orange.classification.base_classification import (LearnerClassification,
+                                                       ModelClassification)
+from Orange.regression.base_regression import LearnerRegression, ModelRegression
 from Orange.canvas.report.owreport import OWReport
 
 app = None
@@ -130,7 +138,7 @@ def send_signal(self, input_name, value, id=None, widget=None):
                 break
         widget.handleNewSignals()
 
-    def get_ouput(self, output_name, widget=None):
+    def get_output(self, output_name, widget=None):
         """Return the last output that has been sent from the widget.
 
         Parameters
@@ -145,4 +153,144 @@ def get_ouput(self, output_name, widget=None):
         """
         if widget is None:
             widget = self.widget
-        self.signal_manager.outputs.get((widget, output_name), None)
+        return self.signal_manager.outputs.get((widget, output_name), None)
+
+
+GuiToParam = namedtuple('GuiParam', 'name gui_el get set values set_values')
+
+
+class WidgetLearnerTestMixin:
+    """Base class for widget learner tests.
+
+    Contains init method to set up testing parameters and test methods.
+
+    All widget learner tests should extend it (beside extending WidgetTest
+    class as well). Learners with extra parameters, which can be set on the
+    widget, should override self.gui_to_params list in the setUp method. The
+    list should contain mapping: learner parameter - gui component.
+    """
+    def init(self):
+        self.iris = Table("iris")
+        self.housing = Table("housing")
+        if issubclass(self.widget.LEARNER, LearnerClassification):
+            self.data = self.iris
+            self.inadequate_data = self.housing
+            self.learner_class = LearnerClassification
+            self.model_name = "Classifier"
+            self.model_class = ModelClassification
+        else:
+            self.data = self.housing
+            self.inadequate_data = self.iris
+            self.learner_class = LearnerRegression
+            self.model_name = "Predictor"
+            self.model_class = ModelRegression
+        self.gui_to_params = []
+
+    def test_input_data(self):
+        """Check widget's data with data on the input"""
+        self.assertEqual(self.widget.data, None)
+        self.send_signal("Data", self.data)
+        self.assertEqual(self.widget.data, self.data)
+
+    def test_input_data_disconnect(self):
+        """Check widget's data and model after disconnecting data from input"""
+        self.send_signal("Data", self.data)
+        self.assertEqual(self.widget.data, self.data)
+        self.widget.apply_button.button.click()
+        self.send_signal("Data", None)
+        self.assertEqual(self.widget.data, None)
+        self.assertIsNone(self.get_output(self.model_name))
+
+    def test_input_data_learner_adequacy(self):
+        """Check if error message is shown with inadequate data on input"""
+        err_id = self.widget.DATA_ERROR_ID
+        self.send_signal("Data", self.inadequate_data)
+        self.widget.apply_button.button.click()
+        self.assertIn(err_id, self.widget.widgetState.get("Error"))
+        self.assertEqual(self.widget.widgetState.get("Error").get(err_id),
+                         self.learner_class.learner_adequacy_err_msg)
+        self.send_signal("Data", self.data)
+        self.assertNotIn(err_id, self.widget.widgetState.get("Error"))
+
+    def test_input_preprocessor(self):
+        """Check learner's preprocessors with an extra pp on input"""
+        self.assertIsNone(self.widget.preprocessors)
+        self.send_signal("Preprocessor", Randomize)
+        pp = (Randomize,) + tuple(self.widget.LEARNER.preprocessors)
+        self.assertEqual(pp, self.widget.preprocessors)
+        self.widget.apply_button.button.click()
+        self.assertEqual(pp, tuple(self.widget.learner.preprocessors))
+
+    def test_input_preprocessors(self):
+        """Check multiple preprocessors on input"""
+        pp_list = PreprocessorList([Randomize, RemoveNaNColumns])
+        self.send_signal("Preprocessor", pp_list)
+        self.widget.apply_button.button.click()
+        self.assertEqual([pp_list] + list(self.widget.LEARNER.preprocessors),
+                         self.widget.learner.preprocessors)
+
+    def test_input_preprocessor_disconnect(self):
+        """Check learner's preprocessors after disconnecting pp from input"""
+        self.send_signal("Preprocessor", Randomize)
+        self.assertIsNotNone(self.widget.preprocessors)
+        self.send_signal("Preprocessor", None)
+        self.assertEqual(self.widget.preprocessors,
+                         tuple(self.widget.LEARNER.preprocessors))
+
+    def test_output_learner(self):
+        """Check if learner is on output after apply"""
+        self.assertIsNone(self.get_output("Learner"))
+        self.widget.apply_button.button.click()
+        self.assertIsNotNone(self.get_output("Learner"))
+        self.assertIsInstance(self.get_output("Learner"), self.widget.LEARNER)
+
+    def test_output_model(self):
+        """Check if model is on output after sending data and apply"""
+        self.assertIsNone(self.get_output(self.model_name))
+        self.widget.apply_button.button.click()
+        self.assertIsNone(self.get_output(self.model_name))
+        self.send_signal("Data", self.data)
+        self.widget.apply_button.button.click()
+        model = self.get_output(self.model_name)
+        self.assertIsNotNone(model)
+        self.assertIsInstance(model, self.widget.LEARNER.__returns__)
+        self.assertIsInstance(model, self.model_class)
+
+    def test_output_learner_name(self):
+        """Check if learner's name properly changes"""
+        new_name = "Learner Name"
+        name_line_edit = self.widget.findChildren(QtGui.QLineEdit)[0]
+        self.widget.apply_button.button.click()
+        self.assertEqual(self.widget.learner.name, name_line_edit.text())
+        name_line_edit.setText(new_name)
+        self.widget.apply_button.button.click()
+        self.assertEqual(self.get_output("Learner").name, new_name)
+
+    def test_output_model_name(self):
+        """Check if model's name properly changes"""
+        new_name = "Model Name"
+        name_line_edit = self.widget.findChildren(QtGui.QLineEdit)[0]
+        name_line_edit.setText(new_name)
+        self.send_signal("Data", self.data)
+        self.widget.apply_button.button.click()
+        self.assertEqual(self.get_output(self.model_name).name, new_name)
+
+    def test_parameters_default(self):
+        """Check if learner's parameters are set to default (widget's) values"""
+        self.widget.apply_button.button.click()
+        if hasattr(self.widget.learner, "params"):
+            learner_params = self.widget.learner.params
+            for element in self.gui_to_params:
+                self.assertEqual(learner_params.get(element.name),
+                                 element.get(element.gui_el))
+
+    def test_parameters(self):
+        """Check learner and model for various values of all parameters"""
+        for element in self.gui_to_params:
+            for val, set_val in zip(element.values, element.set_values):
+                self.send_signal("Data", self.data)
+                element.set(set_val, element.gui_el)
+                self.widget.apply_button.button.click()
+                param = self.widget.learner.params.get(element.name)
+                self.assertEqual(param, element.get(element.gui_el))
+                self.assertEqual(param, val)
diff --git a/Orange/widgets/utils/owlearnerwidget.py b/Orange/widgets/utils/owlearnerwidget.py
@@ -173,7 +173,8 @@ def update_model(self):
             self.model.name = self.learner_name
             self.model.instances = self.data
             self.valid_data = True
-
+        else:
+            self.model = None
         self.send(self.OUTPUT_MODEL_NAME, self.model)
 
     def check_data(self):
@@ -197,7 +198,8 @@ def settings_changed(self, *args, **kwargs):
         self.outdated_settings = True
         self.warning(self.OUTDATED_LEARNER_WARNING_ID,
                      None if self.auto_apply else "Press Apply to submit changes.")
-        self.apply()
+        if self.auto_apply:
+            self.apply()
 
     def send_report(self):
         self.report_items((("Name", self.learner_name),))
