Merge lp:~canonical-platform-qa/uoa-integration-tests/python-testability into lp:uoa-integration-tests

[Leo Arias]

=== added directory 'python'
=== added directory 'python/uoa_integration_tests'
=== added file 'python/uoa_integration_tests/__init__.py'
=== added file 'python/uoa_integration_tests/evernote.py'
--- python/uoa_integration_tests/evernote.py	1970-01-01 00:00:00 +0000
+++ python/uoa_integration_tests/evernote.py	2014-11-14 14:59:44 +0000
@@ -0,0 +1,41 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Copyright (C) 2014 Canonical Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+
+from uoa_integration_tests import onlineaccounts
+
+
+logger = logging.getLogger(__name__)
+
+
+class EvernoteOnlineAccounts():
+
+    @classmethod
+    def add_evernote_sandbox_account_with_oauth_token(
+            cls, user_name, password, oauth_token):
+        """Add an Evernote Sandbox account .
+
+        :param user_name: The user name of the account.
+        :param password: The password of the account.
+        :param oauth_token: The oauth token of the account.
+
+        """
+        accounts_manager = onlineaccounts.AccountsManager()
+        provider_id = 'com.ubuntu.reminders_evernote-account-plugin-sandbox'
+        service_id = 'com.ubuntu.reminders_reminders-sandbox'
+        return accounts_manager.add_account_with_oauth_token(
+            provider_id, service_id, user_name, password, oauth_token)
 
