Merge lp:~nataliabidart/ubuntu-sso-client/no-more-deprecated-service into lp:ubuntu-sso-client

[Natalia Bidart]

- Removing the deprecated SSOCredentials interface (LP: #859635).

[Roberto Alsina (ralsina)]

+1

review: Approve

[Manuel de la Peña (mandel)]

About time we get these classes out :)

review: Approve

=== modified file 'bin/ubuntu-sso-login'
--- bin/ubuntu-sso-login	2011-01-11 19:13:19 +0000
+++ bin/ubuntu-sso-login	2011-09-27 21:50:39 +0000
@@ -29,7 +29,7 @@
 # the locale and imports decimal, and that generates the following trace:
 # Traceback (most recent call last):
 #   File "/usr/lib/ubuntu-sso-client/ubuntu-sso-login", line 33
-#     from ubuntu_sso.main import SSOLogin, SSOCredentials
+#     from ubuntu_sso.main import SSOLogin
 #   File "/usr/lib/pymodules/python2.6/ubuntu_sso/main.py", line 42
 #     from lazr.restfulclient.resource import ServiceRoot
 #   File "/usr/lib/python2.6/dist-packages/lazr/restfulclient/resource.py",
@@ -52,7 +52,7 @@
 
 from ubuntu_sso import (DBUS_BUS_NAME, DBUS_ACCOUNT_PATH, DBUS_CRED_PATH,
     DBUS_CREDENTIALS_PATH)
-from ubuntu_sso.main import SSOLogin, SSOCredentials, CredentialsManagement
+from ubuntu_sso.main import SSOLogin, CredentialsManagement
 
 from ubuntu_sso.logger import setup_logging
 
@@ -93,7 +93,6 @@
     logger.info("Starting Ubuntu SSO login manager for bus %r.", DBUS_BUS_NAME)
     bus_name = dbus.service.BusName(DBUS_BUS_NAME, bus=dbus.SessionBus())
     SSOLogin(bus_name, object_path=DBUS_ACCOUNT_PATH)
-    SSOCredentials(bus_name, object_path=DBUS_CRED_PATH)
     CredentialsManagement(timeout_func=gtk.timeout_add,
                           shutdown_func=gtk.main_quit,
                           bus_name=bus_name, object_path=DBUS_CREDENTIALS_PATH)

