1
=== modified file 'autopilot/introspection/_object_registry.py'
2
--- autopilot/introspection/_object_registry.py	2015-05-06 10:00:49 +0000
3
+++ autopilot/introspection/_object_registry.py	2015-07-20 22:41:01 +0000
4
@@ -42,10 +42,6 @@
5
42
42
6
43
"""
43
"""
7
44
44
8
45
from uuid import uuid4
9
46
10
47
from autopilot.introspection._xpathselect import get_classname_from_path
11
48
from autopilot.utilities import get_debug_logger
12
49
from contextlib import contextmanager
45
from contextlib import contextmanager
13
50
46
14
51
_object_registry = {}
47
_object_registry = {}
15
@@ -62,92 +58,6 @@
16
62
    return _proxy_extensions.get(id, ())
58
    return _proxy_extensions.get(id, ())
17
63
59
18
64
60
19
65
class IntrospectableObjectMetaclass(type):
20
66
    """Metaclass to insert appropriate classes into the object registry."""
21
67
22
68
    def __new__(cls, classname, bases, classdict):
23
69
        """Create a new proxy class, possibly adding it to the object registry.
24
70
25
71
        Test authors may derive a class from DBusIntrospectionObject or the
26
72
        CustomEmulatorBase alias and use this as their 'emulator base'. This
27
73
        class will be given a unique '_id' attribute. That attribute is the
28
74
        first level index into the object registry. It's used so we can have
29
75
        custom proxy classes for more than one process at the same time and
30
76
        avoid clashes in the dictionary.
31
77
        """
32
78
        cls_id = None
33
79
34
80
        for base in bases:
35
81
            if hasattr(base, '_id'):
36
82
                cls_id = base._id
37
83
                break
38
84
        else:
39
85
            # Ignore classes that are in the autopilot class heirarchy:
40
86
            if classname not in (
41
87
                'ApplicationProxyObject',
42
88
                'CustomEmulatorBase',
43
89
                'DBusIntrospectionObject',
44
90
                'DBusIntrospectionObjectBase',
45
91
            ):
46
92
                # Add the '_id' attribute as a class attr:
47
93
                cls_id = classdict['_id'] = uuid4()
48
94
49
95
        # use the bases passed to us, but extend it with whatever is stored in
50
96
        # the proxy_extensions dictionary.
51
97
        extensions = _get_proxy_bases_for_id(cls_id)
52
98
        for extension in extensions:
53
99
            if extension not in bases:
54
100
                bases += (extension,)
55
101
        # make the object. Nothing special here.
56
102
        class_object = type.__new__(cls, classname, bases, classdict)
57
103
58
104
        if not classdict.get('__generated', False):
59
105
            # If the newly made object has an id, add it to the object
60
106
            # registry.
61
107
            if getattr(class_object, '_id', None) is not None:
62
108
                if class_object._id in _object_registry:
63
109
                    _object_registry[class_object._id][classname] = \
64
110
                        class_object
65
111
                else:
66
112
                    _object_registry[class_object._id] = \
67
113
                        {classname: class_object}
68
114
        # in all cases, return the class unchanged.
69
115
        return class_object
70
116
71
117
72
118
DBusIntrospectionObjectBase = IntrospectableObjectMetaclass(
73
119
    'DBusIntrospectionObjectBase',
74
120
    (object,),
75
121
    {}
76
122
)
77
123
78
124
79
125
def _get_proxy_object_class(object_id, path, state):
80
126
    """Return a custom proxy class, from the object registry or the default.
81
127
82
128
    This function first inspects the object registry using the object_id passed
83
129
    in. The object_id will be unique to all custom proxy classes for the same
84
130
    application.
85
131
86
132
    If that fails, we create a class on the fly based on the default class.
87
133
88
134
    :param object_id: The _id attribute of the class doing the lookup. This is
89
135
        used to index into the object registry to retrieve the dict of proxy
90
136
        classes to try.
91
137
    :param path: dbus path
92
138
    :param state: dbus state
93
139
    :returns: appropriate custom proxy class
94
140
    :raises ValueError: if more than one class in the dict matches
95
141
96
142
    """
97
143
    class_type = _try_custom_proxy_classes(object_id, path, state)
98
144
99
145
    return class_type or _get_default_proxy_class(
100
146
        object_id,
101
147
        get_classname_from_path(path)
102
148
    )
103
149
104
150
105
151
def _try_custom_proxy_classes(object_id, path, state):
61
def _try_custom_proxy_classes(object_id, path, state):
106
152
    """Identify which custom proxy class matches the dbus path and state.
62
    """Identify which custom proxy class matches the dbus path and state.
107
153
63
108
@@ -239,26 +149,6 @@
109
239
    return order
149
    return order
110
240
150
111
241
151
112
242
def _get_default_proxy_class(id, name):
113
243
    """Return a custom proxy object class of the default or a base class.
114
244
115
245
    We want the object to inherit from the class that is set as the emulator
116
246
    base class, not the class that is doing the selecting. Using the passed id
117
247
    we retrieve the relevant bases from the object registry.
118
248
119
249
    :param id: The object id (_id attribute) of the class doing the lookup.
120
250
    :param name: name of new class
121
251
    :returns: custom proxy object class
122
252
123
253
    """
124
254
    get_debug_logger().warning(
125
255
        "Generating introspection instance for type '%s' based on generic "
126
256
        "class.", name)
127
257
    if isinstance(name, bytes):
128
258
        name = name.decode('utf-8')
129
259
    return type(name, _get_proxy_bases_for_id(id), dict(__generated=True))
130
260
131
261
132
262
@contextmanager
152
@contextmanager
133
263
def patch_registry(new_registry):
153
def patch_registry(new_registry):
134
264
    """A utility context manager that allows us to patch the object registry.
154
    """A utility context manager that allows us to patch the object registry.
135
265
155
136
=== added file 'autopilot/introspection/_proxy_objects.py'
137
--- autopilot/introspection/_proxy_objects.py	1970-01-01 00:00:00 +0000
138
+++ autopilot/introspection/_proxy_objects.py	2015-07-20 22:41:01 +0000
139
@@ -0,0 +1,212 @@
140
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
141
2
#
142
3
# Autopilot Functional Test Tool
143
4
# Copyright (C) 2015 Canonical
144
5
#
145
6
# This program is free software: you can redistribute it and/or modify
146
7
# it under the terms of the GNU General Public License as published by
147
8
# the Free Software Foundation, either version 3 of the License, or
148
9
# (at your option) any later version.
149
10
#
150
11
# This program is distributed in the hope that it will be useful,
151
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
152
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
153
14
# GNU General Public License for more details.
154
15
#
155
16
# You should have received a copy of the GNU General Public License
156
17
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
157
18
#
158
19
159
20
"""Functions for dealing with proxy classes and objects."""
160
21
161
22
162
23
from autopilot.introspection import (
163
24
    constants,
164
25
    dbus as ap_dbus
165
26
)
166
27
from autopilot.introspection._xpathselect import get_classname_from_path
167
28
from autopilot.utilities import get_debug_logger
168
29
169
30
170
31
def _get_introspection_xml_from_backend(
171
32
        backend, reply_handler=None, error_handler=None):
172
33
    """Get DBus Introspection xml from a backend.
173
34
174
35
    :param backend: The backend object to query.
175
36
    :param reply_handler: If set, makes a dbus async call, and the result will
176
37
        be sent to reply_handler. This must be a callable object.
177
38
    :param error_handler: If set, this callable will recieve any errors, and
178
39
        the call will be made asyncronously.
179
40
    :returns: A string containing introspection xml, if called synchronously.
180
41
    :raises ValueError: if one, but not both of 'reply_handler' and
181
42
        'error_handler' are set.
182
43
183
44
    """
184
45
    if callable(reply_handler) and callable(error_handler):
185
46
        backend.dbus_introspection_iface.Introspect(
186
47
            reply_handler=reply_handler,
187
48
            error_handler=error_handler,
188
49
        )
189
50
    elif reply_handler or error_handler:
190
51
        raise ValueError(
191
52
            "Both 'reply_handler' and 'error_handler' must be set."
192
53
        )
193
54
    else:
194
55
        return backend.dbus_introspection_iface.Introspect()
