Merge lp:~ted/dbus-test-runner/dbusmock-system-bus into lp:dbus-test-runner/15.04

[Ted Gould]

Make watching the task use the same bus the task is on

While we added the ability for tasks to show up on other busses, we didn't update the watchers of those tasks to be aware of them being on other busses and so therefore the watchers were left behind and lonely. Nobody wants lonely watchers. Participate! Set down that video camera!

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:93
http://jenkins.qa.ubuntu.com/job/dbus-test-runner-ci/34/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-vivid-amd64-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-vivid-armhf-ci/3
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-vivid-i386-ci/3

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/dbus-test-runner-ci/34/rebuild

review: Approve (continuous-integration)

[lp:~ted/dbus-test-runner/dbusmock-system-bus]

94. By Ted Gould on 2015-01-30

Add a test that tests waiting on system services

95. By Ted Gould on 2015-01-30

Check running the mock on the system bus

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:95
http://jenkins.qa.ubuntu.com/job/dbus-test-runner-ci/35/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-vivid-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-vivid-armhf-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-vivid-i386-ci/4

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/dbus-test-runner-ci/35/rebuild

review: Approve (continuous-integration)

[Charles Kerr (charlesk)]

LGTM

review: Approve

[lp:~ted/dbus-test-runner/dbusmock-system-bus]

96. By Ted Gould on 2015-02-02

This seems to fail on PPC occationally, curious if it's the fact that we're using the parameter which could be optimized oddly on different platforms. Going for a global.

=== modified file 'debian/libdbustest1.symbols'
--- debian/libdbustest1.symbols	2014-12-09 22:32:29 +0000
+++ debian/libdbustest1.symbols	2015-02-02 15:53:09 +0000
@@ -44,6 +44,7 @@
  dbus_test_task_set_return@Base 15.04.0+15.04.20141209
  dbus_test_task_set_wait_finished@Base 15.04.0+15.04.20141209
  dbus_test_task_set_wait_for@Base 15.04.0+15.04.20141209
+ dbus_test_task_set_wait_for_bus@Base 0replaceme
  dbus_test_watchdog_add_pid@Base 15.04.0+15.04.20141209
  dbus_test_watchdog_get_type@Base 15.04.0+15.04.20141209
  dbus_test_watchdog_ping@Base 15.04.0+15.04.20141209

=== modified file 'libdbustest/dbus-mock.c'
--- libdbustest/dbus-mock.c	2014-11-06 17:33:48 +0000
+++ libdbustest/dbus-mock.c	2015-02-02 15:53:09 +0000
@@ -145,9 +145,6 @@
 static void
 constructed (GObject * object)
 {
-	DbusTestDbusMock * self = DBUS_TEST_DBUS_MOCK(object);
-	const gchar * paramval = NULL;
-
 	if (mock_cnt == 0) {
 		dbus_test_task_set_name(DBUS_TEST_TASK(object), "DBusMock");
 	} else {
@@ -157,27 +154,6 @@
 	}
 	mock_cnt++;
 
-	/* Execute: python3 -m dbusmock $name / com.canonical.DbusTest.DbusMock */
-	g_object_set(object, "executable", "python3", NULL);
-
-	GArray * params = g_array_new(TRUE, TRUE, sizeof(gchar *));
-	/* NOTE: No free func, none of the memory is managed by the array */
-
-	paramval = "-m"; g_array_append_val(params, paramval);
-	paramval = "dbusmock"; g_array_append_val(params, paramval);
-
-	/* If we're set for system, go there, otherwise default to session */
-	if (dbus_test_task_get_bus(DBUS_TEST_TASK(self)) == DBUS_TEST_SERVICE_BUS_SYSTEM) {
-		paramval = "-s"; g_array_append_val(params, paramval);
-	}
-
-	g_array_append_val(params, self->priv->name);
-	paramval = "/"; g_array_append_val(params, paramval);
-	paramval = "com.canonical.DbusTest.DbusMock"; g_array_append_val(params, paramval);
-
-	g_object_set(object, "parameters", params, NULL);
-	g_array_unref(params);
-
 	return;
 }
 
