Merge lp:~alecu/ubuntu-sso-client/refactor-errdict-tests into lp:ubuntu-sso-client

[Alejandro J. Cura]

Refactor and simplify errdict tests, so they use inlineCallbacks.

Refactor and simplify errdict tests, so they use inlineCallbacks.

[Natalia Bidart (nataliabidart)]

Looks great!

Can you please add yield to the super() calls in each setUp definition? Thanks!

review: Approve

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'ubuntu_sso/main/tests/test_windows.py'
--- ubuntu_sso/main/tests/test_windows.py	2011-08-26 00:03:22 +0000
+++ ubuntu_sso/main/tests/test_windows.py	2011-09-07 18:36:29 +0000
@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
-# Author: Manuel de la Pena <[e-mail]>
+# Authors: Manuel de la Pena <[e-mail]>
+#          Alejandro J. Cura <[e-mail]>
 #
 # Copyright 2011 Canonical Ltd.
 #
@@ -201,9 +202,10 @@
 class SSOLoginTestCase(TestCase):
     """Test the login class."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Setup tests."""
-        super(SSOLoginTestCase, self).setUp()
+        yield super(SSOLoginTestCase, self).setUp()
         self.mocker = Mocker()
         self.root = self.mocker.mock()
         self.except_to_errdict = self.mocker.replace(
@@ -219,6 +221,8 @@
         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):
@@ -262,118 +266,79 @@
             setattr(client, signal_name, self.mocker.mock())
         defer.returnValue(client)
 
+    @defer.inlineCallbacks
     def test_emit_captcha_generated(self):
         """Test that the cb was called."""
         app_name = 'app'
         result = 'result'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_captcha_generated_cb(app_name, result)
-            self.mocker.replay()
-            self.login.emit_captcha_generated(app_name, result)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        self.client.on_captcha_generated_cb(app_name, result)
+        self.mocker.replay()
+        self.login.emit_captcha_generated(app_name, result)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_captcha_generation_error(self):
         """Test that the cb was called."""
         app_name = 'app'
         error_value = 'error'
         raised_error = self.mocker.mock()
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            raised_error.value
-            self.mocker.result(error_value)
-            self.except_to_errdict(error_value)
-            self.mocker.result(error_value)
-            client.on_captcha_generation_error_cb(app_name, error_value)
-            self.mocker.replay()
-            self.login.emit_captcha_generation_error(app_name, raised_error)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        raised_error.value
+        self.mocker.result(error_value)
+        self.except_to_errdict(error_value)
+        self.mocker.result(error_value)
+        self.client.on_captcha_generation_error_cb(app_name, error_value)
+        self.mocker.replay()
+        self.login.emit_captcha_generation_error(app_name, raised_error)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_generate_captcha(self):
         """Test the call from the client."""
         app_name = 'app'
         filename = 'file'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.generate_captcha(app_name, filename,
-                                   self.login.emit_captcha_generated,
-                                   self.login.emit_captcha_generation_error)
-            self.mocker.replay()
-            yield client.generate_captcha(app_name, filename)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        self.root.generate_captcha(app_name, filename,
+                               self.login.emit_captcha_generated,
+                               self.login.emit_captcha_generation_error)
+        self.mocker.replay()
+        yield self.client.generate_captcha(app_name, filename)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_user_registered(self):
         """Test that the cb was called."""
         app_name = 'app'
         result = 'result'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_user_registered_cb(app_name, result)