195
56
196
57
197
58
def _get_proxy_bases_from_introspection_xml(introspection_xml):
198
59
    """Return  tuple of the base classes to use when creating a proxy object.
199
60
200
61
    Currently this works by looking for certain interface names in the XML. In
201
62
    the future we may want to parse the XML and perform more rigerous checks.
202
63
203
64
    :param introspection_xml: An xml string that describes the exported object
204
65
        on the dbus backend. This determines which capabilities are present in
205
66
        the backend, and therefore which base classes should be used to create
206
67
        the proxy object.
207
68
208
69
    :raises RuntimeError: if the autopilot interface cannot be found.
209
70
210
71
    """
211
72
212
73
    bases = []
213
74
214
75
    if constants.AP_INTROSPECTION_IFACE not in introspection_xml:
215
76
        raise RuntimeError("Could not find Autopilot interface.")
216
77
217
78
    if constants.QT_AUTOPILOT_IFACE in introspection_xml:
218
79
        from autopilot.introspection.qt import QtObjectProxyMixin
219
80
        bases.append(QtObjectProxyMixin)
220
81
221
82
    return tuple(bases)
222
83
223
84
224
85
def _get_proxy_object_class_name_and_state(
225
86
        backend, reply_handler=None, error_handler=None):
226
87
    """Get details about this autopilot backend via a dbus GetState call.
227
88
228
89
    :param reply_handler: A callable that must accept three positional
229
90
        arguments, which correspond to the return value of this function when
230
91
        called synchronously.
231
92
232
93
    :param error_handler: A callable which will recieve any dbus errors, should
233
94
        they occur.
234
95
235
96
    :raises ValueError: if one, but not both of reply_handler and error_handler
236
97
        are set.
237
98
238
99
    :returns: A tuple containing the class name of the root of the
239
100
        introspection tree, the full path to the root of the introspection
240
101
        tree, and the state dictionary of the root node in the introspection
241
102
        tree.
242
103
243
104
    """
244
105
    if callable(reply_handler) and callable(error_handler):
245
106
        # Async call:
246
107
        # Since we get an array of state, and we only care about the first one
247
108
        # we use a lambda to unpack it and get the details we want.
248
109
        backend.introspection_iface.GetState(
249
110
            "/",
250
111
            reply_handler=lambda r: reply_handler(
251
112
                *_get_details_from_state_data(r[0])
252
113
            ),
253
114
            error_handler=error_handler,
254
115
        )
255
116
    elif reply_handler or error_handler:
256
117
        raise ValueError(
257
118
            "Both 'reply_handler' and 'error_handler' must be set."
258
119
        )
259
120
    else:
260
121
        # Sync call
261
122
        state = backend.introspection_iface.GetState("/")[0]
262
123
        return _get_details_from_state_data(state)
263
124
264
125
265
126
def _get_details_from_state_data(state_data):
266
127
    """Get details from a state data array.
267
128
268
129
    Returns class name, path, and state dictionary.
269
130
    """
270
131
    object_path, object_state = state_data
271
132
    return (
272
133
        get_classname_from_path(object_path),
273
134
        object_path.encode('utf-8'),
274
135
        object_state,
275
136
    )
276
137
277
138
278
139
def _get_default_proxy_class(name, bases):
279
140
    """Return a default custom proxy object class.
280
141
281
142
    :param name: name of new class
282
143
    :param bases: Tuple of base classes to add to the base.
283
144
    :returns: custom proxy object class
284
145
285
146
    """
286
147
    get_debug_logger().warning(
287
148
        "Generating introspection instance for type '%s' based on generic "
288
149
        "class.", name)
289
150
    if isinstance(name, bytes):
290
151
        name = name.decode('utf-8')
291
152
    return type(
292
153
        name,
293
154
        (ap_dbus.DBusIntrospectionObject,) + bases,
294
155
        dict(__generated=True)
295
156
    )
296
157
297
158
298
159
def get_proxy_object_class(cpo_or_string, path, dbus_backend):
299
160
    """Return the proxy class to use with the correct bases added
300
161
301
162
    If passed a CPO returns that, if passed a string contructs a default class
302
163
    to use instead.
303
164
304
165
    """
305
166
306
167
    extension_classes = _get_extension_classes(dbus_backend)
307
168
308
169
    if _is_cpo_class(cpo_or_string):
309
170
        _apply_mixin_bases(cpo_or_string, extension_classes)
310
171
        return cpo_or_string
311
172
    else:
312
173
        cpo_name = _get_applicable_class_name(cpo_or_string, path)
313
174
        return _get_default_proxy_class(cpo_name, extension_classes)
314
175
315
176
316
177
def _get_extension_classes(dbus_backend):
317
178
    """Return any extension classes that this object will need."""
318
179
319
180
    intro_xml = _get_introspection_xml_from_backend(dbus_backend)
320
181
    try:
321
182
        return _get_proxy_bases_from_introspection_xml(intro_xml)
322
183
    except RuntimeError as e:
323
184
        e.args = (
324
185
            "Could not find Autopilot interface on dbus address '%s'."
325
186
            % dbus_backend,
326
187
        )
327
188
328
189
329
190
def _is_cpo_class(cpo_or_string):
330
191
    return cpo_or_string is not None and not isinstance(cpo_or_string, str)
331
192
332
193
333
194
def _get_applicable_class_name(cpo_name, path):
334
195
    """Return correct name for class.
335
196
336
197
    Determine what the actual name should be if cpo_name isn't a class (and
337
198
    thus has its own name.)
338
199
    It is possible that the cpo_name is '*' which is what was used in the
339
200
    original query.
340
201
341
202
    """
342
203
    if cpo_name is None or cpo_name == '*':
343
204
        cls_name = get_classname_from_path(path)
344
205
        return cls_name.decode('utf-8')
345
206
    else:
346
207
        return cpo_name
347
208
348
209
349
210
def _apply_mixin_bases(target_class, mixin_classes):
350
211
    to_add = tuple(set(mixin_classes).difference(target_class.__bases__))
351
212
    target_class.__bases__ += to_add
352
0
213
353
=== modified file 'autopilot/introspection/_search.py'
354
--- autopilot/introspection/_search.py	2015-05-06 10:03:43 +0000
355
+++ autopilot/introspection/_search.py	2015-07-20 22:41:01 +0000
356
@@ -33,7 +33,7 @@
357
33
from autopilot.introspection import backends
33
from autopilot.introspection import backends
358
34
from autopilot.introspection import constants
34
from autopilot.introspection import constants
359
35
from autopilot.introspection import dbus as ap_dbus
35
from autopilot.introspection import dbus as ap_dbus
361
36
from autopilot.introspection import _object_registry
36
from autopilot.introspection import _proxy_objects as _po
362
37
from autopilot.introspection._xpathselect import get_classname_from_path
37
from autopilot.introspection._xpathselect import get_classname_from_path
363
38
from autopilot.introspection.backends import WireProtocolVersionMismatch
38
from autopilot.introspection.backends import WireProtocolVersionMismatch
364
39
from autopilot.introspection.utilities import (
39
from autopilot.introspection.utilities import (
365
@@ -76,8 +76,12 @@
366
76
    Searches the given bus (supplied by the kwarg **dbus_bus**) for an
76
    Searches the given bus (supplied by the kwarg **dbus_bus**) for an
367
77
    application matching the search criteria (also supplied in kwargs, see
77
    application matching the search criteria (also supplied in kwargs, see
368
78
    further down for explaination on what these can be.)
78
    further down for explaination on what these can be.)
371
79
    Returns a proxy object created using the supplied custom emulator
79
    Returns a proxy object created using the supplied custom proxy object class
372
80
    **emulator_base** (which defaults to None).
80
    **cpo_class** (which defaults to None).
373
81
374
82
    Note: for backwards compatibility this method will continue to accept
375
83
      emulator_base instead of cpo_class. Currently will issue a warning, in
376
84
      the future this will potentially be an error.
377
81
85
378
82
    This function take kwargs arguments containing search parameter values to
86
    This function take kwargs arguments containing search parameter values to
379
83
    use when searching for the target application.
87
    use when searching for the target application.
380
@@ -105,9 +109,9 @@
381
105
        Must be a string containing either 'session', 'system' or the
109
        Must be a string containing either 'session', 'system' or the
382
106
        custom buses name (i.e. 'unix:abstract=/tmp/dbus-IgothuMHNk').
110
        custom buses name (i.e. 'unix:abstract=/tmp/dbus-IgothuMHNk').
383
107
        Defaults to 'session'
111
        Defaults to 'session'
385
108
    :param emulator_base: The custom emulator to use when creating the
112
    :param cpo_class: The custom proxy object class to use when creating the
386
109
        resulting proxy object.
113
        resulting proxy object.
388
110
        Defaults to None
114
        Defaults to None resulting in a generated default object.
389
111
115
390
112
    **Exceptions possibly thrown by this function:**
116
    **Exceptions possibly thrown by this function:**
391
113
117
392
@@ -154,7 +158,15 @@
393
154
    # Pop off non-search stuff.
158
    # Pop off non-search stuff.
394
155
    dbus_bus = _get_dbus_bus_from_string(kwargs.pop('dbus_bus', 'session'))
159
    dbus_bus = _get_dbus_bus_from_string(kwargs.pop('dbus_bus', 'session'))
395
156
    process = kwargs.pop('process', None)
160
    process = kwargs.pop('process', None)
396
161
    cpo_class = kwargs.pop('cpo_class', None)
397
157
    emulator_base = kwargs.pop('emulator_base', None)
162
    emulator_base = kwargs.pop('emulator_base', None)
398
163
    if emulator_base is not None:
399
164
        logger.warning(
400
165
            'The use of emulator_base is deprecated. Please use '
401
166
            'cpo_class instead.'
402
167
        )
403
168
404
169
    cpo_class = cpo_class if cpo_class else emulator_base
405
158
170
406
159
    # Force default object_path
171
    # Force default object_path
407
160
    kwargs['object_path'] = kwargs.get('object_path', constants.AUTOPILOT_PATH)
172
    kwargs['object_path'] = kwargs.get('object_path', constants.AUTOPILOT_PATH)
408
@@ -180,7 +192,7 @@
409
180
    connection_name = connections[0]
192
    connection_name = connections[0]
410
181
    return _make_proxy_object(
193
    return _make_proxy_object(
411
182
        _get_dbus_address_object(connection_name, object_path, dbus_bus),
194
        _get_dbus_address_object(connection_name, object_path, dbus_bus),
413
183
        emulator_base
195
        cpo_class
414
184
    )
196
    )
415
185
197
416
186
198
417
@@ -377,47 +389,25 @@
418
377
    ])
