The main aim should be that its easy to write a linear test script<\/p>\n
Allowing to interact with other automated frameworks like dogtail is also a plus<\/p>\n
This little tutorial will introduce you to the concets and API of the dbus testing framework without
\n\tentering too much in the gory details<\/p>\n
The framework is based on two things, the Test case<\/em> and the proxy<\/em> objects.<\/p>\n Each test case you want to make is a method of a class. More precisely it’s the You can also pass a list of test cases to the You can run in the console:<\/p>\n The framework comes with 3 types of pre-made TestCase subclasses each filling a specific testing need.<\/p>\n So we can combine the two points seen above, and say that test cases must be subclasses of Let’s see more in detail the API of each possible working mode…<\/p>\n Client-side scripting takes you in the pants of a client and allows you to make calls on given dbus objects, and First thing to do is to tell the framework where he can find the actual remote dbus object, by giving the First simple example, creates under nickname “nick” the given remote objet proxy.<\/p>\n If the remote object implements more than one interface, you must use a second definition format. This one Now that we have a nickname to refer to our remote object we can access its methods and signal with the python dict mapping<\/p>\n On each method or signal proxy object returned by the dictionnary, we can do several actions. If the proxy is a method:<\/p>\n Call the method and block until the method returns. Returns the method return value. You can use the timeout=secs keyword If the proxy is a signal:<\/p>\n Start listening to the signal (resets previous signal values)<\/p>\n<\/li>\n Block until the signal has been received n times. Wait at most timeout seconds. The return value is the signal parameters, or a list Service-side scripting takes you in the pants of a service and allows you to ensure the right calls sequences First thing to do is to tell the framework what service he needs to export, by giving the To acheive this you first need to define a class, subclassing MockService, in which you declare the exported methods and signals, As you can see, each method is declared and a default implementation is provided. Also note that the Now we can create the service proxy object with a nickname as for the client-side scripting:<\/p>\n We pass as first argument the class of the exported object, the service name and object path<\/p>\n Now that we have a nickname to refer to our service we can access its methods and signal with the python dict mapping<\/p>\n On each method or signal proxy object returned by the dictionnary, we can do several actions. If the proxy is a signal:<\/p>\n Emit the signal with the given arguments.<\/p>\n<\/li>\n<\/ul>\n If the proxy is a method:<\/p>\n Start listening to a method call on this service (resets previous calls values). If the return_val is given an expression, Block until the method call happens. If listening is False, then listen_call(return_val) is implicitely called. Else it is assumed Mixed-type scripting allows one to use both service-side and client-side features of the testing framework. Use this To create the service or client proxies, the syntax is the same as defined above for each type of proxies. One additional syntax Once you have the nicknamed proxy, you can use it like defined above, depending on the type of the proxy under the nickname.<\/p>\n Where xxx depends on the type of the proxy. If the proxy is a mixed one, then you can use both client and service api on it<\/p>\n The following examples will guide you “visually” through the usage of this testing framework. Call this method, expect this reply<\/p>\n Call this method, wait for this signal<\/p>\n A simple client test for an hypothetic HelloWorld service<\/p>\n The same test, but on the service side for testing with an hypothetic HelloWorld Client. First the Service definition:<\/p>\n Then the actual script:<\/p>\n You can of course launch the two tests in separate processes and see that they behave correctly<\/p>\n And finally more or less the same test with mixed scripting. Both the service and the client are in the script. This one Open a notification bubble with no timeout, close it programmatically, and check that the Closed signal is emitted<\/p>\n Log on to two jabber accounts, talk from one to other account, check all Log on to two jabber accounts, add yourself to your buddy list, Like in telepathy, there’s a voip-engine which is both a service and a client of a connection manager Goals The main aim should be that its easy to write a linear test script Allowing to interact with other automated frameworks like dogtail is also a plus Tutorial This little tutorial will introduce you to the concets and API of the dbus testing framework without entering too much in the gory details General concepts […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":47,"menu_order":0,"comment_status":"open","ping_status":"open","template":"page-comments.php","meta":{"footnotes":""},"class_list":["post-49","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/pages\/49","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/comments?post=49"}],"version-history":[{"count":0,"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/pages\/49\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/pages\/47"}],"wp:attachment":[{"href":"https:\/\/raphael.slinckx.net\/blog\/wp-json\/wp\/v2\/media?parent=49"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Test Cases<\/h4>\n
run(self):<\/code> method
\n\tof a TestCase<\/code> subclass. To create a test case just define a new class, override the run method
\n\tand pass it to the run(cases)<\/code> method of the framework, like that:<\/p>\n\r\nclass MyTestCase(TestCase):\r\n\tdef run(self):\r\n\t\t[Execute test script here]\r\n\r\nrun(MyTestCase)\r\n<\/pre>\n
run(cases)<\/code> method. That way, you can select
\n\twhich test case you want to run from the command line. Let’s say you defined FooTest, BarTest and BazTest
\n\tin a file names mytests.py<\/code>.<\/p>\n\r\nclass FooTest(TestCase):\r\n\t[]\r\nclass BarTest(TestCase):\r\n\t[]\r\nclass BazTest(TestCase):\r\n\t[]\r\n\r\nrun([FooTest, BarTest, BazTest])\r\n<\/pre>\n
\r\n$ python mytests.py FooTest\r\n-> execute the FooTest test case\r\n<\/pre>\n
Proxy objects<\/h4>\n
\n
ClientTestCase<\/code>: When you want to test a servie behavior (the test script emulates a client)<\/li>\nServiceTestCase<\/code>: When you want to test a client behavior (the test script emulates a dbus service)<\/li>\nMixedTestCase<\/code>: When you want to test both a service and a client (possibly the same) behavior (the test script
\n\t\t emulates a client and\/or a dbus service)<\/li>\n<\/ul>\n{Client,Service,Mixed}TestCase<\/code>
\n\tand must implement a run(self)<\/code> method. These classes should then be passed to the run(cases)<\/code> function.<\/p>\nClient-side scripting<\/h3>\n
\n\tlisten for signals emitted by these objects (and thus assert they happen at the right moment)<\/p>\n
\n\tservice name, the remote object path and the interfaces implemented by the object. This is all usual Dbus jargon.<\/p>\n\r\nself[\"nick\"] = (\"org.foo.bar\", \"\/org\/foo\/bar\", \"org.foo.IBar\")\r\n<\/pre>\n
\n\t creates under nickname “nick” the given remote object proxy which implement two interfaces, IBar and IBaz.
\n\t Each interface has its own nickname (“iface1” and “iface2”).<\/p>\n\r\nself[\"nick\"] = (\"org.foo.bar\", \"\/org\/foo\/bar\",\r\n\t{\"iface1\": \"org.foo.IBar\", \"iface2\": \"org.foo.IBaz\"})\r\n<\/pre>\n\r\nself[\"nick\"][\"Method\"].xxx\r\nself[\"nick\"][\"Signal\"].xxx\r\n\r\n# If there is more than one interface:\r\nself[\"nick\"][\"iface1\"][\"Method\"].xxx\r\nself[\"nick\"][\"iface1\"][\"Signal\"].xxx\r\n<\/pre>\n
\n
call(self, *args, **kwargs) : result<\/code><\/p>\n
\n\t\targument to specify how much time the call should wait before failure. If not specified the default is used.<\/p>\n<\/li>\n<\/ul>\n\n
listen(self) : void<\/code>\nwait(self, n=1, timeout=DEFAULT_TIMEOUT) : result<\/code>\n
\n\t\tof signal parameters if n > 1, ordered by reception time.<\/p>\n<\/li>\n<\/ul>\nService-side scripting<\/h3>\n
\n\tare made against the exported objects, and emit signals from exported objects. You will be able to test
\n\tthat way that clients are behaving correctly to service events.<\/p>\n
\n\tservice name, the remote object path and the methods\/signals exported by the object. This is all usual Dbus jargon.<\/p>\n
\n\tas you would do when using the dbus bindings in python, plus some more details<\/p>\n\r\nclass FooBarService(MockService):\r\n\t@intercept\r\n\t@dbus.service.method(\"org.foo.bar.IBaz\")\r\n\tdef Foo(self):\r\n\t\treturn \"Foo\"\r\n\r\n\t@intercept\r\n\t@dbus.service.method(\"org.foo.bar.IBaz\")\r\n\tdef Bar(self, param):\r\n\t\treturn param+3\r\n\r\n\t@dbus.service.signal(\"org.foo.bar.IBaz\")\r\n\tdef BazSig(self, s):\r\n\t\tpass\r\n<\/pre>\n
@intercept<\/code> annotation
\n\thas to be used for methods<\/em> (not for signals or things break) and after<\/em> the @method annotation (which means before<\/em>
\n\tin source code)<\/p>\n\r\nself[\"nick\"] = (FooBarService, \"org.foo.bar\", \"\/org\/foo\/bar\")\r\n<\/pre>\n
\r\nself[\"nick\"][\"Method\"].xxx\r\nself[\"nick\"][\"Signal\"].xxx\r\n<\/pre>\n
\n
emit(self, *args, **kwargs) : void<\/code><\/p>\n\n
listen_call(self, return_val=None) : void<\/code>\n
\n\t\tthe expression will be called with the parameters of the method call and its return value will be used instead of the
\n\t\tdefault method implementation as given in the MockService subclass<\/p>\n\r\n# When Method is called by a remote client, the return value will be the tuple (args, kwargs)\r\n# returned by the lambda expression instead of the default return value given in the MockService.\r\nself[\"nick\"][\"Method\"].listen_call(lambda *args, **kwargs: return args, kwargs)\r\n<\/pre>\n<\/li>\n
wait_call(self, listening=False, return_val=None, timeout=DEFAULT_TIMEOUT): result<\/code>\n
\n\t\tthat you have already called listen_call() yourself before. Wait at most timeout seconds. The return value are the arguments provided
\n\t\tto the method when it was called.<\/p>\n<\/li>\n<\/ul>\nMixed type scripting<\/h3>\n
\n\twhen you need clients and service at the same time in a script, that possibly needs to call each other or interact in some ways.<\/p>\n
\n\tis available to defined in one step both a service and a client connected to it, if that’s useful:<\/p>\n\r\nself[\"nick\"] = (FooBarService, \"org.foo.bar\", \"\/org\/foo\/bar\", \"org.foo.bar.IBaz\")\r\n# or for the multi interface client\r\nself[\"nick\"] = (FooBarService, \"org.foo.bar\", \"\/org\/foo\/bar\",\r\n\t\t{\"iface1\": \"org.foo.bar.IBaz\", \"iface2\": \"org.foo.bar.IBaz2\"})\r\n<\/pre>\n\r\nself[\"nick\"][\"Method\"].xxx\r\nself[\"nick\"][\"Signal\"].xxx\r\n<\/pre>\n
Examples<\/h2>\n
\n\t The snippets have to be enclosed in a run(self) method of a TestCase subclass to be chosen among the
\n\t available ones (ClientTestCase, ServiceTestCase, MixedTestCase)<\/p>\nSimple calls\/signals<\/h3>\n
\r\nself[\"foo\"] = (\"org.freedesktop.Foo\",\"\/org\/freedesktop\/Foo\",\"org.freedesktop.Foo\")\r\nret = self[\"foo\"][\"Half\"].call(32)\r\nassert ret == 16\r\n<\/pre>\n
\r\nself[\"foo\"] = (\"org.freedesktop.Foo\",\"\/org\/freedesktop\/Foo\",\"org.freedesktop.Foo\")\r\nself[\"foo\"][\"HalfComputed\"].listen()\r\nself[\"foo\"][\"Half\"].call(32)\r\nret = self[\"foo\"][\"HalfComputed\"].wait()\r\nassert ret == 16\r\n<\/pre>\n
Hello World examples<\/h3>\n
\r\nself[\"hello\"] = (\"org.freedesktop.HelloWorld\",\r\n\t\t\"\/org\/freedesktop\/HelloWorldObject\",\r\n\t\t\"org.freedesktop.HelloWorldIFace\")\r\n\r\necho = self[\"hello\"][\"Hello\"].call()\r\nassert echo == \"olleH\"\r\n\r\nself[\"hello\"].HalloSig.listen()\r\necho = self[\"hello\"][\"Hallo\"].call(\"echomethis\")\r\nassert echo == \"echomethis\"\r\nsigs = self[\"hello\"][\"HalloSig\"].wait()\r\nassert sigs[0] == \"echomethis\"\r\n\r\nself[\"hello\"][\"HalloSig\"].listen()\r\nsigs = self[\"hello\"][\"HalloSig\"].wait()\r\nassert sigs[0] == \"test\"\r\n<\/pre>\n
\r\nclass HelloService(MockService):\r\n\t@intercept\r\n\t@dbus.service.method(\"org.freedesktop.HelloWorldIFace\")\r\n\tdef Hello(self):\r\n\t\treturn \"olleH\"\r\n\r\n\t@intercept\r\n\t@dbus.service.method(\"org.freedesktop.HelloWorldIFace\")\r\n\tdef HalloOverriden(self, param):\r\n\t\treturn param\r\n\r\n\t@intercept\r\n\t@dbus.service.method(\"org.freedesktop.HelloWorldIFace\")\r\n\tdef Hallo(self, param):\r\n\t\tself.HalloSig(param)\r\n\t\treturn param\r\n\r\n\t@dbus.service.signal(\"org.freedesktop.HelloWorldIFace\")\r\n\tdef HalloSig(self, s):\r\n\t\tpass\r\n<\/pre>\n
\r\nself[\"hello\"] = (HelloService,\r\n\t\t\"org.freedesktop.HelloWorld\",\r\n\t\t\"\/org\/freedesktop\/HelloWorldObject\")\r\n\r\nself[\"hello\"][\"Hello\"].wait_call()\r\nself[\"hello\"][\"Hallo\"].wait_call()\r\nself[\"hello\"][\"HalloSig\"].emit(\"test\")\r\n<\/pre>\n
\n\tcan run standalone since the service and object are both provided.<\/p>\n\r\nself[\"hello\"] = (HelloService,\r\n\t\"org.freedesktop.HelloWorld\",\r\n\t\"\/org\/freedesktop\/HelloWorldObject\",\r\n\t\"org.freedesktop.HelloWorldIFace\")\r\n\r\nself[\"hello\"][\"Hello\"].listen_call()\r\necho = self[\"hello\"][\"Hello\"].call()\r\nself[\"hello\"][\"Hello\"].wait_call(True)\r\nassert echo == \"olleH\"\r\n\r\nself[\"hello\"][\"HalloSig\"].listen()\r\necho = self[\"hello\"][\"Hallo\"].call(\"echomethis\")\r\nassert echo == \"echomethis\"\r\n\r\nsigs = self[\"hello\"][\"HalloSig\"].wait()\r\nassert sigs[0] == \"echomethis\"\r\n\r\nself[\"hello\"][\"HalloSig\"].listen()\r\nself[\"hello\"][\"HalloSig\"].emit(\"test\")\r\nsigs = self[\"hello\"][\"HalloSig\"].wait()\r\nassert sigs[0] == \"test\"\r\n\r\nself[\"hello\"][\"HalloOverriden\"].listen_call(return_val=lambda x: x[1:-1])\r\necho = self[\"hello\"][\"HalloOverriden\"].call(\"TestString\")\r\nself[\"hello\"][\"HalloOverriden\"].wait_call(True)\r\nassert echo == \"estStrin\"\r\n<\/pre>\n
Libnotify example<\/h3>\n
\r\nself[\"notif\"] = (\"org.freedesktop.Notifications\",\r\n\t\t\"\/org\/freedesktop\/Notifications\",\r\n\t\t\"org.freedesktop.Notifications\")\r\n\r\nid = self[\"notif\"][\"Notify\"].call(\"notifname\", 0, \"\", \"title\", \"content\",[],{}, 0)\r\n\r\nself[\"notif\"][\"NotificationClosed\"].listen()\r\nself[\"notif\"][\"CloseNotification\"].call(id)\r\nresults = self[\"notif\"][\"NotificationClosed\"].wait()\r\n\r\nassert results[0] == id\r\n<\/pre>\nAdvanced cases<\/h3>\n
\n\t parameters are correct and that the messages are well exchanged, Disconnect.<\/p>\n\r\ndef start_manager(self, nick):\r\n\tself[nick] = (\"org.freedesktop.Telepathy.ConnectionManager.gabble\",\r\n\t\t\"\/org\/freedesktop\/Telepathy\/ConnectionManager\/gabble\",\r\n\t\t\"org.freedesktop.Telepathy.ConnectionManager\")\r\n\r\ndef connect(self, nick, proto, params):\r\n\t# Connect to the manager\r\n\tconn, obj = self[nick][\"Connect\"].call(proto, params)\r\n\t# register connection as self.nick_conn\r\n\tself[nick+\"_conn\"] = (conn, obj, \"org.freedesktop.Telepathy.Connection\")\r\n\r\n\t# Retrieve connection status, and wait until connected\r\n\tstatus = self[nick+\"_conn\"][\"GetStatus\"].call()\r\n\twhile status != 0:\r\n\t\tif status == 2:\r\n\t\t\traise Exception(\"Could not connect\")\r\n\t\tself[nick+\"_conn\"][\"StatusChanged\"].listen()\r\n\t\tstatus, reason = self[nick+\"_conn\"][\"StatusChanged\"].wait()\r\n\r\n\treturn conn\r\n\r\ndef run(self):\r\n\t# Test Setup\r\n\tself.start_manager(\"client1\")\r\n\tself.start_manager(\"client2\")\r\n\r\n\t# Connect the two accounts\r\n\tconn1 = self.connect(\"client1\", \"jabber\",\r\n\t\t{\"account\": \"kikidonk@amessage.be\", \"password\": \"kikidonk\"})\r\n\tconn2 = self.connect(\"client2\", \"google-talk\",\r\n\t\t{ \"account\": \"tryggve.tryggvason@gmail.com\",\"password\": \"badger\"})\r\n\r\n\t# Start listening to NewChannel signal emitted when client2 starts to talk to client1\r\n\tself[\"client1_conn\"][\"NewChannel\"].listen()\r\n\r\n\t# Create a text channel\r\n\tself[\"client2_chan\"] = (\r\n\t\t# The connection service\r\n\t\tconn2,\r\n\t\t# A new text channel to the client 1\r\n\t\tself[\"client2_conn\"][\"RequestChannel\"].call(\r\n\t\t\t\"org.freedesktop.Telepathy.Channel.Type.Text\", 1,\r\n\t\t\tself[\"client2_conn\"][\"RequestHandle\"].call (1, \"kikidonk@amessage.be\"), False),\r\n\t\t# The interfaces for this text channel\r\n\t\t{\"text\": \"org.freedesktop.Telepathy.Channel.Type.Text\",\r\n\t\t \"chan\": \"org.freedesktop.Telepathy.Channel\"})\r\n\r\n\t# Send a test message to client 1 from client 2\r\n\tself[\"client2_chan\"][\"text\"][\"Send\"].call (0, \"Test\")\r\n\r\n\t# We got a newchannel from client 1\r\n\tobj, channel_type, handle_type, handle, suppress_handler = self[\"client1_conn\"][\"NewChannel\"].wait()\r\n\r\n\tassert channel_type == \"org.freedesktop.Telepathy.Channel.Type.Text\"\r\n\tassert handle_type == 1\r\n\tassert suppress_handler == False\r\n\r\n\t# Create the channel structure for client 1\r\n\tself[\"client1_chan\"] = (\r\n\t\tconn1,\r\n\t\tobj,\r\n\t\t{\"text\": \"org.freedesktop.Telepathy.Channel.Type.Text\",\r\n\t\t \"chan\": \"org.freedesktop.Telepathy.Channel\"})\r\n\r\n\t# Retreive pending messages\r\n\tmessages = self[\"client1_chan\"][\"text\"][\"ListPendingMessages\"].call()\r\n\r\n\tid, stamp, from_handle, msg_type, string = messages[0]\r\n\tassert len(messages) == 1\r\n\tassert from_handle == handle\r\n\tassert msg_type == 0\r\n\tassert string == \"Test\"\r\n\r\n\t# Close\/Disconnect stuff\r\n\tself[\"client2_chan\"][\"chan\"][\"Close\"].call()\r\n\tself[\"client1_chan\"][\"chan\"][\"Close\"].call()\r\n\tself[\"client2_conn\"][\"Disconnect\"].call()\r\n\tself[\"client1_conn\"][\"Disconnect\"].call()\r\n<\/pre>\n
\n\t check you got that on the other end, allow it. Remove yourself, check you got that.
\n\t Add yourself again, reject it, check you got that. etc<\/p>\n\r\nTo be written\r\n<\/pre>\n
\n\t I want to be able to pretend to be a client, and call handle channel,
\n\t then pretend to be a service, send out stuff, test that the right things
\n\t are returned, test that prerequisite calls get made.<\/p>\n\r\nTo be written\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"