Merge lp:~elopio/u1-test-utils/in-dash-sso into lp:u1-test-utils

[Leo Arias]

Added the code to create a user and log in to Ubuntu SSO.

[Leo Arias (elopio)]

This branch needs:
https://code.launchpad.net/~elopio/u1-test-utils/in-dash-prerequisites
https://code.launchpad.net/~elopio/u1-test-utils/configglue

[lp:~elopio/u1-test-utils/in-dash-sso]

32. By Leo Arias on 2013-05-06

Implemented the log out with a call to the sso dbus.

33. By Leo Arias on 2013-05-06

Implemented the is_log_in with the sso dbus.

34. By Leo Arias on 2013-05-06

Moved the sso helpers to the sso module.

35. By Leo Arias on 2013-05-08

Use the django config.

36. By Leo Arias on 2013-05-08

Added the missing settings and schema.

37. By Leo Arias on 2013-05-10

Cleanup.

38. By Leo Arias on 2013-05-10

Clean up after login, keep the system clean.

39. By Leo Arias on 2013-05-10

Cleaned the log in and log out test.

40. By Leo Arias on 2013-05-10

Some remainders of the failed config version.

41. By Leo Arias on 2013-05-10

Updated to the latests u1testutils version.

42. By Leo Arias on 2013-05-13

Use the async find credentials.

43. By Leo Arias on 2013-05-15

Import os instead of os.path.

44. By Leo Arias on 2013-05-15

Moved the mainloop call to the methods that use it.

45. By Leo Arias on 2013-05-15

Added a sso server parameter to create account.

46. By Leo Arias on 2013-05-15

Added an assertion that the user is not logged in.

47. By Leo Arias on 2013-05-15

Pass the sso url to the login method, added a FIXME on the django config import.

48. By Leo Arias on 2013-05-15

Comment about the user without payment method.

49. By Leo Arias on 2013-05-15

Pass the test to log in to make sure the user is logged out afterwards.

50. By Leo Arias on 2013-05-15

Added a comment about deleting users.

51. By Leo Arias on 2013-05-15

Added fixme comments to django imports.

52. By Leo Arias on 2013-05-15

Moved the async method to sso, and added to assertion methods to users.

53. By Leo Arias on 2013-05-15

Missing parameter.

54. By Leo Arias on 2013-05-15

Extra parameter.

55. By Leo Arias on 2013-05-15

Wrong assertion.

56. By Leo Arias on 2013-05-15

Also pass the ubuntu server url from the test to the helpers.

57. By Leo Arias on 2013-05-15

Refactored is_logged_in to be synchronous.

58. By Leo Arias on 2013-05-15

Renamed the sso is_loged_in function.

59. By Leo Arias on 2013-05-15

We need to make sure that the SSO service is running.

60. By Leo Arias on 2013-05-15

We need to make sure that the SSO service is running.

61. By Leo Arias on 2013-05-15

We need to make sure that the SSO service is running.

62. By Leo Arias on 2013-05-15

Set the urls as instance attributes.

Unmerged revisions

62. By Leo Arias on 2013-05-15

Set the urls as instance attributes.

61. By Leo Arias on 2013-05-15

We need to make sure that the SSO service is running.

60. By Leo Arias on 2013-05-15

We need to make sure that the SSO service is running.

59. By Leo Arias on 2013-05-15

We need to make sure that the SSO service is running.

58. By Leo Arias on 2013-05-15

Renamed the sso is_loged_in function.

57. By Leo Arias on 2013-05-15

Refactored is_logged_in to be synchronous.

56. By Leo Arias on 2013-05-15

Also pass the ubuntu server url from the test to the helpers.

55. By Leo Arias on 2013-05-15

Wrong assertion.

54. By Leo Arias on 2013-05-15

Extra parameter.

53. By Leo Arias on 2013-05-15

Missing parameter.

