Merge lp:~nataliabidart/ubuntu-sso-client/ping-server into lp:ubuntu-sso-client

[Natalia Bidart]

Ping an URL when the login was successful (LP: #621226).
Signals propagates the app_name to be later check by the GUI so only those belonging to it will be processed (LP: #621377).

Ping an URL when the login was successful.
Also, signals propagates the app_name to be later check by the GUI so only those belonging to it will be processed.

[lp:~nataliabidart/ubuntu-sso-client/ping-server]

589. By Natalia Bidart on 2010-08-23

Removing an unneeded change.

[John Lenton (chipaca)]

The branch looks good. It has some kind of a segfault issue, but it looks like it's in trunk also; nessita will be looking into it more.

review: Approve

[Rodrigo Moya (rodrigo-moya)]

review: Approve

=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2010-08-23 13:32:24 +0000
+++ ubuntu_sso/gui.py	2010-08-24 00:02:39 +0000
@@ -57,10 +57,10 @@
 SIG_USER_CANCELATION = 'user-cancelation'
 
 SIGNAL_ARGUMENTS = [
-    (SIG_LOGIN_FAILED, (gobject.TYPE_STRING,)),
-    (SIG_LOGIN_SUCCEEDED, (gobject.TYPE_STRING,)),
-    (SIG_REGISTRATION_FAILED, (gobject.TYPE_STRING,)),
-    (SIG_REGISTRATION_SUCCEEDED, (gobject.TYPE_STRING,)),
+    (SIG_LOGIN_FAILED, (gobject.TYPE_STRING, gobject.TYPE_STRING)),
+    (SIG_LOGIN_SUCCEEDED, (gobject.TYPE_STRING, gobject.TYPE_STRING,)),
+    (SIG_REGISTRATION_FAILED, (gobject.TYPE_STRING, gobject.TYPE_STRING)),
+    (SIG_REGISTRATION_SUCCEEDED, (gobject.TYPE_STRING, gobject.TYPE_STRING,)),
     (SIG_USER_CANCELATION, (gobject.TYPE_STRING,)),
 ]
 
@@ -100,6 +100,18 @@
     return os.path.join(get_data_dir(), filename)
 
 
+def log_call(f):
+    """Decorator to log call funtions."""
+
+    @wraps(f)
+    def inner(*args, **kwargs):
+        """Execute 'f' logging the call as INFO."""
+        logger.info('%s: args %r, kwargs %r.', f.__name__, args, kwargs)
+        return f(*args, **kwargs)
+
+    return inner
+
+
 class LabeledEntry(gtk.Entry):
     """An entry that displays the label within itself ina grey color."""
 
@@ -472,7 +484,7 @@
         logger.info('Calling generate_captcha with filename path at %r',
                     self._captcha_filename)
         f = self.backend.generate_captcha
-        f(self._captcha_filename,
+        f(self.app_name, self._captcha_filename,
           reply_handler=NO_OP, error_handler=NO_OP)
 
         return self.enter_details_vbox
@@ -669,7 +681,7 @@
                     ' captcha_id %r and captcha_solution %r.', email1,
                     self._captcha_id, captcha_solution)
         f = self.backend.register_user
-        f(email1, password1, self._captcha_id, captcha_solution,
+        f(self.app_name, email1, password1, self._captcha_id, captcha_solution,
           reply_handler=NO_OP, error_handler=NO_OP)
 
     def on_tc_button_clicked(self, *args, **kwargs):
@@ -690,7 +702,7 @@
                     ', app_name %r and email_token %r.', email,
                     self.app_name, email_token)
         f = self.backend.validate_email
-        f(email, password, self.app_name, email_token,
+        f(self.app_name, email, password, email_token,
           reply_handler=NO_OP, error_handler=NO_OP)
 
         self._set_current_page(self.processing_vbox)
@@ -725,7 +737,7 @@
         self._clear_warnings()
 
         f = self.backend.login
-        f(email, password, self.app_name,
+        f(self.app_name, email, password,
           reply_handler=NO_OP, error_handler=NO_OP)
 
         self._set_current_page(self.processing_vbox)
@@ -744,7 +756,7 @@
 
         logger.info('Calling request_password_reset_token with %r.', email)
         f = self.backend.request_password_reset_token
-        f(email, reply_handler=NO_OP, error_handler=NO_OP)
+        f(self.app_name, email, reply_handler=NO_OP, error_handler=NO_OP)
 
         self._set_current_page(self.processing_vbox)
 
@@ -778,7 +790,8 @@
         logger.info('Calling set_new_password with email %r, token %r and ' \
                     'new password: <hidden>.', email, token)
         f = self.backend.set_new_password
-        f(email, token, password1, reply_handler=NO_OP, error_handler=NO_OP)
+        f(self.app_name, email, token, password1,
+          reply_handler=NO_OP, error_handler=NO_OP)
 
         self._set_current_page(self.processing_vbox)
 
@@ -800,83 +813,81 @@
 
     # backend callbacks
 
-    def on_captcha_generated(self, captcha_id, *args, **kwargs):
+    @log_call
+    def on_captcha_generated(self, app_name, captcha_id, *args, **kwargs):
         """Captcha image has been generated and is available to be shown."""
         assert captcha_id is not None
         self._captcha_id = captcha_id
         self._set_captcha_image()
 
-    def on_captcha_generation_error(self, *args, **kwargs):
+    @log_call
+    def on_captcha_generation_error(self, app_name, error, *args, **kwargs):
         """Captcha image generation failed."""
-        logger.warning('on_captcha_generation_error: args %r, kwargs %r',
-                       args, kwargs)
 
-    def on_user_registered(self, *args, **kwargs):
+    @log_call
+    def on_user_registered(self, app_name, email, *args, **kwargs):
         """Registration can go on, user needs to verify email."""
-        logger.info('on_user_registered: user was successfully registered! ' \
-                    'args %r, kwargs %r.', args, kwargs)
         self._set_current_page(self.verify_email_vbox)
 
-    def on_user_registration_error(self, *args, **kwargs):
+    @log_call
+    def on_user_registration_error(self, app_name, error, *args, **kwargs):
         """Captcha image generation failed."""
-        logger.warning('on_user_registration_error: args %r, kwargs %r',
-                       args, kwargs)
         self._set_current_page(self.enter_details_vbox,
                                warning_text=self.UNKNOWN_ERROR)
-        self._gtk_signal_log.append((SIG_REGISTRATION_FAILED, self.app_name))
+        self._gtk_signal_log.append((SIG_REGISTRATION_FAILED, self.app_name,
+                                     error))
 
-    def on_email_validated(self, app_name, *args, **kwargs):
+    @log_call
+    def on_email_validated(self, app_name, email, *args, **kwargs):
         """User email was successfully verified."""
-        logger.info('on_email_validated: email was successfully validated! ' \
-                    'app_name %r, args %r, kwargs %r.', app_name, args, kwargs)
         self._set_current_page(self.success_vbox)
-        self._gtk_signal_log.append((SIG_REGISTRATION_SUCCEEDED, app_name))
+        self._gtk_signal_log.append((SIG_REGISTRATION_SUCCEEDED, self.app_name,
+                                    email))
 
-    def on_email_validation_error(self, *args, **kwargs):
+    @log_call
+    def on_email_validation_error(self, app_name, error, *args, **kwargs):
         """User email validation failed."""
-        logger.warning('on_email_validation_error: args %r, kwargs %r',
-                       args, kwargs)
         self._set_current_page(self.verify_email_vbox,
                                warning_text=self.UNKNOWN_ERROR)
-        self._gtk_signal_log.append((SIG_REGISTRATION_FAILED, self.app_name))
+        self._gtk_signal_log.append((SIG_REGISTRATION_FAILED, self.app_name,
+                                     error))
 
-    def on_logged_in(self, app_name, *args, **kwargs):
+    @log_call
+    def on_logged_in(self, app_name, email, *args, **kwargs):
         """User was successfully logged in."""
-        logger.info('on_logged_in: user was successfully logged in! '
-                    'args %r, kwargs %r', args, kwargs)
         self._set_current_page(self.success_vbox)
-        self._gtk_signal_log.append((SIG_LOGIN_SUCCEEDED, app_name))
+        self._gtk_signal_log.append((SIG_LOGIN_SUCCEEDED, self.app_name,
+                                    email))
 
-    def on_login_error(self, *args, **kwargs):
+    @log_call
+    def on_login_error(self, app_name, error, *args, **kwargs):
         """User was not successfully logged in."""
-        logger.warning('on_login_error: args %r, kwargs %r',
-                       args, kwargs)
         self._set_current_page(self.login_vbox,
                                warning_text=self.UNKNOWN_ERROR)
-        self._gtk_signal_log.append((SIG_LOGIN_FAILED, self.app_name))
+        self._gtk_signal_log.append((SIG_LOGIN_FAILED, self.app_name,
+                                     error))
 
-    def on_password_reset_token_sent(self, email, *args, **kwargs):
+    @log_call
+    def on_password_reset_token_sent(self, app_name, email, *args, **kwargs):
         """Password reset token was successfully sent."""
-        email = self.reset_email_entry.get_text()
         msg = self.SET_NEW_PASSWORD_LABEL % {'email': email}
         self.set_new_password_vbox.help_text = msg
         self._set_current_page(self.set_new_password_vbox)
 
-    def on_password_reset_error(self, *args, **kwargs):
+    @log_call
+    def on_password_reset_error(self, app_name, error, *args, **kwargs):
         """Password reset failed."""
-        logger.warning('on_password_reset_error: args %r, kwargs %r',
-                       args, kwargs)
         self._set_current_page(self.login_vbox,
                                warning_text=self.UNKNOWN_ERROR)
 
-    def on_password_changed(self, email, *args, **kwargs):
+    @log_call
+    def on_password_changed(self, app_name, email, *args, **kwargs):
         """Password was successfully changed."""
         self._set_current_page(self.login_vbox,
                                warning_text=self.PASSWORD_CHANGED)
 
-    def on_password_change_error(self, *args, **kwargs):
+    @log_call
+    def on_password_change_error(self, app_name, error, *args, **kwargs):
         """Password reset failed."""
-        logger.warning('on_password_change_error: args %r, kwargs %r',
-                       args, kwargs)
         self._set_current_page(self.request_password_token_vbox,
                                warning_text=self.UNKNOWN_ERROR)

=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2010-08-23 19:23:40 +0000
+++ ubuntu_sso/main.py	2010-08-24 00:02:39 +0000
@@ -59,6 +59,7 @@
 
 OLD_KEY_NAME = "UbuntuOne token for https://ubuntuone.com"
 U1_APP_NAME = "Ubuntu One"
+PING_URL = "http://one.ubuntu.com/oauth/sso-finished-so-get-tokens/"
 
 
 class NoDefaultConfigError(Exception):
@@ -199,17 +200,16 @@
         elif result['status'] != 'ok':
             raise RegistrationError('Received unknown status: %s' % result)
         else:
-            return True
+            return email
 
-    def login(self, email, password, app_name):
+    def login(self, email, password, token_name):
         """Login a user with 'email' and 'password'."""
-        logger.debug('login: email: %r password: <hidden>, app_name: %r',
-                     email, app_name)
+        logger.debug('login: email: %r password: <hidden>, token_name: %r',
+                     email, token_name)
         basic = BasicHttpAuthorizer(email, password)
         sso_service = self.sso_service_class(basic, self.service_url)
         service = sso_service.authentications.authenticate
 
-        token_name = get_token_name(app_name)
         try:
             credentials = service(token_name=token_name)
         except HTTPError:
@@ -218,16 +218,15 @@
 
         logger.debug('login: authentication successful! consumer_key: %r, ' \
                      'token_name: %r', credentials['consumer_key'], token_name)
-        keyring_store_credentials(app_name, credentials)
         return credentials
 
-    def validate_email(self, email, password, app_name, email_token):
+    def validate_email(self, email, password, email_token, token_name):
         """Validate an email token for user with 'email' and 'password'."""
         logger.debug('validate_email: email: %r password: <hidden>, '
-                     'app_name: %r, email_token: %r',
-                     email, app_name, email_token)
+                     'email_token: %r, token_name: %r.',
+                     email, email_token, token_name)
         token = self.login(email=email, password=password,
-                           app_name=app_name)
+                           token_name=token_name)
 
         oauth_token = OAuthToken(token['token'], token['token_secret'])
         authorizer = OAuthAuthorizer(token['consumer_key'],
@@ -239,7 +238,7 @@
         if 'errors' in result:
             raise EmailTokenError(result['errors'])
         elif 'email' in result:
-            return True
+            return result['email']
         else:
             raise EmailTokenError('Received invalid reply: %s' % result)
 
@@ -254,7 +253,7 @@
             raise ResetPasswordTokenError(e.content)
 
         if result['status'] == 'ok':
-            return True
+            return email
         else:
             raise ResetPasswordTokenError('Received invalid reply: %s' %
                                           result)
@@ -276,7 +275,7 @@
             raise NewPasswordError(e.content)
 
         if result['status'] == 'ok':
-            return True
+            return email
         else:
             raise NewPasswordError('Received invalid reply: %s' % result)
 
@@ -289,16 +288,16 @@
     }
 
 
-def blocking(f, result_cb, error_cb):
+def blocking(f, app_name, result_cb, error_cb):
     """Run f in a thread; return or throw an exception thru the callbacks."""
     def _in_thread():
         """The part that runs inside the thread."""
         try:
-            result_cb(f())
+            result_cb(app_name, f())
         except Exception, e:
             msg = "Exception while running DBus blocking code in a thread."""
             logger.exception(msg)
-            error_cb(except_to_errdict(e))
+            error_cb(app_name, except_to_errdict(e))
     threading.Thread(target=_in_thread).start()
 
 
@@ -320,119 +319,123 @@
                                     sso_service_class=self.sso_service_class)
 
     # generate_capcha signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
-    def CaptchaGenerated(self, result):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def CaptchaGenerated(self, app_name, result):
         """Signal thrown after the captcha is generated."""
 
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="a{ss}")
-    def CaptchaGenerationError(self, error):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def CaptchaGenerationError(self, app_name, error):
         """Signal thrown when there's a problem generating the captcha."""
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='s')
-    def generate_captcha(self, filename):
+                         in_signature='ss')
+    def generate_captcha(self, app_name, filename):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
             return self.processor().generate_captcha(filename)