-            self.mocker.replay()
-            self.login.emit_user_registered(app_name, result)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        self.client.on_user_registered_cb(app_name, result)
+        self.mocker.replay()
+        self.login.emit_user_registered(app_name, result)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_user_registration_error(self):
         """Test that the cb was called."""
         app_name = 'app'
         error_value = 'error'
         raised_error = self.mocker.mock()
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            raised_error.value
-            self.mocker.result(error_value)
-            self.except_to_errdict(error_value)
-            self.mocker.result(error_value)
-            client.on_user_registration_error_cb(app_name, error_value)
-            self.mocker.replay()
-            self.login.emit_user_registration_error(app_name, raised_error)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        raised_error.value
+        self.mocker.result(error_value)
+        self.except_to_errdict(error_value)
+        self.mocker.result(error_value)
+        self.client.on_user_registration_error_cb(app_name, error_value)
+        self.mocker.replay()
+        self.login.emit_user_registration_error(app_name, raised_error)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_register_user(self):
         """Test the call from the client."""
         app_name = 'app'
@@ -383,159 +348,103 @@
         captcha_id = 'captcha_id'
         captcha_solution = 'captcha_solution'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.register_user(app_name, email, password, displayname,
-                                    captcha_id, captcha_solution,
-                                    self.login.emit_user_registered,
-                                    self.login.emit_user_registration_error)
-            self.mocker.replay()
-            yield client.register_user(app_name, email, password, displayname,
-                                       captcha_id, captcha_solution)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        self.root.register_user(app_name, email, password, displayname,
+                                captcha_id, captcha_solution,
+                                self.login.emit_user_registered,
+                                self.login.emit_user_registration_error)
+        self.mocker.replay()
+        yield self.client.register_user(app_name, email, password, displayname,
+                                   captcha_id, captcha_solution)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_logged_in(self):
         """Test that the cb was called."""
         app_name = 'app'
         result = 'result'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_logged_in_cb(app_name, result)
-            self.mocker.replay()
-            self.login.emit_logged_in(app_name, result)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        self.client.on_logged_in_cb(app_name, result)
+        self.mocker.replay()
+        self.login.emit_logged_in(app_name, result)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_login_error(self):
         """Test that the db was called."""
         app_name = 'app'
         error_value = 'error'
         raised_error = self.mocker.mock()
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            raised_error.value
-            self.mocker.result(error_value)
-            self.except_to_errdict(error_value)
-            self.mocker.result(error_value)
-            client.on_login_error_cb(app_name, error_value)
-            self.mocker.replay()
-            self.login.emit_login_error(app_name, raised_error)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        raised_error.value
+        self.mocker.result(error_value)
+        self.except_to_errdict(error_value)
+        self.mocker.result(error_value)
+        self.client.on_login_error_cb(app_name, error_value)
+        self.mocker.replay()
+        self.login.emit_login_error(app_name, raised_error)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_user_not_validated(self):
         """Test that the cb was called."""
         app_name = 'app'
         result = 'result'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_user_not_validated_cb(app_name, result)
-            self.mocker.replay()
-            self.login.emit_user_not_validated(app_name, result)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        self.client.on_user_not_validated_cb(app_name, result)
+        self.mocker.replay()
+        self.login.emit_user_not_validated(app_name, result)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_login(self):
         """Test the call from the client."""
         app_name = 'app'
         email = 'email'
         password = 'password'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.login(app_name, email, password,
-                            self.login.emit_logged_in,
-                            self.login.emit_login_error,
-                            self.login.emit_user_not_validated)
-            self.mocker.replay()
-            yield client.login(app_name, email, password)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        self.root.login(app_name, email, password,
+                        self.login.emit_logged_in,
+                        self.login.emit_login_error,
+                        self.login.emit_user_not_validated)
+        self.mocker.replay()
+        yield self.client.login(app_name, email, password)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_email_validated(self):
         """Test the cb was called."""
         app_name = 'app'
         result = 'result'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_email_validated_cb(app_name, result)
