Merge lp:~nataliabidart/ubuntuone-control-panel/folders-tweaks into lp:ubuntuone-control-panel

[Natalia Bidart]

- Needed to split test_gui in two files due to lint warning 'too many lines in module'.
- Cleanly show the specilal folder of purchased music (LP: #720650).
- 'User' icon for cloud folders list is now 'avatar-default' (LP: #706034).

[Martin Albisetti (beuno)]

review: Approve (ui)

[Roberto Alsina (ralsina)]

+1

review: Approve

=== modified file 'ubuntuone/controlpanel/gtk/gui.py'
--- ubuntuone/controlpanel/gtk/gui.py	2011-02-28 23:24:53 +0000
+++ ubuntuone/controlpanel/gtk/gui.py	2011-03-01 15:44:47 +0000
@@ -397,12 +397,15 @@
     CONFIRM_MERGE = _('The contents of your cloud folder will be merged with '
                       'your local folder "%(folder_path)s" when subscribing.\n'
                       'Do you want to subscribe to this cloud folder?')
+    MUSIC_DISPLAY_NAME = _('Purchased Music')
+    MUSIC_REAL_PATH = '~/.ubuntuone/Purchased from Ubuntu One'
 
     MAX_COLS = 8
 
-    CONTACT_ICON_NAME = 'system-users'
+    CONTACT_ICON_NAME = 'avatar-default'
     FOLDER_ICON_NAME = 'folder'
     SHARE_ICON_NAME = 'folder-remote'
+    MUSIC_ICON_NAME = 'audio-x-generic'
     ROW_HEADER = '<span font_size="large"><b>%s</b></span> ' \
                  '<span foreground="grey">%s</span>'
     ROOT = '%s - <span foreground="%s" font_size="small">%s</span>'
@@ -436,7 +439,14 @@
     def _process_path(self, path):
         """Trim 'path' so the '~' is removed."""
         home = os.path.expanduser('~')
-        return path.replace(os.path.join(home, ''), '')
+        music_path = os.path.expanduser(self.MUSIC_REAL_PATH)
+
+        if path == music_path:
+            result = self.MUSIC_DISPLAY_NAME
+        else:
+            result = path.replace(os.path.join(home, ''), '')
+
+        return result
 
     def on_volumes_info_ready(self, info):
         """Backend notifies of volumes info."""
@@ -454,13 +464,10 @@
 
             if name:
                 name = name + "'s"
-                icon_name = self.SHARE_ICON_NAME
-
                 # we already added user folders, let's add an empty row
                 treeiter = self.volumes_store.append(None, self._empty_row)
             else:
                 name = self.MY_FOLDERS
-                icon_name = self.FOLDER_ICON_NAME
 
             free_bytes_args = {'free_space': self.humanize(int(free_bytes))}
             row = (self.ROW_HEADER % (name, self.FREE_SPACE % free_bytes_args),
@@ -472,6 +479,7 @@
             for volume in volumes:
                 sensitive = True
                 name = self._process_path(volume[u'path'])
+                icon_name = self.FOLDER_ICON_NAME
 
                 is_root = volume[u'type'] == backend.ControlBackend.ROOT_TYPE
                 is_share = volume[u'type'] == backend.ControlBackend.SHARE_TYPE
@@ -481,6 +489,9 @@
                     name = self.ROOT % (name, ORANGE, self.ALWAYS_SUBSCRIBED)
                 elif is_share:
                     name = volume[u'name']
+                    icon_name = self.SHARE_ICON_NAME
+                elif name == self.MUSIC_DISPLAY_NAME:
+                    icon_name = self.MUSIC_ICON_NAME
 
                 row = (name, bool(volume[u'subscribed']), icon_name, True,
                        sensitive, gtk.ICON_SIZE_MENU, volume['volume_id'],

=== modified file 'ubuntuone/controlpanel/gtk/tests/__init__.py'
--- ubuntuone/controlpanel/gtk/tests/__init__.py	2011-02-28 19:53:50 +0000
+++ ubuntuone/controlpanel/gtk/tests/__init__.py	2011-03-01 15:44:47 +0000
@@ -24,6 +24,7 @@
 
 from ubuntuone.devtools.handlers import MementoHandler
 
+from ubuntuone.controlpanel.backend import ControlBackend
 from ubuntuone.controlpanel.gtk import gui
 from ubuntuone.controlpanel.gtk.tests.test_package_manager import (
     FakedTransaction)
@@ -41,26 +42,36 @@
 
 ROOT = {
     u'volume_id': '', u'path': '/home/tester/My Ubuntu',
-    u'subscribed': 'True', u'type': u'ROOT',
+    u'subscribed': 'True', u'type': ControlBackend.ROOT_TYPE,
+}
+
+MUSIC_FOLDER = {
+    u'volume_id': u'58236', u'subscribed': u'True',
+    u'type': ControlBackend.FOLDER_TYPE,
+    u'path': u'/home/tester/.ubuntuone/Purchased from Ubuntu One',
+    u'suggested_path': u'~/.ubuntuone/Purchased from Ubuntu One',
 }
 
 FAKE_FOLDERS_INFO = [
     {u'volume_id': u'0', u'path': u'/home/tester/foo',
-     u'suggested_path': u'~/foo', u'subscribed': u'', u'type': u'UDF'},
+     u'suggested_path': u'~/foo', u'subscribed': u'',
+     u'type': ControlBackend.FOLDER_TYPE},
     {u'volume_id': u'1', u'path': u'/home/tester/bar',
-     u'suggested_path': u'~/bar', u'subscribed': u'True', u'type': u'UDF'},
+     u'suggested_path': u'~/bar', u'subscribed': u'True',
+     u'type': ControlBackend.FOLDER_TYPE},
     {u'volume_id': u'2', u'path': u'/home/tester/baz',
-     u'suggested_path': u'~/baz', u'subscribed': u'True', u'type': u'UDF'},
+     u'suggested_path': u'~/baz', u'subscribed': u'True',
+     u'type': ControlBackend.FOLDER_TYPE},
 ]
 
 FAKE_SHARES_INFO = [
     {u'volume_id': u'1234', u'name': u'do',
      u'path': u'/home/tester/.local/share/ubuntuone/shares/do from Other User',
-     u'subscribed': u'', u'type': u'SHARE'},
+     u'subscribed': u'', u'type': ControlBackend.SHARE_TYPE},
 
     {u'volume_id': u'5678', u'name': u're',
      u'path': u'/home/tester/.local/share/ubuntuone/shares/re from Other User',
-     u'subscribed': u'True', u'type': u'SHARE'},
+     u'subscribed': u'True', u'type': ControlBackend.SHARE_TYPE},
 ]
 
 FAKE_VOLUMES_INFO = [

=== modified file 'ubuntuone/controlpanel/gtk/tests/test_gui.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-02-28 23:24:53 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui.py	2011-03-01 15:44:47 +0000
@@ -23,577 +23,19 @@
 from ubuntuone.controlpanel.gtk import gui
 from ubuntuone.controlpanel.gtk.tests import (FAKE_ACCOUNT_INFO,
     FAKE_DEVICE_INFO, FAKE_DEVICES_INFO, FAKE_FOLDERS_INFO,
-    FAKE_VOLUMES_INFO, FAKE_REPLICATIONS_INFO, ROOT, USER_HOME,
-    BaseTestCase, FakedSSOBackend, FakedConfirmDialog,
+    FAKE_VOLUMES_INFO, FAKE_REPLICATIONS_INFO,
+    MUSIC_FOLDER, ROOT, USER_HOME,
+    FakedConfirmDialog,
+)
+from ubuntuone.controlpanel.gtk.tests.test_gui_basic import (
+    ControlPanelMixinTestCase,
 )
 from ubuntuone.controlpanel.gtk.tests.test_package_manager import (
     SUCCESS, FAILURE)
-from ubuntuone.controlpanel.tests import TOKEN
 
 
 # Attribute 'yyy' defined outside __init__, access to a protected member
 # pylint: disable=W0201, W0212
-# Too many lines in module
-# pylint: disable=C0302
-
-
-class ControlPanelMixinTestCase(BaseTestCase):
-    """The test suite for the control panel widget."""
-
-    klass = gui.ControlPanelMixin
-    ui_filename = None
-
-    def test_is_a_control_panel_mixin(self):
-        """Inherits from ControlPanelMixin."""
-        self.assertIsInstance(self.ui, gui.ControlPanelMixin)
-
-    def test_ui_can_be_created(self):
-        """UI main class exists and can be created."""
-        self.assertTrue(self.ui is not None)
-
-
-class ControlPanelWindowTestCase(BaseTestCase):
-    """The test suite for the control panel window."""
-
-    klass = gui.ControlPanelWindow
-
-    def test_is_a_window(self):
-        """Inherits from gtk.Window."""
-        self.assertIsInstance(self.ui, gui.gtk.Window)
-
-    def test_startup_visibility(self):
-        """The widget is visible at startup."""
-        self.assertTrue(self.ui.get_visible(), 'must be visible at startup.')
-
-    def test_main_start_gtk_main_loop(self):
-        """The GTK main loop is started when calling main()."""
-        self.patch(gui.gtk, 'main', self._set_called)
-        self.ui.main()
-        self.assertEqual(self._called, ((), {}), 'gtk.main was called.')
-
-    def test_closing_stops_the_main_lopp(self):
-        """The GTK main loop is stopped when closing the window."""
-        self.patch(gui.gtk, 'main_quit', self._set_called)
-        self.ui.emit('delete-event', None)
-        self.assertEqual(self._called, ((), {}), 'gtk.main_quit was called.')
-
-    def test_title_is_correct(self):
-        """The window title is correct."""
-        expected = self.ui.TITLE % {'app_name': gui.U1_APP_NAME}
-        self.assertEqual(self.ui.get_title(), expected)
-
-    def test_control_panel_is_the_only_child(self):
-        """The control panel is the window's content."""
-        children = self.ui.get_children()
-        self.assertEqual(1, len(children))
-
-        control_panel = self.ui.get_children()[0]
-        self.assertTrue(control_panel is self.ui.control_panel)
-        self.assertIsInstance(self.ui.control_panel, gui.ControlPanel)
-        self.assertTrue(self.ui.control_panel.get_visible())
-
-    def test_main_window_is_passed_to_child(self):
-        """The child gets the main_window."""
-        self.assertEqual(self.ui.control_panel.main_window, self.ui)
-
-    def test_icon_name_is_correct(self):
-        """The icon name is correct."""
-        self.assertEqual(self.ui.get_icon_name(), 'ubuntuone')
-
-    def test_max_size(self):
-        """Max size is not bigger than 736x525 (LP: #645526, LP: #683164)."""
-        self.assertTrue(self.ui.get_size_request() <= (736, 525))
-
-
-class ControlPanelWindowParamsTestCase(ControlPanelWindowTestCase):
-    """The test suite for the control panel window when passing params."""
-
-    kwargs = {'switch_to': 'devices'}
-
-    def test_switch_to(self):
-        """Can pass a 'switch_to' parameter to start on a particular tab."""
-        actual = self.ui.control_panel.management.notebook.get_current_page()
-        self.assertEqual(actual, self.ui.control_panel.management.DEVICES_PAGE)
-
-
-class ControlPanelWindowParamsNoneTestCase(ControlPanelWindowTestCase):
-    """The suite for the control panel window when passing None params."""
-
-    kwargs = {'switch_to': None}
-
-    def test_switch_to(self):
-        """Can pass a 'switch_to' being None. Should default to dashboard."""
-        actual = self.ui.control_panel.management.notebook.get_current_page()
-        expected = self.ui.control_panel.management.DASHBOARD_PAGE
-        self.assertEqual(actual, expected)
-
-
-class ControlPanelWindowInvalidParamsTestCase(ControlPanelWindowTestCase):
-    """The suite for the control panel window when passing invalid params."""
-
-    kwargs = {'switch_to': 'yadda-yadda'}
-
-    def test_switch_to(self):
-        """Can pass an invalid 'switch_to'. Should default to dashboard."""
-        actual = self.ui.control_panel.management.notebook.get_current_page()
-        expected = self.ui.control_panel.management.DASHBOARD_PAGE
-        self.assertEqual(actual, expected)
-
-
-class ControlPanelTestCase(BaseTestCase):
-    """The test suite for the control panel itself."""
-
-    klass = gui.ControlPanel
-    kwargs = {'main_window': object()}
-
-    def assert_current_tab_correct(self, expected_tab):
-        """Check that the wiget 'expected_tab' is the current page."""
-        actual = self.ui.get_nth_page(self.ui.get_current_page())
-        self.assertTrue(expected_tab is actual)
-
-    def test_is_a_notebook(self):
-        """Inherits from gtk.VBox."""
-        self.assertIsInstance(self.ui, gui.gtk.Notebook)
-
-    def test_startup_visibility(self):
-        """The widget is visible at startup."""
-        self.assertTrue(self.ui.get_visible(),
-                        'must be visible at startup.')
-
-    def test_startup_props(self):
-        """The tabs and border are not shown."""
-        self.assertFalse(self.ui.get_show_border(), 'must not show border.')
-        self.assertFalse(self.ui.get_show_tabs(), 'must not show tabs.')
-
-    def test_overview_is_shown_at_startup(self):
-        """The overview is shown at startup."""
-        self.assertIsInstance(self.ui.overview, gui.OverviewPanel)
-        self.assert_current_tab_correct(self.ui.overview)
-
-    def test_main_window_is_passed_to_child(self):
-        """The child gets the main_window."""
-        self.assertEqual(self.ui.overview.main_window,
-                         self.kwargs['main_window'])
-
-    def test_on_show_management_panel(self):
-        """A ManagementPanel is shown when the callback is executed."""
-        self.ui.on_show_management_panel()
-        self.assert_current_tab_correct(self.ui.management)
-
-    def test_on_show_management_panel_is_idempotent(self):
-        """Only one ManagementPanel is shown."""
-        self.ui.on_show_management_panel()
-        self.ui.on_show_management_panel()
-
-        self.assert_current_tab_correct(self.ui.management)
-
-    def test_credentials_found_shows_dashboard_management_panel(self):
-        """On 'credentials-found' signal, the management panel is shown.
-
-        If first signal parameter is False, visible tab should be dashboard.
-
-        """
-        self.patch(self.ui.management, 'load', self._set_called)
-        self.ui.overview.emit('credentials-found', False, object())
-
-        self.assert_current_tab_correct(self.ui.management)
-        self.assertEqual(self.ui.management.notebook.get_current_page(),
-                         self.ui.management.DASHBOARD_PAGE)
-        self.assertEqual(self._called, ((), {}))
-
-    def test_credentials_found_shows_volumes_management_panel(self):
-        """On 'credentials-found' signal, the management panel is shown.
-
-        If first signal parameter is True, visible tab should be volumes.
-
-        """
-        a_token = object()
-        self.ui.overview.emit('credentials-found', True, a_token)
-
-        self.assert_current_tab_correct(self.ui.management)
-        self.assertEqual(self.ui.management.notebook.get_current_page(),
-                         self.ui.management.VOLUMES_PAGE)
-
-    def test_local_device_removed_shows_overview_panel(self):
-        """On 'local-device-removed' signal, the overview panel is shown."""
-        self.ui.overview.emit('credentials-found', True, object())
-        self.ui.management.emit('local-device-removed')
-
-        self.assert_current_tab_correct(self.ui.overview)
-
-
-class UbuntuOneBinTestCase(BaseTestCase):
-    """The test suite for a Ubuntu One panel."""
-
-    klass = gui.UbuntuOneBin
-    kwargs = {'title': 'Something old, something new and something blue.'}
-
-    def test_is_a_vbox(self):
-        """Inherits from proper gtk widget."""
-        self.assertIsInstance(self.ui, gui.gtk.VBox)
-
-    def test_startup_visibility(self):
-        """The widget is visible at startup."""
-        self.assertTrue(self.ui.get_visible(),
-                        'must be visible at startup.')
-        for child in self.ui.get_children():
-            self.assertTrue(child.get_visible())
-
-    def test_title_is_a_panel_title(self):
-        """Title is the correct widget."""
-        self.assertIsInstance(self.ui.title, gui.PanelTitle)
-        self.assertIn(self.ui.title, self.ui.get_children())
-
-    def test_title_markup_is_correct(self):
-        """The title markup is correctly set when passed as argument."""
-        self.assertEqual(self.ui.title.label.get_text(), self.kwargs['title'])
-
-    def test_title_is_correct(self):
-        """The title markup is correctly set when defined at class level."""
-        ui = self.klass()  # no title given
-        self.assertEqual(ui.title.label.get_text(), '')
-
-    def test_message_is_a_label_loading(self):
-        """Message is the correct widget."""
-        self.assertIsInstance(self.ui.message, gui.LabelLoading)
-        self.assertIn(self.ui.message, self.ui.get_children())
-
-    def test_on_success(self):
-        """Callback to stop the Loading and clear messages."""
-        self.ui.on_success()
-        self.assertEqual(self.ui.message.get_label(), '')
-        self.assertFalse(self.ui.message.active)
-
-    def test_on_success_with_message(self):
-        """Callback to stop the Loading and show a info message."""
-        msg = 'WOW! <i>this rocks</i>'
-        self.ui.on_success(message=msg)
-        self.assertEqual(self.ui.message.get_label(), msg)
-        self.assertFalse(self.ui.message.active)
-
-    def test_on_error(self):
-        """Callback to stop the Loading and clear messages."""
-        self.ui.on_error()
-        self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
-        self.assertFalse(self.ui.message.active)
-
-    def test_on_error_with_message(self):
-        """Callback to stop the Loading and show a info message."""
-        msg = 'WOW! <i>this does not rock</i> :-/'
-        self.ui.on_error(message=msg)
-        self.assert_warning_correct(self.ui.message, msg)
-        self.assertFalse(self.ui.message.active)
-
-    def test_is_processing(self):
-        """The flag 'is_processing' is False on start."""
-        self.assertFalse(self.ui.is_processing)
-        self.assertTrue(self.ui.is_sensitive())
-
-    def test_set_is_processing(self):
-        """When setting 'is_processing', the spinner is shown."""
-        self.ui.is_processing = False
-        self.ui.is_processing = True
-
-        self.assertTrue(self.ui.message.get_visible())
-        self.assertTrue(self.ui.message.active)
-        self.assertFalse(self.ui.is_sensitive())
-
-    def test_unset_is_processing(self):
-        """When unsetting 'is_processing', the spinner is not shown."""
-        self.ui.is_processing = True
-        self.ui.is_processing = False
-
-        self.assertTrue(self.ui.message.get_visible())
-        self.assertFalse(self.ui.message.active)
-        self.assertTrue(self.ui.is_sensitive())
-
-
-class OverwiewPanelTestCase(ControlPanelMixinTestCase):
-    """The test suite for the overview panel."""
-
-    klass = gui.OverviewPanel
-    kwargs = {'main_window': gui.gtk.Window()}
-    ui_filename = 'overview.ui'
-
-    def test_is_a_greyable_bin(self):
-        """Inherits from GreyableBin."""
-        self.assertIsInstance(self.ui, gui.GreyableBin)
-
-    def test_inner_widget_is_packed(self):
-        """The 'itself' vbox is packed into the widget."""
-        self.assertIn(self.ui.itself, self.ui.get_children())
-
-    def test_join_now_is_default(self):
-        """The 'join_now' button is the default widget."""
-        self.assertTrue(self.ui.join_now_button.get_property('can-default'))
-
-    def test_sso_backend(self):
-        """Has a correct SSO backend."""
-        self.assertIsInstance(self.ui.sso_backend, FakedSSOBackend)
-
-    def test_sso_backend_signals(self):
-        """The proper signals are connected to the backend."""
-        self.assertEqual(self.ui.sso_backend._signals['CredentialsFound'],
-                         [self.ui.on_credentials_found])
-        self.assertEqual(self.ui.sso_backend._signals['CredentialsNotFound'],
-                         [self.ui.on_credentials_not_found])
-        self.assertEqual(self.ui.sso_backend._signals['CredentialsError'],
-                         [self.ui.on_credentials_error])
-        self.assertEqual(self.ui.sso_backend._signals['AuthorizationDenied'],
-                         [self.ui.on_authorization_denied])
-
-
-class OverwiewNetworkStatePanelTestCase(OverwiewPanelTestCase):
-    """The test suite for the overview panel regarding network state."""
-
-    def test_network_state_is_created(self):
-        """The network state is created."""
-        self.assertIsInstance(self.ui.network_manager_state,
-                              gui.networkstate.NetworkManagerState)
-        self.assertEqual(self.ui.network_manager_state._kwargs['result_cb'],
-                         self.ui.on_network_state_changed)
-
-    def test_network_state_is_queried_at_startup(self):
-        """The network state is asked to the NetworkManagerState."""
-        self.assertTrue('find_online_state' in
-                        self.ui.network_manager_state._called)
-
-    def test_state_online(self):
-        """Network connection is online."""
-        self.ui.on_network_state_changed(gui.networkstate.ONLINE)
-        # all green, no warning
-        self.assertEqual(self.ui.warning_label.get_text(), '')
-        self.assertTrue(self.ui.get_sensitive())
-
-    def test_state_offline(self):
-        """Network connection is offline."""
-        self.ui.on_network_state_changed(gui.networkstate.OFFLINE)
-        msg = self.ui.NETWORK_OFFLINE % {'app_name': gui.U1_APP_NAME}
-
-        self.assert_warning_correct(self.ui.warning_label, msg)
-        self.assertFalse(self.ui.get_sensitive())
-
-    def test_state_unknown(self):
-        """Network connection is unknown."""
-        self.ui.on_network_state_changed(gui.networkstate.UNKNOWN)
-
-        self.assert_warning_correct(self.ui.warning_label,
-                                    self.ui.NETWORK_UNKNOWN)
-        self.assertFalse(self.ui.get_sensitive())
-
-
-class OverwiewPanelOnlineTestCase(OverwiewPanelTestCase):
-    """The test suite for the overview panel."""
-
-    def setUp(self):
-        super(OverwiewPanelOnlineTestCase, self).setUp()
-        self.ui.on_network_state_changed(gui.networkstate.ONLINE)
-
-    def test_find_credentials_is_called(self):
-        """Credentials are asked to SSO backend."""
-        self.assertFalse(self.ui._credentials_are_new)
-        self.assert_backend_called('find_credentials', (gui.U1_APP_NAME, {}),
-                                   backend=self.ui.sso_backend)
-
-    def test_on_credentials_found(self):
-        """Callback 'on_credentials_found' is correct."""
-        self.ui.connect('credentials-found', self._set_called)
-
-        self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
-
-        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
-        # assume credentials were in local keyring
-        self.assertEqual(self._called, ((self.ui, False, TOKEN), {}))
-
-    def test_on_credentials_found_when_creds_are_not_new(self):
-        """Callback 'on_credentials_found' distinguish if creds are new."""
-        self.ui.connect('credentials-found', self._set_called)
-
-        # credentials weren't in the system
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
-        # now they are!
-        self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
-
-        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
-        # assume credentials were not in local keyring
-        self.assertEqual(self._called, ((self.ui, True, TOKEN), {}))
-
-    def test_on_credentials_not_found(self):
-        """Callback 'on_credentials_not_found' is correct."""
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
-        self.assertTrue(self.ui.get_visible())
-        self.assertTrue(self.ui._credentials_are_new)
-
-    def test_on_credentials_error(self):
-        """Callback 'on_credentials_error' is correct."""
-        self.ui.on_credentials_error(gui.U1_APP_NAME, {})
-        self.assertTrue(self.ui.get_visible())
-        self.assert_warning_correct(self.ui.warning_label,
-                                    self.ui.CREDENTIALS_ERROR)
-
-    def test_on_authorization_denied(self):
-        """Callback 'on_authorization_denied' is correct."""
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)
-        self.assertTrue(self.ui.get_visible())
-        self.assert_warning_correct(self.ui.warning_label,
-                                    self.ui.AUTHORIZATION_DENIED)
-
-
-class OverwiewPanelAppNameMismatchTestCase(OverwiewPanelTestCase):
-    """The test suite for the overview panel when the app_name won't match."""
-
-    NOT_U1_APP = 'Not ' + gui.U1_APP_NAME
-
-    def test_filter_by_app_name(self):
-        """The filter_by_app_name decorator is correct."""
-        f = gui.filter_by_app_name(self._set_called)
-        f(self.ui, self.NOT_U1_APP)
-        self.assertFalse(self._called)
-        self.assertTrue(self.memento.check_info('ignoring', self.NOT_U1_APP))
-
-        args = ('test', object())
-        kwargs = {'really': 'AWESOME'}
-        f(self.ui, gui.U1_APP_NAME, *args, **kwargs)
-        self.assertEqual(self._called,
-                         ((self.ui, gui.U1_APP_NAME,) + args, kwargs))
-
-    def test_on_credentials_found(self):
-        """Callback 'on_credentials_found' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_credentials_found)
-
-    def test_on_credentials_not_found(self):
-        """Callback 'on_credentials_not_found' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_credentials_not_found)
-
-    def test_on_credentials_error(self):
-        """Callback 'on_credentials_error' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_credentials_error)
-
-    def test_on_authorization_denied(self):
-        """Callback 'on_authorization_denied' is not executed."""
-        self.assert_function_decorated(gui.filter_by_app_name,
-                                       self.ui.on_authorization_denied)
-
-
-class OverwiewPanelNoCredsTestCase(OverwiewPanelTestCase):
-    """The test suite for the overview panel when no credentials are found."""
-
-    def setUp(self):
-        super(OverwiewPanelNoCredsTestCase, self).setUp()
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
-
-    def test_startup_visibility(self):
-        """The widget is visible at startup."""
-        self.assertTrue(self.ui.get_visible(),
-                        'must be visible at startup if credentials not found.')
-
-    def test_warning_label_is_hidden(self):
-        """The warning label is not shown by default."""
-        self.assertEqual(self.ui.warning_label.get_text(), '')
-
-    def test_image_is_correct(self):
-        """There is an image attribute and is correct."""
-        self.assert_image_equal(self.ui.image, 'overview.png')
-
-    def test_join_now_is_default_widget(self):
-        """The join now button is the default widget."""
-        self.assertTrue(self.ui.join_now_button.get_property('can_default'))
-
-    def test_join_now_button_clicked(self):
-        """Test the 'join now' button callback."""
-        self.kwargs['main_window'].show()  # ensure parent window is realized
-        self.addCleanup(self.kwargs['main_window'].hide)
-
-        self.ui.join_now_button.clicked()
-
-        window_id = self.kwargs['main_window'].window.xid
-        args = (gui.U1_APP_NAME,
-                {gui.TC_URL_KEY: gui.U1_TC_URL,
-                 gui.HELP_TEXT_KEY: gui.U1_DESCRIPTION,
-                 gui.WINDOW_ID_KEY: str(window_id),
-                 gui.PING_URL_KEY: gui.U1_PING_URL})
-        self.assert_backend_called('register', args,
-                                   backend=self.ui.sso_backend)
-
-    def test_connect_button_clicked(self):
-        """Test the 'join now' button callback."""
-        self.kwargs['main_window'].show()  # ensure parent window is realized
-        self.addCleanup(self.kwargs['main_window'].hide)
-
-        self.ui.connect_button.clicked()
-
-        window_id = self.kwargs['main_window'].window.xid
-        args = (gui.U1_APP_NAME,
-                {gui.TC_URL_KEY: gui.U1_TC_URL,
-                 gui.HELP_TEXT_KEY: gui.U1_DESCRIPTION,
-                 gui.WINDOW_ID_KEY: str(window_id),
-                 gui.PING_URL_KEY: gui.U1_PING_URL})
-        self.assert_backend_called('login', args,
-                                   backend=self.ui.sso_backend)
-
-    def test_join_now_button_clicked_set_greyed(self):
-        """Clicking on 'join_now' self is greyed."""
-        self.ui.join_now_button.clicked()
-        self.assertTrue(self.ui.get_property('greyed'), 'Must be greyed.')
-
-    def test_join_now_button_clicked_removes_warning(self):
-        """Clicking on 'join_now' the warnings are removed."""
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)  # show warning
-        self.ui.join_now_button.clicked()
-
-        self.assertEqual(self.ui.warning_label.get_text(), '')
-
-    def test_connect_button_clicked_set_greyed(self):
-        """Clicking on 'connect' self is greyed."""
-        self.ui.connect_button.clicked()
-        self.assertTrue(self.ui.get_property('greyed'), 'Must be greyed.')
-
-    def test_connect_button_clicked_removes_warning(self):
-        """Clicking on 'connect' the warnings are removed."""
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)  # show warning
-        self.ui.connect_button.clicked()
-
-        self.assertEqual(self.ui.warning_label.get_text(), '')
-
-    def test_on_credentials_not_found_unset_greyed(self):
-        """Callback 'on_credentials_not_found' unsets the 'greyed' prop."""
-        self.ui.connect_button.clicked()
-        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
-
-        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
-
-    def test_on_credentials_error_unset_greyed(self):
-        """Callback 'on_credentials_error' unsets the 'greyed' prop."""
-        self.ui.connect_button.clicked()
-        self.ui.on_credentials_error(gui.U1_APP_NAME, {})
-
-        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
-
-    def test_on_authorization_denied_unset_greyed(self):
-        """Callback 'on_authorization_denied' unsets the 'greyed' prop."""
-        self.ui.connect_button.clicked()
-        self.ui.on_authorization_denied(gui.U1_APP_NAME)
-
-        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
-
-    def test_buttons_disabled_when_greyed(self):
-        """Buttons should be disabled when widget is greyed."""
-        self.ui.set_sensitive(True)
-        self.ui.set_property('greyed', True)
-
-        self.assertFalse(self.ui.join_now_button.is_sensitive())
-        self.assertFalse(self.ui.connect_button.is_sensitive())
-
-    def test_buttons_enabled_when_not_greyed(self):
-        """Buttons should be enabled when widget is not greyed."""
-        self.ui.set_sensitive(False)
-        self.ui.set_property('greyed', False)
-
-        self.assertTrue(self.ui.join_now_button.is_sensitive())
-        self.assertTrue(self.ui.connect_button.is_sensitive())
 
 
 class DashboardTestCase(ControlPanelMixinTestCase):
@@ -842,6 +284,35 @@
         self.assertEqual(self._called,
                          ((None, gui.FILE_URI_PREFIX + ROOT['path']), {}))
 
+    def test_on_volumes_info_ready_with_music_folder(self):
+        """The volumes info is processed when ready."""
+        info = [(u'', u'147852369', [ROOT] + [MUSIC_FOLDER])]
+
+        self.ui.on_volumes_info_ready(info)
+
+        treeiter = self.ui.volumes_store.get_iter_root()
+        row = self.ui.volumes_store.get(treeiter, *xrange(self.ui.MAX_COLS))
+
+        # walk 'Mine' folders children
+        treeiter = self.ui.volumes_store.iter_children(treeiter)
+
+        # grab next row since first one is root
+        treeiter = self.ui.volumes_store.iter_next(treeiter)
+        row = self.ui.volumes_store.get(treeiter, *xrange(self.ui.MAX_COLS))
+
+        volume = MUSIC_FOLDER
+        expected_path = volume['path'].replace(USER_HOME, '~')
+        expected_path = expected_path.replace(self.ui.MUSIC_REAL_PATH,
+                                              self.ui.MUSIC_DISPLAY_NAME)
+        self.assertEqual(row[0], expected_path)
+        self.assertEqual(row[1], bool(volume['subscribed']))
+        self.assertEqual(row[2], self.ui.MUSIC_ICON_NAME)
+        self.assertTrue(row[3], 'toggle should be shown on child!')
+        self.assertTrue(row[4], 'toggle should be sensitive')
+        self.assertEqual(row[5], gui.gtk.ICON_SIZE_MENU)
+        self.assertEqual(row[6], volume['volume_id'])
+        self.assertEqual(row[7], volume['path'])
+
 
 class VolumesSubscriptionTestCase(VolumesTestCase):
     """The test suite for the volumes panel."""

=== added file 'ubuntuone/controlpanel/gtk/tests/test_gui_basic.py'
--- ubuntuone/controlpanel/gtk/tests/test_gui_basic.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/controlpanel/gtk/tests/test_gui_basic.py	2011-03-01 15:44:47 +0000
@@ -0,0 +1,588 @@
+# -*- coding: utf-8 -*-
+
+# Authors: Natalia B Bidart <[e-mail]>
+#
+# Copyright 2010 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 warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""The test suite for the control panel user interface (basics)."""
+
+from __future__ import division
+
+from ubuntuone.controlpanel.gtk import gui
+from ubuntuone.controlpanel.gtk.tests import BaseTestCase, FakedSSOBackend
+from ubuntuone.controlpanel.tests import TOKEN
+
+
+# Attribute 'yyy' defined outside __init__, access to a protected member
+# pylint: disable=W0201, W0212
+
+
+class ControlPanelMixinTestCase(BaseTestCase):
+    """The test suite for the control panel widget."""
+
+    klass = gui.ControlPanelMixin
+    ui_filename = None
+
+    def test_is_a_control_panel_mixin(self):
+        """Inherits from ControlPanelMixin."""
+        self.assertIsInstance(self.ui, gui.ControlPanelMixin)
+
+    def test_ui_can_be_created(self):
+        """UI main class exists and can be created."""
+        self.assertTrue(self.ui is not None)
+
+
+class ControlPanelWindowTestCase(BaseTestCase):
+    """The test suite for the control panel window."""
+
+    klass = gui.ControlPanelWindow
+
+    def test_is_a_window(self):
+        """Inherits from gtk.Window."""
+        self.assertIsInstance(self.ui, gui.gtk.Window)
+
+    def test_startup_visibility(self):
+        """The widget is visible at startup."""
+        self.assertTrue(self.ui.get_visible(), 'must be visible at startup.')
+
+    def test_main_start_gtk_main_loop(self):
+        """The GTK main loop is started when calling main()."""
+        self.patch(gui.gtk, 'main', self._set_called)
+        self.ui.main()
+        self.assertEqual(self._called, ((), {}), 'gtk.main was called.')
+
+    def test_closing_stops_the_main_lopp(self):
+        """The GTK main loop is stopped when closing the window."""
+        self.patch(gui.gtk, 'main_quit', self._set_called)
+        self.ui.emit('delete-event', None)
+        self.assertEqual(self._called, ((), {}), 'gtk.main_quit was called.')
+
+    def test_title_is_correct(self):
+        """The window title is correct."""
+        expected = self.ui.TITLE % {'app_name': gui.U1_APP_NAME}
+        self.assertEqual(self.ui.get_title(), expected)
+
+    def test_control_panel_is_the_only_child(self):
+        """The control panel is the window's content."""
+        children = self.ui.get_children()
+        self.assertEqual(1, len(children))
+
+        control_panel = self.ui.get_children()[0]
+        self.assertTrue(control_panel is self.ui.control_panel)
+        self.assertIsInstance(self.ui.control_panel, gui.ControlPanel)
+        self.assertTrue(self.ui.control_panel.get_visible())
+
+    def test_main_window_is_passed_to_child(self):
+        """The child gets the main_window."""
+        self.assertEqual(self.ui.control_panel.main_window, self.ui)
+
+    def test_icon_name_is_correct(self):
+        """The icon name is correct."""
+        self.assertEqual(self.ui.get_icon_name(), 'ubuntuone')
+
+    def test_max_size(self):
+        """Max size is not bigger than 736x525 (LP: #645526, LP: #683164)."""
+        self.assertTrue(self.ui.get_size_request() <= (736, 525))
+
+
+class ControlPanelWindowParamsTestCase(ControlPanelWindowTestCase):
+    """The test suite for the control panel window when passing params."""
+
+    kwargs = {'switch_to': 'devices'}
+
+    def test_switch_to(self):
+        """Can pass a 'switch_to' parameter to start on a particular tab."""
+        actual = self.ui.control_panel.management.notebook.get_current_page()
+        self.assertEqual(actual, self.ui.control_panel.management.DEVICES_PAGE)
+
+
+class ControlPanelWindowParamsNoneTestCase(ControlPanelWindowTestCase):
+    """The suite for the control panel window when passing None params."""
+
+    kwargs = {'switch_to': None}
+
+    def test_switch_to(self):
+        """Can pass a 'switch_to' being None. Should default to dashboard."""
+        actual = self.ui.control_panel.management.notebook.get_current_page()
+        expected = self.ui.control_panel.management.DASHBOARD_PAGE
+        self.assertEqual(actual, expected)
+
+
+class ControlPanelWindowInvalidParamsTestCase(ControlPanelWindowTestCase):
+    """The suite for the control panel window when passing invalid params."""
+
+    kwargs = {'switch_to': 'yadda-yadda'}
+
+    def test_switch_to(self):
+        """Can pass an invalid 'switch_to'. Should default to dashboard."""
+        actual = self.ui.control_panel.management.notebook.get_current_page()
+        expected = self.ui.control_panel.management.DASHBOARD_PAGE
+        self.assertEqual(actual, expected)
+
+
+class ControlPanelTestCase(BaseTestCase):
+    """The test suite for the control panel itself."""
+
+    klass = gui.ControlPanel
+    kwargs = {'main_window': object()}
+
+    def assert_current_tab_correct(self, expected_tab):
+        """Check that the wiget 'expected_tab' is the current page."""
+        actual = self.ui.get_nth_page(self.ui.get_current_page())
+        self.assertTrue(expected_tab is actual)
+
+    def test_is_a_notebook(self):
+        """Inherits from gtk.VBox."""
+        self.assertIsInstance(self.ui, gui.gtk.Notebook)
+
+    def test_startup_visibility(self):
+        """The widget is visible at startup."""
+        self.assertTrue(self.ui.get_visible(),
+                        'must be visible at startup.')
+
+    def test_startup_props(self):
+        """The tabs and border are not shown."""
+        self.assertFalse(self.ui.get_show_border(), 'must not show border.')
+        self.assertFalse(self.ui.get_show_tabs(), 'must not show tabs.')
+
+    def test_overview_is_shown_at_startup(self):
+        """The overview is shown at startup."""
+        self.assertIsInstance(self.ui.overview, gui.OverviewPanel)
+        self.assert_current_tab_correct(self.ui.overview)
+
+    def test_main_window_is_passed_to_child(self):
+        """The child gets the main_window."""
+        self.assertEqual(self.ui.overview.main_window,
+                         self.kwargs['main_window'])
+
+    def test_on_show_management_panel(self):
+        """A ManagementPanel is shown when the callback is executed."""
+        self.ui.on_show_management_panel()
+        self.assert_current_tab_correct(self.ui.management)
+
+    def test_on_show_management_panel_is_idempotent(self):
+        """Only one ManagementPanel is shown."""
+        self.ui.on_show_management_panel()
+        self.ui.on_show_management_panel()
+
+        self.assert_current_tab_correct(self.ui.management)
+
+    def test_credentials_found_shows_dashboard_management_panel(self):
+        """On 'credentials-found' signal, the management panel is shown.
+
+        If first signal parameter is False, visible tab should be dashboard.
+
+        """
+        self.patch(self.ui.management, 'load', self._set_called)
+        self.ui.overview.emit('credentials-found', False, object())
+
+        self.assert_current_tab_correct(self.ui.management)
+        self.assertEqual(self.ui.management.notebook.get_current_page(),
+                         self.ui.management.DASHBOARD_PAGE)
+        self.assertEqual(self._called, ((), {}))
+
+    def test_credentials_found_shows_volumes_management_panel(self):
+        """On 'credentials-found' signal, the management panel is shown.
+
+        If first signal parameter is True, visible tab should be volumes.
+
+        """
+        a_token = object()
+        self.ui.overview.emit('credentials-found', True, a_token)
+
+        self.assert_current_tab_correct(self.ui.management)
+        self.assertEqual(self.ui.management.notebook.get_current_page(),
+                         self.ui.management.VOLUMES_PAGE)
+
+    def test_local_device_removed_shows_overview_panel(self):
+        """On 'local-device-removed' signal, the overview panel is shown."""
+        self.ui.overview.emit('credentials-found', True, object())
+        self.ui.management.emit('local-device-removed')
+
+        self.assert_current_tab_correct(self.ui.overview)
+
+
+class UbuntuOneBinTestCase(BaseTestCase):
+    """The test suite for a Ubuntu One panel."""
+
+    klass = gui.UbuntuOneBin
+    kwargs = {'title': 'Something old, something new and something blue.'}
+
+    def test_is_a_vbox(self):
+        """Inherits from proper gtk widget."""
+        self.assertIsInstance(self.ui, gui.gtk.VBox)
+
+    def test_startup_visibility(self):
+        """The widget is visible at startup."""
+        self.assertTrue(self.ui.get_visible(),
+                        'must be visible at startup.')
+        for child in self.ui.get_children():
+            self.assertTrue(child.get_visible())
+
+    def test_title_is_a_panel_title(self):
+        """Title is the correct widget."""
+        self.assertIsInstance(self.ui.title, gui.PanelTitle)
+        self.assertIn(self.ui.title, self.ui.get_children())
+
+    def test_title_markup_is_correct(self):
+        """The title markup is correctly set when passed as argument."""
+        self.assertEqual(self.ui.title.label.get_text(), self.kwargs['title'])
+
+    def test_title_is_correct(self):
+        """The title markup is correctly set when defined at class level."""
+        ui = self.klass()  # no title given
+        self.assertEqual(ui.title.label.get_text(), '')
+
+    def test_message_is_a_label_loading(self):
+        """Message is the correct widget."""
+        self.assertIsInstance(self.ui.message, gui.LabelLoading)
+        self.assertIn(self.ui.message, self.ui.get_children())
+
+    def test_on_success(self):
+        """Callback to stop the Loading and clear messages."""
+        self.ui.on_success()
+        self.assertEqual(self.ui.message.get_label(), '')
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_success_with_message(self):
+        """Callback to stop the Loading and show a info message."""
+        msg = 'WOW! <i>this rocks</i>'
+        self.ui.on_success(message=msg)
+        self.assertEqual(self.ui.message.get_label(), msg)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_error(self):
+        """Callback to stop the Loading and clear messages."""
+        self.ui.on_error()
+        self.assert_warning_correct(self.ui.message, gui.VALUE_ERROR)
+        self.assertFalse(self.ui.message.active)
+
+    def test_on_error_with_message(self):
+        """Callback to stop the Loading and show a info message."""
+        msg = 'WOW! <i>this does not rock</i> :-/'
+        self.ui.on_error(message=msg)
+        self.assert_warning_correct(self.ui.message, msg)
+        self.assertFalse(self.ui.message.active)
+
+    def test_is_processing(self):
+        """The flag 'is_processing' is False on start."""
+        self.assertFalse(self.ui.is_processing)
+        self.assertTrue(self.ui.is_sensitive())
+
+    def test_set_is_processing(self):
+        """When setting 'is_processing', the spinner is shown."""
+        self.ui.is_processing = False
+        self.ui.is_processing = True
+
+        self.assertTrue(self.ui.message.get_visible())
+        self.assertTrue(self.ui.message.active)
+        self.assertFalse(self.ui.is_sensitive())
+
+    def test_unset_is_processing(self):
+        """When unsetting 'is_processing', the spinner is not shown."""
+        self.ui.is_processing = True
+        self.ui.is_processing = False
+
+        self.assertTrue(self.ui.message.get_visible())
+        self.assertFalse(self.ui.message.active)
+        self.assertTrue(self.ui.is_sensitive())
+
+
+class OverwiewPanelTestCase(ControlPanelMixinTestCase):
+    """The test suite for the overview panel."""
+
+    klass = gui.OverviewPanel
+    kwargs = {'main_window': gui.gtk.Window()}
+    ui_filename = 'overview.ui'
+
+    def test_is_a_greyable_bin(self):
+        """Inherits from GreyableBin."""
+        self.assertIsInstance(self.ui, gui.GreyableBin)
+
+    def test_inner_widget_is_packed(self):
+        """The 'itself' vbox is packed into the widget."""
+        self.assertIn(self.ui.itself, self.ui.get_children())
+
+    def test_join_now_is_default(self):
+        """The 'join_now' button is the default widget."""
+        self.assertTrue(self.ui.join_now_button.get_property('can-default'))
+
+    def test_sso_backend(self):
+        """Has a correct SSO backend."""
+        self.assertIsInstance(self.ui.sso_backend, FakedSSOBackend)
+
+    def test_sso_backend_signals(self):
+        """The proper signals are connected to the backend."""
+        self.assertEqual(self.ui.sso_backend._signals['CredentialsFound'],
+                         [self.ui.on_credentials_found])
+        self.assertEqual(self.ui.sso_backend._signals['CredentialsNotFound'],
+                         [self.ui.on_credentials_not_found])
+        self.assertEqual(self.ui.sso_backend._signals['CredentialsError'],
+                         [self.ui.on_credentials_error])
+        self.assertEqual(self.ui.sso_backend._signals['AuthorizationDenied'],
+                         [self.ui.on_authorization_denied])
+
+
+class OverwiewNetworkStatePanelTestCase(OverwiewPanelTestCase):
+    """The test suite for the overview panel regarding network state."""
+
+    def test_network_state_is_created(self):
+        """The network state is created."""
+        self.assertIsInstance(self.ui.network_manager_state,
+                              gui.networkstate.NetworkManagerState)
+        self.assertEqual(self.ui.network_manager_state._kwargs['result_cb'],
+                         self.ui.on_network_state_changed)
+
+    def test_network_state_is_queried_at_startup(self):
+        """The network state is asked to the NetworkManagerState."""
+        self.assertTrue('find_online_state' in
+                        self.ui.network_manager_state._called)
+
+    def test_state_online(self):
+        """Network connection is online."""
+        self.ui.on_network_state_changed(gui.networkstate.ONLINE)
+        # all green, no warning
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+        self.assertTrue(self.ui.get_sensitive())
+
+    def test_state_offline(self):
+        """Network connection is offline."""
+        self.ui.on_network_state_changed(gui.networkstate.OFFLINE)
+        msg = self.ui.NETWORK_OFFLINE % {'app_name': gui.U1_APP_NAME}
+
+        self.assert_warning_correct(self.ui.warning_label, msg)
+        self.assertFalse(self.ui.get_sensitive())
+
+    def test_state_unknown(self):
+        """Network connection is unknown."""
+        self.ui.on_network_state_changed(gui.networkstate.UNKNOWN)
+
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.NETWORK_UNKNOWN)
+        self.assertFalse(self.ui.get_sensitive())
+
+
+class OverwiewPanelOnlineTestCase(OverwiewPanelTestCase):
+    """The test suite for the overview panel."""
+
+    def setUp(self):
+        super(OverwiewPanelOnlineTestCase, self).setUp()
+        self.ui.on_network_state_changed(gui.networkstate.ONLINE)
+
+    def test_find_credentials_is_called(self):
+        """Credentials are asked to SSO backend."""
+        self.assertFalse(self.ui._credentials_are_new)
+        self.assert_backend_called('find_credentials', (gui.U1_APP_NAME, {}),
+                                   backend=self.ui.sso_backend)
+
+    def test_on_credentials_found(self):
+        """Callback 'on_credentials_found' is correct."""
+        self.ui.connect('credentials-found', self._set_called)
+
+        self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
+
+        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
+        # assume credentials were in local keyring
+        self.assertEqual(self._called, ((self.ui, False, TOKEN), {}))
+
+    def test_on_credentials_found_when_creds_are_not_new(self):
+        """Callback 'on_credentials_found' distinguish if creds are new."""
+        self.ui.connect('credentials-found', self._set_called)
+
+        # credentials weren't in the system
+        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+        # now they are!
+        self.ui.on_credentials_found(gui.U1_APP_NAME, TOKEN)
+
+        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
+        # assume credentials were not in local keyring
+        self.assertEqual(self._called, ((self.ui, True, TOKEN), {}))
+
+    def test_on_credentials_not_found(self):
+        """Callback 'on_credentials_not_found' is correct."""
+        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+        self.assertTrue(self.ui.get_visible())
+        self.assertTrue(self.ui._credentials_are_new)
+
+    def test_on_credentials_error(self):
+        """Callback 'on_credentials_error' is correct."""
+        self.ui.on_credentials_error(gui.U1_APP_NAME, {})
+        self.assertTrue(self.ui.get_visible())
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.CREDENTIALS_ERROR)
+
+    def test_on_authorization_denied(self):
+        """Callback 'on_authorization_denied' is correct."""
+        self.ui.on_authorization_denied(gui.U1_APP_NAME)
+        self.assertTrue(self.ui.get_visible())
+        self.assert_warning_correct(self.ui.warning_label,
+                                    self.ui.AUTHORIZATION_DENIED)
+
+
+class OverwiewPanelAppNameMismatchTestCase(OverwiewPanelTestCase):
+    """The test suite for the overview panel when the app_name won't match."""
+
+    NOT_U1_APP = 'Not ' + gui.U1_APP_NAME
+
+    def test_filter_by_app_name(self):
+        """The filter_by_app_name decorator is correct."""
+        f = gui.filter_by_app_name(self._set_called)
+        f(self.ui, self.NOT_U1_APP)
+        self.assertFalse(self._called)
+        self.assertTrue(self.memento.check_info('ignoring', self.NOT_U1_APP))
+
+        args = ('test', object())
+        kwargs = {'really': 'AWESOME'}
+        f(self.ui, gui.U1_APP_NAME, *args, **kwargs)
+        self.assertEqual(self._called,
+                         ((self.ui, gui.U1_APP_NAME,) + args, kwargs))
+
+    def test_on_credentials_found(self):
+        """Callback 'on_credentials_found' is not executed."""
+        self.assert_function_decorated(gui.filter_by_app_name,
+                                       self.ui.on_credentials_found)
+
+    def test_on_credentials_not_found(self):
+        """Callback 'on_credentials_not_found' is not executed."""
+        self.assert_function_decorated(gui.filter_by_app_name,
+                                       self.ui.on_credentials_not_found)
+
+    def test_on_credentials_error(self):
+        """Callback 'on_credentials_error' is not executed."""
+        self.assert_function_decorated(gui.filter_by_app_name,
+                                       self.ui.on_credentials_error)
+
+    def test_on_authorization_denied(self):
+        """Callback 'on_authorization_denied' is not executed."""
+        self.assert_function_decorated(gui.filter_by_app_name,
+                                       self.ui.on_authorization_denied)
+
+
+class OverwiewPanelNoCredsTestCase(OverwiewPanelTestCase):
+    """The test suite for the overview panel when no credentials are found."""
+
+    def setUp(self):
+        super(OverwiewPanelNoCredsTestCase, self).setUp()
+        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+
+    def test_startup_visibility(self):
+        """The widget is visible at startup."""
+        self.assertTrue(self.ui.get_visible(),
+                        'must be visible at startup if credentials not found.')
+
+    def test_warning_label_is_hidden(self):
+        """The warning label is not shown by default."""
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_image_is_correct(self):
+        """There is an image attribute and is correct."""
+        self.assert_image_equal(self.ui.image, 'overview.png')
+
+    def test_join_now_is_default_widget(self):
+        """The join now button is the default widget."""
+        self.assertTrue(self.ui.join_now_button.get_property('can_default'))
+
+    def test_join_now_button_clicked(self):
+        """Test the 'join now' button callback."""
+        self.kwargs['main_window'].show()  # ensure parent window is realized
+        self.addCleanup(self.kwargs['main_window'].hide)
+
+        self.ui.join_now_button.clicked()
+
+        window_id = self.kwargs['main_window'].window.xid
+        args = (gui.U1_APP_NAME,
+                {gui.TC_URL_KEY: gui.U1_TC_URL,
+                 gui.HELP_TEXT_KEY: gui.U1_DESCRIPTION,
+                 gui.WINDOW_ID_KEY: str(window_id),
+                 gui.PING_URL_KEY: gui.U1_PING_URL})
+        self.assert_backend_called('register', args,
+                                   backend=self.ui.sso_backend)
+
+    def test_connect_button_clicked(self):
+        """Test the 'join now' button callback."""
+        self.kwargs['main_window'].show()  # ensure parent window is realized
+        self.addCleanup(self.kwargs['main_window'].hide)
+
+        self.ui.connect_button.clicked()
+
+        window_id = self.kwargs['main_window'].window.xid
+        args = (gui.U1_APP_NAME,
+                {gui.TC_URL_KEY: gui.U1_TC_URL,
+                 gui.HELP_TEXT_KEY: gui.U1_DESCRIPTION,
+                 gui.WINDOW_ID_KEY: str(window_id),
+                 gui.PING_URL_KEY: gui.U1_PING_URL})
+        self.assert_backend_called('login', args,
+                                   backend=self.ui.sso_backend)
+
+    def test_join_now_button_clicked_set_greyed(self):
+        """Clicking on 'join_now' self is greyed."""
+        self.ui.join_now_button.clicked()
+        self.assertTrue(self.ui.get_property('greyed'), 'Must be greyed.')
+
+    def test_join_now_button_clicked_removes_warning(self):
+        """Clicking on 'join_now' the warnings are removed."""
+        self.ui.on_authorization_denied(gui.U1_APP_NAME)  # show warning
+        self.ui.join_now_button.clicked()
+
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_connect_button_clicked_set_greyed(self):
+        """Clicking on 'connect' self is greyed."""
+        self.ui.connect_button.clicked()
+        self.assertTrue(self.ui.get_property('greyed'), 'Must be greyed.')
+
+    def test_connect_button_clicked_removes_warning(self):
+        """Clicking on 'connect' the warnings are removed."""
+        self.ui.on_authorization_denied(gui.U1_APP_NAME)  # show warning
+        self.ui.connect_button.clicked()
+
+        self.assertEqual(self.ui.warning_label.get_text(), '')
+
+    def test_on_credentials_not_found_unset_greyed(self):
+        """Callback 'on_credentials_not_found' unsets the 'greyed' prop."""
+        self.ui.connect_button.clicked()
+        self.ui.on_credentials_not_found(gui.U1_APP_NAME)
+
+        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
+
+    def test_on_credentials_error_unset_greyed(self):
+        """Callback 'on_credentials_error' unsets the 'greyed' prop."""
+        self.ui.connect_button.clicked()
+        self.ui.on_credentials_error(gui.U1_APP_NAME, {})
+
+        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
+
+    def test_on_authorization_denied_unset_greyed(self):
+        """Callback 'on_authorization_denied' unsets the 'greyed' prop."""
+        self.ui.connect_button.clicked()
+        self.ui.on_authorization_denied(gui.U1_APP_NAME)
+
+        self.assertFalse(self.ui.get_property('greyed'), 'Must not be greyed.')
+
+    def test_buttons_disabled_when_greyed(self):
+        """Buttons should be disabled when widget is greyed."""
+        self.ui.set_sensitive(True)
+        self.ui.set_property('greyed', True)
+
+        self.assertFalse(self.ui.join_now_button.is_sensitive())
+        self.assertFalse(self.ui.connect_button.is_sensitive())
+
+    def test_buttons_enabled_when_not_greyed(self):
+        """Buttons should be enabled when widget is not greyed."""
+        self.ui.set_sensitive(False)
+        self.ui.set_property('greyed', False)
+
+        self.assertTrue(self.ui.join_now_button.is_sensitive())
+        self.assertTrue(self.ui.connect_button.is_sensitive())