luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-08-31 13:24:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

tests: Move fake-document-portal subprocess inside dbus-appinfo test

Browse Source 
For the reasons given in
https://gitlab.gnome.org/GNOME/glib/-/merge_requests/4176#note_2233317,
it’s best to not rely on subprocesses when writing tests. Spawning a
subprocess can go wrong, getting feedback and assertion data from a
subprocess is a pain, and making sure the subprocess is killed properly
at the end of the test is hard to get right.

For tests where we are trying to mock a D-Bus service, it’s much more
reliable to run that service in-process (either in the main thread or in
a separate thread).

So, do that for the `fake-document-portal` former subprocess in the
`dbus-appinfo` test: move it to a worker thread.

This speeds the test up, simplifies the build slightly, and should make
the test run more reliable.

In particular, it provides a pattern for future `fake-*-portal` tests to
be built off. This is particularly useful for more complex portals,
where data needs to be relayed back from the mock portal service to the
unit test to check that the code under test has behaved properly. That’s
a pain to do from a subprocess.

Delete the `org.freedesktop.portal.Documents.service` file because we no
longer need to rely on D-Bus service activation within the test, as
we’re setting up the mock service thread explicitly now.

Signed-off-by: Philip Withnall <pwithnall@gnome.org>
This commit is contained in:
Philip Withnall
2024-09-27 17:06:40 +01:00
parent d7bb4664e7
commit d7e368f206
6 changed files with 238 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
gio/tests/fake-document-portal.c
View File