-        blocking(f, self.CaptchaGenerated, self.CaptchaGenerationError)
+        blocking(f, app_name, self.CaptchaGenerated,
+                 self.CaptchaGenerationError)
 
     # register_user signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="b")
-    def UserRegistered(self, result):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def UserRegistered(self, app_name, result):
         """Signal thrown when the user is registered."""
 
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="a{ss}")
-    def UserRegistrationError(self, error):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def UserRegistrationError(self, app_name, error):
         """Signal thrown when there's a problem registering the user."""
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='ssss')
-    def register_user(self, email, password, captcha_id, captcha_solution):
+                         in_signature='sssss')
+    def register_user(self, app_name, email, password,
+                      captcha_id, captcha_solution):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
             return self.processor().register_user(email, password,
-                                              captcha_id, captcha_solution)
-        blocking(f, self.UserRegistered, self.UserRegistrationError)
+                                                  captcha_id, captcha_solution)
+        blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
 
     # login signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
-    def LoggedIn(self, result):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def LoggedIn(self, app_name, result):
         """Signal thrown when the user is logged in."""
 
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="a{ss}")
-    def LoginError(self, error):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def LoginError(self, app_name, error):
         """Signal thrown when there is a problem in the login."""
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='sss')
-    def login(self, email, password, app_name):
+    def login(self, app_name, email, password):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            credentials = self.processor().login(email, password, app_name)
+            token_name = get_token_name(app_name)
+            credentials = self.processor().login(email, password, token_name)
             assert credentials is not None
