Merge lp:~nataliabidart/ubuntu-sso-client/filter-by-app-name into lp:ubuntu-sso-client

[Natalia Bidart]

* Signals from the DBus "UserManagement" service are now filtered by app name (LP: #629025).

Before this branch, the GUI processed every signal emitted by the "UserManagement" DBus service.

To test this, you should open more than one GUI (for different app_names) and proceed to do different things in each one. Each GUI instance should behave properly (ie events from one should not interfere in the other).

[Rodrigo Moya (rodrigo-moya)]

review: Approve

[John Lenton (chipaca)]

review: Approve

=== modified file 'contrib/testing/testcase.py'
--- contrib/testing/testcase.py	2010-09-03 21:14:00 +0000
+++ contrib/testing/testcase.py	2010-09-07 14:11:20 +0000
@@ -90,9 +90,9 @@
         """Just add the record to self.records."""
         self.records.append(record)
 
-    def check(self, level, msg):
-        """Check that something is logged."""
+    def check(self, level, *msgs):
+        """Verifies that the msgs are logged in the specified level."""
         for rec in self.records:
-            if rec.levelno == level and str(msg) in rec.message:
+            if rec.levelno == level and all(m in rec.message for m in msgs):
                 return True
         return False

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-09-03 21:14:00 +0000
+++ ubuntu_sso/gui.py	2010-09-07 14:11:20 +0000
@@ -341,19 +341,32 @@
         for label in self.labels:
             label.set_size_request(*size_req)
 
-        self._signals = [
-            ('CaptchaGenerated', self.on_captcha_generated),
-            ('CaptchaGenerationError', self.on_captcha_generation_error),
-            ('UserRegistered', self.on_user_registered),
-            ('UserRegistrationError', self.on_user_registration_error),
-            ('EmailValidated', self.on_email_validated),
-            ('EmailValidationError', self.on_email_validation_error),
-            ('LoggedIn', self.on_logged_in),
-            ('LoginError', self.on_login_error),
-            ('PasswordResetTokenSent', self.on_password_reset_token_sent),
-            ('PasswordResetError', self.on_password_reset_error),
-            ('PasswordChanged', self.on_password_changed),
-            ('PasswordChangeError', self.on_password_change_error)]
+        self._signals = {
+            'CaptchaGenerated':
+             self._filter_by_app_name(self.on_captcha_generated),
+            'CaptchaGenerationError':
+             self._filter_by_app_name(self.on_captcha_generation_error),
+            'UserRegistered':
+             self._filter_by_app_name(self.on_user_registered),
+            'UserRegistrationError':
+             self._filter_by_app_name(self.on_user_registration_error),
+            'EmailValidated':
+             self._filter_by_app_name(self.on_email_validated),
+            'EmailValidationError':
+             self._filter_by_app_name(self.on_email_validation_error),
+            'LoggedIn':
+             self._filter_by_app_name(self.on_logged_in),
+            'LoginError':
+             self._filter_by_app_name(self.on_login_error),
+            'PasswordResetTokenSent':
+             self._filter_by_app_name(self.on_password_reset_token_sent),
+            'PasswordResetError':
+             self._filter_by_app_name(self.on_password_reset_error),
+            'PasswordChanged':
+             self._filter_by_app_name(self.on_password_changed),
+            'PasswordChangeError':
+             self._filter_by_app_name(self.on_password_change_error),
+        }
         self._setup_signals()
         self._gtk_signal_log = []
 
@@ -377,10 +390,27 @@
 
         self.window.show()
 
+    def _filter_by_app_name(self, f):
+        """Excecute the decorated function only for 'self.app_name'."""
+
+        @wraps(f)
+        def inner(app_name, *args, **kwargs):
+            """Execute 'f' only if 'app_name' matches 'self.app_name'."""
+            result = None
+            if app_name == self.app_name:
+                result = f(app_name, *args, **kwargs)
+            else:
+                logger.info('%s: ignoring call since received app_name '\
+                            '"%s" (expected "%s")',
+                            f.__name__, app_name, self.app_name)
+            return result
+
+        return inner
+
     def _setup_signals(self):
         """Bind signals to callbacks to be able to test the pages."""
         iface = self.iface_name
-        for signal, method in self._signals:
+        for signal, method in self._signals.iteritems():
             actual = self._signals_receivers.get((iface, signal))
             if actual is not None:
                 msg = 'Signal %r is already connected with %r at iface %r.'

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-09-03 21:24:47 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-09-07 14:11:20 +0000
@@ -1780,26 +1780,118 @@
 
     def test_all_the_signals_are_listed(self):
         """All the backend signals are listed to be binded."""
-        names = [sig for (sig, _) in self.ui._signals]
         for sig in ('CaptchaGenerated', 'CaptchaGenerationError',
                     'UserRegistered', 'UserRegistrationError',
                     'LoggedIn', 'LoginError',
                     'EmailValidated', 'EmailValidationError',
                     'PasswordResetTokenSent', 'PasswordResetError',
                     'PasswordChanged', 'PasswordChangeError'):
-            self.assertIn(sig, names)
+            self.assertIn(sig, self.ui._signals)
 
     def test_signal_receivers_are_connected(self):
         """Callbacks are connected to signals of interest."""
         msg1 = 'callback %r for signal %r must be added to the internal bus.'
         msg2 = 'callback %r for signal %r must be added to the ui log.'
         dbus_iface = self.ui.iface_name
-        for signal, method in self.ui._signals:
+        for signal, method in self.ui._signals.iteritems():
             actual = self.ui.bus.callbacks.get((dbus_iface, signal))
             self.assertEqual(method, actual, msg1 % (method, signal))
             actual = self.ui._signals_receivers.get((dbus_iface, signal))
             self.assertEqual(method, actual, msg2 % (method, signal))
 
+    def test_callbacks_only_log_when_app_name_doesnt_match(self):
+        """Callbacks do nothing but logging when app_name doesn't match."""
+        mismatch_app_name = self.ui.app_name * 2
+        for method in self.ui._signals.itervalues():
+            msgs = ('ignoring', method.__name__, mismatch_app_name)
+            method(mismatch_app_name, 'dummy')
+            self.assertTrue(self.memento.check(logging.INFO, *msgs))
+            self.memento.records = []
+
+    def test_on_captcha_generated_is_not_called(self):
+        """on_captcha_generated is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_captcha_generated', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['CaptchaGenerated'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_captcha_generation_error_is_not_called(self):
+        """on_captcha_generation_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_captcha_generation_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['CaptchaGenerationError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_user_registered_is_not_called(self):
+        """on_user_registered is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_user_registered', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['UserRegistered'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_user_registration_error_is_not_called(self):
+        """on_user_registration_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_user_registration_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['UserRegistrationError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_email_validated_is_not_called(self):
+        """on_email_validated is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_email_validated', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['EmailValidated'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_email_validation_error_is_not_called(self):
+        """on_email_validation_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_email_validation_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['EmailValidationError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_logged_in_is_not_called(self):
+        """on_logged_in is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_logged_in', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['LoggedIn'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_login_error_is_not_called(self):
+        """on_login_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_login_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['LoginError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_reset_token_sent_is_not_called(self):
+        """on_password_reset_token_sent is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_reset_token_sent', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordResetTokenSent'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_reset_error_is_not_called(self):
+        """on_password_reset_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_reset_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordResetError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_changed_is_not_called(self):
+        """on_password_changed is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_changed', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordChanged'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
+    def test_on_password_change_error_is_not_called(self):
+        """on_password_change_error is not called if incorrect app_name."""
+        self.patch(self.ui, 'on_password_change_error', self._set_called)
+        mismatch_app_name = self.ui.app_name * 2
+        self.ui._signals['PasswordChangeError'](mismatch_app_name, 'dummy')
+        self.assertFalse(self._called)
+
 
 class LoginOnlyTestCase(UbuntuSSOClientTestCase):
     """Test suite for the login only GUI."""

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-09-07 12:15:46 +0000
+++ ubuntu_sso/tests/test_main.py	2010-09-07 14:11:20 +0000
@@ -1181,7 +1181,7 @@
 
         self.assertTrue(1, len(self.memento.records))
         self.assertTrue(self.memento.check(logging.ERROR,
-                                           LOGIN_OR_REGISTER_GUI_ARGS))
+                                           str(LOGIN_OR_REGISTER_GUI_ARGS)))
         exc_info = self.memento.records[0].exc_info
         self.assertIn(self.args, exc_info)
 
@@ -1244,7 +1244,7 @@
 
         self.assertTrue(1, len(self.memento.records))
         self.assertTrue(self.memento.check(logging.ERROR,
-                                           LOGIN_ONLY_GUI_ARGS))
+                                           str(LOGIN_ONLY_GUI_ARGS)))
         exc_info = self.memento.records[0].exc_info
         self.assertIn(self.args, exc_info)