@@ -26,8 +26,56 @@
#include <gio/gio.h>
#include <gio/gunixfdlist.h>
#include "fake-document-portal.h"
#include "fake-document-portal-generated.h"
struct _GFakeDocumentPortalThread
{
GObject parent_instance;
char *address; /* (not nullable) */
GCancellable *cancellable; /* (not nullable) (owned) */
GThread *thread; /* (not nullable) (owned) */
GCond cond; /* (mutex mutex) */
GMutex mutex;
gboolean ready; /* (mutex mutex) */
};
G_DEFINE_FINAL_TYPE (GFakeDocumentPortalThread, g_fake_document_portal_thread, G_TYPE_OBJECT)
static void g_fake_document_portal_thread_finalize (GObject *object);
static void
g_fake_document_portal_thread_class_init (GFakeDocumentPortalThreadClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = g_fake_document_portal_thread_finalize;
}
static void
g_fake_document_portal_thread_init (GFakeDocumentPortalThread *self)
{
self->cancellable = g_cancellable_new ();
g_cond_init (&self->cond);
g_mutex_init (&self->mutex);
}
static void
g_fake_document_portal_thread_finalize (GObject *object)
{
GFakeDocumentPortalThread *self = G_FAKE_DOCUMENT_PORTAL_THREAD (object);
g_assert (self->thread == NULL); /* should already have been joined */
g_mutex_clear (&self->mutex);
g_cond_clear (&self->cond);
g_clear_object (&self->cancellable);
g_clear_pointer (&self->address, g_free);
G_OBJECT_CLASS (g_fake_document_portal_thread_parent_class)->finalize (object);
}
static gboolean
on_handle_get_mount_point (FakeDocuments *object,
GDBusMethodInvocation *invocation,
@@ -76,13 +124,66 @@ on_handle_add_full (FakeDocuments *object,
}
static void
on_bus_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
on_name_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
FakeDocuments *interface;
GError *error = NULL;
GFakeDocumentPortalThread *self = G_FAKE_DOCUMENT_PORTAL_THREAD (user_data);
g_test_message ("Acquired the name %s", name);
g_mutex_lock (&self->mutex);
self->ready = TRUE;
g_cond_signal (&self->cond);
g_mutex_unlock (&self->mutex);
}
static void
on_name_lost (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
g_test_message ("Lost the name %s", name);
}
static gboolean
cancelled_cb (GCancellable *cancellable,
gpointer user_data)
{
g_test_message ("fake-document-portal cancelled");
return G_SOURCE_CONTINUE;
}
static gpointer
fake_document_portal_thread_cb (gpointer user_data)
{
GFakeDocumentPortalThread *self = G_FAKE_DOCUMENT_PORTAL_THREAD (user_data);
GMainContext *context = NULL;
GDBusConnection *connection = NULL;
GSource *source = NULL;
guint id;
FakeDocuments *interface = NULL;
GError *local_error = NULL;
context = g_main_context_new ();
g_main_context_push_thread_default (context);
connection = g_dbus_connection_new_for_address_sync (self->address,
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
NULL,
self->cancellable,
&local_error);
g_assert_no_error (local_error);
/* Listen for cancellation. The source will wake up the context iteration
* which can then re-check its exit condition below. */
source = g_cancellable_source_new (self->cancellable);
g_source_set_callback (source, G_SOURCE_FUNC (cancelled_cb), NULL, NULL);
g_source_attach (source, context);
g_source_unref (source);
/* Set up the interface */
g_test_message ("Acquired a message bus connection");
interface = fake_documents_skeleton_new ();
@@ -98,51 +199,81 @@ on_bus_acquired (GDBusConnection *connection,
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (interface),
connection,
"/org/freedesktop/portal/documents",
&error);
g_assert_no_error (error);
}
&local_error);
g_assert_no_error (local_error);
static void
on_name_acquired (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
g_test_message ("Acquired the name %s", name);
}
/* Own the portal name */
id = g_bus_own_name_on_connection (connection,
"org.freedesktop.portal.Documents",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
G_BUS_NAME_OWNER_FLAGS_REPLACE,
on_name_acquired,
on_name_lost,
self,
NULL);
static void
on_name_lost (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
g_test_message ("Lost the name %s", name);
}
gint
main (gint argc, gchar *argv[])
{
GMainLoop *loop;
guint id;
g_log_writer_default_set_use_stderr (TRUE);
loop = g_main_loop_new (NULL, FALSE);
id = g_bus_own_name (G_BUS_TYPE_SESSION,
"org.freedesktop.portal.Documents",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
G_BUS_NAME_OWNER_FLAGS_REPLACE,
on_bus_acquired,
on_name_acquired,
on_name_lost,
loop,
NULL);
g_main_loop_run (loop);
while (!g_cancellable_is_cancelled (self->cancellable))
g_main_context_iteration (context, TRUE);
g_bus_unown_name (id);
g_main_loop_unref (loop);
g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (interface));
g_clear_object (&interface);
g_clear_object (&connection);
g_main_context_pop_thread_default (context);
g_clear_pointer (&context, g_main_context_unref);
return 0;
return NULL;
}
/*
* Create a new #GFakeDocumentPortalThread. The thread isn’t started until
* g_fake_document_portal_thread_run() is called on it.
*
* Returns: (transfer full): the new fake document portal wrapper
*/
GFakeDocumentPortalThread *
g_fake_document_portal_thread_new (const char *address)
{
GFakeDocumentPortalThread *self = g_object_new (G_TYPE_FAKE_DOCUMENT_PORTAL_THREAD, NULL);
self->address = g_strdup (address);
return g_steal_pointer (&self);
}
/*
* Start a worker thread which will run a fake
* `org.freedesktop.portal.Documents` portal on the bus at @address. This is
* intended to be used with #GTestDBus to mock up a portal from within a unit
* test process, rather than relying on D-Bus activation of a mock portal
* subprocess.
*
* It blocks until the thread has owned its D-Bus name and is ready to handle
* requests.
*/
void
g_fake_document_portal_thread_run (GFakeDocumentPortalThread *self)
{
g_return_if_fail (G_IS_FAKE_DOCUMENT_PORTAL_THREAD (self));
g_return_if_fail (self->thread == NULL);
self->thread = g_thread_new ("fake-document-portal", fake_document_portal_thread_cb, self);
/* Block until the thread is ready. */
g_mutex_lock (&self->mutex);
while (!self->ready)
g_cond_wait (&self->cond, &self->mutex);
g_mutex_unlock (&self->mutex);
}
/* Stop and join a worker thread started with fake_document_portal_thread_run().
* Blocks until the thread has stopped and joined.
*
* Once this has been called, it’s safe to drop the final reference on @self. */
void
g_fake_document_portal_thread_stop (GFakeDocumentPortalThread *self)
{
g_return_if_fail (G_IS_FAKE_DOCUMENT_PORTAL_THREAD (self));
g_return_if_fail (self->thread != NULL);
g_cancellable_cancel (self->cancellable);
g_thread_join (g_steal_pointer (&self->thread));
}