-            return app_name
-        blocking(f, self.LoggedIn, self.LoginError)
+            keyring_store_credentials(app_name, credentials)
+            return email
+        blocking(f, app_name, self.LoggedIn, self.LoginError)
 
     # validate_email signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
-    def EmailValidated(self, app_name):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def EmailValidated(self, app_name, result):
         """Signal thrown after the email is validated."""
 
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="a{ss}")
-    def EmailValidationError(self, error):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def EmailValidationError(self, app_name, error):
         """Signal thrown when there's a problem validating the email."""
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ssss')
-    def validate_email(self, email, password, app_name, email_token):
+    def validate_email(self, app_name, email, password, email_token):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            self.processor().validate_email(email, password,
-                                               app_name, email_token)
-            return app_name
-        blocking(f, self.EmailValidated, self.EmailValidationError)
+            token_name = get_token_name(app_name)
+            return self.processor().validate_email(email, password,
+                                                   email_token, token_name)
+        blocking(f, app_name, self.EmailValidated, self.EmailValidationError)
 
     # request_password_reset_token signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
-    def PasswordResetTokenSent(self, email):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def PasswordResetTokenSent(self, app_name, email):
         """Signal thrown when the token is succesfully sent."""
 
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="a{ss}")
-    def PasswordResetError(self, error):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def PasswordResetError(self, app_name, error):
         """Signal thrown when there's a problem sending the token."""
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='s')
-    def request_password_reset_token(self, email):
+                         in_signature='ss')
+    def request_password_reset_token(self, app_name, email):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            self.processor().request_password_reset_token(email)
-            return email
-        blocking(f, self.PasswordResetTokenSent, self.PasswordResetError)
+            return self.processor().request_password_reset_token(email)
+        blocking(f, app_name, self.PasswordResetTokenSent,
+                 self.PasswordResetError)
 
     # set_new_password signals
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="s")
-    def PasswordChanged(self, email):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
+    def PasswordChanged(self, app_name, email):
         """Signal thrown when the token is succesfully sent."""
 
-    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="a{ss}")
-    def PasswordChangeError(self, error):
+    @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="sa{ss}")
+    def PasswordChangeError(self, app_name, error):
         """Signal thrown when there's a problem sending the token."""
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
-                         in_signature='sss')
-    def set_new_password(self, email, token, new_password):
+                         in_signature='ssss')
+    def set_new_password(self, app_name, email, token, new_password):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            self.processor().set_new_password(email, token, new_password)
-            return email
-        blocking(f, self.PasswordChanged, self.PasswordChangeError)
+            return self.processor().set_new_password(email, token,
+                                                     new_password)
+        blocking(f, app_name, self.PasswordChanged, self.PasswordChangeError)
 
 
 class SSOCredentials(dbus.service.Object):
@@ -460,8 +463,9 @@
         else:
             return token
 
-    def _login_success_cb(self, dialog, app_name):
+    def _login_success_cb(self, dialog, app_name, email):
         """Handles the response from the UI dialog."""
+        logger.info('Login successful for app %r, email %r', app_name, email)
         try:
             creds = keyring_get_credentials(app_name)
             self.CredentialsFound(app_name, creds)
@@ -470,16 +474,21 @@
             logger.exception(msg)
             self.CredentialsError(app_name, msg, traceback.format_exc())
 
