Merge lp:~veebers/autopilot/remove_object_registry-CPO_creation_explicit into lp:autopilot

[Christopher Lee]

Remove the idea of (and actual) the object registry

Remove the idea of (and actual) the object registry. CPO usage will now be explicit and not magic.
The CPO passed to the select_* methods (and get_children...) will instantiate the passed in proxy object class.

[lp:~veebers/autopilot/remove_object_registry-CPO_creation_explicit]

567. By Christopher Lee on 2015-06-12

Initial changes for async proxy creation (autopilot vis) not stable.

568. By Christopher Lee on 2015-06-15

Fix pyflake errors

569. By Christopher Lee on 2015-06-15

Merge and fix conflicts from push branch

570. By Christopher Lee on 2015-06-15

Another pyflake fix

571. By Christopher Lee on 2015-06-15

Remove question comment, has been answered

572. By Christopher Lee on 2015-06-15

Test for error message (error message has been improved.

573. By Christopher Lee on 2015-06-15

Further tests and fixes for an issue found

574. By Christopher Lee on 2015-06-18

Pyflake fixes.

575. By Christopher Lee on 2015-06-18

Make vis work

576. By Christopher Lee on 2015-06-18

Cleanup for vis make_proxy

577. By Christopher Lee on 2015-06-18

Slight cleanup and removal of unneeded method

578. By Christopher Lee on 2015-06-18

Remove comment and clear up question from comment.

579. By Christopher Lee on 2015-06-18

Clean up docstring

580. By Christopher Lee on 2015-06-18

Fix tests due to updated code.

581. By Christopher Lee on 2015-06-18

Initial renaming from emulator_base to cpo_class

582. By Christopher Lee on 2015-06-18

Remove conversion notes

583. By Christopher Lee on 2015-06-23

Merge pre-req. changes

584. By Christopher Lee on 2015-06-23

Remove changes that accidently got in

585. By Christopher Lee on 2015-06-26

Remove un-used method

586. By Christopher Lee on 2015-06-26

Remove question comment and update docstring.

587. By Christopher Lee on 2015-06-26

Fix whitespace issue.

588. By Christopher Lee on 2015-06-26

Remove un-used test class.

589. By Christopher Lee on 2015-07-19

Merge pre-req. updates.

Unmerged revisions

589. By Christopher Lee on 2015-07-19

Merge pre-req. updates.

588. By Christopher Lee on 2015-06-26

Remove un-used test class.

587. By Christopher Lee on 2015-06-26

Fix whitespace issue.

586. By Christopher Lee on 2015-06-26

Remove question comment and update docstring.

585. By Christopher Lee on 2015-06-26

Remove un-used method

584. By Christopher Lee on 2015-06-23

Remove changes that accidently got in

583. By Christopher Lee on 2015-06-23

Merge pre-req. changes

582. By Christopher Lee on 2015-06-18

Remove conversion notes

581. By Christopher Lee on 2015-06-18

Initial renaming from emulator_base to cpo_class

580. By Christopher Lee on 2015-06-18

Fix tests due to updated code.

=== modified file 'autopilot/introspection/_object_registry.py'
--- autopilot/introspection/_object_registry.py	2015-05-06 10:00:49 +0000
+++ autopilot/introspection/_object_registry.py	2015-06-15 09:43:19 +0000
@@ -42,10 +42,6 @@
 
 """
 
-from uuid import uuid4
-
-from autopilot.introspection._xpathselect import get_classname_from_path
-from autopilot.utilities import get_debug_logger
 from contextlib import contextmanager
 
 _object_registry = {}
@@ -62,92 +58,6 @@
     return _proxy_extensions.get(id, ())
 
 
-class IntrospectableObjectMetaclass(type):
-    """Metaclass to insert appropriate classes into the object registry."""
-
-    def __new__(cls, classname, bases, classdict):
-        """Create a new proxy class, possibly adding it to the object registry.
-
-        Test authors may derive a class from DBusIntrospectionObject or the
-        CustomEmulatorBase alias and use this as their 'emulator base'. This
-        class will be given a unique '_id' attribute. That attribute is the
-        first level index into the object registry. It's used so we can have
-        custom proxy classes for more than one process at the same time and
-        avoid clashes in the dictionary.
-        """
-        cls_id = None
-
-        for base in bases:
-            if hasattr(base, '_id'):
-                cls_id = base._id
-                break
-        else:
-            # Ignore classes that are in the autopilot class heirarchy:
-            if classname not in (
-                'ApplicationProxyObject',
-                'CustomEmulatorBase',
-                'DBusIntrospectionObject',
-                'DBusIntrospectionObjectBase',
-            ):
-                # Add the '_id' attribute as a class attr:
-                cls_id = classdict['_id'] = uuid4()
-
-        # use the bases passed to us, but extend it with whatever is stored in
-        # the proxy_extensions dictionary.
-        extensions = _get_proxy_bases_for_id(cls_id)
-        for extension in extensions:
-            if extension not in bases:
-                bases += (extension,)
-        # make the object. Nothing special here.
-        class_object = type.__new__(cls, classname, bases, classdict)
-
-        if not classdict.get('__generated', False):
-            # If the newly made object has an id, add it to the object
-            # registry.
-            if getattr(class_object, '_id', None) is not None:
-                if class_object._id in _object_registry:
-                    _object_registry[class_object._id][classname] = \
-                        class_object
-                else:
-                    _object_registry[class_object._id] = \
-                        {classname: class_object}
-        # in all cases, return the class unchanged.
-        return class_object
-
-
-DBusIntrospectionObjectBase = IntrospectableObjectMetaclass(
-    'DBusIntrospectionObjectBase',
-    (object,),
-    {}
-)
-
-
-def _get_proxy_object_class(object_id, path, state):
-    """Return a custom proxy class, from the object registry or the default.
-
-    This function first inspects the object registry using the object_id passed
-    in. The object_id will be unique to all custom proxy classes for the same
-    application.
-
-    If that fails, we create a class on the fly based on the default class.
-
-    :param object_id: The _id attribute of the class doing the lookup. This is
-        used to index into the object registry to retrieve the dict of proxy
-        classes to try.
-    :param path: dbus path
-    :param state: dbus state
-    :returns: appropriate custom proxy class
-    :raises ValueError: if more than one class in the dict matches
-
-    """
-    class_type = _try_custom_proxy_classes(object_id, path, state)
-
-    return class_type or _get_default_proxy_class(
-        object_id,
-        get_classname_from_path(path)
-    )
-
-
 def _try_custom_proxy_classes(object_id, path, state):
     """Identify which custom proxy class matches the dbus path and state.
 
@@ -239,26 +149,6 @@
     return order
 
 
-def _get_default_proxy_class(id, name):
-    """Return a custom proxy object class of the default or a base class.
-
-    We want the object to inherit from the class that is set as the emulator
-    base class, not the class that is doing the selecting. Using the passed id
-    we retrieve the relevant bases from the object registry.
-
-    :param id: The object id (_id attribute) of the class doing the lookup.
-    :param name: name of new class
-    :returns: custom proxy object class
-
-    """
-    get_debug_logger().warning(
-        "Generating introspection instance for type '%s' based on generic "
-        "class.", name)
-    if isinstance(name, bytes):
-        name = name.decode('utf-8')
-    return type(name, _get_proxy_bases_for_id(id), dict(__generated=True))
-
-
 @contextmanager
 def patch_registry(new_registry):
     """A utility context manager that allows us to patch the object registry.

=== added file 'autopilot/introspection/_proxy_objects.py'
--- autopilot/introspection/_proxy_objects.py	1970-01-01 00:00:00 +0000
+++ autopilot/introspection/_proxy_objects.py	2015-06-15 09:43:19 +0000
@@ -0,0 +1,211 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Autopilot Functional Test Tool
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Functions for dealing with proxy classes and objects."""
+
+
+from autopilot.introspection import (
+    constants,
+    dbus as ap_dbus
+)
+from autopilot.introspection._xpathselect import get_classname_from_path
+from autopilot.utilities import get_debug_logger
+
+
+def _get_introspection_xml_from_backend(
+        backend, reply_handler=None, error_handler=None):
+    """Get DBus Introspection xml from a backend.
+
+    :param backend: The backend object to query.
+    :param reply_handler: If set, makes a dbus async call, and the result will
+        be sent to reply_handler. This must be a callable object.
+    :param error_handler: If set, this callable will recieve any errors, and
+        the call will be made asyncronously.
+    :returns: A string containing introspection xml, if called synchronously.
+    :raises ValueError: if one, but not both of 'reply_handler' and
+        'error_handler' are set.
+
+    """
+    if callable(reply_handler) and callable(error_handler):
+        backend.dbus_introspection_iface.Introspect(
+            reply_handler=reply_handler,
+            error_handler=error_handler,
+        )
+    elif reply_handler or error_handler:
+        raise ValueError(
+            "Both 'reply_handler' and 'error_handler' must be set."
+        )
+    else:
+        return backend.dbus_introspection_iface.Introspect()
+
+
+def _get_proxy_bases_from_introspection_xml(introspection_xml):
+    """Return  tuple of the base classes to use when creating a proxy object.
+
+    Currently this works by looking for certain interface names in the XML. In
+    the future we may want to parse the XML and perform more rigerous checks.
+
+    :param introspection_xml: An xml string that describes the exported object
+        on the dbus backend. This determines which capabilities are present in
+        the backend, and therefore which base classes should be used to create
+        the proxy object.
+
+    :raises RuntimeError: if the autopilot interface cannot be found.
+
+    """
+
+    bases = []
+
+    if constants.AP_INTROSPECTION_IFACE not in introspection_xml:
+        raise RuntimeError("Could not find Autopilot interface.")
+
+    if constants.QT_AUTOPILOT_IFACE in introspection_xml:
+        from autopilot.introspection.qt import QtObjectProxyMixin
+        bases.append(QtObjectProxyMixin)
+
+    return tuple(bases)
+
+
+def _get_proxy_object_class_name_and_state(
+        backend, reply_handler=None, error_handler=None):
+    """Get details about this autopilot backend via a dbus GetState call.
+
+    :param reply_handler: A callable that must accept three positional
+        arguments, which correspond to the return value of this function when
+        called synchronously.
+
+    :param error_handler: A callable which will recieve any dbus errors, should
+        they occur.
+
+    :raises ValueError: if one, but not both of reply_handler and error_handler
+        are set.
+
+    :returns: A tuple containing the class name of the root of the
+        introspection tree, the full path to the root of the introspection
+        tree, and the state dictionary of the root node in the introspection
+        tree.
+
+    """
+    if callable(reply_handler) and callable(error_handler):
+        # Async call:
+        # Since we get an array of state, and we only care about the first one
+        # we use a lambda to unpack it and get the details we want.
+        backend.introspection_iface.GetState(
+            "/",
+            reply_handler=lambda r: reply_handler(
+                *_get_details_from_state_data(r[0])
+            ),
+            error_handler=error_handler,
+        )
+    elif reply_handler or error_handler:
+        raise ValueError(
+            "Both 'reply_handler' and 'error_handler' must be set."
+        )
+    else:
+        # Sync call
+        state = backend.introspection_iface.GetState("/")[0]
+        return _get_details_from_state_data(state)
+
+
+def _get_details_from_state_data(state_data):
+    """Get details from a state data array.
+
+    Returns class name, path, and state dictionary.
+    """
+    object_path, object_state = state_data
+    return (
+        get_classname_from_path(object_path),
+        object_path.encode('utf-8'),
+        object_state,
+    )
+
+
+def _get_default_proxy_class(name, bases):
+    """Return a default custom proxy object class.
+
+    :param name: name of new class
+    :param bases: Tuple of base classes to add to the base.
+    :returns: custom proxy object class
+
+    """
+    get_debug_logger().warning(
+        "Generating introspection instance for type '%s' based on generic "
+        "class.", name)
+    if isinstance(name, bytes):
+        name = name.decode('utf-8')
+    return type(
+        name,
+        (ap_dbus.DBusIntrospectionObject,) + bases,
+        dict(__generated=True)
+    )
+
+
+# vvveebers this probably shouldn't be 'private'.
+def _get_proxy_object_class(cpo_or_string, path, dbus_backend):
+    """Return the proxy class to use with the correct bases added
+
+    If passed a CPO returns that, if passed a string contructs a default class
+    to use instead.
+
+    """
+
+    extension_classes = _get_extension_classes(dbus_backend)
+
+    if _is_cpo_class(cpo_or_string):
+        _apply_mixin_bases(cpo_or_string, extension_classes)
+        return cpo_or_string
+    else:
+        cpo_name = _get_applicable_class_name(cpo_or_string, path)
+        return _get_default_proxy_class(cpo_name, extension_classes)
+
+
+def _get_extension_classes(dbus_backend):
+    """Return any extension classes that this object will need."""
+
+    intro_xml = _get_introspection_xml_from_backend(dbus_backend)
+    try:
+        return _get_proxy_bases_from_introspection_xml(intro_xml)
+    except RuntimeError as e:
+        e.args = (
+            "Could not find Autopilot interface on dbus address '%s'."
+            % dbus_backend,
+        )
+
+
+def _is_cpo_class(cpo_or_string):
+    return cpo_or_string is not None and not isinstance(cpo_or_string, str)
+
+
+def _get_applicable_class_name(cpo_name, path):
+    """Return correct name for class.
+
+    It is possible that the cpo_name is '*' which is what was used in the
+    query. Determine what the actual name should be.
+
+    """
+    if cpo_name is None or cpo_name == '*':
+        cls_name = get_classname_from_path(path)
+        return cls_name
+    else:
+        return cpo_name
+
+
+def _apply_mixin_bases(target_class, mixin_classes):
+    to_add = tuple(set(mixin_classes).difference(target_class.__bases__))
+    target_class.__bases__ += to_add

=== modified file 'autopilot/introspection/_search.py'
--- autopilot/introspection/_search.py	2015-05-06 10:03:43 +0000
+++ autopilot/introspection/_search.py	2015-06-15 09:43:19 +0000
@@ -33,7 +33,7 @@
 from autopilot.introspection import backends
 from autopilot.introspection import constants
 from autopilot.introspection import dbus as ap_dbus
-from autopilot.introspection import _object_registry
+from autopilot.introspection import _proxy_objects as _po
 from autopilot.introspection._xpathselect import get_classname_from_path
 from autopilot.introspection.backends import WireProtocolVersionMismatch
 from autopilot.introspection.utilities import (
@@ -384,40 +384,22 @@
     :param emulator_base: The emulator base object (or None), as provided by
         the user.
     """
+
+    # vvveebers emulator_base will become proxy_class (to be explicit as the
+    # term emulator has long gone.).
+
     # make sure we always have an emulator base. Either use the one the user
     # gave us, or make one:
-    emulator_base = emulator_base or _make_default_emulator_base()
-    _raise_if_base_class_not_actually_base(emulator_base)
-
-    # Get the dbus introspection Xml for the backend.
-    intro_xml = _get_introspection_xml_from_backend(dbus_address)
-    try:
-        # Figure out if the backend has any extension methods, and return
-        # classes that understand how to use each of those extensions:
-        extension_classes = _get_proxy_bases_from_introspection_xml(intro_xml)
-
-        # Register those base classes for everything that will derive from this
-        # emulator base class.
-        _object_registry.register_extension_classes_for_proxy_base(
-            emulator_base,
-            extension_classes,
-        )
-    except RuntimeError as e:
-        e.args = (
-            "Could not find Autopilot interface on dbus address '%s'."
-            % dbus_address,
-        )
-        raise e
-
-    cls_name, path, cls_state = _get_proxy_object_class_name_and_state(
+    # This will return a default class or the CPO with the correct stuff added.
+
+    cls_name, path, cls_state = _po._get_proxy_object_class_name_and_state(
         dbus_address
     )
 
-    proxy_class = _object_registry._get_proxy_object_class(
-        emulator_base._id,
-        path,
-        cls_state
+    proxy_class = _po._get_proxy_object_class(
+        emulator_base, path, dbus_address
     )
+
     # For this object only, add the ApplicationProxy class, since it's the
     # root of the tree. Ideally this would be nicer...
     if ApplicationProxyObject not in proxy_class.__bases__:
@@ -426,6 +408,7 @@
 
 
 def _make_default_emulator_base():
+    # vvveebers this will be removed (make_proxy_async needs updated.)
     """Make a default base class for all proxy classes to derive from."""
     return type("DefaultEmulatorBase", (ap_dbus.DBusIntrospectionObject,), {})
 
@@ -471,6 +454,8 @@
     reply_handler will be called with a single argument: The proxy object.
 
     """
+    # vvveebers emulator_base name will change to proxy_class.
+
     # Note: read this function backwards!
     #
     # Due to the callbacks, I need to define the end of the callback chain
@@ -482,20 +467,26 @@
     def build_proxy(introspection_xml, cls_name, path, cls_state):
         # Figure out if the backend has any extension methods, and return
         # classes that understand how to use each of those extensions:
-        extension_classes = _get_proxy_bases_from_introspection_xml(
+        extension_classes = _po._get_proxy_bases_from_introspection_xml(
             introspection_xml
         )
-        # Register those base classes for everything that will derive from this
-        # emulator base class.
-        _object_registry.register_extension_classes_for_proxy_base(
-            emulator_base,
-            extension_classes,
-        )
-        proxy_class = _object_registry._get_proxy_object_class(
-            emulator_base._id,
-            path,
-            cls_state
-        )
+
+        # XXX ERROR!
+        emulator_base = None
+        if emulator_base is None:
+            emulator_base = cls_name
+
+        if isinstance(emulator_base, str):
+            cpo_name = emulator_base
+            proxy_class = _po._get_default_proxy_class(
+                cpo_name,
+                extension_classes
+            )
+        else:
+            # It's actually a CPO class.
+            _po._apply_mixin_bases(emulator_base, extension_classes)
+            proxy_class = emulator_base
+
         reply_handler(
             proxy_class(cls_state, path, backends.Backend(data_source))
         )
@@ -503,7 +494,7 @@
     # Phase 2: We recieve the introspection string, and make an asynchronous
     # dbus call to get the state information for the root of this applicaiton.
     def get_root_state(introspection_xml):
-        _get_proxy_object_class_name_and_state(
+        _po._get_proxy_object_class_name_and_state(
             data_source,
             reply_handler=partial(build_proxy, introspection_xml),
             error_handler=error_handler,
@@ -513,121 +504,13 @@
     # from the data_source provided for us.
     emulator_base = emulator_base or _make_default_emulator_base()
 
-    _get_introspection_xml_from_backend(
+    _po._get_introspection_xml_from_backend(
         data_source,
         reply_handler=get_root_state,
         error_handler=error_handler
     )
 
 
-def _get_introspection_xml_from_backend(
-        backend, reply_handler=None, error_handler=None):
-    """Get DBus Introspection xml from a backend.
-
-    :param backend: The backend object to query.
-    :param reply_handler: If set, makes a dbus async call, and the result will
-        be sent to reply_handler. This must be a callable object.
-    :param error_handler: If set, this callable will recieve any errors, and
-        the call will be made asyncronously.
-    :returns: A string containing introspection xml, if called synchronously.
-    :raises ValueError: if one, but not both of 'reply_handler' and
-        'error_handler' are set.
-
-    """
-    if callable(reply_handler) and callable(error_handler):
-        backend.dbus_introspection_iface.Introspect(
-            reply_handler=reply_handler,
-            error_handler=error_handler,
-        )
-    elif reply_handler or error_handler:
-        raise ValueError(
-            "Both 'reply_handler' and 'error_handler' must be set."
-        )
-    else:
-        return backend.dbus_introspection_iface.Introspect()
-
-
-def _get_proxy_object_class_name_and_state(
-        backend, reply_handler=None, error_handler=None):
-    """Get details about this autopilot backend via a dbus GetState call.
-
-    :param reply_handler: A callable that must accept three positional
-        arguments, which correspond to the return value of this function when
-        called synchronously.
-
-    :param error_handler: A callable which will recieve any dbus errors, should
-        they occur.
-
-    :raises ValueError: if one, but not both of reply_handler and error_handler
-        are set.
-
-    :returns: A tuple containing the class name of the root of the
-        introspection tree, the full path to the root of the introspection
-        tree, and the state dictionary of the root node in the introspection
-        tree.
-
-    """
-    if callable(reply_handler) and callable(error_handler):
-        # Async call:
-        # Since we get an array of state, and we only care about the first one
-        # we use a lambda to unpack it and get the details we want.
-        backend.introspection_iface.GetState(
-            "/",
-            reply_handler=lambda r: reply_handler(
-                *_get_details_from_state_data(r[0])
-            ),
-            error_handler=error_handler,
-        )
-    elif reply_handler or error_handler:
-        raise ValueError(
-            "Both 'reply_handler' and 'error_handler' must be set."
-        )
-    else:
-        # Sync call
-        state = backend.introspection_iface.GetState("/")[0]
-        return _get_details_from_state_data(state)
-
-
-def _get_details_from_state_data(state_data):
-    """Get details from a state data array.
-
-    Returns class name, path, and state dictionary.
-    """
-    object_path, object_state = state_data
-    return (
-        get_classname_from_path(object_path),
-        object_path.encode('utf-8'),
-        object_state,
-    )
-
-
-def _get_proxy_bases_from_introspection_xml(introspection_xml):
-    """Return  tuple of the base classes to use when creating a proxy object.
-
-    Currently this works by looking for certain interface names in the XML. In
-    the future we may want to parse the XML and perform more rigerous checks.
-
-    :param introspection_xml: An xml string that describes the exported object
-        on the dbus backend. This determines which capabilities are present in
-        the backend, and therefore which base classes should be used to create
-        the proxy object.
-
-    :raises RuntimeError: if the autopilot interface cannot be found.
-
-    """
-
-    bases = []
-
-    if constants.AP_INTROSPECTION_IFACE not in introspection_xml:
-        raise RuntimeError("Could not find Autopilot interface.")
-
-    if constants.QT_AUTOPILOT_IFACE in introspection_xml:
-        from autopilot.introspection.qt import QtObjectProxyMixin
-        bases.append(QtObjectProxyMixin)
-
-    return tuple(bases)
-
-
 class ApplicationProxyObject(object):
     """A class that better supports query data from an application."""
 

=== modified file 'autopilot/introspection/backends.py'
--- autopilot/introspection/backends.py	2015-06-09 15:35:08 +0000
+++ autopilot/introspection/backends.py	2015-06-15 09:43:19 +0000
@@ -51,7 +51,7 @@
     _pid_is_running,
     _get_bus_connections_pid,
 )
-from autopilot.introspection._object_registry import _get_proxy_object_class
+from autopilot.introspection import _proxy_objects
 
 
 _logger = logging.getLogger(__name__)
@@ -245,14 +245,14 @@
                 )
             return data
 
-    def execute_query_get_proxy_instances(self, query, id):
+    def execute_query_get_proxy_instances(self, query, cpo_class):
         """Execute 'query', returning proxy instances."""
         data = self.execute_query_get_data(query)
         objects = [
             make_introspection_object(
                 t,
                 type(self)(self.ipc_address),
-                id,
+                cpo_class,
             )
             for t in data
         ]
@@ -288,7 +288,7 @@
         return self.fake_ipc_return_data
 
 
-def make_introspection_object(dbus_tuple, backend, object_id):
+def make_introspection_object(dbus_tuple, backend, cpo_class):
     """Make an introspection object given a DBus tuple of
     (path, state_dict).
 
@@ -303,7 +303,13 @@
     """
     path, state = dbus_tuple
     path = path.encode('utf-8')
-    class_object = _get_proxy_object_class(object_id, path, state)
+    # import ipdb; ipdb.set_trace()
+    # Path seems correct here.
+    class_object = _proxy_objects._get_proxy_object_class(
+        cpo_class,
+        path,
+        backend.ipc_address
+    )
     return class_object(state, path, backend)
 
 

=== modified file 'autopilot/introspection/dbus.py'
--- autopilot/introspection/dbus.py	2014-07-31 04:42:08 +0000
+++ autopilot/introspection/dbus.py	2015-06-15 09:43:19 +0000
@@ -30,9 +30,6 @@
 import logging
 
 from autopilot.exceptions import StateNotFoundError
-from autopilot.introspection._object_registry import (
-    DBusIntrospectionObjectBase,
-)
 from autopilot.introspection.types import create_value_instance
 from autopilot.introspection.utilities import translate_state_keys
 from autopilot.introspection import _xpathselect as xpathselect
@@ -42,7 +39,7 @@
 _logger = logging.getLogger(__name__)
 
 
-class DBusIntrospectionObject(DBusIntrospectionObjectBase):
+class DBusIntrospectionObject(object):
     """A class that supports transparent data retrieval from the application
     under test.
 
@@ -83,11 +80,15 @@
             self.id
         )
 
-    def _execute_query(self, query):
+    def _execute_query(self, query, cpo_class=None):
+        # Default to None because it's ok to create a default CPO oh or perhaps
+        # default to a default dbus object?
         """Execute query object 'query' and return the result."""
+        # vvveebers this will need to be updated to take any CPO passed in.
+        # as well as updating the backend code so that it can handle it.
         return self._backend.execute_query_get_proxy_instances(
             query,
-            getattr(self, '_id', None),
+            cpo_class,
         )
 
     def _set_properties(self, state_dict):
@@ -146,6 +147,9 @@
             Tutorial Section :ref:`custom_proxy_classes`
 
         """
+        # vvveebers this will need updating (docs, and select_child).
+        # Will def need to pass in the CPO class.
+        # (seems that this will reside in execute_query.
         new_query = self._query.select_child(
             get_type_name(desired_type),
             kwargs
@@ -175,10 +179,13 @@
         This returns a list of all children. To return only children of a
         specific type, use :meth:`get_children_by_type`. To get objects
         further down the introspection tree (i.e.- nodes that may not
-        necessarily be immeadiate children), use :meth:`select_single` and
+        necessarily be immediate children), use :meth:`select_single` and
         :meth:`select_many`.
 
         """
+        # vvveebers this will need a note stating that any objects returned
+        # will be just defaults.
+
         # Thomi: 2014-03-20: There used to be a call to 'self.refresh_state()'
         # here. That's not needed, since the only thing we use is the proxy
         # path, which isn't affected by the current state.
@@ -192,6 +199,8 @@
         tree). Then it returns itself.
 
         """
+        # vvveebers This might also be an issue as there will be no record of
+        # what CPO to use.
         new_query = self._query.select_parent()
         return self._execute_query(new_query)[0]
 
@@ -237,7 +246,7 @@
             type_name_str,
             kwargs
         )
-        instances = self._execute_query(new_query)
+        instances = self._execute_query(new_query, type_name)
         if len(instances) > 1:
             raise ValueError("More than one item was returned for query")
         if not instances:
@@ -351,7 +360,7 @@
             'any type'
             if type_name_str == '*' else 'type ' + type_name_str, kwargs
         )
-        return self._execute_query(new_query)
+        return self._execute_query(new_query, type_name)
 
     def refresh_state(self):
         """Refreshes the object's state.
@@ -385,6 +394,11 @@
         :return: List (possibly empty) of class instances.
 
         """
+        # vvveebers this will need a revamp:
+        #  - getting cls_name like this will fail for CPOs with different
+        #  names.
+        #  - this would currently produce a default proxy as the CPO isn't
+        #  passed in: either pass self in (or similar) or perhaps 'from_cpo()'.
         cls_name = type(self).__name__
         return self._execute_query(
             xpathselect.Query.whole_tree_search(cls_name)
@@ -397,6 +411,10 @@
         introspection tree.
 
         """
+        # vvveebers undecided if this should take a cpo argument so the
+        # returned object can be instatiated instead of a default.
+        # It appears that currently in use that the expectation is that it's a
+        # default.
         query = xpathselect.Query.pseudo_tree_root()
         return self._execute_query(query)[0]
 
@@ -410,10 +428,14 @@
             if self.__refresh_on_attribute:
                 self.refresh_state()
             return self.__state[name]
+
+        exception_msg = "{}Class '{}' has no attribute '{}'.".format(
+            'Generated ' if hasattr(self.__class__, '__generated') else '',
+            self.__class__.__name__,
+            name
+        )
         # attribute not found.
-        raise AttributeError(
-            "Class '%s' has no attribute '%s'." %
-            (self.__class__.__name__, name))
+        raise AttributeError(exception_msg)
 
     def _get_new_state(self):
         """Retrieve a new state dictionary for this class instance.
@@ -538,12 +560,47 @@
         :returns: Whether this class is appropriate for the dbus object
 
         """
+
+        # vvveebers this won't be needed with the newer design. Is there
+        # perhaps a need for something along this line so CPOs are created for
+        # the expected bits?
+
         state_name = xpathselect.get_classname_from_path(path)
         if isinstance(state_name, str):
             state_name = state_name.encode('utf-8')
         class_name = cls.__name__.encode('utf-8')
         return state_name == class_name
 
+    @classmethod
+    def get_type_query_name(cls):
+        """Return the Type node name to use within the search query.
+
+        This allows for a Custom Proxy Object to be named differently to the
+        underlying node type name.
+
+        For instance if you have a QML type defined in the file RedRect.qml::
+
+            import QtQuick 2.0
+            Rectangle {
+                color: red;
+            }
+
+        You can then define a Custom Proxy Object  for this type like so::
+
+        class RedRect(DBusIntrospectionObject):
+            @classmethod
+            def get_type_query_name(cls):
+                return 'QQuickRectangle'
+
+        This is due to the qml engine storing 'RedRect' as a QQuickRectangle in
+        the UI tree and the xpathquery query needs a node type to query for.
+        By default the query will use the class name (in this case RedRect) but
+        this will not match any node type in the tree.
+
+        """
+
+        return cls.__name__
+
 
 # TODO - can we add a deprecation warning around this somehow?
 CustomEmulatorBase = DBusIntrospectionObject
@@ -557,5 +614,12 @@
 
     """
     if not isinstance(maybe_string_or_class, str):
-        return maybe_string_or_class.__name__
+        return _get_class_type_name(maybe_string_or_class)
     return maybe_string_or_class
+
+
+def _get_class_type_name(maybe_cpo_class):
+    if hasattr(maybe_cpo_class, 'get_type_query_name'):
+        return maybe_cpo_class.get_type_query_name()
+    else:
+        return maybe_cpo_class.__name__

=== modified file 'autopilot/tests/functional/test_dbus_query.py'
--- autopilot/tests/functional/test_dbus_query.py	2015-06-09 15:35:08 +0000
+++ autopilot/tests/functional/test_dbus_query.py	2015-06-15 09:43:19 +0000
@@ -217,6 +217,12 @@
         self.assertThat(abs(end_time - start_time), GreaterThan(9))
         self.assertThat(abs(end_time - start_time), LessThan(11))
 
+    def test_selecting_without_classname_sets_proxy_classname(self):
+        app = self.start_fully_featured_app()
+        test_object = app.select_single(windowTitle='Default Window Title')
+
+        self.assertThat(test_object.__class__.__name__, Equals('QMainWindow'))
+
 
 @skipIf(platform.model() != "Desktop", "Only suitable on Desktop (WinMocker)")
 class DbusCustomBusTests(AutopilotTestCase):

=== modified file 'autopilot/tests/functional/test_input_stack.py'
--- autopilot/tests/functional/test_input_stack.py	2015-05-08 04:32:51 +0000
+++ autopilot/tests/functional/test_input_stack.py	2015-06-15 09:43:19 +0000
@@ -379,7 +379,7 @@
         screen_geometry = Display.create().get_screen_geometry(0)
         target_x = screen_geometry[0] + 10
         target_y = screen_geometry[1] + 10.6
-        self.device.move(target_x, target_y)
+        device.move(target_x, target_y)
         self.assertEqual(device.position(), (target_x, int(target_y)))
 
     @patch('autopilot.platform.model', new=lambda *args: "Not Desktop", )

=== modified file 'autopilot/tests/functional/test_introspection_features.py'
--- autopilot/tests/functional/test_introspection_features.py	2015-04-30 03:34:13 +0000
+++ autopilot/tests/functional/test_introspection_features.py	2015-06-15 09:43:19 +0000
@@ -36,16 +36,15 @@
     StartsWith,
 )
 from textwrap import dedent
-from unittest.mock import patch
 from io import StringIO
 
 from autopilot import platform
 from autopilot.matchers import Eventually
 from autopilot.testcase import AutopilotTestCase
+from autopilot.tests.functional import QmlScriptRunnerMixin
 from autopilot.tests.functional.fixtures import TempDesktopFile
 from autopilot.introspection import CustomEmulatorBase
 from autopilot.introspection import _object_registry as object_registry
-from autopilot.introspection import _search
 from autopilot.introspection.qt import QtObjectProxyMixin
 from autopilot.display import Display
 
@@ -93,14 +92,16 @@
                 return path == b'/window-mocker'
 
         # verify that the initial proxy object we get back is the correct type:
-        app = self.start_mock_app(EmulatorBase)
+        app = self.start_mock_app(WindowMockerApp)
         self.assertThat(type(app), Equals(WindowMockerApp))
 
         # verify that we get the correct type from get_root_instance:
-        self.assertThat(
-            type(app.get_root_instance()),
-            Equals(WindowMockerApp)
-        )
+        # vvveebers behaviour has changed, get_root_instance currently returns
+        # a default cpo.
+        # self.assertThat(
+        #     type(app.get_root_instance()),
+        #     Equals(WindowMockerApp)
+        # )
 
     def test_customised_proxy_classes_have_extension_classes(self):
         class WindowMockerApp(EmulatorBase):
@@ -112,21 +113,22 @@
         self.assertThat(app.__class__.__bases__, Contains(QtObjectProxyMixin))
 
     def test_customised_proxy_classes_have_multiple_extension_classes(self):
-        with object_registry.patch_registry({}):
-            class SecondEmulatorBase(CustomEmulatorBase):
-                pass
-
-            class WindowMockerApp(EmulatorBase, SecondEmulatorBase):
-                @classmethod
-                def validate_dbus_object(cls, path, _state):
-                    return path == b'/window-mocker'
-
-            app = self.start_mock_app(EmulatorBase)
-            self.assertThat(app.__class__.__bases__, Contains(EmulatorBase))
-            self.assertThat(
-                app.__class__.__bases__,
-                Contains(SecondEmulatorBase)
-            )
+        # vvveebers this test isn't really testing anything anymore as it's
+        # handled by python (i.e. class inheritence)
+        class SecondEmulatorBase(CustomEmulatorBase):
+            pass
+
+        class WindowMockerApp(EmulatorBase, SecondEmulatorBase):
+            @classmethod
+            def validate_dbus_object(cls, path, _state):
+                return path == b'/window-mocker'
+
+        app = self.start_mock_app(WindowMockerApp)
+        self.assertThat(app.__class__.__bases__, Contains(EmulatorBase))
+        self.assertThat(
+            app.__class__.__bases__,
+            Contains(SecondEmulatorBase)
+        )
 
     def test_handles_using_app_cpo_base_class(self):
         # This test replicates an issue found in an application test suite
@@ -139,30 +141,16 @@
 
             self.start_mock_app(WindowMockerApp)
 
-    def test_warns_when_using_incorrect_cpo_base_class(self):
-        # Ensure the warning method is called when launching a proxy.
-        with object_registry.patch_registry({}):
-            class TestCPO(CustomEmulatorBase):
-                pass
-
-            class WindowMockerApp(TestCPO):
-                @classmethod
-                def validate_dbus_object(cls, path, _state):
-                    return path == b'/window-mocker'
-
-            with patch.object(_search, 'logger') as p_logger:
-                self.start_mock_app(WindowMockerApp)
-                self.assertTrue(p_logger.warning.called)
-
-    def test_can_select_custom_emulators_by_name(self):
-        """Must be able to select a custom emulator type by name."""
+    def test_selecting_using_string_creates_default_cpo(self):
+        """When not passing CPO must return generated default."""
         class MouseTestWidget(EmulatorBase):
             pass
 
         app = self.start_mock_app(EmulatorBase)
         test_widget = app.select_single('MouseTestWidget')
 
-        self.assertThat(type(test_widget), Equals(MouseTestWidget))
+        self.assertThat(type(test_widget), Not(Equals(MouseTestWidget)))
+        self.assertTrue(getattr(test_widget, '__generated'))
 
     def test_can_select_custom_emulators_by_type(self):
         """Must be able to select a custom emulator type by type."""
@@ -397,3 +385,31 @@
                 [e[1] for e in result2.decorated.errors]
             )
         )