=== added directory 'bin'
=== added file 'bin/vm_session_setup.py'
--- bin/vm_session_setup.py	1970-01-01 00:00:00 +0000
+++ bin/vm_session_setup.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+"""
+Setup the gnome session environment to suit test needs.
+"""
+
+from gi.repository import Gio, Gtk
+
+
+def run(args=None):
+    session = Gio.Settings('org.gnome.desktop.session')
+    # Never sleep, we're in a vm
+    session.set_uint('idle-delay', 0)
+    # Never lock the screen either
+    screen_saver = Gio.Settings('org.gnome.desktop.screensaver')
+    screen_saver.set_boolean('lock-enabled', False)
+
+
+if __name__ == "__main__":
+    run()

=== added file 'selftest.py'
--- selftest.py	1970-01-01 00:00:00 +0000
+++ selftest.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+
+import sys
+
+import tests
+
+# load tests
+# filter tests
+# order tests
+# run tests
+
+
+# We discover tests under './tests', the python 'load_test' protocol can be
+# used in test modules for more fancy stuff.
+discover_args = ['discover',
+                 '--start-directory', './tests',
+                 ]
+tests.TestProgram(__name__, argv=[sys.argv[0]] + discover_args + sys.argv[1:])
+

=== added directory 'tests'
=== added file 'tests/__init__.py'
--- tests/__init__.py	1970-01-01 00:00:00 +0000
+++ tests/__init__.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,114 @@
+import os
+import selenium
+from selenium.webdriver.firefox import (
+    firefox_binary,
+    webdriver as ff_webdriver,
+    )
+
+from sst import runtests as stests
+import testtools
+from testtools import (
+    run,
+    testcase,
+    )
+import unittest
+import unity.tests as utests
+
+
+class TestCase(testcase.TestCase):
+    pass
+
+
+class FirefoxNoRemote(firefox_binary.FirefoxBinary):
+    """A firefox that can be called by all apps.
+
+    Selelnium provides a firefox instance working in isolation. While that's
+    the most common case, we need a variant here as we don't control how the
+    dash or any lens will call the web browser.
+    """
+
+    def __init__(self, firefox_path=None):
+        super(FirefoxNoRemote, self).__init__(firefox_path)
+        if self._firefox_env.get('MOZ_NO_REMOTE', None) is not None:
+            del self._firefox_env['MOZ_NO_REMOTE']
+
+    if selenium.__version__ < '2.32':
+        # FIXME: The constructor above is all that is needed for selenium 2.32,
+        # but it hasn't been pushed in all places so far so the method below
+        # achieve the same trick for previous selenium releases
+        def _start_from_profile_path(self, path):
+            import platform
+            from subprocess import Popen, PIPE, STDOUT
+            self._firefox_env["XRE_PROFILE_PATH"] = path
+            self._firefox_env["MOZ_CRASHREPORTER_DISABLE"] = "1"
+            self._firefox_env["NO_EM_RESTART"] = "1"
+
+            if platform.system().lower() == 'linux':
+                self._modify_link_library_path()
+            command = [self._start_cmd, "-silent"]
+            if self.command_line is not None:
+                for cli in self.command_line:
+                    command.append(cli)
+
+            Popen(command, stdout=PIPE, stderr=STDOUT,
+                  env=self._firefox_env).communicate()
+            command[1] = '-foreground'
+            self.process = Popen(
+                command, stdout=PIPE, stderr=STDOUT,
+                env=self._firefox_env)
+
+
+class WebDriverNoRemote(ff_webdriver.WebDriver):
+    """A selenium webdriver using FirefoxNoRemote.
+
+    See FirefoxNoRemote for rationale.
+    """
+
+    def __init__(self, firefox_profile=None, firefox_binary=None, timeout=30,
+                 capabilities=None, proxy=None):
+        super(WebDriverNoRemote, self).__init__(
+            firefox_profile, FirefoxNoRemote(), timeout, capabilities, proxy)
+
+
+class FirefoxNoRemoteFactory(stests.FirefoxFactory):
+    """A browser factory using FirefoxNoRemote.
+
+    See FirefoxNoRemote for rationale.
+    """
+
+    webdriver_class = WebDriverNoRemote
+
+
+class UnitySSTestcase(utests.UnityTestCase, stests.SSTTestCase):
+
+    def setUp(self):
+        # We need to setup a firefox instance that capture all web connections
+        self.browser_factory = FirefoxNoRemoteFactory()
+        utests.UnityTestCase.setUp(self)
+        # FIXME: Urgh, for an unclear reason, the following occurs in
+        # autopilot.testcase.LoggedTestCase.setUp when super(LoggedTestCase,
+        # self).setUp() is called. The joy of multiple inheritance... One more
+        # reason to avoid it but sst doesn't provide a way to compose instead
+        # of inheriting in our case. If we leave the following call in place,
+        # we end up calling SSTTestCase.setUp twice which is utterly wrong. One
+        # workaround may be to make SSTTestCase detect double calls and avoid
+        # them but that's even dirtier than the actual behavior and may lead to
+        # even more obscure failures -- vila 2013-03-27
+        # stests.SSTTestCase.setUp(self)
+
+        # Check that the browser started with a single window opened
+        self.assertEqual(1, len(self.browser.window_handles))
+        self.assertEqual('about:blank', self.browser.current_url)
+
+    # FIXME: sst overrides testtools definition, that breaks autopilot
+    # assumption that shortDescription can be used to generate a unique log
+    # file. -- vila 2013-03-27
+    shortDescription = testcase.TestCase.shortDescription
+
+class TestProgram(testtools.run.TestProgram):
+
+    def __init__(self, module, argv, stdout=None, testRunner=None, exit=True):
+        if testRunner is None:
+            testRunner = unittest.TextTestRunner
+        super(TestProgram, self).__init__(module, argv=argv, stdout=stdout,
+                                          testRunner=testRunner, exit=exit)