=== added file 'python/uoa_integration_tests/onlineaccounts.py'
--- python/uoa_integration_tests/onlineaccounts.py	1970-01-01 00:00:00 +0000
+++ python/uoa_integration_tests/onlineaccounts.py	2014-11-14 14:59:44 +0000
@@ -0,0 +1,233 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Copyright (C) 2014 Canonical Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+import time
+import threading
+
+from gi.repository import Accounts, GLib, Signon
+
+
+logger = logging.getLogger(__name__)
+
+
+class CredentialsException(Exception):
+
+    """Exception for credentials problems."""
+
+
+class AccountsManager(object):
+
+    """Manager for online accounts."""
+
+    def __init__(self):
+        self._manager = Accounts.Manager.new()
+
+    def _start_main_loop(self):
+        self.error = None
+        self._main_loop = GLib.MainLoop()
+        self._main_loop_thread = threading.Thread(
+            target=self._main_loop.run)
+        self._main_loop_thread.start()
+
+    def _join_main_loop(self):
+        self._main_loop_thread.join()
+        if self.error is not None:
+            raise CredentialsException(self.error)
+
+    def add_account_with_oauth_token(
+            self, provider_id, service_id, user_name, password, oauth_token):
+        """Add an account with an oauth token.
+
+        :param provider_id: The identifier of the account provider.
+        :param servide_id: The identifier of the service that will use the
+            account.
+        :param user_name: The user name of the account.
+        :param password: The password of the account.
+        :param oauth_token: The oauth token of the account.
+
+        """
+        logger.info('Add an account for provider {} and service {}.'.format(
+            provider_id, service_id))
+        logger.info('user name: {}, password: {}, oauth_token: {}.'.format(
+            user_name, password, oauth_token))
+        self._start_main_loop()
+
+        account = self._create_account(provider_id)
+        logger.debug('account %s' % account.get_settings_dict())
+
+        if not account.get_settings_dict():
+            self._delete_account_on_error(account)
+            self._quit_main_loop_on_error('account is blank', 'add account')
+
+        info = self._get_identity_info(user_name, password)
+
+        identity = Signon.Identity.new()
+        identity.store_credentials_with_info(
+            info, self._set_credentials_id_to_account,
+            {'account': account, 'oauth_token': oauth_token})
+        logger.debug('identity %s' % identity.list_properties())
+
+        logger.debug('Joining loop')
+
+        self._join_main_loop()
+
+        # XXX Sometimes, the account fails to be enabled. This sleep seems to
+        # fix it but we haven't yet found the reason. --elopio - 2014-06-25
+        time.sleep(10)
+        self._enable_service(account, service_id)
+
+        logger.info('Created the account with id: {}.'.format(account.id))
+        self._log_accounts_info()
+        return account
+
+    def _create_account(self, provider_id):
+        logger.debug('Creating the Evernote account.')
+        account = self._manager.create_account(provider_id)
+        account.set_enabled(True)
+        account.store(self._on_account_created, None)
+        return account
+
+    def _on_account_created(self, account, error, _):
+        if error:
+            self._quit_main_loop_on_error(error, 'storing account')
+
+    def _delete_account_on_error(self, account):
+        # attempt to clean up after ourselves, since normal
+        # addCleanups will not run in this case
+        try:
+            logger.debug('Cleaning up account %s' % account.id)
+            account.delete()
+            account.store(self._on_account_deleted, None)
+        except:
+            logger.warn('Failed to cleanup account')
+
+    def _quit_main_loop_on_error(self, error, step):
+        logger.error('Error {}.'.format(step))
+        self.error = error
+        self._main_loop.quit()
+        raise CredentialsException(error)
+
+    def _get_identity_info(self, user_name, password):
+        info = Signon.IdentityInfo.new()
+        info.set_username(user_name)
+        info.set_caption(user_name)
+        info.set_secret(password, True)
+        return info
+
+    def _set_credentials_id_to_account(
+            self, identity, id_, error, account_dict):
+        if error:
+            self._quit_main_loop_on_error(
+                error, 'storing credentials with info')
+
+        logger.debug('Setting credentials to account.')
+        account = account_dict.get('account')
+        oauth_token = account_dict.get('oauth_token')
+        account.set_variant('CredentialsId', GLib.Variant('u', id_))
+        account.store(self._process_session, oauth_token)
+        logger.debug('Account stored')
+
+    def _process_session(self, account, error, oauth_token):
+        if error:
+            self._quit_main_loop_on_error(
+                error, 'setting credentials id to account')
+
+        logger.debug('Processing session.')
+        account_service = Accounts.AccountService.new(account, None)
+        logger.debug('account_service %s' % account_service.list_properties())
+        auth_data = account_service.get_auth_data()
+        logger.debug('auth_data %s' % auth_data.get_parameters())
+        identity = auth_data.get_credentials_id()
+        method = auth_data.get_method()
+        if method is None:
+            self._delete_account_on_error(account)
+            self._quit_main_loop_on_error('Method is none',
+                                          'processing auth data')
+        mechanism = auth_data.get_mechanism()
+        session_data = auth_data.get_parameters()
+        session_data['ProvidedTokens'] = GLib.Variant('a{sv}', {
+            'TokenSecret': GLib.Variant('s', 'dummy'),
+            'AccessToken': GLib.Variant('s', oauth_token),
+        })
+        logger.debug('session_data %s' % session_data)
+        logger.debug('Authenticating session %s, %s' % (identity, method))
+        session = Signon.AuthSession.new(identity, method)
+        logger.debug('Send session %s' % session)
+        session.process(
+            session_data, mechanism, self._on_login_processed, None)
+        logger.debug('Session processed')
+
+    def _on_login_processed(self, session, reply, error, userdata):
+        if error:
+            self._quit_main_loop_on_error(error, 'processing session')
+
+        else:
+            self._main_loop.quit()
+
+    def _enable_service(self, account, service_id):
+        logger.debug('Enabling evernote service.')
+        service = self._manager.get_service(service_id)
+        account.select_service(service)
+        account.set_enabled(True)
+        account.store(self._on_service_enabled, None)
+
+    def _on_service_enabled(self, account, error, _):
+        if error:
+            self._quit_main_loop_on_error(error, 'enabling service')
+
+    def _log_accounts_info(self):
+        account_ids = self._manager.list()
+        logger.debug('Existing accounts: {}.'.format(account_ids))
+        for id_ in account_ids:
+            account = self._manager.get_account(id_)
+            self._log_account_info(account)
+
+    def _log_account_info(self, account):
+        logger.debug('Account info:')
+        logger.debug('id: {}'.format(account.id))
+        logger.debug('provider: {}'.format(account.get_provider_name()))
+        logger.debug('enabled: {}'.format(account.get_enabled()))
+        logger.debug('Account services:')
+        for service in account.list_services():
+            logger.debug('name: {}'.format(service.get_name()))
+            account_service = Accounts.AccountService.new(account, service)
+            logger.debug('enabled: {}'.format(account_service.get_enabled()))
+
+    def get_accounts_list(self):
+        return self._manager.list()
+
+    def delete_account(self, account):
+        """Delete an account.
+
+        :param account: The account to delete.
+
+        """
+        logger.info('Deleting the account with id {}.'.format(account.id))
+        self._start_main_loop()
+        # XXX There seems to be a problem when we try to delete the account too
+        # soon after starting the main loop.
+        # Reported as bug http://pad.lv/1363604. --elopio - 2014-09-01
+        time.sleep(10)
+        account.delete()
+        account.store(self._on_account_deleted, None)
+        self._join_main_loop()
+
+    def _on_account_deleted(self, account, error, _):
+        if error:
+            self._quit_main_loop_on_error(error, 'deleting account')
+        else:
+            self._main_loop.quit()
 
