Merge lp:~nataliabidart/ubuntu-sso-client/restore-register-api into lp:ubuntu-sso-client/stable-1-0

[Natalia Bidart]

- Restoring former API for register_user. Added a new method call register_with_name to ensure no API is broke (LP: #709494).

To properly test please use the SRU instructions in the attached bug report. Thanks!

[Joshua Hoover (joshuahoover)]

Works as expected.

review: Approve (tested)

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'run-tests'
--- run-tests	2010-09-03 19:32:51 +0000
+++ run-tests	2011-03-29 17:46:34 +0000
@@ -16,7 +16,7 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 `which xvfb-run` ./contrib/test "$@"
-pylint contrib ubuntu_sso
+pylint ubuntu_sso
 if [ -x `which pep8` ]; then
     pep8 --repeat bin/ contrib/ ubuntu_sso/
 else
 
=== modified file 'ubuntu_sso/gui.py'
--- ubuntu_sso/gui.py	2011-03-24 13:01:02 +0000
+++ ubuntu_sso/gui.py	2011-03-29 17:46:34 +0000
@@ -808,10 +808,10 @@
         self.user_email = email1
         self.user_password = password1
 
-        logger.info('Calling register_user with email %r, password <hidden>,' \
-                    ' name %r, captcha_id %r and captcha_solution %r.', email1,
-                    name, self._captcha_id, captcha_solution)
-        f = self.backend.register_user
+        logger.info('Calling register_with_name with email %r, password, '
+                    '<hidden> name %r, captcha_id %r and captcha_solution %r.',
+                    email1, name, self._captcha_id, captcha_solution)
+        f = self.backend.register_with_name
         f(self.app_name, email1, password1, name,
           self._captcha_id, captcha_solution,
           reply_handler=NO_OP, error_handler=NO_OP)
 
=== modified file 'ubuntu_sso/main.py'
--- ubuntu_sso/main.py	2011-03-24 13:01:02 +0000
+++ ubuntu_sso/main.py	2011-03-29 17:46:34 +0000
@@ -171,19 +171,19 @@
 
         return captcha['captcha_id']
 
-    def register_user(self, email, password, displayname,
+    def register_with_name(self, email, password, displayname,
                       captcha_id, captcha_solution):
         """Register a new user with 'email' and 'password'."""
-        logger.debug('register_user: email: %r password: <hidden>, '
+        logger.debug('register_with_name: email: %r password: <hidden>, '
                      'displayname: %r, captcha_id: %r, captcha_solution: %r',
                      email, displayname, captcha_id, captcha_solution)
         sso_service = self.sso_service_class(None, self.service_url)
         if not self._valid_email(email):
-            logger.error('register_user: InvalidEmailError for email: %r',
+            logger.error('register_with_name: InvalidEmailError for email: %r',
                          email)
             raise InvalidEmailError()
         if not self._valid_password(password):
-            logger.error('register_user: InvalidPasswordError')
+            logger.error('register_with_name: InvalidPasswordError')
             raise InvalidPasswordError()
 
         result = sso_service.registrations.register(
@@ -191,7 +191,7 @@
                     displayname=displayname,
                     captcha_id=captcha_id,
                     captcha_solution=captcha_solution)
-        logger.info('register_user: email: %r result: %r', email, result)
+        logger.info('register_with_name: email: %r result: %r', email, result)
 
         if result['status'] == 'error':
             errorsdict = self._format_webservice_errors(result['errors'])
@@ -201,6 +201,17 @@
         else:
             return email
 
+    def register_user(self, email, password,
+                      captcha_id, captcha_solution):
+        """Register a new user with 'email' and 'password'."""
+        logger.debug('register_user: email: %r password: <hidden>, '
+                     'captcha_id: %r, captcha_solution: %r',
+                     email, captcha_id, captcha_solution)
+        res = self.register_with_name(email, password, displayname='',
+                                      captcha_id=captcha_id,
+                                      captcha_solution=captcha_solution)
+        return res
+
     def login(self, email, password, token_name):
         """Login a user with 'email' and 'password'."""
         logger.debug('login: email: %r password: <hidden>, token_name: %r',
@@ -380,13 +391,24 @@
                      'app_name "%s" and error %r', app_name, error)
 
     @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
+                         in_signature='sssss')
+    def register_user(self, app_name, email, password,
+                      captcha_id, captcha_solution):
+        """Call the matching method in the processor."""
+        def f():
+            """Inner function that will be run in a thread."""
+            return self.processor.register_user(email, password,
+                                                captcha_id, captcha_solution)
+        blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
+
+    @dbus.service.method(dbus_interface=DBUS_IFACE_USER_NAME,
                          in_signature='ssssss')
-    def register_user(self, app_name, email, password, name,
-                      captcha_id, captcha_solution):
+    def register_with_name(self, app_name, email, password, name,
+                           captcha_id, captcha_solution):
         """Call the matching method in the processor."""
         def f():
             """Inner function that will be run in a thread."""
-            return self.processor.register_user(email, password, name,
+            return self.processor.register_with_name(email, password, name,
                                                 captcha_id, captcha_solution)
         blocking(f, app_name, self.UserRegistered, self.UserRegistrationError)
 
 
=== modified file 'ubuntu_sso/tests/test_gui.py'
--- ubuntu_sso/tests/test_gui.py	2011-03-24 13:01:02 +0000
+++ ubuntu_sso/tests/test_gui.py	2011-03-29 17:46:34 +0000
@@ -63,7 +63,7 @@
         self._args = args
         self._kwargs = kwargs
         self._called = {}
-        for i in ('generate_captcha', 'login', 'register_user',
+        for i in ('generate_captcha', 'login', 'register_with_name',
                   'validate_email', 'request_password_reset_token',
                   'set_new_password'):
             setattr(self, i, self._record_call(i))
@@ -674,8 +674,8 @@
         """Clicking 'join_ok_button' sends info to backend using 'register'."""
         self.click_join_with_valid_data()
 
-        # assert register_user was called
-        expected = 'register_user'
+        # assert register_with_name was called
+        expected = 'register_with_name'
         self.assertIn(expected, self.ui.backend._called)
         self.assertEqual(self.ui.backend._called[expected],
                          ((APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
@@ -1161,7 +1161,7 @@
 
         self.assert_correct_entry_warning(self.ui.name_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_empty_email(self):
         """A warning message is shown if emails are empty."""
@@ -1174,7 +1174,7 @@
                                           self.ui.FIELD_REQUIRED)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_email_mismatch(self):
         """A warning message is shown if emails doesn't match."""
@@ -1187,7 +1187,7 @@
                                           self.ui.EMAIL_MISMATCH)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.EMAIL_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_invalid_email(self):
         """A warning message is shown if email is invalid."""
@@ -1200,7 +1200,7 @@
                                           self.ui.EMAIL_INVALID)
         self.assert_correct_entry_warning(self.ui.email2_entry,
                                           self.ui.EMAIL_INVALID)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_password_help_is_always_shown(self):
         """Password help text is correctly displayed."""
@@ -1208,7 +1208,7 @@
                         'password help text is visible.')
         self.assertEqual(self.ui.password_help_label.get_text(),
                          self.ui.PASSWORD_HELP)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_password_mismatch(self):
         """A warning message is shown if password doesn't match."""
@@ -1221,7 +1221,7 @@
                                           self.ui.PASSWORD_MISMATCH)
         self.assert_correct_entry_warning(self.ui.password2_entry,
                                           self.ui.PASSWORD_MISMATCH)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_password_too_weak(self):
         """A warning message is shown if password is too weak."""
@@ -1236,7 +1236,7 @@
                                               self.ui.PASSWORD_TOO_WEAK)
             self.assert_correct_entry_warning(self.ui.password2_entry,
                                               self.ui.PASSWORD_TOO_WEAK)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_tc_not_accepted(self):
         """A warning message is shown if TC are not accepted."""
@@ -1247,7 +1247,7 @@
 
         self.assert_correct_label_warning(self.ui.tc_warning_label,
                                           self.ui.TC_NOT_ACCEPTED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_warning_is_shown_if_not_captcha_solution(self):
         """A warning message is shown if TC are not accepted."""
@@ -1258,7 +1258,7 @@
 
         self.assert_correct_entry_warning(self.ui.captcha_solution_entry,
                                           self.ui.FIELD_REQUIRED)
-        self.assertNotIn('register_user', self.ui.backend._called)
+        self.assertNotIn('register_with_name', self.ui.backend._called)
 
     def test_no_warning_messages_if_valid_data(self):
         """No warning messages are shown if the data is valid."""
 
=== modified file 'ubuntu_sso/tests/test_main.py'
--- ubuntu_sso/tests/test_main.py	2011-03-24 13:01:02 +0000
+++ ubuntu_sso/tests/test_main.py	2011-03-29 17:46:34 +0000
@@ -200,7 +200,6 @@
         """Init."""
         self.processor = SSOLoginProcessor(sso_service_class=FakedSSOServer)
         self.register_kwargs = dict(email=EMAIL, password=PASSWORD,
-                                    displayname=NAME,
                                     captcha_id=CAPTCHA_ID,
                                     captcha_solution=CAPTCHA_SOLUTION)
         self.login_kwargs = dict(email=EMAIL, password=PASSWORD,
@@ -404,6 +403,16 @@
         self.assertIn('Received invalid reply: %s' % STATUS_UNKNOWN, exc)
 
 
+class SSORegistrationWithNameTestCase(SSOLoginProcessorTestCase):
+    """Test suite for the SSO login processor for register_with_name."""
+
+    def setUp(self):
+        """Init."""
+        super(SSORegistrationWithNameTestCase, self).setUp()
+        self.register_kwargs['displayname'] = NAME
+        self.processor.register_user = self.processor.register_with_name
+
+
 class BlockingSampleException(Exception):
     """The exception that will be thrown by the fake blocking."""
 
@@ -515,7 +524,7 @@
         """Test that the register_user method works ok."""
         d = Deferred()
         expected_result = "expected result"
-        self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
+        self.create_mock_processor().register_user(EMAIL, PASSWORD,
             CAPTCHA_ID, CAPTCHA_SOLUTION)
         self.mocker.result(expected_result)
         self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
@@ -531,7 +540,7 @@
                           sso_login_processor_class=self.mockprocessorclass)
         self.patch(client, "UserRegistered", verify)
         self.patch(client, "UserRegistrationError", d.errback)
-        client.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+        client.register_user(APP_NAME, EMAIL, PASSWORD, CAPTCHA_ID,
                              CAPTCHA_SOLUTION)
         return d
 
@@ -539,23 +548,71 @@
         """Test that the register_user method fails as expected."""
         d = Deferred()
         expected_result = "expected result"
-        self.create_mock_processor().register_user(EMAIL, PASSWORD, NAME,
-            CAPTCHA_ID, CAPTCHA_SOLUTION)
-        self.mocker.result(expected_result)
-        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
-        self.mocker.replay()
-
-        def verify(app_name, errdict):
-            """The actual test."""
-            self.assertEqual(errdict["errtype"], "BlockingSampleException")
-            self.assertEqual(app_name, APP_NAME)
-            d.callback("Ok")
-
-        client = SSOLogin(self.mockbusname,
-                          sso_login_processor_class=self.mockprocessorclass)
-        self.patch(client, "UserRegistered", d.errback)
-        self.patch(client, "UserRegistrationError", verify)
-        client.register_user(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+        self.create_mock_processor().register_user(EMAIL, PASSWORD,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", d.errback)
+        self.patch(client, "UserRegistrationError", verify)
+        client.register_user(APP_NAME, EMAIL, PASSWORD, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
+    def test_register_with_name(self):
+        """Test that the register_with_name method works ok."""
+        d = Deferred()
+        expected_result = "expected result"
+        self.create_mock_processor().register_with_name(EMAIL, PASSWORD, NAME,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_ok_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, result):
+            """The actual test."""
+            self.assertEqual(result, expected_result)
+            self.assertEqual(app_name, APP_NAME)
+            d.callback(result)
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", verify)
+        self.patch(client, "UserRegistrationError", d.errback)
+        client.register_with_name(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
+                             CAPTCHA_SOLUTION)
+        return d
+
+    def test_register_with_name_error(self):
+        """Test that the register_with_name method fails as expected."""
+        d = Deferred()
+        expected_result = "expected result"
+        self.create_mock_processor().register_with_name(EMAIL, PASSWORD, NAME,
+            CAPTCHA_ID, CAPTCHA_SOLUTION)
+        self.mocker.result(expected_result)
+        self.patch(ubuntu_sso.main, "blocking", self.fake_err_blocking)
+        self.mocker.replay()
+
+        def verify(app_name, errdict):
+            """The actual test."""
+            self.assertEqual(errdict["errtype"], "BlockingSampleException")
+            self.assertEqual(app_name, APP_NAME)
+            d.callback("Ok")
+
+        client = SSOLogin(self.mockbusname,
+                          sso_login_processor_class=self.mockprocessorclass)
+        self.patch(client, "UserRegistered", d.errback)
+        self.patch(client, "UserRegistrationError", verify)
+        client.register_with_name(APP_NAME, EMAIL, PASSWORD, NAME, CAPTCHA_ID,
                              CAPTCHA_SOLUTION)
         return d