=== added file 'tests/browsers.py'
--- tests/browsers.py	1970-01-01 00:00:00 +0000
+++ tests/browsers.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,24 @@
+from sst import actions
+
+
+class Browser(object):
+
+    def __init__(self, test):
+        super(Browser, self).__init__()
+        self.browser = test.browser
+        self.nb_windows = len(self.browser.window_handles)
+
+    def switch_to_new_window(self, test):
+        def new_window_appeared():
+            return len(self.browser.window_handles) > 1
+        actions.wait_for(new_window_appeared)
+        test.assertEqual(2, len(self.browser.window_handles))
+        self.browser.switch_to_window(self.browser.window_handles[1])
+
+    @property
+    def url(self):
+        return self.browser.current_url
+
+    @property
+    def title(self):
+        return self.browser.title

=== added file 'tests/dash.py'
--- tests/dash.py	1970-01-01 00:00:00 +0000
+++ tests/dash.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,131 @@
+from autopilot.matchers import Eventually
+from testtools.matchers import (
+    Equals,
+    GreaterThan,
+    NotEquals,
+)
+from unity.emulators import dash as udash
+
+
+def wait_for_category(test, scope, category_name):
+    get_category = lambda: scope.get_category_by_name(category_name)
+    test.assertThat(get_category, Eventually(NotEquals(None)))
+    return get_category()
+
+
+class Window(object):
+    """A dash window with a content, including buttons and links."""
+
+    def __init__(self, user):
+        self.user = user
+
+class Home(Window):
+    """The first window opened when the dash is activated."""
+
+    def get_result(self, test):
+        lens = test.unity.dash.get_current_lens()
+        # Wait for the category we care about to appear (that's the one where
+        # goods can be bought).
+        category = lens.get_category_by_name('More suggestions')
+
+        refresh_results_fn = lambda: len(category.get_results())
+        test.assertThat(refresh_results_fn, Eventually(GreaterThan(0)))
+        # Select first result as soon as it appears
+        return category.get_results()[0]
+
+    def get_preview(self, test, good):
+        test.unity.dash.ensure_visible()
+        test.addCleanup(test.unity.dash.ensure_hidden)
+        if test.lens_name == 'music':
+            test.unity.dash.reveal_music_lens()
+        # Start the search
+        test.keyboard.type(good.search)
+        result = self.get_result(test)
+        # The name of the result is different between home lens and music lens
+        # :-/ -- vila 2013-04-04
+        test.assertTrue(good.name in result.name)
+        # We got the right one, preview it
+        result.preview()
+        test.assertThat(test.unity.dash.view.preview_displaying,
+                        Eventually(Equals(True)))
+        test.assertThat(test.unity.dash.view.get_preview_container,
+                        Eventually(NotEquals(None)))
+        container = test.unity.dash.view.get_preview_container()
+        # We have the preview now
+        return Preview(self.user, good, container)
+
+
+class WindowWithGood(Window):
+
+    def __init__(self, user, good):
+        super(WindowWithGood, self).__init__(user)
+        self.good = good
+
+    def good_displayed(self):
+        # FIXME: There should be a way to fail ;) -- vila 2013-03-26
+        return True
+
+
+class Preview(WindowWithGood):
+
+    def __init__(self, user, good, container):
+        super(Preview, self).__init__(user, good)
+        self.container = container
+
+
+    def get_dash_preview(self):
+        content = self.container.get_children_by_type(udash.PreviewContent)[0]
+        preview = content.get_current_preview()
+        return preview
+
+    def good_displayed(self):
+        preview = self.get_dash_preview()
+        # FIXME: At some point, self.good.name == preview.text_boxes[0].text
+        # used to be True... we need some other way now -- vila 2013-04-03
+        return True
+
+    def get_download_button(self):
+        preview = self.get_dash_preview()
+        download = preview.get_action_by_id('download_album')
+        return download
+
+    def click_download(self, test):
+        download = self.get_download_button()
+        # FIXME: MusicPreview should allow executing the action but it's
+        # currently broken (http://pad.lv/1163930) -- vila 2013-04-03
+        mouse = udash.Mouse()
+        mouse.move(download.x, download.y)
+        mouse.click()
+        # FIXME: The current implementation diverges from the design spec by
+        # going straight to the web without presenting a window explaining why
+        # the good can't be bought while also displaying the good. As of today,
+        # the workaround is to display a message instead of the button. But
+        # this is only implemented for the music lens, not the home
+        # lens. -- vila 2013-03-28
+        return GotoU1(self.user, self.good)
+
+
+class GotoU1(WindowWithGood):
+
+    def __init__(self, user, good):
+        super(GotoU1, self).__init__(user, good)
+        if self.user.logged_in:
+            if self.user.payment_method == 'expired':
+                self.message = ('Your card has expired.'
+                                'To add a new payment method, please visit...')
+            else:
+                self.message = 'To add a payment method, please visit...'
+        else:
+            self.message = ("You don't have  an Ubuntu One account,"
+                            " or you are not logged in.")
+
+    def click_goto_u1(self):
+        from tests import browsers
+        browser = browsers.get_default()
+        # Fake the app response by forcing the url in the browser
+        if self.user.logged_in:
+            browser.current_url = 'https://pay.ubuntu.com'
+        else:
+            browser.current_url = 'https://one.ubuntu.com'
+        return browser
+

