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) )