-            self.mocker.replay()
-            self.login.emit_email_validated(app_name, result)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        self.client.on_email_validated_cb(app_name, result)
+        self.mocker.replay()
+        self.login.emit_email_validated(app_name, result)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_email_validation_error(self):
         """Test the cb was called."""
         app_name = 'app'
         error_value = 'error'
         raised_error = self.mocker.mock()
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            raised_error.value
-            self.mocker.result(error_value)
-            self.except_to_errdict(error_value)
-            self.mocker.result(error_value)
-            client.on_email_validation_error_cb(app_name, error_value)
-            self.mocker.replay()
-            self.login.emit_email_validation_error(app_name, raised_error)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        raised_error.value
+        self.mocker.result(error_value)
+        self.except_to_errdict(error_value)
+        self.mocker.result(error_value)
+        self.client.on_email_validation_error_cb(app_name, error_value)
+        self.mocker.replay()
+        self.login.emit_email_validation_error(app_name, raised_error)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_validate_email(self):
         """Test the client calll."""
         app_name = 'app'
@@ -543,135 +452,88 @@
         password = 'password'
         email_token = 'token'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.validate_email(app_name, email, password, email_token,
+        self.root.validate_email(app_name, email, password, email_token,
                                  self.login.emit_email_validated,
                                  self.login.emit_email_validation_error)
-            self.mocker.replay()
-            yield client.validate_email(app_name, email, password, email_token)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        self.mocker.replay()
+        yield self.client.validate_email(app_name, email, password,
+                                         email_token)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_password_reset_token_sent(self):
         """Test the cb was called."""
         app_name = 'app'
         result = 'result'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_password_reset_token_sent_cb(app_name, result)
-            self.mocker.replay()
-            self.login.emit_password_reset_token_sent(app_name, result)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        self.client.on_password_reset_token_sent_cb(app_name, result)
+        self.mocker.replay()
+        self.login.emit_password_reset_token_sent(app_name, result)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_password_reset_error(self):
         """Test the cb was called."""
         app_name = 'app'
         error_value = 'error'
         raised_error = self.mocker.mock()
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            raised_error.value
-            self.mocker.result(error_value)
-            self.except_to_errdict(error_value)
-            self.mocker.result(error_value)
-            client.on_password_reset_error_cb(app_name, error_value)
-            self.mocker.replay()
-            self.login.emit_password_reset_error(app_name, raised_error)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        raised_error.value
+        self.mocker.result(error_value)
+        self.except_to_errdict(error_value)
+        self.mocker.result(error_value)
+        self.client.on_password_reset_error_cb(app_name, error_value)
+        self.mocker.replay()
+        self.login.emit_password_reset_error(app_name, raised_error)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_request_password_reset_token(self):
         """Test the client call."""
         app_name = 'app'
         email = 'email'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.request_password_reset_token(app_name, email,
-                                self.login.emit_password_reset_token_sent,
-                                self.login.emit_password_reset_error)
-            self.mocker.replay()
-            client.request_password_reset_token(app_name, email)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        self.root.request_password_reset_token(app_name, email,
+                            self.login.emit_password_reset_token_sent,
+                            self.login.emit_password_reset_error)
+        self.mocker.replay()
+        self.client.request_password_reset_token(app_name, email)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_password_changed(self):
         """Test the cb was called."""
         app_name = 'app'
         result = 'result'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_password_changed_cb(app_name, result)
-            self.mocker.replay()
-            self.login.emit_password_changed(app_name, result)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        self.client.on_password_changed_cb(app_name, result)
+        self.mocker.replay()
+        self.login.emit_password_changed(app_name, result)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_password_change_error(self):
         """Test the cb was called."""
         app_name = 'app'
         error_value = 'error'
         raised_error = self.mocker.mock()
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            raised_error.value
-            self.mocker.result(error_value)
-            self.except_to_errdict(error_value)
-            self.mocker.result(error_value)
-            client.on_password_change_error(app_name, error_value)
-            self.mocker.replay()
-            self.login.emit_password_change_error(app_name, raised_error)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        raised_error.value
+        self.mocker.result(error_value)
+        self.except_to_errdict(error_value)
+        self.mocker.result(error_value)
+        self.client.on_password_change_error(app_name, error_value)
+        self.mocker.replay()
+        self.login.emit_password_change_error(app_name, raised_error)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_set_new_password(self):
         """Test the client call."""
         app_name = 'app'
@@ -679,30 +541,23 @@
         token = 'token'
         new_password = 'password'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.set_new_password(app_name, email, token, new_password,
-                                   self.login.emit_password_changed,
-                                   self.login.emit_password_change_error)
-            self.mocker.replay()
-            yield client.set_new_password(app_name, email, token, new_password)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
+        self.root.set_new_password(app_name, email, token, new_password,
+                               self.login.emit_password_changed,
+                               self.login.emit_password_change_error)
+        self.mocker.replay()
+        yield self.client.set_new_password(app_name, email, token,
+                                           new_password)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
 
 
 class SSOCredentialsTestCase(TestCase):
     """Test the credentials class."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(SSOCredentialsTestCase, self).setUp()
+        yield super(SSOCredentialsTestCase, self).setUp()
         self.mocker = Mocker()
         self.root = self.mocker.mock()
         self.except_to_errdict = self.mocker.replace(
@@ -718,6 +573,7 @@
         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):
@@ -751,109 +607,70 @@
             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'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_authorization_denied_cb(app_name)
-            self.mocker.replay()
-            self.creds.emit_authorization_denied(app_name)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        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'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_credentials_found_cb(app_name, credentials)
-            self.mocker.replay()
-            self.creds.emit_credentials_found(app_name, credentials)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        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'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            client.on_credentials_error_cb(app_name, raised_error, detail)
-            self.mocker.replay()
-            self.creds.emit_credentials_error(app_name, raised_error, detail)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        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
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.find_credentials(app_name, MATCH(callable),
-                                       MATCH(callable))
-            self.mocker.replay()
-            yield client.find_credentials(app_name, callback, errback)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        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
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.find_credentials(app_name, MATCH(callable),
-                                       MATCH(callable))
-            self.mocker.replay()
-            yield client.find_credentials(app_name, callback=callback,
-                                          errback=errback)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        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'
@@ -861,103 +678,71 @@
         help_txt = 'help'
         window_id = 'window_id'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            # 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 client.login_or_register_to_get_credentials(app_name, terms,
-                                                          help_txt, window_id)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        # 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'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            # 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 client.login_to_get_credentials(app_name, help_txt,
-                                                  window_id)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        # 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
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.clear_token(app_name, MATCH(callable), MATCH(callable))
-            self.mocker.replay()
-            yield client.clear_token(app_name, callback, errback)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        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
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.clear_token(app_name, MATCH(callable), MATCH(callable))
-            self.mocker.replay()
-            yield client.clear_token(app_name, callback=callback,
-                                     errback=errback)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
+        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."""
 
+    @defer.inlineCallbacks
     def setUp(self):
         """Set up tests."""
-        super(CredentialsManagementTestCase, self).setUp()
+        yield super(CredentialsManagementTestCase, self).setUp()
         self.mocker = Mocker()
         self.root = self.mocker.mock()
         self.except_to_errdict = self.mocker.replace(
@@ -973,6 +758,7 @@
         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):
@@ -1009,295 +795,190 @@
             setattr(client, signal_name, self.mocker.mock())
         defer.returnValue(client)
 
+    @defer.inlineCallbacks
     def test_shutdown(self):
         """Test that root is called."""
-
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            # pylint: disable=W0104
-            self.root.ref_count
-            # pylint: enable=W0104
-            self.mocker.result(1)
-            self.root.shutdown()
-            self.mocker.replay()
-            yield client.shutdown()
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0104
+        self.root.ref_count
+        # pylint: enable=W0104
+        self.mocker.result(1)
+        self.root.shutdown()
+        self.mocker.replay()
+        yield self.client.shutdown()
+        yield self.client.unregister_to_signals()
+
+    @defer.inlineCallbacks
     def test_emit_authorization_denied(self):
         """Test the callback is called."""
         app_name = 'app'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            # pylint: disable=W0104
-            self.root.ref_count
-            # pylint: enable=W0104
-            self.mocker.result(1)
-            self.root.ref_count = 0
-            client.on_authorization_denied_cb(app_name)
-            self.mocker.replay()
-            self.creds.emit_authorization_denied(app_name)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0104
+        self.root.ref_count
+        # pylint: enable=W0104
+        self.mocker.result(1)
+        self.root.ref_count = 0
+        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 the callback is called."""
         app_name = 'app'
         creds = 'creds'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            # pylint: disable=W0104
-            self.root.ref_count
-            # pylint: enable=W0104
-            self.mocker.result(1)
-            self.root.ref_count = 0
-            client.on_credentials_found_cb(app_name, creds)
-            self.mocker.replay()
-            self.creds.emit_credentials_found(app_name, creds)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0104
+        self.root.ref_count
+        # pylint: enable=W0104
+        self.mocker.result(1)
+        self.root.ref_count = 0
+        self.client.on_credentials_found_cb(app_name, creds)
+        self.mocker.replay()
+        self.creds.emit_credentials_found(app_name, creds)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_credentials_not_found(self):
         """Test the callback is called."""
         app_name = 'app'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            # pylint: disable=W0104
-            self.root.ref_count
-            # pylint: enable=W0104
-            self.mocker.result(1)
-            self.root.ref_count = 0
-            client.on_credentials_not_found_cb(app_name)
-            self.mocker.replay()
-            self.creds.emit_credentials_not_found(app_name)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0104
+        self.root.ref_count
+        # pylint: enable=W0104
+        self.mocker.result(1)
+        self.root.ref_count = 0
+        self.client.on_credentials_not_found_cb(app_name)
+        self.mocker.replay()
+        self.creds.emit_credentials_not_found(app_name)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_credentials_cleared(self):
         """Test the callback is called."""
         app_name = 'app'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            # pylint: disable=W0104
-            self.root.ref_count
-            # pylint: enable=W0104
-            self.mocker.result(1)
-            self.root.ref_count = 0
-            client.on_credentials_cleared_cb(app_name)
-            self.mocker.replay()
-            self.creds.emit_credentials_cleared(app_name)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0104
+        self.root.ref_count
+        # pylint: enable=W0104
+        self.mocker.result(1)
+        self.root.ref_count = 0
+        self.client.on_credentials_cleared_cb(app_name)
+        self.mocker.replay()
+        self.creds.emit_credentials_cleared(app_name)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_credentials_stored(self):
         """Test the callback is called."""
         app_name = 'app'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            # pylint: disable=W0104
-            self.root.ref_count
-            # pylint: enable=W0104
-            self.mocker.result(1)
-            self.root.ref_count = 0
-            client.on_credentials_stored_cb(app_name)
-            self.mocker.replay()
-            self.creds.emit_credentials_stored(app_name)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0104
+        self.root.ref_count
+        # pylint: enable=W0104
+        self.mocker.result(1)
+        self.root.ref_count = 0
+        self.client.on_credentials_stored_cb(app_name)
+        self.mocker.replay()
+        self.creds.emit_credentials_stored(app_name)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_emit_credentials_error(self):
         """Test the callback is called."""
         app_name = 'app'
         raised_error = 'error'
 
-        @defer.inlineCallbacks
-        def test_emit(client):
-            """Actual test."""
-            # pylint: disable=W0104
-            self.root.ref_count
-            # pylint: enable=W0104
-            self.mocker.result(1)
-            self.root.ref_count = 0
-            client.on_credentials_error_cb(app_name, raised_error)
-            self.mocker.replay()
-            self.creds.emit_credentials_error(app_name, raised_error)
-            yield client.unregister_to_signals()
-            self.mocker.verify()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_emit)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0104
+        self.root.ref_count
+        # pylint: enable=W0104
+        self.mocker.result(1)
+        self.root.ref_count = 0
+        self.client.on_credentials_error_cb(app_name, raised_error)
+        self.mocker.replay()
+        self.creds.emit_credentials_error(app_name, raised_error)
+        yield self.client.unregister_to_signals()
+        self.mocker.verify()
+
+    @defer.inlineCallbacks
     def test_find_credentials(self):
         """Test that root is called."""
         app_name = 'app'
         args = 'args'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            # pylint: disable=W0212
-            self.root.find_credentials(app_name, args, MATCH(callable),
-                                       self.creds._process_failure)
-            # pylint: enable=W0212
-            self.root.shutdown()
-            yield client.find_credentials(app_name, args)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0212
+        self.root.find_credentials(app_name, args, MATCH(callable),
+                                   self.creds._process_failure)
+        # pylint: enable=W0212
+        self.root.shutdown()
+        yield self.client.find_credentials(app_name, args)
+        yield self.client.unregister_to_signals()
+
+    @defer.inlineCallbacks
     def test_clear_credentials(self):
         """Test that root is called."""
         app_name = 'app'
         args = 'args'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            # pylint: disable=W0212
-            self.root.clear_credentials(app_name, args, MATCH(callable),
-                                        self.creds._process_failure)
-            # pylint: enable=W0212
-            self.mocker.replay()
-            yield client.clear_credentials(app_name, args)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0212
+        self.root.clear_credentials(app_name, args, MATCH(callable),
+                                    self.creds._process_failure)
+        # pylint: enable=W0212
+        self.mocker.replay()
+        yield self.client.clear_credentials(app_name, args)
+        yield self.client.unregister_to_signals()
+
+    @defer.inlineCallbacks
     def test_store_credentials(self):
         """Test that root is called."""
         app_name = 'app'
         args = 'args'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            # pylint: disable=W0212
-            self.root.store_credentials(app_name, args, MATCH(callable),
-                               self.creds._process_failure)
-            # pylint: enable=W0212
-            self.mocker.replay()
-            yield client.store_credentials(app_name, args)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        # pylint: disable=W0212
+        self.root.store_credentials(app_name, args, MATCH(callable),
+                           self.creds._process_failure)
+        # pylint: enable=W0212
+        self.mocker.replay()
+        yield self.client.store_credentials(app_name, args)
+        yield self.client.unregister_to_signals()
+
+    @defer.inlineCallbacks
     def test_register(self):
         """Test that root is called."""
         app_name = 'app'
         args = 'args'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.register(app_name, args)
-            self.mocker.replay()
-            yield client.register(app_name, args)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        self.root.register(app_name, args)
+        self.mocker.replay()
+        yield self.client.register(app_name, args)
+        yield self.client.unregister_to_signals()
+
+    @defer.inlineCallbacks
     def test_login(self):
         """Test that root is called."""
         app_name = 'app'
         args = 'args'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.login(app_name, args)
-            self.mocker.replay()
-            yield client.login(app_name, args)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
-
+        self.root.login(app_name, args)
+        self.mocker.replay()
+        yield self.client.login(app_name, args)
+        yield self.client.unregister_to_signals()
+
+    @defer.inlineCallbacks
     def test_login_email_password(self):
         """Test that root is called."""
         app_name = 'app'
         args = 'args'
 
-        @defer.inlineCallbacks
-        def test_execution(client):
-            """Actual test."""
-            self.root.login_email_password(app_name, args)
-            self.mocker.replay()
-            yield client.login_email_password(app_name, args)
-            yield client.unregister_to_signals()
-
-        d = self._get_client()
-        # pylint: disable=E1101
-        d.addCallback(test_execution)
-        # pylint: enable=E1101
-        return d
+        self.root.login_email_password(app_name, args)
+        self.mocker.replay()
+        yield self.client.login_email_password(app_name, args)
+        yield self.client.unregister_to_signals()
 
 
 class MockRemoteObject(object):