=== added file 'tests/goods.py'
--- tests/goods.py	1970-01-01 00:00:00 +0000
+++ tests/goods.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,9 @@
+class Good(object):
+
+    def __init__(self, name, search):
+        # Name is used to lightly check the result we get from the
+        # search. Lightly here means that we ensure that the result name
+        # contains the good name.
+        self.name = name
+        # How to search for this good from the dash
+        self.search = search

=== added file 'tests/sso.py'
--- tests/sso.py	1970-01-01 00:00:00 +0000
+++ tests/sso.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,147 @@
+import os
+import subprocess
+import time
+
+from autopilot.emulators import input
+from autopilot import introspection
+from u1testutils import settings
+
+
+class UbuntuSSO(object):
+
+    def launch_application(self):
+        self._prepare_environment()
+        process = subprocess.Popen(
+            '/usr/lib/ubuntu-sso-client/ubuntu-sso-login-qt')
+        self.application = (
+            introspection.get_autopilot_proxy_object_for_process(process))
+
+    def _prepare_environment(self):
+        os.environ['TESTABILITY'] = '1'
+        os.environ['USSOC_SERVICE_URL'] = '{0}/api/1.0/'.format(
+            settings.OPENID_SSO_SERVER_URL)
+        os.environ['SSO_AUTH_BASE_URL'] = settings.OPENID_SSO_SERVER_URL
+        os.environ['SSO_UONE_BASE_URL'] = settings.UBUNTUONE_SERVER_URL
+        os.system('pkill ubuntu-sso')
+        subprocess.Popen('/usr/lib/ubuntu-sso-client/ubuntu-sso-login')
+
+    def log_in(self, user):
+        self.launch_application()
+        log_in_page = self._go_to_log_in_page()
+        success_page = log_in_page.log_in_with_successful_authentication(user)
+        assert (success_page.get_message() ==
+                'You are now logged into Ubuntu One.')
+        success_page.finish()
+
+    def _go_to_log_in_page(self):
+        sign_up_page = SignUpPage(self.application)
+        sign_up_page.wait_for_action_to_complete()
+        return sign_up_page.go_to_log_in()
+
+
+class Page(object):
+
+    def __init__(self, application, page_type):
+        self.application = application
+        self.page = self.application.select_single(page_type)
+        self.keyboard = input.get_keyboard()
+        self.mouse = input.get_mouse()
+
+    def wait_for_action_to_complete(self):
+        """Wait for the last action to complete.
+
+        This method waits for the loading overlay to dissapear.
+
+        """
+        # If autopilot executes too fast, we might look for the loading overlay
+        # before it is shown. We should wait a little to give it time to
+        # appear, but it's not possible to wait for it, because if autopilot
+        # executes too slow, we might look for it after it dissapears.
+        # Thus, the only solution that comes to mind is a sleep.
+        # -- elopio - 2013-05-03
+        time.sleep(3)
+        loading_overlay = self.application.select_single('LoadingOverlay')
+        loading_overlay.visible.wait_for(False)
+
+    # TODO propose this to autopilot. -- elopio - 2013-05-03
+    def get_child_by_type(self, desired_type, **kwargs):
+        children = self.page.get_children_by_type(desired_type, **kwargs)
+        assert len(children) > 0, 'No child found.'
+        assert len(children) == 1, 'More than one child found.'
+        return children[0]
+
+
+class SignUpPage(Page):
+
+    def __init__(self, application):
+        super(SignUpPage, self).__init__(application, 'SetupAccountPage')
+
+    def go_to_log_in(self):
+        self.wait_for_action_to_complete()
+        sign_in_label = self.get_child_by_type(
+            'QLabel', objectName='sign_in_label')
+        self.mouse.move_to_object(sign_in_label)
+        self.mouse.click()
+        self.wait_for_action_to_complete()
+        return LogInPage(self.application)
+
+
+class LogInPage(Page):
+
+    def __init__(self, application):
+        super(LogInPage, self).__init__(application, 'CurrentUserSignInPage')
+
+    def log_in_with_successful_authentication(self, user):
+        self._log_in(user.email, user.password)
+        assert self.get_form_errors() is None
+        return SuccessPage(self.application)
+
+    def _log_in(self, email, password):
+        self._fill_log_in_form(email, password)
+        sign_in_button = self.get_child_by_type(
+            'QPushButton', objectName='sign_in_button')
+        self.mouse.move_to_object(sign_in_button)
+        self.mouse.click()
+        self.wait_for_action_to_complete()
+
+    def _fill_log_in_form(self, email, password):
+        email_edit = self.get_child_by_type(
+            'QLineEdit', objectName='email_edit')
+        self.mouse.move_to_object(email_edit)
+        self.mouse.click()
+        self.keyboard.type(email)
+        password_edit = self.get_child_by_type(
+            'QLineEdit', objectName='password_edit')
+        self.mouse.move_to_object(password_edit)
+        self.mouse.click()
+        self.keyboard.type(password)
+
+    def get_form_errors(self):
+        form_errors = self.get_child_by_type(
+            'QLabel', objectName='form_errors')
+        if form_errors.visible:
+            return form_errors.text
+        else:
+            return None
+
+
+class SuccessPage(Page):
+
+    def __init__(self, application):
+        super(SuccessPage, self).__init__(application, 'SuccessPage')
+
+    def get_message(self):
+        label = self.get_child_by_type(
+            'QLabel', objectName='success_message_body')
+        return label.text
+
+    def finish(self):
+        # TODO when we have the emulator, this should be on the wizard, not the
+        # page. -- elopio - 2013-05-03
+        # Bug reported to QWizard because the buttons don't have objectName:
+        # https://bugreports.qt-project.org/browse/QTBUG-29924
+        # TODO update when the bug is fixed. -- elopio - 2013-05-03
+        finish_button = self.application.select_single(
+            'QPushButton', text='&Finish')
+        self.mouse.move_to_object(finish_button)
+        self.mouse.click()