389
    ])
419
378
390
420
379
391
422
380
def _make_proxy_object(dbus_address, emulator_base):
392
def _make_proxy_object(dbus_address, cpo_class):
423
381
    """Returns a root proxy object given a DBus service name.
393
    """Returns a root proxy object given a DBus service name.
424
382
394
425
383
    :param dbus_address: The DBusAddress object we're querying.
395
    :param dbus_address: The DBusAddress object we're querying.
428
384
    :param emulator_base: The emulator base object (or None), as provided by
396
    :param cpo_class: The Custom Proxy Object class (or None) to use, as
429
385
        the user.
397
    provided by the user.
430
386
    """
398
    """
457
387
    # make sure we always have an emulator base. Either use the one the user
399
458
388
    # gave us, or make one:
400
    # make sure we always have an cpo class. Either use the one the user gave
459
389
    emulator_base = emulator_base or _make_default_emulator_base()
401
    # us, or make one:
460
390
    _raise_if_base_class_not_actually_base(emulator_base)
402
    # This will return a default class or the CPO with the correct additions
461
391
403
    # made.
462
392
    # Get the dbus introspection Xml for the backend.
404
    cls_name, path, cls_state = _po._get_proxy_object_class_name_and_state(
437
393
    intro_xml = _get_introspection_xml_from_backend(dbus_address)
438
394
    try:
439
395
        # Figure out if the backend has any extension methods, and return
440
396
        # classes that understand how to use each of those extensions:
441
397
        extension_classes = _get_proxy_bases_from_introspection_xml(intro_xml)
442
398
443
399
        # Register those base classes for everything that will derive from this
444
400
        # emulator base class.
445
401
        _object_registry.register_extension_classes_for_proxy_base(
446
402
            emulator_base,
447
403
            extension_classes,
448
404
        )
449
405
    except RuntimeError as e:
450
406
        e.args = (
451
407
            "Could not find Autopilot interface on dbus address '%s'."
452
408
            % dbus_address,
453
409
        )
454
410
        raise e
455
411
456
412
    cls_name, path, cls_state = _get_proxy_object_class_name_and_state(
463
413
        dbus_address
405
        dbus_address
464
414
    )
406
    )
465
407
    proxy_class = _po.get_proxy_object_class(
466
408
        cpo_class, path, dbus_address
467
409
    )
468
415
410
469
416
    proxy_class = _object_registry._get_proxy_object_class(
470
417
        emulator_base._id,
471
418
        path,
472
419
        cls_state
473
420
    )
474
421
    # For this object only, add the ApplicationProxy class, since it's the
411
    # For this object only, add the ApplicationProxy class, since it's the
475
422
    # root of the tree. Ideally this would be nicer...
412
    # root of the tree. Ideally this would be nicer...
476
423
    if ApplicationProxyObject not in proxy_class.__bases__:
413
    if ApplicationProxyObject not in proxy_class.__bases__:
477
@@ -425,11 +415,6 @@
478
425
    return proxy_class(cls_state, path, backends.Backend(dbus_address))
415
    return proxy_class(cls_state, path, backends.Backend(dbus_address))
479
426
416
480
427
417
481
428
def _make_default_emulator_base():
482
429
    """Make a default base class for all proxy classes to derive from."""
483
430
    return type("DefaultEmulatorBase", (ap_dbus.DBusIntrospectionObject,), {})
484
431
485
432
486
433
WRONG_CPO_CLASS_MSG = '''\
418
WRONG_CPO_CLASS_MSG = '''\
487
434
base_class: {passed} does not appear to be the actual base CPO class.
419
base_class: {passed} does not appear to be the actual base CPO class.
488
435
Perhaps you meant to use: {actual}.'''
420
Perhaps you meant to use: {actual}.'''
489
@@ -482,20 +467,22 @@
490
482
    def build_proxy(introspection_xml, cls_name, path, cls_state):
467
    def build_proxy(introspection_xml, cls_name, path, cls_state):
491
483
        # Figure out if the backend has any extension methods, and return
468
        # Figure out if the backend has any extension methods, and return
492
484
        # classes that understand how to use each of those extensions:
469
        # classes that understand how to use each of those extensions:
494
485
        extension_classes = _get_proxy_bases_from_introspection_xml(
470
        extension_classes = _po._get_proxy_bases_from_introspection_xml(
495
486
            introspection_xml
471
            introspection_xml
496
487
        )
472
        )
508
488
        # Register those base classes for everything that will derive from this
473
509
489
        # emulator base class.
474
        cpo_base = _po._get_applicable_class_name(emulator_base, path)
510
490
        _object_registry.register_extension_classes_for_proxy_base(
475
511
491
            emulator_base,
476
        if not _po._is_cpo_class(cpo_base):
512
492
            extension_classes,
477
            proxy_class = _po._get_default_proxy_class(
513
493
        )
478
                cpo_base,
514
494
        proxy_class = _object_registry._get_proxy_object_class(
479
                extension_classes
515
495
            emulator_base._id,
480
            )
516
496
            path,
481
        else:
517
497
            cls_state
482
            # It's actually a CPO class.
518
498
        )
483
            _po._apply_mixin_bases(cpo_base, extension_classes)
519
484
            proxy_class = cpo_base
520
485
521
499
        reply_handler(
486
        reply_handler(
522
500
            proxy_class(cls_state, path, backends.Backend(data_source))
487
            proxy_class(cls_state, path, backends.Backend(data_source))
523
501
        )
488
        )
524
@@ -503,7 +490,7 @@
525
503
    # Phase 2: We recieve the introspection string, and make an asynchronous
490
    # Phase 2: We recieve the introspection string, and make an asynchronous
526
504
    # dbus call to get the state information for the root of this applicaiton.
491
    # dbus call to get the state information for the root of this applicaiton.
527
505
    def get_root_state(introspection_xml):
492
    def get_root_state(introspection_xml):