-    def _login_error_cb(self, dialog, app_name):
+    def _login_error_cb(self, dialog, app_name, error):
         """Handles a problem in the UI."""
+        logger.info('Login unsuccessful for app %r, error %r', app_name, error)
         msg = "Problem getting the credentials from the keyring."
         self.CredentialsError(app_name, msg, "no more info available")
-        logger.error(msg)
 
     def _login_auth_denied_cb(self, dialog, app_name):
         """The user decides not to allow the registration or login."""
         self.AuthorizationDenied(app_name)
 
+    def _ping_url(self, dialog, app_name, email):
+        """Ping the given url."""
+        if app_name == U1_APP_NAME:
+            urllib2.urlopen(PING_URL + email)
+
     def _show_login_or_register_ui(self, app_name, tc_url, help_text,
                                    win_id, login_only=False):
         """Shows the UI so the user can login or register."""
@@ -487,9 +496,11 @@
             gui_app = gui.UbuntuSSOClientGUI(app_name, tc_url,
                                              help_text, win_id, login_only)
             gui_app.connect(gui.SIG_LOGIN_SUCCEEDED, self._login_success_cb)
+            gui_app.connect(gui.SIG_LOGIN_SUCCEEDED, self._ping_url)
             gui_app.connect(gui.SIG_LOGIN_FAILED, self._login_error_cb)
             gui_app.connect(gui.SIG_REGISTRATION_SUCCEEDED,
                             self._login_success_cb)
+            gui_app.connect(gui.SIG_REGISTRATION_SUCCEEDED, self._ping_url)
             gui_app.connect(gui.SIG_REGISTRATION_FAILED, self._login_error_cb)
             gui_app.connect(gui.SIG_USER_CANCELATION,
                             self._login_auth_denied_cb)

=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2010-08-23 13:32:24 +0000
+++ ubuntu_sso/tests/test_gui.py	2010-08-24 00:02:39 +0000
@@ -44,6 +44,7 @@
 CAPTCHA_SOLUTION = 'william Byrd'
 EMAIL = '[e-mail]'
 EMAIL_TOKEN = 'B2Pgtf'
+ERROR = 'Something bad happened!'
 NAME = 'Juanito Pérez'
 PASSWORD = 'h3lloWorld'
 RESET_PASSWORD_TOKEN = '8G5Wtq'
@@ -358,7 +359,7 @@
 
     def click_join_with_valid_data(self):
         """Move to the next page after entering details."""
-        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)  # we have captcha!
+        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
 
         self.ui.name_entry.set_text(NAME)
         # match emails
