Extracted Logic in Pairing Table View to Presenter

qt/python/mantidqtinterfaces/mantidqtinterfaces/Muon/GUI/Common/grouping_tab_widget/grouping_tab_widget_model.py

@@ -44,6 +44,10 @@ def get_group_workspace(self, group_name, run):
             self._groups_and_pairs[group_name].update_counts_workspace(MuonRun(run), workspace)
         return workspace
 
+    @property
+    def get_context(self):
+        return self._context
+
     @property
     def groups(self):
         return self._groups_and_pairs.groups

qt/python/mantidqtinterfaces/test/Muon/grouping_tab/grouping_tab_presenter_test.py

@@ -119,7 +119,7 @@ def tearDown(self):
     # TESTS
     # ------------------------------------------------------------------------------------------------------------------
     def test_context_menu_add_pair_adds_pair_if_two_groups_selected(self):
-        self.assertEqual(self.pairing_table_view.num_rows(), 2)
+        self.assertEqual(self.pairing_table_widget.num_rows(), 2)
         self.grouping_table_view._get_selected_row_indices = mock.Mock(return_value=[0, 1])
         self.grouping_table_view.contextMenuEvent(0)
         self.grouping_table_view.add_pair_action.triggered.emit(True)
@@ -132,7 +132,7 @@ def test_that_clear_button_clears_model_and_view(self):
         self.assertEqual(len(self.model.groups), 0)
         self.assertEqual(len(self.model.pairs), 0)
         self.assertEqual(self.grouping_table_view.num_rows(), 0)
-        self.assertEqual(self.pairing_table_view.num_rows(), 0)
+        self.assertEqual(self.pairing_table_widget.num_rows(), 0)
 
     @mock.patch("mantidqtinterfaces.Muon.GUI.Common.grouping_tab_widget.grouping_tab_widget_presenter.xml_utils.load_grouping_from_XML")
     def test_that_load_grouping_triggers_the_correct_function(self, mock_load):
@@ -155,7 +155,7 @@ def test_that_load_grouping_inserts_loaded_groups_and_pairs_correctly(self):
         self.assertCountEqual(self.model.group_names, ["grp1", "grp2"])
         self.assertCountEqual(self.model.pair_names, ["pair1"])
         self.assertEqual(self.grouping_table_view.num_rows(), 2)
-        self.assertEqual(self.pairing_table_view.num_rows(), 1)
+        self.assertEqual(self.pairing_table_widget.num_rows(), 1)
         self.assertEqual(self.pairing_table_view.pairing_table.cellWidget(0, 2).currentText(), "grp1")
         self.assertEqual(self.pairing_table_view.pairing_table.cellWidget(0, 3).currentText(), "grp2")
 
@@ -169,7 +169,7 @@ def test_loading_does_not_insert_invalid_groups(self):
         self.assertCountEqual(self.model.group_names, ["grp1"])
         self.assertCountEqual(self.model.pair_names, [])
         self.assertEqual(self.grouping_table_view.num_rows(), 1)
-        self.assertEqual(self.pairing_table_view.num_rows(), 0)
+        self.assertEqual(self.pairing_table_widget.num_rows(), 0)
 
     def test_loading_selects_all_pairs_if_any_pairs_exist_and_no_default_set(self):
         groups = [MuonGroup(group_name="grp1", detector_ids=[1, 2, 3, 4, 5]), MuonGroup(group_name="grp2", detector_ids=[6, 7, 8, 9, 10])]
@@ -291,9 +291,9 @@ def test_cannot_remove_last_row_pair_table_if_used_by_diff(self):
 
     def test_cannot_remove_a_selected_pair_used_by_diff(self):
         self.add_pair_diff()
-        self.pairing_table_view.get_selected_pair_names_and_indexes = mock.Mock(return_value=[["long1", 0]])
+        self.pairing_table_widget.get_selected_pair_names_and_indexes = mock.Mock(return_value=[["long1", 0]])
         self.pairing_table_widget.handle_remove_pair_button_clicked()
-
+        #
         self.assertEqual(1, self.pairing_table_view.warning_popup.call_count)
         self.assertEqual("long1 is used by: diff_1\n", self.pairing_table_view.warning_popup.call_args_list[0][0][0])
 