529
506
        _get_proxy_object_class_name_and_state(
493
        _po._get_proxy_object_class_name_and_state(
530
507
            data_source,
494
            data_source,
531
508
            reply_handler=partial(build_proxy, introspection_xml),
495
            reply_handler=partial(build_proxy, introspection_xml),
532
509
            error_handler=error_handler,
496
            error_handler=error_handler,
533
@@ -511,123 +498,13 @@
534
511
498
535
512
    # Phase 1: Make an asynchronous dbus call to get the introspection xml
499
    # Phase 1: Make an asynchronous dbus call to get the introspection xml
536
513
    # from the data_source provided for us.
500
    # from the data_source provided for us.
540
514
    emulator_base = emulator_base or _make_default_emulator_base()
501
    _po._get_introspection_xml_from_backend(
538
515
539
516
    _get_introspection_xml_from_backend(
541
517
        data_source,
502
        data_source,
542
518
        reply_handler=get_root_state,
503
        reply_handler=get_root_state,
543
519
        error_handler=error_handler
504
        error_handler=error_handler
544
520
    )
505
    )
545
521
506
546
522
507
547
523
def _get_introspection_xml_from_backend(
548
524
        backend, reply_handler=None, error_handler=None):
549
525
    """Get DBus Introspection xml from a backend.
550
526
551
527
    :param backend: The backend object to query.
552
528
    :param reply_handler: If set, makes a dbus async call, and the result will
553
529
        be sent to reply_handler. This must be a callable object.
554
530
    :param error_handler: If set, this callable will recieve any errors, and
555
531
        the call will be made asyncronously.
556
532
    :returns: A string containing introspection xml, if called synchronously.
557
533
    :raises ValueError: if one, but not both of 'reply_handler' and
558
534
        'error_handler' are set.
559
535
560
536
    """
561
537
    if callable(reply_handler) and callable(error_handler):
562
538
        backend.dbus_introspection_iface.Introspect(
563
539
            reply_handler=reply_handler,
564
540
            error_handler=error_handler,
565
541
        )
566
542
    elif reply_handler or error_handler:
567
543
        raise ValueError(
568
544
            "Both 'reply_handler' and 'error_handler' must be set."
569
545
        )
570
546
    else:
571
547
        return backend.dbus_introspection_iface.Introspect()
572
548
573
549
574
550
def _get_proxy_object_class_name_and_state(
575
551
        backend, reply_handler=None, error_handler=None):
576
552
    """Get details about this autopilot backend via a dbus GetState call.
577
553
578
554
    :param reply_handler: A callable that must accept three positional
579
555
        arguments, which correspond to the return value of this function when
580
556
        called synchronously.
581
557
582
558
    :param error_handler: A callable which will recieve any dbus errors, should
583
559
        they occur.
584
560
585
561
    :raises ValueError: if one, but not both of reply_handler and error_handler
586
562
        are set.
587
563
588
564
    :returns: A tuple containing the class name of the root of the
589
565
        introspection tree, the full path to the root of the introspection
590
566
        tree, and the state dictionary of the root node in the introspection
591
567
        tree.
592
568
593
569
    """
594
570
    if callable(reply_handler) and callable(error_handler):
595
571
        # Async call:
596
572
        # Since we get an array of state, and we only care about the first one
597
573
        # we use a lambda to unpack it and get the details we want.
598
574
        backend.introspection_iface.GetState(
599
575
            "/",
600
576
            reply_handler=lambda r: reply_handler(
601
577
                *_get_details_from_state_data(r[0])
602
578
            ),
603
579
            error_handler=error_handler,
604
580
        )
605
581
    elif reply_handler or error_handler:
606
582
        raise ValueError(
607
583
            "Both 'reply_handler' and 'error_handler' must be set."
608
584
        )
609
585
    else:
610
586
        # Sync call
611
587
        state = backend.introspection_iface.GetState("/")[0]
612
588
        return _get_details_from_state_data(state)
613
589
614
590
615
591
def _get_details_from_state_data(state_data):
616
592
    """Get details from a state data array.
617
593
618
594
    Returns class name, path, and state dictionary.
619
595
    """
620
596
    object_path, object_state = state_data
621
597
    return (
622
598
        get_classname_from_path(object_path),
623
599
        object_path.encode('utf-8'),
624
600
        object_state,
625
601
    )
626
602
627
603
628
604
def _get_proxy_bases_from_introspection_xml(introspection_xml):
629
605
    """Return  tuple of the base classes to use when creating a proxy object.
630
606
631
607
    Currently this works by looking for certain interface names in the XML. In
632
608
    the future we may want to parse the XML and perform more rigerous checks.
633
609
634
610
    :param introspection_xml: An xml string that describes the exported object
635
611
        on the dbus backend. This determines which capabilities are present in
636
612
        the backend, and therefore which base classes should be used to create
637
613
        the proxy object.
638
614
639
615
    :raises RuntimeError: if the autopilot interface cannot be found.
640
616
641
617
    """
642
618
643
619
    bases = []
644
620
645
621
    if constants.AP_INTROSPECTION_IFACE not in introspection_xml:
646
622
        raise RuntimeError("Could not find Autopilot interface.")
647
623
648
624
    if constants.QT_AUTOPILOT_IFACE in introspection_xml:
649
625
        from autopilot.introspection.qt import QtObjectProxyMixin
650
626
        bases.append(QtObjectProxyMixin)
651
627
652
628
    return tuple(bases)
653
629
654
630
655
631
class ApplicationProxyObject(object):
508
class ApplicationProxyObject(object):
656
632
    """A class that better supports query data from an application."""
509
    """A class that better supports query data from an application."""
657
633
510
658
634
511
659
=== modified file 'autopilot/introspection/backends.py'
660
--- autopilot/introspection/backends.py	2015-06-09 15:35:08 +0000
661
+++ autopilot/introspection/backends.py	2015-07-20 22:41:01 +0000
662
@@ -51,7 +51,7 @@
663
51
    _pid_is_running,
51
    _pid_is_running,
664
52
    _get_bus_connections_pid,
52
    _get_bus_connections_pid,
665
53
)
53
)
667
54
from autopilot.introspection._object_registry import _get_proxy_object_class
54
from autopilot.introspection import _proxy_objects
668
55
55
669
56
56
670
57
_logger = logging.getLogger(__name__)
57
_logger = logging.getLogger(__name__)
671
@@ -245,14 +245,14 @@
672
245
                )
245
                )
673
246
            return data
246
            return data
674
247
247
676
248
    def execute_query_get_proxy_instances(self, query, id):
248
    def execute_query_get_proxy_instances(self, query, cpo_class):
677
249
        """Execute 'query', returning proxy instances."""
249
        """Execute 'query', returning proxy instances."""
678
250
        data = self.execute_query_get_data(query)
250
        data = self.execute_query_get_data(query)
679
251
        objects = [
251
        objects = [
680
252
            make_introspection_object(
252
            make_introspection_object(
681
253
                t,
253
                t,
682
254
                type(self)(self.ipc_address),
254
                type(self)(self.ipc_address),
684
255
                id,
255
                cpo_class,
685
256
            )
256
            )
686
257
            for t in data
257
            for t in data
687
258
        ]
258
        ]
688
@@ -288,7 +288,7 @@
689
288
        return self.fake_ipc_return_data
288
        return self.fake_ipc_return_data
690
289
289
691
290
290
693
291
def make_introspection_object(dbus_tuple, backend, object_id):
291
def make_introspection_object(dbus_tuple, backend, cpo_class):
694
292
    """Make an introspection object given a DBus tuple of
292
    """Make an introspection object given a DBus tuple of
695
293
    (path, state_dict).
293
    (path, state_dict).
696
294
294
697
@@ -303,7 +303,11 @@
698
303
    """
303
    """
699
304
    path, state = dbus_tuple
304
    path, state = dbus_tuple
700
305
    path = path.encode('utf-8')
305
    path = path.encode('utf-8')
702
306
    class_object = _get_proxy_object_class(object_id, path, state)
306
    class_object = _proxy_objects.get_proxy_object_class(
703
307
        cpo_class,
704
308
        path,
705
309
        backend.ipc_address
706
310
    )
707
307
    return class_object(state, path, backend)
311
    return class_object(state, path, backend)
708
308
312
709
309
313
710
310
314
711
=== modified file 'autopilot/introspection/dbus.py'
712
--- autopilot/introspection/dbus.py	2015-07-20 22:41:00 +0000
713
+++ autopilot/introspection/dbus.py	2015-07-20 22:41:01 +0000
714
@@ -30,9 +30,6 @@
715
30
import logging
30
import logging
716
31
31
717
32
from autopilot.exceptions import StateNotFoundError
32
from autopilot.exceptions import StateNotFoundError
718
33
from autopilot.introspection._object_registry import (
719
34
    DBusIntrospectionObjectBase,
720
35
)
721
36
from autopilot.introspection.types import create_value_instance
33
from autopilot.introspection.types import create_value_instance
722
37
from autopilot.introspection.utilities import translate_state_keys
34
from autopilot.introspection.utilities import translate_state_keys
723
38
from autopilot.introspection import _xpathselect as xpathselect
35
from autopilot.introspection import _xpathselect as xpathselect
724
@@ -42,7 +39,7 @@
725
42
_logger = logging.getLogger(__name__)
39
_logger = logging.getLogger(__name__)
726
43
40
727
44
41
729
45
class DBusIntrospectionObject(DBusIntrospectionObjectBase):
42
class DBusIntrospectionObject(object):
730
46
    """A class that supports transparent data retrieval from the application
43
    """A class that supports transparent data retrieval from the application