@@ -446,6 +422,34 @@
 	return;
 }
 
+/* Configure the executable and parameters for the mock */
+static void
+configure_process (DbusTestDbusMock * self)
+{
+	const gchar * paramval = NULL;
+
+	/* Execute: python3 -m dbusmock $name / com.canonical.DbusTest.DbusMock */
+	g_object_set(G_OBJECT(self), "executable", "python3", NULL);
+
+	GArray * params = g_array_new(TRUE, TRUE, sizeof(gchar *));
+	/* NOTE: No free func, none of the memory is managed by the array */
+
+	paramval = "-m"; g_array_append_val(params, paramval);
+	paramval = "dbusmock"; g_array_append_val(params, paramval);
+
+	/* If we're set for system, go there, otherwise default to session */
+	if (dbus_test_task_get_bus(DBUS_TEST_TASK(self)) == DBUS_TEST_SERVICE_BUS_SYSTEM) {
+		paramval = "--system"; g_array_append_val(params, paramval);
+	}
+
+	g_array_append_val(params, self->priv->name);
+	paramval = "/"; g_array_append_val(params, paramval);
+	paramval = "com.canonical.DbusTest.DbusMock"; g_array_append_val(params, paramval);
+
+	g_object_set(G_OBJECT(self), "parameters", params, NULL);
+	g_array_unref(params);
+}
+
 /* Run the mock */
 static void
 run (DbusTestTask * task)
@@ -454,9 +458,20 @@
 	DbusTestDbusMock * self = DBUS_TEST_DBUS_MOCK(task);
 
 	/* Grab the new bus */
-	self->priv->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+	if (dbus_test_task_get_bus(DBUS_TEST_TASK(self)) == DBUS_TEST_SERVICE_BUS_SYSTEM) {
+		self->priv->bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+	} else {
+		self->priv->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
+	}
+
+	if (error != NULL) {
+		g_warning("Unable to get bus to start DBus Mock: %s", error->message);
+		g_error_free(error);
+		return;
+	}
 
 	/* Use the process code to get the process running */
+	configure_process(self);
 	DBUS_TEST_TASK_CLASS (dbus_test_dbus_mock_parent_class)->run (task);
 
 	/**** Initialize the DBus Mock instance ****/

=== modified file 'libdbustest/task.c'
--- libdbustest/task.c	2014-11-17 18:24:33 +0000
+++ libdbustest/task.c	2015-02-02 15:53:09 +0000
@@ -28,6 +28,7 @@
 	DbusTestTaskReturn return_type;
 
 	gchar * wait_for;
+	DbusTestServiceBus wait_for_bus;
 	guint wait_task;
 
 	gchar * name;
@@ -93,6 +94,7 @@
 	self->priv->return_type = DBUS_TEST_TASK_RETURN_NORMAL;
 
 	self->priv->wait_for = NULL;
+	self->priv->wait_for_bus = DBUS_TEST_SERVICE_BUS_BOTH;
 	self->priv->wait_task = 0;
 
 	self->priv->name = g_strdup_printf("task-%d", task_count++);
@@ -187,15 +189,21 @@
 
 	return;
 }
-
 void
 dbus_test_task_set_wait_for (DbusTestTask * task, const gchar * dbus_name)
 {
+	return dbus_test_task_set_wait_for_bus(task, dbus_name, DBUS_TEST_SERVICE_BUS_BOTH);
+}
+
+void
+dbus_test_task_set_wait_for_bus (DbusTestTask * task, const gchar * dbus_name, DbusTestServiceBus bus)
+{
 	g_return_if_fail(DBUS_TEST_IS_TASK(task));
 
 	if (task->priv->wait_for != NULL) {
 		g_free(task->priv->wait_for);
 		task->priv->wait_for = NULL;
+		task->priv->wait_for_bus = DBUS_TEST_SERVICE_BUS_BOTH;
 	}
 
 	if (dbus_name == NULL) {
@@ -203,6 +211,7 @@
 	}
 
 	task->priv->wait_for = g_strdup(dbus_name);
+	task->priv->wait_for_bus = bus;
 
 	return;
 }