=== added file 'tests/test_dash.py'
--- tests/test_dash.py	1970-01-01 00:00:00 +0000
+++ tests/test_dash.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,34 @@
+import autopilot
+from autopilot.matchers import Eventually
+from testtools.matchers import Contains, Equals, GreaterThan
+import unity.tests as utests
+
+
+class TestDash(utests.UnityTestCase):
+
+    # This test needs to be upgraded to catch up with autopilot and unity
+    # recent versions.
+    def xtest_select_preview(self):
+        self.unity.dash.ensure_visible()
+        self.addCleanup(self.unity.dash.ensure_hidden)
+        lens = self.unity.dash.get_current_lens()
+        self.keyboard.type("hendrix")
+        results_category = lens.get_category_by_name("More suggestions")
+        refresh_results_fn = lambda: len(results_category.get_results())
+        self.assertThat(refresh_results_fn, Eventually(GreaterThan(1)))
+        # Select first result
+        self.keyboard.press_and_release('Enter')
+        # We have the preview now
+        self.keyboard.press_and_release('Enter')
+        self.assertTrue(self.bamf.wait_until_application_is_running(
+                'firefox.desktop', 10.0))
+        firefox = self.bamf.get_running_applications_by_desktop_file(
+            'firefox.desktop')[0]
+        self.addCleanup(firefox.get_windows()[0].close)
+        # FIXME: We can't get the right title as we receive the window too
+        # soon. -- vila 2013-02-21
+#        for w in firefox.get_windows():
+#            print 'title: %s' % (w.title)
+#        import pdb; pdb.set_trace()
+#        self.assertEqual('Log in - Mozilla Firefox',
+#                         firefox.get_windows()[0].title)