731
47
    under test.
44
    under test.
732
48
45
733
@@ -83,11 +80,16 @@
734
83
            self.id
80
            self.id
735
84
        )
81
        )
736
85
82
739
86
    def _execute_query(self, query):
83
    def _execute_query(self, query, cpo_class=None):
740
87
        """Execute query object 'query' and return the result."""
84
        """Execute query object 'query' and return the result.
741
85
742
86
        Returns a proxy object created from ``cpo_class``. If ``cpo_class`` is
743
87
        None the proxy object will be a generated default.
744
88
745
89
        """
746
88
        return self._backend.execute_query_get_proxy_instances(
90
        return self._backend.execute_query_get_proxy_instances(
747
89
            query,
91
            query,
749
90
            getattr(self, '_id', None),
92
            cpo_class,
750
91
        )
93
        )
751
92
94
752
93
    def _set_properties(self, state_dict):
95
    def _set_properties(self, state_dict):
753
@@ -151,7 +153,7 @@
754
151
            kwargs
153
            kwargs
755
152
        )
154
        )
756
153
155
758
154
        return self._execute_query(new_query)
156
        return self._execute_query(new_query, desired_type)
759
155
157
760
156
    def get_properties(self):
158
    def get_properties(self):
761
157
        """Returns a dictionary of all the properties on this class.
159
        """Returns a dictionary of all the properties on this class.
762
@@ -175,9 +177,12 @@
763
175
        This returns a list of all children. To return only children of a
177
        This returns a list of all children. To return only children of a
764
176
        specific type, use :meth:`get_children_by_type`. To get objects
178
        specific type, use :meth:`get_children_by_type`. To get objects
765
177
        further down the introspection tree (i.e.- nodes that may not
179
        further down the introspection tree (i.e.- nodes that may not
767
178
        necessarily be immeadiate children), use :meth:`select_single` and
180
        necessarily be immediate children), use :meth:`select_single` and
768
179
        :meth:`select_many`.
181
        :meth:`select_many`.
769
180
182
770
183
        Note. Any proxy objects return from this call will be generated
771
184
        defaults and will not use any Custom Proxy Object classes.
772
185
773
181
        """
186
        """
774
182
        # Thomi: 2014-03-20: There used to be a call to 'self.refresh_state()'
187
        # Thomi: 2014-03-20: There used to be a call to 'self.refresh_state()'
775
183
        # here. That's not needed, since the only thing we use is the proxy
188
        # here. That's not needed, since the only thing we use is the proxy
776
@@ -191,6 +196,9 @@
777
191
        If this object has no parent (i.e.- it is the root of the introspection
196
        If this object has no parent (i.e.- it is the root of the introspection
778
192
        tree). Then it returns itself.
197
        tree). Then it returns itself.
779
193
198
780
199
        Note. Any proxy object return from this call will be generated defaults
781
200
        and will not use any Custom Proxy Object classes.
782
201
783
194
        """
202
        """
784
195
        new_query = self._query.select_parent()
203
        new_query = self._query.select_parent()
785
196
        return self._execute_query(new_query)[0]
204
        return self._execute_query(new_query)[0]
786
@@ -237,7 +245,7 @@
787
237
            type_name_str,
245
            type_name_str,
788
238
            kwargs
246
            kwargs
789
239
        )
247
        )
791
240
        instances = self._execute_query(new_query)
248
        instances = self._execute_query(new_query, type_name)
792
241
        if len(instances) > 1:
249
        if len(instances) > 1:
793
242
            raise ValueError("More than one item was returned for query")
250
            raise ValueError("More than one item was returned for query")
794
243
        if not instances:
251
        if not instances:
795
@@ -351,7 +359,7 @@
796
351
            'any type'
359
            'any type'
797
352
            if type_name_str == '*' else 'type ' + type_name_str, kwargs
360
            if type_name_str == '*' else 'type ' + type_name_str, kwargs
798
353
        )
361
        )
800
354
        return self._execute_query(new_query)
362
        return self._execute_query(new_query, type_name)
801
355
363
802
356
    def refresh_state(self):
364
    def refresh_state(self):
803
357
        """Refreshes the object's state.
365
        """Refreshes the object's state.
804
@@ -410,10 +418,14 @@
805
410
            if self.__refresh_on_attribute:
418
            if self.__refresh_on_attribute:
806
411
                self.refresh_state()
419
                self.refresh_state()
807
412
            return self.__state[name]
420
            return self.__state[name]
808
421
809
422
        exception_msg = "{}Class '{}' has no attribute '{}'.".format(
810
423
            'Generated ' if hasattr(self.__class__, '__generated') else '',
811
424
            self.__class__.__name__,
812
425
            name
813
426
        )
814
413
        # attribute not found.
427
        # attribute not found.
818
414
        raise AttributeError(
428
        raise AttributeError(exception_msg)
816
415
            "Class '%s' has no attribute '%s'." %
817
416
            (self.__class__.__name__, name))
819
417
429
820
418
    def _get_new_state(self):
430
    def _get_new_state(self):
821
419
        """Retrieve a new state dictionary for this class instance.
431
        """Retrieve a new state dictionary for this class instance.
822
@@ -538,6 +550,7 @@
823
538
        :returns: Whether this class is appropriate for the dbus object
550
        :returns: Whether this class is appropriate for the dbus object
824
539
551
825
540
        """
552
        """
826
553
827
541
        state_name = xpathselect.get_classname_from_path(path)
554
        state_name = xpathselect.get_classname_from_path(path)
828
542
        if isinstance(state_name, str):
555
        if isinstance(state_name, str):
829
543
            state_name = state_name.encode('utf-8')
556
            state_name = state_name.encode('utf-8')
830
544
557
831
=== modified file 'autopilot/tests/functional/test_dbus_query.py'
832
--- autopilot/tests/functional/test_dbus_query.py	2015-06-09 15:35:08 +0000
833
+++ autopilot/tests/functional/test_dbus_query.py	2015-07-20 22:41:01 +0000
834
@@ -217,6 +217,12 @@
835
217
        self.assertThat(abs(end_time - start_time), GreaterThan(9))
217
        self.assertThat(abs(end_time - start_time), GreaterThan(9))
836
218
        self.assertThat(abs(end_time - start_time), LessThan(11))
218
        self.assertThat(abs(end_time - start_time), LessThan(11))
837
219
219
838
220
    def test_selecting_without_classname_sets_proxy_classname(self):
839
221
        app = self.start_fully_featured_app()
840
222
        test_object = app.select_single(windowTitle='Default Window Title')
841
223
842
224
        self.assertThat(test_object.__class__.__name__, Equals('QMainWindow'))
843
225
844
220
226
845
221
@skipIf(platform.model() != "Desktop", "Only suitable on Desktop (WinMocker)")
227
@skipIf(platform.model() != "Desktop", "Only suitable on Desktop (WinMocker)")
846
222
class DbusCustomBusTests(AutopilotTestCase):
228
class DbusCustomBusTests(AutopilotTestCase):
847
223
229
848
=== modified file 'autopilot/tests/functional/test_introspection_features.py'
849
--- autopilot/tests/functional/test_introspection_features.py	2015-07-20 22:41:00 +0000
850
+++ autopilot/tests/functional/test_introspection_features.py	2015-07-20 22:41:01 +0000
851
@@ -36,7 +36,6 @@
852
36
    StartsWith,
36
    StartsWith,
853
37
)
37
)
854
38
from textwrap import dedent
38
from textwrap import dedent
855
39
from unittest.mock import patch
856
40
from io import StringIO
39
from io import StringIO
857
41
40
858
42
from autopilot import platform
41
from autopilot import platform
859
@@ -46,7 +45,6 @@
860
46
from autopilot.tests.functional.fixtures import TempDesktopFile
45
from autopilot.tests.functional.fixtures import TempDesktopFile
861
47
from autopilot.introspection import CustomEmulatorBase
46
from autopilot.introspection import CustomEmulatorBase
862
48
from autopilot.introspection import _object_registry as object_registry
47
from autopilot.introspection import _object_registry as object_registry
863
49
from autopilot.introspection import _search
864
50
from autopilot.introspection.qt import QtObjectProxyMixin
48
from autopilot.introspection.qt import QtObjectProxyMixin
865
51
from autopilot.display import Display
49
from autopilot.display import Display
866
52
50
867
@@ -94,15 +92,9 @@
868
94
                return path == b'/window-mocker'
