Merge lp:~nataliabidart/ubuntu-sso-client/gtk-ui-executable into lp:ubuntu-sso-client

[Natalia Bidart]

- Make the GTK UI a separated executable script (LP: #917373).

[lp:~nataliabidart/ubuntu-sso-client/gtk-ui-executable]

838. By Natalia Bidart on 2012-01-17

Rename LOGIN_SUCCESSFULL to LOGIN_SUCCESS for consistency sake.

839. By Natalia Bidart on 2012-01-18

- Removing unused setUp.

840. By Natalia Bidart on 2012-01-18

Remove unused import.

[Manuel de la Peña (mandel)]

I'm getting the following when I run the tests on windows:

C:\Users\Mandel\Projects\Canonical\ubuntu-sso-client\gtk-ui-executable>run-tests

Checking if python 2.7 is in the system
ERROR: The system was unable to find the specified registry key or value.
Checking if python 2.6 is in the system
ERROR: The system was unable to find the specified registry key or value.
Checking if python 2.7 32 is in the system
Python found, building auto-generated modules...
running build
Compiled data\qt\choose_sign_in.ui into ubuntu_sso\qt\choose_sign_in_ui.py
Compiled data\qt\current_user_sign_in.ui into ubuntu_sso\qt\current_user_sign_in
_ui.py
Compiled data\qt\email_verification.ui into ubuntu_sso\qt\email_verification_ui.
py
Compiled data\qt\error_message.ui into ubuntu_sso\qt\error_message_ui.py
Compiled data\qt\forgotten_password.ui into ubuntu_sso\qt\forgotten_password_ui.
py
Compiled data\qt\reset_password.ui into ubuntu_sso\qt\reset_password_ui.py
Compiled data\qt\setup_account.ui into ubuntu_sso\qt\setup_account_ui.py
Compiled data\qt\success_message.ui into ubuntu_sso\qt\success_message_ui.py
running build_py
creating build
creating build\lib
creating build\lib\ubuntu_sso
copying ubuntu_sso\account.py -> build\lib\ubuntu_sso
copying ubuntu_sso\credentials.py -> build\lib\ubuntu_sso
copying ubuntu_sso\logger.py -> build\lib\ubuntu_sso
copying ubuntu_sso\__init__.py -> build\lib\ubuntu_sso
creating build\lib\ubuntu_sso\utils
copying ubuntu_sso\utils\ipc.py -> build\lib\ubuntu_sso\utils
copying ubuntu_sso\utils\tcpactivation.py -> build\lib\ubuntu_sso\utils
copying ubuntu_sso\utils\txsecrets.py -> build\lib\ubuntu_sso\utils
copying ubuntu_sso\utils\ui.py -> build\lib\ubuntu_sso\utils
copying ubuntu_sso\utils\__init__.py -> build\lib\ubuntu_sso\utils
creating build\lib\ubuntu_sso\keyring
copying ubuntu_sso\keyring\linux.py -> build\lib\ubuntu_sso\keyring
copying ubuntu_sso\keyring\windows.py -> build\lib\ubuntu_sso\keyring
copying ubuntu_sso\keyring\__init__.py -> build\lib\ubuntu_sso\keyring
creating build\lib\ubuntu_sso\networkstate
copying ubuntu_sso\networkstate\linux.py -> build\lib\ubuntu_sso\networkstate
copying ubuntu_sso\networkstate\windows.py -> build\lib\ubuntu_sso\networkstate
copying ubuntu_sso\networkstate\__init__.py -> build\lib\ubuntu_sso\networkstate

creating build\lib\ubuntu_sso\main
copying ubuntu_sso\main\linux.py -> build\lib\ubuntu_sso\main
copying ubuntu_sso\main\windows.py -> build\lib\ubuntu_sso\main
copying ubuntu_sso\main\__init__.py -> build\lib\ubuntu_sso\main
creating build\lib\ubuntu_sso\gtk
copying ubuntu_sso\gtk\gui.py -> build\lib\ubuntu_sso\gtk
copying ubuntu_sso\gtk\main.py -> build\lib\ubuntu_sso\gtk
copying ubuntu_sso\gtk\__init__.py -> build\lib\ubuntu_sso\gtk
creating build\lib\ubuntu_sso\qt
copying ubuntu_sso\qt\choose_sign_in_ui.py -> build\lib\ubuntu_sso\qt
copying ubuntu_sso\qt\common.py -> build\lib\ubuntu_sso\qt
copying ubuntu_sso\qt\controllers.py -> build\lib\ubuntu_sso\qt
copying ubuntu_sso\qt\current_user_sign_in_ui.py -> build\lib\ubuntu_sso\qt
copying ubuntu_sso\qt\email_verification_ui.py -> build\lib\ubuntu_sso\qt
copying ubuntu_sso\qt\error_message_ui.py -> build\lib\ubuntu_sso\qt
copying ubun...

review: Needs Fixing

[lp:~nataliabidart/ubuntu-sso-client/gtk-ui-executable]

841. By Natalia Bidart on 2012-01-18

- Not running any test related to GTK on windows.

[Manuel de la Peña (mandel)]

Fixed, nice branch!

review: Approve

[Roberto Alsina (ralsina)]

+1

review: Approve

=== added file 'bin/ubuntu-sso-login-gtk'
--- bin/ubuntu-sso-login-gtk	1970-01-01 00:00:00 +0000
+++ bin/ubuntu-sso-login-gtk	2012-01-18 13:20:30 +0000
@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Start the sso GTK UI."""
+
+# Invalid name "ubuntu-sso-login-gtk", pylint: disable=C0103
+# Access to a protected member, pylint: disable=W0212
+
+from ubuntu_sso.gtk.main import parse_args, main
+
+from dbus.mainloop.glib import DBusGMainLoop
+DBusGMainLoop(set_as_default=True)
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(**dict(args._get_kwargs()))

=== modified file 'run-tests.bat'
--- run-tests.bat	2011-12-01 15:02:38 +0000
+++ run-tests.bat	2012-01-18 13:20:30 +0000
@@ -1,70 +1,70 @@
-:: Author: Manuel de la Pena <[e-mail]>
-::
-:: Copyright 2010 Canonical Ltd.
-::
-:: This program is free software: you can redistribute it and/or modify it
-:: under the terms of the GNU General Public License version 3, as published
-:: by the Free Software Foundation.
-::
-:: This program is distributed in the hope that it will be useful, but
-:: WITHOUT ANY WARRANTY; without even the implied warranties of
-:: MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
-:: PURPOSE.  See the GNU General Public License for more details.
-::
-:: You should have received a copy of the GNU General Public License along
-:: with this program.  If not, see <http://www.gnu.org/licenses/>.
-@ECHO off
-:: We could have Python 2.6 or 2.7 on Windows. In order to check availability,
-:: we should first check for 2.7, and run the tests, otherwise fall back to 2.6.
-SET PYTHONEXEPATH=""
-:: This is very annoying; FOR /F will work differently depending on the output
-:: of reg which is not consistent between OS versions (XP, 7). We must choose
-:: the tokens according to OS version.
-SET PYTHONPATHTOKENS=3
-VER | FIND "XP" > nul
-IF %ERRORLEVEL% == 0 SET PYTHONPATHTOKENS=4
-ECHO Checking if python 2.7 is in the system
-:: Look for python 2.7
-FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Python\PythonCore\2.7\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
-IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
-ECHO Checking if python 2.6 is in the system
-:: we do not have python 2.7 in the system, try to find 2.6
-FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Python\PythonCore\2.6\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
-IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
-
-:: we do not have python (2.6 or 2.7) this could hapen in the case  that the
-:: user installed the 32version in a 64 machine, let check if the software was installed in the wow key
-
-:: Look for python 2.7 in WoW64
-ECHO Checking if python 2.7 32 is in the system
-FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Wow6432Node\Python\PythonCore\2.7\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
-IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
-ECHO Checking if python 2.6 32 is in the system
-:: we do not have python 2.7 in the system, try to find 2.6
-FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Wow6432Node\Python\PythonCore\2.6\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
-IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
-
-ECHO Please ensure you have python installed
-GOTO :END
-
-
-:PYTHONPRESENT
-ECHO Python found, building auto-generated modules...
-:: call setup.py build so that the qt uic is called
-::START "Build code" /D%CD% /WAIT "%PYTHONEXEPATH%\python.exe" setup.py build
-"%PYTHONEXEPATH%\python.exe" setup.py build
-ECHO Running tests
-:: execute the tests with a number of ignored linux only modules
-"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1trial" -c -i "test_gui.py, test_linux.py, test_txsecrets.py" --reactor=qt4 --gui %* ubuntu_sso 
-:: Clean the build from the setupt.py
-ECHO Cleaning the generated code before running the style checks...
-"%PYTHONEXEPATH%\python.exe" setup.py clean
-ECHO Performing style checks...
-SET IGNORE_LINT="ubuntu_sso\gtk,ubuntu_sso\networkstate\linux.py,ubuntu_sso\main\linux.py,ubuntu_sso\main\tests\test_linux.py,ubuntu_sso\utils\txsecrets.py,ubuntu_sso\utils\tests\test_txsecrets.py,ubuntu_sso\tests\bin,bin\ubuntu-sso-login"
-"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1lint" -i "%IGNORE_LINT%" ubuntu_sso
-:: test for style if we can, if pep8 is not present, move to the end
-"%PYTHONEXEPATH%\Scripts\pep8.exe" --repeat .
-:: Delete the temp folders
-RMDIR /q /s _trial_temp
-DEL /q .coverage
-:END
+:: Author: Manuel de la Pena <[e-mail]>
+::
+:: Copyright 2010 Canonical Ltd.
+::
+:: This program is free software: you can redistribute it and/or modify it
+:: under the terms of the GNU General Public License version 3, as published
+:: by the Free Software Foundation.
+::
+:: This program is distributed in the hope that it will be useful, but
+:: WITHOUT ANY WARRANTY; without even the implied warranties of
+:: MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+:: PURPOSE.  See the GNU General Public License for more details.
+::
+:: You should have received a copy of the GNU General Public License along
+:: with this program.  If not, see <http://www.gnu.org/licenses/>.
+@ECHO off
+:: We could have Python 2.6 or 2.7 on Windows. In order to check availability,
+:: we should first check for 2.7, and run the tests, otherwise fall back to 2.6.
+SET PYTHONEXEPATH=""
+:: This is very annoying; FOR /F will work differently depending on the output
+:: of reg which is not consistent between OS versions (XP, 7). We must choose
+:: the tokens according to OS version.
+SET PYTHONPATHTOKENS=3
+VER | FIND "XP" > nul
+IF %ERRORLEVEL% == 0 SET PYTHONPATHTOKENS=4
+ECHO Checking if python 2.7 is in the system
+:: Look for python 2.7
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Python\PythonCore\2.7\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
+IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
+ECHO Checking if python 2.6 is in the system
+:: we do not have python 2.7 in the system, try to find 2.6
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Python\PythonCore\2.6\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
+IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
+
+:: we do not have python (2.6 or 2.7) this could hapen in the case  that the
+:: user installed the 32version in a 64 machine, let check if the software was installed in the wow key
+
+:: Look for python 2.7 in WoW64
+ECHO Checking if python 2.7 32 is in the system
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Wow6432Node\Python\PythonCore\2.7\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
+IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
+ECHO Checking if python 2.6 32 is in the system
+:: we do not have python 2.7 in the system, try to find 2.6
+FOR /F "tokens=%PYTHONPATHTOKENS%" %%A IN ('REG QUERY HKLM\Software\Wow6432Node\Python\PythonCore\2.6\InstallPath /ve') DO @SET PYTHONEXEPATH=%%A
+IF NOT %PYTHONEXEPATH% == "" GOTO :PYTHONPRESENT
+
+ECHO Please ensure you have python installed
+GOTO :END
+
+
+:PYTHONPRESENT
+ECHO Python found, building auto-generated modules...
+:: call setup.py build so that the qt uic is called
+::START "Build code" /D%CD% /WAIT "%PYTHONEXEPATH%\python.exe" setup.py build
+"%PYTHONEXEPATH%\python.exe" setup.py build
+ECHO Running tests
+:: execute the tests with a number of ignored linux only modules
+"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1trial" -i "test_linux.py, test_txsecrets.py" -p "ubuntu_sso\gtk" --reactor=qt4 --gui %* ubuntu_sso 
+:: Clean the build from the setupt.py
+ECHO Cleaning the generated code before running the style checks...
+"%PYTHONEXEPATH%\python.exe" setup.py clean
+ECHO Performing style checks...
+SET IGNORE_LINT="ubuntu_sso\gtk,ubuntu_sso\networkstate\linux.py,ubuntu_sso\main\linux.py,ubuntu_sso\main\tests\test_linux.py,ubuntu_sso\utils\txsecrets.py,ubuntu_sso\utils\tests\test_txsecrets.py,ubuntu_sso\tests\bin,bin\ubuntu-sso-login"
+"%PYTHONEXEPATH%\python.exe" "%PYTHONEXEPATH%\Scripts\u1lint" -i "%IGNORE_LINT%" ubuntu_sso
+:: test for style if we can, if pep8 is not present, move to the end
+"%PYTHONEXEPATH%\Scripts\pep8.exe" --repeat .
+:: Delete the temp folders
+RMDIR /q /s _trial_temp
+DEL /q .coverage
+:END

=== modified file 'setup.py'
--- setup.py	2011-11-14 17:40:13 +0000
+++ setup.py	2012-01-18 13:20:30 +0000
@@ -349,7 +349,7 @@
             },
         },
         # add the console script so that py2exe compiles it
-        'console': ['bin/windows-ubuntu-sso-login'],
+        'console': ['bin/ubuntu-sso-login'],
         'zipfile': None,
     }
     return _data_files, _extra
@@ -357,9 +357,12 @@
 if sys.platform == 'win32':
     data_files, extra = setup_windows()
 else:
-    data_files = [('share/dbus-1/services', ['data/com.ubuntu.sso.service']),
-                   ('lib/ubuntu-sso-client', ['bin/ubuntu-sso-login']),
-                   ('share/ubuntu-sso-client/data/gtk', ['data/gtk/ui.glade'])]
+    data_files = [
+        ('lib/ubuntu-sso-client', ['bin/ubuntu-sso-login']),
+        ('lib/ubuntu-sso-client', ['bin/ubuntu-sso-login-gtk']),
+        ('share/dbus-1/services', ['data/com.ubuntu.sso.service']),
+        ('share/ubuntu-sso-client/data/gtk', ['data/gtk/ui.glade']),
+    ]
     extra = {}
 
 DistUtilsExtra.auto.setup(

=== modified file 'ubuntu_sso/gtk/gui.py'
--- ubuntu_sso/gtk/gui.py	2011-12-15 20:40:20 +0000
+++ ubuntu_sso/gtk/gui.py	2012-01-18 13:20:30 +0000
@@ -1,9 +1,5 @@
 # -*- coding: utf-8 -*-
 #
-# ubuntu_sso.gui - GUI for login and registration
-#
-# Author: Natalia Bidart <[e-mail]>
-#
 # Copyright 2010 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
@@ -22,20 +18,18 @@
 
 import logging
 import os
+import sys
 import tempfile
 import webbrowser
 
 from functools import wraps
 
-import dbus
 import gtk
 
-from twisted.internet.defer import inlineCallbacks
+from twisted.internet import defer
 
 from ubuntu_sso import (
-    DBUS_ACCOUNT_PATH,
-    DBUS_BUS_NAME,
-    DBUS_IFACE_USER_NAME,
+    main,
     NO_OP,
     utils,
 )
@@ -101,6 +95,9 @@
 HELP_TEXT_COLOR = gtk.gdk.Color("#bfbfbf")
 WARNING_TEXT_COLOR = gtk.gdk.Color("red")
 
+USER_CANCELLATION = 10
+LOGIN_SUCCESS = REGISTRATION_SUCCESS = 0
+
 
 def log_call(f):
     """Decorator to log call funtions."""
@@ -183,9 +180,11 @@
 class UbuntuSSOClientGUI(object):
     """Ubuntu single sign-on GUI."""
 
-    def __init__(self, app_name, tc_url='', help_text='',
-                 window_id=0, login_only=False):
+    def __init__(self, app_name, **kwargs):
         """Create the GUI and initialize widgets."""
+        logger.debug('UbuntuSSOClientGUI: app_name %r, kwargs %r.',
+                     app_name, kwargs)
+
         gtk.link_button_set_uri_hook(NO_OP)
 
         self._captcha_filename = tempfile.mktemp()
@@ -195,11 +194,15 @@
 
         self.app_name = app_name
         self.app_label = '<b>%s</b>' % self.app_name
-        self.tc_url = tc_url
-        self.help_text = help_text
-        self.login_only = login_only
-
-        self.close_callback = NO_OP
+        self.ping_url = kwargs.get('ping_url', '')
+        self.tc_url = kwargs.get('tc_url', '')
+        self.help_text = kwargs.get('help_text', '')
+        self.login_only = kwargs.get('login_only', False)
+        window_id = kwargs.get('window_id', 0)
+        self.close_callback = kwargs.get('close_callback', NO_OP)
+        self.backend = None
+        # the following 3 callbacks will be removed as soon as
+        # the backend stop using them
         self.login_success_callback = NO_OP
         self.registration_success_callback = NO_OP
         self.user_cancellation_callback = NO_OP
@@ -252,23 +255,12 @@
 
         self.window.set_icon_name('ubuntu-logo')
 
-        self.bus = dbus.SessionBus()
-        obj = self.bus.get_object(bus_name=DBUS_BUS_NAME,
-                                  object_path=DBUS_ACCOUNT_PATH,
-                                  follow_name_owner_changes=True)
-        self.iface_name = DBUS_IFACE_USER_NAME
-        self.backend = dbus.Interface(object=obj,
-                                      dbus_interface=self.iface_name)
-        logger.debug('UbuntuSSOClientGUI: backend created: %r', self.backend)
-
         self.pages = (self.enter_details_vbox, self.processing_vbox,
                       self.verify_email_vbox, self.finish_vbox,
                       self.tc_browser_vbox, self.login_vbox,
                       self.request_password_token_vbox,
                       self.set_new_password_vbox)
 
-        self._append_pages()
-
         self._signals = {
             'CaptchaGenerated':
              self._filter_by_app_name(self.on_captcha_generated),
@@ -297,7 +289,6 @@
             'PasswordChangeError':
              self._filter_by_app_name(self.on_password_change_error),
         }
-        self._setup_signals()
 
         if window_id != 0:
             # be as robust as possible:
@@ -314,7 +305,18 @@
                 logger.exception(msg, window_id)
 
         self.yes_to_updates_checkbutton.hide()
-
+        self.start_backend()
+
+    @defer.inlineCallbacks
+    def start_backend(self):
+        """Start the backend, show the window when ready."""
+        client = yield main.get_sso_client()
+        self.backend = client.sso_login
+
+        logger.debug('UbuntuSSOClientGUI: backend created: %r', self.backend)
+
+        self._setup_signals()
+        self._append_pages()
         self.window.show()
 
     @property
@@ -353,22 +355,14 @@
 
     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.iteritems():
-            actual = self._signals_receivers.get((iface, signal))
+            actual = self._signals_receivers.get(signal)
             if actual is not None:
-                msg = 'Signal %r is already connected with %r at iface %r.'
-                logger.warning(msg, signal, actual, iface)
-
-            match = self.bus.add_signal_receiver(method, signal_name=signal,
-                                                 dbus_interface=iface)
-            logger.debug('Connecting signal %r with method %r at iface %r.' \
-                         'Match: %r', signal, method, iface, match)
-            self._signals_receivers[(iface, signal)] = method
-
-    def _debug(self, *args, **kwargs):
-        """Do some debugging."""
-        print args, kwargs
+                msg = 'Signal %r is already connected with %r.'
+                logger.warning(msg, signal, actual)
+
+            match = self.backend.connect_to_signal(signal, method)
+            self._signals_receivers[signal] = match
 
     def _add_spinner_to_container(self, container, legend=None):
         """Add a spinner to 'container'."""
@@ -651,10 +645,6 @@
 
     # GTK callbacks
 
-    def run(self):
-        """Run the application."""
-        gtk.main()
-
     def connect(self, signal_name, handler, *args, **kwargs):
         """Connect 'signal_name' with 'handler'."""
         logger.debug('connect: signal %r, handler %r, args  %r, kwargs, %r',
@@ -680,13 +670,8 @@
         if os.path.exists(self._captcha_filename):
             os.remove(self._captcha_filename)
 
-        # remove the signals from DBus
-        remove = self.bus.remove_signal_receiver
-        for (iface, signal) in self._signals_receivers.keys():
-            method = self._signals_receivers.pop((iface, signal))
-            logger.debug('Removing signal %r with method %r at iface %r.',
-                         signal, method, iface)
-            remove(method, signal_name=signal, dbus_interface=iface)
+        for signal, match in self._signals_receivers.iteritems():
+            self.backend.disconnect_from_signal(signal, match)
 
         # hide the main window
         if self.window is not None:
@@ -696,14 +681,18 @@
         while gtk.events_pending():
             gtk.main_iteration()
 
+        return_code = LOGIN_SUCCESS
         if not self._done:
             self.user_cancellation_callback(self.app_name)
+            return_code = USER_CANCELLATION
 
         # call user defined callback
         logger.info('Calling custom close_callback %r with params %r, %r',
                     self.close_callback, args, kwargs)
         self.close_callback(*args, **kwargs)
 
+        sys.exit(return_code)
+
     def on_sign_in_button_clicked(self, *args, **kwargs):
         """User wants to sign in, present the Login page."""
         self._set_current_page(self.login_vbox)
@@ -780,12 +769,18 @@
 
         email = self.user_email
         password = self.user_password
-        f = self.backend.validate_email
-        logger.info('Calling validate_email with email %r, password <hidden>' \
-                    ', app_name %r and email_token %r.', email, self.app_name,
+
+        args = (self.app_name, email, password, email_token)
+        if self.ping_url:
+            f = self.backend.validate_email_with_ping
+            args = args + (self.ping_url,)
+        else:
+            f = self.backend.validate_email
+
+        logger.info('Calling validate_email with email %r, password <hidden>, '
+                    'app_name %r and email_token %r.', email, self.app_name,
                     email_token)
-        f(self.app_name, email, password, email_token,
-          reply_handler=NO_OP, error_handler=NO_OP)
+        f(*args, reply_handler=NO_OP, error_handler=NO_OP)
 
         self._set_current_page(self.processing_vbox)
 
@@ -812,9 +807,14 @@
         if error:
             return
 
-        f = self.backend.login
-        f(self.app_name, email, password,
-          reply_handler=NO_OP, error_handler=NO_OP)
+        args = (self.app_name, email, password)
+        if self.ping_url:
+            f = self.backend.login_with_ping
+            args = args + (self.ping_url,)
+        else:
+            f = self.backend.login
+
+        f(*args, reply_handler=NO_OP, error_handler=NO_OP)
 
         self._set_current_page(self.processing_vbox)
         self.user_email = email
@@ -1021,15 +1021,10 @@
         self._set_current_page(self.enter_details_vbox, warning_text=msg)
 
     @log_call
-    @inlineCallbacks
     def on_email_validated(self, app_name, email, *args, **kwargs):
         """User email was successfully verified."""
-        self._done = True
-        result = yield self.registration_success_callback(self.app_name, email)
-        if result == 0:
-            self.finish_success()
-        else:
-            self.finish_error()
+        self.registration_success_callback(self.app_name, email)
+        self.finish_success()
 
     @log_call
     def on_email_validation_error(self, app_name, error, *args, **kwargs):
@@ -1042,15 +1037,10 @@
         self._set_current_page(self.verify_email_vbox, warning_text=msg)
 
     @log_call
-    @inlineCallbacks
     def on_logged_in(self, app_name, email, *args, **kwargs):
         """User was successfully logged in."""
-        self._done = True
-        result = yield self.login_success_callback(self.app_name, email)
-        if result == 0:
-            self.finish_success()
-        else:
-            self.finish_error()
+        self.login_success_callback(self.app_name, email)
+        self.finish_success()
 
     @log_call
     def on_login_error(self, app_name, error, *args, **kwargs):

=== added file 'ubuntu_sso/gtk/main.py'
--- ubuntu_sso/gtk/main.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/gtk/main.py	2012-01-18 13:20:30 +0000
@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Main module to open the GTK UI."""
+
+import argparse
+
+import gtk
+
+from ubuntu_sso.gtk.gui import UbuntuSSOClientGUI
+
+
+def parse_args():
+    """Parse sys.argv options."""
+    parser = argparse.ArgumentParser(description='Open the GTK SSO UI.')
+    parser.add_argument('--app_name', required=True,
+        help='the name of the application to retrieve credentials for')
+    parser.add_argument('--ping_url', default='',
+        help='a link to be used as the ping url (to notify about new tokens)')
+    parser.add_argument('--tc_url', default='',
+        help='a link to be used as Terms & Conditions url')
+    parser.add_argument('--help_text', default='',
+        help='extra text that will be shown below the headers')
+    parser.add_argument('--window_id', type=int, default=0,
+        help='the window id to be set transient for the SSO GTK dialogs')
+    parser.add_argument('--login_only', action='store_true', default=False,
+        help='whether the SSO GTK UI should only offer login or not')
+
+    args = parser.parse_args()
+    return args
+
+
+def main(**kwargs):
+    """Start the GTK mainloop and open the main window."""
+    UbuntuSSOClientGUI(close_callback=gtk.main_quit, **kwargs)
+    gtk.main()

=== modified file 'ubuntu_sso/gtk/tests/test_gui.py'
--- ubuntu_sso/gtk/tests/test_gui.py	2011-12-15 20:40:20 +0000
+++ ubuntu_sso/gtk/tests/test_gui.py	2012-01-18 13:20:30 +0000
@@ -1,10 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# test_gui - tests for ubuntu_sso.gui
-#
-# Author: Natalia Bidart <[e-mail]>
-#
-# Copyright 2010 Canonical Ltd.
+# Copyright 2010-2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -25,7 +21,6 @@
 
 from collections import defaultdict
 
-import dbus
 import gtk
 import webkit
 
@@ -36,7 +31,9 @@
 from ubuntu_sso.utils.ui import UNKNOWN_ERROR
 from ubuntu_sso.gtk import gui
 from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,
-    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, NAME, PASSWORD, RESET_PASSWORD_TOKEN)
+    CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, NAME, PASSWORD, PING_URL,
+    RESET_PASSWORD_TOKEN,
+)
 
 
 # Access to a protected member 'yyy' of a client class