=== added file 'tests/test_dbus.py'
--- tests/test_dbus.py	1970-01-01 00:00:00 +0000
+++ tests/test_dbus.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,19 @@
+import tests
+
+import dbus
+from gi.repository import Gio, Gtk
+
+class TestDBUS(tests.TestCase):
+
+    def setUp(self):
+        super(TestDBUS, self).setUp()
+        self.bus = dbus.SessionBus()
+        # Register and clean up our own bus.
+        self.bus.request_name('canonical.online-services.selftest')
+        self.addCleanup(self.bus.release_name,
+                        'canonical.online-services.selftest')
+
+    def test_it(self):
+        # FIXME: We need some real tests :0) But the setUp above will be
+        # exercised even by an eempty test and represent useful knowledge.
+        pass

=== added file 'tests/test_purchase_good.py'
--- tests/test_purchase_good.py	1970-01-01 00:00:00 +0000
+++ tests/test_purchase_good.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,92 @@
+import unity.tests as utests
+
+from sst import actions as sactions
+
+import tests
+from tests import (
+    browsers,
+    dash,
+    goods,
+    users,
+)
+
+# Command to use different servers for in-dash purchases
+# pkill unity-music; G_MESSAGES_DEBUG=all U1_STAGING_WEBAPI=https://staging.one.ubuntu.com/ U1_STAGING_AUTHENTICATION=https://login.staging.ubuntu.com/ /usr/lib/x86_64-linux-gnu/unity-lens-music/unity-musicstore-daemon
+
+# Command to use the local servers for in-dash purchases
+# pkill unity-music; G_MESSAGES_DEBUG=all U1_STAGING_WEBAPI=http://u1.local:8003/ U1_STAGING_AUTHENTICATION=http://sso.local:8001/ /usr/lib/x86_64-linux-gnu/unity-lens-music/unity-musicstore-daemon
+
+
+class TestPurchaseGood(tests.UnitySSTestcase):
+
+
+    def setUp(self):
+        super(TestPurchaseGood, self).setUp()
+        # A user will purchase a good
+        self.user = users.User.make_unique()
+        # Arbitrarily using a good that is known to work
+        self.good = goods.Good(u'Jimi Hendrix', 'hendrix')
+
+    def preview_good(self):
+        home = dash.Home(self.user)
+        self.preview = home.get_preview(self, self.good)
+        # user get a preview screen and a button to click on
+        self.assertTrue(self.preview.good_displayed())
+
+    def purchase_good(self):
+        # Attempt to purchase the good
+        return self.preview.click_download(self)
+
+
+class TestUserCannotPay(TestPurchaseGood):
+
+    scenarios = [(name, {'lens_name': name}) for name in ('home', 'music',)]
+
+    def test_user_not_logged_in(self):
+        # User not logged in
+        self.user.logout()
+        self.preview_good()
+        if self.lens_name == 'music':
+            # There is a workaround in place for the music lens only that
+            # forbids testing the rest of the workflow
+            self.assertIs(None, self.preview.get_download_button())
+            # FIXME: It would be nice to check the message displayed when the
+            # button is not available but it's not exposed -- vila 2013-04-04
+            return
+        goto_u1 = self.purchase_good()
+        # diverges from the design spec, we go directly to the web
+        # self.assertTrue(goto_u1.good_displayed()) 
+        browser = browsers.Browser(self)
+        # We've been redirected to the web
+        browser.switch_to_new_window(self)
+        sactions.wait_for(sactions.assert_url_contains,
+                          'https://login.ubuntu.com')
+        self.assertEqual('Log in', browser.title)
+
+    def test_no_payment_method_stored(self):
+        # User has no payment method
+        self.user.login()
+        self.user.payment_method = None
+        goto_u1 = self.purchase_good()
+        self.assertTrue(goto_u1.good_displayed())
+        self.assertIn('add a payment method', goto_u1.message)
+        # The default browser is launched to propose paying 
+        browser = goto_u1.click_goto_u1()
+        # User is sent to the web
+        self.assertTrue(browser.is_running())
+        self.assertEqual('https://pay.ubuntu.com', browser.current_url)
+
+    def test_pay_method_expired(self):
+        # Uesrs's payment has expired
+        self.user.login()
+        self.user.payment_method = 'expired'
+        goto_u1 = self.purchase_good()
+        self.assertTrue(goto_u1.good_displayed())
+        self.assertIn('card has expired', goto_u1.message)
+        # The default browser is launched to propose paying 
+        browser = goto_u1.click_goto_u1()
+        # User is sent to the web
+        self.assertTrue(browser.is_running())
+        self.assertEqual('https://pay.ubuntu.com', browser.current_url)
+
+