92
                return path == b'/window-mocker'
869
95
93
870
96
        # verify that the initial proxy object we get back is the correct type:
94
        # verify that the initial proxy object we get back is the correct type:
872
97
        app = self.start_mock_app(EmulatorBase)
95
        app = self.start_mock_app(WindowMockerApp)
873
98
        self.assertThat(type(app), Equals(WindowMockerApp))
96
        self.assertThat(type(app), Equals(WindowMockerApp))
874
99
97
875
100
        # verify that we get the correct type from get_root_instance:
876
101
        self.assertThat(
877
102
            type(app.get_root_instance()),
878
103
            Equals(WindowMockerApp)
879
104
        )
880
105
881
106
    def test_customised_proxy_classes_have_extension_classes(self):
98
    def test_customised_proxy_classes_have_extension_classes(self):
882
107
        class WindowMockerApp(EmulatorBase):
99
        class WindowMockerApp(EmulatorBase):
883
108
            @classmethod
100
            @classmethod
884
@@ -113,21 +105,20 @@
885
113
        self.assertThat(app.__class__.__bases__, Contains(QtObjectProxyMixin))
105
        self.assertThat(app.__class__.__bases__, Contains(QtObjectProxyMixin))
886
114
106
887
115
    def test_customised_proxy_classes_have_multiple_extension_classes(self):
107
    def test_customised_proxy_classes_have_multiple_extension_classes(self):
903
116
        with object_registry.patch_registry({}):
108
        class SecondEmulatorBase(CustomEmulatorBase):
904
117
            class SecondEmulatorBase(CustomEmulatorBase):
109
            pass
905
118
                pass
110
906
119
111
        class WindowMockerApp(EmulatorBase, SecondEmulatorBase):
907
120
            class WindowMockerApp(EmulatorBase, SecondEmulatorBase):
112
            @classmethod
908
121
                @classmethod
113
            def validate_dbus_object(cls, path, _state):
909
122
                def validate_dbus_object(cls, path, _state):
114
                return path == b'/window-mocker'
910
123
                    return path == b'/window-mocker'
115
911
124
116
        app = self.start_mock_app(WindowMockerApp)
912
125
            app = self.start_mock_app(EmulatorBase)
117
        self.assertThat(app.__class__.__bases__, Contains(EmulatorBase))
913
126
            self.assertThat(app.__class__.__bases__, Contains(EmulatorBase))
118
        self.assertThat(
914
127
            self.assertThat(
119
            app.__class__.__bases__,
915
128
                app.__class__.__bases__,
120
            Contains(SecondEmulatorBase)
916
129
                Contains(SecondEmulatorBase)
121
        )
902
130
            )
917
131
122
918
132
    def test_handles_using_app_cpo_base_class(self):
123
    def test_handles_using_app_cpo_base_class(self):
919
133
        # This test replicates an issue found in an application test suite
124
        # This test replicates an issue found in an application test suite
920
@@ -140,30 +131,17 @@
921
140
131
922
141
            self.start_mock_app(WindowMockerApp)
132
            self.start_mock_app(WindowMockerApp)
923
142
133
941
143
    def test_warns_when_using_incorrect_cpo_base_class(self):
134
    def test_selecting_using_string_creates_default_cpo(self):
942
144
        # Ensure the warning method is called when launching a proxy.
135
        """When not passing CPO must return generated default."""
943
145
        with object_registry.patch_registry({}):
136
927
146
            class TestCPO(CustomEmulatorBase):
928
147
                pass
929
148
930
149
            class WindowMockerApp(TestCPO):
931
150
                @classmethod
932
151
                def validate_dbus_object(cls, path, _state):
933
152
                    return path == b'/window-mocker'
934
153
935
154
            with patch.object(_search, 'logger') as p_logger:
936
155
                self.start_mock_app(WindowMockerApp)
937
156
                self.assertTrue(p_logger.warning.called)
938
157
939
158
    def test_can_select_custom_emulators_by_name(self):
940
159
        """Must be able to select a custom emulator type by name."""
944
160
        class MouseTestWidget(EmulatorBase):
137
        class MouseTestWidget(EmulatorBase):
945
161
            pass
138
            pass
946
162
139
947
163
        app = self.start_mock_app(EmulatorBase)
140
        app = self.start_mock_app(EmulatorBase)
948
164
        test_widget = app.select_single('MouseTestWidget')
141
        test_widget = app.select_single('MouseTestWidget')
949
165
142
951
166
        self.assertThat(type(test_widget), Equals(MouseTestWidget))
143
        self.assertThat(type(test_widget), Not(Equals(MouseTestWidget)))
952
144
        self.assertTrue(getattr(test_widget, '__generated'))
953
167
145
954
168
    def test_can_select_custom_emulators_by_type(self):
146
    def test_can_select_custom_emulators_by_type(self):
955
169
        """Must be able to select a custom emulator type by type."""
147
        """Must be able to select a custom emulator type by type."""
956
170
148
957
=== renamed file 'autopilot/tests/unit/test_introspection_object_registry.py' => 'autopilot/tests/unit/introspection_object_registry.py'
958
=== modified file 'autopilot/tests/unit/test_introspection.py'
959
--- autopilot/tests/unit/test_introspection.py	2014-07-31 04:42:08 +0000
960
+++ autopilot/tests/unit/test_introspection.py	2015-07-20 22:41:01 +0000
961
@@ -25,7 +25,10 @@
962
25
    IsInstance,
25
    IsInstance,
963
26
    raises,
26
    raises,
964
27
)
27
)
966
28
import autopilot.introspection._search as _s
28
from autopilot.introspection import (
967
29
    _proxy_objects as _po,
968
30
    _search as _s
969
31
)
970
29
from autopilot.introspection.qt import QtObjectProxyMixin
32
from autopilot.introspection.qt import QtObjectProxyMixin
971
30
import autopilot.introspection as _i
33
import autopilot.introspection as _i
972
31
34
973
@@ -35,21 +38,21 @@
974
35
    fake_state_data = (String('/some/path'), dict(foo=123))
38
    fake_state_data = (String('/some/path'), dict(foo=123))
975
36
39
976
37
    def test_returns_classname(self):
40
    def test_returns_classname(self):
978
38
        class_name, _, _ = _s._get_details_from_state_data(
41
        class_name, _, _ = _po._get_details_from_state_data(
979
39
            self.fake_state_data
42
            self.fake_state_data
980
40
        )
43
        )
981
41
        self.assertThat(class_name, Equals('path'))
44
        self.assertThat(class_name, Equals('path'))
982
42
45
983
43
    def test_returns_path(self):
46
    def test_returns_path(self):
985
44
        _, path, _ = _s._get_details_from_state_data(self.fake_state_data)
47
        _, path, _ = _po._get_details_from_state_data(self.fake_state_data)
986
45
        self.assertThat(path, Equals(b'/some/path'))
48
        self.assertThat(path, Equals(b'/some/path'))
987
46
49
988
47
    def test_returned_path_is_bytestring(self):
50
    def test_returned_path_is_bytestring(self):
990
48
        _, path, _ = _s._get_details_from_state_data(self.fake_state_data)
51
        _, path, _ = _po._get_details_from_state_data(self.fake_state_data)
991
49
        self.assertThat(path, IsInstance(type(b'')))
52
        self.assertThat(path, IsInstance(type(b'')))
992
50
53
993
51
    def test_returns_state_dict(self):
54
    def test_returns_state_dict(self):
995
52
        _, _, state = _s._get_details_from_state_data(self.fake_state_data)
55
        _, _, state = _po._get_details_from_state_data(self.fake_state_data)
996
53
        self.assertThat(state, Equals(dict(foo=123)))
56
        self.assertThat(state, Equals(dict(foo=123)))
997
54
57
998
55
58
999
@@ -119,13 +122,13 @@
1000
119
122
1001
120
    def test_raises_RuntimeError_when_no_interface_is_found(self):
123
    def test_raises_RuntimeError_when_no_interface_is_found(self):
1002
121
        self.assertThat(
124
        self.assertThat(
1004
122
            lambda: _s._get_proxy_bases_from_introspection_xml(""),
125
            lambda: _po._get_proxy_bases_from_introspection_xml(""),
1005
123
            raises(RuntimeError("Could not find Autopilot interface."))
126
            raises(RuntimeError("Could not find Autopilot interface."))
1006
124
        )
127
        )
