Merge lp:~nataliabidart/ubuntu-sso-client/activatable-entry-and-button into lp:ubuntu-sso-client

[Natalia Bidart]

Every form can be submitted by activating the buttons and/or the entries (LP: #616421).

Every form can be submitted by activating the buttons and/or the entries.

[lp:~nataliabidart/ubuntu-sso-client/activatable-entry-and-button]

604. By Natalia Bidart on 2010-08-27

Removing XXX (is beign resolved by this branch).

[Rodrigo Moya (rodrigo-moya)]

review: Approve

[John Lenton (chipaca)]

review: Approve

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-08-26 22:30:15 +0000
+++ ubuntu_sso/gui.py	2010-08-27 15:27:59 +0000
@@ -255,9 +255,6 @@
         builder.add_from_file(ui_filename)
         builder.connect_signals(self)
 
-        # XXX: every button should have tests for 'activate' signal
-        # see LP: #616421
-
         self.widgets = []
         self.warnings = []
         self.cancels = []
@@ -278,6 +275,8 @@
                 if 'cancel_button' in name:
                     obj.connect('clicked', self.on_close_clicked)
                     self.cancels.append(obj)
+                if '_button' in name:
+                    obj.connect('activate', lambda w: w.clicked())
                 if 'label' in name:
                     self.labels.append(obj)
 
@@ -525,6 +524,11 @@
             self.tc_hbox.hide_all()
         self.login_button.set_label(self.LOGIN_BUTTON_LABEL)
 
+        for entry in (self.name_entry, self.email1_entry, self.email2_entry,
+                      self.password1_entry, self.password2_entry,
+                      self.captcha_solution_entry):
+            entry.connect('activate', lambda w: self.join_ok_button.clicked())
+
         return self.enter_details_vbox
 
     def _build_tc_page(self):
@@ -540,6 +544,8 @@
 
     def _build_verify_email_page(self):
         """Build the verify email page."""
+        cb = lambda w: self.verify_token_button.clicked()
+        self.email_token_entry.connect('activate', cb)
         self.verify_email_vbox.pack_start(self.email_token_entry, expand=False)
         self.verify_email_vbox.reorder_child(self.email_token_entry, 0)
 
@@ -566,6 +572,9 @@
         self.forgotten_password_button.set_label(msg)
         self.login_ok_button.grab_focus()
 
+        for entry in (self.login_email_entry, self.login_password_entry):
+            entry.connect('activate', lambda w: self.login_ok_button.clicked())
+
         return self.login_vbox
 
     def _build_request_password_token_page(self):
@@ -581,6 +590,9 @@
         self.request_password_token_ok_button.set_label(self.NEXT)
         self.request_password_token_ok_button.set_sensitive(False)
 
+        cb = lambda w: self.request_password_token_ok_button.clicked()
+        self.reset_email_entry.connect('activate', cb)
+
         return self.request_password_token_vbox
 
     def _build_set_new_password_page(self):
@@ -588,10 +600,12 @@
         self.set_new_password_vbox.header = self.RESET_PASSWORD
         self.set_new_password_vbox.help_text = self.SET_NEW_PASSWORD_LABEL
 
+        cb = lambda w: self.set_new_password_ok_button.clicked()
         for entry in (self.reset_code_entry,
                       self.reset_password1_entry,
                       self.reset_password2_entry):
             self.set_new_password_details_vbox.pack_start(entry)
+            entry.connect('activate', cb)
 
         cb = self.on_set_new_password_entries_changed
         self.reset_code_entry.connect('changed', cb)
@@ -649,6 +663,9 @@
 
     def on_join_ok_button_clicked(self, *args, **kwargs):
         """Submit info for processing, present the processing vbox."""
+        if not self.join_ok_button.is_sensitive():
+            return
+
         self._clear_warnings()
 
         error = False
@@ -725,6 +742,9 @@
 
     def on_verify_token_button_clicked(self, *args, **kwargs):
         """The user entered the email token, let's verify!"""
+        if not self.verify_token_button.is_sensitive():
+            return
+
         email = self.email1_entry.get_text()
         password = self.password1_entry.get_text()
         email_token = self.email_token_entry.get_text()
@@ -740,6 +760,9 @@
 
     def on_login_connect_button_clicked(self, *args, **kwargs):
         """User wants to connect!"""
+        if not self.login_ok_button.is_sensitive():
+            return
+
         self._clear_warnings()
 
         error = False
@@ -780,6 +803,9 @@
 
     def on_request_password_token_ok_button_clicked(self, *args, **kwargs):
         """User entered the email address to reset the password."""
+        if not self.request_password_token_ok_button.is_sensitive():
+            return
+
         email = self.reset_email_entry.get_text()
 
         logger.info('Calling request_password_reset_token with %r.', email)
@@ -808,6 +834,9 @@
 
     def on_set_new_password_ok_button_clicked(self, *args, **kwargs):
         """User entered reset code and new passwords."""
+        if not self.set_new_password_ok_button.is_sensitive():
+            return
+
         email = self.reset_email_entry.get_text()
         token = self.reset_code_entry.get_text()
         # XXX: validate passwords!

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-08-26 22:30:15 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-08-27 15:27:59 +0000
@@ -574,6 +574,17 @@
             self.assertEqual(self._called, ((widget,), {}), msg % name)
             self._called = False
 
+    def test_all_buttons_are_activatable(self):
+        """Every button should be activatable."""
+        msg = '"%s" should be activatable.'
+        buttons = filter(lambda name: '_button' in name, self.ui.widgets)
+        for name in buttons:
+            widget = getattr(self.ui, name)
+            widget.connect('clicked', self._set_called)
+            widget.activate()
+            self.assertEqual(self._called, ((widget,), {}), msg % name)
+            self._called = False
+
     def test_window_icon(self):
         """Main window has the proper icon."""
         self.assertEqual('ubuntu-logo', self.ui.window.get_icon_name())
@@ -790,6 +801,50 @@
         actual = self.ui.login_button.get_label()
         self.assertEqual(self.ui.LOGIN_BUTTON_LABEL, actual)
 
+    def test_activate_name_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.name_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_activate_email_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.email1_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+        self._called = False
+        self.ui.email2_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_activate_password_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.password1_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+        self._called = False
+        self.ui.password2_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_activate_captcha_solution_entry_clicks_connect(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.join_ok_button.connect('clicked', self._set_called)
+        self.ui.captcha_solution_entry.activate()
+        self.assertEqual(self._called, ((self.ui.join_ok_button,), {}))
+
+    def test_join_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The join form can only be submitted if the button is sensitive."""
+        self.patch(self.ui.name_entry, 'get_text', self._set_called)
+
+        self.ui.join_ok_button.set_sensitive(False)
+        self.ui.join_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.join_ok_button.set_sensitive(True)
+        self.ui.join_ok_button.clicked()
+        self.assertTrue(self._called)
+
 
 class NoTermsAndConditionsTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (with no t&c link)."""
@@ -986,10 +1041,33 @@
         self.ui.success_close_button.clicked()
         self.assertFalse(self.ui.window.get_property('visible'))
 
+    def test_activate_email_token_entry_clicks_verify_token(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.verify_token_button.connect('clicked', self._set_called)
+        self.ui.email_token_entry.activate()
+        self.assertEqual(self._called, ((self.ui.verify_token_button,), {}))
+
+    def test_verify_token_button_does_nothing_if_clicked_but_disabled(self):
+        """The email token can only be submitted if the button is sensitive."""
+        self.patch(self.ui.email_token_entry, 'get_text', self._set_called)
+
+        self.ui.verify_token_button.set_sensitive(False)
+        self.ui.verify_token_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.verify_token_button.set_sensitive(True)
+        self.ui.verify_token_button.clicked()
+        self.assertTrue(self._called)
+
 
 class RegistrationValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration  validations."""
 
+    def setUp(self):
+        """Init."""
+        super(RegistrationValidationTestCase, self).setUp()
+        self.ui.join_ok_button.set_sensitive(True)
+
     def test_warning_is_shown_if_name_empty(self):
         """A warning message is shown if name is empty."""
         self.ui.name_entry.set_text('')
@@ -1216,6 +1294,30 @@
         self.ui.login_back_button.clicked()
         self.assertFalse(self.ui.warning_label.get_property('visible'))
 
+    def test_activate_email_entry_clicks_login(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.login_ok_button.connect('clicked', self._set_called)
+        self.ui.login_email_entry.activate()
+        self.assertEqual(self._called, ((self.ui.login_ok_button,), {}))
+
+    def test_activate_password_entry_clicks_login(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.login_ok_button.connect('clicked', self._set_called)
+        self.ui.login_password_entry.activate()
+        self.assertEqual(self._called, ((self.ui.login_ok_button,), {}))
+
+    def test_login_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The join form can only be submitted if the button is sensitive."""
+        self.patch(self.ui.login_email_entry, 'get_text', self._set_called)
+
+        self.ui.login_ok_button.set_sensitive(False)
+        self.ui.login_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.login_ok_button.set_sensitive(True)
+        self.ui.login_ok_button.clicked()
+        self.assertTrue(self._called)
+
 
 class LoginValidationTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user login validation."""
@@ -1380,6 +1482,26 @@
         expected = '\n'.join((error['__all__'], error['message']))
         self.assert_correct_label_warning(self.ui.warning_label, expected)
 
+    def test_activate_reset_email_entry_clicks_login(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.request_password_token_ok_button.connect('clicked',
+                                                         self._set_called)
+        self.ui.reset_email_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.request_password_token_ok_button,), {}))
+
+    def test_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The password token can be requested if the button is sensitive."""
+        self.patch(self.ui.reset_email_entry, 'get_text', self._set_called)
+
+        self.ui.request_password_token_ok_button.set_sensitive(False)
+        self.ui.request_password_token_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.request_password_token_ok_button.set_sensitive(True)
+        self.ui.request_password_token_ok_button.clicked()
+        self.assertTrue(self._called)
+
 
 class SetNewPasswordTestCase(UbuntuSSOClientTestCase):
     """Test suite for setting a new password functionality."""
@@ -1448,6 +1570,37 @@
         expected = '\n'.join((error['__all__'], error['message']))
         self.assert_correct_label_warning(self.ui.warning_label, expected)
 
+    def test_activate_reset_code_entry_clicks_set_new_password(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.set_new_password_ok_button.connect('clicked', self._set_called)
+        self.ui.reset_code_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.set_new_password_ok_button,), {}))
+
+    def test_activate_password_entry_clicks_set_new_password(self):
+        """Activating any entry generates a connect attempt."""
+        self.ui.set_new_password_ok_button.connect('clicked', self._set_called)
+        self.ui.reset_password1_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.set_new_password_ok_button,), {}))
+
+        self._called = False
+        self.ui.reset_password2_entry.activate()
+        self.assertEqual(self._called,
+                         ((self.ui.set_new_password_ok_button,), {}))
+
+    def test_ok_button_does_nothing_if_clicked_but_disabled(self):
+        """The new passwrd can only be set if the button is sensitive."""
+        self.patch(self.ui.reset_code_entry, 'get_text', self._set_called)
+
+        self.ui.set_new_password_ok_button.set_sensitive(False)
+        self.ui.set_new_password_ok_button.clicked()
+        self.assertFalse(self._called)
+
+        self.ui.set_new_password_ok_button.set_sensitive(True)
+        self.ui.set_new_password_ok_button.clicked()
+        self.assertTrue(self._called)
+
 
 class DbusTestCase(UbuntuSSOClientTestCase):
     """Test suite for the dbus calls."""