Merge lp:~ack/landscape-client/drop-ui into lp:~landscape/landscape-client/trunk

[Alberto Donato]

This removes landscape-client-ui and landscape-client-ui-install packages and drops all UI-related code.
We want to drop these packages starting from Xenial.

This removes landscape-client-ui and landscape-client-ui-install packages and drops all UI-related code.
We want to drop these packages starting from Xenial.

[Chris Glass (tribaal)]

Great, I love seeing so much red in a branch :)

I tested that this package still registers against hosted - and ran the tests.

+1

review: Approve

[Данило Шеган (danilo)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2012-09-18 08:03:43 +0000
+++ .bzrignore	2016-03-10 16:35:24 +0000
@@ -16,17 +16,10 @@
 debian/landscape-common.postrm.debhelper
 debian/landscape-common.prerm.debhelper
 debian/landscape-common.substvars
-debian/landscape-client-ui/
-debian/landscape-client-ui-install/
-debian/landscape-client-ui-install.debhelper.log
-debian/landscape-client-ui-install.substvars
-debian/landscape-client-ui.debhelper.log
-debian/landscape-client-ui.substvars
 man/landscape-client.1
 man/landscape-config.1
 man/landscape-message.1
 man/landscape-sysinfo.1
-smart-update/smart-update
 apt-update/apt-update
 docs
 tags

=== removed directory 'applications'
=== removed file 'applications/landscape-client-settings.desktop.in'
--- applications/landscape-client-settings.desktop.in	2015-07-20 10:00:42 +0000
+++ applications/landscape-client-settings.desktop.in	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-[Desktop Entry]
-_Name=Landscape Service
-_Comment=Landscape Management Service Preferences
-Exec=landscape-client-ui-install
-Icon=preferences-management-service
-Terminal=False
-Type=Application
-StartupNotify=true
-Categories=GNOME;GTK;Settings;X-GNOME-SystemSettings;X-GNOME-Settings-Panel;X-Unity-Settings-Panel;
-OnlyShowIn=GNOME;Unity;MATE;
-X-Unity-Settings-Panel=landscape
-X-GNOME-Settings-Panel=landscape
-X-Ubuntu-Gettext-Domain=landscape-client

=== removed file 'dbus-1/com.canonical.LandscapeClientRegistration.conf'
--- dbus-1/com.canonical.LandscapeClientRegistration.conf	2012-01-19 14:06:45 +0000
+++ dbus-1/com.canonical.LandscapeClientRegistration.conf	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
-"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
-<busconfig>
-  <type>system</type>
-  <policy user="root">
-    <allow own="com.canonical.LandscapeClientRegistration"/>
-    <allow send_destination="com.canonical.LandscapeClientRegistration"/>
-    <allow send_interface="com.canonical.LandscapeClientRegistration"/>
-  </policy>
-
-  <policy context="default">
-    <allow send_destination="com.canonical.LandscapeClientRegistration"/>
-    <allow send_interface="com.canonical.LandscapeClientRegistration"/>
-  </policy>
-</busconfig>

=== removed file 'dbus-1/com.canonical.LandscapeClientRegistration.service'
--- dbus-1/com.canonical.LandscapeClientRegistration.service	2012-01-19 14:06:45 +0000
+++ dbus-1/com.canonical.LandscapeClientRegistration.service	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-[D-BUS Service]
-Name=com.canonical.LandscapeClientRegistration
-Exec=/usr/bin/landscape-client-registration-mechanism
-User=root
\ No newline at end of file

=== removed file 'dbus-1/com.canonical.LandscapeClientSettings.conf'
--- dbus-1/com.canonical.LandscapeClientSettings.conf	2012-01-19 14:06:45 +0000
+++ dbus-1/com.canonical.LandscapeClientSettings.conf	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
-"http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
-<busconfig>
-  <type>system</type>
-  <policy user="root">
-    <allow own="com.canonical.LandscapeClientSettings"/>
-    <allow send_destination="com.canonical.LandscapeClientSettings"/>
-    <allow send_interface="com.canonical.LandscapeClientSettings"/>
-  </policy>
-
-  <policy context="default">
-    <allow send_destination="com.canonical.LandscapeClientSettings"/>
-    <allow send_interface="com.canonical.LandscapeClientSettings"/>
-  </policy>
-</busconfig>

=== removed file 'dbus-1/com.canonical.LandscapeClientSettings.service'
--- dbus-1/com.canonical.LandscapeClientSettings.service	2012-01-19 14:06:45 +0000
+++ dbus-1/com.canonical.LandscapeClientSettings.service	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-[D-BUS Service]
-Name=com.canonical.LandscapeClientSettings
-Exec=/usr/bin/landscape-client-settings-mechanism
-User=root
\ No newline at end of file

=== modified file 'debian/control'
--- debian/control	2014-11-20 20:47:08 +0000
+++ debian/control	2016-03-10 16:35:24 +0000
@@ -44,6 +44,8 @@
          python-twisted-web,
          python-pycurl,
          landscape-common (= ${binary:Version})
+Replaces: landscape-client-ui, landscape-client-ui-install
+Conflicts: landscape-client-ui, landscape-client-ui-install
 Suggests: ${extra:Suggests}
 Description: The Landscape administration system client
  Landscape is a web-based tool for managing Ubuntu systems. This
@@ -52,39 +54,3 @@
  .
  This package provides the Landscape client and requires a Landscape account.
 XB-Python-Version: ${python:Versions}
-
-Package: landscape-client-ui
-Architecture: any
-Depends: ${python:Depends}, ${misc:Depends},
-         landscape-client (= ${binary:Version}),
-         landscape-client-ui-install (= ${binary:Version}),
-         python-gi,
-         python-dbus,
-         policykit-1,
-         gir1.2-notify-0.7,
-         gir1.2-gtk-3.0
-# Added when we moved the /etc/dbus-1/system.d/landscape.conf file from -client to
-# -client-ui in r682. There is no accompaining "Breaks" because -client-ui requires
-# the exact same version of -client, which will trigger the upgrade
-# and avoid the case discussed in
-# http://www.debian.org/doc/debian-policy/footnotes.html#f53
-Replaces: landscape-client (<< 13.05.1+bzr682)
-Description: The Landscape administration system client - UI configuration
- Landscape is a web-based tool for managing Ubuntu systems.
- .
- This package provides the Landscape client configuration UI.
-XB-Python-Version: ${python:Versions}
-
-Package: landscape-client-ui-install
-Architecture: any
-Depends: ${python:Depends}, ${misc:Depends},
-         python-gi,
-         python-dbus,
-         policykit-1,
-         gir1.2-gtk-3.0,
-         python-aptdaemon.gtk3widgets
-Description: The Landscape administration system client - UI installer
- Landscape is a web-based tool for managing Ubuntu systems.
- .
- This package provides an automatic installer for landscape-client-ui.
-XB-Python-Version: ${python:Versions}

=== removed file 'debian/landscape-client-ui-install.install'
--- debian/landscape-client-ui-install.install	2012-03-22 18:43:44 +0000
+++ debian/landscape-client-ui-install.install	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-usr/bin/landscape-client-ui-install
-usr/share/applications/landscape-client-settings.desktop
-usr/share/icons/hicolor/scalable/apps/preferences-management-service.svg
-usr/share/locale

=== removed file 'debian/landscape-client-ui.install'
--- debian/landscape-client-ui.install	2013-05-16 09:15:13 +0000
+++ debian/landscape-client-ui.install	1970-01-01 00:00:00 +0000
@@ -1,10 +0,0 @@
-usr/bin/landscape-client-settings-mechanism
-usr/bin/landscape-client-registration-mechanism
-usr/bin/landscape-client-settings-ui
-usr/share/dbus-1/system-services/com.canonical.LandscapeClientSettings.service
-usr/share/dbus-1/system-services/com.canonical.LandscapeClientRegistration.service
-usr/share/polkit-1/actions/com.canonical.LandscapeClientSettings.policy
-etc/dbus-1/system.d/com.canonical.LandscapeClientSettings.conf
-etc/dbus-1/system.d/com.canonical.LandscapeClientRegistration.conf
-etc/dbus-1/system.d/landscape.conf
-usr/share/glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml

=== modified file 'debian/landscape-client.install'
--- debian/landscape-client.install	2014-07-17 18:54:12 +0000
+++ debian/landscape-client.install	2016-03-10 16:35:24 +0000
@@ -9,3 +9,4 @@
 usr/bin/landscape-release-upgrader
 usr/bin/landscape-dbus-proxy
 usr/lib/landscape
+etc/dbus-1/system.d/landscape.conf

=== modified file 'debian/rules'
--- debian/rules	2014-07-17 18:54:12 +0000
+++ debian/rules	2016-03-10 16:35:24 +0000
@@ -9,10 +9,6 @@
 endif
 
 dh_extra_flags = -plandscape-common -plandscape-client
-ifeq (,$(filter $(dist_release),hardy lucid natty oneiric))
-	# We want landscape-client-ui only from precise onward
-	dh_extra_flags += -plandscape-client-ui -plandscape-client-ui-install
-endif
 
 -include /usr/share/python/python.mk
 ifeq (,$(py_sitename))
@@ -49,7 +45,6 @@
 	rm -rf build
 	make -C apt-update clean
 	dh_clean
-	debconf-updatepo
 	sed -i -e "s/^DEBIAN_REVISION = .*/DEBIAN_REVISION = \"\"/g" landscape/__init__.py
 
 install: build

=== removed directory 'glib-2.0'
=== removed directory 'glib-2.0/schemas'
=== removed file 'glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml'
--- glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml	2012-03-20 14:39:42 +0000
+++ glib-2.0/schemas/com.canonical.landscape-client-settings.gschema.xml	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<schemalist>
-  <schema id="com.canonical.landscape-client-settings" path="/com/canonical/landscape-client-settings/">
-    <key type="s" name="management-type">
-      <default>"not"</default>
-      <summary>Whether the client settings UI currently set to a hosted client configuration, an LDS instance or no management service.</summary>
-    </key>
-    <key type="s" name="computer-title">
-      <default>""</default>
-      <summary>The title to register the machine with.</summary>
-    </key>
-    <key type="s" name="hosted-landscape-host">
-      <default>"landscape.canonical.com"</default>
-      <summary>The hostname of the Canonical hosted landscape system.</summary>
-    </key>
-    <key type="s" name="hosted-account-name">
-      <default>""</default>
-      <summary>An account name for use with the Canonical hosted landscape system.</summary>
-    </key>
-    <key type="s" name="hosted-password">
-      <default>""</default>
-      <summary>A password for use with the Canonical hosted landscape system</summary>
-    </key>
-    <key type="s" name="local-landscape-host">
-      <default>""</default>
-      <summary>The hostname of the local landscape system.</summary>
-    </key>
-    <key type="s" name="local-account-name">
-      <default>""</default>
-      <summary>An account name for use with the local landscape system.</summary>
-    </key>
-    <key type="s" name="local-password">
-      <default>""</default>
-      <summary>A password for use with the local landscape system</summary>
-    </key>
-  </schema>
-</schemalist>

=== removed directory 'icons'
=== removed file 'icons/preferences-management-service.svg'
--- icons/preferences-management-service.svg	2014-06-13 15:00:01 +0000
+++ icons/preferences-management-service.svg	1970-01-01 00:00:00 +0000
@@ -1,54 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Generator: Adobe Illustrator 16.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   version="1.1"
-   id="artwork"
-   x="0px"
-   y="0px"
-   width="34px"
-   height="34px"
-   viewBox="0 0 34 34"
-   enable-background="new 0 0 34 34"
-   xml:space="preserve"
-   inkscape:version="0.48.4 r9939"
-   sodipodi:docname="landscape_favicon_32px.svg"><metadata
-     id="metadata3887"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
-     id="defs3885" /><sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="640"
-     inkscape:window-height="480"
-     id="namedview3883"
-     showgrid="false"
-     inkscape:zoom="6.9411765"
-     inkscape:cx="17"
-     inkscape:cy="17"
-     inkscape:window-x="0"
-     inkscape:window-y="24"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="artwork" /><circle
-     fill="#DD4814"
-     cx="17"
-     cy="17.001"
-     r="16"
-     id="circle3877" /><g
-     id="g3879"><polygon
-       fill="#FFFFFF"
-       points="24.5,26.5 10.5,26.5 10.5,6.5 11.5,6.5 11.5,25.5 23.5,25.5 23.5,22.5 14.5,22.5 14.5,7.5    13.5,7.5 13.5,23.5 22.5,23.5 22.5,24.5 12.5,24.5 12.5,6.5 15.5,6.5 15.5,21.5 24.5,21.5  "
-       id="polygon3881" /></g></svg>
\ No newline at end of file

=== modified file 'landscape/package/facade.py'
--- landscape/package/facade.py	2015-04-15 13:16:20 +0000
+++ landscape/package/facade.py	2016-03-10 16:35:24 +0000
@@ -23,7 +23,6 @@
 from apt.progress.base import InstallProgress
 
 from landscape.lib.fs import append_file, create_file, read_file, touch_file
-from landscape.constants import UBUNTU_PATH
 from landscape.package.skeleton import build_skeleton_apt
 
 
@@ -592,23 +591,11 @@
         os.environ["APT_LISTCHANGES_FRONTEND"] = "none"
         os.environ["APT_LISTBUGS_FRONTEND"] = "none"
 
-    def _default_path_when_missing(self):
-        """
-        If no PATH is set in the environment, use the Ubuntu default PATH.
-
-        When the client is launched from the landscape-client-settings-ui the
-        PATH variable is incorrectly set, this method rectifies that.
-        """
-        # dpkg will fail if no path is set.
-        if "PATH" not in os.environ:
-            os.environ["PATH"] = UBUNTU_PATH
-
     def _setup_dpkg_for_changes(self):
         """
         Setup environment and apt options for successful package operations.
         """
         self._set_frontend_noninteractive()
-        self._default_path_when_missing()
         apt_pkg.config.clear("DPkg::options")
         apt_pkg.config.set("DPkg::options::", "--force-confold")
 

=== modified file 'landscape/package/tests/test_facade.py'
--- landscape/package/tests/test_facade.py	2015-04-15 13:16:20 +0000
+++ landscape/package/tests/test_facade.py	2016-03-10 16:35:24 +0000
@@ -8,7 +8,6 @@
 from aptsources.sourceslist import SourcesList
 from apt.cache import LockFailedException
 
-from landscape.constants import UBUNTU_PATH
 from landscape.lib.fs import read_file, create_file
 from landscape.package.facade import (
     TransactionError, DependencyError, ChannelError, AptFacade,
@@ -960,16 +959,6 @@
         self.assertEqual(["--force-confold"],
                          apt_pkg.config.value_list("DPkg::options"))
 
-    def test_perform_changes_with_no_path(self):
-        """
-        perform_changes() sets C{PATH} if it's not set already, since
-        dpkg requires it to be set.
-        """
-        del os.environ["PATH"]
-        self.facade.reload_channels()
-        self.assertEqual(self.facade.perform_changes(), None)
-        self.assertEqual(UBUNTU_PATH, os.environ["PATH"])
-
     def test_perform_changes_with_path(self):
         """
         perform_changes() doesn't set C{PATH} if it's set already.

=== removed directory 'landscape/ui'
=== removed file 'landscape/ui/__init__.py'
=== removed file 'landscape/ui/constants.py'
--- landscape/ui/constants.py	2012-02-28 11:52:56 +0000
+++ landscape/ui/constants.py	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-CANONICAL_MANAGED = "canonical"
-LOCAL_MANAGED = "LDS"
-NOT_MANAGED = "not"

=== removed directory 'landscape/ui/controller'
=== removed file 'landscape/ui/controller/__init__.py'
=== removed file 'landscape/ui/controller/app.py'
--- landscape/ui/controller/app.py	2012-03-23 10:12:34 +0000
+++ landscape/ui/controller/app.py	1970-01-01 00:00:00 +0000
@@ -1,91 +0,0 @@
-import sys
-
-from gettext import gettext as _
-
-from gi.repository import Gio, Gtk, Notify
-
-from landscape.ui.model.configuration.proxy import ConfigurationProxy
-from landscape.ui.model.configuration.state import ConfigurationModel
-from landscape.ui.model.configuration.uisettings import UISettings
-from landscape.ui.view.configuration import ClientSettingsDialog
-from landscape.ui.controller.configuration import ConfigController
-
-
-APPLICATION_ID = "com.canonical.landscape-client.settings.ui"
-NOTIFY_ID = "Landscape management service"
-
-
-class SettingsApplicationController(Gtk.Application):
-    """
-    Core application controller for the landscape settings application.
-    """
-
-    def __init__(self, args=[]):
-        super(SettingsApplicationController, self).__init__(
-            application_id=APPLICATION_ID)
-        self._args = args
-        self.connect("activate", self.setup_ui)
-
-    def get_config(self):
-        return ConfigurationProxy()
-
-    def get_uisettings(self):
-        return UISettings(Gio.Settings)
-
-    def on_notify(self, message):
-        notification = Notify.Notification.new(NOTIFY_ID, message,
-                                               "dialog-information")
-        notification.show()
-
-    def on_error(self, message):
-        notification = Notify.Notification.new(NOTIFY_ID, message,
-                                               "dialog-information")
-        notification.show()
-
-    def on_succeed(self, action=None):
-        if action:
-            message = action
-        else:
-            message = _("Success.")
-        notification = Notify.Notification.new(NOTIFY_ID, message,
-                                               "dialog-information")
-        notification.show()
-
-    def on_fail(self, action=None):
-        if action:
-            message = action
-        else:
-            message = _("Failure.")
-        notification = Notify.Notification.new(NOTIFY_ID, message,
-                                               "dialog-information")
-        notification.show()
-
-    def setup_ui(self, data=None, asynchronous=True):
-        """
-        L{setup_ui} wires the model to the L{ConfigurationController} and then
-        invokes the view with the controller.  When the dialog exits
-        appropriate termination is triggered.
-
-        @param data: the Gtk callback could pass this, but it is always None in
-        practice.
-        @param asynchronous: a parameter passed through to
-        L{ConfigurationController.exit}, it indicates whether the exit method
-        should be called asynchronously.  Is makes testing easier to use it
-        synchronously.
-        """
-        Notify.init(NOTIFY_ID)
-        config = self.get_config()
-        uisettings = self.get_uisettings()
-        model = ConfigurationModel(proxy=config, proxy_loadargs=self._args,
-                                   uisettings=uisettings)
-        controller = ConfigController(model)
-        if controller.load():
-            self.settings_dialog = ClientSettingsDialog(controller)
-            if self.settings_dialog.run() == Gtk.ResponseType.OK:
-                controller.persist(self.on_notify, self.on_error,
-                                   self.on_succeed, self.on_fail)
-            controller.exit(asynchronous=asynchronous)
-            self.settings_dialog.destroy()
-        else:
-            self.on_fail(action=_("Authentication failed"))
-            sys.stderr.write("Authentication failed.\n")

=== removed file 'landscape/ui/controller/configuration.py'
--- landscape/ui/controller/configuration.py	2012-03-23 09:39:56 +0000
+++ landscape/ui/controller/configuration.py	1970-01-01 00:00:00 +0000
@@ -1,122 +0,0 @@
-import logging
-
-from gettext import gettext as _
-
-from landscape.ui.constants import NOT_MANAGED, CANONICAL_MANAGED
-
-from landscape.ui.model.registration.proxy import RegistrationProxy
-from landscape.ui.model.configuration.state import StateError
-
-
-class ConfigControllerLockError(Exception):
-    pass
-
-
-class ConfigController(object):
-    """
-    L{ConfigContoller} defines actions to take against a configuration object,
-    providing starting values from the file, allowing them to be changed
-    transiently, reverted or committed.
-    """
-
-    DEFAULT_DEDICATED_ACCOUNT_NAME = "standalone"
-
-    def __init__(self, configuration):
-        self._observers = []
-        self._configuration = configuration
-        self._initialised = True
-
-    def __getattr__(self, name):
-        if name in self.__dict__:
-            return self.__dict__[name]
-        else:
-            return getattr(self._configuration, name)
-
-    def __setattr__(self, name, value):
-        # this test allows attributes to be set in the __init__ method
-        if not '_initialised' in self.__dict__:
-            return object.__setattr__(self, name, value)
-        if name in ConfigController.__dict__:
-            return object.__setattr__(self, name, value)
-        else:
-            try:
-                setattr(self._configuration, name, value)
-                self._configuration.modify()
-            except AttributeError:
-                return object.__setattr__(self, name, value)
-            else:
-                self._configuration.modify()
-
-    def load(self):
-        """
-        Load the initial data from the configuration.
-        """
-        return self._configuration.load_data()
-
-    def revert(self):
-        """
-        Revert settings to those the configuration object originally found.
-        """
-        try:
-            self._configuration.revert()
-        except StateError:
-            # We probably don't care.
-            logging.info("landscape-client-settings-ui reverted with no "
-                         "changes to revert.")
-
-    def persist(self, on_notify, on_error, on_succeed, on_fail):
-        """Persist settings via the configuration object."""
-        try:
-            self._configuration.persist()
-        except StateError:
-            # We probably don't care.
-            logging.info("landscape-client-settings-ui committed with no "
-                         "changes to commit.")
-        if self._configuration.management_type == NOT_MANAGED:
-            self.disable(on_notify, on_succeed, on_fail)
-        else:
-            self.register(on_notify, on_error, on_succeed, on_fail)
-
-    def register(self, notify_method, error_method, succeed_method,
-                 fail_method):
-        """
-        Perform registration using the L{RegistrationProxy}.
-        """
-
-        def registration_fail_wrapper():
-            fail_method(action=_("Registering client failed"))
-
-        def registration_succeed_wrapper():
-            succeed_method(action=_("Registering client was successful"))
-
-        registration = RegistrationProxy(
-            on_register_notify=notify_method,
-            on_register_error=error_method,
-            on_register_succeed=registration_succeed_wrapper,
-            on_register_fail=registration_fail_wrapper)
-        if self._configuration.management_type == CANONICAL_MANAGED:
-            notify_method(_("Attempting to register at %s") %
-                          self._configuration.hosted_landscape_host)
-        else:
-            notify_method(_("Attempting to register at %s") %
-                          self._configuration.local_landscape_host)
-        registration.register(self._configuration.get_config_filename())
-        registration.exit()
-
-    def disable(self, notify_method, succeed_method, fail_method):
-        """
-        Disable landscape client via the L{RegistrationProxy}.
-        """
-
-        def disabling_fail_wrapper():
-            fail_method(action=_("Disabling client failed"))
-
-        def disabling_succeed_wrapper():
-            succeed_method(action=_("Disabling client was successful"))
-
-        registration = RegistrationProxy(
-            on_disable_succeed=disabling_succeed_wrapper,
-            on_disable_fail=disabling_fail_wrapper)
-        notify_method(_("Attempting to disable landscape client."))
-        registration.disable()
-        registration.exit()

=== removed directory 'landscape/ui/controller/tests'
=== removed file 'landscape/ui/controller/tests/__init__.py'
=== removed file 'landscape/ui/controller/tests/test_app.py'
--- landscape/ui/controller/tests/test_app.py	2013-02-14 10:32:46 +0000
+++ landscape/ui/controller/tests/test_app.py	1970-01-01 00:00:00 +0000
@@ -1,135 +0,0 @@
-import sys
-
-from landscape.ui.tests.helpers import (
-    ConfigurationProxyHelper, dbus_test_should_skip, dbus_skip_message,
-    FakeGSettings)
-
-if not dbus_test_should_skip:
-    from gi.repository import Gtk
-    from landscape.ui.controller.app import SettingsApplicationController
-    from landscape.ui.controller.configuration import ConfigController
-    from landscape.ui.view.configuration import ClientSettingsDialog
-    from landscape.ui.model.configuration.uisettings import UISettings
-else:
-    SettingsApplicationController = object
-
-from landscape.tests.helpers import LandscapeTest
-
-
-class ConnectionRecordingSettingsApplicationController(
-    SettingsApplicationController):
-    _connections = set()
-    _connection_args = {}
-    _connection_kwargs = {}
-
-    def __init__(self, get_config=None, get_uisettings=None):
-        super(ConnectionRecordingSettingsApplicationController,
-              self).__init__()
-        if get_config:
-            self.get_config = get_config
-        if get_uisettings:
-            self.get_uisettings = get_uisettings
-
-    def _make_connection_name(self, signal, func):
-        return signal + ">" + func.__name__
-
-    def _record_connection(self, signal, func, *args, **kwargs):
-        connection_name = self._make_connection_name(signal, func)
-        self._connections.add(connection_name)
-        signal_connection_args = self._connection_args.get(
-            connection_name, [])
-        signal_connection_args.append(repr(args))
-        self._connection_args = signal_connection_args
-        signal_connection_kwargs = self._connection_kwargs.get(
-            connection_name, [])
-        signal_connection_kwargs.append(repr(kwargs))
-        self._connection_kwargs = signal_connection_kwargs
-
-    def is_connected(self, signal, func):
-        connection_name = self._make_connection_name(signal, func)
-        return self._connections.issuperset(set([connection_name]))
-
-    def connect(self, signal, func, *args, **kwargs):
-        self._record_connection(signal, func)
-
-
-class SettingsApplicationControllerInitTest(LandscapeTest):
-
-    def setUp(self):
-        super(SettingsApplicationControllerInitTest, self).setUp()
-
-    def test_init(self):
-        """
-        Test we connect activate to something useful on application
-        initialisation.
-        """
-        app = ConnectionRecordingSettingsApplicationController()
-        self.assertTrue(app.is_connected("activate", app.setup_ui))
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class SettingsApplicationControllerUISetupTest(LandscapeTest):
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = "\n".join(
-            ["[client]",
-             "data_path = %s" % sys.path[0],
-             "http_proxy = http://proxy.localdomain:3192",
-             "tags = a_tag",
-             "url = https://landscape.canonical.com/message-system",
-             "account_name = foo",
-             "registration_key = bar",
-             "computer_title = baz",
-             "https_proxy = https://proxy.localdomain:6192",
-             "ping_url = http://landscape.canonical.com/ping"])
-        self.default_data = {"management-type": "not",
-                             "computer-title": "",
-                             "hosted-landscape-host": "",
-                             "hosted-account-name": "",
-                             "hosted-password": "",
-                             "local-landscape-host": "",
-                             "local-account-name": "",
-                             "local-password": ""}
-        super(SettingsApplicationControllerUISetupTest, self).setUp()
-
-        def fake_run(obj):
-            """
-            Retard X11 mapping.
-            """
-            pass
-
-        self._real_run = Gtk.Dialog.run
-        Gtk.Dialog.run = fake_run
-
-        def get_config():
-            return self.proxy
-
-        def get_uisettings():
-            settings = FakeGSettings(data=self.default_data)
-            return UISettings(settings)
-
-        self.app = ConnectionRecordingSettingsApplicationController(
-            get_config=get_config, get_uisettings=get_uisettings)
-
-    def tearDown(self):
-        Gtk.Dialog.run = self._real_run
-        super(
-            SettingsApplicationControllerUISetupTest, self).tearDown()
-
-    def test_setup_ui(self):
-        """
-        Test that we correctly setup the L{ClientSettingsDialog} with
-        the config object and correct data
-        """
-        self.assertRaises(SystemExit, self.app.setup_ui, data=None,
-                          asynchronous=False)
-        self.assertIsInstance(self.app.settings_dialog, ClientSettingsDialog)
-        self.assertIsInstance(self.app.settings_dialog.controller,
-                              ConfigController)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed file 'landscape/ui/controller/tests/test_configuration.py'
--- landscape/ui/controller/tests/test_configuration.py	2013-02-14 10:32:46 +0000
+++ landscape/ui/controller/tests/test_configuration.py	1970-01-01 00:00:00 +0000
@@ -1,208 +0,0 @@
-from landscape.ui.tests.helpers import (
-    ConfigurationProxyHelper, dbus_test_should_skip, dbus_skip_message,
-    FakeGSettings)
-
-if not dbus_test_should_skip:
-    from landscape.ui.controller.configuration import ConfigController
-    import landscape.ui.model.configuration.state
-    from landscape.ui.model.configuration.state import (
-        ConfigurationModel, COMPUTER_TITLE)
-    from landscape.ui.model.configuration.uisettings import UISettings
-
-from landscape.tests.helpers import LandscapeTest
-
-
-class ConfigControllerTest(LandscapeTest):
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = "\n".join(
-            ["[client]",
-             "data_path = /var/lib/landscape/client/",
-             "http_proxy = http://proxy.localdomain:3192",
-             "tags = a_tag",
-             "url = https://landscape.canonical.com/message-system",
-             "account_name = foo",
-             "registration_key = bar",
-             "computer_title = baz",
-             "https_proxy = https://proxy.localdomain:6192",
-             "ping_url = http://landscape.canonical.com/ping"])
-
-        self.default_data = {"management-type": "canonical",
-                             "computer-title": "",
-                             "hosted-landscape-host": "",
-                             "hosted-account-name": "",
-                             "hosted-password": "",
-                             "local-landscape-host": "",
-                             "local-account-name": "",
-                             "local-password": ""}
-
-        super(ConfigControllerTest, self).setUp()
-        landscape.ui.model.configuration.state.DEFAULT_DATA[COMPUTER_TITLE] \
-            = "me.here.com"
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-
-        def disable(on_suceed, on_fail):
-            pass
-
-        def register(on_notify, on_error, on_succeed, on_fail):
-            pass
-
-        self.controller = ConfigController(model)
-        self.controller.disable = disable
-        self.controller.register = register
-        self.controller.load()
-
-    def test_init(self):
-        """
-        Test that when we create a controller it has initial state read in
-        directly from the configuration file.
-        """
-        self.controller.load()
-        self.assertEqual("baz", self.controller.computer_title)
-        self.assertTrue(self.controller.management_type)
-        self.assertEqual("landscape.canonical.com",
-                         self.controller.hosted_landscape_host)
-        self.assertEqual("foo", self.controller.hosted_account_name)
-        self.assertEqual("bar", self.controller.hosted_password)
-        self.assertEqual("", self.controller.local_landscape_host)
-        self.assertEqual("standalone", self.controller.local_account_name)
-        self.assertEqual("", self.controller.local_password)
-
-    def test_set_hosted_account_name(self):
-        """
-        Test that we can set the L{hosted_account_name} property.
-        """
-        self.controller.load()
-        self.assertEqual(self.controller.hosted_account_name, "foo")
-        self.controller.hosted_account_name = "shoe"
-        self.assertEqual(self.controller.hosted_account_name, "shoe")
-
-    def test_set_local_account_name(self):
-        """
-        Test that we can set the L{local_account_name} property.
-        """
-        self.controller.load()
-        self.assertEqual("standalone", self.controller.local_account_name)
-        self.controller.local_account_name = "shoe"
-        self.assertEqual(self.controller.local_account_name, "shoe")
-
-    def test_set_hosted_password(self):
-        """
-        Test that we can set the L{hosted_password} property.
-        """
-        self.controller.load()
-        self.assertEqual(self.controller.hosted_password, "bar")
-        self.controller.hosted_password = "nucker"
-        self.assertEqual(self.controller.hosted_password, "nucker")
-
-    def test_set_local_password(self):
-        """
-        Test that we can set the L{local_password} property.
-        """
-        self.controller.load()
-        self.assertEqual(self.controller.local_password, "")
-        self.controller.local_password = "nucker"
-        self.assertEqual(self.controller.local_password, "nucker")
-
-    def test_set_local_landscape_host(self):
-        """
-        Test that we can set the L{local_landscape_host} property.
-        """
-        self.controller.load()
-        self.assertEqual("", self.controller.local_landscape_host)
-        self.controller.local_landscape_host = "smelly.pants"
-        self.assertEqual(self.controller.local_landscape_host, "smelly.pants")
-
-    def test_revert(self):
-        """
-        Test that we can revert the controller to it's initial state.
-        """
-        self.controller.load()
-        self.assertEqual(self.controller.hosted_account_name, "foo")
-        self.controller.hosted_account_name = "Hildaborg"
-        self.assertEqual(self.controller.hosted_account_name, "Hildaborg")
-        self.controller.revert()
-        self.assertEqual(self.controller.hosted_account_name, "foo")
-
-    def test_is_modified(self):
-        """
-        Test that we can determine when something has been modified.
-        """
-        self.controller.load()
-        self.assertFalse(self.controller.is_modified)
-        self.controller.local_landscape_host = "bing.bang.a.bang"
-        self.assertTrue(self.controller.is_modified)
-        self.controller.revert()
-        self.assertFalse(self.controller.is_modified)
-        self.controller.account_name = "soldierBlue"
-        self.assertTrue(self.controller.is_modified)
-        self.controller.revert()
-        self.assertFalse(self.controller.is_modified)
-        self.controller.registration_key = "HesAnIndianCowboyInTheRodeo"
-        self.assertTrue(self.controller.is_modified)
-
-    def test_persist(self):
-        """
-        Test that we can write configuration settings back to the config file.
-        """
-        self.controller.load()
-        self.assertEqual("", self.controller.local_landscape_host)
-        self.controller.local_landscape_host = "landscape.localdomain"
-        self.assertEqual("landscape.localdomain",
-                         self.controller.local_landscape_host)
-        self.controller.persist(None, None, None, None)
-        self.assertEqual("landscape.localdomain",
-                         self.controller.local_landscape_host)
-        self.controller.local_landscape_host = "boo"
-        self.controller.revert()
-        self.assertEqual("landscape.localdomain",
-                         self.controller.local_landscape_host)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class EmptyConfigControllerTest(LandscapeTest):
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = ""
-        self.default_data = {"management-type": "not",
-                             "computer-title": "",
-                             "hosted-landscape-host": "",
-                             "hosted-account-name": "",
-                             "hosted-password": "",
-                             "local-landscape-host": "",
-                             "local-account-name": "",
-                             "local-password": ""}
-
-        super(EmptyConfigControllerTest, self).setUp()
-        landscape.ui.model.configuration.state.DEFAULT_DATA[COMPUTER_TITLE] \
-            = "me.here.com"
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.controller = ConfigController(model)
-        self.controller.load()
-
-    def test_defaulting(self):
-        """
-        Test we set the correct values when loading a blank configuration.
-        """
-        self.controller.load()
-        self.assertEqual("not", self.controller.management_type)
-        self.assertEqual("", self.controller.hosted_account_name)
-        self.assertEqual("", self.controller.hosted_password)
-        self.assertEqual("landscape.canonical.com",
-                         self.controller.hosted_landscape_host)
-        self.assertEqual("standalone", self.controller.local_account_name)
-        self.assertEqual("", self.controller.local_password)
-        self.assertEqual("me.here.com", self.controller.computer_title)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed directory 'landscape/ui/lib'
=== removed file 'landscape/ui/lib/__init__.py'
=== removed file 'landscape/ui/lib/polkit.py'
--- landscape/ui/lib/polkit.py	2012-03-13 14:58:54 +0000
+++ landscape/ui/lib/polkit.py	1970-01-01 00:00:00 +0000
@@ -1,102 +0,0 @@
-import dbus
-import dbus.service
-import dbus.glib
-
-from gi.repository import GObject
-
-
-POLICY_NAME = "com.canonical.LandscapeClientSettings.configure"
-
-
-class PolicyKitMechanism(dbus.service.Object):
-    """
-    L{PolicyKitMechanism} is a specialised L{dbus.service.Object} which
-    provides PolicyKit authorization checks for a provided DBus bus name and
-    object path.  Subclasses must therefore call l{__init__} here with their
-    object path, bus name and an error class to be raised when permission
-    escalation fails.
-
-    @type object_path: string
-    @param object_path: The object path to register the subclass with.
-    @type bus_name: dbus.service.BusName
-    @param bus_name: The L{BusName} to the register the subclass with.
-    @type permission_error: dbus.DBusException
-    @param permission_error: A L{dbus.DBusException} to be raised when
-        PolicyKit authorisation fails for the client.
-    """
-
-    def __init__(self, object_path, bus_name, permission_error,
-                 bypass=False, conn=None):
-        super(PolicyKitMechanism, self).__init__(
-            conn, object_path, bus_name)
-        self.permission_error = permission_error
-        self.dbus_info = None
-        self.polkit = None
-        self.bypass = bypass
-
-    def _get_polkit_authorization(self, pid, privilege):
-        """
-        Check that the process with id L{pid} is allowed, by policy to utilise
-        the L{privilege }.  If the class was initialised with L{bypass}=True
-        then just say it was authorised without checking (useful for testing).
-        """
-        if self.bypass:
-            return (True, None, "Bypass")
-        polkit = dbus.Interface(dbus.SystemBus().get_object(
-                'org.freedesktop.PolicyKit1',
-                '/org/freedesktop/PolicyKit1/Authority', False),
-                'org.freedesktop.PolicyKit1.Authority')
-        subject = ('unix-process',
-                   {'pid': dbus.UInt32(pid, variant_level=1),
-                    'start-time': dbus.UInt64(0, variant_level=1)})
-        action_id = privilege
-        details = {"": ""}  # <- empty strings allow type inference
-        flags = dbus.UInt32(1)
-        cancellation_id = ""
-        return polkit.CheckAuthorization(
-            subject,
-            action_id,
-            details,
-            flags,
-            cancellation_id,
-            timeout=15)
-
-    def _get_peer_pid(self, sender, conn):
-        """
-        Get the process ID of the L{sender}.
-        """
-        if self.dbus_info is None:
-            self.dbus_info = dbus.Interface(
-                conn.get_object('org.freedesktop.DBus',
-                '/org/freedesktop/DBus/Bus', False), 'org.freedesktop.DBus')
-        return self.dbus_info.GetConnectionUnixProcessID(sender)
-
-    def _is_local_call(self, sender, conn):
-        """
-        Check if this is a local call, implying it is within a secure context.
-        """
-        return (sender is None and conn is None)
-
-    def _is_allowed_by_policy(self, sender, conn, privilege):
-        """
-        Check if we are already in a secure context, and if not check if the
-        policy associated with L{privilege} both exists and allows the peer to
-        utilise it.  As a side effect, if escalation of privileges is required
-        then this will occur and a challenge will be generated if needs be.
-        """
-        if self._is_local_call(sender, conn):
-            return True
-        peer_pid = self._get_peer_pid(sender, conn)
-        (is_auth, _, details) = self._get_polkit_authorization(peer_pid,
-                                                               privilege)
-        if not is_auth:
-            raise self.permission_error(privilege)
-        return True
-
-
-def listen():
-    """
-    Invoke a L{gobject.MainLoop} to process incoming DBus events.
-    """
-    mainloop = GObject.MainLoop()
-    mainloop.run()

=== removed directory 'landscape/ui/model'
=== removed file 'landscape/ui/model/__init__.py'
=== removed directory 'landscape/ui/model/configuration'
=== removed file 'landscape/ui/model/configuration/__init__.py'
=== removed file 'landscape/ui/model/configuration/mechanism.py'
--- landscape/ui/model/configuration/mechanism.py	2012-03-15 17:07:33 +0000
+++ landscape/ui/model/configuration/mechanism.py	1970-01-01 00:00:00 +0000
@@ -1,113 +0,0 @@
-import sys
-
-import dbus
-import dbus.service
-
-from landscape.ui.lib.polkit import PolicyKitMechanism, POLICY_NAME
-
-
-SERVICE_NAME = "com.canonical.LandscapeClientSettings"
-INTERFACE_NAME = "com.canonical.LandscapeClientSettings.ConfigurationInterface"
-OBJECT_PATH = "/com/canonical/LandscapeClientSettings/ConfigurationInterface"
-
-
-class PermissionDeniedByPolicy(dbus.DBusException):
-    _dbus_error_name = \
-        "com.canonical.LandscapeClientSettings.PermissionDeniedByPolicy"
-
-
-class ConfigurationMechanism(PolicyKitMechanism):
-    """
-    L{ConfigurationMechanism} provides access to the
-    L{LandscapeSetupConfiguration} object via DBus with access control
-    implemented via PolicyKit policy.  The use of DBus results from the use of
-    PolicyKit, not the other way around, and is done that way because that is
-    considered to be the Right Thing for Ubuntu Desktop circa January 2012.
-    """
-
-    def __init__(self, config, bus_name, bypass=False, conn=None):
-        super(ConfigurationMechanism, self).__init__(
-            OBJECT_PATH, bus_name, PermissionDeniedByPolicy,
-            bypass=bypass, conn=conn)
-        self._config = config
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="as",
-                         out_signature="",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def load(self, arglist, sender=None, conn=None):
-        if self._is_allowed_by_policy(sender, conn, POLICY_NAME):
-            if len(arglist) > 0:
-                self._config.load(arglist.split(chr(0x1e)))
-            else:
-                self._config.load([])
-        return
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="", out_signature="",
-                         sender_keyword="sender", connection_keyword="conn")
-    def reload(self, sender=None, conn=None):
-        if self._is_allowed_by_policy(sender, conn, POLICY_NAME):
-            self._config.reload()
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="", out_signature="",
-                         sender_keyword="sender", connection_keyword="conn")
-    def write(self, sender=None, conn=None):
-        if self._is_allowed_by_policy(sender, conn, POLICY_NAME):
-            self._config.write()
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="",
-                         out_signature="s",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def get_config_filename(self, sender=None, conn=None):
-        return self._config.get_config_filename()
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="s",
-                         out_signature="s",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def get(self, name, sender=None, conn=None):
-        """
-        Return the configuration option value associated with L{name} from the
-        L{LandscapeSetupConfiguration}.
-        """
-        if self._is_allowed_by_policy(sender, conn, POLICY_NAME):
-            try:
-                value = self._config.get(name)
-            except AttributeError:
-                return ""
-            if value is None:
-                return ""
-            return str(value)
-        return ""
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="ss",
-                         out_signature="",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def set(self, name, value, sender=None, conn=None):
-        """
-        Set the configuration option associated with L{name} to L{value} in the
-        L{LandscapeSetupConfiguration}.
-        """
-        if self._is_allowed_by_policy(sender, conn, POLICY_NAME):
-            # Underlying _config does not support unicode so convert to ascii
-            value = unicode(value).encode("ascii", errors="replace")
-            setattr(self._config, name, value)
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="",
-                         out_signature="",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def exit(self, sender=None, conn=None):
-        """
-        Exit this process.
-        """
-        sys.exit(0)

=== removed file 'landscape/ui/model/configuration/proxy.py'
--- landscape/ui/model/configuration/proxy.py	2012-05-15 17:30:38 +0000
+++ landscape/ui/model/configuration/proxy.py	1970-01-01 00:00:00 +0000
@@ -1,110 +0,0 @@
-"""
-This module contains a class, L{ConfigurationProxy} which pretends to be a
-L{landscape.configuration.LandscapeSetupConfiguration} but actually directs
-its calls via DBus to the L{ConfigurationMechanism}.
-"""
-
-import dbus
-
-from landscape.ui.model.configuration.mechanism import (
-    SERVICE_NAME, INTERFACE_NAME, OBJECT_PATH)
-from landscape.configuration import LandscapeSetupConfiguration
-
-
-class ConfigurationProxy(object):
-    """
-    L{ConfigurationProxy} attempts to be a drop-in replacement for
-    L{LandscapeSetupConfiguration} allowing applications run by user accounts
-    with the correct rights (as defined by a PolicyKit policy file) to interact
-    with the landscape client configuration via a DBus service.  This is the
-    RightThing(TM) for PolicyKit and therefore for GNOME/Unity.
-
-    The canonical case for this is L{landscape-client-settings-ui}.
-    """
-
-    def __init__(self, bus=None, interface=None, loadargs=[]):
-        self._loadargs = loadargs
-        if bus is None:
-            self._bus = dbus.SystemBus()
-        else:
-            self._bus = bus
-        if interface is None:
-            remote_object = self._bus.get_object(SERVICE_NAME, OBJECT_PATH)
-            self._interface = dbus.Interface(remote_object, INTERFACE_NAME)
-        else:
-            self._interface = interface
-
-    def load(self, arglist):
-        if arglist is None:
-            arglist = self._loadargs
-        if len(arglist) == 0:
-            al = ""
-        else:
-            al = chr(0x1e).join(arglist)
-        try:
-            self._interface.load(al)
-        except dbus.DBusException, e:
-            error_name = e.get_dbus_name()
-            if error_name not in ("com.canonical.LandscapeClientSettings."
-                                  "PermissionDeniedByPolicy",
-                                  "org.freedesktop.DBus.Error.NoReply"):
-                raise
-            return False
-        return True
-    load.__doc__ = LandscapeSetupConfiguration.load.__doc__
-
-    def reload(self):
-        self._interface.reload()
-    reload.__doc__ = LandscapeSetupConfiguration.reload.__doc__
-
-    def write(self):
-        self._interface.write()
-    write.__doc__ = LandscapeSetupConfiguration.write.__doc__
-
-    def get_config_filename(self):
-        return self._interface.get_config_filename()
-    get_config_filename.__doc__ = \
-        LandscapeSetupConfiguration.get_config_filename.__doc__
-
-    def exit(self, asynchronous=True):
-        """
-        Cause the mechanism to exit.
-        """
-        def on_reply():
-            """
-            This will never get called because we call L{sys.exit} inside the
-            mechanism.
-            """
-
-        def on_error():
-            """
-            This will always be called, this allows us to supress the
-            L{NoReply} error from DBus when we terminate the mechanism.
-            """
-
-        if asynchronous:
-            self._interface.exit(reply_handler=on_reply,
-                                 error_handler=on_error)
-        else:
-            self._interface.exit()
-
-    def _delegate_to_interface(field):
-
-        def get(self):
-            return self._interface.get(field)
-
-        def set(self, value):
-            self._interface.set(field, value)
-
-        return get, set
-
-    account_name = property(*_delegate_to_interface("account_name"))
-    computer_title = property(*_delegate_to_interface("computer_title"))
-    data_path = property(*_delegate_to_interface("data_path"))
-    http_proxy = property(*_delegate_to_interface("http_proxy"))
-    https_proxy = property(*_delegate_to_interface("https_proxy"))
-    ping_url = property(*_delegate_to_interface("ping_url"))
-    registration_key = property(
-        *_delegate_to_interface("registration_key"))
-    tags = property(*_delegate_to_interface("tags"))
-    url = property(*_delegate_to_interface("url"))

=== removed file 'landscape/ui/model/configuration/state.py'
--- landscape/ui/model/configuration/state.py	2012-05-15 17:30:38 +0000
+++ landscape/ui/model/configuration/state.py	1970-01-01 00:00:00 +0000
@@ -1,586 +0,0 @@
-import copy
-
-from landscape.lib.network import get_fqdn
-
-from landscape.ui.constants import CANONICAL_MANAGED, NOT_MANAGED
-from landscape.ui.model.configuration.proxy import ConfigurationProxy
-
-
-HOSTED_LANDSCAPE_HOST = "landscape.canonical.com"
-LOCAL_LANDSCAPE_HOST = ""
-
-HOSTED_ACCOUNT_NAME = ""
-LOCAL_ACCOUNT_NAME = "standalone"
-
-HOSTED_PASSWORD = ""
-LOCAL_PASSWORD = ""
-
-HOSTED = "hosted"
-LOCAL = "local"
-MANAGEMENT_TYPE = "management-type"
-COMPUTER_TITLE = "computer-title"
-LANDSCAPE_HOST = "landscape-host"
-ACCOUNT_NAME = "account-name"
-PASSWORD = "password"
-
-
-DEFAULT_DATA = {
-    MANAGEMENT_TYPE: NOT_MANAGED,
-    COMPUTER_TITLE: get_fqdn(),
-    HOSTED: {
-        LANDSCAPE_HOST: HOSTED_LANDSCAPE_HOST,
-        ACCOUNT_NAME: HOSTED_ACCOUNT_NAME,
-        PASSWORD: HOSTED_PASSWORD},
-    LOCAL: {
-        LANDSCAPE_HOST: LOCAL_LANDSCAPE_HOST,
-        ACCOUNT_NAME: LOCAL_ACCOUNT_NAME,
-        PASSWORD: LOCAL_PASSWORD}}
-
-
-def derive_server_host_name_from_url(url):
-    """
-    Extract the hostname part from a URL.
-    """
-    try:
-        without_protocol = url[url.index("://") + 3:]
-    except ValueError:
-        without_protocol = url
-    try:
-        return without_protocol[:without_protocol.index("/")]
-    except ValueError:
-        return without_protocol
-
-
-def derive_url_from_host_name(host_name):
-    """
-    Extrapolate a url from a host name.
-    """
-    #Reuse this code to make sure it's a proper host name
-    host_name = derive_server_host_name_from_url(host_name)
-    return "https://" + host_name + "/message-system"
-
-
-def derive_ping_url_from_host_name(host_name):
-    """
-    Extrapolate a ping_url from a host name.
-    """
-    #Reuse this code to make sure it's a proper host name
-    host_name = derive_server_host_name_from_url(host_name)
-    return "http://" + host_name + "/ping"
-
-
-class StateError(Exception):
-    """
-    An exception that is raised when there is an error relating to the current
-    state.
-    """
-
-
-class TransitionError(Exception):
-    """
-    An L{Exception} that is raised when a valid transition between states fails
-    for some non state related reason.  For example, this error is raised when
-    the user does not have the privilege of reading the configuration file,
-    this causes the transition from L{VirginState} to L{InitialisedState} to
-    fail but not because that transition from one state to another was not
-    permitted, but rather the transition encountered an error.
-    """
-
-
-class ConfigurationState(object):
-    """
-    Base class for states used in the L{ConfigurationModel}.
-    """
-    def __init__(self, data, proxy, uisettings):
-        self._data = copy.deepcopy(data)
-        self._proxy = proxy
-        self._uisettings = uisettings
-
-    def get_config_filename(self):
-        return self._proxy.get_config_filename()
-
-    def get(self, *args):
-        """
-        Retrieve only valid values from two level dictionary based tree.
-
-        This mainly served to pick up programming errors and could easily be
-        replaced with a simpler scheme.
-        """
-        arglen = len(args)
-        if arglen > 2 or arglen == 0:
-            raise TypeError(
-                "get() takes either 1 or 2 keys (%d given)" % arglen)
-        if arglen == 2:  # We're looking for a leaf on a branch
-            sub_dict = None
-            if args[0] in [HOSTED, LOCAL]:
-                sub_dict = self._data.get(args[0], {})
-            sub_dict = self._data[args[0]]
-            if not isinstance(sub_dict, dict):
-                raise KeyError(
-                    "Compound key [%s][%s] is invalid. The data type " +
-                    "returned from the first index was %s." %
-                    sub_dict.__class__.__name__)
-            return sub_dict.get(args[1], None)
-        else:
-            if args[0] in (MANAGEMENT_TYPE, COMPUTER_TITLE):
-                return self._data.get(args[0], None)
-            else:
-                raise KeyError("Key [%s] is invalid. " % args[0])
-
-    def set(self, *args):
-        """
-        Set only valid values from two level dictionary based tree.
-
-        This mainly served to pick up programming errors and could easily be
-        replaced with a simpler scheme.
-        """
-        arglen = len(args)
-        if arglen < 2 or arglen > 3:
-            raise TypeError("set() takes either 1 or 2 keys and exactly 1 " +
-                            "value (%d arguments given)" % arglen)
-        if arglen == 2:  # We're setting a leaf attached to the root
-            self._data[args[0]] = args[1]
-        else:  # We're setting a leaf on a branch
-            sub_dict = None
-            if args[0] in [HOSTED, LOCAL]:
-                sub_dict = self._data.get(args[0], {})
-            if not isinstance(sub_dict, dict):
-                raise KeyError("Compound key [%s][%s] is invalid. The data " +
-                               "type returned from the first index was %s."
-                               % sub_dict.__class__.__name__)
-            sub_dict[args[1]] = args[2]
-            self._data[args[0]] = sub_dict
-
-    def load_data(self, asynchronous=True, exit_method=None):
-        raise NotImplementedError
-
-    def modify(self):
-        raise NotImplementedError
-
-    def revert(self):
-        raise NotImplementedError
-
-    def persist(self):
-        raise NotImplementedError
-
-    def exit(self, asynchronous=True, exit_method=None):
-        return ExitedState(self._data, self._proxy, self._uisettings,
-                           asynchronous=asynchronous, exit_method=exit_method)
-
-
-class Helper(object):
-    """
-    Base class for all state transition helpers.
-
-    It is assumed that the Helper classes are "friends" of the
-    L{ConfigurationState} classes and can have some knowledge of their
-    internals.  They shouldn't be visible to users of the
-    L{ConfigurationState}s and in general we should avoid seeing the
-    L{ConfigurationState}'s _data attribute outside this module.
-    """
-
-    def __init__(self, state):
-        self._state = state
-
-
-class ModifiableHelper(Helper):
-    """
-    Allow a L{ConfigurationState}s to be modified.
-    """
-
-    def modify(self):
-        return ModifiedState(self._state._data, self._state._proxy,
-                             self._state._uisettings)
-
-
-class UnloadableHelper(Helper):
-    """
-    Disallow loading of data into a L{ConfigurationModel}.
-    """
-
-    def load_data(self, asynchronous=True, exit_method=None):
-        raise StateError("A ConfiguratiomModel in a " +
-                         self.__class__.__name__ +
-                         " cannot be transitioned via load_data()")
-
-
-class UnmodifiableHelper(Helper):
-    """
-    Disallow modification of a L{ConfigurationState}.
-    """
-
-    def modify(self):
-        raise StateError("A ConfigurationModel in " +
-                         self.__class__.__name__ +
-                         " cannot transition via modify()")
-
-
-class RevertableHelper(Helper):
-    """
-    Allow reverting of a L{ConfigurationModel}.
-    """
-
-    def revert(self):
-        return InitialisedState(self._state._data, self._state._proxy,
-                                self._state._uisettings)
-
-
-class UnrevertableHelper(Helper):
-    """
-    Disallow reverting of a L{ConfigurationModel}.
-    """
-
-    def revert(self):
-        raise StateError("A ConfigurationModel in " +
-                         self.__class__.__name__ +
-                         " cannot transition via revert()")
-
-
-class PersistableHelper(Helper):
-    """
-    Allow a L{ConfigurationModel} to persist.
-    """
-
-    def _save_to_uisettings(self):
-        """
-        Persist full content to the L{UISettings} object.
-        """
-        self._state._uisettings.set_management_type(
-            self._state.get(MANAGEMENT_TYPE))
-        self._state._uisettings.set_computer_title(
-            self._state.get(COMPUTER_TITLE))
-        self._state._uisettings.set_hosted_account_name(
-            self._state.get(HOSTED, ACCOUNT_NAME))
-        self._state._uisettings.set_hosted_password(
-            self._state.get(HOSTED, PASSWORD))
-        self._state._uisettings.set_local_landscape_host(
-            self._state.get(LOCAL, LANDSCAPE_HOST))
-        self._state._uisettings.set_local_account_name(
-            self._state.get(LOCAL, ACCOUNT_NAME))
-        self._state._uisettings.set_local_password(
-            self._state.get(LOCAL, PASSWORD))
-
-    def _save_to_config(self):
-        """
-        Persist the subset of the data we want to make live to the actual
-        configuration file.
-        """
-        hosted = self._state.get(MANAGEMENT_TYPE)
-        if hosted is NOT_MANAGED:
-            pass
-        else:
-            if hosted == CANONICAL_MANAGED:
-                first_key = HOSTED
-            else:
-                first_key = LOCAL
-            self._state._proxy.url = derive_url_from_host_name(
-                self._state.get(first_key, LANDSCAPE_HOST))
-            self._state._proxy.ping_url = derive_ping_url_from_host_name(
-                self._state.get(first_key, LANDSCAPE_HOST))
-            self._state._proxy.account_name = self._state.get(
-                first_key, ACCOUNT_NAME)
-            self._state._proxy.registration_key = self._state.get(
-                first_key, PASSWORD)
-            self._state._proxy.computer_title = self._state.get(COMPUTER_TITLE)
-            self._state._proxy.write()
-
-    def persist(self):
-        self._save_to_uisettings()
-        self._save_to_config()
-        return InitialisedState(self._state._data, self._state._proxy,
-                                self._state._uisettings)
-
-
-class UnpersistableHelper(Helper):
-    """
-    Disallow persistence of a L{ConfigurationModel}.
-    """
-
-    def persist(self):
-        raise StateError("A ConfiguratonModel in " +
-                         self.__class__.__name__ +
-                         " cannot be transitioned via persist().")
-
-
-class ExitedState(ConfigurationState):
-    """
-    The terminal state of L{ConfigurationModel}, you can't do anything further
-    once this state is reached.
-    """
-    def __init__(self, data, proxy, uisettings, exit_method=None,
-                 asynchronous=True):
-        super(ExitedState, self).__init__(None, None, None)
-        if callable(exit_method):
-            exit_method()
-        else:
-            proxy.exit(asynchronous=asynchronous)
-        self._unloadable_helper = UnloadableHelper(self)
-        self._unmodifiable_helper = UnmodifiableHelper(self)
-        self._unrevertable_helper = UnrevertableHelper(self)
-        self._unpersistable_helper = UnpersistableHelper(self)
-
-    def load_data(self, asynchronous=True, exit_method=None):
-        return self._unloadable_helper.load_data(asynchronous=asynchronous,
-                                                 exit_method=exit_method)
-
-    def modify(self):
-        return self._unmodifiable_helper.modify()
-
-    def revert(self):
-        return self._unrevertable_helper.revert()
-
-    def persist(self):
-        return self._unpersistable_helper.persist()
-
-    def exit(self, asynchronous=True):
-        return self
-
-
-class ModifiedState(ConfigurationState):
-    """
-    The state of a L{ConfigurationModel} whenever the user has modified some
-    data but hasn't yet L{persist}ed or L{revert}ed.
-    """
-
-    def __init__(self, data, proxy, uisettings):
-        super(ModifiedState, self).__init__(data, proxy, uisettings)
-        self._modifiable_helper = ModifiableHelper(self)
-        self._revertable_helper = RevertableHelper(self)
-        self._persistable_helper = PersistableHelper(self)
-
-    def modify(self):
-        return self._modifiable_helper.modify()
-
-    def revert(self):
-        return self._revertable_helper.revert()
-
-    def persist(self):
-        return self._persistable_helper.persist()
-
-
-class InitialisedState(ConfigurationState):
-    """
-    The state of the L{ConfigurationModel} as initially presented to the
-    user. Baseline data should have been loaded from the real configuration
-    data, any persisted user data should be loaded into blank values and
-    finally defaults should be applied where necessary.
-    """
-
-    def __init__(self, data, proxy, uisettings):
-        super(InitialisedState, self).__init__(data, proxy, uisettings)
-        self._modifiable_helper = ModifiableHelper(self)
-        self._unrevertable_helper = UnrevertableHelper(self)
-        self._unpersistable_helper = UnpersistableHelper(self)
-        self._load_uisettings_data()
-        if not self._load_live_data():
-            raise TransitionError("Authentication Failure")
-
-    def _load_uisettings_data(self):
-        """
-        Load the complete set of dialog data from L{UISettings}.
-        """
-        hosted = self._uisettings.get_management_type()
-        self.set(MANAGEMENT_TYPE, hosted)
-        computer_title = self._uisettings.get_computer_title()
-        if computer_title:
-            self.set(COMPUTER_TITLE, computer_title)
-        self.set(HOSTED, ACCOUNT_NAME,
-                 self._uisettings.get_hosted_account_name())
-        self.set(HOSTED, PASSWORD, self._uisettings.get_hosted_password())
-        self.set(LOCAL, LANDSCAPE_HOST,
-                 self._uisettings.get_local_landscape_host())
-        local_account_name = self._uisettings.get_local_account_name()
-        if local_account_name:
-            self.set(LOCAL, ACCOUNT_NAME, local_account_name)
-        self.set(LOCAL, PASSWORD, self._uisettings.get_local_password())
-
-    def _load_live_data(self):
-        """
-        Load the current live subset of data from the configuration file.
-        """
-        if self._proxy.load(None):
-            computer_title = self._proxy.computer_title
-            if computer_title:
-                self.set(COMPUTER_TITLE, computer_title)
-            url = self._proxy.url
-            if url.find(HOSTED_LANDSCAPE_HOST) > -1:
-                self.set(HOSTED, ACCOUNT_NAME, self._proxy.account_name)
-                self.set(HOSTED, PASSWORD, self._proxy.registration_key)
-            else:
-                self.set(LOCAL, LANDSCAPE_HOST,
-                         derive_server_host_name_from_url(url))
-                if self._proxy.account_name != "":
-                    self.set(LOCAL, ACCOUNT_NAME, self._proxy.account_name)
-            return True
-        else:
-            return False
-
-    def load_data(self, asynchronous=True, exit_method=None):
-        return self
-
-    def modify(self):
-        return self._modifiable_helper.modify()
-
-    def revert(self):
-        return self._unrevertable_helper.revert()
-
-    def persist(self):
-        return self._unpersistable_helper.persist()
-
-
-class VirginState(ConfigurationState):
-    """
-    The state of the L{ConfigurationModel} before any actions have been taken
-    upon it.
-    """
-
-    def __init__(self, proxy, uisettings):
-        super(VirginState, self).__init__(DEFAULT_DATA, proxy, uisettings)
-        self._unmodifiable_helper = UnmodifiableHelper(self)
-        self._unrevertable_helper = UnrevertableHelper(self)
-        self._unpersistable_helper = UnpersistableHelper(self)
-
-    def load_data(self, asynchronous=True, exit_method=None):
-        try:
-            return InitialisedState(self._data, self._proxy, self._uisettings)
-        except TransitionError:
-            return ExitedState(self._data, self._proxy, self._uisettings,
-                               asynchronous=asynchronous,
-                               exit_method=exit_method)
-
-    def modify(self):
-        return self._unmodifiable_helper.modify()
-
-    def revert(self):
-        return self._unrevertable_helper.revert()
-
-    def persist(self):
-        return self._unpersistable_helper.persist()
-
-
-class ConfigurationModel(object):
-    """
-    L{ConfigurationModel} presents a model of configuration as the UI
-    requirements describe it (separate values for the Hosted and Local
-    configurations) as opposed to the real structure of the configuration
-    file.  This is intended to achieve the following:
-
-       1. Allow the expected behaviour in the UI without changing the live
-          config file.
-       2. Supersede the overly complex logic in the controller layer with a
-          cleaner state pattern.
-
-    The allowable state transitions are:
-
-       VirginState      --(load_data)--> InitialisedState
-       VirginState      --(load_data)--> ExitedState
-       VirginState      --(exit)-------> ExitedState
-       InitialisedState --(modify)-----> ModifiedState
-       InitialisedState --(exit)-------> ExitedState
-       ModifiedState    --(revert)-----> InitialisedState
-       ModifiedState    --(modify)-----> ModifiedState
-       ModifiedState    --(persist)----> InitialisedState
-       ModifiedState    --(exit)-------> ExitedState
-    """
-
-    def __init__(self, proxy=None, proxy_loadargs=[], uisettings=None):
-        if not proxy:
-            proxy = ConfigurationProxy(loadargs=proxy_loadargs)
-        self._current_state = VirginState(proxy, uisettings)
-
-    def get_state(self):
-        """
-        Expose the underlying L{ConfigurationState}, for testing purposes.
-        """
-        return self._current_state
-
-    def load_data(self, asynchronous=True, exit_method=None):
-        self._current_state = self._current_state.load_data(
-            asynchronous=asynchronous, exit_method=exit_method)
-        return isinstance(self._current_state, InitialisedState)
-
-    def modify(self):
-        self._current_state = self._current_state.modify()
-
-    def revert(self):
-        self._current_state = self._current_state.revert()
-
-    def persist(self):
-        self._current_state = self._current_state.persist()
-
-    def _get_management_type(self):
-        return self._current_state.get(MANAGEMENT_TYPE)
-
-    def _set_management_type(self, value):
-        self._current_state.set(MANAGEMENT_TYPE, value)
-
-    management_type = property(_get_management_type, _set_management_type)
-
-    def _get_computer_title(self):
-        return self._current_state.get(COMPUTER_TITLE)
-
-    def _set_computer_title(self, value):
-        self._current_state.set(COMPUTER_TITLE, value)
-
-    computer_title = property(_get_computer_title, _set_computer_title)
-
-    def _get_hosted_landscape_host(self):
-        return self._current_state.get(HOSTED, LANDSCAPE_HOST)
-
-    hosted_landscape_host = property(_get_hosted_landscape_host)
-
-    def _get_local_landscape_host(self):
-        return self._current_state.get(LOCAL, LANDSCAPE_HOST)
-
-    def _set_local_landscape_host(self, value):
-        self._current_state.set(LOCAL, LANDSCAPE_HOST, value)
-
-    local_landscape_host = property(_get_local_landscape_host,
-                                    _set_local_landscape_host)
-
-    def _get_hosted_account_name(self):
-        return self._current_state.get(HOSTED, ACCOUNT_NAME)
-
-    def _set_hosted_account_name(self, value):
-        self._current_state.set(HOSTED, ACCOUNT_NAME, value)
-
-    hosted_account_name = property(_get_hosted_account_name,
-                                   _set_hosted_account_name)
-
-    def _get_local_account_name(self):
-        return self._current_state.get(LOCAL, ACCOUNT_NAME)
-
-    def _set_local_account_name(self, value):
-        self._current_state.set(LOCAL, ACCOUNT_NAME, value)
-
-    local_account_name = property(_get_local_account_name,
-                                   _set_local_account_name)
-
-    def _get_hosted_password(self):
-        return self._current_state.get(HOSTED, PASSWORD)
-
-    def _set_hosted_password(self, value):
-        self._current_state.set(HOSTED, PASSWORD, value)
-
-    hosted_password = property(_get_hosted_password,
-                               _set_hosted_password)
-
-    def _get_local_password(self):
-        return self._current_state.get(LOCAL, PASSWORD)
-
-    def _set_local_password(self, value):
-        self._current_state.set(LOCAL, PASSWORD, value)
-
-    local_password = property(_get_local_password,
-                              _set_local_password)
-
-    def _get_is_modified(self):
-        return isinstance(self.get_state(), ModifiedState)
-
-    is_modified = property(_get_is_modified)
-
-    def get_config_filename(self):
-        return self._current_state.get_config_filename()
-
-    def exit(self, asynchronous=True):
-        self._current_state.exit(asynchronous=asynchronous)

=== removed directory 'landscape/ui/model/configuration/tests'
=== removed file 'landscape/ui/model/configuration/tests/__init__.py'
=== removed file 'landscape/ui/model/configuration/tests/test_mechanism.py'
--- landscape/ui/model/configuration/tests/test_mechanism.py	2013-09-16 14:39:23 +0000
+++ landscape/ui/model/configuration/tests/test_mechanism.py	1970-01-01 00:00:00 +0000
@@ -1,201 +0,0 @@
-from landscape.configuration import LandscapeSetupConfiguration
-from landscape.tests.helpers import LandscapeTest
-from landscape.ui.tests.helpers import (
-    dbus_test_should_skip, dbus_skip_message)
-if not dbus_test_should_skip:
-    import dbus
-    from landscape.ui.model.configuration.mechanism import (
-        ConfigurationMechanism, INTERFACE_NAME)
-
-
-class MechanismTest(LandscapeTest):
-    """
-    Test that we can use mechanism calls successfully from within a secure
-    context (the easiest to achieve is in-process calls.
-    """
-
-    def setUp(self):
-        super(MechanismTest, self).setUp()
-        config = "[client]\n"
-        config += "data_path = /var/lib/landscape/client/\n"
-        config += "http_proxy = http://proxy.localdomain:3192\n"
-        config += "tags = a_tag\n"
-        config += "url = https://landscape.canonical.com/message-system\n"
-        config += "account_name = foo\n"
-        config += "registration_key = boink\n"
-        config += "computer_title = baz\n"
-        config += "https_proxy = https://proxy.localdomain:6192\n"
-        config += "ping_url = http://landscape.canonical.com/ping\n"
-        self.config_filename = self.makeFile(config)
-        self.config = LandscapeSetupConfiguration()
-        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-        bus = dbus.SessionBus(private=True)
-        bus_name = dbus.service.BusName(INTERFACE_NAME, bus)
-        self.mechanism = ConfigurationMechanism(self.config, bus_name)
-        self.config.load(["-c", self.config_filename])
-
-    def tearDown(self):
-        self.mechanism.remove_from_connection()
-        super(MechanismTest, self).tearDown()
-
-    def test_is_local_call(self):
-        """
-        Test simple mechanism for checking if a call is local does the right
-        thing.  Anything passed to this function that is not L{None} will
-        result in is returning False - this in turn means that bypassing
-        security will not happen, which is the right thing in failure cases
-        too.
-        """
-        self.assertTrue(self.mechanism._is_local_call(None, None))
-        self.assertFalse(self.mechanism._is_local_call(True, True))
-
-    def test_get_account_name(self):
-        """
-        Test we can get account name from the mechanism.
-        """
-        self.assertEqual("foo", self.mechanism.get("account_name"))
-
-    def test_set_account_name(self):
-        """
-        Test we can set the account name via the mechanism.
-        """
-        self.mechanism.set("account_name", "bar")
-        self.assertEqual("bar", self.mechanism.get("account_name"))
-
-    def test_set_account_name_unicode(self):
-        """
-        Non-ascii characters are replaced before passing to underlying config.
-        """
-        self.mechanism.set("account_name", u"unicode\u00a3unicode")
-        self.assertEqual("unicode?unicode", self.mechanism.get("account_name"))
-
-    def test_no_unicode_to_underlying_config(self):
-        """
-        Non-ascii characters are replaced before passing to underlying config.
-        """
-        class FakeConfig(object):
-            def __init__(self):
-                self.account_name = None
-
-        fake_config = FakeConfig()
-        self.mechanism._config = fake_config
-        self.mechanism.set("account_name", u"unicode\u00a3unicode")
-        self.assertEqual("unicode?unicode", fake_config.account_name)
-
-    def test_get_data_path(self):
-        """
-        Test we can get the data path from the mechanism.
-        """
-        self.assertEqual("/var/lib/landscape/client/",
-                         self.mechanism.get("data_path"))
-
-    def set_data_path(self):
-        """
-        Test we can set the data path via the mechanism.
-        """
-        self.mechanism.set("data_path", "bar")
-        self.assertEqual("bar", self.mechanism.get("data_path"))
-
-    def test_get_http_proxy(self):
-        """
-        Test that we can get the HTTP proxy from the mechanism.
-        """
-        self.assertEqual("http://proxy.localdomain:3192",
-                         self.mechanism.get("http_proxy"))
-
-    def test_set_http_proxy(self):
-        """
-        Test that we can set the HTTP proxy via the mechanism.
-        """
-        self.mechanism.set("http_proxy", "bar")
-        self.assertEqual("bar", self.mechanism.get("http_proxy"))
-
-    def test_get_tags(self):
-        """
-        Test that we can get Tags from the mechanism.
-        """
-        self.assertEqual("a_tag", self.mechanism.get("tags"))
-
-    def test_set_tags(self):
-        """
-        Test that we can set Tags via the mechanism.
-        """
-        self.mechanism.set("tags", "bar")
-        self.assertEqual("bar", self.mechanism.get("tags"))
-
-    def test_get_url(self):
-        """
-        Test that we can get URL from the mechanism.
-        """
-        self.assertEqual("https://landscape.canonical.com/message-system",
-                          self.mechanism.get("url"))
-
-    def test_set_url(self):
-        """
-        Test that we can set the URL via the mechanisms.
-        """
-        self.mechanism.set("url", "bar")
-        self.assertEqual(self.mechanism.get("url"), "bar")
-
-    def test_get_ping_url(self):
-        """
-        Test that we can get the Ping URL from the mechanism.
-        """
-        self.assertEqual("http://landscape.canonical.com/ping",
-                          self.mechanism.get("ping_url"))
-
-    def test_set_ping_url(self):
-        """
-        Test that we can set the Ping URL via the mechanism.
-        """
-        self.mechanism.set("ping_url", "bar")
-        self.assertEqual("bar", self.mechanism.get("ping_url"))
-
-    def test_get_registration_key(self):
-        """
-        Test that we can get the registration key from the mechanism.
-        """
-        self.assertEqual("boink", self.mechanism.get("registration_key"))
-
-    def test_set_registration_key(self):
-        """
-        Test that we can set the registration key via the mechanism.
-        """
-        self.mechanism.set("registration_key", "bar")
-        self.assertEqual("bar", self.mechanism.get("registration_key"))
-
-    def test_get_computer_title(self):
-        """
-        Test that we can get the computer title from the mechanism.
-        """
-        self.assertEqual("baz", self.mechanism.get("computer_title"))
-
-    def test_set_computer_title(self):
-        """
-        Test that we can set the computer title via the mechanism.
-        """
-        self.mechanism.set("computer_title", "bar")
-        self.assertEqual("bar", self.mechanism.get("computer_title"))
-
-    def test_get_https_proxy(self):
-        """
-        Test that we can get the HTTPS Proxy from the mechanism.
-        """
-        self.assertEqual("https://proxy.localdomain:6192",
-                         self.mechanism.get("https_proxy"))
-
-    def test_set_https_proxy(self):
-        """
-        Test that we can set the HTTPS Proxy via the mechanism.
-        """
-        self.mechanism.set("https_proxy", "bar")
-        self.assertEqual("bar", self.mechanism.get("https_proxy"))
-
-    def test_exit(self):
-        """
-        Test that we cause the mechanism to exit.
-        """
-        self.assertRaises(SystemExit, self.mechanism.exit)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed file 'landscape/ui/model/configuration/tests/test_proxy.py'
--- landscape/ui/model/configuration/tests/test_proxy.py	2013-02-14 10:32:46 +0000
+++ landscape/ui/model/configuration/tests/test_proxy.py	1970-01-01 00:00:00 +0000
@@ -1,187 +0,0 @@
-from landscape.configuration import LandscapeSetupConfiguration
-from landscape.ui.tests.helpers import (
-    ConfigurationProxyHelper, dbus_test_should_skip, dbus_skip_message)
-if not dbus_test_should_skip:
-    from landscape.ui.model.configuration.mechanism import (
-        PermissionDeniedByPolicy)
-    import dbus
-from landscape.tests.helpers import LandscapeTest
-
-
-class AuthenticationFailureTest(LandscapeTest):
-    """
-    Test that an authentication failure is handled correctly.
-    """
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = ""
-
-        super(AuthenticationFailureTest, self).setUp()
-
-    def test_failed_authentication(self):
-        """
-        Test that load returns False when authentication fails.
-        """
-
-        def fake_policy_failure_load(arglist):
-            """
-            This simulates what you see if you click "Cancel" or give the wrong
-            credentials 3 times when L{PolicyKit} challenges you.
-            """
-            raise PermissionDeniedByPolicy()
-
-        def fake_timeout_failure_load(arglist):
-            """
-            This simulates what you see if you take no action when L{PolicyKit}
-            challenges you.
-            """
-
-            class FakeNoReply(dbus.DBusException):
-                """
-                Simulate a L{DBus} L{NoReply} exception.
-                """
-                _dbus_error_name = "org.freedesktop.DBus.Error.NoReply"
-
-            raise FakeNoReply()
-
-        self.mechanism.load = fake_policy_failure_load
-        self.assertFalse(self.proxy.load([]))
-        self.mechanism.load = fake_timeout_failure_load
-        self.assertFalse(self.proxy.load([]))
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class ConfigurationProxyInterfaceTest(LandscapeTest):
-    """
-    Test that we define the correct interface to a
-    L{LandscapeSetupConfiguration} by really using one as the interface.
-    """
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = "[client]\n" \
-            "data_path = /var/lib/landscape/client/\n" \
-            "http_proxy = http://proxy.localdomain:3192\n" \
-            "tags = a_tag\n" \
-            "url = https://landscape.canonical.com/message-system\n" \
-            "account_name = foo\n" \
-            "registration_key = boink\n" \
-            "computer_title = baz\n" \
-            "https_proxy = https://proxy.localdomain:6192\n" \
-            "ping_url = http://landscape.canonical.com/ping\n"
-
-        super(ConfigurationProxyInterfaceTest, self).setUp()
-
-    def test_method_docstrings(self):
-        """
-        Test that we pass through the docstrings for methods.
-        """
-        self.assertEqual(self.proxy.load.__doc__,
-                         LandscapeSetupConfiguration.load.__doc__)
-        self.assertEqual(self.proxy.reload.__doc__,
-                         LandscapeSetupConfiguration.reload.__doc__)
-        self.assertEqual(self.proxy.write.__doc__,
-                         LandscapeSetupConfiguration.write.__doc__)
-
-    def test_account_name(self):
-        """
-        Test that we can get and set an account name via the configuration
-        proxy.
-        """
-        self.assertEqual("foo", self.proxy.account_name)
-        self.proxy.account_name = "bar"
-        self.assertEqual("bar", self.proxy.account_name)
-        self.assertEqual("bar", self.config.account_name)
-
-    def test_computer_title(self):
-        """
-        Test that we can get and set a computer title via the configuration
-        proxy.
-        """
-        self.assertEqual("baz", self.proxy.computer_title)
-        self.proxy.computer_title = "bar"
-        self.assertEqual("bar", self.proxy.computer_title)
-        self.assertEqual("bar", self.config.computer_title)
-
-    def test_data_path(self):
-        """
-        Test that we can get and set the data path via the configuration proxy.
-        """
-        self.assertEqual("/var/lib/landscape/client/", self.proxy.data_path)
-        self.proxy.data_path = "bar"
-        self.assertEqual("bar", self.proxy.data_path)
-        self.assertEqual("bar", self.config.data_path)
-
-    def test_http_proxy(self):
-        """
-        Test that we can get and set the HTTP proxy via the configuration
-        proxy.
-        """
-        self.assertEqual("http://proxy.localdomain:3192",
-                         self.proxy.http_proxy)
-        self.proxy.http_proxy = "bar"
-        self.assertEqual("bar", self.proxy.http_proxy)
-        self.assertEqual("bar", self.config.http_proxy)
-
-    def test_https_proxy(self):
-        """
-        Test that we can get and set the HTTPS proxy via the configuration
-        proxy.
-        """
-        self.assertEqual("https://proxy.localdomain:6192",
-                         self.proxy.https_proxy)
-        self.proxy.https_proxy = "bar"
-        self.assertEqual("bar", self.proxy.https_proxy)
-        self.assertEqual("bar", self.config.https_proxy)
-
-    def test_ping_url(self):
-        """
-        Test that we can get and set the ping URL via the configuration proxy.
-        """
-        self.assertEqual("http://landscape.canonical.com/ping",
-                         self.proxy.ping_url)
-        self.proxy.ping_url = "bar"
-        self.assertEqual("bar", self.proxy.ping_url)
-        self.assertEqual("bar", self.config.ping_url)
-
-    def test_registration_key(self):
-        """
-        Test that we can get and set the registration key via the
-        configuration proxy.
-        """
-        self.assertEqual("boink", self.proxy.registration_key)
-        self.proxy.registration_key = "bar"
-        self.assertEqual("bar", self.proxy.registration_key)
-        self.assertEqual("bar", self.config.registration_key)
-
-    def test_tags(self):
-        """
-        Test that we can get and set the tags via the configuration proxy.
-        """
-        self.assertEqual("a_tag", self.proxy.tags)
-        self.proxy.tags = "bar"
-        self.assertEqual("bar", self.proxy.tags)
-        self.assertEqual("bar", self.config.tags)
-
-    def test_url(self):
-        """
-        Test that we can get and set the URL via the configuration proxy.
-        """
-        self.assertEqual("https://landscape.canonical.com/message-system",
-                         self.proxy.url)
-        self.proxy.url = "bar"
-        self.assertEqual("bar", self.proxy.url)
-        self.assertEqual("bar", self.config.url)
-
-    def test_exit(self):
-        """
-        Test that we can cause the mechanism to exit.
-        """
-        self.assertRaises(SystemExit, self.proxy.exit, asynchronous=False)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed file 'landscape/ui/model/configuration/tests/test_state.py'
--- landscape/ui/model/configuration/tests/test_state.py	2013-02-14 10:32:46 +0000
+++ landscape/ui/model/configuration/tests/test_state.py	1970-01-01 00:00:00 +0000
@@ -1,635 +0,0 @@
-from landscape.ui.tests.helpers import (
-    ConfigurationProxyHelper, FakeGSettings, dbus_test_should_skip,
-    dbus_skip_message)
-
-if not dbus_test_should_skip:
-    from landscape.ui.model.configuration.uisettings import UISettings
-    import landscape.ui.model.configuration.state
-    from landscape.ui.model.configuration.state import (
-        ConfigurationModel, StateError, VirginState, InitialisedState,
-        ModifiedState, MANAGEMENT_TYPE, HOSTED, LOCAL, HOSTED_LANDSCAPE_HOST,
-        LANDSCAPE_HOST, COMPUTER_TITLE, ExitedState)
-    from landscape.ui.model.configuration.mechanism import (
-        PermissionDeniedByPolicy)
-    from landscape.ui.constants import (
-        CANONICAL_MANAGED, LOCAL_MANAGED, NOT_MANAGED)
-
-
-from landscape.tests.helpers import LandscapeTest
-
-
-class AuthenticationFailureTest(LandscapeTest):
-    """
-    Test that an authentication failure is handled correctly in the
-    L{ConfigurationModel}.
-    """
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = ""
-        self.default_data = {"management-type": "canonical",
-                             "computer-title": "",
-                             "hosted-landscape-host": "",
-                             "hosted-account-name": "",
-                             "hosted-password": "",
-                             "local-landscape-host": "",
-                             "local-account-name": "",
-                             "local-password": ""}
-        landscape.ui.model.configuration.state.DEFAULT_DATA[COMPUTER_TITLE] \
-            = "bound.to.lose"
-        super(AuthenticationFailureTest, self).setUp()
-
-    def test_failed_authentication(self):
-        """
-        Test that load returns False when authentication fails.
-        """
-
-        def fake_faily_load(arglist):
-            """
-            This simulates what you see if you click "Cancel" or give the wrong
-            credentials 3 times when L{PolicyKit} challenges you.
-            """
-            raise PermissionDeniedByPolicy()
-
-        def fake_exit_method():
-            """
-            Avoid raising a L{SystemExit} exception.
-            """
-
-        self.mechanism.load = fake_faily_load
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertFalse(model.load_data(asynchronous=False,
-                                         exit_method=fake_exit_method))
-        self.assertTrue(isinstance(model.get_state(), ExitedState))
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class ConfigurationModelTest(LandscapeTest):
-    """
-    Test the internal data handling of the L{ConfigurationModel} without
-    loading external data.
-    """
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = ""
-        self.default_data = {"management-type": "canonical",
-                             "computer-title": "",
-                             "hosted-landscape-host": "",
-                             "hosted-account-name": "",
-                             "hosted-password": "",
-                             "local-landscape-host": "",
-                             "local-account-name": "",
-                             "local-password": ""}
-        landscape.ui.model.configuration.state.DEFAULT_DATA[COMPUTER_TITLE] \
-            = "bound.to.lose"
-        super(ConfigurationModelTest, self).setUp()
-
-    def test_get(self):
-        """
-        Test that L{get} correctly extracts data from the internal data storage
-        of the L{ConfigurationState}s associated with a L{ConfigurationModel}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        state = model.get_state()
-        self.assertEqual(NOT_MANAGED, state.get(MANAGEMENT_TYPE))
-        self.assertEqual(HOSTED_LANDSCAPE_HOST,
-                         state.get(HOSTED, LANDSCAPE_HOST))
-        self.assertRaises(TypeError, state.get, MANAGEMENT_TYPE, HOSTED,
-                          LANDSCAPE_HOST)
-        self.assertRaises(KeyError, state.get, LANDSCAPE_HOST)
-        self.assertRaises(KeyError, state.get, MANAGEMENT_TYPE, LANDSCAPE_HOST)
-
-    def test_set(self):
-        """
-        Test that L{set} correctly sets data in the internal data storage of
-        the L{ConfigurationState}s associated with a L{ConfigurationModel}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        state = model.get_state()
-        state.set(MANAGEMENT_TYPE, NOT_MANAGED)
-        self.assertEqual(NOT_MANAGED, state.get(MANAGEMENT_TYPE))
-        state.set(MANAGEMENT_TYPE, CANONICAL_MANAGED)
-        self.assertEqual(CANONICAL_MANAGED, state.get(MANAGEMENT_TYPE))
-        state.set(MANAGEMENT_TYPE, LOCAL_MANAGED)
-        self.assertEqual(LOCAL_MANAGED, state.get(MANAGEMENT_TYPE))
-        self.assertEqual("", state.get(LOCAL, LANDSCAPE_HOST))
-        state.set(LOCAL, LANDSCAPE_HOST, "goodison.park")
-        self.assertEqual("goodison.park", state.get(LOCAL, LANDSCAPE_HOST))
-
-    def test_virginal(self):
-        """
-        Test that the L{ConfigurationModel} is created with default data.  This
-        should be managed via L{VirginState} (hence the name), but this should
-        not be exposed and is not explicitly tested here (see
-        L{StateTransitionTest}).
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertEqual(NOT_MANAGED, model.management_type)
-        self.assertEqual(HOSTED_LANDSCAPE_HOST, model.hosted_landscape_host)
-        self.assertEqual("bound.to.lose", model.computer_title)
-        self.assertEqual("", model.local_landscape_host)
-        self.assertEqual("", model.hosted_account_name)
-        self.assertEqual("standalone", model.local_account_name)
-        self.assertEqual("", model.hosted_password)
-
-    def test_is_hosted_property(self):
-        """
-        Test we can use the L{is_hosted} property to set and get that data on
-        the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual(CANONICAL_MANAGED, model.management_type)
-        model.management_type = LOCAL_MANAGED
-        self.assertEqual(LOCAL_MANAGED, model.management_type)
-        model.management_type = NOT_MANAGED
-        self.assertEqual(NOT_MANAGED, model.management_type)
-
-    def test_computer_title_property(self):
-        """
-        Test that we can use the L{computer_title} property to set and get that
-        data on the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual("bound.to.lose", model.computer_title)
-        model.computer_title = "bound.to.win"
-        self.assertEqual("bound.to.win", model.computer_title)
-
-    def test_hosted_landscape_host_property(self):
-        """
-        Test we can use the L{hosted_landscape_host} property to set and get
-        that data on the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertEqual(HOSTED_LANDSCAPE_HOST, model.hosted_landscape_host)
-        self.assertRaises(AttributeError, setattr, model,
-                          "hosted_landscape_host", "foo")
-
-    def test_hosted_account_name_property(self):
-        """
-        Test we can use the L{hosted_account_name} property to set and get
-        that data on the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertEqual("", model.hosted_account_name)
-        model.hosted_account_name = "foo"
-        self.assertEqual("foo", model.hosted_account_name)
-
-    def test_hosted_password_property(self):
-        """
-        Test we can use the L{hosted_password} property to set and get
-        that data on the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertEqual("", model.hosted_password)
-        model.hosted_password = "foo"
-        self.assertEqual("foo", model.hosted_password)
-
-    def test_local_landscape_host_property(self):
-        """
-        Test we can use the L{local_landscape_host} property to set and get
-        that data on the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertEqual("", model.local_landscape_host)
-        model.local_landscape_host = "foo"
-        self.assertEqual("foo", model.local_landscape_host)
-
-    def test_local_account_name_property(self):
-        """
-        Test we can use the L{local_account_name} property to set and get
-        that data on the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertEqual("standalone", model.local_account_name)
-        model.local_account_name = "foo"
-        self.assertEqual("foo", model.local_account_name)
-
-    def test_local_password_property(self):
-        """
-        Test we can use the L{local_password} property to set and get
-        that data on the current L{ConfigurationState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertEqual("", model.local_password)
-        model.local_password = "foo"
-        self.assertEqual("foo", model.local_password)
-
-    def test_exit(self):
-        """
-        Test that we can cause the mechanism to exit.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertRaises(SystemExit, model.exit, asynchronous=False)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class ConfigurationModelHostedTest(LandscapeTest):
-    """
-    Test the L{ConfigurationModel} is correctly initialised when the live
-    configuration is set for a hosted account.
-
-    Note the multilayer data loading:
-
-         1. Internal state is defaulted.
-         2. UISettings data is loaded.
-         3. Live configuration is loaded.
-    """
-
-    helpers = [ConfigurationProxyHelper]
-
-    default_data = {"management-type": "canonical",
-                    "computer-title": "bound.to.lose",
-                    "hosted-landscape-host": "landscape.canonical.com",
-                    "hosted-account-name": "Sparklehorse",
-                    "hosted-password": "Vivadixiesubmarinetransmissionplot",
-                    "local-landscape-host": "the.local.machine",
-                    "local-account-name": "CrazyHorse",
-                    "local-password": "RustNeverSleeps"}
-
-    def setUp(self):
-        self.config_string = "[client]\n" \
-            "data_path = /var/lib/landscape/client/\n" \
-            "http_proxy = http://proxy.localdomain:3192\n" \
-            "tags = a_tag\n" \
-            "url = https://landscape.canonical.com/message-system\n" \
-            "account_name = foo\n" \
-            "registration_key = boink\n" \
-            "computer_title = baz\n" \
-            "https_proxy = https://proxy.localdomain:6192\n" \
-            "ping_url = http://landscape.canonical.com/ping\n"
-
-        super(ConfigurationModelHostedTest, self).setUp()
-
-    def test_initialised_hosted(self):
-        """
-        Test the L{ConfigurationModel} is correctly initialised from a proxy
-        and defaults with hosted data.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual(CANONICAL_MANAGED, model.management_type)
-        self.assertEqual("landscape.canonical.com",
-                         model.hosted_landscape_host)
-        self.assertEqual("the.local.machine", model.local_landscape_host)
-        self.assertEqual("foo", model.hosted_account_name)
-        self.assertEqual("CrazyHorse", model.local_account_name)
-        self.assertEqual("boink", model.hosted_password)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class ConfigurationModelLocalTest(LandscapeTest):
-
-    helpers = [ConfigurationProxyHelper]
-
-    default_data = {"management-type": "LDS",
-                    "computer-title": "bound.to.lose",
-                    "hosted-landscape-host": "landscape.canonical.com",
-                    "hosted-account-name": "Sparklehorse",
-                    "hosted-password": "Vivadixiesubmarinetransmissionplot",
-                    "local-landscape-host": "the.local.machine",
-                    "local-account-name": "CrazyHorse",
-                    "local-password": "RustNeverSleeps"}
-
-    def setUp(self):
-        self.config_string = "[client]\n" \
-            "data_path = /var/lib/landscape/client/\n" \
-            "http_proxy = http://proxy.localdomain:3192\n" \
-            "tags = a_tag\n" \
-            "url = https://landscape.localdomain/message-system\n" \
-            "account_name = foo\n" \
-            "registration_key = boink\n" \
-            "computer_title = baz\n" \
-            "https_proxy = \n" \
-            "ping_url = http://landscape.localdomain/ping\n"
-
-        super(ConfigurationModelLocalTest, self).setUp()
-
-    def test_initialised_local(self):
-        """
-        Test the L{ConfigurationModel} is correctly initialised from a proxy
-        and defaults with local data.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual(LOCAL_MANAGED, model.management_type)
-        self.assertEqual("landscape.canonical.com",
-                         model.hosted_landscape_host)
-        self.assertEqual("landscape.localdomain", model.local_landscape_host)
-        self.assertEqual("Sparklehorse", model.hosted_account_name)
-        self.assertEqual("foo", model.local_account_name)
-        self.assertEqual("Vivadixiesubmarinetransmissionplot",
-                         model.hosted_password)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class StateTransitionTest(LandscapeTest):
-    """
-    Test that we make the correct state transitions when taking actions on the
-    L{ConfigurationModel}.
-    """
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = ""
-        self.default_data = {
-            "management-type": "canonical",
-            "computer-title": "bound.to.lose",
-            "hosted-landscape-host": "landscape.canonical.com",
-            "hosted-account-name": "Sparklehorse",
-            "hosted-password": "Vivadixiesubmarinetransmissionplot",
-            "local-landscape-host": "the.local.machine",
-            "local-account-name": "CrazyHorse",
-            "local-password": "RustNeverSleeps"}
-        super(StateTransitionTest, self).setUp()
-
-    def test_load_data_transitions(self):
-        """
-        Test that the L{ConfigurationModel} correctly changes state as we call
-        L{load_data}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertTrue(isinstance(model.get_state(), VirginState))
-        model.load_data()
-        self.assertTrue(isinstance(model.get_state(), InitialisedState))
-        initialised = model.get_state()
-        model.load_data()
-        self.assertTrue(isinstance(model.get_state(), InitialisedState))
-        self.assertIs(initialised, model.get_state())
-
-    def test_modifying_a_virgin_raises(self):
-        """
-        Test that attempting a L{modify} a L{ConfigurationModel} in
-        L{VirginState} raises a L{StateError}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertRaises(StateError, model.modify)
-
-    def test_initialised_state_is_modifiable(self):
-        """
-        Test that the L{ConfigurationModel} transitions to L{ModifiedState}
-        whenever L{modify} is called on it in L{InitialisedState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual(CANONICAL_MANAGED, model.management_type)
-        model.management_type = LOCAL_MANAGED
-        self.assertEqual(LOCAL_MANAGED, model.management_type)
-        model.modify()
-        self.assertTrue(isinstance(model.get_state(), ModifiedState))
-        self.assertEqual(LOCAL_MANAGED, model.management_type)
-
-    def test_modified_state_is_modifiable(self):
-        """
-        Test that the L{ConfigurationModel} transitions to L{ModifiedState}
-        whenever L{modify} is called on it in L{ModifiedState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        model.modify()
-        self.assertTrue(isinstance(model.get_state(), ModifiedState))
-        model.modify()
-        self.assertTrue(isinstance(model.get_state(), ModifiedState))
-
-    def test_reverting_a_virgin_raises(self):
-        """
-        Test that calling L{revert} on a L{ConfigurationModel} in
-        L{VirginState} raises a L{StateError}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertRaises(StateError, model.revert)
-
-    def test_initialiased_state_is_unrevertable(self):
-        """
-        Test that calling L{revert} on a L{ConfigurationModel} in
-        L{InitialisedState} raises a L{StateError}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertRaises(StateError, model.revert)
-
-    def test_modified_state_is_revertable(self):
-        """
-        Test that a L{ConfigurationModel} in L{ModifiedState} can be
-        transitioned via L{revert} to L{InitialisedState}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        model.modify()
-        model.revert()
-        self.assertTrue(isinstance(model.get_state(), InitialisedState))
-
-    def test_reverting_reverts_data(self):
-        """
-        Test that transitioning via L{revert} causes the original
-        L{InitialisedState} to be restored.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual(HOSTED_LANDSCAPE_HOST, model.hosted_landscape_host)
-        self.assertEqual("CrazyHorse", model.local_account_name)
-        model.local_account_name = "bar"
-        model.modify()
-        self.assertEqual("bar", model.local_account_name)
-        model.revert()
-        self.assertTrue(isinstance(model.get_state(), InitialisedState))
-        self.assertEqual("CrazyHorse", model.local_account_name)
-
-    def test_persisting_a_virgin_raises(self):
-        """
-        Test that a L{ConfigurationModel} in L{VirginState} will raise a
-        L{StateError} when you attempt to transition it with L{persist}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        self.assertRaises(StateError, model.persist)
-
-    def test_persisting_initialised_state_raises(self):
-        """
-        Test that a L{ConfigurationModel} in L{IntialisedState} will raise a
-        L{StateError} when you attempt to transition it with L{persist}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertRaises(StateError, model.persist)
-
-    def test_persisting_modified_is_allowed(self):
-        """
-        Test that a L{ConfigurationModel} in L{ModifiedState} will allow itself
-        to be transitioned with L{persist}.
-        """
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        model.modify()
-        model.persist()
-        self.assertTrue(isinstance(model.get_state(), InitialisedState))
-
-    def test_persisting_saves_data_to_uisettings(self):
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual(CANONICAL_MANAGED, uisettings.get_management_type())
-        self.assertEqual("Sparklehorse", uisettings.get_hosted_account_name())
-        self.assertEqual("Vivadixiesubmarinetransmissionplot",
-                        uisettings.get_hosted_password())
-        self.assertEqual("the.local.machine",
-                         uisettings.get_local_landscape_host())
-        self.assertEqual("CrazyHorse", uisettings.get_local_account_name())
-        self.assertEqual("RustNeverSleeps", uisettings.get_local_password())
-        model.management_type = LOCAL_MANAGED
-        model.hosted_account_name = "ThomasPaine"
-        model.hosted_password = "TheAgeOfReason"
-        model.local_landscape_host = "another.local.machine"
-        model.local_account_name = "ThomasHobbes"
-        model.local_password = "TheLeviathan"
-        model.modify()
-        self.assertTrue(isinstance(model.get_state(), ModifiedState))
-        model.persist()
-        self.assertTrue(isinstance(model.get_state(), InitialisedState))
-        self.assertEqual(LOCAL_MANAGED, uisettings.get_management_type())
-        self.assertEqual("ThomasPaine", uisettings.get_hosted_account_name())
-        self.assertEqual("TheAgeOfReason", uisettings.get_hosted_password())
-        self.assertEqual("another.local.machine",
-                         uisettings.get_local_landscape_host())
-        self.assertEqual("ThomasHobbes", uisettings.get_local_account_name())
-        self.assertEqual("TheLeviathan", uisettings.get_local_password())
-
-    def test_any_transition_on_exited_state_raises(self):
-        """
-        Test that we cannot transition the L{ExitedState} at all.
-        """
-
-        def fake_exit():
-            """
-            This just avoids raising L{exceptions.SysExit} during __init__.
-            """
-
-        state = ExitedState(None, None, None, exit_method=fake_exit)
-        self.assertRaises(StateError, state.load_data)
-        self.assertRaises(StateError, state.modify)
-        self.assertRaises(StateError, state.persist)
-        self.assertRaises(StateError, state.revert)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class StateTransitionWithExistingConfigTest(LandscapeTest):
-    """
-    Test that we handle existing configuration data correctly when
-    transitioning through L{ConfigurationModel} states.
-    """
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.config_string = (
-            "[client]\n"
-            "data_path = /var/lib/landscape/client/\n"
-            "http_proxy = http://proxy.localdomain:3192\n"
-            "tags = a_tag\n"
-            "url = https://landscape.canonical.com/message-system\n"
-            "account_name = Sparklehorse\n"
-            "registration_key = Vivadixiesubmarinetransmissionplot\n"
-            "computer_title = baz\n"
-            "https_proxy = https://proxy.localdomain:6192\n"
-            "ping_url = http://landscape.canonical.com/ping\n")
-        self.default_data = {
-            "management-type": "canonical",
-            "computer-title": "bound.to.lose",
-            "hosted-landscape-host": "landscape.canonical.com",
-            "hosted-account-name": "Sparklehorse",
-            "hosted-password": "Vivadixiesubmarinetransmissionplot",
-            "local-landscape-host": "the.local.machine",
-            "local-account-name": "CrazyHorse",
-            "local-password": "RustNeverSleeps"}
-        super(StateTransitionWithExistingConfigTest, self).setUp()
-
-    def test_persisting_saves_data_to_proxy(self):
-        settings = FakeGSettings(data=self.default_data)
-        uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy, uisettings=uisettings)
-        model.load_data()
-        self.assertEqual("Sparklehorse", self.proxy.account_name)
-        self.assertEqual("Vivadixiesubmarinetransmissionplot",
-                        self.proxy.registration_key)
-        model.management_type = LOCAL_MANAGED
-        model.local_account_name = "ThomasPaine"
-        model.local_password = "TheAgeOfReason"
-        model.modify()
-        self.assertTrue(isinstance(model.get_state(), ModifiedState))
-        model.persist()
-        self.assertTrue(isinstance(model.get_state(), InitialisedState))
-        self.assertEqual(LOCAL_MANAGED, model.management_type)
-        self.assertEqual("https://the.local.machine/message-system",
-                         self.proxy.url)
-        self.assertEqual("http://the.local.machine/ping", self.proxy.ping_url)
-        self.assertEqual("ThomasPaine", self.proxy.account_name)
-        self.assertEqual("TheAgeOfReason", self.proxy.registration_key)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed file 'landscape/ui/model/configuration/tests/test_uisettings.py'
--- landscape/ui/model/configuration/tests/test_uisettings.py	2013-02-14 10:32:46 +0000
+++ landscape/ui/model/configuration/tests/test_uisettings.py	1970-01-01 00:00:00 +0000
@@ -1,167 +0,0 @@
-
-from landscape.tests.helpers import LandscapeTest
-from landscape.ui.model.configuration.uisettings import UISettings
-from landscape.ui.tests.helpers import (
-    FakeGSettings, dbus_test_should_skip, dbus_skip_message)
-
-
-class UISettingsTest(LandscapeTest):
-
-    default_data = {"management-type": "LDS",
-                    "computer-title": "bound.to.lose",
-                    "hosted-landscape-host": "landscape.canonical.com",
-                    "hosted-account-name": "Sparklehorse",
-                    "hosted-password": "Vivadixiesubmarinetransmissionplot",
-                    "local-landscape-host": "the.local.machine",
-                    "local-account-name": "CrazyHorse",
-                    "local-password": "RustNeverSleeps"}
-
-    def setUp(self):
-        super(UISettingsTest, self).setUp()
-        self.settings = FakeGSettings(data=self.default_data)
-        self.uisettings = UISettings(self.settings)
-
-    def test_setup(self):
-        """
-        Test that the L{GSettings.Client} is correctly initialised.
-        """
-        self.assertTrue(self.settings.was_called_with_args(
-                "new", UISettings.BASE_KEY))
-
-    def test_get_management_type(self):
-        """
-        Test that the L{get_management_type} value is correctly fetched from
-        the L{GSettings.Client}.
-        """
-        self.assertEqual("LDS", self.uisettings.get_management_type())
-
-    def test_set_management_type(self):
-        """
-        Test that we can correctly use L{set_management_type} to write the
-        L{management_type} value to the L{GSettings.Client}.
-        """
-        self.assertEqual("LDS", self.uisettings.get_management_type())
-        self.uisettings.set_management_type("canonical")
-        self.assertEqual("canonical", self.uisettings.get_management_type())
-        self.assertTrue(self.settings.was_called_with_args(
-                "set_string", "management-type", "canonical"))
-
-    def test_get_computer_title(self):
-        """
-        Test that the L{get_computer_title} value is correctly fetched
-        from the L{GSettings.Client}.
-        """
-        self.assertEqual("bound.to.lose",
-                         self.uisettings.get_computer_title())
-
-    def test_set_computer_title(self):
-        """
-        Test that L{set_computer_title} correctly sets the value of
-        L{computer_title} in the L{GSettings.Client}.
-        """
-        self.assertEqual("bound.to.lose", self.uisettings.get_computer_title())
-        self.uisettings.set_computer_title("Bang")
-        self.assertEqual("Bang", self.uisettings.get_computer_title())
-
-    def test_get_hosted_landscape_host(self):
-        """
-        Test that the L{get_hosted_landscape_host} value is correctly fetched
-        from the L{GSettings.Client}.
-        """
-        self.assertEqual("landscape.canonical.com",
-                         self.uisettings.get_hosted_landscape_host())
-
-    # NOTE: There is no facility to set the hosted-landscape-host
-
-    def test_get_hosted_account_name(self):
-        """
-        Test that the L{get_hosted_account_name} value is correctly fetched
-        from the L{GSettings.Client}.
-        """
-        self.assertEqual("Sparklehorse",
-                         self.uisettings.get_hosted_account_name())
-
-    def test_set_hosted_account_name(self):
-        """
-        Test that L{set_hosted_account_name} correctly sets the value of
-        L{hosted_account_name} in the L{GSettings.Client}.
-        """
-        self.assertEqual("Sparklehorse",
-                         self.uisettings.get_hosted_account_name())
-        self.uisettings.set_hosted_account_name("Bang")
-        self.assertEqual("Bang", self.uisettings.get_hosted_account_name())
-
-    def test_get_hosted_password(self):
-        """
-        Test that the L{get_hosted_password} value is correctly fetched
-        from the L{GSettings.Client}.
-        """
-        self.assertEqual("Vivadixiesubmarinetransmissionplot",
-                         self.uisettings.get_hosted_password())
-
-    def test_set_hosted_password(self):
-        """
-        Test that L{set_hosted_password} correctly sets the value of
-        L{hosted_password} in the L{GSettings.Client}.
-        """
-        self.assertEqual("Vivadixiesubmarinetransmissionplot",
-                         self.uisettings.get_hosted_password())
-        self.uisettings.set_hosted_password("Bang")
-        self.assertEqual("Bang", self.uisettings.get_hosted_password())
-
-    def test_get_local_landscape_host(self):
-        """
-        Test that the L{get_local_landscape_host} value is correctly fetched
-        from the L{GSettings.Client}.
-        """
-        self.assertEqual("the.local.machine",
-                         self.uisettings.get_local_landscape_host())
-
-    def test_set_local_landscape_host(self):
-        """
-        Test that L{set_local_landscape_host} correctly sets the value of
-        L{local_landscape_host} in the L{GSettings.Client}.
-        """
-        self.assertEqual("the.local.machine",
-                         self.uisettings.get_local_landscape_host())
-        self.uisettings.set_local_landscape_host("Bang")
-        self.assertEqual("Bang", self.uisettings.get_local_landscape_host())
-
-    def test_get_local_account_name(self):
-        """
-        Test that the L{get_local_account_name} value is correctly fetched
-        from the L{GSettings.Client}.
-        """
-        self.assertEqual("CrazyHorse",
-                         self.uisettings.get_local_account_name())
-
-    def test_set_local_account_name(self):
-        """
-        Test that L{set_local_account_name} correctly sets the value of
-        L{local_account_name} in the L{GSettings.Client}.
-        """
-        self.assertEqual("CrazyHorse",
-                         self.uisettings.get_local_account_name())
-        self.uisettings.set_local_account_name("Bang")
-        self.assertEqual("Bang", self.uisettings.get_local_account_name())
-
-    def test_get_local_password(self):
-        """
-        Test that the L{get_local_password} value is correctly fetched
-        from the L{GSettings.Client}.
-        """
-        self.assertEqual("RustNeverSleeps",
-                         self.uisettings.get_local_password())
-
-    def test_set_local_password(self):
-        """
-        Test that L{set_local_password} correctly sets the value of
-        L{local_password} in the L{GSettings.Client}.
-        """
-        self.assertEqual("RustNeverSleeps",
-                         self.uisettings.get_local_password())
-        self.uisettings.set_local_password("Bang")
-        self.assertEqual("Bang", self.uisettings.get_local_password())
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed file 'landscape/ui/model/configuration/uisettings.py'
--- landscape/ui/model/configuration/uisettings.py	2012-02-29 17:02:37 +0000
+++ landscape/ui/model/configuration/uisettings.py	1970-01-01 00:00:00 +0000
@@ -1,57 +0,0 @@
-class UISettings(object):
-    """
-    A very thin wrapper around L{GSettings} to avoid having to know the
-    L{BaseKey} and type information elsewhere.  In some future version it would
-    be right to bind to change events here so we can react to people changing
-    the settings in dconf, for now that is overkill.
-    """
-
-    BASE_KEY = "com.canonical.landscape-client-settings"
-
-    def __init__(self, settings):
-        self.settings = settings.new(self.BASE_KEY)
-
-    def get_management_type(self):
-        return self.settings.get_string("management-type")
-
-    def set_management_type(self, value):
-        self.settings.set_string("management-type", value)
-
-    def get_computer_title(self):
-        return self.settings.get_string("computer-title")
-
-    def set_computer_title(self, value):
-        self.settings.set_string("computer-title", value)
-
-    def get_hosted_landscape_host(self):
-        return self.settings.get_string("hosted-landscape-host")
-
-    def get_hosted_account_name(self):
-        return self.settings.get_string("hosted-account-name")
-
-    def set_hosted_account_name(self, value):
-        self.settings.set_string("hosted-account-name", value)
-
-    def get_hosted_password(self):
-        return self.settings.get_string("hosted-password")
-
-    def set_hosted_password(self, value):
-        self.settings.set_string("hosted-password", value)
-
-    def get_local_landscape_host(self):
-        return self.settings.get_string("local-landscape-host")
-
-    def set_local_landscape_host(self, value):
-        self.settings.set_string("local-landscape-host", value)
-
-    def get_local_account_name(self):
-        return self.settings.get_string("local-account-name")
-
-    def set_local_account_name(self, value):
-        self.settings.set_string("local-account-name", value)
-
-    def get_local_password(self):
-        return self.settings.get_string("local-password")
-
-    def set_local_password(self, value):
-        self.settings.set_string("local-password", value)

=== removed directory 'landscape/ui/model/registration'
=== removed file 'landscape/ui/model/registration/__init__.py'
=== removed file 'landscape/ui/model/registration/mechanism.py'
--- landscape/ui/model/registration/mechanism.py	2012-03-16 14:58:50 +0000
+++ landscape/ui/model/registration/mechanism.py	1970-01-01 00:00:00 +0000
@@ -1,177 +0,0 @@
-import subprocess
-import sys
-import os
-
-import dbus
-import dbus.service
-import dbus.glib
-
-from landscape.ui.lib.polkit import PolicyKitMechanism, POLICY_NAME
-
-
-SERVICE_NAME = "com.canonical.LandscapeClientRegistration"
-INTERFACE_NAME = \
-    "com.canonical.LandscapeClientRegistration.RegistrationInterface"
-OBJECT_PATH = \
-    "/com/canonical/LandscapeClientRegistration/RegistrationInterface"
-
-
-class PermissionDeniedByPolicy(dbus.DBusException):
-    _dbus_error_name = \
-        "com.canonical.LandscapeClientRegistration.PermissionDeniedByPolicy"
-
-
-class RegistrationError(dbus.DBusException):
-    _dbus_error_name = \
-        "com.canonical.LandscapeClientRegistration.RegistrationError"
-
-
-class RegistrationMechanism(PolicyKitMechanism):
-    """
-    L{RegistrationMechanism} is a mechanism for invoking and observing client
-    registration over DBus.  It utilises PolicyKit to ensure that only
-    administrative users may use it.
-    """
-
-    def __init__(self, bus_name, bypass=False, conn=None):
-        super(RegistrationMechanism, self).__init__(
-            OBJECT_PATH, bus_name, PermissionDeniedByPolicy,
-            bypass=bypass, conn=conn)
-        self.process = None
-        self.message_queue = []
-        self.error_queue = []
-
-    def _do_registration(self, config_path):
-        self.register_notify("Trying to register ...\n")
-        cmd = ["landscape-config", "--silent", "-c",
-               os.path.abspath(config_path)]
-        try:
-            message = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
-            self.register_notify(message)
-            return True, message
-        except subprocess.CalledProcessError, error:
-            wait_phrase = "Please wait... "
-            wait_phrase_index = error.output.find(wait_phrase)
-            if wait_phrase_index > -1:
-                message = error.output[wait_phrase_index + len(wait_phrase):]
-            else:
-                message = "Landscape configuration failed.\n%s" % error.output
-            self.register_error(message)
-            return False, message
-
-    @dbus.service.signal(dbus_interface=INTERFACE_NAME,
-                         signature='s')
-    def register_notify(self, message):
-        """
-        L{register_notify} is a signal sent to subscribers.  It is not
-        necessary for any actual work to occur in the method as it is called
-        for the effect of invoking its decorator.
-        """
-
-    @dbus.service.signal(dbus_interface=INTERFACE_NAME,
-                         signature='s')
-    def register_error(self, message):
-        """
-        L{register_error} is a signal sent to subscribers.  It is not
-        necessary for any actual work to occur in the method as it is called
-        for the effect of invoking its decorator.
-        """
-
-    @dbus.service.signal(dbus_interface=INTERFACE_NAME,
-                         signature='s')
-    def register_succeed(self, message):
-        """
-        L{register_succeed} is a signal sent to subscribers.  It is not
-        necessary for any actual work to occur in the method as it is called
-        for the effect of invoking its decorator.
-        """
-
-    @dbus.service.signal(dbus_interface=INTERFACE_NAME,
-                         signature='s')
-    def register_fail(self, message):
-        """
-        L{register_fail} is a signal sent to subscribers.  It is not
-        necessary for any actual work to occur in the method as it is called
-        for the effect of invoking its decorator.
-        """
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="",
-                         out_signature="b",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def challenge(self, sender=None, conn=None):
-        """
-        Safely check if we can escalate permissions.
-        """
-        try:
-            return self._is_allowed_by_policy(sender, conn, POLICY_NAME)
-        except PermissionDeniedByPolicy:
-            return False
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="s",
-                         out_signature="(bs)",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def register(self, config_path, sender=None, conn=None):
-        if self._is_allowed_by_policy(sender, conn, POLICY_NAME):
-            succeed, message = self._do_registration(config_path)
-            if succeed:
-                message = "Registration message sent to Landscape server.\n"
-                self.register_succeed(message)
-                return (True, message)
-            else:
-                self.register_fail(message)
-                return (False, message)
-
-    def _do_disabling(self):
-        cmd = ["landscape-config", "--disable"]
-        try:
-            subprocess.check_output(cmd, stderr=subprocess.STDOUT)
-            return True
-        except subprocess.CalledProcessError:
-            return False
-
-    @dbus.service.signal(dbus_interface=INTERFACE_NAME,
-                         signature='')
-    def disable_succeed(self):
-        """
-        L{disable_succeed} is a signal sent to subscribers.  It is not
-        necessary for any actual work to occur in the method as it is called
-        for the effect of invoking its decorator.
-        """
-
-    @dbus.service.signal(dbus_interface=INTERFACE_NAME,
-                         signature='')
-    def disable_fail(self):
-        """
-        L{disable_fail} is a signal sent to subscribers.  It is not
-        necessary for any actual work to occur in the method as it is called
-        for the effect of invoking its decorator.
-        """
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="",
-                         out_signature="b",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def disable(self, sender=None, conn=None):
-        if self._is_allowed_by_policy(sender, conn, POLICY_NAME):
-            if self._do_disabling():
-                self.disable_succeed()
-                return True
-            else:
-                self.disable_fail()
-                return False
-
-    @dbus.service.method(INTERFACE_NAME,
-                         in_signature="",
-                         out_signature="",
-                         sender_keyword="sender",
-                         connection_keyword="conn")
-    def exit(self, sender=None, conn=None):
-        """
-        Exit this process.
-        """
-        sys.exit(0)

=== removed file 'landscape/ui/model/registration/proxy.py'
--- landscape/ui/model/registration/proxy.py	2012-03-20 16:21:39 +0000
+++ landscape/ui/model/registration/proxy.py	1970-01-01 00:00:00 +0000
@@ -1,139 +0,0 @@
-import dbus
-
-import landscape.ui.model.registration.mechanism as mechanism
-
-
-class RegistrationProxy(object):
-    """
-    L{RegistrationProxy} allows the use of the L{RegistrationMechanism} via
-    DBus without having to know about DBus.  This in turn allows controller
-    code to remain agnostic to the implementation of registration.
-    """
-
-    def __init__(self, on_register_notify=None, on_register_error=None,
-                 on_register_succeed=None, on_register_fail=None,
-                 on_disable_succeed=None, on_disable_fail=None, bus=None):
-        self._bus = None
-        self._interface = None
-        self._on_register_notify = on_register_notify
-        self._on_register_error = on_register_error
-        self._on_register_succeed = on_register_succeed
-        self._on_register_fail = on_register_fail
-        self._on_disable_succeed = on_disable_succeed
-        self._on_disable_fail = on_disable_fail
-        self._setup_interface(bus)
-
-    def _setup_interface(self, bus):
-        """
-        Redefining L{_setup_interface} allows us to bypass DBus for more
-        convenient testing in some instances.
-        """
-        if bus is None:
-            self._bus = dbus.SystemBus()
-        else:
-            self._bus = bus
-        self._remote_object = self._bus.get_object(mechanism.SERVICE_NAME,
-                                                   mechanism.OBJECT_PATH)
-        self._interface = dbus.Interface(self._remote_object,
-                                         mechanism.INTERFACE_NAME)
-
-    def _exit_handler_wrapper(self, exit_handler):
-
-        def wrapped_exit_handler(message):
-            self._remove_handlers()
-            exit_handler(message)
-
-        return wrapped_exit_handler
-
-    def _register_handlers(self):
-        self._handlers = []
-        if self._on_register_notify:
-            self._handlers.append(
-                self._bus.add_signal_receiver(
-                    self._on_register_notify,
-                    signal_name="register_notify",
-                    dbus_interface=mechanism.INTERFACE_NAME,
-                    bus_name=None,
-                    path=mechanism.OBJECT_PATH))
-        if self._on_register_error:
-            self._handlers.append(
-                self._bus.add_signal_receiver(
-                    self._on_register_error,
-                    signal_name="register_error",
-                    dbus_interface=mechanism.INTERFACE_NAME,
-                    bus_name=None,
-                    path=mechanism.OBJECT_PATH))
-        if self._on_register_succeed:
-            self._handlers.append(
-                self._bus.add_signal_receiver(
-                    self._exit_handler_wrapper(self._on_register_succeed),
-                    signal_name="register_succeed",
-                    dbus_interface=mechanism.INTERFACE_NAME,
-                    bus_name=None,
-                    path=mechanism.OBJECT_PATH))
-        if self._on_register_fail:
-            self._handlers.append(
-                self._bus.add_signal_receiver(
-                    self._exit_handler_wrapper(self._on_register_fail),
-                    signal_name="register_fail",
-                    dbus_interface=mechanism.INTERFACE_NAME,
-                    bus_name=None,
-                    path=mechanism.OBJECT_PATH))
-        if self._on_disable_succeed:
-            self._handlers.append(
-                self._bus.add_signal_receiver(
-                    self._exit_handler_wrapper(self._on_disable_succeed),
-                    signal_name="disable_succeed",
-                    dbus_interface=mechanism.INTERFACE_NAME,
-                    bus_name=None,
-                    path=mechanism.OBJECT_PATH))
-        if self._on_disable_fail:
-            self._handlers.append(
-                self._bus.add_signal_receiver(
-                    self._exit_handler_wrapper(self._on_disable_fail),
-                    signal_name="disable_fail",
-                    dbus_interface=mechanism.INTERFACE_NAME,
-                    bus_name=None,
-                    path=mechanism.OBJECT_PATH))
-
-    def _remove_handlers(self):
-        for handler in self._handlers:
-            self._bus.remove_signal_receiver(handler)
-
-    def challenge(self):
-        return self._interface.challenge()
-
-    def register(self, config_path):
-        self._register_handlers()
-        try:
-            result, message = self._interface.register(config_path)
-        except dbus.DBusException, e:
-            if e.get_dbus_name() != "org.freedesktop.DBus.Error.NoReply":
-                raise
-            else:
-                result = False
-                message = "Registration timed out."
-        if result:
-            self._on_register_succeed()
-        else:
-            self._on_register_error(message)
-        return result
-
-    def disable(self):
-        self._register_handlers()
-        result = self._interface.disable()
-        if result:
-            self._on_disable_succeed()
-        else:
-            self._on_disable_fail()
-        return result
-
-    def exit(self):
-        """
-        Cause the mechanism to exit.
-        """
-        try:
-            self._interface.exit()
-        except dbus.DBusException, e:
-            if e.get_dbus_name() != "org.freedesktop.DBus.Error.NoReply":
-                raise

=== removed directory 'landscape/ui/model/registration/tests'
=== removed file 'landscape/ui/model/registration/tests/__init__.py'
=== removed file 'landscape/ui/model/registration/tests/test_mechanism.py'
--- landscape/ui/model/registration/tests/test_mechanism.py	2013-02-18 13:44:51 +0000
+++ landscape/ui/model/registration/tests/test_mechanism.py	1970-01-01 00:00:00 +0000
@@ -1,100 +0,0 @@
-import dbus
-
-from landscape.tests.helpers import LandscapeTest
-from landscape.ui.tests.helpers import dbus_test_should_skip, dbus_skip_message
-if not dbus_test_should_skip:
-    from landscape.ui.model.registration.mechanism import (
-        RegistrationMechanism, INTERFACE_NAME)
-
-
-class MechanismTest(LandscapeTest):
-    """
-    L{MechanismTest} mocks out the actual registration process and allows us to
-    simply and quickly check the outputs of registration that are relied on
-    elsewhere.
-    """
-
-    def setUp(self):
-        super(MechanismTest, self).setUp()
-        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-        bus = dbus.SessionBus(private=True)
-        self.bus_name = dbus.service.BusName(INTERFACE_NAME, bus)
-        self.mechanism = None
-
-    def tearDown(self):
-        if not self.mechanism is None:
-            self.mechanism.remove_from_connection()
-        super(MechanismTest, self).tearDown()
-
-    def make_fake_registration(self, succeed, message=""):
-        """
-        Return a fake registration method that will fail or succeed by
-        returning L{succeed} (a boolean).
-        """
-
-        def _do_registration(this, config_path):
-            return succeed, message
-
-        return _do_registration
-
-    def make_fake_disabling(self, succeed):
-        """
-        Return a fake disabling method that will fail or succeed by
-        returning L{succeed} (a boolean).
-        """
-
-        def _do_disabling(this):
-            return succeed
-
-        return _do_disabling
-
-    def test_registration_succeed(self):
-        """
-        Test we get appropriate feedback from a successful connection when we
-        call L{register} synchronously.
-        """
-        RegistrationMechanism._do_registration = self.make_fake_registration(
-            True)
-        self.mechanism = RegistrationMechanism(self.bus_name)
-        self.assertEqual(
-            (True, "Registration message sent to Landscape server.\n"),
-            self.mechanism.register("foo"))
-
-    def test_registration_fail(self):
-        """
-        Test we get appropriate feedback from a failed connection when we
-        call L{register} synchronously.
-        """
-        RegistrationMechanism._do_registration = self.make_fake_registration(
-            False, "boom")
-        self.mechanism = RegistrationMechanism(self.bus_name)
-        self.assertEqual((False, "boom"),
-                         self.mechanism.register("foo"))
-
-    def test_disabling_succeed(self):
-        """
-        Test we get True from a failed disabling when we call L{disable}
-        synchronously.
-        """
-        RegistrationMechanism._do_disabling = self.make_fake_disabling(True)
-        self.mechanism = RegistrationMechanism(self.bus_name)
-        self.assertTrue(self.mechanism.disable())
-
-    def test_disabling_fail(self):
-        """
-        Test we get False from a failed disabling when we call L{disable}
-        synchronously.
-        """
-        RegistrationMechanism._do_disabling = self.make_fake_disabling(False)
-        self.mechanism = RegistrationMechanism(self.bus_name)
-        self.assertFalse(self.mechanism.disable())
-
-    def test_exit(self):
-        """
-        Test that we cause the mechanism to exit.
-        """
-        self.mechanism = RegistrationMechanism(self.bus_name)
-        self.assertRaises(SystemExit, self.mechanism.exit)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed file 'landscape/ui/model/registration/tests/test_proxy.py'
--- landscape/ui/model/registration/tests/test_proxy.py	2013-02-18 13:44:51 +0000
+++ landscape/ui/model/registration/tests/test_proxy.py	1970-01-01 00:00:00 +0000
@@ -1,141 +0,0 @@
-import dbus
-
-from landscape.tests.helpers import LandscapeTest
-from landscape.ui.tests.helpers import dbus_test_should_skip, dbus_skip_message
-if not dbus_test_should_skip:
-    from landscape.ui.model.registration.mechanism import (
-        RegistrationMechanism, INTERFACE_NAME)
-    from landscape.ui.model.registration.proxy import RegistrationProxy
-
-
-class TimeoutTest(LandscapeTest):
-    """
-    L{TimeoutTest} bypasses DBus and tests with a faked method that raises a
-    timeout exception.
-    """
-
-    def setUp(self):
-        super(TimeoutTest, self).setUp()
-        self.error_handler_messages = []
-
-        class FakeBus(object):
-            """
-            Hello, I will be your fake DBus for this flight.
-            """
-
-        class FakeTimeoutException(dbus.DBusException):
-            _dbus_error_name = "org.freedesktop.DBus.Error.NoReply"
-
-        class FakeFailyMechanism(object):
-
-            def register(this, config_path, reply_handler=None,
-                         error_handler=None):
-                raise FakeTimeoutException()
-
-        def fake_setup_interface(this, bus):
-            this._interface = FakeFailyMechanism()
-            this._bus = bus
-
-        def fake_register_handlers(this):
-            pass
-
-        def fake_remove_handlers(this):
-            pass
-
-        def fake_error_handler(message):
-            self.error_handler_messages.append(message)
-
-        RegistrationProxy._setup_interface = fake_setup_interface
-        RegistrationProxy._register_handlers = fake_register_handlers
-        RegistrationProxy._remove_handlers = fake_remove_handlers
-        self.proxy = RegistrationProxy(bus=FakeBus(),
-                                       on_register_error=fake_error_handler)
-
-    def tearDown(self):
-        self.error_handler_messages = []
-        super(TimeoutTest, self).tearDown()
-
-    def test_register(self):
-        """
-        Test that the proxy calls through to the underlying interface and
-        correctly performs registration.
-        """
-        self.proxy.register("foo")
-        self.assertEqual(1, len(self.error_handler_messages))
-        [message] = self.error_handler_messages
-        self.assertEqual("Registration timed out.", message)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class RegistrationProxyTest(LandscapeTest):
-    """
-    L{RegistrationProxyTest} bypasses DBus to simply check the interface
-    between the proxy and the mechanism it would usually contact via DBus.
-    """
-
-    def setUp(self):
-        super(RegistrationProxyTest, self).setUp()
-        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-        bus = dbus.SessionBus(private=True)
-        bus_name = dbus.service.BusName(INTERFACE_NAME, bus)
-
-        def fake_do__registration(this, config_path):
-            return True, ""
-
-        def fake_do__disabling(this):
-            return True
-
-        RegistrationMechanism._do_registration = fake_do__registration
-        RegistrationMechanism._do_disabling = fake_do__disabling
-        self.mechanism = RegistrationMechanism(bus_name)
-
-        def fake_setup_interface(this, bus):
-            """
-            This just allows us to test without actually relying on dbus.
-            """
-            this._interface = self.mechanism
-
-        def fake_register_handlers(this):
-            pass
-
-        def fake_remove_handlers(this):
-            pass
-
-        def fake_callback(message=None):
-            pass
-
-        RegistrationProxy._setup_interface = fake_setup_interface
-        RegistrationProxy._register_handlers = fake_register_handlers
-        RegistrationProxy._remove_handlers = fake_remove_handlers
-        self.proxy = RegistrationProxy(fake_callback, fake_callback,
-                                       fake_callback, fake_callback,
-                                       fake_callback, fake_callback)
-
-    def tearDown(self):
-        self.mechanism.remove_from_connection()
-        super(RegistrationProxyTest, self).tearDown()
-
-    def test_register(self):
-        """
-        Test that the proxy calls through to the underlying interface and
-        correctly performs registration.
-        """
-        self.assertEqual(True, self.proxy.register("foo"))
-
-    def test_disable(self):
-        """
-        Test that the proxy calls through to the underlying interface and
-        correctly performs disabling.
-        """
-        self.assertEqual(True, self.proxy.disable())
-
-    def test_exit(self):
-        """
-        Test that we can cause the mechanism to exit.
-        """
-        self.assertRaises(SystemExit, self.proxy.exit)
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed directory 'landscape/ui/model/tests'
=== removed file 'landscape/ui/model/tests/__init__.py'
=== removed directory 'landscape/ui/tests'
=== removed file 'landscape/ui/tests/__init__.py'
=== removed file 'landscape/ui/tests/helpers.py'
--- landscape/ui/tests/helpers.py	2013-02-14 10:32:46 +0000
+++ landscape/ui/tests/helpers.py	1970-01-01 00:00:00 +0000
@@ -1,188 +0,0 @@
-import os
-
-from lxml import etree
-import dbus
-
-from landscape.configuration import LandscapeSetupConfiguration
-
-dbus_test_should_skip = False
-dbus_skip_message = "Cannot launch private DBus session without X11"
-try:
-    from gi.repository import GObject, Gtk
-    got_gobject_introspection = True
-    # Shut up pyflakes
-    dbus_skip_message = GObject._version + str(Gtk.MAJOR_VERSION) 
-except (ImportError, RuntimeError):
-    got_gobject_introspection = False
-    dbus_test_should_skip = True
-    dbus_skip_message = "GObject Introspection module unavailable"
-    bus = object
-    bus_name = ""
-
-
-if got_gobject_introspection:
-    from gi.repository import Gdk
-    from landscape.ui.model.configuration.mechanism import (
-        INTERFACE_NAME, ConfigurationMechanism)
-    from landscape.ui.model.configuration.proxy import ConfigurationProxy
-    # We have to do these steps because the ConfigurationMechanism inherits
-    # from dbus.service.Object which throws a fit if it notices you using
-    # it without a mainloop.
-    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
-    try:
-        bus = dbus.SessionBus(private=True)
-        bus_name = dbus.service.BusName(INTERFACE_NAME, bus)
-    except dbus.exceptions.DBusException:
-        bus = object
-        bus_name = ""
-        dbus_test_should_skip = True
-        dbus_skip_message = "Cannot launch private DBus session without X11"
-
-
-class ConfigurationProxyHelper(object):
-    """
-    L{ConfigurationProxyHelper} will provide it's test case with a
-    L{ConfigurationProxy} setup in such a way that it uses a real
-    L{ConfigurationMechanism} (which in turn uses a real
-    L{LandscapeSetupConfiguration}) but which does not make use of DBus for
-    communication.
-
-    Tests utilising this helper must define a L{test_case.config_string} for
-    use in L{set_up} below.
-    """
-
-    def set_up(self, test_case):
-        if not dbus_test_should_skip:
-            test_case.config_filename = test_case.makeFile(
-                test_case.config_string)
-            test_case.config = LandscapeSetupConfiguration()
-            test_case.config.default_config_filenames = \
-                [test_case.config_filename]
-
-            if got_gobject_introspection:
-                test_case.mechanism = ConfigurationMechanism(test_case.config,
-                                                             bus_name)
-
-                test_case.proxy = ConfigurationProxy(
-                    interface=test_case.mechanism)
-                test_case.proxy.load(["-c", test_case.config_filename])
-
-    def tear_down(self, test_case):
-        if not dbus_test_should_skip and got_gobject_introspection:
-            test_case.mechanism.remove_from_connection()
-
-
-class FakeGSettings(object):
-    """
-    This class impersonates a real L{gi.repostiroy.Gio.GSettings}
-    object to allow for testing code that utilises it without setting values in
-    the live DConf.
-    """
-
-    calls = {}
-
-    def __init__(self, data={}):
-        self.set_data(data)
-        tree = etree.parse(
-            os.path.join(
-                os.path.dirname(os.path.abspath(__file__)),
-                "../../../",
-                "glib-2.0/schemas/",
-                "com.canonical.landscape-client-settings.gschema.xml"))
-        root = tree.getroot()
-        self.schema = root.find("schema")
-        assert(self.schema.attrib["id"] ==
-               "com.canonical.landscape-client-settings")
-        self.keys = {}
-        for key in self.schema.findall("key"):
-            self.keys[key.attrib["name"]] = key.attrib["type"]
-
-    def check_key_data(self, name, gstype):
-        if name in self.keys:
-            if self.keys[name] == gstype:
-                return True
-            else:
-                raise ValueError("The GSchema file says %s is a %s, " +
-                                 "but you asked for a %s" %
-                                 (name, self.keys[name], gstype))
-        else:
-            raise KeyError("Can't find %s in the GSchema file!" % name)
-
-    def get_value(self, name, gstype):
-        if self.check_key_data(name, gstype):
-            return self.data[name]
-
-    def set_value(self, name, gstype, value):
-        if self.check_key_data(name, gstype):
-            self.data[name] = value
-
-    def set_data(self, data):
-        self.data = data
-
-    def _call(self, name, *args):
-        [count, arglist] = self.calls.get(name, (0, []))
-        count += 1
-        arglist.append(self._args_to_string(*args))
-        self.calls[name] = [count, arglist]
-
-    def _args_to_string(self, *args):
-        return "|".join([str(arg) for arg in args])
-
-    def new(self, key):
-        self._call("new", key)
-        return self
-
-    def connect(self, signal, callback, *args):
-        self._call("connect", signal, callback, *args)
-
-    def get_boolean(self, name):
-        self._call("get_boolean", name)
-        return self.get_value(name, "b")
-
-    def set_boolean(self, name, value):
-        self._call("set_boolean", name, value)
-        self.set_value(name, "b", value)
-
-    def get_string(self, name):
-        self._call("get_string", name)
-        return self.get_value(name, "s")
-
-    def set_string(self, name, value):
-        self._call("set_string", name, value)
-        self.set_value(name, "s", value)
-
-    def was_called(self, name):
-        return self.calls.haskey(name)
-
-    def was_called_with_args(self, name, *args):
-        try:
-            [count, arglist] = self.calls.get(name, (0, []))
-        except KeyError:
-            return False
-
-        expected_args = self._args_to_string(*args)
-        return expected_args in arglist
-
-
-def simulate_gtk_key_release(widget, key):
-    """
-    Simulates a keypress in a widget
-
-    @param widget: The widget which should receive the keypress.
-    @param key: The key to use.
-    """
-    widget.insert_text(key, -1)
-
-
-def simulate_gtk_paste(widget, pasted_text):
-    """
-    Simulates pasting text into a editable element.
-
-    @param widget: The widget which should receive the paste.
-    @param pasted_text: The text to paste into the widget.
-    """
-    widget.set_text("")
-    clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
-    clipboard.set_text(pasted_text, len=-1)
-    widget.set_position(0)
-    widget.paste_clipboard()

=== removed directory 'landscape/ui/view'
=== removed file 'landscape/ui/view/__init__.py'
=== removed file 'landscape/ui/view/configuration.py'
--- landscape/ui/view/configuration.py	2012-08-27 15:35:05 +0000
+++ landscape/ui/view/configuration.py	1970-01-01 00:00:00 +0000
@@ -1,356 +0,0 @@
-import re
-import os
-
-from gettext import gettext as _
-
-from gi.repository import GObject, Gtk
-
-from landscape.ui.constants import (
-    CANONICAL_MANAGED, LOCAL_MANAGED, NOT_MANAGED)
-
-# Note, I think this may not be fully compliant with the changes in RFC 1123
-HOST_NAME_REGEXP = re.compile("^(([a-zA-Z][a-zA-Z0-9\-]*)?[a-zA-Z0-9][\.]?)*"
-                              "(([A-Za-z][A-Za-z0-9\-]*)?[A-Za-z0-9])$")
-
-
-def sanitise_host_name(host_name):
-    """
-    Do some minimal host name sanitation.
-    """
-    return host_name.strip()
-
-
-def is_valid_host_name(host_name):
-    """
-    Check that the provided host name complies with L{HOST_NAME_REGEXP} and is
-    therefor valid.
-    """
-    return HOST_NAME_REGEXP.match(host_name) is not None
-
-
-def is_ascii(text):
-    """
-    Test that the provided string contains only characters from the ASCII set.
-    """
-    try:
-        text.decode("ascii")
-        return True
-    except UnicodeDecodeError:
-        return False
-
-
-class ClientSettingsDialog(Gtk.Dialog):
-    """
-    L{ClientSettingsDialog} is a subclass of Gtk.Dialog that loads the UI
-    components from the associated Glade XML file and wires everything up to
-    the controller.
-    """
-
-    GLADE_FILE = "landscape-client-settings.glade"
-    INVALID_HOST_NAME = 0
-    UNICODE_IN_ENTRY = 1
-
-    def __init__(self, controller):
-        super(ClientSettingsDialog, self).__init__(
-            title=_("Landscape Service"),
-            flags=Gtk.DialogFlags.MODAL)
-        self.set_default_icon_name("preferences-management-service")
-        self.set_resizable(False)
-        self._initialised = False
-        self._validation_errors = set()
-        self._errored_entries = []
-        self.controller = controller
-        self.setup_ui()
-        self.load_data()
-        # One extra revert to reset after loading data
-        self.controller.revert()
-
-    def indicate_error_on_entry(self, entry):
-        """
-        Show a warning icon on a L{Gtk.Entry} to indicate some associated
-        error.
-        """
-        entry.set_icon_from_stock(
-            Gtk.EntryIconPosition.PRIMARY, Gtk.STOCK_DIALOG_WARNING)
-        self._errored_entries.append(entry)
-
-    def check_local_landscape_host_name_entry(self):
-        host_name = sanitise_host_name(
-            self.local_landscape_host_entry.get_text())
-        ascii_ok = is_ascii(host_name)
-        host_name_ok = is_valid_host_name(host_name)
-        if ascii_ok and host_name_ok:
-            self.local_landscape_host_entry.set_text(host_name)
-            return True
-        else:
-            self.indicate_error_on_entry(self.local_landscape_host_entry)
-            if not host_name_ok:
-                self._validation_errors.add(self.INVALID_HOST_NAME)
-            if not ascii_ok:
-                self._validation_errors.add(self.UNICODE_IN_ENTRY)
-            return False
-
-    def check_entry(self, entry):
-        """
-        Check that the text content of a L{Gtk.Entry} is acceptable.
-        """
-        if is_ascii(entry.get_text()):
-            return True
-        else:
-            self.indicate_error_on_entry(entry)
-            self._validation_errors.add(self.UNICODE_IN_ENTRY)
-            return False
-
-    def validity_check(self):
-        self._validation_errors = set()
-        if self._info_bar_container.get_visible():
-            self.dismiss_infobar(None)
-        active_iter = self.liststore.get_iter(
-            self.use_type_combobox.get_active())
-        [management_type] = self.liststore.get(active_iter, 0)
-        if management_type == NOT_MANAGED:
-            return True
-        elif management_type == CANONICAL_MANAGED:
-            account_name_ok = self.check_entry(self.hosted_account_name_entry)
-            password_ok = self.check_entry(self.hosted_password_entry)
-            return account_name_ok and password_ok
-        else:
-            host_name_ok = self.check_local_landscape_host_name_entry()
-            password_ok = self.check_entry(self.local_password_entry)
-            return host_name_ok and password_ok
-
-    @property
-    def NO_SERVICE_TEXT(self):
-        return _("None")
-
-    @property
-    def HOSTED_SERVICE_TEXT(self):
-        return _("Landscape - hosted by Canonical")
-
-    @property
-    def LOCAL_SERVICE_TEXT(self):
-        return _("Landscape - dedicated server")
-
-    @property
-    def REGISTER_BUTTON_TEXT(self):
-        return _("Register")
-
-    @property
-    def DISABLE_BUTTON_TEXT(self):
-        return _("Disable")
-
-    @property
-    def INVALID_HOST_NAME_MESSAGE(self):
-        return _("Invalid host name.")
-
-    @property
-    def UNICODE_IN_ENTRY_MESSAGE(self):
-        return _("Only ASCII characters are allowed.")
-
-    def _set_use_type_combobox_from_controller(self):
-        """
-        Load the persisted L{management_type} from the controller and set the
-        combobox appropriately.
-
-        Note that Gtk makes us jump through some hoops by having it's own model
-        level to deal with here.  The conversion between paths and iters makes
-        more sense if you understand that treeviews use the same model.
-        """
-        list_iter = self.liststore.get_iter_first()
-        while (self.liststore.get(list_iter, 0)[0] !=
-               self.controller.management_type):
-            list_iter = self.liststore.iter_next(list_iter)
-        path = self.liststore.get_path(list_iter)
-        [index] = path.get_indices()
-        self.use_type_combobox.set_active(index)
-
-    def _set_hosted_values_from_controller(self):
-        self.hosted_account_name_entry.set_text(
-            self.controller.hosted_account_name)
-        self.hosted_password_entry.set_text(self.controller.hosted_password)
-
-    def _set_local_values_from_controller(self):
-        self.local_landscape_host_entry.set_text(
-            self.controller.local_landscape_host)
-        self.local_password_entry.set_text(self.controller.local_password)
-
-    def load_data(self):
-        self._initialised = False
-        self.controller.load()
-        self._set_hosted_values_from_controller()
-        self._set_local_values_from_controller()
-        self._set_use_type_combobox_from_controller()
-        self._initialised = True
-
-    def make_liststore(self):
-        """
-        Construct the correct L{Gtk.ListStore} to drive the L{Gtk.ComboBox} for
-        use-type.  This a table of:
-
-           * Management type (key)
-           * Text to display in the combobox
-           * L{Gtk.Frame} to load when this item is selected.
-        """
-        liststore = Gtk.ListStore(GObject.TYPE_PYOBJECT,
-                                  GObject.TYPE_STRING,
-                                  GObject.TYPE_PYOBJECT)
-        self.active_widget = None
-        liststore.append([NOT_MANAGED, self.NO_SERVICE_TEXT,
-                          self._builder.get_object("no-service-frame")])
-        liststore.append([CANONICAL_MANAGED, self.HOSTED_SERVICE_TEXT,
-                          self._builder.get_object("hosted-service-frame")])
-        liststore.append([LOCAL_MANAGED, self.LOCAL_SERVICE_TEXT,
-                          self._builder.get_object("local-service-frame")])
-        return liststore
-
-    def link_hosted_service_widgets(self):
-        self.hosted_account_name_entry = self._builder.get_object(
-            "hosted-account-name-entry")
-        self.hosted_account_name_entry.connect(
-            "changed", self.on_changed_event, "hosted_account_name")
-
-        self.hosted_password_entry = self._builder.get_object(
-            "hosted-password-entry")
-        self.hosted_password_entry.connect(
-            "changed", self.on_changed_event, "hosted_password")
-
-    def link_local_service_widgets(self):
-        self.local_landscape_host_entry = self._builder.get_object(
-            "local-landscape-host-entry")
-        self.local_landscape_host_entry.connect(
-            "changed", self.on_changed_event, "local_landscape_host")
-
-        self.local_password_entry = self._builder.get_object(
-            "local-password-entry")
-        self.local_password_entry.connect(
-            "changed", self.on_changed_event, "local_password")
-
-    def link_use_type_combobox(self, liststore):
-        self.use_type_combobox = self._builder.get_object("use-type-combobox")
-        self.use_type_combobox.connect("changed", self.on_combo_changed)
-        self.use_type_combobox.set_model(liststore)
-        cell = Gtk.CellRendererText()
-        self.use_type_combobox.pack_start(cell, True)
-        self.use_type_combobox.add_attribute(cell, 'text', 1)
-
-    def cancel_response(self, widget):
-        self.response(Gtk.ResponseType.CANCEL)
-
-    def register_response(self, widget):
-        if self.validity_check():
-            self.response(Gtk.ResponseType.OK)
-        else:
-            error_text = []
-            if self.UNICODE_IN_ENTRY in self._validation_errors:
-                error_text.append(self.UNICODE_IN_ENTRY_MESSAGE)
-            if self.INVALID_HOST_NAME in self._validation_errors:
-                error_text.append(self.INVALID_HOST_NAME_MESSAGE)
-            self.info_message.set_text("\n".join(error_text))
-            self._info_bar_container.show()
-
-    def set_button_text(self, management_type):
-        [alignment] = self.register_button.get_children()
-        [hbox] = alignment.get_children()
-        [image, label] = hbox.get_children()
-        if management_type == NOT_MANAGED:
-            label.set_text(self.DISABLE_BUTTON_TEXT)
-        else:
-            label.set_text(self.REGISTER_BUTTON_TEXT)
-
-    def setup_buttons(self):
-        self.revert_button = Gtk.Button(stock=Gtk.STOCK_REVERT_TO_SAVED)
-        self.action_area.pack_start(self.revert_button, True, True, 0)
-        self.revert_button.connect("clicked", self.revert)
-        self.revert_button.show()
-        self.cancel_button = Gtk.Button(stock=Gtk.STOCK_CANCEL)
-        self.action_area.pack_start(self.cancel_button, True, True, 0)
-        self.cancel_button.show()
-        self.cancel_button.connect("clicked", self.cancel_response)
-        self.register_button = Gtk.Button(stock=Gtk.STOCK_OK)
-        self.action_area.pack_start(self.register_button, True, True, 0)
-        self.register_button.show()
-        self.register_button.connect("clicked", self.register_response)
-
-    def dismiss_infobar(self, widget):
-        self._info_bar_container.hide()
-        for entry in self._errored_entries:
-            entry.set_icon_from_stock(Gtk.EntryIconPosition.PRIMARY, None)
-        self._errored_entries = []
-
-    def setup_info_bar(self):
-        labels_size_group = self._builder.get_object("labels-sizegroup")
-        entries_size_group = self._builder.get_object("entries-sizegroup")
-        labels_size_group.set_ignore_hidden(False)
-        entries_size_group.set_ignore_hidden(False)
-        self._info_bar_container = Gtk.HBox()
-        self._info_bar_container.set_spacing(12)
-        info_bar = Gtk.InfoBar()
-        entries_size_group.add_widget(info_bar)
-        info_bar.show()
-        empty_label = Gtk.Label()
-        labels_size_group.add_widget(empty_label)
-        empty_label.show()
-        self._info_bar_container.pack_start(empty_label, expand=False,
-                                            fill=False, padding=0)
-        self._info_bar_container.pack_start(info_bar, expand=False, fill=False,
-                                            padding=0)
-        content_area = info_bar.get_content_area()
-        hbox = Gtk.HBox()
-        self.info_message = Gtk.Label()
-        self.info_message.set_alignment(0, 0.5)
-        self.info_message.show()
-        hbox.pack_start(self.info_message, expand=True, fill=True, padding=6)
-        ok_button = Gtk.Button("Dismiss")
-        ok_button.connect("clicked", self.dismiss_infobar)
-        ok_button.show()
-        hbox.pack_start(ok_button, expand=True, fill=True, padding=0)
-        hbox.show()
-        content_area.pack_start(hbox, expand=True, fill=True, padding=0)
-
-    def setup_ui(self):
-        self._builder = Gtk.Builder()
-        self._builder.set_translation_domain("landscape-client")
-        self._builder.add_from_file(
-            os.path.join(
-                os.path.dirname(__file__), "ui", self.GLADE_FILE))
-        content_area = self.get_content_area()
-        content_area.set_spacing(12)
-        self.set_border_width(12)
-        self.setup_info_bar()
-        self._vbox = self._builder.get_object("toplevel-vbox")
-        self._vbox.unparent()
-        content_area.pack_start(self._vbox, expand=True, fill=True,
-                                padding=12)
-        self._vbox.pack_start(self._info_bar_container, expand=False,
-                              fill=False, padding=0)
-        self.liststore = self.make_liststore()
-        self.link_use_type_combobox(self.liststore)
-        self.link_hosted_service_widgets()
-        self.link_local_service_widgets()
-        self.setup_buttons()
-
-    def on_combo_changed(self, combobox):
-        list_iter = self.liststore.get_iter(combobox.get_active())
-        if not self.active_widget is None:
-            self._vbox.remove(self.active_widget)
-        [management_type] = self.liststore.get(list_iter, 0)
-        self.set_button_text(management_type)
-        if self._initialised:
-            self.controller.management_type = management_type
-            self.controller.modify()
-        [self.active_widget] = self.liststore.get(list_iter, 2)
-        self.active_widget.unparent()
-        self._vbox.add(self.active_widget)
-
-    def on_changed_event(self, widget, attribute):
-        setattr(self.controller, attribute, widget.get_text())
-        self.controller.modify()
-
-    def quit(self, *args):
-        self.destroy()
-
-    def revert(self, button):
-        self.controller.revert()
-        self.load_data()
-        # One extra revert to reset after loading data
-        self.controller.revert()

=== removed directory 'landscape/ui/view/tests'
=== removed file 'landscape/ui/view/tests/__init__.py'
=== removed file 'landscape/ui/view/tests/test_configuration.py'
--- landscape/ui/view/tests/test_configuration.py	2013-02-14 10:32:46 +0000
+++ landscape/ui/view/tests/test_configuration.py	1970-01-01 00:00:00 +0000
@@ -1,608 +0,0 @@
-import sys
-
-from landscape.ui.tests.helpers import (
-    ConfigurationProxyHelper, FakeGSettings, dbus_test_should_skip,
-    dbus_skip_message, simulate_gtk_key_release, simulate_gtk_paste)
-
-if not dbus_test_should_skip:
-    from gi.repository import Gtk
-    from landscape.ui.view.configuration import (
-        ClientSettingsDialog, sanitise_host_name, is_valid_host_name)
-    from landscape.ui.controller.configuration import ConfigController
-    import landscape.ui.model.configuration.state
-    from landscape.ui.model.configuration.state import (
-        COMPUTER_TITLE, ConfigurationModel)
-    from landscape.ui.model.configuration.uisettings import UISettings
-
-from landscape.tests.helpers import LandscapeTest
-
-
-class ViewFunctionsTest(LandscapeTest):
-
-    def test_sanitise_host_name(self):
-        """
-        Test UI level host_name sanitation.
-        """
-        self.assertEqual("foo.bar", sanitise_host_name(" foo.bar"))
-        self.assertEqual("foo.bar", sanitise_host_name("foo.bar "))
-        self.assertEqual("foo.bar", sanitise_host_name(" foo.bar "))
-
-    def test_is_valid_host_name_ok(self):
-        """
-        Test that valid host names cause L{is_valid_host_name} to return
-        L{True}.
-        """
-        self.assertTrue(is_valid_host_name("a"))
-        self.assertTrue(is_valid_host_name("a.b"))
-        self.assertTrue(is_valid_host_name("a.b.c"))
-        self.assertTrue(is_valid_host_name("stop-squark"))
-        self.assertTrue(is_valid_host_name("stop-squark.teale.DE"))
-        self.assertTrue(is_valid_host_name("a2.b3.c4"))
-
-    def test_is_valid_host_name_bad(self):
-        """
-        Test that invalid host names cause L{is_valid_host_name} to return
-        L{False}.
-        """
-        self.assertFalse(is_valid_host_name(".a"))
-        self.assertFalse(is_valid_host_name("a."))
-        self.assertFalse(is_valid_host_name("a b"))
-        self.assertFalse(is_valid_host_name("a .b"))
-        self.assertFalse(is_valid_host_name("a. b"))
-
-    def test_is_valid_host_name_unicode(self):
-        """
-        Test that host names containing Unicode cause L{is_valid_host_name} to
-        return L{False}.
-        """
-        self.assertFalse(is_valid_host_name(u"\xc3a"))
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class ConfigurationViewTest(LandscapeTest):
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.default_data = {"management-type": "canonical",
-                             "computer-title": "",
-                             "hosted-landscape-host": "",
-                             "hosted-account-name": "",
-                             "hosted-password": "",
-                             "local-landscape-host": "",
-                             "local-account-name": "",
-                             "local-password": ""}
-
-        self.config_string = (
-            "[client]\n"
-            "data_path = %s\n"
-            "http_proxy = http://proxy.localdomain:3192\n"
-            "tags = a_tag\n"
-            "url = https://landscape.canonical.com/message-system\n"
-            "account_name = foo\n"
-            "registration_key = bar\n"
-            "computer_title = baz\n"
-            "https_proxy = https://proxy.localdomain:6192\n"
-            "ping_url = http://landscape.canonical.com/ping\n" % sys.path[0])
-
-        super(ConfigurationViewTest, self).setUp()
-        landscape.ui.model.configuration.state.DEFAULT_DATA[COMPUTER_TITLE] \
-            = "me.here.com"
-        settings = FakeGSettings(data=self.default_data)
-        self.uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy,
-                                   uisettings=self.uisettings)
-        self.controller = ConfigController(model)
-
-    def run_gtk_eventloop(self):
-        """Run the Gtk event loop until all events have been processed."""
-        while Gtk.events_pending():
-            Gtk.main_iteration()
-
-    def assert_paste_data_saved(self, dialog, combo, widget, attribute):
-        """
-        Paste text into specified widget then verify data is saved.
-        """
-        # Switch to local mode
-        dialog.use_type_combobox.set_active(combo)
-        self.run_gtk_eventloop()
-
-        simulate_gtk_paste(widget, "pasted text")
-        self.run_gtk_eventloop()
-        self.assertTrue(self.controller.is_modified)
-        self.assertEqual("pasted text", getattr(self.controller, attribute))
-
-        dialog.revert(None)
-        self.run_gtk_eventloop()
-        self.assertFalse(self.controller.is_modified)
-
-    def test_init(self):
-        """
-        Test that we correctly initialise the L{ConfigurationView} correctly
-        from the controller.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        content_area = dialog.get_content_area()
-        self.assertEqual("preferences-management-service",
-                         dialog.get_default_icon_name())
-        children = content_area.get_children()
-        self.assertEqual(len(children), 2)
-        box = children[0]
-        self.assertIsInstance(box, Gtk.Box)
-        self.assertEqual(1, dialog.use_type_combobox.get_active())
-
-    def test_on_combobox_changed(self):
-        """
-        Test that changes to the active selection in L{use_type_combobox}
-        result in the correct panel becoming active and visible.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        iter = dialog.liststore.get_iter(0)
-        no_service_frame = dialog.liststore.get(iter, 2)[0]
-        iter = dialog.liststore.get_iter(1)
-        hosted_service_frame = dialog.liststore.get(iter, 2)[0]
-        iter = dialog.liststore.get_iter(2)
-        local_service_frame = dialog.liststore.get(iter, 2)[0]
-
-        self.assertEqual(1, dialog.use_type_combobox.get_active())
-        [alignment] = dialog.register_button.get_children()
-        [hbox] = alignment.get_children()
-        [image, label] = hbox.get_children()
-
-        self.run_gtk_eventloop()
-        self.assertIs(hosted_service_frame, dialog.active_widget)
-        self.assertEqual(dialog.REGISTER_BUTTON_TEXT, label.get_text())
-
-        dialog.use_type_combobox.set_active(0)
-        self.run_gtk_eventloop()
-        self.assertIs(no_service_frame, dialog.active_widget)
-        self.assertEqual(dialog.DISABLE_BUTTON_TEXT, label.get_text())
-
-        dialog.use_type_combobox.set_active(2)
-        self.run_gtk_eventloop()
-        self.assertIs(local_service_frame, dialog.active_widget)
-        self.assertEqual(dialog.REGISTER_BUTTON_TEXT, label.get_text())
-
-    def test_modify(self):
-        """
-        Test that modifications to data in the UI are propagated to the
-        controller.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        self.assertFalse(self.controller.is_modified)
-        self.assertEqual(1, dialog.use_type_combobox.get_active())
-        dialog.use_type_combobox.set_active(2)
-        self.run_gtk_eventloop()
-        self.assertTrue(self.controller.is_modified)
-        dialog.revert(None)
-        self.run_gtk_eventloop()
-        self.assertFalse(self.controller.is_modified)
-        simulate_gtk_key_release(dialog.hosted_account_name_entry, "A")
-        self.run_gtk_eventloop()
-        self.assertTrue(self.controller.is_modified)
-        dialog.revert(None)
-        self.run_gtk_eventloop()
-        self.assertFalse(self.controller.is_modified)
-        simulate_gtk_key_release(dialog.hosted_password_entry, "B")
-        self.run_gtk_eventloop()
-        self.assertTrue(self.controller.is_modified)
-        dialog.revert(None)
-        self.run_gtk_eventloop()
-        self.assertFalse(self.controller.is_modified)
-        simulate_gtk_key_release(dialog.local_landscape_host_entry, "C")
-        self.run_gtk_eventloop()
-        self.assertTrue(self.controller.is_modified)
-
-    def test_modify_with_paste(self):
-        """
-        Non-keypress modifications to data in the UI are propagated to the
-        controller.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        self.assertFalse(self.controller.is_modified)
-        self.assertEqual(1, dialog.use_type_combobox.get_active())
-        # Test hosted account name
-        self.assert_paste_data_saved(dialog, 1,
-                                     dialog.hosted_account_name_entry,
-                                     "hosted_account_name")
-        # Test hosted password
-        self.assert_paste_data_saved(dialog, 1,
-                                     dialog.hosted_password_entry,
-                                     "hosted_password")
-        # Test local hostname
-        self.assert_paste_data_saved(dialog, 2,
-                                     dialog.local_landscape_host_entry,
-                                     "local_landscape_host")
-        # Test local password
-        self.assert_paste_data_saved(dialog, 2,
-                                     dialog.local_password_entry,
-                                     "local_password")
-
-    def test_load_data_from_config(self):
-        """
-        Test that we load data into the appropriate entries from the
-        configuration file.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.assertEqual(1, dialog.use_type_combobox.get_active())
-        self.assertEqual("foo", dialog.hosted_account_name_entry.get_text())
-        self.assertEqual("bar", dialog.hosted_password_entry.get_text())
-        self.assertEqual("", dialog.local_landscape_host_entry.get_text())
-        self.assertEqual("", dialog.local_password_entry.get_text())
-
-    def test_revert(self):
-        """
-        Test that we can revert the UI values using the controller.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        self.assertEqual(1, dialog.use_type_combobox.get_active())
-        self.assertEqual("foo", dialog.hosted_account_name_entry.get_text())
-        self.assertEqual("bar", dialog.hosted_password_entry.get_text())
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text("more.barn")
-        self.run_gtk_eventloop()
-        self.assertEqual("bar", dialog.hosted_password_entry.get_text())
-        self.assertEqual("more.barn",
-                         dialog.local_landscape_host_entry.get_text())
-        dialog.revert(None)
-        self.run_gtk_eventloop()
-        self.assertEqual(1, dialog.use_type_combobox.get_active())
-        self.assertEqual("foo", dialog.hosted_account_name_entry.get_text())
-        self.assertEqual("bar", dialog.hosted_password_entry.get_text())
-
-    def test_check_local_landscape_host_name_entry_ok(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} returns L{True} when
-        the input is a valid host name.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text("foo.bar")
-        self.assertTrue(dialog.check_local_landscape_host_name_entry())
-
-    def test_check_local_landscape_host_name_entry_ok_not_recorded(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} does not add the
-        entry to L{ClientSettingsDialog._errored_entries} when the input is a
-        valid host name.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text("foo.bar")
-        dialog.check_local_landscape_host_name_entry()
-        self.assertEqual(0, len(dialog._errored_entries))
-
-    def test_check_local_landscape_host_name_entry_bad_host_name(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} returns L{False}
-        when the input is not a valid host name.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text("foo bar")
-        self.assertFalse(dialog.check_local_landscape_host_name_entry())
-
-    def test_check_local_landscape_host_name_entry_bad_recorded(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} does add the
-        entry to L{ClientSettingsDialog._errored_entries} when the input is not
-        a valid host name.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text("foo bar")
-        dialog.check_local_landscape_host_name_entry()
-        self.assertEqual(1, len(dialog._errored_entries))
-
-    def test_check_local_landscape_host_name_entry_bad_error_type(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} adds the correct
-        error type to L{ClientSettingsDialog._validation_errors} when the input
-        is not a valid host name.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text("foo bar")
-        dialog.check_local_landscape_host_name_entry()
-        self.assertEqual(set([dialog.INVALID_HOST_NAME]),
-                         dialog._validation_errors)
-
-    def test_check_local_landscape_host_name_entry_unicode_in_host_name(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} returns L{False}
-        when the input contains Unicode.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text(u"f\xc3.bar")
-        self.assertFalse(dialog.check_local_landscape_host_name_entry())
-
-    def test_check_local_landscape_host_name_entry_unicode_recorded(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} does add the
-        entry to L{ClientSettingsDialog._errored_entries} when the input
-        contains Unicode.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text(u"f\xc3.bar")
-        dialog.check_local_landscape_host_name_entry()
-        self.assertEqual(1, len(dialog._errored_entries))
-
-    def test_check_local_landscape_host_name_entry_unicode_error_type(self):
-        """
-        Test that L{check_local_landscape_host_name_entry} adds the correct
-        error type to L{ClientSettingsDialog._validation_errors} when the input
-        contains Unicode.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text(u"f\xc3.bar")
-        dialog.check_local_landscape_host_name_entry()
-        self.assertEqual(
-            set([dialog.INVALID_HOST_NAME, dialog.UNICODE_IN_ENTRY]),
-            dialog._validation_errors)
-
-    def test_check_entry_ok(self):
-        """
-        Test that we return L{True} when the text of a L{Gtk.Entry} is valid
-        input.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(1)
-        self.run_gtk_eventloop()
-        dialog.hosted_account_name_entry.set_text("Toodleoo")
-        self.assertTrue(dialog.check_entry(dialog.hosted_account_name_entry))
-
-    def test_check_entry_doesnt_record_entry_when_ok(self):
-        """
-        Test that, when the text of a L{Gtk.Entry} is valid nothing is added to
-        L{ClientSettingsDialog._errored_entries}.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(1)
-        self.run_gtk_eventloop()
-        dialog.hosted_account_name_entry.set_text("Toodleoo")
-        dialog.check_entry(dialog.hosted_account_name_entry)
-        self.assertEqual(0, len(dialog._errored_entries))
-
-    def test_check_entry_non_ascii(self):
-        """
-        Test that we return L{False} when the text of a L{Gtk.Entry} contains
-        Unicode input.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(1)
-        self.run_gtk_eventloop()
-        dialog.hosted_account_name_entry.set_text(u"T\xc3dle\xc4")
-        self.assertFalse(dialog.check_entry(dialog.hosted_account_name_entry))
-
-    def test_check_entry_records_entry_when_non_ascii(self):
-        """
-        Test that, when the text of a L{Gtk.Entry} contains Unicode it is
-        added to L{ClientSettingsDialog._errored_entries}.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(1)
-        self.run_gtk_eventloop()
-        dialog.hosted_account_name_entry.set_text(u"T\xc3dle\xc4")
-        dialog.check_entry(dialog.hosted_account_name_entry)
-        self.assertEqual(1, len(dialog._errored_entries))
-
-    def test_dismiss_validation_errors_local(self):
-        """
-        Test that dismissing the validation errors tidies up indicators that
-        have been set against local settings.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(1)
-        self.run_gtk_eventloop()
-        dialog.hosted_account_name_entry.set_text(u"T\xc3dle\xc4")
-        dialog.hosted_password_entry.set_text(u"T\xc3dle\xc4")
-        self.run_gtk_eventloop()
-        dialog.validity_check()
-        self.run_gtk_eventloop()
-        self.assertEqual(2, len(dialog._errored_entries))
-        [entry1, entry2] = dialog._errored_entries
-        self.assertEqual(Gtk.STOCK_DIALOG_WARNING,
-                         entry1.get_icon_stock(Gtk.EntryIconPosition.PRIMARY))
-        self.assertEqual(Gtk.STOCK_DIALOG_WARNING,
-                         entry2.get_icon_stock(Gtk.EntryIconPosition.PRIMARY))
-        dialog.dismiss_infobar(None)
-        self.run_gtk_eventloop()
-        self.assertEqual(0, len(dialog._errored_entries))
-        self.assertNotEqual(
-            Gtk.STOCK_DIALOG_WARNING,
-            entry1.get_icon_stock(Gtk.EntryIconPosition.PRIMARY))
-        self.assertNotEqual(
-            Gtk.STOCK_DIALOG_WARNING,
-            entry2.get_icon_stock(Gtk.EntryIconPosition.PRIMARY))
-
-    def test_dismiss_validation_errors_hosted(self):
-        """
-        Test that dismissing the validation errors tidies up indicators that
-        have been set against hosted fields.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(2)
-        self.run_gtk_eventloop()
-        dialog.local_landscape_host_entry.set_text("dodgy as hell")
-        self.run_gtk_eventloop()
-        dialog.validity_check()
-        self.run_gtk_eventloop()
-        self.assertEqual(1, len(dialog._errored_entries))
-        [entry1] = dialog._errored_entries
-        self.assertEqual(Gtk.STOCK_DIALOG_WARNING,
-                         entry1.get_icon_stock(Gtk.EntryIconPosition.PRIMARY))
-        dialog.dismiss_infobar(None)
-        self.run_gtk_eventloop()
-        self.assertEqual(0, len(dialog._errored_entries))
-        self.assertNotEqual(
-            Gtk.STOCK_DIALOG_WARNING,
-            entry1.get_icon_stock(Gtk.EntryIconPosition.PRIMARY))
-
-    def test_validity_check_disabled(self):
-        """
-        Test that the L{validity_check} returns True when we disable landscape
-        client.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(0)
-        self.run_gtk_eventloop()
-        self.assertTrue(dialog.validity_check())
-
-    def test_validity_check_hosted(self):
-        """
-        Test that the L{validity_check} returns True when the hosted fields are
-        valid.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(1)
-        dialog.hosted_account_name_entry.set_text("Bob")
-        dialog.hosted_password_entry.set_text("the builder")
-        self.run_gtk_eventloop()
-        self.assertTrue(dialog.validity_check())
-
-    def test_validity_check_hosted_unicode(self):
-        """
-        Test that the L{validity_check} returns False when the hosted fields
-        contain Unicode.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(1)
-        dialog.hosted_account_name_entry.set_text(u"B\xc3b")
-        self.run_gtk_eventloop()
-        self.assertFalse(dialog.validity_check())
-
-    def test_validity_check_local_ok(self):
-        """
-        Test that the L{validity_check} returns True when the local fields
-        are valid.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(2)
-        self.run_gtk_eventloop()
-        dialog.local_landscape_host_entry.set_text("foo.bar")
-        self.run_gtk_eventloop()
-        self.assertTrue(dialog.validity_check())
-
-    def test_validity_check_local_sanitisable(self):
-        """
-        Test that the L{validity_check} returns True when the local fields
-        are valid after sanitation.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text(" foo.bar")
-        self.run_gtk_eventloop()
-        self.assertTrue(dialog.validity_check())
-        dialog.local_landscape_host_entry.set_text("foo.bar ")
-        self.run_gtk_eventloop()
-        self.assertTrue(dialog.validity_check())
-
-    def test_validity_check_local_invalid_host_name(self):
-        """
-        Test that the L{validity_check} returns False when the host name is
-        invalid.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text("foo bar")
-        self.run_gtk_eventloop()
-        self.assertFalse(dialog.validity_check())
-
-    def test_validity_check_local_unicode(self):
-        """
-        Test that the L{validity_check} returns False when the host name
-        contains Unicode.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        self.run_gtk_eventloop()
-        dialog.use_type_combobox.set_active(2)
-        dialog.local_landscape_host_entry.set_text(u"f\xc3.bar")
-        self.run_gtk_eventloop()
-        self.assertFalse(dialog.validity_check())
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message
-
-
-class LocalConfigurationViewTest(LandscapeTest):
-
-    helpers = [ConfigurationProxyHelper]
-
-    def setUp(self):
-        self.default_data = {"management-type": "LDS",
-                             "computer-title": "",
-                             "hosted-landscape-host": "",
-                             "hosted-account-name": "",
-                             "hosted-password": "",
-                             "local-landscape-host": "",
-                             "local-account-name": "",
-                             "local-password": "manky"}
-
-        self.config_string = (
-            "[client]\n"
-            "data_path = %s\n"
-            "url = https://landscape.localdomain/message-system\n"
-            "computer_title = baz\n"
-            "ping_url = http://landscape.localdomain/ping\n" % sys.path[0])
-
-        super(LocalConfigurationViewTest, self).setUp()
-        landscape.ui.model.configuration.state.DEFAULT_DATA[COMPUTER_TITLE] \
-            = "me.here.com"
-        settings = FakeGSettings(data=self.default_data)
-        self.uisettings = UISettings(settings)
-        model = ConfigurationModel(proxy=self.proxy,
-                                   uisettings=self.uisettings)
-        self.controller = ConfigController(model)
-
-    def test_init(self):
-        """
-        Test that we correctly initialise the L{ConfigurationView} correctly
-        from the controller.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        while Gtk.events_pending():
-            Gtk.main_iteration()
-        content_area = dialog.get_content_area()
-        children = content_area.get_children()
-        self.assertEqual(len(children), 2)
-        box = children[0]
-        self.assertIsInstance(box, Gtk.Box)
-        self.assertEqual(2, dialog.use_type_combobox.get_active())
-
-    def test_load_data_from_config(self):
-        """
-        Test that we load data into the appropriate entries from the
-        configuration file.
-        """
-        dialog = ClientSettingsDialog(self.controller)
-        while Gtk.events_pending():
-            Gtk.main_iteration()
-        self.assertEqual(2, dialog.use_type_combobox.get_active())
-        self.assertEqual("", dialog.hosted_account_name_entry.get_text())
-        self.assertEqual("", dialog.hosted_password_entry.get_text())
-        self.assertEqual("landscape.localdomain",
-                         dialog.local_landscape_host_entry.get_text())
-        self.assertEqual("manky", dialog.local_password_entry.get_text())
-
-    if dbus_test_should_skip:
-        skip = dbus_skip_message

=== removed directory 'landscape/ui/view/ui'
=== removed file 'landscape/ui/view/ui/landscape-client-settings.glade'
--- landscape/ui/view/ui/landscape-client-settings.glade	2014-10-09 09:46:05 +0000
+++ landscape/ui/view/ui/landscape-client-settings.glade	1970-01-01 00:00:00 +0000
@@ -1,462 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated with glade 3.18.3 -->
-<interface>
-  <requires lib="gtk+" version="3.0"/>
-  <object class="GtkDialog" id="dialog1">
-    <property name="can_focus">False</property>
-    <property name="border_width">5</property>
-    <property name="type_hint">dialog</property>
-    <child internal-child="vbox">
-      <object class="GtkBox" id="dialog-vbox">
-        <property name="can_focus">False</property>
-        <property name="orientation">vertical</property>
-        <property name="spacing">2</property>
-        <child internal-child="action_area">
-          <object class="GtkButtonBox" id="dialog-action_area1">
-            <property name="can_focus">False</property>
-            <property name="layout_style">end</property>
-            <child>
-              <object class="GtkButton" id="revertbutton">
-                <property name="label">gtk-revert-to-saved</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_stock">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkButton" id="cancel-button">
-                <property name="label">gtk-cancel</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_stock">True</property>
-              </object>
-              <packing>
-                <property name="expand">False</property>
-                <property name="fill">True</property>
-                <property name="position">1</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkButton" id="ok-button">
-                <property name="label">gtk-ok</property>
-                <property name="use_action_appearance">False</property>
-                <property name="visible">True</property>
-                <property name="can_focus">True</property>
-                <property name="receives_default">True</property>
-                <property name="use_stock">True</property>
-              </object>