=== added file 'tests/test_session.py'
--- tests/test_session.py	1970-01-01 00:00:00 +0000
+++ tests/test_session.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,19 @@
+import tests
+
+from gi.repository import Gio, Gtk
+
+class TestGSettings(tests.TestCase):
+
+    def test_session(self):
+        s = Gio.Settings('org.gnome.desktop.session')
+        orig = s.get_uint('idle-delay')
+        self.addCleanup(s.set_uint, 'idle-delay', orig)
+        s.set_uint('idle-delay', orig + 2)
+        self.assertEqual(orig + 2, s.get_uint('idle-delay'))
+
+    def test_screensaver(self):
+        s = Gio.Settings('org.gnome.desktop.screensaver')
+        orig = s.get_boolean('lock-enabled')
+        self.addCleanup(s.set_boolean, 'lock-enabled', orig)
+        s.set_boolean('lock-enabled', not orig)
+        self.assertEqual(not orig, s.get_boolean('lock-enabled'))

=== added file 'tests/test_users.py'
--- tests/test_users.py	1970-01-01 00:00:00 +0000
+++ tests/test_users.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,42 @@
+import mock
+
+import tests
+from tests import users
+
+
+class UsersTest(tests.TestCase):
+
+    def _patch_u1testutils_settings(self, **kwargs):
+        for setting, new_value in kwargs.items():
+            name = 'u1testutils.settings.{0}'.format(setting)
+            patcher = mock.patch(name, new_value)
+            self.addCleanup(patcher.stop)
+            patcher.start()
+
+    def test_make_unique(self):
+        self._patch_u1testutils_settings(
+            EMAIL_ADDRESS_PATTERN='[e-mail]',
+            SSO_TEST_ACCOUNT_PASSWORD='password from configuration')
+        with mock.patch('uuid.uuid1') as mock_uuid:
+            mock_uuid.return_value = 'test_uuid'
+            user = users.User.make_unique()
+
+        self.assertEqual(user.user_data.full_name, 'Test user test_uuid')
+        self.assertEqual(
+            user.user_data.email, '[e-mail]')
+        self.assertEqual(
+            user.user_data.password, 'password from configuration')
+        self.assertEqual(user.is_logged_in(), False)
+        self.assertEqual(user.payment_method, None)
+
+    def test_log_in(self):
+        user = users.User.make_unique()
+        user.login()
+        self.assertEqual(user.is_logged_in(), True)
+
+    def test_log_out(self):
+        user = users.User.make_unique()
+        user.logged_in = True
+        user.logout()
+        self.assertEqual(user.is_logged_in(), False)
+