@@ -47,17 +44,32 @@
 
 
 class FakedSSOBackend(object):
-    """Fake a SSO Backend (acts as a dbus.Interface as well)."""
+    """Fake a SSO Backend."""
 
     def __init__(self, *args, **kwargs):
         self._args = args
         self._kwargs = kwargs
         self._called = {}
-        for i in ('generate_captcha', 'login', 'register_user',
-                  'validate_email', 'request_password_reset_token',
+        self.callbacks = defaultdict(list)
+
+        for i in ('generate_captcha', 'login', 'login_with_ping',
+                  'register_user', 'validate_email',
+                  'validate_email_with_ping',
+                  'request_password_reset_token',
                   'set_new_password'):
             setattr(self, i, self._record_call(i))
 
+    def connect_to_signal(self, signal_name, callback):
+        """Connect a callback to a given signal."""
+        self.callbacks[signal_name].append(callback)
+        return callback
+
+    def disconnect_from_signal(self, signal_name, match):
+        """Disconnect from a given signal."""
+        self.callbacks[signal_name].remove(match)
+        if len(self.callbacks[signal_name]) == 0:
+            self.callbacks.pop(signal_name)
+
     def _record_call(self, func_name):
         """Store values when calling 'func_name'."""
 
@@ -68,42 +80,11 @@
         return inner
 
 
-class FakedDbusObject(object):
-    """Fake a dbus."""
-
-    def __init__(self, *args, **kwargs):
-        """Init."""
-        self._args = args
-        self._kwargs = kwargs
-
-
-class FakedSessionBus(object):
-    """Fake the session bus."""
+class FakedSSOService(object):
+    """A faked SSO service."""
 
     def __init__(self):
-        """Init."""
-        self.obj = None
-        self.callbacks = {}
-
-    def add_signal_receiver(self, method, signal_name, dbus_interface):
-        """Add a signal receiver."""
-        self.callbacks[(dbus_interface, signal_name)] = method
-
-    def remove_signal_receiver(self, match, signal_name, dbus_interface):
-        """Remove the signal receiver."""
-        assert (dbus_interface, signal_name) in self.callbacks
-        del self.callbacks[(dbus_interface, signal_name)]
-
-    def get_object(self, bus_name, object_path, introspect=True,
-                   follow_name_owner_changes=False, **kwargs):
-        """Return a faked proxy for the given remote object."""
-        if bus_name == gui.DBUS_BUS_NAME and \
-           object_path == gui.DBUS_ACCOUNT_PATH:
-            assert self.obj is None
-            kwargs = dict(object_path=object_path,
-                          bus_name=bus_name, follow_name_owner_changes=True)
-            self.obj = FakedDbusObject(**kwargs)
-        return self.obj
+        self.sso_login = FakedSSOBackend()
 
 
 class Settings(dict):
@@ -165,6 +146,8 @@
         yield super(BasicTestCase, self).setUp()
         self._called = False  # helper
 
+        self.patch(gui.sys, 'exit', lambda *a: None)
+
         self.memento = MementoHandler()
         self.memento.setLevel(logging.DEBUG)
         gui.logger.addHandler(self.memento)
@@ -382,20 +365,14 @@
     def setUp(self):
         """Init."""
         yield super(UbuntuSSOClientTestCase, self).setUp()
-        self.patch(dbus, 'SessionBus', FakedSessionBus)
-        self.patch(dbus, 'Interface', FakedSSOBackend)
+        self.patch(gui.main, 'get_sso_client',
+                   lambda: defer.succeed(FakedSSOService()))
         self.pages = ('enter_details', 'processing', 'verify_email', 'finish',
                       'tc_browser', 'login', 'request_password_token',
                       'set_new_password')
         self.ui = self.gui_class(**self.kwargs)
         self.error = {'message': UNKNOWN_ERROR}
 
-    @defer.inlineCallbacks
-    def tearDown(self):
-        self.ui.bus.callbacks = {}
-        self.ui = None
-        yield super(UbuntuSSOClientTestCase, self).tearDown()
-
     def assert_entries_are_packed_to_ui(self, container_name, entries):
         """Every entry is properly packed in the ui 'container_name'."""
         msg = 'Entry "%s" must be packed in "%s" but is not.'
@@ -524,39 +501,13 @@
         """The app_name is stored for further use."""
         self.assertIn(APP_NAME, self.ui.app_name)
 
-    def test_session_bus_is_correct(self):
-        """The session bus is created and is correct."""
-        self.assertIsInstance(self.ui.bus, FakedSessionBus)
-
-    def test_iface_name_is_correct(self):
-        """The session bus is created and is correct."""
-        self.assertEqual(self.ui.iface_name, gui.DBUS_IFACE_USER_NAME)
-
-    def test_bus_object_is_created(self):
-        """SessionBus.get_object is called properly."""
-        self.assertIsInstance(self.ui.bus.obj, FakedDbusObject)
-        self.assertEqual(self.ui.bus.obj._args, ())
-        expected = dict(object_path=gui.DBUS_ACCOUNT_PATH,
-                        bus_name=gui.DBUS_BUS_NAME,
-                        follow_name_owner_changes=True)
-        self.assertEqual(expected, self.ui.bus.obj._kwargs)
-
-    def test_bus_interface_is_created(self):
-        """dbus.Interface is called properly."""
-        self.assertIsInstance(self.ui.backend, FakedSSOBackend)
-        self.assertEqual(self.ui.backend._args, ())
-        expected = dict(object=self.ui.bus.obj,
-                        dbus_interface=gui.DBUS_IFACE_USER_NAME)
-        self.assertEqual(expected, self.ui.backend._kwargs)
-
-    def test_dbus_signals_are_removed(self):
+    def test_signals_are_removed(self):
         """The hooked signals are removed at shutdown time."""
-        self.ui._setup_signals()
-        assert len(self.ui.bus.callbacks) > 0  # at least one callback
+        assert len(self.ui.backend.callbacks) > 0  # at least one callback
 
         self.ui.on_close_clicked()
 
-        self.assertEqual(self.ui.bus.callbacks, {})
+        self.assertEqual(self.ui.backend.callbacks, {})
 
     def test_pages_are_packed_into_container(self):
         """All the pages are packed in the main container."""
@@ -607,6 +558,7 @@
 
     def test_cancel_buttons_close_window(self):
         """Every cancel button should close the window when clicked."""
+        self.patch(self.ui.backend, 'disconnect_from_signal', lambda *a: None)
         msg = '"%s" should close the window when clicked.'
         buttons = filter(lambda name: 'cancel_button' in name or
                                       'close_button' in name, self.ui.widgets)
@@ -923,15 +875,12 @@
         self.patch(webkit, 'WebView', FakedEmbeddedBrowser)
 
         self.ui.tc_button.clicked()
+        self.addCleanup(self.ui.tc_browser_vbox.hide)
+
         children = self.ui.tc_browser_window.get_children()
         assert len(children) == 1
         self.browser = children[0]
 
-    @defer.inlineCallbacks
-    def tearDown(self):
-        self.ui.tc_browser_vbox.hide()
-        yield super(TermsAndConditionsBrowserTestCase, self).tearDown()
-
     def test_tc_browser_is_created_when_tc_page_is_shown(self):
         """The browser is created when the TC button is clicked."""
         self.ui.on_tc_browser_notify_load_status(self.browser)
@@ -1124,12 +1073,14 @@
 class VerifyEmailTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user registration (verify email page)."""
 
+    method = 'validate_email'
+    method_args = (APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN)
+
     @defer.inlineCallbacks
     def setUp(self):
         """Init."""
         yield super(VerifyEmailTestCase, self).setUp()
         self.ui.on_user_registered(app_name=APP_NAME, email=EMAIL)
-        self.click_verify_email_with_valid_data()
 
     def test_registration_successful_shows_verify_email_vbox(self):
         """Receiving 'registration_successful' shows the verify email vbox."""
@@ -1144,13 +1095,13 @@
                                              'email': EMAIL}
         self.assertEqual(expected, actual, msg % (expected, actual))
 
-    def test_on_verify_token_button_clicked_calls_validate_email(self):
+    def test_on_verify_token_button_clicked_calls_backend(self):
         """Verify token button triggers call to backend."""
         self.click_verify_email_with_valid_data()
-        expected = 'validate_email'
+        expected = self.method
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN),
+                         (self.method_args,
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
@@ -1158,10 +1109,16 @@
         """Verify token uses cached user_email and user_password."""
         self.ui.user_email = '[e-mail]'
         self.ui.user_password = 'yadda-yedda'
+        method_args = list(self.method_args)
+        method_args[1] = self.ui.user_email
+        method_args[2] = self.ui.user_password
+
+        # resolve email token properly
+        self.ui.email_token_entry.set_text(EMAIL_TOKEN)
+
         self.ui.on_verify_token_button_clicked()
-        self.assertEqual(self.ui.backend._called['validate_email'],
-                         ((APP_NAME, self.ui.user_email,
-                           self.ui.user_password, EMAIL_TOKEN),
+        self.assertEqual(self.ui.backend._called[self.method],
+                         (tuple(method_args),
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
@@ -1240,31 +1197,22 @@
         self.ui.verify_token_button.clicked()
         self.assertTrue(self._called)
 
-    def test_after_registration_success_finish_success(self):
-        """After REGISTRATION_SUCCESS is called, finish_success is called.
-
-        Only when REGISTRATION_SUCCESS returns 0.
-
-        """
+    def test_after_email_validated_finish_success(self):
+        """After email_validated is called, finish_success is called."""
         self.patch(self.ui, 'finish_success', self._set_called)
-        self.ui.registration_success_callback = lambda app, email: 0
-
-        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-
-        self.assertEqual(self._called, ((), {}))
-
-    def test_after_registration_error_finish_error(self):
-        """After REGISTRATION_SUCCESS is called, finish_error is called.
-
-        Only when REGISTRATION_SUCCESS returns a non-zero value.
-
-        """
-        self.patch(self.ui, 'finish_error', self._set_called)
-        self.ui.registration_success_callback = lambda app, email: -1
-
-        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
-
-        self.assertEqual(self._called, ((), {}))
+
+        self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._called, ((), {}))
+
+
+class VerifyEmailWithPingTestCase(VerifyEmailTestCase):
+    """Test suite for the user registration (verify email page)."""
+
+    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
+                  ping_url=PING_URL)
+    method = 'validate_email_with_ping'
+    method_args = (APP_NAME, EMAIL, PASSWORD, EMAIL_TOKEN, PING_URL)
 
 
 class VerifyEmailValidationTestCase(UbuntuSSOClientTestCase):
@@ -1455,6 +1403,9 @@
 class LoginTestCase(UbuntuSSOClientTestCase):
     """Test suite for the user login pages."""
 
+    method = 'login'
+    method_args = (APP_NAME, EMAIL, PASSWORD)
+
     @defer.inlineCallbacks
     def setUp(self):
         """Init."""
@@ -1505,10 +1456,10 @@
         """Clicking login_ok_button calls backend.login."""
         self.click_connect_with_valid_data()
 
-        expected = 'login'
+        expected = self.method
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
-                         ((APP_NAME, EMAIL, PASSWORD),
+                         (self.method_args,
                           dict(reply_handler=gui.NO_OP,
                                error_handler=gui.NO_OP)))
 
@@ -1579,30 +1530,21 @@
         self.assertEqual(self.ui.user_password, PASSWORD)
 
     def test_after_login_success_finish_success(self):
-        """After LOGIN_SUCCESSFULL is called, finish_success is called.
-
-        Only when LOGIN_SUCCESSFULL returns 0.
-
-        """
+        """After logged_in is called, finish_success is called."""
         self.patch(self.ui, 'finish_success', self._set_called)
-        self.ui.login_success_callback = lambda app, email: 0
-
-        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-
-        self.assertEqual(self._called, ((), {}))
-
-    def test_after_login_error_finish_error(self):
-        """After LOGIN_SUCCESSFULL is called, finish_error is called.
-
-        Only when LOGIN_SUCCESSFULL returns a non-zero value.
-
-        """
-        self.patch(self.ui, 'finish_error', self._set_called)
-        self.ui.login_success_callback = lambda app, email: -1
-
-        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
-
-        self.assertEqual(self._called, ((), {}))
+
+        self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
+
+        self.assertEqual(self._called, ((), {}))
+
+
+class LoginWithPingTestCase(LoginTestCase):
+    """Test suite for the login when the ping_url is set."""
+
+    kwargs = dict(app_name=APP_NAME, tc_url=TC_URL, help_text=HELP_TEXT,
+                  ping_url=PING_URL)
+    method = 'login_with_ping'
+    method_args = (APP_NAME, EMAIL, PASSWORD, PING_URL)
 
 
 class LoginValidationTestCase(UbuntuSSOClientTestCase):
@@ -1978,8 +1920,8 @@
         self.assert_warnings_visibility()
 
 
-class DbusTestCase(UbuntuSSOClientTestCase):
-    """Test suite for the dbus calls."""
+class SignalsTestCase(UbuntuSSOClientTestCase):
+    """Test suite for the backend signals."""
 
     def test_all_the_signals_are_listed(self):
         """All the backend signals are listed to be binded."""
@@ -1993,13 +1935,12 @@
 
     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.'
+        msg1 = 'callback %r for signal %r must be added to the backend.'
         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.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))
+            actual = self.ui.backend.callbacks.get(signal)
+            self.assertEqual([method], actual, msg1 % (method, signal))
+            actual = self.ui._signals_receivers.get(signal)
             self.assertEqual(method, actual, msg2 % (method, signal))
 
     def test_callbacks_only_log_when_app_name_doesnt_match(self):
@@ -2126,79 +2067,62 @@
         self.assertEqual(self.ui.help_label.get_text(), HELP_TEXT)
 
 
-class CallbacksTestCase(UbuntuSSOClientTestCase):
-    """Test the GTK callback calls."""
+class ReturnCodeTestCase(UbuntuSSOClientTestCase):
+    """Test the return codes."""
 
-    LOGIN_SUCCESSFULL = 'login_success_callback'
-    REGISTRATION_SUCCESS = 'registration_success_callback'
-    USER_CANCELLATION = 'user_cancellation_callback'
+    LOGIN_SUCCESS = gui.LOGIN_SUCCESS
+    REGISTRATION_SUCCESS = gui.REGISTRATION_SUCCESS
+    USER_CANCELLATION = gui.USER_CANCELLATION
 
     @defer.inlineCallbacks
     def setUp(self):
-        """Init."""
-        yield super(CallbacksTestCase, self).setUp()
-        self._called = {}
-        for name in (self.LOGIN_SUCCESSFULL,
-                     self.REGISTRATION_SUCCESS,
-                     self.USER_CANCELLATION):
-            setattr(self.ui, name, self._set_called(name))
-
-    def _set_called(self, callback_name):
-        """Keep trace of callbacks calls."""
-
-        # pylint: disable=W0221
-
-        def inner(*args, **kwargs):
-            """Store arguments used in this call."""
-            self._called[callback_name] = args
-
-        return inner
+        yield super(ReturnCodeTestCase, self).setUp()
+        self.patch(gui.sys, 'exit', self._set_called)
 
     def test_closing_main_window(self):
         """When closing the main window, USER_CANCELLATION is called."""
         self.ui.window.emit('delete-event', gtk.gdk.Event(gtk.gdk.DELETE))
-        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
 
     def test_every_cancel_calls_proper_callback(self):
         """When any cancel button is clicked, USER_CANCELLATION is called."""
-        msg = 'user_cancellation_callback is called when "%s" is clicked.'
+        self.patch(self.ui.backend, 'disconnect_from_signal', lambda *a: None)
+        msg = 'USER_CANCELLATION should be returned when "%s" is clicked.'
         buttons = filter(lambda name: 'cancel_button' in name, self.ui.widgets)
         for name in buttons:
             widget = getattr(self.ui, name)
             widget.clicked()
-            self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,),
+            self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}),
                              msg % name)
-            self._called = {}
+            self._called = False
 
     def test_on_user_registration_error_proper_callback_is_called(self):
         """On UserRegistrationError, USER_CANCELLATION is called."""
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
 
     def test_on_email_validated_proper_callback_is_called(self):
         """On EmailValidated, REGISTRATION_SUCCESS is called."""
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called[self.REGISTRATION_SUCCESS],
-                         (APP_NAME, EMAIL))
+        self.assertEqual(self._called, ((gui.REGISTRATION_SUCCESS,), {}))
 
     def test_on_email_validation_error_proper_callback_is_called(self):
         """On EmailValidationError, USER_CANCELLATION is called."""
         self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
 
     def test_on_logged_in_proper_callback_is_called(self):
-        """On LoggedIn, LOGIN_SUCCESSFULL is called."""
+        """On LoggedIn, LOGIN_SUCCESS is called."""
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called[self.LOGIN_SUCCESSFULL],
-                         (APP_NAME, EMAIL))
+        self.assertEqual(self._called, ((gui.LOGIN_SUCCESS,), {}))
 
     def test_on_login_error_proper_callback_is_called(self):
         """On LoginError, USER_CANCELLATION is called."""
@@ -2206,7 +2130,7 @@
         self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
 
     def test_registration_success_even_if_prior_registration_error(self):
         """Only one callback is called with the final outcome.
@@ -2221,13 +2145,12 @@
         self.ui.on_email_validated(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called[self.REGISTRATION_SUCCESS],
-                         (APP_NAME, EMAIL))
+        self.assertEqual(self._called, ((gui.REGISTRATION_SUCCESS,), {}))
 
     def test_login_success_even_if_prior_login_error(self):
         """Only one callback is called with the final outcome.
 
-        When the user successfully logins, LOGIN_SUCCESSFULL is called even if
+        When the user successfully logins, LOGIN_SUCCESS is called even if
         there were errors before.
 
         """
@@ -2237,8 +2160,7 @@
         self.ui.on_logged_in(app_name=APP_NAME, email=EMAIL)
         self.ui.on_close_clicked()
 
-        self.assertEqual(self._called[self.LOGIN_SUCCESSFULL],
-                         (APP_NAME, EMAIL))
+        self.assertEqual(self._called, ((gui.LOGIN_SUCCESS,), {}))
 
     def test_user_cancelation_even_if_prior_registration_error(self):
         """Only one callback is called with the final outcome.
@@ -2251,7 +2173,7 @@
         self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)
         self.ui.join_cancel_button.clicked()
 
-        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
 
     def test_user_cancelation_even_if_prior_login_error(self):
         """Only one callback is called with the final outcome.
@@ -2264,7 +2186,7 @@
         self.ui.on_login_error(app_name=APP_NAME, error=self.error)
         self.ui.login_cancel_button.clicked()
 
-        self.assertEqual(self._called[self.USER_CANCELLATION], (APP_NAME,))
+        self.assertEqual(self._called, ((gui.USER_CANCELLATION,), {}))
 
 
 class DefaultButtonsTestCase(UbuntuSSOClientTestCase):

=== added file 'ubuntu_sso/gtk/tests/test_main.py'
--- ubuntu_sso/gtk/tests/test_main.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/gtk/tests/test_main.py	2012-01-18 13:20:30 +0000
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program. If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the GUI main module."""
+
+import sys
+
+from StringIO import StringIO
+
+from twisted.trial.unittest import TestCase
+
+from ubuntu_sso.gtk import main
+
+
+APP_NAME = 'Foo Bar'
+DEFAULTS = dict(
+    app_name=APP_NAME,
+    help_text='',
+    login_only=False,
+    ping_url='',
+    tc_url='',
+    window_id=0,
+)
+DUMMY_TEXT = """Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed
+risus orci, lacinia ac tincidunt fermentum, vestibulum suscipit orci. Aliquam
+quis aliquet magna. Morbi vitae ligula ut libero porttitor imperdiet.
+Vestibulum et ipsum sapien, pellentesque ultricies risus. Aenean in lectus
+orci. Cras a lorem sollicitudin dui mollis varius. In hac habitasse platea
+dictumst."""
+PROGRAM = 'foo-bar'
+SOME_URL = 'http://example.com/foo/bar'
+
+
+class BasicTestCase(TestCase):
+    """Test case with a helper tracker."""
+
+    def assert_parse_args_custom_field(self, option_name=None,
+                                       option_value=None):
+        """The args are correctly set when using a custom value."""
+        expected = dict(DEFAULTS)
+        argv = [PROGRAM, '--app_name=%s' % APP_NAME]
+
+        if option_name is not None:
+            if option_value is not None:
+                argv.append('--%s=%s' % (option_name, option_value))
+                expected[option_name] = option_value
+            else:
+                argv.append('--%s' % (option_name,))
+                expected[option_name] = True
+
+        self.patch(sys, 'argv', argv)
+
+        result = main.parse_args()
+
+        # Access to a protected member, pylint: disable=W0212
+        self.assertEqual(expected, dict(result._get_kwargs()))
+
+    def test_main(self):
+        """Calling main.main() a UI instance is created."""
+        called = []
+        self.patch(main, 'UbuntuSSOClientGUI',
+                   lambda **kw: called.append(('GUI', kw)))
+        self.patch(main.gtk, 'main',
+                   lambda: called.append('gtk.main'))
+
+        kwargs = dict(foo='foo', bar='bar', baz='yadda', yadda=0)
+        main.main(**kwargs)
+
+        kwargs['close_callback'] = main.gtk.main_quit
+        self.assertEqual(called, [('GUI', kwargs), 'gtk.main'])
+
+    def test_parse_args_app_name_is_required(self):
+        """If no app_name, show help and exit."""
+        called = []
+        stderr = StringIO()
+        self.addCleanup(stderr.close)
+
+        self.patch(sys, 'argv', [PROGRAM])
+        self.patch(sys, 'exit', called.append)
+        self.patch(sys, 'stderr', stderr)
+
+        main.parse_args()
+
+        self.assertEqual(called, [2])
+        self.assertIn('usage: %s' % PROGRAM, stderr.getvalue())
+        self.assertIn('app_name is required', stderr.getvalue())
+
+    def test_parse_args_defaults(self):
+        """The args are correctly set when using defaults."""
+        self.assert_parse_args_custom_field()
+
+    def test_parse_args_help_text(self):
+        """The args are correctly set when using a custom help_text."""
+        self.assert_parse_args_custom_field('help_text', DUMMY_TEXT)
+
+    def test_parse_args_ping_url(self):
+        """The args are correctly set when using a custom ping_url."""
+        self.assert_parse_args_custom_field('ping_url', SOME_URL)
+
+    def test_parse_args_tc_url(self):
+        """The args are correctly set when using a custom tc_url."""
+        self.assert_parse_args_custom_field('tc_url', SOME_URL)
+
+    def test_parse_args_window_id(self):
+        """The args are correctly set when using a custom window_id."""
+        self.assert_parse_args_custom_field('window_id', 42)
+
+    def test_parse_args_login_only(self):
+        """The args are correctly set when using a custom login_only."""
+        self.assert_parse_args_custom_field('login_only')

=== modified file 'ubuntu_sso/keyring/linux.py'
--- ubuntu_sso/keyring/linux.py	2011-03-03 15:19:29 +0000
+++ ubuntu_sso/keyring/linux.py	2012-01-18 13:20:30 +0000
@@ -37,7 +37,7 @@
     try_old_credentials)
 
 
-logger = setup_logging("ubuntu_sso.keyring")
+logger = setup_logging("ubuntu_sso.keyring.linux")
 
 
 class Keyring(object):
@@ -51,16 +51,15 @@
     def _find_keyring_item(self, app_name, attr=None):
         """Return the keyring item or None if not found."""
         if attr is None:
-            logger.debug("getting attr")
             attr = self._get_keyring_attr(app_name)
-        logger.debug("finding all items")
+        logger.debug("Finding all items for app_name %r.", app_name)
         items = yield self.service.search_items(attr)
         if len(items) == 0:
             # if no items found, return None
-            logger.debug("No items found")
+            logger.debug("No items found!")
             returnValue(None)
 
-        logger.debug("Returning first item found")
+        logger.debug("Returning first item found.")
         returnValue(items[0])
 
     def _get_keyring_attr(self, app_name):
@@ -84,44 +83,36 @@
     @inlineCallbacks
     def _migrate_old_token_name(self, app_name):
         """Migrate credentials with old name, store them with new name."""
-        logger.debug("getting keyring attr")
+        logger.debug("Migrating old token name.")
         attr = self._get_keyring_attr(app_name)
-        logger.debug("getting old token name")
         attr['token-name'] = get_old_token_name(app_name)
-        logger.debug("finding keyring item")
         item = yield self._find_keyring_item(app_name, attr=attr)
         if item is not None:
-            logger.debug("setting credentials")
             yield self.set_credentials(app_name,
                                        dict(urlparse.parse_qsl(item.secret)))
-            logger.debug("deleting old item")
             yield item.delete()
 
-        logger.debug("finding keyring item")
         result = yield self._find_keyring_item(app_name)
-        logger.debug("returning result value")
         returnValue(result)
 
     @inlineCallbacks
     def get_credentials(self, app_name):
         """A deferred with the secret of the SSO item in a dictionary."""
         # If we have no attributes, return None
-        logger.debug("getting credentials")
+        logger.debug("Getting credentials for %r.", app_name)
         yield self.service.open_session()
-        logger.debug("calling find item")
         item = yield self._find_keyring_item(app_name)
         if item is None:
-            logger.debug("migrating token")
             item = yield self._migrate_old_token_name(app_name)
 
         if item is not None:
-            logger.debug("parsing secret")
+            logger.debug("Parsing secret.")
             secret = yield item.get_value()
             returnValue(dict(urlparse.parse_qsl(secret)))
         else:
             # if no item found, try getting the old credentials
             if app_name == U1_APP_NAME:
-                logger.debug("trying old credentials")
+                logger.debug("Trying old credentials for %r.", app_name)
                 old_creds = yield try_old_credentials(app_name)
                 returnValue(old_creds)
         # nothing was found