@@ -598,7 +599,8 @@
         expected = 'register_user'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((EMAIL, PASSWORD, CAPTCHA_ID, CAPTCHA_SOLUTION),
+                         ((APP_NAME, EMAIL, PASSWORD, CAPTCHA_ID,
+                           CAPTCHA_SOLUTION),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
@@ -678,18 +680,18 @@
 
     def test_join_ok_button_is_enabled_when_captcha_is_available(self):
         """The join_ok_button is sensitive when captcha is available."""
-        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
         self.assertTrue(self.ui.join_ok_button.is_sensitive())
 
     def test_captcha_loading_is_hid_when_captcha_is_available(self):
         """The captcha_loading is hid when captcha is available."""
-        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
         self.assertFalse(self.ui.captcha_loading.get_property('visible'),
                          'captcha_loading is not visible.')
 
     def test_captcha_id_is_stored_when_captcha_is_available(self):
         """The captcha_id is stored when captcha is available."""
-        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
         self.assertEqual(CAPTCHA_ID, self.ui._captcha_id)
 
     def test_captcha_image_is_requested_as_startup(self):
@@ -698,14 +700,14 @@
         expected = 'generate_captcha'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((self.ui._captcha_filename,),
+                         ((APP_NAME, self.ui._captcha_filename),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
     def test_captcha_is_shown_when_available(self):
         """The captcha image is shown when available."""
         self.patch(self.ui.captcha_image, 'set_from_file', self._set_called)
-        self.ui.on_captcha_generated(captcha_id=CAPTCHA_ID)
+        self.ui.on_captcha_generated(app_name=APP_NAME, captcha_id=CAPTCHA_ID)
         self.assertTrue(self.ui.captcha_image.get_property('visible'))
         self.assertEqual(self._called, ((self.ui._captcha_filename,), {}))
 
@@ -770,7 +772,7 @@
         """Init."""
         super(UserRegistrationErrorTestCase, self).setUp()
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error()
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
 
     def test_previous_page_is_shown(self):
         """On UserRegistrationError the previous page is shown."""
@@ -788,6 +790,7 @@
     def setUp(self):
         """Init."""
         super(VerifyEmailTestCase, self).setUp()
+        self.ui.on_user_registered(app_name=APP_NAME, email=EMAIL)
         self.click_verify_email_with_valid_data()
 
     def test_verify_email_image_is_correct(self):
@@ -798,12 +801,11 @@
 
     def test_registration_successful_shows_verify_email_vbox(self):
         """Receiving 'registration_successful' shows the verify email vbox."""
-        self.ui.on_user_registered()
+        self.ui.on_user_registered(app_name=APP_NAME, email=EMAIL)
         self.assert_pages_visibility(verify_email=True)
 
     def test_help_label_display_correct_wording(self):
         """The help_label display VERIFY_EMAIL_LABEL."""
-        self.ui.on_user_registered()
         msg = 'help_label must read "%s" (got "%s" instead).'
         actual = self.ui.help_label.get_text()
         expected = self.ui.VERIFY_EMAIL_LABEL
@@ -815,7 +817,7 @@
         expected = 'validate_email'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((EMAIL, PASSWORD, APP_NAME, EMAIL_TOKEN),
+                         ((APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
@@ -832,18 +834,18 @@
 
     def test_on_email_validated_shows_success_page(self):
         """On email validated the success page is shown."""
-        self.ui.on_email_validated(APP_NAME)
+        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.assert_pages_visibility(success=True)
 
     def test_on_email_validated_clears_the_help_text(self):
         """On email validated the help text is removed."""
-        self.ui.on_email_validated(APP_NAME)
+        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.assertEqual('', self.ui.help_label.get_text())
     test_on_email_validated_clears_the_help_text.skip = 'Maybe this is wrong.'
 
     def test_on_email_validation_error_verify_email_is_shown(self):
         """On email validation error, the verify_email page is shown."""
-        self.ui.on_email_validation_error()
+        self.ui.on_email_validation_error(app_name=APP_NAME, error=ERROR)
         self.assert_pages_visibility(verify_email=True)
         self.assert_correct_warning(self.ui.warning_label,
                                     self.ui.UNKNOWN_ERROR)
@@ -1033,7 +1035,7 @@
         expected = 'login'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((EMAIL, PASSWORD, APP_NAME),
+                         ((APP_NAME, EMAIL, PASSWORD),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
@@ -1045,26 +1047,26 @@
     def test_on_logged_in_morphs_to_success_page(self):
         """When user logged in the success page is shown."""
         self.click_connect_with_valid_data()
-        self.ui.on_logged_in(APP_NAME)
+        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.assert_pages_visibility(success=True)
 
     def test_on_login_error_morphs_to_login_page(self):
         """On user login error, the previous page is shown."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error()
+        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
         self.assert_pages_visibility(login=True)
 
     def test_on_login_error_a_warning_is_shown(self):
         """On user login error, a warning is shown with proper wording."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error()
+        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
         self.assert_correct_warning(self.ui.warning_label,
                                     self.ui.UNKNOWN_ERROR)
 
     def test_back_to_registration_hides_warning(self):
         """After user login error, warning is hidden when clicking 'Back'."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error()
+        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
         self.ui.login_back_button.clicked()
         self.assertFalse(self.ui.warning_label.get_property('visible'))
 
@@ -1188,20 +1190,20 @@
         expected = 'request_password_reset_token'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((EMAIL,),
+                         ((APP_NAME, EMAIL),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
     def test_on_password_reset_token_sent_morphs_window(self):
         """When the reset token was sent, the reset password page is shown."""
         self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(email=EMAIL)
+        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
         self.assert_pages_visibility(set_new_password=True)
 
     def test_on_password_reset_token_sent_help_text(self):
         """Clicking request_password_token_ok_button changes the help text."""
         self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(email=EMAIL)
+        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
 
         self.assertEqual(self.ui.help_label.get_text(),
                          self.ui.SET_NEW_PASSWORD_LABEL % {'email': EMAIL})
@@ -1209,14 +1211,14 @@
     def test_on_password_reset_token_sent_ok_button(self):
         """After request_password_token_ok_button the ok button is updated."""
         self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(email=EMAIL)
+        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
 
         self.assertEqual(self.ui.set_new_password_ok_button.get_label(),
                          self.ui.RESET_PASSWORD)
 
     def test_on_password_reset_error_shows_login_page(self):
         """When reset token wasn't successfuly sent the login page is shown."""
-        self.ui.on_password_reset_error()
+        self.ui.on_password_reset_error(app_name=APP_NAME, error=ERROR)
         self.assert_correct_warning(self.ui.warning_label,
                                     self.ui.UNKNOWN_ERROR)
         self.assert_pages_visibility(login=True)
@@ -1229,7 +1231,7 @@
         """Init."""
         super(SetNewPasswordTestCase, self).setUp()
         self.click_request_password_token_with_valid_data()
-        self.ui.on_password_reset_token_sent(email=EMAIL)
+        self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)
 
     def test_on_set_new_password_ok_button_disabled(self):
         """The set_new_password_ok_button is disabled until values added."""
@@ -1260,20 +1262,20 @@
         expected = 'set_new_password'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((EMAIL, RESET_PASSWORD_TOKEN, PASSWORD),
+                         ((APP_NAME, EMAIL, RESET_PASSWORD_TOKEN, PASSWORD),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
     def test_on_password_changed_shows_success_page(self):
         """When password was successfuly changed the success page is shown."""
-        self.ui.on_password_changed(EMAIL)
+        self.ui.on_password_changed(app_name=APP_NAME, email=EMAIL)
         self.assert_correct_warning(self.ui.warning_label,
                                     self.ui.PASSWORD_CHANGED)
         self.assert_pages_visibility(login=True)
 
     def test_on_password_change_error_shows_login_page(self):
         """When password wasn't changed the reset password page is shown."""
-        self.ui.on_password_change_error()
+        self.ui.on_password_change_error(app_name=APP_NAME, error=ERROR)
         self.assert_correct_warning(self.ui.warning_label,
                                     self.ui.UNKNOWN_ERROR)
         self.assert_pages_visibility(request_password_token=True)
@@ -1353,46 +1355,46 @@
 
     def test_on_user_registration_error_proper_signal_is_emitted(self):
         """On UserRegistrationError, 'registration-failed' signal is sent."""
-        self.ui.on_user_registration_error()
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME,), {}),
+        self.assertEqual((self.ui.window, (APP_NAME, ERROR), {}),
                          self._called[gui.SIG_REGISTRATION_FAILED])
 
     def test_on_email_validated_proper_signals_is_emitted(self):
         """On EmailValidated, 'registration-succeeded' signal is sent."""
-        self.ui.on_email_validated(APP_NAME)
+        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME,), {}),
+        self.assertEqual((self.ui.window, (APP_NAME, EMAIL), {}),
                           self._called[gui.SIG_REGISTRATION_SUCCEEDED])
 
     def test_on_email_validation_error_proper_signals_is_emitted(self):
         """On EmailValidationError, 'registration-failed' signal is sent."""
-        self.ui.on_email_validation_error()
+        self.ui.on_email_validation_error(app_name=APP_NAME, error=ERROR)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME,), {}),
+        self.assertEqual((self.ui.window, (APP_NAME, ERROR), {}),
                           self._called[gui.SIG_REGISTRATION_FAILED])
 
     def test_on_logged_in_proper_signals_is_emitted(self):
         """On LoggedIn, 'login-succeeded' signal is sent."""
-        self.ui.on_logged_in(APP_NAME)
+        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME,), {}),
+        self.assertEqual((self.ui.window, (APP_NAME, EMAIL), {}),
                           self._called[gui.SIG_LOGIN_SUCCEEDED])
 
     def test_on_login_error_proper_signals_is_emitted(self):
         """On LoginError, 'login-failed' signal is sent."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error()
+        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
         self.ui.on_close_clicked()
-        self.assertEqual((self.ui.window, (APP_NAME,), {}),
+        self.assertEqual((self.ui.window, (APP_NAME, ERROR), {}),
                           self._called[gui.SIG_LOGIN_FAILED])
 
     def test_registration_successfull_even_if_prior_registration_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error()
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
         self.click_join_with_valid_data()
-        self.ui.on_email_validated(APP_NAME)
+        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
         self.assertEqual(len(self._called), 1)
@@ -1401,9 +1403,9 @@
     def test_login_successfull_even_if_prior_login_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error()
+        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
         self.click_connect_with_valid_data()
-        self.ui.on_logged_in(APP_NAME)
+        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
         self.assertEqual(len(self._called), 1)
@@ -1412,7 +1414,7 @@
     def test_user_cancelation_even_if_prior_registration_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_join_with_valid_data()
-        self.ui.on_user_registration_error()
+        self.ui.on_user_registration_error(app_name=APP_NAME, error=ERROR)
         self.ui.join_cancel_button.clicked()
 
         self.assertEqual(len(self._called), 1)
@@ -1421,7 +1423,7 @@
     def test_user_cancelation_even_if_prior_login_error(self):
         """Only one signal is sent with the final outcome."""
         self.click_connect_with_valid_data()
-        self.ui.on_login_error()
+        self.ui.on_login_error(app_name=APP_NAME, error=ERROR)
         self.ui.login_cancel_button.clicked()
 
         self.assertEqual(len(self._called), 1)

=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2010-08-23 19:23:40 +0000
+++ ubuntu_sso/tests/test_main.py	2010-08-24 00:02:39 +0000
@@ -22,6 +22,7 @@
 import logging
 import os
 import StringIO
+import urllib2
 
 import gobject
 
@@ -36,10 +37,13 @@
 from ubuntu_sso import config, gui
 from ubuntu_sso.main import (
     AuthenticationError, BadRealmError, blocking, EmailTokenError,
-    InvalidEmailError, InvalidPasswordError, SSOLogin, SSOCredentials,
-    get_token_name, keyring_get_credentials, keyring_store_credentials, logger,
-    LoginProcessor, NewPasswordError, SSOLoginProcessor, RegistrationError,
-    ResetPasswordTokenError, OLD_KEY_NAME, U1_APP_NAME, except_to_errdict)
+    except_to_errdict, get_token_name,
+    InvalidEmailError, InvalidPasswordError,
+    keyring_get_credentials, keyring_store_credentials, logger,
+    LoginProcessor, NewPasswordError, OLD_KEY_NAME, PING_URL,
+    RegistrationError, ResetPasswordTokenError,
+    SSOCredentials, SSOLogin, SSOLoginProcessor,
+    U1_APP_NAME)
 
 
 APP_NAME = 'The Coolest App Ever'
@@ -60,15 +64,17 @@
          u'name': u'test',
          u'token': u'GkInOfSMGwTXAUoVQwLUoPxElEEUdhsLVNTPhxHJDUIeHCPNEo',
          u'token_secret': u'qFYImEtlczPbsCnYyuwLoPDlPEnvNcIktZphPQklAWrvyfFMV'}
+TOKEN_NAME = get_token_name(APP_NAME)
 STATUS_UNKNOWN = {'status': 'yadda-yadda'}
 STATUS_ERROR = {'status': 'error', 'errors': {'something': ['Bla', 'Ble']}}
 STATUS_OK = {'status': 'ok'}
 STATUS_EMAIL_UNKNOWN = {'status': 'yadda-yadda'}
 STATUS_EMAIL_ERROR = {'errors': {'email_token': ['Error1', 'Error2']}}
-STATUS_EMAIL_OK = {'email': '[e-mail]'}
+STATUS_EMAIL_OK = {'email': EMAIL}
 TC_URL = 'tcurl'
 WINDOW_ID = 5
 
+NO_OP = lambda *args, **kwargs: None
 LOGIN_OR_REGISTER_ARGS = (APP_NAME, TC_URL, HELP, WINDOW_ID)
 LOGIN_OR_REGISTER_GUI_ARGS = LOGIN_OR_REGISTER_ARGS + (False,)
 LOGIN_ONLY_ARGS = (APP_NAME, HELP, WINDOW_ID)
@@ -120,7 +126,7 @@
 
     def authenticate(self, token_name):
         """Fake authenticate. Return a fix result."""
-        if not token_name.startswith(get_token_name(APP_NAME)):
+        if not token_name.startswith(TOKEN_NAME):
             raise HTTPError(response=None, content=None)
         else:
             return TOKEN
@@ -159,13 +165,7 @@
                                     captcha_id=CAPTCHA_ID,
                                     captcha_solution=CAPTCHA_SOLUTION)
         self.login_kwargs = dict(email=EMAIL, password=PASSWORD,
-                                 app_name=APP_NAME)
-
-        def ksc(k, v):
-            self.assertEqual(k, APP_NAME)
-            self.assertEqual(v, TOKEN)
-
-        self.patch(ubuntu_sso.main, "keyring_store_credentials", ksc)
+                                 token_name=TOKEN_NAME)
 
     def tearDown(self):
         """Clean up."""
@@ -215,7 +215,7 @@
     def test_register_user_if_status_ok(self):
         """A user is succesfuy registered into the SSO server."""
         result = self.processor.register_user(**self.register_kwargs)
-        self.assertTrue(result, 'registration was successful.')
+        self.assertEqual(EMAIL, result, 'registration was successful.')
 
     def test_register_user_if_status_error(self):
         """Proper error is raised if register fails."""
@@ -238,7 +238,7 @@
 
     def test_login_if_http_error(self):
         """Proper error is raised if authentication fails."""
-        self.login_kwargs['app_name'] = APP_NAME * 2  # invalid token name
+        self.login_kwargs['token_name'] = APP_NAME * 2  # invalid token name
         self.assertRaises(AuthenticationError,
                           self.processor.login, **self.login_kwargs)
 
@@ -253,7 +253,7 @@
         """A email is succesfuy validated in the SSO server."""
         self.login_kwargs['email_token'] = EMAIL_TOKEN  # valid email token
         result = self.processor.validate_email(**self.login_kwargs)
-        self.assertTrue(result, 'email validation was successful.')
+        self.assertEqual(EMAIL, result, 'email validation was successful.')
 
     def test_validate_email_if_status_error(self):
         """Proper error is raised if email validation fails."""
@@ -276,7 +276,8 @@
     def test_request_password_reset_token_if_status_ok(self):
         """A reset password token is succesfuly sent."""
         result = self.processor.request_password_reset_token(email=EMAIL)
-        self.assertTrue(result, 'password reset token must be successful.')
+        self.assertEqual(EMAIL, result,
+                         'password reset token must be successful.')
 
     def test_request_password_reset_token_if_http_error(self):
         """Proper error is raised if password token request fails."""
@@ -297,7 +298,8 @@
         result = self.processor.set_new_password(email=EMAIL,
                                                  token=RESET_PASSWORD_TOKEN,
                                                  new_password=PASSWORD)
-        self.assertTrue(result, 'new password must be set successfully.')
+        self.assertEqual(EMAIL, result,
+                         'new password must be set successfully.')
 
     def test_set_new_password_if_http_error(self):
         """Proper error is raised if setting a new password fails."""
@@ -399,19 +401,26 @@
         self.mocker.result(mockbus)
         mockbus._register_object_path(ARGS)
 
+        def ksc(k, v):
+            """Assert over token and app_name."""
+            self.assertEqual(k, APP_NAME)
+            self.assertEqual(v, TOKEN)
+
+        self.patch(ubuntu_sso.main, "keyring_store_credentials", ksc)
+
     def tearDown(self):
         """Verify the mocking bus and shut it down."""
         self.mocker.verify()
         self.mocker.restore()
 
-    def fake_ok_blocking(self, f, cb, eb):
+    def fake_ok_blocking(self, f, a, cb, eb):
         """A fake blocking function that succeeds."""
-        cb(f())
+        cb(a, f())
 
-    def fake_err_blocking(self, f, cb, eb):
+    def fake_err_blocking(self, f, a, cb, eb):
         """A fake blocking function that fails."""
         f()
-        eb(except_to_errdict(BlockingSampleException()))
+        eb(a, except_to_errdict(BlockingSampleException()))
 
     def test_creation(self):
         """Test that the object creation is successful."""
@@ -436,15 +445,16 @@
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
-        def verify(result):
+        def verify(app_name, result):
             self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "CaptchaGenerated", verify)
         self.patch(client, "CaptchaGenerationError", d.errback)
-        client.generate_captcha(filename)
+        client.generate_captcha(APP_NAME, filename)
         return d
 
     def test_generate_captcha_error(self):
@@ -457,15 +467,16 @@
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
         self.mocker.replay()
 
-        def verify(errdict):
+        def verify(app_name, errdict):
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "CaptchaGenerated", d.errback)
         self.patch(client, "CaptchaGenerationError", verify)
-        client.generate_captcha(filename)
+        client.generate_captcha(APP_NAME, filename)
         return d
 
     def test_register_user(self):
@@ -478,15 +489,17 @@
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
-        def verify(result):
+        def verify(app_name, result):
             self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "UserRegistered", verify)
         self.patch(client, "UserRegistrationError", d.errback)
-        client.register_user(EMAIL, PASSWORD, CAPTCHA_ID, CAPTCHA_SOLUTION)
+        client.register_user(APP_NAME, EMAIL, PASSWORD, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
         return d
 
     def test_register_user_error(self):
@@ -499,47 +512,49 @@
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
         self.mocker.replay()
 
-        def verify(errdict):
+        def verify(app_name, errdict):
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "UserRegistered", d.errback)
         self.patch(client, "UserRegistrationError", verify)
-        client.register_user(EMAIL, PASSWORD, CAPTCHA_ID, CAPTCHA_SOLUTION)
+        client.register_user(APP_NAME, EMAIL, PASSWORD, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
         return d
 
     def test_login(self):
         """Test that the login method works ok."""
         d = Deferred()
-        sample_result = {"sample": "tokens"}
-        self.create_mock_processor().login(EMAIL, PASSWORD, APP_NAME)
-        self.mocker.result(sample_result)
+        self.create_mock_processor().login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
-        def verify(result):
-            self.assertEqual(result, APP_NAME)
+        def verify(app_name, result):
+            self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "LoggedIn", verify)
         self.patch(client, "LoginError", d.errback)
-        client.login(EMAIL, PASSWORD, APP_NAME)
+        client.login(APP_NAME, EMAIL, PASSWORD)
         return d
 
     def test_login_error(self):
         """Test that the login method fails as expected."""
         d = Deferred()
-        expected_result = "expected result"
-        self.create_mock_processor().login(EMAIL, PASSWORD, APP_NAME)
-        self.mocker.result(expected_result)
+        self.create_mock_processor().login(EMAIL, PASSWORD, TOKEN_NAME)
+        self.mocker.result(TOKEN)
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
         self.mocker.replay()
 
-        def verify(errdict):
+        def verify(app_name, errdict):
+            self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             d.callback("Ok")
 
@@ -547,27 +562,28 @@
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "LoggedIn", d.errback)
         self.patch(client, "LoginError", verify)
-        client.login(EMAIL, PASSWORD, APP_NAME)
+        client.login(APP_NAME, EMAIL, PASSWORD)
         return d
 
     def test_validate_email(self):
         """Test that the validate_email method works ok."""
         d = Deferred()
         self.create_mock_processor().validate_email(EMAIL, PASSWORD,
-                                                    APP_NAME, EMAIL_TOKEN)
-        self.mocker.result(APP_NAME)
+                                                    EMAIL_TOKEN, TOKEN_NAME)
+        self.mocker.result(EMAIL)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
-        def verify(result):
-            self.assertEqual(result, APP_NAME)
+        def verify(app_name, result):
+            self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "EmailValidated", verify)
         self.patch(client, "EmailValidationError", d.errback)
-        client.validate_email(EMAIL, PASSWORD, APP_NAME, EMAIL_TOKEN)
+        client.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
         return d
 
     def test_validate_email_error(self):
@@ -576,12 +592,13 @@
         expected_result = "expected result"
 
         self.create_mock_processor().validate_email(EMAIL, PASSWORD,
-                                                    APP_NAME, EMAIL_TOKEN)
+                                                    EMAIL_TOKEN, TOKEN_NAME)
         self.mocker.result(expected_result)
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
         self.mocker.replay()
 
-        def verify(errdict):
+        def verify(app_name, errdict):
+            self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             d.callback("Ok")
 
@@ -589,7 +606,7 @@
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "EmailValidated", d.errback)
         self.patch(client, "EmailValidationError", verify)
-        client.validate_email(EMAIL, PASSWORD, APP_NAME, EMAIL_TOKEN)
+        client.validate_email(APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
         return d
 
     def test_request_password_reset_token(self):
@@ -598,17 +615,19 @@
         processor = self.create_mock_processor()
         processor.request_password_reset_token(EMAIL)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.mocker.result(EMAIL)
         self.mocker.replay()
 
-        def verify(result):
+        def verify(app_name, result):
             self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "PasswordResetTokenSent", verify)
         self.patch(client, "PasswordResetError", d.errback)
-        client.request_password_reset_token(EMAIL)
+        client.request_password_reset_token(APP_NAME, EMAIL)
         return d
 
     def test_request_password_reset_token_error(self):
@@ -616,19 +635,20 @@
         d = Deferred()
 
         self.create_mock_processor().request_password_reset_token(EMAIL)
-        self.mocker.result(True)
+        self.mocker.result(EMAIL)
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
         self.mocker.replay()
 
-        def verify(errdict):
+        def verify(app_name, errdict):
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "PasswordResetTokenSent", d.errback)
         self.patch(client, "PasswordResetError", verify)
-        client.request_password_reset_token(EMAIL)
+        client.request_password_reset_token(APP_NAME, EMAIL)
         return d
 
     def test_set_new_password(self):
@@ -640,15 +660,16 @@
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
         self.mocker.replay()
 
-        def verify(result):
+        def verify(app_name, result):
             self.assertEqual(result, EMAIL)
+            self.assertEqual(app_name, APP_NAME)
             d.callback(result)
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "PasswordChanged", verify)
         self.patch(client, "PasswordChangeError", d.errback)
-        client.set_new_password(EMAIL, EMAIL_TOKEN, PASSWORD)
+        client.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
         return d
 
     def test_set_new_password_error(self):
@@ -662,20 +683,22 @@
         self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
         self.mocker.replay()
 
-        def verify(errdict):
+        def verify(app_name, errdict):
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
             d.callback("Ok")
 
         client = SSOLogin(self.mockbusname,
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "PasswordChanged", d.errback)
         self.patch(client, "PasswordChangeError", verify)
-        client.set_new_password(EMAIL, EMAIL_TOKEN, PASSWORD)
+        client.set_new_password(APP_NAME, EMAIL, EMAIL_TOKEN, PASSWORD)
         return d
 
 
 class BlockingFunctionTestCase(TestCase):
     """Tests for the "blocking" function."""
+
     timeout = 5
 
     def test_blocking(self):
@@ -686,11 +709,12 @@
         def f():
             return expected_result
 
-        def verify(result):
+        def verify(app_name, result):
             self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
             d.callback(result)
 
-        blocking(f, verify, d.errback)
+        blocking(f, APP_NAME, verify, d.errback)
         return d
 
     def test_blocking_error(self):
@@ -701,12 +725,13 @@
         def f():
             raise BlockingSampleException(expected_error_message)
 
-        def verify(errdict):
+        def verify(app_name, errdict):
+            self.assertEqual(app_name, APP_NAME)
             self.assertEqual(errdict["errtype"], "BlockingSampleException")
             self.assertEqual(errdict["message"], expected_error_message)
             d.callback("Ok")
 
-        blocking(f, d.errback, verify)
+        blocking(f, APP_NAME, d.errback, verify)
         return d
 
 
@@ -971,7 +996,7 @@
         client = SSOCredentials(self.mocker.mock())
         self.patch(client, "CredentialsError", verify)
 
-        client._login_error_cb(None, APP_NAME)
+        client._login_error_cb(None, APP_NAME, 'some error')
         return d
 
     def test_show_login_or_register_ui_error(self):
@@ -1008,7 +1033,7 @@
         client = SSOCredentials(self.mocker.mock())
         self.patch(client, "CredentialsFound", verify)
 
-        client._login_success_cb(None, APP_NAME)
+        client._login_success_cb(None, APP_NAME, EMAIL)
         return d
 
     def test_login_success_cb_error(self):
@@ -1026,7 +1051,7 @@
         client = SSOCredentials(self.mocker.mock())
         self.patch(client, "CredentialsError", verify)
 
-        client._login_success_cb(None, APP_NAME)
+        client._login_success_cb(None, APP_NAME, EMAIL)
         return d
 
     def test_auth_denied_cb(self):
@@ -1114,8 +1139,10 @@
 
         expected = [
             (gui.SIG_LOGIN_SUCCEEDED, self.client._login_success_cb),
+            (gui.SIG_LOGIN_SUCCEEDED, self.client._ping_url),
             (gui.SIG_LOGIN_FAILED, self.client._login_error_cb),
             (gui.SIG_REGISTRATION_SUCCEEDED, self.client._login_success_cb),
+            (gui.SIG_REGISTRATION_SUCCEEDED, self.client._ping_url),
             (gui.SIG_REGISTRATION_FAILED, self.client._login_error_cb),
             (gui.SIG_USER_CANCELATION, self.client._login_auth_denied_cb),
         ]
@@ -1174,11 +1201,47 @@
 
         expected = [
             (gui.SIG_LOGIN_SUCCEEDED, self.client._login_success_cb),
+            (gui.SIG_LOGIN_SUCCEEDED, self.client._ping_url),
             (gui.SIG_LOGIN_FAILED, self.client._login_error_cb),
             (gui.SIG_REGISTRATION_SUCCEEDED, self.client._login_success_cb),
+            (gui.SIG_REGISTRATION_SUCCEEDED, self.client._ping_url),
             (gui.SIG_REGISTRATION_FAILED, self.client._login_error_cb),
             (gui.SIG_USER_CANCELATION, self.client._login_auth_denied_cb),
         ]
         self.patch(gui, "UbuntuSSOClientGUI", FakedUbuntuSSOClientGUI)
         self.login_only(*LOGIN_ONLY_ARGS)
         self.assertEqual(self.signals, expected)
+
+    def test_on_registration_successful_u1_server_is_pinged(self):
+        """When a registration is successful, the PING_URL is pinged."""
+        self.args = None
+        self.kwargs = None
+
+        def fake_it(*args, **kwargs):
+            """Fake a call."""
+            self.args = args
+            self.kwargs = kwargs
+
+        self.patch(urllib2, 'urlopen', fake_it)
+
+        self.client._ping_url(None, U1_APP_NAME, EMAIL)
+
+        self.assertEqual(self.args, (PING_URL + EMAIL,))
+        self.assertEqual(self.kwargs, {})
+
+    def test_on_registration_successful_no_server_is_pinged(self):
+        """When a registration is successful, the PING_URL is not pinged."""
+        self.args = None
+        self.kwargs = None
+
+        def fake_it(*args, **kwargs):
+            """Fake a call."""
+            self.args = args
+            self.kwargs = kwargs
+
+        self.patch(urllib2, 'urlopen', fake_it)
+
+        self.client._ping_url(None, APP_NAME, EMAIL)
+
+        self.assertEqual(self.args, None)
+        self.assertEqual(self.kwargs, None)