+
+
+class CustomCPOTest(AutopilotTestCase, QmlScriptRunnerMixin):
+
+    def launch_simple_qml_script(self):
+        simple_script = dedent("""
+        import QtQuick 2.0
+        Rectangle {
+            objectName: "ExampleRectangle"
+        }
+        """)
+        return self.start_qml_script(simple_script)
+
+    def test_cpo_can_be_named_different_to_underlying_type(self):
+        """A CPO with the correct name match method must be matched if the
+        class name is different to the Type name.
+
+        """
+        with object_registry.patch_registry({}):
+            class RandomNamedCPORectangle(CustomEmulatorBase):
+                @classmethod
+                def get_type_query_name(cls):
+                    return 'QQuickRectangle'
+
+            app = self.launch_simple_qml_script()
+            rectangle = app.select_single(RandomNamedCPORectangle)
+
+            self.assertThat(rectangle.objectName, Equals('ExampleRectangle'))

=== renamed file 'autopilot/tests/unit/test_introspection_object_registry.py' => 'autopilot/tests/unit/introspection_object_registry.py'
=== modified file 'autopilot/tests/unit/test_introspection.py'
--- autopilot/tests/unit/test_introspection.py	2014-07-31 04:42:08 +0000
+++ autopilot/tests/unit/test_introspection.py	2015-06-15 09:43:19 +0000
@@ -25,7 +25,10 @@
     IsInstance,
     raises,
 )