=== modified file 'bin/windows-ubuntu-sso-login'
--- bin/windows-ubuntu-sso-login	2011-07-22 22:00:45 +0000
+++ bin/windows-ubuntu-sso-login	2011-09-27 21:50:39 +0000
@@ -37,7 +37,6 @@
 from ubuntu_sso.main.windows import (
     CredentialsManagement,
     LOCALHOST,
-    SSOCredentials,
     SSOLogin,
     UbuntuSSORoot,
     get_activation_config,
@@ -61,9 +60,8 @@
     port = yield ai.get_port()
 
     login = SSOLogin('ignored')
-    creds = SSOCredentials()
     creds_management = CredentialsManagement(add_timeout, reactor.stop)
-    root = UbuntuSSORoot(login, creds, creds_management)
+    root = UbuntuSSORoot(soo_login=login, cred_manager=creds_management)
 
     reactor.listenTCP(port, PBServerFactory(root), interface=LOCALHOST)
 

=== modified file 'ubuntu_sso/main/__init__.py'
--- ubuntu_sso/main/__init__.py	2011-09-14 18:15:33 +0000
+++ ubuntu_sso/main/__init__.py	2011-09-27 21:50:39 +0000
@@ -19,11 +19,8 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Main object implementations."""
 
-import os
 import sys
-import warnings
 
-from ubuntu_sso import NO_OP
 from ubuntu_sso.account import Account
 from ubuntu_sso.credentials import (
     Credentials,
@@ -37,7 +34,7 @@
     UI_MODULE_KEY,
     WINDOW_ID_KEY,
 )
-from ubuntu_sso.keyring import get_token_name, U1_APP_NAME, Keyring
+from ubuntu_sso.keyring import get_token_name, Keyring
 from ubuntu_sso.logger import setup_logging
 
 
@@ -46,20 +43,6 @@
 TIMEOUT_INTERVAL = 10000  # 10 seconds
 
 
-class SSOLoginProcessor(Account):
-    """Login and register users using the Ubuntu Single Sign On service.
-
-    Alias classname to maintain backwards compatibility. DO NOT USE, use
-    ubuntu_sso.account.Account instead.
-    """
-
-    def __init__(self, sso_service_class=None):
-        """Create a new SSO Account manager."""
-        msg = 'Use ubuntu_sso.account.Account instead.'
-        warnings.warn(msg, DeprecationWarning)
-        super(SSOLoginProcessor, self).__init__(sso_service_class)
-
-
 def except_to_errdict(e):
     """Turn an exception into a dictionary to return thru DBus."""
     result = {
@@ -169,84 +152,6 @@
         thread_execute(f, app_name, result_cb, error_cb)
 
 
-class SSOCredentialsRoot(object):
-    """Object that gets credentials, and login/registers if needed.
-
-    This class is DEPRECATED, use CredentialsManagementRoot instead.
-
-    """
-
-    def __init__(self):
-        self.ping_url = os.environ.get('USSOC_PING_URL', U1_PING_URL)
-        msg = 'Use ubuntu_sso.main.CredentialsManagementRoot instead.'
-        warnings.warn(msg, DeprecationWarning)
-
-    def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Get the credentials from the keyring or {} if not there."""
-
-        def log_result(result):
-            """Log the result and continue."""
-            logger.info('find_credentials: app_name "%s", result is {}? %s',
-                        app_name, result == {})
-            return result
-
-        d = Credentials(app_name=app_name).find_credentials()
-        # pylint: disable=E1101
-        d.addCallback(log_result)
-        d.addCallbacks(callback, errback)
-
-    def login_or_register_to_get_credentials(self, app_name,
-                                             terms_and_conditions_url,
-                                             help_text, window_id,
-                                             success_cb, error_cb, denial_cb,
-                                             ui_module='ubuntu_sso.gtk.gui'):
-        """Get credentials if found else prompt GUI to login or register.
-
-        'app_name' will be displayed in the GUI.
-        'terms_and_conditions_url' will be the URL pointing to T&C.
-        'help_text' is an explanatory text for the end-users, will be shown
-         below the headers.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        ping_url = self.ping_url if app_name == U1_APP_NAME else None
-        obj = Credentials(app_name=app_name, ping_url=ping_url,
-                          tc_url=terms_and_conditions_url,
-                          help_text=help_text, window_id=window_id,
-                          success_cb=success_cb, error_cb=error_cb,
-                          denial_cb=denial_cb, ui_module=ui_module)
-        obj.register()
-
-    def login_to_get_credentials(self, app_name, help_text, window_id,
-                                 success_cb, error_cb, denial_cb,
-                                 ui_module='ubuntu_sso.gtk.gui'):
-        """Get credentials if found else prompt GUI just to login
-
-        'app_name' will be displayed in the GUI.
-        'help_text' is an explanatory text for the end-users, will be shown
-         before the login fields.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        ping_url = self.ping_url if app_name == U1_APP_NAME else None
-        obj = Credentials(app_name=app_name, ping_url=ping_url, tc_url=None,
-                          help_text=help_text, window_id=window_id,
-                          success_cb=success_cb, error_cb=error_cb,
-                          denial_cb=denial_cb, ui_module=ui_module)
-        obj.login()
-
-    def clear_token(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Clear the token for an application from the keyring.
-
-        'app_name' is the name of the application.
-        """
-        d = Credentials(app_name=app_name).clear_credentials()
-        # pylint: disable=E1101
-        d.addCallbacks(lambda _: callback(), errback)
-
-
 class CredentialsManagementRoot(object):
     """Object that manages credentials.
 
@@ -434,7 +339,6 @@
 if sys.platform == 'win32':
     from ubuntu_sso.main import windows
     SSOLogin = windows.SSOLogin
-    SSOCredentials = windows.SSOCredentials
     CredentialsManagement = windows.CredentialsManagement
     TIMEOUT_INTERVAL = 10000000000  # forever
     thread_execute = windows.blocking
@@ -442,7 +346,6 @@
 else:
     from ubuntu_sso.main import linux
     SSOLogin = linux.SSOLogin
-    SSOCredentials = linux.SSOCredentials
     CredentialsManagement = linux.CredentialsManagement
     thread_execute = linux.blocking
     get_sso_login_backend = linux.get_sso_login_backend

=== modified file 'ubuntu_sso/main/linux.py'
--- ubuntu_sso/main/linux.py	2011-09-14 18:15:33 +0000
+++ ubuntu_sso/main/linux.py	2011-09-27 21:50:39 +0000
@@ -28,24 +28,19 @@
 """
 
 import threading
-import warnings
 
 import dbus.service
 
 from ubuntu_sso import (
     DBUS_ACCOUNT_PATH,
     DBUS_CREDENTIALS_IFACE,
-    DBUS_IFACE_CRED_NAME,
     DBUS_IFACE_USER_NAME,
-    NO_OP,
 )
 from ubuntu_sso.account import Account
-from ubuntu_sso.credentials import ERROR_KEY, ERROR_DETAIL_KEY
 from ubuntu_sso.logger import setup_logging
 from ubuntu_sso.main import (
     CredentialsManagementRoot,
     SSOLoginRoot,
-    SSOCredentialsRoot,
     except_to_errdict,
 )
 
@@ -83,8 +78,6 @@
         dbus.service.Object.__init__(self, object_path=object_path,
                                      bus_name=bus_name)
         self.root = SSOLoginRoot(sso_login_processor_class, sso_service_class)
-        msg = 'Use ubuntu_sso.main.CredentialsManagement instead.'
-        warnings.warn(msg, DeprecationWarning)
 
     # generate_capcha signals
     @dbus.service.signal(DBUS_IFACE_USER_NAME, signature="ss")
@@ -220,106 +213,6 @@
                                    self.PasswordChangeError)
 
 
-class SSOCredentials(dbus.service.Object):
-    """DBus object that gets credentials, and login/registers if needed.
-
-    This class is Deprecated. DO NOT USE, use CredentialsManagement instead.
-
-    """
-
-    # Operator not preceded by a space (fails with dbus decorators)
-    # pylint: disable=C0322
-
-    def __init__(self, *args, **kwargs):
-        dbus.service.Object.__init__(self, *args, **kwargs)
-        self.root = SSOCredentialsRoot()
-        warnings.warn('%r DBus object is deprecated, please use %r instead.' %
-                      (DBUS_IFACE_CRED_NAME, DBUS_CREDENTIALS_IFACE),
-                      DeprecationWarning)
-
-    def _process_error(self, app_name, error_dict):
-        """Process the 'error_dict' and emit CredentialsError."""
-        msg = error_dict.get(ERROR_KEY, 'No error message given.')
-        detail = error_dict.get(ERROR_DETAIL_KEY, 'No detailed error given.')
-        self.CredentialsError(app_name, msg, detail)
-
-    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="s")
-    def AuthorizationDenied(self, app_name):
-        """Signal thrown when the user denies the authorization."""
-        logger.info('SSOCredentials: emitting AuthorizationDenied with '
-                    'app_name "%s"', app_name)
-
-    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sa{ss}")
-    def CredentialsFound(self, app_name, credentials):
-        """Signal thrown when the credentials are found."""
-        logger.info('SSOCredentials: emitting CredentialsFound with '
-                    'app_name "%s"', app_name)
-
-    @dbus.service.signal(DBUS_IFACE_CRED_NAME, signature="sss")
-    def CredentialsError(self, app_name, error_message, detailed_error):
-        """Signal thrown when there is a problem finding the credentials."""
-        logger.error('SSOCredentials: emitting CredentialsError with app_name '
-                     '"%s" and error_message %r', app_name, error_message)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature="s", out_signature="a{ss}",
-                         async_callbacks=("callback", "errback"))
-    def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Get the credentials from the keyring or {} if not there."""
-        self.root.find_credentials(app_name, callback, errback)
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature="sssx", out_signature="")
-    def login_or_register_to_get_credentials(self, app_name,
-                                             terms_and_conditions_url,
-                                             help_text, window_id):
-        """Get credentials if found else prompt GUI to login or register.
-
-        'app_name' will be displayed in the GUI.
-        'terms_and_conditions_url' will be the URL pointing to T&C.
-        'help_text' is an explanatory text for the end-users, will be shown
-         below the headers.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        self.root.login_or_register_to_get_credentials(app_name,
-                                               terms_and_conditions_url,
-                                               help_text, window_id,
-                                               self.CredentialsFound,
-                                               self._process_error,
-                                               self.AuthorizationDenied,
-                                               ui_module='ubuntu_sso.gtk.gui')
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature="ssx", out_signature="")
-    def login_to_get_credentials(self, app_name, help_text, window_id):
-        """Get credentials if found else prompt GUI just to login
-
-        'app_name' will be displayed in the GUI.
-        'help_text' is an explanatory text for the end-users, will be shown
-         before the login fields.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        self.root.login_to_get_credentials(app_name, help_text, window_id,
-                                           self.CredentialsFound,
-                                           self._process_error,
-                                           self.AuthorizationDenied,
-                                           ui_module='ubuntu_sso.gtk.gui')
-
-    @dbus.service.method(dbus_interface=DBUS_IFACE_CRED_NAME,
-                         in_signature='s', out_signature='',
-                         async_callbacks=("callback", "errback"))
-    def clear_token(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Clear the token for an application from the keyring.
-
-        'app_name' is the name of the application.
-        """
-        self.root.clear_token(app_name, callback, errback)
-
-
 class CredentialsManagement(dbus.service.Object):
     """DBus object that manages credentials.
 

=== modified file 'ubuntu_sso/main/tests/test_common.py'
--- ubuntu_sso/main/tests/test_common.py	2011-08-22 16:21:36 +0000
+++ ubuntu_sso/main/tests/test_common.py	2011-09-27 21:50:39 +0000
@@ -21,39 +21,14 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Tests share by diff platforms."""
 
-import os
-
 from unittest import TestCase
+
 from mocker import MockerTestCase, MATCH
+
 from ubuntu_sso.main import (
     CredentialsManagement,
-    SSOCredentialsRoot,
-    SSOCredentials,
     SSOLogin,
-    U1_PING_URL)
-
-
-class EnvironOverridesTestCase(TestCase):
-    """Some URLs can be set from the environment for testing/QA purposes."""
-
-    def test_override_ping_url(self):
-        """The ping url can be set from the environ via USSOC_PING_URL."""
-        fake_url = 'this is not really a URL'
-        old_url = os.environ.get('USSOC_PING_URL')
-        os.environ['USSOC_PING_URL'] = fake_url
-        try:
-            creds = SSOCredentialsRoot()
-            self.assertEqual(creds.ping_url, fake_url)
-        finally:
-            if old_url:
-                os.environ['USSOC_PING_URL'] = old_url
-            else:
-                del os.environ['USSOC_PING_URL']
-
-    def test_no_override_ping_url(self):
-        """If the environ is unset, the default ping url is used."""
-        creds = SSOCredentialsRoot()
-        self.assertEqual(creds.ping_url, U1_PING_URL)
+)
 
 
 class SSOLoginMockedTestCase(MockerTestCase):
@@ -142,53 +117,6 @@
         self.login.set_new_password(app_name, email, token, new_password)
 
 
-class SSOCredentialsMockedTestCase(MockerTestCase):
-    """Test that the call are relied correctly."""
-
-    def setUp(self):
-        """Setup tests."""
-        super(SSOCredentialsMockedTestCase, self).setUp()
-        self.root = self.mocker.mock()
-        mockbusname = self.mocker.mock()
-        mockbus = self.mocker.mock()
-        mockbusname.get_bus()
-        self.mocker.result(mockbus)
-        self.cred = SSOCredentials(mockbus)
-        self.cred.root = self.root
-        self.mocker.reset()
-
-    def test_find_credentials(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        result_cb = error_cb = lambda: None
-        self.root.find_credentials(app_name, MATCH(callable), MATCH(callable))
-        self.mocker.mock()
-        self.mocker.replay()
-        self.cred.find_credentials(app_name, result_cb, error_cb)
-
-    def test_login_or_register_to_get_credentials(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        terms = 'terms'
-        help_text = 'help'
-        window_id = 'id'
-        self.root.login_or_register_to_get_credentials(app_name, terms,
-                                help_text, window_id, MATCH(callable),
-                                MATCH(callable), MATCH(callable),
-                                ui_module=MATCH(lambda x: isinstance(x, str)))
-        self.mocker.replay()
-        self.cred.login_or_register_to_get_credentials(app_name, terms,
-                                                       help_text, window_id)
-
-    def test_clear_token(self):
-        """Test that the call is relayed."""
-        app_name = 'app'
-        result_cb = error_cb = lambda: None
-        self.root.clear_token(app_name, MATCH(callable), MATCH(callable))
-        self.mocker.replay()
-        self.cred.clear_token(app_name, result_cb, error_cb)
-
-
 class CredentialsManagementMockedTestCase(MockerTestCase, TestCase):
     """Test that the call are relied correctly."""
 

=== modified file 'ubuntu_sso/main/tests/test_linux.py'
--- ubuntu_sso/main/tests/test_linux.py	2011-08-22 16:21:36 +0000
+++ ubuntu_sso/main/tests/test_linux.py	2011-09-27 21:50:39 +0000
@@ -21,11 +21,9 @@
 """Tests for the main SSO client code."""
 
 import logging
-import os
 
-from mocker import Mocker, MockerTestCase, ARGS, KWARGS, MATCH
+from mocker import Mocker, ARGS, KWARGS
 from twisted.internet import defer
-from twisted.internet.defer import Deferred, inlineCallbacks
 from twisted.trial.unittest import TestCase
 from ubuntuone.devtools.handlers import MementoHandler
 
@@ -34,9 +32,12 @@
 import ubuntu_sso.main.linux
 
 from ubuntu_sso import DBUS_CREDENTIALS_IFACE
-from ubuntu_sso.keyring import U1_APP_NAME
-from ubuntu_sso.main import (U1_PING_URL, except_to_errdict,
-    CredentialsManagement, SSOCredentials, SSOLogin, TIMEOUT_INTERVAL)
+from ubuntu_sso.main import (
+    except_to_errdict,
+    CredentialsManagement,
+    SSOLogin,
+    TIMEOUT_INTERVAL,
+)
 from ubuntu_sso.main.linux import blocking
 from ubuntu_sso.main import (HELP_TEXT_KEY, PING_URL_KEY,
     TC_URL_KEY, UI_CLASS_KEY, UI_MODULE_KEY, WINDOW_ID_KEY,
@@ -116,7 +117,7 @@
 
     def test_generate_captcha(self):
         """Test that the captcha method works ok."""
-        d = Deferred()
+        d = defer.Deferred()
         filename = "sample filename"
         expected_result = "expected result"
         self.create_mock_processor().generate_captcha(filename)
@@ -139,7 +140,7 @@
 
     def test_generate_captcha_error(self):
         """Test that the captcha method fails as expected."""
-        d = Deferred()
+        d = defer.Deferred()
         filename = "sample filename"
         expected_result = "expected result"
         self.create_mock_processor().generate_captcha(filename)
@@ -162,7 +163,7 @@
 
     def test_register_user(self):
         """Test that the register_user method works ok."""
-        d = Deferred()
+        d = defer.Deferred()
         expected_result = "expected result"
         self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
             CAPTCHA_ID, CAPTCHA_SOLUTION)
@@ -186,7 +187,7 @@
 
     def test_register_user_error(self):
         """Test that the register_user method fails as expected."""
-        d = Deferred()
+        d = defer.Deferred()
         expected_result = "expected result"
         self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
             CAPTCHA_ID, CAPTCHA_SOLUTION)
@@ -210,7 +211,7 @@
 
     def test_login(self):
         """Test that the login method works ok."""
-        d = Deferred()
+        d = defer.Deferred()
         processor = self.create_mock_processor()
         processor.login(EMAIL, PASSWORD, TOKEN_NAME)
         self.mocker.result(TOKEN)
@@ -236,7 +237,7 @@
 
     def test_login_user_not_validated(self):
         """Test that the login sends EmailNotValidated signal."""
-        d = Deferred()
+        d = defer.Deferred()
         processor = self.create_mock_processor()
         processor.login(EMAIL, PASSWORD, TOKEN_NAME)
         self.mocker.result(TOKEN)
@@ -262,7 +263,7 @@
 
     def test_login_error_get_token_name(self):
         """The login method fails as expected when get_token_name fails."""
-        d = Deferred()
+        d = defer.Deferred()
         self.create_mock_processor()
         self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
 
@@ -290,7 +291,7 @@
 
     def test_login_error_set_credentials(self):
         """The login method fails as expected when set_credentials fails."""
-        d = Deferred()
+        d = defer.Deferred()
         processor = self.create_mock_processor()
         processor.login(EMAIL, PASSWORD, TOKEN_NAME)
         self.mocker.result(TOKEN)
@@ -324,7 +325,7 @@
 
     def test_validate_email(self):
         """Test that the validate_email method works ok."""
-        d = Deferred()
+        d = defer.Deferred()
         self.create_mock_processor().validate_email(EMAIL, PASSWORD,
                                                     EMAIL_TOKEN, TOKEN_NAME)
         self.mocker.result(TOKEN)
@@ -347,7 +348,7 @@
 
     def test_validate_email_error(self):
         """Test that the validate_email method fails as expected."""
-        d = Deferred()
+        d = defer.Deferred()
         self.create_mock_processor()
         self.patch(ubuntu_sso.main.linux, "blocking", fake_err_blocking)
 
@@ -374,7 +375,7 @@
 
     def test_request_password_reset_token(self):
         """Test that the request_password_reset_token method works ok."""
-        d = Deferred()
+        d = defer.Deferred()
         processor = self.create_mock_processor()
         processor.request_password_reset_token(EMAIL)
         self.patch(ubuntu_sso.main, "thread_execute", fake_ok_blocking)
@@ -396,7 +397,7 @@
 
     def test_request_password_reset_token_error(self):
         """Test the request_password_reset_token method fails as expected."""
-        d = Deferred()
+        d = defer.Deferred()
 
         self.create_mock_processor().request_password_reset_token(EMAIL)
         self.mocker.result(EMAIL)
@@ -418,7 +419,7 @@
 
     def test_set_new_password(self):
         """Test that the set_new_password method works ok."""
-        d = Deferred()
+        d = defer.Deferred()
         self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
                                                       PASSWORD)
         self.mocker.result(EMAIL)
@@ -440,7 +441,7 @@
 
     def test_set_new_password_error(self):
         """Test that the set_new_password method fails as expected."""
-        d = Deferred()
+        d = defer.Deferred()
         expected_result = "expected result"
 
         self.create_mock_processor().set_new_password(EMAIL, EMAIL_TOKEN,
@@ -470,7 +471,7 @@
 
     def test_blocking(self):
         """Test the normal behaviour."""
-        d = Deferred()
+        d = defer.Deferred()
         expected_result = "expected result"
 
         def f():
@@ -488,7 +489,7 @@
 
     def test_blocking_error(self):
         """Test the behaviour when an Exception is raised."""
-        d = Deferred()
+        d = defer.Deferred()
         expected_error_message = "expected error message"
 
         def f():
@@ -559,150 +560,6 @@
         self.assertEqual(result["errtype"], e.__class__.__name__)
 
 
-class RegisterSampleException(Exception):
-    """A mock exception thrown just when testing."""
-
-
-class ApplicationCredentialsTestCase(TestCase, MockerTestCase):
-    """Tests for the ApplicationCredentials related DBus methods."""
-
-    timeout = 5
-
-    def setUp(self):
-        MockerTestCase.setUp(self)
-
-        self.client = SSOCredentials(self.mocker.mock())
-
-        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
-        mock_class(app_name=APP_NAME)
-        self.creds_obj = self.mocker.mock()
-        self.mocker.result(self.creds_obj)
-
-    @inlineCallbacks
-    def test_find_credentials(self):
-        """find_credentials immediately returns the token when found."""
-        expected_creds = "expected creds"
-        self.creds_obj.find_credentials()
-        self.mocker.result(defer.succeed(expected_creds))
-        self.mocker.replay()
-
-        d = Deferred()
-        self.client.find_credentials(APP_NAME, d.callback, d.errback)
-        creds = yield d
-        self.assertEqual(creds, expected_creds)
-
-    @inlineCallbacks
-    def test_credentials_not_found(self):
-        """find_credentials immediately returns {} when no creds found."""
-        expected_creds = {}
-        self.creds_obj.find_credentials()
-        self.mocker.result(defer.succeed(expected_creds))
-        self.mocker.replay()
-
-        d = Deferred()
-        self.client.find_credentials(APP_NAME, d.callback, d.errback)
-        creds = yield d
-        self.assertEqual(creds, expected_creds)
-
-
-class ApplicationCredentialsGUITestCase(TestCase, MockerTestCase):
-    """Tests for the ApplicationCredentials register/login DBus method."""
-
-    app_name = APP_NAME
-    ping_url = None
-
-    def setUp(self):
-        MockerTestCase.setUp(self)
-        self.client = SSOCredentials(self.mocker.mock())
-        self.args = {PING_URL_KEY: self.ping_url,
-                     TC_URL_KEY: TC_URL, HELP_TEXT_KEY: HELP_TEXT,
-                     WINDOW_ID_KEY: WINDOW_ID,
-                     SUCCESS_CB_KEY: self.client.CredentialsFound,
-                     ERROR_CB_KEY: self.client._process_error,
-                     DENIAL_CB_KEY: self.client.AuthorizationDenied}
-
-    def test_login_or_register(self):
-        """login_or_register is correct."""
-        self.args[UI_MODULE_KEY] = MATCH(lambda x: isinstance(x, str))
-        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
-        mock_class(app_name=self.app_name, **self.args)
-        creds_obj = self.mocker.mock()
-        self.mocker.result(creds_obj)
-
-        creds_obj.register()
-        self.mocker.replay()
-
-        args = (self.app_name, TC_URL, HELP_TEXT, WINDOW_ID)
-        self.client.login_or_register_to_get_credentials(*args)
-
-    def test_login_only(self):
-        """login_or_register is correct."""
-        self.args[TC_URL_KEY] = None
-        self.args[UI_MODULE_KEY] = MATCH(lambda x: isinstance(x, str))
-        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
-        mock_class(app_name=self.app_name, **self.args)
-        creds_obj = self.mocker.mock()
-        self.mocker.result(creds_obj)
-
-        creds_obj.login()
-        self.mocker.replay()
-
-        args = (self.app_name, HELP_TEXT, WINDOW_ID)
-        self.client.login_to_get_credentials(*args)
-
-
-class ApplicationCredentialsU1TestCase(ApplicationCredentialsGUITestCase):
-    """Tests for the ApplicationCredentials register/login DBus method.
-
-    Specifically for APP_NAME == U1_APP_NAME.
-
-    """
-
-    app_name = U1_APP_NAME
-    ping_url = U1_PING_URL
-
-
-class ApplicationCredentialsClearTokenTestCase(TestCase, MockerTestCase):
-    """Tests for the ApplicationCredentials related DBus methods."""
-
-    def test_clear_token(self):
-        """Check that clear_token tries removing the correct token."""
-        mock_class = self.mocker.replace("ubuntu_sso.credentials.Credentials")
-        mock_class(app_name=APP_NAME)
-        creds_obj = self.mocker.mock()
-        self.mocker.result(creds_obj)
-
-        creds_obj.clear_credentials()
-        self.mocker.result(defer.succeed(None))
-        self.mocker.replay()
-
-        client = SSOCredentials(self.mocker.mock())
-        client.clear_token(APP_NAME)
-
-
-class EnvironOverridesTestCase(TestCase):
-    """Some URLs can be set from the environment for testing/QA purposes."""
-
-    def test_override_ping_url(self):
-        """The ping url can be set from the environ via USSOC_PING_URL."""
-        fake_url = 'this is not really a URL'
-        old_url = os.environ.get('USSOC_PING_URL')
-        os.environ['USSOC_PING_URL'] = fake_url
-        try:
-            creds = SSOCredentials(None)
-            self.assertEqual(creds.root.ping_url, fake_url)
-        finally:
-            if old_url:
-                os.environ['USSOC_PING_URL'] = old_url
-            else:
-                del os.environ['USSOC_PING_URL']
-
-    def test_no_override_ping_url(self):
-        """If the environ is unset, the default ping url is used."""
-        creds = SSOCredentials(None)
-        self.assertEqual(creds.root.ping_url, U1_PING_URL)
-
-
 class CredentialsManagementTestCase(TestCase):
     """Tests for the CredentialsManagement DBus interface."""
 
@@ -776,7 +633,7 @@
 
     def test_find_credentials(self):
         """Keep proper track of on going requests."""
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(*args):
             """Make the check."""
@@ -790,7 +647,7 @@
 
     def test_clear_credentials(self):
         """Keep proper track of on going requests."""
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(*args):
             """Make the check."""
@@ -804,7 +661,7 @@
 
     def test_store_credentials(self):
         """Keep proper track of on going requests."""
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(*args):
             """Make the check."""
@@ -1004,7 +861,7 @@
         If the creds are found, CredentialsFound is emitted.
 
         """
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(app_name, creds):
             """The actual test."""
@@ -1032,7 +889,7 @@
         If the creds are not found, CredentialsNotFound is emitted.
 
         """
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(app_name):
             """The actual test."""
@@ -1056,7 +913,7 @@
 
     def test_find_credentials_error(self):
         """If find_credentials fails, CredentialsError is sent."""
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(app_name, errdict):
             """The actual test."""
@@ -1091,7 +948,7 @@
 
     def test_clear_credentials_does_not_block(self):
         """Calling clear_credentials does not block but return thru signals."""
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(app_name):
             """The actual test."""
@@ -1115,7 +972,7 @@
 
     def test_clear_credentials_error(self):
         """If clear_credentials fails, CredentialsError is sent."""
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(app_name, errdict):
             """The actual test."""
@@ -1152,7 +1009,7 @@
         If the creds are stored, CredentialsStored is emitted.
 
         """
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(app_name):
             """The actual test."""
@@ -1176,7 +1033,7 @@
 
     def test_store_credentials_error(self):
         """If store_credentials fails, CredentialsError is sent."""
-        d = Deferred()
+        d = defer.Deferred()
 
         def verify(app_name, errdict):
             """The actual test."""

=== modified file 'ubuntu_sso/main/tests/test_windows.py'
--- ubuntu_sso/main/tests/test_windows.py	2011-09-14 18:21:11 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2011-09-27 21:50:39 +0000
@@ -37,8 +37,6 @@
     CredentialsManagementClient,
     LOCALHOST,
     SignalBroadcaster,
-    SSOCredentials,
-    SSOCredentialsClient,
     SSOLogin,
     SSOLoginClient,
     UbuntuSSORoot,
@@ -269,7 +267,7 @@
         self.root = self.mocker.mock()
         self.login = SSOLogin(None)
         # start pb
-        self.sso_root = UbuntuSSORoot(self.login, None, None)
+        self.sso_root = UbuntuSSORoot(sso_login=self.login)
         self.server_factory = SaveProtocolServerFactory(self.sso_root)
         # pylint: disable=E1101
         port = get_sso_pb_port()
@@ -542,191 +540,6 @@
         self.mocker.verify()
 
 
-class SSOCredentialsTestCase(TestCase):
-    """Test the credentials class."""
-
-    @defer.inlineCallbacks
-    def setUp(self):
-        """Set up tests."""
-        yield super(SSOCredentialsTestCase, self).setUp()
-        self.mocker = Mocker()
-        self.root = self.mocker.mock()
-        self.except_to_errdict = self.mocker.replace(
-                                        'ubuntu_sso.main.except_to_errdict')
-        self.creds = SSOCredentials(None)
-        self.creds.root = self.root
-        # start pb
-        self.sso_root = UbuntuSSORoot(None, self.creds, None)
-        self.server_factory = SaveProtocolServerFactory(self.sso_root)
-        # pylint: disable=E1101
-        port = get_sso_pb_port()
-        self.listener = reactor.listenTCP(port, self.server_factory)
-        self.client_factory = PBClientFactory()
-        self.connector = reactor.connectTCP(LOCALHOST, port,
-                                            self.client_factory)
-        self.client = yield self._get_client()
-        # pylint: enable=E1101
-
-    def tearDown(self):
-        """Clean reactor."""
-        if self.server_factory.protocolInstance is not None:
-            self.server_factory.protocolInstance.transport.loseConnection()
-        return defer.gatherResults([self._tearDownServer(),
-                                    self._tearDownClient()])
-
-    def _tearDownServer(self):
-        """Teardown the server."""
-        return defer.maybeDeferred(self.listener.stopListening)
-
-    def _tearDownClient(self):
-        """Tear down the client."""
-        self.connector.disconnect()
-        return defer.succeed(None)
-
-    @defer.inlineCallbacks
-    def _get_client(self):
-        """Get the client."""
-        # request the remote object and create a client
-        root = yield self.client_factory.getRootObject()
-        remote = yield root.callRemote('get_sso_credentials')
-        client = SSOCredentialsClient(remote)
-        yield client.register_to_signals()
-        # set the cb
-        for signal_name in ['on_authorization_denied_cb',
-                            'on_credentials_found_cb',
-                            'on_credentials_error_cb']:
-            setattr(client, signal_name, self.mocker.mock())
-        defer.returnValue(client)
-
-    @defer.inlineCallbacks
-    def test_emit_authorization_denied(self):
-        """Test that the cb is executed."""
-        app_name = 'app'
-
-        self.client.on_authorization_denied_cb(app_name)
-        self.mocker.replay()
-        self.creds.emit_authorization_denied(app_name)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_credentials_found(self):
-        """Test that the cb was executed."""
-        app_name = 'app'
-        credentials = 'cred'
-
-        self.client.on_credentials_found_cb(app_name, credentials)
-        self.mocker.replay()
-        self.creds.emit_credentials_found(app_name, credentials)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_emit_credentials_error(self):
-        """Test that the cb was executed."""
-        app_name = 'app'
-        raised_error = 'error'
-        detail = 'detail'
-
-        self.client.on_credentials_error_cb(app_name, raised_error, detail)
-        self.mocker.replay()
-        self.creds.emit_credentials_error(app_name, raised_error, detail)
-        yield self.client.unregister_to_signals()
-        self.mocker.verify()
-
-    @defer.inlineCallbacks
-    def test_find_credentials_no_kword(self):
-        """Ensure that the root is called."""
-        app_name = 'app'
-        callback = lambda: None
-        errback = lambda: None
-
-        self.root.find_credentials(app_name, MATCH(callable),
-                                   MATCH(callable))
-        self.mocker.replay()
-        yield self.client.find_credentials(app_name, callback, errback)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_find_credentials_(self):
-        """Ensure that the root is called."""
-        app_name = 'app'
-        callback = lambda: None
-        errback = lambda: None
-
-        self.root.find_credentials(app_name, MATCH(callable),
-                                   MATCH(callable))
-        self.mocker.replay()
-        yield self.client.find_credentials(app_name, callback=callback,
-                                      errback=errback)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_login_or_register_to_get_credentials(self):
-        """Ensure that the root is called."""
-        app_name = 'app'
-        terms = 'terms'
-        help_txt = 'help'
-        window_id = 'window_id'
-
-        # pylint: disable=W0212
-        self.root.login_or_register_to_get_credentials(app_name, terms,
-                                    help_txt, window_id,
-                                    self.creds.emit_credentials_found,
-                                    self.creds._process_error,
-                                    self.creds.emit_authorization_denied,
-                                    ui_module='ubuntu_sso.qt.gui')
-        # pylint: enable=W0212
-        self.mocker.replay()
-        yield self.client.login_or_register_to_get_credentials(app_name, terms,
-                                                      help_txt, window_id)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_login_to_get_credentials(self):
-        """Ensure that the root is called."""
-        app_name = 'app'
-        help_txt = 'help'
-        window_id = 'window_id'
-
-        # pylint: disable=W0212
-        self.root.login_to_get_credentials(app_name, help_txt, window_id,
-                                    self.creds.emit_credentials_found,
-                                    self.creds._process_error,
-                                    self.creds.emit_authorization_denied,
-                                    ui_module='ubuntu_sso.qt.gui')
-        # pylint: enable=W0212
-        self.mocker.replay()
-        yield self.client.login_to_get_credentials(app_name, help_txt,
-                                              window_id)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_clear_token_no_kword(self):
-        """Ensure that the root is called."""
-        app_name = 'app'
-        callback = lambda: None
-        errback = lambda: None
-
-        self.root.clear_token(app_name, MATCH(callable), MATCH(callable))
-        self.mocker.replay()
-        yield self.client.clear_token(app_name, callback, errback)
-        yield self.client.unregister_to_signals()
-
-    @defer.inlineCallbacks
-    def test_clear_token(self):
-        """Ensure that the root is called."""
-        app_name = 'app'
-        callback = lambda: None
-        errback = lambda: None
-
-        self.root.clear_token(app_name, MATCH(callable), MATCH(callable))
-        self.mocker.replay()
-        yield self.client.clear_token(app_name, callback=callback,
-                                 errback=errback)
-        yield self.client.unregister_to_signals()
-
-
 class CredentialsManagementTestCase(TestCase):
     """Test the management class."""
 
@@ -741,7 +554,7 @@
         self.creds = CredentialsManagement(None, None)
         self.creds.root = self.root
         # start pb
-        self.sso_root = UbuntuSSORoot(None, None, self.creds)
+        self.sso_root = UbuntuSSORoot(cred_manager=self.creds)
         self.server_factory = SaveProtocolServerFactory(self.sso_root)
         # pylint: disable=E1101
         port = get_sso_pb_port()

=== modified file 'ubuntu_sso/main/windows.py'
--- ubuntu_sso/main/windows.py	2011-09-14 20:59:39 +0000
+++ ubuntu_sso/main/windows.py	2011-09-27 21:50:39 +0000
@@ -17,8 +17,6 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Main implementation on windows."""
 
-import warnings
-
 from functools import wraps
 
 # pylint: disable=F0401
@@ -36,14 +34,11 @@
     Root,
 )
 
-from ubuntu_sso import NO_OP
 from ubuntu_sso.account import Account
-from ubuntu_sso.credentials import ERROR_KEY, ERROR_DETAIL_KEY
 from ubuntu_sso.logger import setup_logging
 from ubuntu_sso.main import (
     CredentialsManagementRoot,
     SSOLoginRoot,
-    SSOCredentialsRoot,
     except_to_errdict,
 )
 from ubuntu_sso.utils.tcpactivation import ActivationConfig, ActivationClient
@@ -334,100 +329,6 @@
                                    self.emit_password_change_error)
 
 
-class SSOCredentials(Referenceable, SignalBroadcaster):
-    """DBus object that gets credentials, and login/registers if needed."""
-
-    __metaclass__ = RemoteMeta
-
-    # calls that will be accessible remotely
-    remote_calls = [
-        'find_credentials',
-        'login_or_register_to_get_credentials',
-        'login_to_get_credentials',
-        'clear_token',
-    ]
-
-    def __init__(self, *args, **kwargs):
-        super(SSOCredentials, self).__init__()
-        self.root = SSOCredentialsRoot()
-
-    def _process_error(self, app_name, error_dict):
-        """Process the 'error_dict' and emit CredentialsError."""
-        msg = error_dict.get(ERROR_KEY, 'No error message given.')
-        detail = error_dict.get(ERROR_DETAIL_KEY, 'No detailed error given.')
-        self.emit_credentials_error(app_name, msg, detail)
-
-    def emit_authorization_denied(self, app_name):
-        """Signal thrown when the user denies the authorization."""
-        logger.info('SSOCredentials: emitting AuthorizationDenied with '
-                    'app_name "%s"', app_name)
-        self.emit_signal('on_authorization_denied', app_name)
-
-    def emit_credentials_found(self, app_name, credentials):
-        """Signal thrown when the credentials are found."""
-        logger.info('SSOCredentials: emitting CredentialsFound with '
-                    'app_name "%s"', app_name)
-        self.emit_signal('on_credentials_found', app_name, credentials)
-
-    def emit_credentials_error(self, app_name, error_message, detailed_error):
-        """Signal thrown when there is a problem finding the credentials."""
-        logger.error('SSOCredentials: emitting CredentialsError with app_name '
-                     '"%s" and error_message %r', app_name, error_message)
-        self.emit_signal('on_credentials_error', app_name, error_message,
-                         detailed_error)
-
-    def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Get the credentials from the keyring or {} if not there."""
-        self.root.find_credentials(app_name, remote_handler(callback),
-                                   remote_handler(errback))
-
-    def login_or_register_to_get_credentials(self, app_name,
-                                             terms_and_conditions_url,
-                                             help_text, window_id,
-                                             ui_module='ubuntu_sso.qt.gui'):
-        """Get credentials if found else prompt GUI to login or register.
-
-        'app_name' will be displayed in the GUI.
-        'terms_and_conditions_url' will be the URL pointing to T&C.
-        'help_text' is an explanatory text for the end-users, will be shown
-         below the headers.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        self.root.login_or_register_to_get_credentials(app_name,
-                                                terms_and_conditions_url,
-                                                help_text, window_id,
-                                                self.emit_credentials_found,
-                                                self._process_error,
-                                                self.emit_authorization_denied,
-                                                ui_module=ui_module)
-
-    def login_to_get_credentials(self, app_name, help_text, window_id):
-        """Get credentials if found else prompt GUI just to login
-
-        'app_name' will be displayed in the GUI.
-        'help_text' is an explanatory text for the end-users, will be shown
-         before the login fields.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-        self.root.login_to_get_credentials(app_name, help_text, window_id,
-                                           self.emit_credentials_found,
-                                           self._process_error,
-                                           self.emit_authorization_denied,
-                                           ui_module='ubuntu_sso.qt.gui')
-
-    def clear_token(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Clear the token for an application from the keyring.
-
-        'app_name' is the name of the application.
-        """
-        self.root.clear_token(app_name, remote_handler(callback),
-                              remote_handler(errback))
-
-
 class CredentialsManagement(Referenceable, SignalBroadcaster):
     """Object that manages credentials.
 
@@ -595,24 +496,19 @@
     # calls that will be accessible remotely
     remote_calls = [
         'get_sso_login',
-        'get_sso_credentials',
-        'get_cred_manager']
+        'get_cred_manager',
+    ]
 
-    def __init__(self, sso_login, sso_credentials, cred_manager):
+    def __init__(self, sso_login=None, cred_manager=None):
         """Create a new instance that will expose the objects."""
         super(UbuntuSSORoot, self).__init__()
         self._sso_login = sso_login
-        self._sso_credentials = sso_credentials
         self._cred_manager = cred_manager
 
     def get_sso_login(self):
         """Return the sso_login."""
         return self._sso_login
 
-    def get_sso_credentials(self):
-        """Return the sso credentials."""
-        return self._sso_credentials
-
     def get_cred_manager(self):
         """Return the credentials manager."""
         return self._cred_manager
@@ -807,80 +703,6 @@
         """Call the matching method in the processor."""
 
 
-class SSOCredentialsClient(RemoteClient, Referenceable):
-    """Deprecated client for the remote SSOCredentials object.
-
-    This class is deprecated!
-    """
-
-    __metaclass__ = RemoteMeta
-
-    # calls that will be accessible remotely
-    remote_calls = [
-        'on_authorization_denied',
-        'on_credentials_found',
-        'on_credentials_error',
-    ]
-
-    def __init__(self, remote_login):
-        """Create a client for the cred API."""
-        warnings.warn("SSOCredentialsClient is deprecated.",
-            DeprecationWarning)
-        super(SSOCredentialsClient, self).__init__(remote_login)
-
-    @signal
-    def on_authorization_denied(self, app_name):
-        """Signal thrown when the user denies the authorization."""
-
-    @signal
-    def on_credentials_found(self, app_name, credentials):
-        """Signal thrown when the credentials are found."""
-
-    @signal
-    def on_credentials_error(self, app_name, error_message, detailed_error):
-        """Signal thrown when there is a problem finding the credentials."""
-
-    @callbacks(callbacks_names=[('callback', 2), ('errback', 3)])
-    @remote
-    def find_credentials(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Get the credentials from the keyring or {} if not there."""
-
-    @remote
-    def login_or_register_to_get_credentials(self, app_name,
-                                             terms_and_conditions_url,
-                                             help_text, window_id):
-        """Get credentials if found else prompt GUI to login or register.
-
-        'app_name' will be displayed in the GUI.
-        'terms_and_conditions_url' will be the URL pointing to T&C.
-        'help_text' is an explanatory text for the end-users, will be shown
-         below the headers.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-
-    @remote
-    def login_to_get_credentials(self, app_name, help_text, window_id):
-        """Get credentials if found else prompt GUI just to login
-
-        'app_name' will be displayed in the GUI.
-        'help_text' is an explanatory text for the end-users, will be shown
-         before the login fields.
-        'window_id' is the id of the window which will be set as a parent of
-         the GUI. If 0, no parent will be set.
-
-        """
-
-    @callbacks(callbacks_names=[('callback', 2), ('errback', 3)])
-    @remote
-    def clear_token(self, app_name, callback=NO_OP, errback=NO_OP):
-        """Clear the token for an application from the keyring.
-
-        'app_name' is the name of the application.
-        """
-
-
 class CredentialsManagementClient(RemoteClient, Referenceable):
     """Client that can perform calls to the remote CredManagement object."""
 

=== modified file 'ubuntu_sso/qt/controllers.py'
--- ubuntu_sso/qt/controllers.py	2011-09-21 21:41:04 +0000
+++ ubuntu_sso/qt/controllers.py	2011-09-27 21:50:39 +0000
@@ -77,9 +77,6 @@
 logger = setup_logging('ubuntu_sso.controllers')
 FAKE_URL = '<a href="http://one.ubuntu.com">%s</a>'
 
-# pylint: disable=W0511
-# disabled warnings about TODO comments
-
 
 # Based on the gtk implementation
 def _build_general_error_message(errordict):
@@ -916,7 +913,6 @@
         logger.debug('UbuntuSSOWizardController.on_registration_success')
         result = yield self.registration_success_callback(unicode(app_name),
                                                           unicode(email))
-        # TODO: what to do?
         logger.debug('Result from callback is %s', result)
         if result == 0:
             logger.info('Success in calling the given registration_callback')