/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ /* test-secret-util.c: Test secret utils Copyright (C) 2012 Red Hat Inc The Gnome Keyring Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The Gnome Keyring Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the Gnome Library; see the file COPYING.LIB. If not, . Author: Stef Walter */ #include "config.h" #include "test-service.h" #include "gkd-secret-types.h" #include "egg/egg-testing.h" #include #include #include #include #include typedef struct { gchar *path; gchar *iface; gchar *name; GVariant *parameters; } ReceivedSignal; typedef struct { TestService service; guint signal_id; GList *received_signals; gboolean expecting_properties; } Test; static void on_signal_received (GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) { Test *test = user_data; ReceivedSignal *sig; g_assert (object_path != NULL); g_assert (interface_name != NULL); g_assert (signal_name != NULL); g_assert (parameters != NULL); sig = g_slice_new0 (ReceivedSignal); sig->path = g_strdup (object_path); sig->iface = g_strdup (interface_name); sig->name = g_strdup (signal_name); sig->parameters = g_variant_ref (parameters); test->received_signals = g_list_prepend (test->received_signals, sig); if (test->expecting_properties && g_str_equal ("org.freedesktop.DBus.Properties", interface_name) && g_str_equal ("PropertiesChanged", signal_name)) { egg_test_wait_stop (); } } static void received_signal_free (gpointer data) { ReceivedSignal *sig = data; g_free (sig->path); g_free (sig->iface); g_free (sig->name); g_variant_unref (sig->parameters); g_slice_free (ReceivedSignal, sig); } static void received_signals_flush (Test *test) { g_list_free_full (test->received_signals, received_signal_free); test->received_signals = NULL; } static void expect_signal_with_path (Test *test, const gchar *signal_path, const gchar *signal_iface, const gchar *signal_name, const gchar *param_path) { ReceivedSignal *sig; const gchar *path; GList *l; g_assert (signal_path != NULL); g_assert (signal_iface != NULL); g_assert (signal_name != NULL); g_assert (param_path != NULL); for (l = test->received_signals; l != NULL; l = g_list_next (l)) { sig = l->data; if (g_str_equal (signal_path, sig->path) && g_str_equal (signal_iface, sig->iface) && g_str_equal (signal_name, sig->name)) { g_assert (g_variant_is_of_type (sig->parameters, G_VARIANT_TYPE ("(o)"))); g_variant_get (sig->parameters, "(&o)", &path); if (!g_str_equal (path, param_path)) { g_critical ("received invalid path from signal %s on interface %s at object %s: " "expected path %s but got %s", sig->name, sig->iface, sig->path, param_path, path); } return; } } g_critical ("didn't receive signal %s on interface %s at object %s", signal_name, signal_iface, signal_path); } static gboolean has_property_changed (Test *test, const gchar *signal_path, const gchar *property_iface, const gchar *property_name) { ReceivedSignal *sig; const gchar *iface; GVariant *properties; GVariant *invalidated; GVariant *value; GList *l; g_assert (signal_path != NULL); g_assert (property_iface != NULL); g_assert (property_name != NULL); for (l = test->received_signals; l != NULL; l = g_list_next (l)) { sig = l->data; if (g_str_equal (signal_path, sig->path) && g_str_equal ("org.freedesktop.DBus.Properties", sig->iface) && g_str_equal ("PropertiesChanged", sig->name)) { value = NULL; g_assert (g_variant_is_of_type (sig->parameters, G_VARIANT_TYPE ("(sa{sv}as)"))); g_variant_get (sig->parameters, "(&s@a{sv}@as)", &iface, &properties, &invalidated); if (g_str_equal (iface, property_iface)) { value = g_variant_lookup_value (properties, property_name, NULL); g_variant_unref (value); } g_variant_unref (properties); g_variant_unref (invalidated); if (value != NULL) return TRUE; } } return FALSE; } static void expect_property_changed (Test *test, const gchar *signal_path, const gchar *property_iface, const gchar *property_name) { /* GDBus queues property change signal emissions in an idle, * so we cannot rely on PropertiesChanged to have arrived by * the time we have returned from the method call - but we cannot * rely on it *not* having arrived either! * If the property notification hasn't been received, we set up * ourselves to wake up at every property change. * Eventually, if we don't receive any that match our arguments, * we're going to fail. */ while (!has_property_changed (test, signal_path, property_iface, property_name)) { test->expecting_properties = TRUE; egg_test_wait_until (2000); test->expecting_properties = FALSE; } if (!has_property_changed (test, signal_path, property_iface, property_name)) g_critical ("didn't receive PropertiesChanged for %s property on interface %s at object %s", property_name, property_iface, signal_path); } static void on_complete_get_result (GObject *source, GAsyncResult *result, gpointer user_data) { GAsyncResult **res = user_data; g_assert (res != NULL); g_assert (*res == NULL); *res = g_object_ref (result); egg_test_wait_stop (); } static GVariant * dbus_call_perform (Test *test, const gchar *object_path, const gchar *interface, const gchar *member, GVariant *parameters, const GVariantType *restype, GError **error) { GAsyncResult *result = NULL; GVariant *retval; /* * Do an async call with a full main loop, so that the signals * arrive before the method result. */ g_dbus_connection_call (test->service.connection, test->service.bus_name, object_path, interface, member, parameters, restype, G_DBUS_CALL_FLAGS_NO_AUTO_START, -1, NULL, on_complete_get_result, &result); g_assert (result == NULL); egg_test_wait (); g_assert (result != NULL); retval = g_dbus_connection_call_finish (test->service.connection, result, error); g_object_unref (result); return retval; } static void setup (Test *test, gconstpointer unused) { GError *error = NULL; GVariant *retval; test->service.mock_prompter = gcr_mock_prompter_start (); g_assert (test->service.mock_prompter != NULL); test_service_setup (&test->service); /* Unlock the test collection */ retval = g_dbus_connection_call_sync (test->service.connection, test->service.bus_name, SECRET_SERVICE_PATH, INTERNAL_SERVICE_INTERFACE, "UnlockWithMasterPassword", g_variant_new ("(o@(oayays))", "/org/freedesktop/secrets/collection/test", test_service_build_secret (&test->service, "booo")), G_VARIANT_TYPE ("()"), G_DBUS_CALL_FLAGS_NO_AUTO_START, -1, NULL, &error); g_assert_no_error (error); g_variant_unref (retval); /* Wait for the prompt's completed signal */ test->signal_id = g_dbus_connection_signal_subscribe (test->service.connection, test->service.bus_name, NULL, NULL, NULL, NULL, G_DBUS_SIGNAL_FLAGS_NONE, on_signal_received, test, NULL); received_signals_flush (test); } static void setup_locked (Test *test, gconstpointer unused) { GVariant *element; GVariant *retval; GError *error = NULL; const gchar *prompt; GVariant *locked; /* Main setup */ setup (test, unused); element = g_variant_new_object_path ("/org/freedesktop/secrets/collection/test"); retval = dbus_call_perform (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "Lock", g_variant_new ("(@ao)", g_variant_new_array (G_VARIANT_TYPE ("o"), &element, 1)), G_VARIANT_TYPE ("(aoo)"), &error); g_assert_no_error (error); /* Not expecting a prompt */ g_variant_get (retval, "(@ao&o)", &locked, &prompt); g_assert_cmpstr (prompt, ==, "/"); g_variant_unref (locked); g_variant_unref (retval); /* Don't carry over any received signals into test */ received_signals_flush (test); } static void teardown (Test *test, gconstpointer unused) { received_signals_flush (test); g_dbus_connection_signal_unsubscribe (test->service.connection, test->signal_id); test_service_teardown (&test->service); gcr_mock_prompter_stop (); } static void on_prompt_completed (GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) { GVariant **prompt_result = user_data; gboolean dismissed; GVariant *result; g_assert (prompt_result != NULL); g_assert (*prompt_result == NULL); g_assert (g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(bv)"))); g_variant_get (parameters, "(b@v)", &dismissed, &result); if (dismissed) *prompt_result = NULL; else *prompt_result = g_variant_ref (result); g_variant_unref (result); egg_test_wait_stop (); } static GVariant * prompt_password_perform (Test *test, const gchar *prompt_path, const gchar *password, const GVariantType *type) { GVariant *prompt_result = NULL; GError *error = NULL; GVariant *inside; GVariant *retval; guint sig; /* Tell the mock prompter which password to use */ gcr_mock_prompter_expect_password_ok (password, NULL); /* Wait for the prompt's completed signal */ sig = g_dbus_connection_signal_subscribe (test->service.connection, test->service.bus_name, SECRET_PROMPT_INTERFACE, "Completed", prompt_path, NULL, G_DBUS_SIGNAL_FLAGS_NONE, on_prompt_completed, &prompt_result, NULL); /* Perform the prompt, this will use the mock prompter */ retval = g_dbus_connection_call_sync (test->service.connection, test->service.bus_name, prompt_path, SECRET_PROMPT_INTERFACE, "Prompt", g_variant_new ("(s)", ""), G_VARIANT_TYPE ("()"), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); g_assert_no_error (error); g_variant_unref (retval); egg_test_wait (); /* Done, now stop waiting for the prompts signal, make sure mock was used */ g_dbus_connection_signal_unsubscribe (test->service.connection, sig); g_assert (!gcr_mock_prompter_is_expecting ()); /* Check prompt result for right type */ g_assert (prompt_result != NULL); inside = g_variant_get_variant (prompt_result); g_assert (g_variant_is_of_type (inside, type)); g_variant_unref (prompt_result); return inside; } static void test_collection_created (Test *test, gconstpointer unused) { const gchar *collection; GError *error = NULL; const gchar *prompt; GVariant *properties; GVariant *retval; GVariant *result; GVariant *label; /* Create a new collection */ label = g_variant_new_dict_entry (g_variant_new_string ("org.freedesktop.Secret.Collection.Label"), g_variant_new_variant (g_variant_new_string ("My Collection"))); properties = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), &label, 1); retval = dbus_call_perform (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CreateCollection", g_variant_new ("(@a{sv}s)", properties, ""), G_VARIANT_TYPE ("(oo)"), &error); g_assert_no_error (error); /* We expect that a prompt is necessary */ g_variant_get (retval, "(&o&o)", &collection, &prompt); g_assert_cmpstr (collection, ==, "/"); g_assert_cmpstr (prompt, !=, "/"); /* * Perform the password prompt to create the collection, which returns * the new collection path */ result = prompt_password_perform (test, prompt, "booo", G_VARIANT_TYPE_OBJECT_PATH); g_variant_unref (retval); expect_signal_with_path (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CollectionCreated", g_variant_get_string (result, NULL)); expect_property_changed (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "Collections"); g_variant_unref (result); } static void test_collection_created_no_prompt (Test *test, gconstpointer unused) { const gchar *collection; GError *error = NULL; GVariant *properties; GVariant *retval; GVariant *label; /* Create a new collection */ label = g_variant_new_dict_entry (g_variant_new_string ("org.freedesktop.Secret.Collection.Label"), g_variant_new_variant (g_variant_new_string ("Without Prompt"))); properties = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), &label, 1); retval = dbus_call_perform (test, SECRET_SERVICE_PATH, INTERNAL_SERVICE_INTERFACE, "CreateWithMasterPassword", g_variant_new ("(@a{sv}@(oayays))", properties, test_service_build_secret (&test->service, "booo")), G_VARIANT_TYPE ("(o)"), &error); g_assert_no_error (error); g_variant_get (retval, "(&o)", &collection); g_assert_cmpstr (collection, !=, "/"); expect_signal_with_path (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CollectionCreated", collection); expect_property_changed (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "Collections"); g_variant_unref (retval); } static void test_collection_deleted (Test *test, gconstpointer unused) { const gchar *prompt; GError *error = NULL; GVariant *retval; /* Delete a collection */ retval = dbus_call_perform (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "Delete", g_variant_new ("()"), G_VARIANT_TYPE ("(o)"), &error); g_assert_no_error (error); /* Expect that no prompt is returned */ g_variant_get (retval, "(&o)", &prompt); g_assert_cmpstr (prompt, ==, "/"); expect_signal_with_path (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CollectionDeleted", "/org/freedesktop/secrets/collection/test"); expect_property_changed (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "Collections"); g_variant_unref (retval); } static void test_collection_changed (Test *test, gconstpointer unused) { GError *error = NULL; GVariant *retval; retval = dbus_call_perform (test, "/org/freedesktop/secrets/collection/test", "org.freedesktop.DBus.Properties", "Set", g_variant_new ("(ssv)", SECRET_COLLECTION_INTERFACE, "Label", g_variant_new_string ("New label")), G_VARIANT_TYPE ("()"), &error); g_assert_no_error (error); expect_signal_with_path (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CollectionChanged", "/org/freedesktop/secrets/collection/test"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "Label"); g_variant_unref (retval); } static void test_collection_lock (Test *test, gconstpointer unused) { GError *error = NULL; const gchar *prompt; GVariant *element; GVariant *locked; GVariant *retval; element = g_variant_new_object_path ("/org/freedesktop/secrets/collection/test"); retval = dbus_call_perform (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "Lock", g_variant_new ("(@ao)", g_variant_new_array (G_VARIANT_TYPE ("o"), &element, 1)), G_VARIANT_TYPE ("(aoo)"), &error); g_assert_no_error (error); /* Not expecting a prompt */ g_variant_get (retval, "(@ao&o)", &locked, &prompt); g_assert_cmpstr (prompt, ==, "/"); g_variant_unref (locked); expect_signal_with_path (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CollectionChanged", "/org/freedesktop/secrets/collection/test"); expect_signal_with_path (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "ItemChanged", "/org/freedesktop/secrets/collection/test/1"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "Locked"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test/1", SECRET_ITEM_INTERFACE, "Locked"); g_variant_unref (retval); } static void test_collection_unlock (Test *test, gconstpointer unused) { GError *error = NULL; const gchar *prompt; GVariant *unlocked; GVariant *retval; GVariant *element; element = g_variant_new_object_path ("/org/freedesktop/secrets/collection/test"); retval = dbus_call_perform (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "Unlock", g_variant_new ("(@ao)", g_variant_new_array (G_VARIANT_TYPE ("o"), &element, 1)), G_VARIANT_TYPE ("(aoo)"), &error); g_assert_no_error (error); /* Not expecting a prompt */ g_variant_get (retval, "(@ao&o)", &unlocked, &prompt); g_assert_cmpstr (prompt, !=, "/"); g_variant_unref (unlocked); unlocked = prompt_password_perform (test, prompt, "booo", G_VARIANT_TYPE ("ao")); g_variant_unref (unlocked); expect_signal_with_path (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CollectionChanged", "/org/freedesktop/secrets/collection/test"); expect_signal_with_path (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "ItemChanged", "/org/freedesktop/secrets/collection/test/1"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "Locked"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test/1", SECRET_ITEM_INTERFACE, "Locked"); g_variant_unref (retval); } static void test_collection_unlock_no_prompt (Test *test, gconstpointer unused) { GError *error = NULL; GVariant *retval; retval = dbus_call_perform (test, SECRET_SERVICE_PATH, INTERNAL_SERVICE_INTERFACE, "UnlockWithMasterPassword", g_variant_new ("(o@(oayays))", "/org/freedesktop/secrets/collection/test", test_service_build_secret (&test->service, "booo")), G_VARIANT_TYPE ("()"), &error); g_assert_no_error (error); expect_signal_with_path (test, SECRET_SERVICE_PATH, SECRET_SERVICE_INTERFACE, "CollectionChanged", "/org/freedesktop/secrets/collection/test"); expect_signal_with_path (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "ItemChanged", "/org/freedesktop/secrets/collection/test/1"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "Locked"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test/1", SECRET_ITEM_INTERFACE, "Locked"); g_variant_unref (retval); } static void test_item_created (Test *test, gconstpointer unused) { const gchar *item; const gchar *prompt; GError *error = NULL; GVariant *properties; GVariant *retval; GVariant *label; /* Create a new collection */ label = g_variant_new_dict_entry (g_variant_new_string ("org.freedesktop.Secret.Item.Label"), g_variant_new_variant (g_variant_new_string ("My Item"))); properties = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), &label, 1); retval = dbus_call_perform (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "CreateItem", g_variant_new ("(@a{sv}@(oayays)b)", properties, test_service_build_secret (&test->service, "booo"), FALSE), G_VARIANT_TYPE ("(oo)"), &error); g_assert_no_error (error); /* Not expecting a prompt */ g_variant_get (retval, "(&o&o)", &item, &prompt); g_assert_cmpstr (item, !=, "/"); g_assert_cmpstr (prompt, ==, "/"); expect_signal_with_path (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "ItemCreated", item); expect_property_changed (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "Items"); g_variant_unref (retval); } static void test_item_deleted (Test *test, gconstpointer unused) { const gchar *prompt; GError *error = NULL; GVariant *retval; retval = dbus_call_perform (test, "/org/freedesktop/secrets/collection/test/1", SECRET_ITEM_INTERFACE, "Delete", g_variant_new ("()"), G_VARIANT_TYPE ("(o)"), &error); g_assert_no_error (error); /* Not expecting a prompt */ g_variant_get (retval, "(&o)", &prompt); g_assert_cmpstr (prompt, ==, "/"); expect_signal_with_path (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "ItemDeleted", "/org/freedesktop/secrets/collection/test/1"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "Items"); g_variant_unref (retval); } static void test_item_changed (Test *test, gconstpointer unused) { GError *error = NULL; GVariant *retval; retval = dbus_call_perform (test, "/org/freedesktop/secrets/collection/test/1", "org.freedesktop.DBus.Properties", "Set", g_variant_new ("(ssv)", SECRET_ITEM_INTERFACE, "Label", g_variant_new_string ("New label")), G_VARIANT_TYPE ("()"), &error); g_assert_no_error (error); expect_signal_with_path (test, "/org/freedesktop/secrets/collection/test", SECRET_COLLECTION_INTERFACE, "ItemChanged", "/org/freedesktop/secrets/collection/test/1"); expect_property_changed (test, "/org/freedesktop/secrets/collection/test/1", SECRET_ITEM_INTERFACE, "Label"); g_variant_unref (retval); } int main (int argc, char **argv) { #if !GLIB_CHECK_VERSION(2,35,0) g_type_init (); #endif g_test_init (&argc, &argv, NULL); g_test_add ("/secret-signals/collection-created", Test, NULL, setup, test_collection_created, teardown); g_test_add ("/secret-signals/collection-created-no-prompt", Test, NULL, setup, test_collection_created_no_prompt, teardown); g_test_add ("/secret-signals/collection-changed", Test, NULL, setup, test_collection_changed, teardown); g_test_add ("/secret-signals/collection-deleted", Test, NULL, setup, test_collection_deleted, teardown); g_test_add ("/secret-signals/collection-lock", Test, NULL, setup, test_collection_lock, teardown); g_test_add ("/secret-signals/collection-unlock", Test, NULL, setup_locked, test_collection_unlock, teardown); g_test_add ("/secret-signals/collection-unlock-no-prompt", Test, NULL, setup_locked, test_collection_unlock_no_prompt, teardown); g_test_add ("/secret-signals/item-created", Test, NULL, setup, test_item_created, teardown); g_test_add ("/secret-signals/item-changed", Test, NULL, setup, test_item_changed, teardown); g_test_add ("/secret-signals/item-deleted", Test, NULL, setup, test_item_deleted, teardown); return egg_tests_run_with_loop (); }