1007
125
128
1008
126
    def test_returns_ApplicationProxyObject_claws_for_base_interface(self):
129
    def test_returns_ApplicationProxyObject_claws_for_base_interface(self):
1009
127
        self.assertThat(
130
        self.assertThat(
1011
128
            _s._get_proxy_bases_from_introspection_xml(
131
            _po._get_proxy_bases_from_introspection_xml(
1012
129
                self.fake_data_with_ap_interface
132
                self.fake_data_with_ap_interface
1013
130
            ),
133
            ),
1014
131
            Equals(())
134
            Equals(())
1015
@@ -133,7 +136,7 @@
1016
133
136
1017
134
    def test_returns_both_base_and_qt_interface(self):
137
    def test_returns_both_base_and_qt_interface(self):
1018
135
        self.assertThat(
138
        self.assertThat(
1020
136
            _s._get_proxy_bases_from_introspection_xml(
139
            _po._get_proxy_bases_from_introspection_xml(
1021
137
                self.fake_data_with_ap_and_qt_interfaces
140
                self.fake_data_with_ap_and_qt_interfaces
1022
138
            ),
141
            ),
1023
139
            Equals((QtObjectProxyMixin,))
142
            Equals((QtObjectProxyMixin,))
1024
140
143
1025
=== modified file 'autopilot/tests/unit/test_introspection_backends.py'
1026
--- autopilot/tests/unit/test_introspection_backends.py	2015-06-09 15:35:08 +0000
1027
+++ autopilot/tests/unit/test_introspection_backends.py	2015-07-20 22:41:01 +0000
1028
@@ -23,6 +23,7 @@
1029
23
from testtools.matchers import Equals, Not, NotEquals, IsInstance
23
from testtools.matchers import Equals, Not, NotEquals, IsInstance
1030
24
24
1031
25
from autopilot.introspection import (
25
from autopilot.introspection import (
1032
26
    _proxy_objects as _po,
1033
26
    _xpathselect as xpathselect,
27
    _xpathselect as xpathselect,
1034
27
    backends,
28
    backends,
1035
28
    dbus,
29
    dbus,
1036
@@ -325,21 +326,24 @@
1037
325
        """Verify that a class has a validation method by default."""
326
        """Verify that a class has a validation method by default."""
1038
326
        self.assertTrue(callable(self.DefaultSelector.validate_dbus_object))
327
        self.assertTrue(callable(self.DefaultSelector.validate_dbus_object))
1039
327
328
1041
328
    @patch.object(backends, '_get_proxy_object_class')
329
    @patch.object(_po, 'get_proxy_object_class')
1042
329
    def test_make_introspection_object(self, gpoc):
330
    def test_make_introspection_object(self, gpoc):
1043
330
        """Verify that make_introspection_object makes the right call."""
331
        """Verify that make_introspection_object makes the right call."""
1044
331
        gpoc.return_value = self.DefaultSelector
332
        gpoc.return_value = self.DefaultSelector
1046
332
        fake_id = Mock()
333
        fake_backend = Mock()
1047
334
        cpo_name = self.getUniqueString()
1048
335
        path = String('/Object')
1049
336
1050
333
        new_fake = backends.make_introspection_object(
337
        new_fake = backends.make_introspection_object(
1054
334
            (String('/Object'), {'id': [0, 42]}),
338
            (path, {'id': [0, 42]}),
1055
335
            None,
339
            fake_backend,
1056
336
            fake_id,
340
            cpo_name
1057
337
        )
341
        )
1058
338
        self.assertThat(new_fake, IsInstance(self.DefaultSelector))
342
        self.assertThat(new_fake, IsInstance(self.DefaultSelector))
1059
339
        gpoc.assert_called_once_with(
343
        gpoc.assert_called_once_with(
1063
340
            fake_id,
344
            cpo_name,
1064
341
            b'/Object',
345
            path.encode('utf-8'),
1065
342
            {'id': [0, 42]}
346
            fake_backend.ipc_address
1066
343
        )
347
        )
1067
344
348
1068
345
    def test_validate_dbus_object_matches_on_class_name(self):
349
    def test_validate_dbus_object_matches_on_class_name(self):
1069
346
350
1070
=== modified file 'autopilot/tests/unit/test_introspection_dbus.py'
1071
--- autopilot/tests/unit/test_introspection_dbus.py	2015-07-20 22:41:00 +0000
1072
+++ autopilot/tests/unit/test_introspection_dbus.py	2015-07-20 22:41:01 +0000
1073
@@ -29,50 +29,19 @@
1074
29
from testtools.matchers import (
29
from testtools.matchers import (
1075
30
    Equals,
30
    Equals,
1076
31
    Not,
31
    Not,
1077
32
    NotEquals,
1078
33
    Raises,
32
    Raises,
1079
34
    raises,
33
    raises,
1080
35
)
34
)
1081
36
35
1082
37
from autopilot.exceptions import StateNotFoundError
36
from autopilot.exceptions import StateNotFoundError
1085
38
from autopilot.introspection import CustomEmulatorBase
37
from autopilot.introspection import (
1086
39
from autopilot.introspection import dbus
38
    _proxy_objects as _po,
1087
39
    CustomEmulatorBase,
1088
40
    dbus
1089
41
)
1090
40
from autopilot.utilities import sleep
42
from autopilot.utilities import sleep
1091
41
43
1092
42
44
1093
43
class IntrospectionFeatureTests(TestCase):
1094
44
1095
45
    def test_custom_emulator_base_does_not_have_id(self):
1096
46
        self.assertThat(hasattr(CustomEmulatorBase, '_id'), Equals(False))
1097
47
1098
48
    def test_derived_emulator_bases_do_have_id(self):
1099
49
        class MyEmulatorBase(CustomEmulatorBase):
1100
50
            pass
1101
51
        self.assertThat(hasattr(MyEmulatorBase, '_id'), Equals(True))
1102
52
1103
53
    def test_derived_children_have_same_id(self):
1104
54
        class MyEmulatorBase(CustomEmulatorBase):
1105
55
            pass
1106
56
1107
57
        class MyEmulator(MyEmulatorBase):
1108
58
            pass
1109
59
1110
60
        class MyEmulator2(MyEmulatorBase):
1111
61
            pass
1112
62
1113
63
        self.assertThat(MyEmulatorBase._id, Equals(MyEmulator._id))
1114
64
        self.assertThat(MyEmulatorBase._id, Equals(MyEmulator2._id))
1115
65
1116
66
    def test_children_have_different_ids(self):
1117
67
        class MyEmulatorBase(CustomEmulatorBase):
1118
68
            pass
1119
69
1120
70
        class MyEmulatorBase2(CustomEmulatorBase):
1121
71
            pass
1122
72
1123
73
        self.assertThat(MyEmulatorBase._id, NotEquals(MyEmulatorBase2._id))
1124
74
1125
75
1126
76
class DBusIntrospectionObjectTests(TestCase):
45
class DBusIntrospectionObjectTests(TestCase):
1127
77
46
1128
78
    def test_can_access_path_attribute(self):
47
    def test_can_access_path_attribute(self):
1129
@@ -141,6 +110,27 @@
1130
141
        self.assertThat(TestCPO.get_type_query_name(), Equals("TestCPO"))
110
        self.assertThat(TestCPO.get_type_query_name(), Equals("TestCPO"))
1131
142
111
1132
143
112
1133
113
class ProxyObjectCreationTests(TestCase):
1134
114
    def test_default_class_mentioned_in_attr_error(self):
1135
115
        name = self.getUniqueString()
1136
116
        fake_class = _po._get_default_proxy_class(name, ())
1137
117
        fake_object = fake_class(
1138
118
            dict(id=[0, 123], path=[0, '/some/path']),
1139
119
            b'/root',
1140
120
            Mock()
1141
121
        )
1142
122
1143
123
        expected_msg = "Generated Class '{}' has no attribute 'foo'.".format(
1144
124
            name
1145
125
        )
1146
126
1147
127
        with fake_object.no_automatic_refreshing():
1148
128
            self.assertThat(
1149
129
                lambda: fake_object.foo(),
1150
130
                raises(AttributeError(expected_msg))
1151
131
            )
1152
132
1153
133
1154
144
class ProxyObjectPrintTreeTests(TestCase):
134
class ProxyObjectPrintTreeTests(TestCase):
1155
145
135
1156
146
    def _print_test_fake_object(self):
136
    def _print_test_fake_object(self):
1157
147
137
1158
=== modified file 'autopilot/tests/unit/test_introspection_search.py'
1159
--- autopilot/tests/unit/test_introspection_search.py	2015-05-06 10:00:49 +0000
1160
+++ autopilot/tests/unit/test_introspection_search.py	2015-07-20 22:41:01 +0000
1161
@@ -35,7 +35,6 @@
1162
35
from autopilot.utilities import sleep
35
from autopilot.utilities import sleep
1163
36
from autopilot.introspection import _search as _s
36
from autopilot.introspection import _search as _s
1164
37
37
1165
38
from autopilot.introspection import CustomEmulatorBase
1166
39
from autopilot.introspection.constants import AUTOPILOT_PATH
38
from autopilot.introspection.constants import AUTOPILOT_PATH
1167
40
39
1168
41
40
1169
@@ -732,95 +731,3 @@
1170
732
                _s._find_matching_connections(bus, lambda *args: True)
731
                _s._find_matching_connections(bus, lambda *args: True)
1171
733
732
1172
734
                dedupe.assert_called_once_with(["conn1"], bus)
733
                dedupe.assert_called_once_with(["conn1"], bus)
1173
735
1174
736
1175
737
class ActualBaseClassTests(TestCase):
1176
738
1177
739
    def test_dont_raise_passed_base_when_is_only_base(self):
1178
740
        class ActualBase(CustomEmulatorBase):
1179
741
            pass
1180
742
1181
743
        try:
1182
744
            _s._raise_if_base_class_not_actually_base(ActualBase)
1183
745
        except ValueError:
1184
746
            self.fail('Unexpected ValueError exception')
1185
747
1186
748
    def test_raises_if_passed_incorrect_base_class(self):
1187
749
        class ActualBase(CustomEmulatorBase):
1188
750
            pass
1189
751
1190
752
        class InheritedCPO(ActualBase):
1191
753
            pass
1192
754
1193
755
        self.assertRaises(
1194
756
            ValueError,
1195
757
            _s._raise_if_base_class_not_actually_base,
1196
758
            InheritedCPO
1197
759
        )
1198
760
1199
761
    def test_raises_parent_with_simple_non_ap_multi_inheritance(self):
1200
762
        """When mixing in non-customproxy classes must return the base."""
1201
763
1202
764
        class ActualBase(CustomEmulatorBase):
1203
765
            pass
1204
766
1205
767
        class InheritedCPO(ActualBase):
1206
768
            pass
1207
769
1208
770
        class TrickyOne(object):
1209
771
            pass
1210
772
1211
773
        class FinalForm(InheritedCPO, TrickyOne):
1212
774
            pass
1213
775
1214
776
        self.assertRaises(
1215
777
            ValueError,
1216
778
            _s._raise_if_base_class_not_actually_base,
1217
779
            FinalForm
1218
780
        )
1219
781
1220
782
    def test_raises_parent_with_non_ap_multi_inheritance(self):
1221
783
1222
784
        class ActualBase(CustomEmulatorBase):
1223
785
            pass
1224
786
1225
787
        class InheritedCPO(ActualBase):
1226
788
            pass
1227
789
1228
790
        class TrickyOne(object):
1229
791
            pass
1230
792
1231
793
        class FinalForm(TrickyOne, InheritedCPO):
1232
794
            pass
1233
795
1234
796
        self.assertRaises(
1235
797
            ValueError,
1236
798
            _s._raise_if_base_class_not_actually_base,
1237
799
            FinalForm
1238
800
        )
1239
801
1240
802
    def test_dont_raise_when_using_default_emulator_base(self):
1241
803
        # _make_proxy_object potentially creates a default base.
1242
804
        DefaultBase = _s._make_default_emulator_base()
1243
805
        try:
1244
806
            _s._raise_if_base_class_not_actually_base(DefaultBase)
1245
807
        except ValueError:
1246
808
            self.fail('Unexpected ValueError exception')
1247
809
1248
810
    def test_exception_message_contains_useful_information(self):
1249
811
        class ActualBase(CustomEmulatorBase):
1250
812
            pass
1251
813
1252
814
        class InheritedCPO(ActualBase):
1253
815
            pass
1254
816
1255
817
        try:
1256
818
            _s._raise_if_base_class_not_actually_base(InheritedCPO)
1257
819
        except ValueError as err:
1258
820
            self.assertEqual(
1259
821
                str(err),
1260
822
                _s.WRONG_CPO_CLASS_MSG.format(
1261
823
                    passed=InheritedCPO,
1262
824
                    actual=ActualBase
1263
825
                )
1264
826
            )
1265
827
734
1266
=== added file 'autopilot/tests/unit/test_proxy_object.py'
1267
--- autopilot/tests/unit/test_proxy_object.py	1970-01-01 00:00:00 +0000
1268
+++ autopilot/tests/unit/test_proxy_object.py	2015-07-20 22:41:01 +0000
1269
@@ -0,0 +1,81 @@
1270
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
1271
2
#
1272
3
# Autopilot Functional Test Tool
1273
4
# Copyright (C) 2015 Canonical
1274
5
#
1275
6
# This program is free software: you can redistribute it and/or modify
1276
7
# it under the terms of the GNU General Public License as published by
1277
8
# the Free Software Foundation, either version 3 of the License, or
1278
9
# (at your option) any later version.
1279
10
#
1280
11
# This program is distributed in the hope that it will be useful,
1281
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1282
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1283
14
# GNU General Public License for more details.
1284
15
#
1285
16
# You should have received a copy of the GNU General Public License
1286
17
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1287
18
#
1288
19
1289
20
from unittest.mock import (
1290
21
    Mock,
1291
22
    patch
1292
23
)
1293
24
from testtools import TestCase
1294
25
1295
26
from autopilot.introspection import _proxy_objects as _po
1296
27
1297
28
1298
29
class IsCpoClassTests(TestCase):
1299
30
1300
31
    def test_returns_False_when_None(self):
1301
32
        self.assertFalse(_po._is_cpo_class(None))
1302
33
1303
34
    def test_returns_False_when_is_string(self):
1304
35
        self.assertFalse(_po._is_cpo_class('foo'))
1305
36
1306
37
    def test_returns_True_when_is_class(self):
1307
38
        class Foo():
1308
39
            pass
1309
40
        self.assertTrue(_po._is_cpo_class(Foo))
1310
41
1311
42
1312
43
class GetApplicableClassNameTests(TestCase):
1313
44
1314
45
    @patch.object(_po, 'get_classname_from_path')
1315
46
    def test_queries_path_when_name_unknown(self, p_gcfp):
1316
47
        path = self.getUniqueString()
1317
48
        _po._get_applicable_class_name(None, path)
1318
49
        p_gcfp.assert_called_once_with(path)
1319
50
1320
51
    @patch.object(_po, 'get_classname_from_path')
1321
52
    def test_returns_path_name_when_passed_None(self, p_gcfp):
1322
53
        name = self.getUniqueString()
1323
54
        p_gcfp.return_value = bytes(name, 'utf-8')
1324
55
1325
56
        self.assertEqual(name, _po._get_applicable_class_name(None, ''))
1326
57
1327
58
    @patch.object(_po, 'get_classname_from_path')
1328
59
    def test_returns_dbus_name_when_passed_star(self, p_gcfp):
1329
60
        name = self.getUniqueString()
1330
61
        path = ''
1331
62
        p_gcfp.return_value = bytes(name, 'utf-8')
1332
63
1333
64
        self.assertEqual(
1334
65
            name,
1335
66
            _po._get_applicable_class_name('*', path)
1336
67
        )
1337
68
1338
69
    def test_returns_string_from_classname(self):
1339
70
        name = self.getUniqueString()
1340
71
        fake_dbus_backend = Mock()
1341
72
        with patch.object(_po, 'get_classname_from_path') as from_path:
1342
73
            from_path.return_value = bytes(name, 'utf-8')
1343
74
            self.assertEqual(
1344
75
                _po._get_applicable_class_name('*', fake_dbus_backend),
1345
76
                name
1346
77
            )
1347
78
1348
79
    def test_returns_name_of_string(self):
1349
80
        name = self.getUniqueString()
1350
81
        self.assertEqual(name, _po._get_applicable_class_name(name, None))
Reviewer	Review Type	Date Requested	Status
platform-qa-bot	continuous-integration		Approve on 2016-01-19
PS Jenkins bot	continuous-integration		Approve on 2015-07-20
Max Brustkern (community)		2015-06-16	Approve on 2015-07-07
Review via email: mp+262048@code.launchpad.net