@@ -293,7 +302,13 @@
 	/* We're going to process the waiting at this level if we've been
 	   asked to do so */
 	if (task->priv->wait_for != NULL) {
-		task->priv->wait_task = g_bus_watch_name(G_BUS_TYPE_SESSION,
+		GBusType bustype = G_BUS_TYPE_SESSION;
+		if (task->priv->wait_for_bus == DBUS_TEST_SERVICE_BUS_BOTH &&
+				task->priv->preferred_bus == DBUS_TEST_SERVICE_BUS_SYSTEM) {
+			bustype = G_BUS_TYPE_SYSTEM;
+		}
+
+		task->priv->wait_task = g_bus_watch_name(bustype,
 		                                         task->priv->wait_for,
 		                                         G_BUS_NAME_WATCHER_FLAGS_NONE,
 		                                         wait_for_found,

=== modified file 'libdbustest/task.h'
--- libdbustest/task.h	2014-11-06 17:28:07 +0000
+++ libdbustest/task.h	2015-02-02 15:53:09 +0000
@@ -82,6 +82,7 @@
 void dbus_test_task_set_name (DbusTestTask * task, const gchar * name);
 void dbus_test_task_set_name_spacing (DbusTestTask * task, glong chars);
 void dbus_test_task_set_wait_for (DbusTestTask * task, const gchar * dbus_name);
+void dbus_test_task_set_wait_for_bus (DbusTestTask * task, const gchar * dbus_name, DbusTestServiceBus bus);
 void dbus_test_task_set_return (DbusTestTask * task, DbusTestTaskReturn ret);
 void dbus_test_task_set_wait_finished (DbusTestTask * task, gboolean wait_till_complete);
 void dbus_test_task_set_bus (DbusTestTask * task, DbusTestServiceBus bus);

=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2014-11-17 20:55:44 +0000
+++ tests/Makefile.am	2015-02-02 15:53:09 +0000
@@ -120,6 +120,12 @@
 	@chmod +x $@
 XFAIL_TESTS += test-param-only-wait
 
+TESTS += test-param-wait-system
+test-param-wait-system: Makefile.am
+	@echo "#!/bin/sh" > $@
+	@echo $(DBUS_RUNNER) --bus-type=system --task ls --task-bus=system --wait-for org.test.test --task gdbus --parameter call --parameter --system --parameter --dest --parameter org.freedesktop.DBus --parameter --object-path --parameter / --parameter --method --parameter org.freedesktop.DBus.RequestName --parameter org.test.test --parameter 0 --task-bus=system >> $@
+	@chmod +x $@
+
 TESTS += test-param-multi-wait
 test-param-multi-wait: Makefile.am
 	@echo "#!/bin/sh" > $@

=== modified file 'tests/test-libdbustest-mock.c'
--- tests/test-libdbustest-mock.c	2014-02-26 17:25:21 +0000
+++ tests/test-libdbustest-mock.c	2015-02-02 15:53:09 +0000
@@ -22,20 +22,22 @@
 	g_main_loop_unref (temploop);
 }
 
-#define SESSION_MAX_WAIT 10
+#define SESSION_MAX_WAIT 100
 
 /*
 * Waiting until the session bus shuts down
 */
+GDBusConnection * wait_for_close_ptr = NULL;
 static void
 wait_for_connection_close (GDBusConnection *connection)
 {
-	g_object_add_weak_pointer(G_OBJECT(connection), (gpointer) &connection);
+	wait_for_close_ptr = connection;
+	g_object_add_weak_pointer(G_OBJECT(connection), (gpointer) &wait_for_close_ptr);
 
 	g_object_unref (connection);
 
 	int wait_count;
-	for (wait_count = 0; connection != NULL && wait_count < SESSION_MAX_WAIT; wait_count++)
+	for (wait_count = 0; wait_for_close_ptr != NULL && wait_count < SESSION_MAX_WAIT; wait_count++)
 	{
 		process_mainloop(200);
 	}
@@ -61,6 +63,9 @@
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 
+	dbus_test_service_add_task(service, DBUS_TEST_TASK(mock));
+	dbus_test_service_start_tasks(service);
+
 	gchar * dbusname = NULL;
 	g_object_get(mock, "dbus-name", &dbusname, NULL);
 	g_assert(g_strcmp0(dbusname, "foo.test") == 0);
@@ -71,9 +76,6 @@
 	g_assert(g_strcmp0(exec, "python3") == 0);
 	g_free(exec);
 
-	dbus_test_service_add_task(service, DBUS_TEST_TASK(mock));
-	dbus_test_service_start_tasks(service);
-
 	g_assert(dbus_test_task_get_state(DBUS_TEST_TASK(mock)) == DBUS_TEST_TASK_STATE_RUNNING);
 
 	/* check setup */
@@ -522,6 +524,75 @@
 }
 
 void
+test_running_system (void)
+{
+	DbusTestService * service = dbus_test_service_new(NULL);
+	g_assert(service != NULL);
+	dbus_test_service_set_bus(service, DBUS_TEST_SERVICE_BUS_SYSTEM);
+
+	dbus_test_service_set_conf_file(service, SESSION_CONF);
+
+	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
+	g_assert(mock != NULL);
+	dbus_test_task_set_bus(DBUS_TEST_TASK(mock), DBUS_TEST_SERVICE_BUS_SYSTEM);
+
+	/* Startup the mock */
+	dbus_test_service_add_task(service, DBUS_TEST_TASK(mock));
+	dbus_test_service_start_tasks(service);
+
+	GDBusConnection * bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+	g_dbus_connection_set_exit_on_close(bus, FALSE);
+
+	/* Add the object */
+	DbusTestDbusMockObject * obj = dbus_test_dbus_mock_get_object(mock, "/test", "foo.test.interface", NULL);
+	g_assert(obj != NULL);
+
+	g_assert(dbus_test_dbus_mock_object_add_method(mock, obj,
+		"method1",
+		G_VARIANT_TYPE("s"),
+		G_VARIANT_TYPE("s"),
+		"ret = 'test'",
+		NULL));
+
+	GVariant * propret = NULL;
+	GVariant * testvar = NULL;
+	GError * error = NULL;
+
+	/* Check method */
+	propret = g_dbus_connection_call_sync(bus,
+		"foo.test",
+		"/test",
+		"foo.test.interface",
+		"method1",
+		g_variant_new("(s)", "testin"),
+		G_VARIANT_TYPE("(s)"),
+		G_DBUS_CALL_FLAGS_NONE,
+		-1,
+		NULL,
+		&error);
+
+	if (error != NULL) {
+		g_error("Unable to call method1: %s", error->message);
+		g_error_free(error);
+	}
+
+	g_assert(propret != NULL);
+	testvar = g_variant_new_string("test");
+	testvar = g_variant_new_tuple(&testvar, 1);
+	g_variant_ref_sink(testvar);
+	g_assert(g_variant_equal(propret, testvar));
+	g_variant_unref(testvar);
+
+	g_variant_unref(propret);
+
+	/* Clean up */
+	g_object_unref(mock);
+	g_object_unref(service);
+
+	wait_for_connection_close(bus);
+}
+
+void
 test_interfaces (void)
 {
 	DbusTestService * service = dbus_test_service_new(NULL);
@@ -637,6 +708,7 @@
 	g_test_add_func ("/libdbustest/mock/methods",      test_methods);
 	g_test_add_func ("/libdbustest/mock/signals",      test_signals);
 	g_test_add_func ("/libdbustest/mock/running",      test_running);
+	g_test_add_func ("/libdbustest/mock/running-system", test_running_system);
 	g_test_add_func ("/libdbustest/mock/interfaces",   test_interfaces);
 
 	return;