def _compare(self, type_hint, expected_string):
"""Compare generated and expected types."""
# Generate a type string.
dbus_type = get_dbus_type(type_hint)
self.assertEqual(dbus_type, expected_string)
self.assertTrue(GLib.VariantType.string_is_valid(dbus_type))
# Create a variant type from a type hint.
variant_type = get_variant_type(type_hint)
self.assertIsInstance(variant_type, GLib.VariantType)
self.assertEqual(variant_type.dup_string(), expected_string)
expected_type = GLib.VariantType.new(expected_string)
self.assertTrue(expected_type.equal(variant_type))
# Create a variant type from a type string.
variant_type = get_variant_type(expected_string)
self.assertIsInstance(variant_type, GLib.VariantType)
self.assertTrue(expected_type.equal(variant_type))
# Test the is_tuple_of_one function.
expected_value = is_base_type(type_hint, Tuple) \
and len(get_type_arguments(type_hint)) == 1
self.assertEqual(is_tuple_of_one(type_hint), expected_value)
self.assertEqual(is_tuple_of_one(expected_string), expected_value)
self.assertTrue(is_tuple_of_one(Tuple[type_hint]))
self.assertTrue(is_tuple_of_one("({})".format(expected_string)))
def test_variant_type_factory(self):
"""Test the variant type factory."""
self.assertEqual(str(get_variant_type("s")), "s")
self.assertEqual(repr(get_variant_type("i")), "i")
self.assertEqual(get_variant_type("s"), get_variant_type("s"))
self.assertEqual(get_variant_type("i"), get_variant_type("i"))
self.assertNotEqual(get_variant_type("b"), get_variant_type("i"))
self.assertNotEqual(get_variant_type("s"), get_variant_type("u"))
def test_introspect(self):
"""Test the introspection."""
self._set_reply(get_variant("(s)", (dedent("""
<node>
<interface name="Interface">
<method name="Method1"/>
</interface>
</node>
"""), )))
self.handler = ClientObjectHandler(
self.message_bus,
self.service_name,
self.object_path
)
self.assertIsNotNone(self.handler.specification)
self._check_call(
"org.freedesktop.DBus.Introspectable",
"Introspect",
reply_type=get_variant_type("(s)")
)
self.assertIn(
DBusSpecification.Method("Method1", "Interface", None, None),
self.handler.specification.members
)
def _check_get_property(self, name):
"""Check the DBus call that gets a property."""
self._check_call(
"org.freedesktop.DBus.Properties",
"Get",
get_variant("(ss)", ("Interface", name)),
get_variant_type("(v)")
)
def _compare(self, type_hint, expected_string):
"""Compare generated and expected types."""
# Generate a type string.
dbus_type = get_dbus_type(type_hint)
self.assertEqual(dbus_type, expected_string)
self.assertTrue(GLib.VariantType.string_is_valid(dbus_type))
# Create a variant type from a type hint.
variant_type = get_variant_type(type_hint)
self.assertIsInstance(variant_type, GLib.VariantType)
self.assertEqual(variant_type.dup_string(), expected_string)
expected_type = GLib.VariantType.new(expected_string)
self.assertTrue(expected_type.equal(variant_type))
# Create a variant type from a type string.
variant_type = get_variant_type(expected_string)
self.assertIsInstance(variant_type, GLib.VariantType)
self.assertTrue(expected_type.equal(variant_type))
def _call_method(self, interface_name, method_name, in_type,
out_type, *parameters, **kwargs):
"""Call a DBus method.
:return: a result of the call or None
"""
# Create variants.
if not parameters:
parameters = None
if in_type is not None:
parameters = get_variant(in_type, parameters)
# Create variant types.
reply_type = None
if out_type is not None:
reply_type = get_variant_type(out_type)
# Collect arguments.
args = (
self._message_bus.connection,
self._service_name,
self._object_path,
interface_name,
method_name,
parameters,
reply_type,
)
# Get the callback.
callback = kwargs.pop("callback", None)
callback_args = kwargs.pop("callback_args", tuple())
# Choose the type of invocation.
if not callback:
return self._get_method_reply(
self._client.sync_call,
*args,
**kwargs,
)
else:
return self._client.async_call(
*args,
**kwargs,
callback=self._method_callback,
callback_args=(callback, callback_args)
)
def test_async_method(self):
"""Test asynchronous calls of a method proxy."""
self._create_proxy("""
<node>
<interface name="Interface">
<method name="Method1"/>
<method name="Method2">
<arg direction="in" name="x" type="i"/>
<arg direction="in" name="y" type="i"/>
<arg direction="out" name="return" type="i"/>
</method>
</interface>
</node>
""")
callback = Mock()
callback_args = ("A", "B")
self.proxy.Method1(callback=callback, callback_args=callback_args)
self._check_async_call(
"Interface",
"Method1",
callback,
callback_args
)
self._finish_async_call(self.NO_REPLY, callback, callback_args)
callback.assert_called_once_with(None, "A", "B")
callback = Mock()
callback_args = ("A", "B")
self.proxy.Method2(
1, 2, callback=callback, callback_args=callback_args
)
self._check_async_call(
"Interface",
"Method2",
callback,
callback_args,
get_variant("(ii)", (1, 2)),
get_variant_type("(i)")
)
self._finish_async_call(
get_variant("(i)", (3, )),
callback,
callback_args
)
callback.assert_called_once_with(3, "A", "B")
self.error_mapper.add_rule(ErrorRule(
exception_type=FakeException,
error_name="org.test.Unknown"
))
callback = Mock()
callback_args = ("A", "B")
error = Gio.DBusError.new_for_dbus_error(
"org.test.Unknown",
"My message."
)
with self.assertRaises(FakeException) as cm:
self._finish_async_call(error, callback, callback_args)
self.assertEqual(str(cm.exception), "My message.")
callback.assert_not_called()
def test_method(self):
"""Test the method proxy."""
self._create_proxy("""
<node>
<interface name="Interface">
<method name="Method1"/>
<method name="Method2">
<arg direction="in" name="x" type="i"/>
</method>
<method name="Method3">
<arg direction="out" name="return" type="i"/>
</method>
<method name="Method4">
<arg direction="in" name="x" type="ad"/>
<arg direction="in" name="y" type="o"/>
<arg direction="out" name="return" type="(ib)"/>
</method>
<method name="Method5">
<arg direction="out" name="return_x" type="i"/>
<arg direction="out" name="return_y" type="i"/>
</method>
</interface>
</node>
""")
self.assertTrue(callable(self.proxy.Method1))
self.assertEqual(self.proxy.Method1, self.proxy.Method1)
self._set_reply(self.NO_REPLY)
self.assertEqual(self.proxy.Method1(), None)
self._check_call(
"Interface",
"Method1"
)
self._set_reply(self.NO_REPLY)
self.assertEqual(self.proxy.Method2(1), None)
self._check_call(
"Interface",
"Method2",
parameters=get_variant("(i)", (1, ))
)
self._set_reply(get_variant("(i)", (0, )))
self.assertEqual(self.proxy.Method3(), 0)
self._check_call(
"Interface",
"Method3",
reply_type=get_variant_type("(i)")
)
self._set_reply(get_variant("((ib))", ((1, True), )))
self.assertEqual(self.proxy.Method4([1.2, 2.3], "/my/path"),
(1, True))
self._check_call(
"Interface",
"Method4",
parameters=get_variant("(ado)", ([1.2, 2.3], "/my/path")),
reply_type=get_variant_type("((ib))")
)
self._set_reply(get_variant("(ii)", (1, 2)))
self.assertEqual(self.proxy.Method5(), (1, 2))
self._check_call(
"Interface",
"Method5",
reply_type=get_variant_type("(ii)")
)
# Handle unregistered remote exception.
self._set_reply(Gio.DBusError.new_for_dbus_error(
"org.test.Unknown",
"My message."
))
with self.assertRaises(DBusError) as cm:
self.proxy.Method1()
self.assertTrue("My message." in str(cm.exception))
# Handle registered remote exception.
self.error_mapper.add_rule(ErrorRule(
exception_type=FakeException,
error_name="org.test.Unknown"
))
self._set_reply(Gio.DBusError.new_for_dbus_error(
"org.test.Unknown",
"My message."
))
with self.assertRaises(FakeException) as cm:
self.proxy.Method1()
self.assertEqual(str(cm.exception), "My message.")
# Handle local exception.
self._set_reply(Exception("My message."))
with self.assertRaises(Exception) as cm:
self.proxy.Method1()
self.assertEqual(str(cm.exception), "My message.")
# Test invalid method.
with self.assertRaises(AttributeError) as cm:
self.proxy.MethodInvalid()
self.assertEqual(
"DBus object has no attribute 'MethodInvalid'.",
str(cm.exception)
)
# Test invalid attribute.
with self.assertRaises(AttributeError) as cm:
self.proxy.Method1 = lambda: 1
self.assertEqual(
"Can't set DBus attribute 'Method1'.",
str(cm.exception)
)
