def setUp(self):
self.bus = Gio.TestDBus()
self.bus.up()
self.message_bus = AddressedMessageBus(self.bus.get_bus_address())
self.service = None
self.clients = []
def setUp(self):
self.bus = Gio.TestDBus()
self.bus.up()
self.message_bus = AddressedMessageBus(
self.bus.get_bus_address(),
error_mapper=error_mapper
)
self.service = None
self.clients = []
self.maxDiff = None
class DBusTestCase(unittest.TestCase):
"""Test DBus support with a real DBus connection."""
TIMEOUT = 3
def setUp(self):
self.bus = Gio.TestDBus()
self.bus.up()
self.message_bus = AddressedMessageBus(
self.bus.get_bus_address(),
error_mapper=error_mapper
)
self.service = None
self.clients = []
self.maxDiff = None
def tearDown(self):
self.message_bus.disconnect()
self.bus.down()
def test_message_bus(self):
"""Test the message bus."""
self.assertTrue(self.message_bus.check_connection())
self.assertEqual(self.message_bus.address, self.bus.get_bus_address())
self.assertEqual(self.message_bus.proxy.Ping(), None)
def _set_service(self, service):
self.service = service
def test_xml_specification(self):
"""Test the generated specification."""
self._set_service(ExampleInterface())
expected_xml = '''
<node>
<!--Specifies ExampleInterface-->
<interface name="my.testing.Example">
<method name="GetInfo">
<arg direction="in" name="arg" type="s"></arg>
<arg direction="out" name="return" type="s"></arg>
</method>
<method name="Hello">
<arg direction="in" name="name" type="s"></arg>
<arg direction="out" name="return" type="s"></arg>
</method>
<method name="Knock"></method>
<signal name="Knocked"></signal>
<property access="read" name="Name" type="s"></property>
<method name="Raise">
<arg direction="in" name="message" type="s"></arg>
</method>
<method name="ReturnArgs">
<arg direction="out" name="return_0" type="i"></arg>
<arg direction="out" name="return_1" type="b"></arg>
<arg direction="out" name="return_2" type="s"></arg>
</method>
<property access="write" name="Secret" type="s"></property>
<property access="readwrite" name="Value" type="i"></property>
<signal name="Visited">
<arg direction="out" name="name" type="s"></arg>
</signal>
</interface>
</node>
'''
generated_xml = self.service.__dbus_xml__
self.assertEqual(
XMLGenerator.prettify_xml(expected_xml),
XMLGenerator.prettify_xml(generated_xml)
)
def _add_client(self, client_test):
thread = Thread(None, client_test)
thread.daemon = True
self.clients.append(thread)
def _get_proxy(self, interface_name=None):
return self.message_bus.get_proxy(
"my.testing.Example",
"/my/testing/Example",
interface_name=interface_name
)
def _run_test(self):
self.message_bus.publish_object(
"/my/testing/Example",
self.service
)
self.message_bus.register_service(
"my.testing.Example"
)
for client in self.clients:
client.start()
self.assertTrue(self._run_service())
for client in self.clients:
client.join()
@run_in_glib(TIMEOUT)
def _run_service(self):
return True
def test_knock(self):
"""Call a simple DBus method."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._knocked, False)
def test():
proxy = self._get_proxy()
self.assertEqual(None, proxy.Knock())
self._add_client(test)
self._run_test()
self.assertEqual(self.service._knocked, True)
def test_hello(self):
"""Call a DBus method."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._names, [])
def test1():
proxy = self._get_proxy()
self.assertEqual("Hello, Foo!", proxy.Hello("Foo"))
def test2():
proxy = self._get_proxy()
self.assertEqual("Hello, Bar!", proxy.Hello("Bar"))
self._add_client(test1)
self._add_client(test2)
self._run_test()
self.assertEqual(sorted(self.service._names), ["Bar", "Foo"])
def test_name(self):
"""Use a DBus read-only property."""
self._set_service(ExampleInterface())
def test1():
proxy = self._get_proxy()
self.assertEqual("My example", proxy.Name)
def test2():
proxy = self._get_proxy()
self.assertEqual("My example", proxy.Name)
def test3():
proxy = self._get_proxy()
with self.assertRaises(AttributeError) as cm:
proxy.Name = "Another example"
self.assertEqual(
"Can't set DBus property.",
str(cm.exception)
)
self.assertEqual("My example", proxy.Name)
self._add_client(test1)
self._add_client(test2)
self._add_client(test3)
self._run_test()
def test_secret(self):
"""Use a DBus write-only property."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._secrets, [])
def test1():
proxy = self._get_proxy()
proxy.Secret = "Secret 1"
def test2():
proxy = self._get_proxy()
proxy.Secret = "Secret 2"
def test3():
proxy = self._get_proxy()
with self.assertRaises(AttributeError) as cm:
self.fail(proxy.Secret)
self.assertEqual(
"Can't read DBus property.",
str(cm.exception)
)
self._add_client(test1)
self._add_client(test2)
self._add_client(test3)
self._run_test()
self.assertEqual(sorted(self.service._secrets), [
"Secret 1",
"Secret 2"
])
def test_value(self):
"""Use a DBus read-write property."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._values, [0])
def test1():
proxy = self._get_proxy()
self.assertIn(proxy.Value, (0, 3, 4))
proxy.Value = 1
self.assertIn(proxy.Value, (1, 3, 4))
proxy.Value = 2
self.assertIn(proxy.Value, (2, 3, 4))
def test2():
proxy = self._get_proxy()
self.assertIn(proxy.Value, (0, 1, 2))
proxy.Value = 3
self.assertIn(proxy.Value, (3, 1, 2))
proxy.Value = 4
self.assertIn(proxy.Value, (4, 1, 2))
self._add_client(test1)
self._add_client(test2)
self._run_test()
self.assertEqual(sorted(self.service._values), [0, 1, 2, 3, 4])
self.assertEqual(self.service._values[0], 0)
self.assertLess(self.service._values.index(1),
self.service._values.index(2))
self.assertLess(self.service._values.index(3),
self.service._values.index(4))
def test_knocked(self):
"""Use a simple DBus signal."""
self._set_service(ExampleInterface())
event = Event()
knocked = Mock()
def callback():
knocked("Knocked!")
def test_1():
proxy = self._get_proxy()
proxy.Knocked.connect(callback)
event.set()
def test_2():
event.wait()
proxy = self._get_proxy()
proxy.Knock()
proxy.Knock()
proxy.Knock()
self._add_client(test_1)
self._add_client(test_2)
self._run_test()
knocked.assert_has_calls([
mock.call("Knocked!"),
mock.call("Knocked!"),
mock.call("Knocked!")
])
def test_visited(self):
"""Use a DBus signal."""
self._set_service(ExampleInterface())
event = Event()
visited = Mock()
def callback(name):
visited("Visited by {}.".format(name))
def test1():
proxy = self._get_proxy()
proxy.Visited.connect(callback)
event.set()
def test2():
event.wait()
proxy = self._get_proxy()
proxy.Hello("Foo")
proxy.Hello("Bar")
self._add_client(test1)
self._add_client(test2)
self._run_test()
visited.assert_has_calls([
mock.call("Visited by Foo."),
mock.call("Visited by Bar.")
])
def test_unsubscribed(self):
"""Use an unsubscribed DBus signal."""
self._set_service(ExampleInterface())
event = Event()
knocked = Mock()
def callback():
knocked("Knocked!")
def test_1():
proxy = self._get_proxy()
proxy.Knocked.connect(callback)
disconnect_proxy(proxy)
event.set()
def test_2():
event.wait()
proxy = self._get_proxy()
proxy.Knock()
proxy.Knock()
proxy.Knock()
self._add_client(test_1)
self._add_client(test_2)
self._run_test()
knocked.assert_not_called()
def test_asynchronous(self):
"""Call a DBus method asynchronously."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._names, [])
returned = Mock()
def callback(call, number):
returned(number, call())
def test():
proxy = self._get_proxy()
proxy.Hello("Foo", callback=callback, callback_args=(1, ))
proxy.Hello("Foo", callback=callback, callback_args=(2, ))
proxy.Hello("Bar", callback=callback, callback_args=(3, ))
self._add_client(test)
self._run_test()
returned.assert_has_calls([
mock.call(1, "Hello, Foo!"),
mock.call(2, "Hello, Foo!"),
mock.call(3, "Hello, Bar!"),
])
def test_error(self):
"""Handle a DBus error."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._names, [])
raised = Mock()
def callback(call, number):
try:
call()
except ExampleException as e:
raised(number, str(e))
def test1():
proxy = self._get_proxy()
proxy.Raise("Foo failed!", callback=callback, callback_args=(1, ))
proxy.Raise("Foo failed!", callback=callback, callback_args=(2, ))
proxy.Raise("Bar failed!", callback=callback, callback_args=(3, ))
def test2():
proxy = self._get_proxy()
try:
proxy.Raise("My message")
except ExampleException as e:
self.assertEqual(str(e), "My message")
else:
self.fail("Exception wasn't raised!")
self._add_client(test1)
self._add_client(test2)
with self.assertLogs(level='WARN'):
self._run_test()
raised.assert_has_calls([
mock.call(1, "Foo failed!"),
mock.call(2, "Foo failed!"),
mock.call(3, "Bar failed!"),
])
def test_properties_changed(self):
"""Test the PropertiesChanged signal."""
self._set_service(ExampleInterface())
event = Event()
callback = Mock()
def test_1():
proxy = self._get_proxy()
proxy.PropertiesChanged.connect(callback)
event.set()
def test_2():
event.wait()
proxy = self._get_proxy()
proxy.Value = 10
self._add_client(test_1)
self._add_client(test_2)
self._run_test()
callback.assert_called_once_with(
"my.testing.Example",
{"Value": get_variant(Int, 10)},
["Name"]
)
def test_interface(self):
"""Use a specific DBus interface."""
self._set_service(ExampleInterface())
def test_1():
proxy = self._get_proxy(interface_name="my.testing.Example")
proxy.Knock()
with self.assertRaises(AttributeError):
proxy.Ping()
def test_2():
proxy = self._get_proxy(interface_name="org.freedesktop.DBus.Peer")
proxy.Ping()
with self.assertRaises(AttributeError):
proxy.Knock()
self._add_client(test_1)
self._add_client(test_2)
self._run_test()
def test_additional_arguments(self):
"""Call a DBus method."""
self._set_service(ExampleInterface())
def test1():
proxy = self._get_proxy()
self.assertEqual(
proxy.GetInfo("Foo"),
"Foo: {'sender': ':1.0'}"
)
def test2():
proxy = self._get_proxy()
self.assertEqual(
proxy.GetInfo("Bar"),
"Bar: {'sender': ':1.0'}"
)
self._add_client(test1)
self._add_client(test2)
self._run_test()
def test_multiple_output_arguments(self):
"""Call a DBus method with multiple output arguments."""
self._set_service(ExampleInterface())
def test1():
proxy = self._get_proxy()
self.assertEqual(
proxy.ReturnArgs(),
(0, False, "zero")
)
self._add_client(test1)
self._run_test()
for line in input_file:
# change path to the startup script to point to local copy
output_file.write(line.replace(EXEC_PATH, modified_exec_path))
test_dbus = Gio.TestDBus()
# set service folder
test_dbus.add_service_dir(temp_service_dir.name)
try:
# start the custom DBus daemon
print("starting custom dbus session")
test_dbus.up()
# our custom bus is now running, connect to it
test_dbus_connection = AddressedMessageBus(test_dbus.get_bus_address())
enter_word = GREEN + "enter" + RESET
q_word = GREEN + "q" + RESET
print("")
print(
"###########################################################################"
)
print("Connect to the bus address below [press a key to continue]:")
print("(guid part may be ignored)")
print(GREEN + test_dbus_connection.address + RESET)
if args.kickstart:
print()
print("Kickstart file {} will be distributed to modules.".format(
args.kickstart))
print()
def test_addressed_bus(self, getter):
"""Test the addressed bus."""
message_bus = AddressedMessageBus("ADDRESS")
self._check_addressed_connection(message_bus, getter, "ADDRESS")
class DBusTestCase(unittest.TestCase):
"""Test DBus support with a real DBus connection."""
TIMEOUT = 3
def setUp(self):
self.bus = Gio.TestDBus()
self.bus.up()
self.message_bus = AddressedMessageBus(self.bus.get_bus_address())
self.service = None
self.clients = []
def tearDown(self):
self.message_bus.disconnect()
self.bus.down()
def test_message_bus(self):
"""Test the message bus."""
self.assertTrue(self.message_bus.check_connection())
self.assertEqual(self.message_bus.address, self.bus.get_bus_address())
self.assertEqual(self.message_bus.proxy.Ping(), None)
def _set_service(self, service):
self.service = service
def _add_client(self, client_test):
thread = Thread(None, client_test)
thread.daemon = True
self.clients.append(thread)
def _get_proxy(self):
return self.message_bus.get_proxy("my.testing.Example",
"/my/testing/Example")
def _run_test(self):
self.message_bus.publish_object("/my/testing/Example", self.service)
self.message_bus.register_service("my.testing.Example")
for client in self.clients:
client.start()
self.assertTrue(self._run_service())
for client in self.clients:
client.join()
@run_in_glib(TIMEOUT)
def _run_service(self):
return True
def test_knock(self):
"""Call a simple DBus method."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._knocked, False)
def test():
proxy = self._get_proxy()
self.assertEqual(None, proxy.Knock())
self._add_client(test)
self._run_test()
self.assertEqual(self.service._knocked, True)
def test_hello(self):
"""Call a DBus method."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._names, [])
def test1():
proxy = self._get_proxy()
self.assertEqual("Hello, Foo!", proxy.Hello("Foo"))
def test2():
proxy = self._get_proxy()
self.assertEqual("Hello, Bar!", proxy.Hello("Bar"))
self._add_client(test1)
self._add_client(test2)
self._run_test()
self.assertEqual(sorted(self.service._names), ["Bar", "Foo"])
def test_name(self):
"""Use a DBus read-only property."""
self._set_service(ExampleInterface())
def test1():
proxy = self._get_proxy()
self.assertEqual("My example", proxy.Name)
def test2():
proxy = self._get_proxy()
self.assertEqual("My example", proxy.Name)
def test3():
proxy = self._get_proxy()
with self.assertRaises(AttributeError):
proxy.Name = "Another example"
self.assertEqual("My example", proxy.Name)
self._add_client(test1)
self._add_client(test2)
self._add_client(test3)
self._run_test()
def test_secret(self):
"""Use a DBus write-only property."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._secrets, [])
def test1():
proxy = self._get_proxy()
proxy.Secret = "Secret 1"
def test2():
proxy = self._get_proxy()
proxy.Secret = "Secret 2"
def test3():
proxy = self._get_proxy()
with self.assertRaises(AttributeError):
self.fail(proxy.Secret)
self._add_client(test1)
self._add_client(test2)
self._add_client(test3)
self._run_test()
self.assertEqual(sorted(self.service._secrets),
["Secret 1", "Secret 2"])
def test_value(self):
"""Use a DBus read-write property."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._values, [0])
def test1():
proxy = self._get_proxy()
self.assertIn(proxy.Value, (0, 3, 4))
proxy.Value = 1
self.assertIn(proxy.Value, (1, 3, 4))
proxy.Value = 2
self.assertIn(proxy.Value, (2, 3, 4))
def test2():
proxy = self._get_proxy()
self.assertIn(proxy.Value, (0, 1, 2))
proxy.Value = 3
self.assertIn(proxy.Value, (3, 1, 2))
proxy.Value = 4
self.assertIn(proxy.Value, (4, 1, 2))
self._add_client(test1)
self._add_client(test2)
self._run_test()
self.assertEqual(sorted(self.service._values), [0, 1, 2, 3, 4])
self.assertEqual(self.service._values[0], 0)
self.assertLess(self.service._values.index(1),
self.service._values.index(2))
self.assertLess(self.service._values.index(3),
self.service._values.index(4))
def test_knocked(self):
"""Use a simple DBus signal."""
self._set_service(ExampleInterface())
event = Event()
knocked = Mock()
def callback():
knocked("Knocked!")
def test_1():
proxy = self._get_proxy()
proxy.Knocked.connect(callback)
event.set()
def test_2():
event.wait()
proxy = self._get_proxy()
proxy.Knock()
proxy.Knock()
proxy.Knock()
self._add_client(test_1)
self._add_client(test_2)
self._run_test()
knocked.assert_has_calls([
mock.call("Knocked!"),
mock.call("Knocked!"),
mock.call("Knocked!")
])
def test_visited(self):
"""Use a DBus signal."""
self._set_service(ExampleInterface())
event = Event()
visited = Mock()
def callback(name):
visited("Visited by {}.".format(name))
def test1():
proxy = self._get_proxy()
proxy.Visited.connect(callback)
event.set()
def test2():
event.wait()
proxy = self._get_proxy()
proxy.Hello("Foo")
proxy.Hello("Bar")
self._add_client(test1)
self._add_client(test2)
self._run_test()
visited.assert_has_calls(
[mock.call("Visited by Foo."),
mock.call("Visited by Bar.")])
def test_unsubscribed(self):
"""Use an unsubscribed DBus signal."""
self._set_service(ExampleInterface())
event = Event()
knocked = Mock()
def callback():
knocked("Knocked!")
def test_1():
proxy = self._get_proxy()
proxy.Knocked.connect(callback)
disconnect_proxy(proxy)
event.set()
def test_2():
event.wait()
proxy = self._get_proxy()
proxy.Knock()
proxy.Knock()
proxy.Knock()
self._add_client(test_1)
self._add_client(test_2)
self._run_test()
knocked.assert_not_called()
def test_asynchronous(self):
"""Call a DBus method asynchronously."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._names, [])
returned = Mock()
def callback(call, number):
returned(number, call())
def test():
proxy = self._get_proxy()
proxy.Hello("Foo", callback=callback, callback_args=(1, ))
proxy.Hello("Foo", callback=callback, callback_args=(2, ))
proxy.Hello("Bar", callback=callback, callback_args=(3, ))
self._add_client(test)
self._run_test()
returned.assert_has_calls([
mock.call(1, "Hello, Foo!"),
mock.call(2, "Hello, Foo!"),
mock.call(3, "Hello, Bar!"),
])
def test_error(self):
"""Handle a DBus error."""
self._set_service(ExampleInterface())
self.assertEqual(self.service._names, [])
raised = Mock()
def callback(call, number):
try:
call()
except ExampleException as e:
raised(number, str(e))
def test1():
proxy = self._get_proxy()
proxy.Raise("Foo failed!", callback=callback, callback_args=(1, ))
proxy.Raise("Foo failed!", callback=callback, callback_args=(2, ))
proxy.Raise("Bar failed!", callback=callback, callback_args=(3, ))
def test2():
proxy = self._get_proxy()
try:
proxy.Raise("My message")
except ExampleException as e:
self.assertEqual(str(e), "My message")
else:
self.fail("Exception wasn't raised!")
self._add_client(test1)
self._add_client(test2)
with self.assertLogs(level='WARN'):
self._run_test()
raised.assert_has_calls([
mock.call(1, "Foo failed!"),
mock.call(2, "Foo failed!"),
mock.call(3, "Bar failed!"),
])
def test_properties_changed(self):
self._set_service(ExampleInterface())
event = Event()
callback = Mock()
def test_1():
proxy = self._get_proxy()
proxy.PropertiesChanged.connect(callback)
event.set()
def test_2():
event.wait()
proxy = self._get_proxy()
proxy.Value = 10
self._add_client(test_1)
self._add_client(test_2)
self._run_test()
callback.assert_called_once_with("my.testing.Example",
{"Value": get_variant(Int, 10)},
["Name"])