qt/python/mantidqtinterfaces/test/Muon/grouping_tab/pairing_table_alpha_test.py

@@ -80,19 +80,19 @@ def get_group_2_selector(self, row):
     def test_that_alpha_defaults_to_1(self):
         self.presenter.handle_add_pair_button_clicked()
 
-        self.assertEqual(self.view.get_table_item_text(0, 4), "1.0")
+        self.assertEqual(self.presenter.get_table_item_text(0, 4), "1.0")
 
     def test_that_table_reverts_to_previous_value_when_adding_values_which_arent_numbers_to_alpha_column(self):
         self.presenter.handle_add_pair_button_clicked()
 
         non_numeric_alphas = ["", "a", "long", "!", "_", "1+2"]
 
-        default_value = self.view.get_table_item_text(0, 4)
+        default_value = self.presenter.get_table_item_text(0, 4)
         for invalid_alpha in non_numeric_alphas:
             self.view.pairing_table.setCurrentCell(0, 4)
             self.view.pairing_table.item(0, 4).setText(invalid_alpha)
 
-            self.assertEqual(self.view.get_table_item_text(0, 4), default_value)
+            self.assertEqual(self.presenter.get_table_item_text(0, 4), default_value)
 
     def test_that_warning_displayed_when_adding_invalid_alpha_values(self):
         self.presenter.handle_add_pair_button_clicked()
@@ -114,7 +114,7 @@ def test_that_alpha_values_stored_to_correct_decimal_places(self):
         # test that rounds correctly
         self.view.pairing_table.item(0, 4).setText("1.1234567890")
 
-        self.assertEqual(self.view.get_table_item_text(0, 4), "1.123457")
+        self.assertEqual(self.presenter.get_table_item_text(0, 4), "1.123457")
 
     def test_that_alpha_values_stored_to_correct_decimal_places_when_rounding_down(self):
         self.presenter.handle_add_pair_button_clicked()