=== added directory 'python/uoa_integration_tests/tests'
=== added file 'python/uoa_integration_tests/tests/__init__.py'
=== added file 'python/uoa_integration_tests/tests/test_evernote_online_accounts.py'
--- python/uoa_integration_tests/tests/test_evernote_online_accounts.py	1970-01-01 00:00:00 +0000
+++ python/uoa_integration_tests/tests/test_evernote_online_accounts.py	2014-11-14 14:59:44 +0000
@@ -0,0 +1,72 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Copyright (C) 2014 Canonical Ltd
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import logging
+
+import testtools
+from gi.repository import Accounts
+from testtools.matchers import HasLength
+
+from uoa_integration_tests import onlineaccounts, evernote
+
+
+logger = logging.getLogger(__name__)
+
+
+class EvernoteCredentialsTestCase(testtools.TestCase):
+
+    def setUp(self):
+        super(EvernoteCredentialsTestCase, self).setUp()
+        self.accounts_manager = onlineaccounts.AccountsManager()
+
+    def add_evernote_sandbox_account(self):
+        accounts = evernote.EvernoteOnlineAccounts
+        add_account = accounts.add_evernote_sandbox_account_with_oauth_token
+        account = add_account('dummy', 'dummy', 'dummy')
+        self.addCleanup(self.delete_account, account)
+        return account
+
+    def delete_account(self, account):
+        if account.id in self.account_manager.get_accounts_list():
+            self.accounts_manager.delete_account(account)
+
+    def test_add_evernote_sandbox_account_must_enable_it(self):
+        account = self.add_evernote_sandbox_account()
+
+        self.assertTrue(account.get_enabled())
+
+    def test_add_evernote_sandbox_account_must_set_provider(self):
+        account = self.add_evernote_sandbox_account()
+
+        provider_id = 'com.ubuntu.reminders_evernote-account-plugin-sandbox'
+        self.assertEqual(account.get_provider_name(), provider_id)
+
+    def test_add_evernote_sandbox_account_must_enable_evernote_service(self):
+        account = self.add_evernote_sandbox_account()
+        services = account.list_services()
+
+        self.assertThat(services, HasLength(1))
+        service_id = 'com.ubuntu.reminders_reminders-sandbox'
+        self.assertEqual(services[0].get_name(), service_id)
+        service = Accounts.AccountService.new(account, services[0])
+        self.assertTrue(service.get_enabled())
+
+    def test_delete_evernote_sandbox_account_must_remove_it(self):
+        account = self.add_evernote_sandbox_account()
+        self.assertThat(self.account_manager._manager.list(), HasLength(1))
+
+        self.account_manager.delete_account(account)
+        self.assertThat(self.account_manager._manager.list(), HasLength(0))