=== added file 'tests/users.py'
--- tests/users.py	1970-01-01 00:00:00 +0000
+++ tests/users.py	2013-05-06 17:45:31 +0000
@@ -0,0 +1,43 @@
+import dbus
+from dbus.mainloop.glib import DBusGMainLoop
+
+from u1testutils.sso import data, client
+
+from tests import sso
+
+
+class User(object):
+
+    def __init__(self, user_data):
+        self.user_data = user_data
+        self.logged_in = False
+        self.payment_method = None
+
+    @classmethod
+    def make_unique(cls):
+        user_data = data.User.make_from_configuration(new_user=True)
+        return cls(user_data)
+
+    def is_logged_in(self):
+        # TODO make this work.
+        #DBusGMainLoop(set_as_default=True)
+        #session_bus = dbus.SessionBus()
+        #proxy = session_bus.get_object(
+        #    'com.ubuntu.sso', '/com/ubuntu/sso/credentials')
+        #interface = dbus.Interface(
+        #    proxy, dbus_interface='com.ubuntu.sso.CredentialsManagement')
+        #proxy.connect_to_signal('CredentialsFound', credentials_found)
+        #proxy.connect_to_signal('CredentialsNotFound', credentials_not_found)
+        #proxy.connect_to_signal('CredentialsError', credentials_error)
+        #interface.find_credentials('Ubuntu One', {})
+        return self.logged_in
+
+    def login(self):
+        client.create_new_account(
+            self.user_data, captcha_id='Not used', captcha_solution='Not used')
+        ubuntu_sso = sso.UbuntuSSO()
+        ubuntu_sso.log_in(self.user_data)
+        self.logged_in = True
+
+    def logout(self):
+        self.logged_in = False