@@ -123,7 +123,7 @@ def test_that_alpha_values_stored_to_correct_decimal_places_when_rounding_down(s
         # test that rounds correctly
         self.view.pairing_table.item(0, 4).setText("1.12345617890")
 
-        self.assertEqual(self.view.get_table_item_text(0, 4), "1.123456")
+        self.assertEqual(self.presenter.get_table_item_text(0, 4), "1.123456")
 
     def test_that_valid_alpha_values_are_added_correctly(self):
         self.presenter.handle_add_pair_button_clicked()
@@ -136,16 +136,16 @@ def test_that_valid_alpha_values_are_added_correctly(self):
             self.view.pairing_table.item(0, 4).setText(valid_alpha)
             # make presenter update
             self.presenter.handle_data_change(0, 4)
-            self.assertEqual(float(self.view.get_table_item_text(0, 4)), expected_alpha)
+            self.assertEqual(float(self.presenter.get_table_item_text(0, 4)), expected_alpha)
 
     def test_that_negative_alpha_is_not_allowed(self):
         self.presenter.handle_add_pair_button_clicked()
 
         self.view.pairing_table.setCurrentCell(0, 4)
-        default_value = self.view.get_table_item_text(0, 4)
+        default_value = self.presenter.get_table_item_text(0, 4)
         self.view.pairing_table.item(0, 4).setText("-1.0")
 
-        self.assertEqual(self.view.get_table_item_text(0, 4), default_value)
+        self.assertEqual(self.presenter.get_table_item_text(0, 4), default_value)
         self.assertEqual(self.view.warning_popup.call_count, 1)
 
     def test_that_clicking_guess_alpha_triggers_correct_slot_with_correct_row_supplied(self):

qt/python/mantidqtinterfaces/test/Muon/grouping_tab/pairing_table_group_selector_test.py

@@ -15,6 +15,7 @@
 from mantidqtinterfaces.Muon.GUI.Common.pairing_table_widget.pairing_table_widget_presenter import PairingTablePresenter
 from mantidqtinterfaces.Muon.GUI.Common.pairing_table_widget.pairing_table_widget_view import PairingTableView
 from mantidqtinterfaces.Muon.GUI.Common.test_helpers.context_setup import setup_context_for_tests
+from mantidqtinterfaces.Muon.GUI.ElementalAnalysis2.grouping_widget.ea_grouping_table_widget_view import EAGroupingTableView
 
 
 def pair_name():
@@ -93,14 +94,14 @@ def test_that_added_groups_appear_in_group_combo_boxes_in_new_pairs(self):
     def test_that_get_index_of_text_returns_correct_index_if_text_exists(self):
         self.presenter.handle_add_pair_button_clicked()
 
-        index = self.view.get_index_of_text(self.get_group_1_selector_from_pair(0), "my_group_1")
+        index = EAGroupingTableView.get_index_of_text(self.get_group_1_selector_from_pair(0), "my_group_1")
 
         self.assertEqual(index, 1)
 
     def test_that_get_index_of_text_returns_0_if_text_does_not_exists(self):
         self.presenter.handle_add_pair_button_clicked()
 
-        index = self.view.get_index_of_text(self.get_group_1_selector_from_pair(0), "random string")
+        index = EAGroupingTableView.get_index_of_text(self.get_group_1_selector_from_pair(0), "random string")
 
         self.assertEqual(index, 0)
 

qt/python/mantidqtinterfaces/test/Muon/grouping_tab/pairing_table_presenter_test.py

@@ -49,7 +49,7 @@ def assert_model_empty(self):
         self.assertEqual(len(self.model.pairs), 0)
 
     def assert_view_empty(self):
-        self.assertEqual(self.view.num_rows(), 0)
+        self.assertEqual(self.presenter.num_rows(), 0)
 
     def add_three_groups_to_model(self):
         group1 = MuonGroup(group_name="my_group_0", detector_ids=[1])
@@ -71,7 +71,7 @@ def add_two_pairs_to_table(self):
 
     def test_that_table_has_five_columns_when_initialized(self):
         # these are : pair name, group 1, group 2, alpha, guess alpha
-        self.assertEqual(self.view.num_cols(), 6)
+        self.assertEqual(self.presenter.num_cols(), 6)
 
     def test_that_model_is_initialized_as_empty(self):
         self.assert_model_empty()
@@ -85,31 +85,31 @@ def test_that_view_is_initialized_as_empty(self):
 
     def test_that_add_pair_button_adds_pair(self):
         self.presenter.handle_add_pair_button_clicked()
-        self.assertEqual(self.view.num_rows(), 1)
+        self.assertEqual(self.presenter.num_rows(), 1)
         self.assertEqual(len(self.model.pairs), 1)
 
     def test_that_remove_pair_button_removes_group(self):
         self.add_two_pairs_to_table()
         self.presenter.handle_remove_pair_button_clicked()
-        self.assertEqual(self.view.num_rows(), 1)
+        self.assertEqual(self.presenter.num_rows(), 1)
 
     def test_that_add_pair_button_adds_pair_to_end_of_table(self):
         self.add_two_pairs_to_table()
 
         self.presenter.add_pair(MuonPair(pair_name="new", forward_group_name="my_group_0", backward_group_name="my_group_1"))
 
-        self.assertEqual(self.view.get_table_item_text(self.view.num_rows() - 1, 0), "new")
+        self.assertEqual(self.presenter.get_table_item_text(self.presenter.num_rows() - 1, 0), "new")
 
     def test_that_remove_pair_button_removes_pair_from_end_of_table(self):
         self.add_two_pairs_to_table()
 
         self.presenter.handle_remove_pair_button_clicked()
 
-        self.assertEqual(self.view.get_table_item_text(self.view.num_rows() - 1, 0), "my_pair_0")
+        self.assertEqual(self.presenter.get_table_item_text(self.presenter.num_rows() - 1, 0), "my_pair_0")
 
     def test_that_highlighting_rows_and_clicking_remove_pair_removes_the_selected_rows(self):
         self.add_two_pairs_to_table()
-        self.view._get_selected_row_indices = mock.Mock(return_value=[0, 1])
+        self.presenter.get_selected_row_indices = mock.Mock(return_value=[0, 1])
 
         self.presenter.handle_remove_pair_button_clicked()
 
@@ -120,7 +120,7 @@ def test_that_cannot_add_more_than_20_rows(self):
         for i in range(21):
             self.presenter.handle_add_pair_button_clicked()
 
-        self.assertEqual(self.view.num_rows(), 20)
+        self.assertEqual(self.presenter.num_rows(), 20)
         self.assertEqual(len(self.model.pairs), 20)
 
     def test_that_trying_to_add_a_20th_row_gives_warning_message(self):
@@ -143,12 +143,12 @@ def test_context_menu_add_pairing_with_no_rows_selected_adds_pair_to_end_of_tabl
         self.view.add_pair_action.triggered.emit(True)
 
         self.assertEqual(len(self.model.pairs), 1)
-        self.assertEqual(self.view.num_rows(), 1)
-        self.assertEqual(self.view.get_table_item_text(0, 0), "pair_1")
+        self.assertEqual(self.presenter.num_rows(), 1)
+        self.assertEqual(self.presenter.get_table_item_text(0, 0), "pair_1")
 
     def test_context_menu_add_pairing_with_rows_selected_does_not_add_pair(self):
         self.add_two_pairs_to_table()
-        self.view._get_selected_row_indices = mock.Mock(return_value=[0])
+        self.presenter.get_selected_row_indices = mock.Mock(return_value=[0])
 
         self.view.contextMenuEvent(0)
 
@@ -163,22 +163,22 @@ def test_context_menu_remove_pairing_with_no_rows_selected_removes_last_row(self
         self.view.remove_pair_action.triggered.emit(True)
 
         self.assertEqual(len(self.model.pairs), 2)
-        self.assertEqual(self.view.num_rows(), 2)
-        self.assertEqual(self.view.get_table_item_text(0, 0), "pair_1")
-        self.assertEqual(self.view.get_table_item_text(1, 0), "pair_2")
+        self.assertEqual(self.presenter.num_rows(), 2)
+        self.assertEqual(self.presenter.get_table_item_text(0, 0), "pair_1")
+        self.assertEqual(self.presenter.get_table_item_text(1, 0), "pair_2")
 
     def test_context_menu_remove_pairing_removes_selected_rows(self):
         for i in range(3):
             # names : pair_0, pair_1, pair_2
             self.presenter.handle_add_pair_button_clicked()
-        self.view._get_selected_row_indices = mock.Mock(return_value=[0, 2])
+        self.presenter.get_selected_row_indices = mock.Mock(return_value=[0, 2])
 
         self.view.contextMenuEvent(0)
         self.view.remove_pair_action.triggered.emit(True)
 
         self.assertEqual(len(self.model.pairs), 1)
-        self.assertEqual(self.view.num_rows(), 1)
-        self.assertEqual(self.view.get_table_item_text(0, 0), "pair_2")
+        self.assertEqual(self.presenter.num_rows(), 1)
+        self.assertEqual(self.presenter.get_table_item_text(0, 0), "pair_2")
 
     def test_context_menu_remove_pairing_disabled_if_no_pairs_in_table(self):
         self.view.contextMenuEvent(0)
@@ -191,10 +191,10 @@ def test_context_menu_remove_pairing_disabled_if_no_pairs_in_table(self):
 
     def test_that_can_change_pair_name_to_valid_name_and_update_view_and_model(self):
         self.add_two_pairs_to_table()
-        self.view.pairing_table.setCurrentCell(0, 0)
-        self.view.pairing_table.item(0, 0).setText("new_name")
+        self.view.get_pairing_table.setCurrentCell(0, 0)
+        self.view.get_pairing_table.item(0, 0).setText("new_name")
 
-        self.assertEqual(self.view.get_table_item_text(0, 0), "new_name")
+        self.assertEqual(self.presenter.get_table_item_text(0, 0), "new_name")
         self.assertIn("new_name", self.model.pair_names)
 
     def test_that_if_invalid_name_given_warning_message_is_shown(self):
@@ -204,8 +204,8 @@ def test_that_if_invalid_name_given_warning_message_is_shown(self):
         call_count = self.view.warning_popup.call_count
         for invalid_name in invalid_names:
             call_count += 1
-            self.view.pairing_table.setCurrentCell(0, 0)
-            self.view.pairing_table.item(0, 0).setText(invalid_name)
+            self.view.get_pairing_table.setCurrentCell(0, 0)
+            self.view.get_pairing_table.item(0, 0).setText(invalid_name)
 
             self.assertEqual(self.view.warning_popup.call_count, call_count)
 
@@ -215,10 +215,10 @@ def test_that_if_invalid_name_given_name_reverts_to_its_previous_value(self):
         invalid_names = ["", "@", "name!", "+-"]
 
         for invalid_name in invalid_names:
-            self.view.pairing_table.setCurrentCell(0, 0)
-            self.view.pairing_table.item(0, 0).setText(invalid_name)
+            self.view.get_pairing_table.setCurrentCell(0, 0)
+            self.view.get_pairing_table.item(0, 0).setText(invalid_name)
 
-            self.assertEqual(str(self.view.get_table_item_text(0, 0)), "my_pair_0")
+            self.assertEqual(str(self.presenter.get_table_item_text(0, 0)), "my_pair_0")
             self.assertIn("my_pair_0", self.model.pair_names)
 
     def test_that_pair_names_with_numbers_and_letters_and_underscores_are_valid(self):
@@ -227,10 +227,10 @@ def test_that_pair_names_with_numbers_and_letters_and_underscores_are_valid(self
         valid_names = ["fwd", "fwd_1", "1234", "FWD0001", "_fwd"]
 
         for valid_name in valid_names:
-            self.view.pairing_table.setCurrentCell(0, 0)
-            self.view.pairing_table.item(0, 0).setText(valid_name)
+            self.view.get_pairing_table.setCurrentCell(0, 0)
+            self.view.get_pairing_table.item(0, 0).setText(valid_name)
 
-            self.assertEqual(str(self.view.get_table_item_text(0, 0)), valid_name)
+            self.assertEqual(str(self.presenter.get_table_item_text(0, 0)), valid_name)
             self.assertIn(valid_name, self.model.pair_names)
 
     def test_that_warning_shown_if_duplicated_pair_name_used(self):
@@ -244,19 +244,39 @@ def test_that_warning_shown_if_duplicated_pair_name_used(self):
     def test_that_default_pair_name_is_pair_0(self):
         self.presenter.handle_add_pair_button_clicked()
 
-        self.assertEqual(str(self.view.get_table_item_text(0, 0)), "pair_1")
+        self.assertEqual(str(self.presenter.get_table_item_text(0, 0)), "pair_1")
         self.assertIn("pair_1", self.model.pair_names)
 
     def test_that_adding_new_pair_creates_incremented_default_name(self):
         self.presenter.handle_add_pair_button_clicked()
         self.presenter.handle_add_pair_button_clicked()
         self.presenter.handle_add_pair_button_clicked()
 
-        self.assertEqual(str(self.view.get_table_item_text(0, 0)), "pair_1")
-        self.assertEqual(str(self.view.get_table_item_text(1, 0)), "pair_2")
-        self.assertEqual(str(self.view.get_table_item_text(2, 0)), "pair_3")
+        self.assertEqual(str(self.presenter.get_table_item_text(0, 0)), "pair_1")
+        self.assertEqual(str(self.presenter.get_table_item_text(1, 0)), "pair_2")
+        self.assertEqual(str(self.presenter.get_table_item_text(2, 0)), "pair_3")
         self.assertCountEqual(self.model.pair_names, ["pair_1", "pair_2", "pair_3"])
 
+    def test_enable_updates(self):
+        self.presenter.enable_updates()
+        self.assertEqual(self.view.is_updating, True)
+
+    def test_disable_updates(self):
+        self.presenter.disable_updates()
+        self.assertEqual(self.view.is_updating, False)
+
+    def test_enable_editing(self):
+        self.presenter.enable_editing()
+        self.assertTrue(self.view.add_pair_button.isEnabled())
+        self.assertTrue(self.view.remove_pair_button.isEnabled())
+        self.assertEqual(self.view.is_updating, False)
+
+    def test_disable_editing(self):
+        self.presenter.disable_editing()
+        self.assertFalse(self.view.add_pair_button.isEnabled())
+        self.assertFalse(self.view.remove_pair_button.isEnabled())
+        self.assertEqual(self.view.is_updating, False)
+
 
 if __name__ == "__main__":
     unittest.main(buffer=False, verbosity=2)