-import autopilot.introspection._search as _s
+from autopilot.introspection import (
+    _proxy_objects as _po,
+    _search as _s
+)
 from autopilot.introspection.qt import QtObjectProxyMixin
 import autopilot.introspection as _i
 
@@ -35,21 +38,21 @@
     fake_state_data = (String('/some/path'), dict(foo=123))
 
     def test_returns_classname(self):
-        class_name, _, _ = _s._get_details_from_state_data(
+        class_name, _, _ = _po._get_details_from_state_data(
             self.fake_state_data
         )
         self.assertThat(class_name, Equals('path'))
 
     def test_returns_path(self):
-        _, path, _ = _s._get_details_from_state_data(self.fake_state_data)
+        _, path, _ = _po._get_details_from_state_data(self.fake_state_data)
         self.assertThat(path, Equals(b'/some/path'))
 
     def test_returned_path_is_bytestring(self):
-        _, path, _ = _s._get_details_from_state_data(self.fake_state_data)
+        _, path, _ = _po._get_details_from_state_data(self.fake_state_data)
         self.assertThat(path, IsInstance(type(b'')))
 
     def test_returns_state_dict(self):
-        _, _, state = _s._get_details_from_state_data(self.fake_state_data)
+        _, _, state = _po._get_details_from_state_data(self.fake_state_data)
         self.assertThat(state, Equals(dict(foo=123)))
 
 
@@ -119,13 +122,13 @@
 
     def test_raises_RuntimeError_when_no_interface_is_found(self):
         self.assertThat(
-            lambda: _s._get_proxy_bases_from_introspection_xml(""),
+            lambda: _po._get_proxy_bases_from_introspection_xml(""),
             raises(RuntimeError("Could not find Autopilot interface."))
         )
 
     def test_returns_ApplicationProxyObject_claws_for_base_interface(self):
         self.assertThat(
-            _s._get_proxy_bases_from_introspection_xml(
+            _po._get_proxy_bases_from_introspection_xml(
                 self.fake_data_with_ap_interface
             ),
             Equals(())
@@ -133,7 +136,7 @@
 
     def test_returns_both_base_and_qt_interface(self):
         self.assertThat(
-            _s._get_proxy_bases_from_introspection_xml(
+            _po._get_proxy_bases_from_introspection_xml(
                 self.fake_data_with_ap_and_qt_interfaces
             ),
             Equals((QtObjectProxyMixin,))

=== modified file 'autopilot/tests/unit/test_introspection_backends.py'
--- autopilot/tests/unit/test_introspection_backends.py	2015-06-09 15:35:08 +0000
+++ autopilot/tests/unit/test_introspection_backends.py	2015-06-15 09:43:19 +0000
@@ -23,6 +23,7 @@
 from testtools.matchers import Equals, Not, NotEquals, IsInstance
 
 from autopilot.introspection import (
+    _proxy_objects as _po,
     _xpathselect as xpathselect,
     backends,
     dbus,
@@ -325,21 +326,22 @@
         """Verify that a class has a validation method by default."""
         self.assertTrue(callable(self.DefaultSelector.validate_dbus_object))
 
-    @patch.object(backends, '_get_proxy_object_class')
+    @patch.object(_po, '_get_proxy_object_class')
     def test_make_introspection_object(self, gpoc):
         """Verify that make_introspection_object makes the right call."""
         gpoc.return_value = self.DefaultSelector
-        fake_id = Mock()
+        fake_backend = Mock()
+        cpo_name = self.getUniqueString()
+
         new_fake = backends.make_introspection_object(
             (String('/Object'), {'id': [0, 42]}),
-            None,
-            fake_id,
+            fake_backend,
+            cpo_name
         )
         self.assertThat(new_fake, IsInstance(self.DefaultSelector))
         gpoc.assert_called_once_with(
-            fake_id,
-            b'/Object',
-            {'id': [0, 42]}
+            cpo_name,
+            fake_backend.ipc_address
         )
 
     def test_validate_dbus_object_matches_on_class_name(self):

=== modified file 'autopilot/tests/unit/test_introspection_dbus.py'
--- autopilot/tests/unit/test_introspection_dbus.py	2014-07-22 02:30:19 +0000
+++ autopilot/tests/unit/test_introspection_dbus.py	2015-06-15 09:43:19 +0000
@@ -29,50 +29,19 @@
 from testtools.matchers import (
     Equals,
     Not,
-    NotEquals,
     Raises,
     raises,
 )
 
 from autopilot.exceptions import StateNotFoundError
-from autopilot.introspection import CustomEmulatorBase
-from autopilot.introspection import dbus
+from autopilot.introspection import (
+    _proxy_objects as _po,
+    CustomEmulatorBase,
+    dbus
+)
 from autopilot.utilities import sleep
 
 
-class IntrospectionFeatureTests(TestCase):
-
-    def test_custom_emulator_base_does_not_have_id(self):
-        self.assertThat(hasattr(CustomEmulatorBase, '_id'), Equals(False))
-
-    def test_derived_emulator_bases_do_have_id(self):
-        class MyEmulatorBase(CustomEmulatorBase):
-            pass
-        self.assertThat(hasattr(MyEmulatorBase, '_id'), Equals(True))
-
-    def test_derived_children_have_same_id(self):
-        class MyEmulatorBase(CustomEmulatorBase):
-            pass
-
-        class MyEmulator(MyEmulatorBase):
-            pass
-
-        class MyEmulator2(MyEmulatorBase):
-            pass
-
-        self.assertThat(MyEmulatorBase._id, Equals(MyEmulator._id))
-        self.assertThat(MyEmulatorBase._id, Equals(MyEmulator2._id))
-
-    def test_children_have_different_ids(self):
-        class MyEmulatorBase(CustomEmulatorBase):
-            pass
-
-        class MyEmulatorBase2(CustomEmulatorBase):
-            pass
-
-        self.assertThat(MyEmulatorBase._id, NotEquals(MyEmulatorBase2._id))
-
-
 class DBusIntrospectionObjectTests(TestCase):
 
     def test_can_access_path_attribute(self):
@@ -118,6 +87,49 @@
                 ),
             )
 
+    def test_base_class_provides_correct_query_name(self):
+        self.assertThat(
+            dbus.DBusIntrospectionObject.get_type_query_name(),
+            Equals('ProxyBase')
+        )
+
+    def test_inherited_uses_default_get_node_name(self):
+        class TestCPO(dbus.DBusIntrospectionObject):
+            pass
+
+        self.assertThat(
+            TestCPO.get_type_query_name(),
+            Equals('TestCPO')
+        )
+
+    def test_inherited_overwrites_node_name_is_correct(self):
+        class TestCPO(dbus.DBusIntrospectionObject):
+            @classmethod
+            def get_type_query_name(cls):
+                return "TestCPO"
+        self.assertThat(TestCPO.get_type_query_name(), Equals("TestCPO"))
+
+
+class ProxyObjectCreationTests(TestCase):
+    def test_default_class_mentioned_in_attr_error(self):
+        name = self.getUniqueString()
+        fake_class = _po._get_default_proxy_class(name, ())
+        fake_object = fake_class(
+            dict(id=[0, 123], path=[0, '/some/path']),
+            b'/root',
+            Mock()
+        )
+
+        expected_msg = "Generated Class '{}' has no attribute 'foo'.".format(
+            name
+        )
+
+        with fake_object.no_automatic_refreshing():
+            self.assertThat(
+                lambda: fake_object.foo(),
+                raises(AttributeError(expected_msg))
+            )
+
 
 class ProxyObjectPrintTreeTests(TestCase):
 
@@ -222,3 +234,23 @@
         class FooBarBaz(object):
             pass
         self.assertEqual("FooBarBaz", dbus.get_type_name(FooBarBaz))
+
+    def test_get_type_name_returns_classname(self):
+        class CustomCPO(dbus.DBusIntrospectionObject):
+            pass
+
+        type_name = dbus.get_type_name(CustomEmulatorBase)
+        self.assertThat(type_name, Equals('ProxyBase'))
+
+    def test_get_type_name_returns_custom_node_name(self):
+        class CustomCPO(dbus.DBusIntrospectionObject):
+            @classmethod
+            def get_type_query_name(cls):
+                return 'TestingCPO'
+        type_name = dbus.get_type_name(CustomCPO)
+        self.assertThat(type_name, Equals('TestingCPO'))
+
+    def test_get_type_name_returns_classname_of_non_proxybase_classes(self):
+        class Foo(object):
+            pass
+        self.assertEqual('Foo', dbus.get_type_name(Foo))

=== modified file 'autopilot/tests/unit/test_introspection_search.py'
--- autopilot/tests/unit/test_introspection_search.py	2015-05-06 10:00:49 +0000
+++ autopilot/tests/unit/test_introspection_search.py	2015-06-15 09:43:19 +0000
@@ -35,7 +35,6 @@
 from autopilot.utilities import sleep
 from autopilot.introspection import _search as _s
 
-from autopilot.introspection import CustomEmulatorBase
 from autopilot.introspection.constants import AUTOPILOT_PATH
 
 
@@ -732,95 +731,3 @@
                 _s._find_matching_connections(bus, lambda *args: True)
 
                 dedupe.assert_called_once_with(["conn1"], bus)
-
-
-class ActualBaseClassTests(TestCase):
-
-    def test_dont_raise_passed_base_when_is_only_base(self):
-        class ActualBase(CustomEmulatorBase):
-            pass
-
-        try:
-            _s._raise_if_base_class_not_actually_base(ActualBase)
-        except ValueError:
-            self.fail('Unexpected ValueError exception')
-
-    def test_raises_if_passed_incorrect_base_class(self):
-        class ActualBase(CustomEmulatorBase):
-            pass
-
-        class InheritedCPO(ActualBase):
-            pass
-
-        self.assertRaises(
-            ValueError,
-            _s._raise_if_base_class_not_actually_base,
-            InheritedCPO
-        )
-
-    def test_raises_parent_with_simple_non_ap_multi_inheritance(self):
-        """When mixing in non-customproxy classes must return the base."""
-
-        class ActualBase(CustomEmulatorBase):
-            pass
-
-        class InheritedCPO(ActualBase):
-            pass
-
-        class TrickyOne(object):
-            pass
-
-        class FinalForm(InheritedCPO, TrickyOne):
-            pass
-
-        self.assertRaises(
-            ValueError,
-            _s._raise_if_base_class_not_actually_base,
-            FinalForm
-        )
-
-    def test_raises_parent_with_non_ap_multi_inheritance(self):
-
-        class ActualBase(CustomEmulatorBase):
-            pass
-
-        class InheritedCPO(ActualBase):
-            pass
-
-        class TrickyOne(object):
-            pass
-
-        class FinalForm(TrickyOne, InheritedCPO):
-            pass
-
-        self.assertRaises(
-            ValueError,
-            _s._raise_if_base_class_not_actually_base,
-            FinalForm
-        )
-
-    def test_dont_raise_when_using_default_emulator_base(self):
-        # _make_proxy_object potentially creates a default base.
-        DefaultBase = _s._make_default_emulator_base()
-        try:
-            _s._raise_if_base_class_not_actually_base(DefaultBase)
-        except ValueError:
-            self.fail('Unexpected ValueError exception')
-
-    def test_exception_message_contains_useful_information(self):
-        class ActualBase(CustomEmulatorBase):
-            pass
-
-        class InheritedCPO(ActualBase):
-            pass
-
-        try:
-            _s._raise_if_base_class_not_actually_base(InheritedCPO)
-        except ValueError as err:
-            self.assertEqual(
-                str(err),
-                _s.WRONG_CPO_CLASS_MSG.format(
-                    passed=InheritedCPO,
-                    actual=ActualBase
-                )
-            )

=== added file 'autopilot/tests/unit/test_proxy_object.py'
--- autopilot/tests/unit/test_proxy_object.py	1970-01-01 00:00:00 +0000
+++ autopilot/tests/unit/test_proxy_object.py	2015-06-15 09:43:19 +0000
@@ -0,0 +1,84 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Autopilot Functional Test Tool
+# Copyright (C) 2015 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from unittest.mock import (
+    Mock,
+    patch
+)
+from testtools import TestCase
+
+from autopilot.introspection import _proxy_objects as _po
+
+
+class GetProxyObjectClassesTests(TestCase):
+    pass
+
+
+class IsCpoClassTests(TestCase):
+
+    def test_returns_False_when_None(self):
+        self.assertFalse(_po._is_cpo_class(None))
+
+    def test_returns_False_when_is_string(self):
+        self.assertFalse(_po._is_cpo_class('foo'))
+
+    def test_returns_True_when_is_class(self):
+        class Foo(): pass
+        self.assertTrue(_po._is_cpo_class(Foo))
+
+class GetApplicableClassNameTests(TestCase):
+
+    @patch.object(_po, '_get_proxy_object_class_name_and_state')
+    def test_queries_dbus_name_unknown(self, po_cs):
+        fake_dbus_backend = Mock()
+        po_cs.return_value = (None, None, None)
+        _po._get_applicable_class_name(None, fake_dbus_backend)
+        po_cs.assert_called_once_with(fake_dbus_backend)
+
+    @patch.object(_po, '_get_proxy_object_class_name_and_state')
+    def test_returns_dbus_name_when_passed_None(self, po_cs):
+        name = self.getUniqueString()
+        po_cs.return_value = (name, None, None)
+        fake_dbus_backend = Mock()
+
+        self.assertEqual(
+            name,
+            _po._get_applicable_class_name(
+                None,
+                fake_dbus_backend
+            )
+        )
+
+    @patch.object(_po, '_get_proxy_object_class_name_and_state')
+    def test_returns_dbus_name_when_passed_star(self, po_cs):
+        name = self.getUniqueString()
+        po_cs.return_value = (name, None, None)
+        fake_dbus_backend = Mock()
+
+        self.assertEqual(
+            name,
+            _po._get_applicable_class_name(
+                '*',
+                fake_dbus_backend
+            )
+        )
+
+    def test_returns_name_of_string(self):
+        name = self.getUniqueString()
+        self.assertEqual(name, _po._get_applicable_class_name(name, None))