Merge lp:~mardy/signon-keyring-extension/libsecret into lp:signon-keyring-extension

[Alberto Mardegan]

Migrate from libgnome-keyring to libsecret

Also tag a new upstream release.

Migrate from libgnome-keyring to libsecret

Also tag a new upstream release.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:30
http://jenkins.qa.ubuntu.com/job/signon-keyring-extension-ci/9/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/signon-keyring-extension-saucy-amd64-ci/2

Click here to trigger a rebuild:
http://s-jenkins:8080/job/signon-keyring-extension-ci/9/rebuild

review: Approve (continuous-integration)

[Ken VanDine (ken-vandine)]

Excellent, looks much better than the gnome-keyring API. Tests pass and it works on the phone, ship it!

review: Approve

=== modified file 'common-vars.pri'
--- common-vars.pri	2013-06-03 15:28:51 +0000
+++ common-vars.pri	2013-06-25 07:19:28 +0000
@@ -14,7 +14,7 @@
 # Project version
 # remember to update debian/* files if you changes this
 #-----------------------------------------------------------------------------
-PROJECT_VERSION = 0.5.1
+PROJECT_VERSION = 0.6
 
 # End of File
 

=== modified file 'debian/changelog'
--- debian/changelog	2013-06-05 18:49:03 +0000
+++ debian/changelog	2013-06-25 07:19:28 +0000
@@ -1,3 +1,10 @@
+signon-keyring-extension (0.6-0ubuntu1) UNRELEASED; urgency=low
+
+  * New upstream version
+    - migrate from libgnome-keyring to libsecret
+
+ -- Alberto Mardegan <[e-mail]>  Tue, 25 Jun 2013 10:14:29 +0300
+
 signon-keyring-extension (0.5.1daily13.06.05.1-0ubuntu1) saucy; urgency=low
 
   [ Ken VanDine ]

=== modified file 'debian/control'
--- debian/control	2013-06-03 15:28:51 +0000
+++ debian/control	2013-06-25 07:19:28 +0000
@@ -2,7 +2,7 @@
 Priority: optional
 Maintainer: Ubuntu Desktop Team <[e-mail]>
 Build-Depends: debhelper (>= 9),
-               libgnome-keyring-dev,
+               libsecret-1-dev,
                pkg-config,
                qt5-default,
                qt5-qmake,

=== modified file 'src/secrets-storage.cpp'
--- src/secrets-storage.cpp	2013-04-26 11:32:40 +0000
+++ src/secrets-storage.cpp	2013-06-25 07:19:28 +0000
@@ -25,10 +25,19 @@
 #include "secrets-storage.h"
 
 #include <QDataStream>
-#include <gnome-keyring.h>
+#include <libsecret/secret.h>
 
 using namespace SignOn;
 
+static const SecretSchema signonSchema = {
+    "com.ubuntu.OnlineAccounts.Secrets", SECRET_SCHEMA_DONT_MATCH_NAME,
+    {
+        { "signon-type", SECRET_SCHEMA_ATTRIBUTE_INTEGER },
+        { "signon-id", SECRET_SCHEMA_ATTRIBUTE_INTEGER },
+        { "signon-method", SECRET_SCHEMA_ATTRIBUTE_INTEGER },
+    }
+};
+
 SecretsStorage::SecretsStorage(QObject *parent) :
     AbstractSecretsStorage(parent),
     m_keyringName()
@@ -46,17 +55,7 @@
     if (configuration.contains(QLatin1String("KeyringName"))) {
         m_keyringName = configuration.value(QLatin1String("KeyringName")).toByteArray();
     } else {
-        GnomeKeyringResult ret;
-        gchar *name;
-
-        ret = gnome_keyring_get_default_keyring_sync(&name);
-        if (ret != GNOME_KEYRING_RESULT_OK) {
-            BLAME() << "Couldn't get default keyring name:" << ret;
-            return false;
-        }
-
-        m_keyringName = QByteArray(name);
-        g_free(name);
+        m_keyringName = QByteArray(SECRET_COLLECTION_DEFAULT);
     }
     TRACE() << "Using keyring:" << m_keyringName;
 
@@ -157,39 +156,36 @@
                                  quint32 method,
                                  const QByteArray &secret)
 {
-    GnomeKeyringResult ret;
-    guint32 createdItemId;
-
     TRACE() << "Storing secret:" << id <<
         "type:" << type <<
         "method:" << method;
 
-    GnomeKeyringAttributeList *attributes = gnome_keyring_attribute_list_new();
-    gnome_keyring_attribute_list_append_uint32(attributes, "signon-type", type);
-    gnome_keyring_attribute_list_append_uint32(attributes, "signon-id", id);
-    if (type == Data) {
-        gnome_keyring_attribute_list_append_uint32(attributes,
-                                                   "signon-method", method);
-    }
-
     QString displayName =
         QString::fromLatin1("Ubuntu Web Account: id %1-%2").arg(id).arg(type);
     QByteArray ba = displayName.toUtf8();
 
-    ret = gnome_keyring_item_create_sync(keyring(),
-                                         GNOME_KEYRING_ITEM_GENERIC_SECRET,
-                                         ba.constData(),
-                                         attributes,
-                                         secret.constData(),
-                                         TRUE,
-                                         &createdItemId);
-    gnome_keyring_attribute_list_free(attributes);
-    if (ret != GNOME_KEYRING_RESULT_OK) {
-        TRACE() << "Got error from GNOME keyring:" << ret;
+    const gchar *signonMethod = (type == Data) ? "signon-method" : NULL;
+
+    gboolean ok;
+    GError *error = NULL;
+    ok = secret_password_store_sync(&signonSchema,
+                                    keyring(),
+                                    ba.constData(),
+                                    secret.constData(),
+                                    NULL,
+                                    &error,
+                                    "signon-type", type,
+                                    "signon-id", id,
+                                    signonMethod, method,
+                                    NULL);
+
+
+    if (!ok) {
+        TRACE() << "Got error from GNOME keyring:" << error->message;
+        g_error_free(error);
         return false;
     }
 
-    Q_UNUSED(createdItemId);
     return true;
 }
 
@@ -198,50 +194,29 @@
                                 quint32 method,
                                 QByteArray &secret)
 {
-    GList *found = 0;
-    GnomeKeyringResult ret;
-
     TRACE() << "id:" << id << "type:" << type << "method:" << method;
-    GnomeKeyringAttributeList *attributes = gnome_keyring_attribute_list_new();
-    gnome_keyring_attribute_list_append_uint32(attributes, "signon-type", type);
-    gnome_keyring_attribute_list_append_uint32(attributes, "signon-id", id);
-    if (type == Data) {
-        gnome_keyring_attribute_list_append_uint32(attributes, "signon-method",
-                                                   method);
-    }
-
-    ret = gnome_keyring_find_items_sync(GNOME_KEYRING_ITEM_GENERIC_SECRET,
-                                        attributes,
-                                        &found);
-    gnome_keyring_attribute_list_free(attributes);
-    if (ret != GNOME_KEYRING_RESULT_OK) {
-        TRACE() << "Credentials loading failed:" << ret;
+
+    const gchar *signonMethod = (type == Data) ? "signon-method" : NULL;
+
+    GError *error = NULL;
+    gchar *data = secret_password_lookup_sync(&signonSchema,
+                                              NULL,
+                                              &error,
+                                              "signon-type", type,
+                                              "signon-id", id,
+                                              signonMethod, method,
+                                              NULL);
+
+    if (error != NULL) {
+        TRACE() << "Credentials loading failed:" << error->message;
+        g_error_free(error);
         return false;
     }
 
-    for (GList *list = found; list != 0; list = list->next) {
-        GnomeKeyringFound *result = (GnomeKeyringFound *)list->data;
-
-        if (!isActiveKeyring(result->keyring))
-            continue;
-
-        GnomeKeyringItemInfo *info;
-        ret = gnome_keyring_item_get_info_sync(result->keyring,
-                                               result->item_id,
-                                               &info);
-        if (ret != GNOME_KEYRING_RESULT_OK) {
-            TRACE() << "Error loading credentials:" << ret;
-            break;
-        }
-
-        gchar *data = gnome_keyring_item_info_get_secret(info);
-        secret = QByteArray(data);
-        g_free(data);
-        gnome_keyring_item_info_free(info);
-    }
-    gnome_keyring_found_list_free(found);
-
-    return ret == GNOME_KEYRING_RESULT_OK;
+    secret = QByteArray(data);
+    g_free(data);
+
+    return data != NULL;
 }
 
 bool SecretsStorage::removeSecrets(SignonSecretType type,
@@ -249,78 +224,41 @@
                                    quint32 method,
                                    QueryFields fields)
 {
-    GList *found = 0;
-    GnomeKeyringResult ret;
+    GHashTable *attributes = g_hash_table_new(g_str_hash, g_str_equal);
+    gchar id_str[16];
+    gchar method_str[16];
+    gchar type_str[16];
 
-    GnomeKeyringAttributeList *attributes = gnome_keyring_attribute_list_new();
     if (fields & IdField) {
-        gnome_keyring_attribute_list_append_uint32(attributes,
-                                                   "signon-id", id);
+        snprintf(id_str, sizeof(id_str), "%d", id);
+        g_hash_table_insert(attributes, gpointer("signon-id"), id_str);
     }
     if (fields & MethodField) {
-        gnome_keyring_attribute_list_append_uint32(attributes,
-                                                   "signon-method", method);
+        snprintf(method_str, sizeof(method_str), "%d", method);
+        g_hash_table_insert(attributes, gpointer("signon-method"), method_str);
     }
     if (fields & TypeField) {
-        gnome_keyring_attribute_list_append_uint32(attributes,
-                                                   "signon-type", type);
+        snprintf(type_str, sizeof(type_str), "%d", type);
+        g_hash_table_insert(attributes, gpointer("signon-type"), type_str);
     }
 
-    ret = gnome_keyring_find_items_sync(GNOME_KEYRING_ITEM_GENERIC_SECRET,
-                                        attributes,
-                                        &found);
-    if (ret != GNOME_KEYRING_RESULT_OK) {
-        if (ret == GNOME_KEYRING_RESULT_NO_MATCH) {
-            return true;
-        }
-        TRACE() << "Credentials search failed:" << ret;
+    GError *error = NULL;
+    secret_password_clearv_sync(&signonSchema,
+                                attributes,
+                                NULL,
+                                &error);
+    if (error != NULL) {
+        TRACE() << "Credentials search failed:" << error->message;
+        g_error_free(error);
         return false;
     }
 
-    for (GList *list = found; list != 0; list = list->next) {
-        GnomeKeyringFound *result = (GnomeKeyringFound *)list->data;
-
-        if (!isActiveKeyring(result->keyring))
-            continue;
-
-        ret = gnome_keyring_item_delete_sync(result->keyring, result->item_id);
-        if (ret != GNOME_KEYRING_RESULT_OK) {
-            TRACE() << "Error deleting credentials:" << ret;
-            break;
-        }
-    }
-    gnome_keyring_found_list_free(found);
-
-    return ret == GNOME_KEYRING_RESULT_OK;
+    g_hash_table_unref(attributes);
+
+    return true;
 }
 
 const char *SecretsStorage::keyring() const
 {
     return m_keyringName.isEmpty() ? 0 : m_keyringName.constData();
 }
-
-bool SecretsStorage::isActiveKeyring(const char *keyringName) const
-{
-    /* This method is needed not to apply the same hack in different parts of
-     * the code.
-     */
-    const gchar *activeKeyringName = keyring();
-    if (qstrcmp(keyringName, activeKeyringName) == 0)
-        return true;
-
-    /* Unfortunately GNOME keyring doesn't return the proper name of the
-     * default keyring (it returns NULL). This means that if the active
-     * keyring is the default keyring the above string comparison would fail.
-     * In other words, if the current keyring is NULL, we have no clue on what
-     * to return from this method.
-     * https://bugzilla.gnome.org/show_bug.cgi?id=664454
-     *
-     * If the current keyring is NULL, we just return true.
-     */
-    if (activeKeyringName == 0) {
-        return true;
-    } else {
-        return false;
-    }
-}
-

=== modified file 'src/secrets-storage.h'
--- src/secrets-storage.h	2011-11-21 12:46:50 +0000
+++ src/secrets-storage.h	2013-06-25 07:19:28 +0000
@@ -82,7 +82,6 @@
                        quint32 method,
                        QueryFields fields);
     const char *keyring() const;
-    bool isActiveKeyring(const char *keyringName) const;
 
     QByteArray m_keyringName;
 };

=== modified file 'src/src.pro'
--- src/src.pro	2011-11-18 17:06:13 +0000
+++ src/src.pro	2013-06-25 07:19:28 +0000
@@ -16,9 +16,11 @@
 
 QMAKE_CXXFLAGS += -Wno-missing-field-initializers
 
+DEFINES += QT_NO_KEYWORDS
+
 PKGCONFIG += \
     SignOnExtension \
-    gnome-keyring-1
+    libsecret-1
 
 # The following use of pkg-config + sed is a hack to workaround a qmake
 # limitation: the CFLAGS variable is not used with the moc compiler, so the

=== modified file 'tests/mocked-gnome-keyring.c'
--- tests/mocked-gnome-keyring.c	2012-08-14 12:26:01 +0000
+++ tests/mocked-gnome-keyring.c	2013-06-25 07:19:28 +0000
@@ -21,18 +21,18 @@
  */
 
 #include "mocked-gnome-keyring.h"
-#include <gnome-keyring.h>
+#include <libsecret/secret.h>
 
-#define DEFAULT_KEYRING "mock-keyring"
+#define DEFAULT_KEYRING SECRET_COLLECTION_DEFAULT
 
 static GHashTable *keyrings = NULL;
 static guint32 last_item_id = 123;
 
 typedef struct {
     guint32 id;
-    GnomeKeyringItemType type;
+    const SecretSchema *schema;
     char *display_name;
-    GnomeKeyringAttributeList *attributes;
+    GHashTable *attributes;
     char *secret;
 } MockedItem;
 
@@ -40,55 +40,52 @@
     GList *items;
 } MockedKeyring;
 
+static GHashTable *
+copy_g_hash_table(GHashTable *table)
+{
+    GHashTable *copy;
+    GHashTableIter iter;
+    gpointer key, value;
+
+    copy = g_hash_table_new_full(g_str_hash, g_str_equal,
+                                 g_free, g_free);
+    g_hash_table_iter_init(&iter, table);
+    while (g_hash_table_iter_next(&iter, &key, &value)) {
+        g_hash_table_insert(copy, g_strdup(key), g_strdup(value));
+    }
+
+    return copy;
+}
+
 static MockedItem *
-mocked_item_new(GnomeKeyringItemType type,
+mocked_item_new(const SecretSchema *schema,
                 const char *display_name,
-                GnomeKeyringAttributeList *attributes,
+                GHashTable *attributes,
                 const char *secret)
 {
     MockedItem *item = g_slice_new0(MockedItem);
     item->id = last_item_id++;
-    item->type = type;
+    item->schema = schema;
     item->display_name = g_strdup(display_name);
-    item->attributes = gnome_keyring_attribute_list_copy(attributes);
+    item->attributes = copy_g_hash_table(attributes);
     item->secret = g_strdup(secret);
     return item;
 }
 
 static gboolean
-attributes_are_equal (GnomeKeyringAttribute *a1,
-                      GnomeKeyringAttribute *a2)
-{
-    if (g_strcmp0(a1->name, a2->name) != 0) return FALSE;
-    if (a1->type != a2->type) return FALSE;
-    if (a1->type == GNOME_KEYRING_ATTRIBUTE_TYPE_STRING) {
-        return g_strcmp0(a1->value.string, a2->value.string) == 0;
-    } else {
-        return a1->value.integer == a2->value.integer;
-    }
-}
-
-static gboolean
 mocked_item_has_attributes(MockedItem *item,
-                           GnomeKeyringAttributeList *attributes)
+                           GHashTable *attributes)
 {
-    guint i, j;
-
-    for (i = 0; i < attributes->len; i++) {
-        gboolean found = FALSE;
-        GnomeKeyringAttribute *required =
-            &g_array_index(attributes, GnomeKeyringAttribute, i);
-
-        for (j = 0; j < item->attributes->len; j++) {
-            GnomeKeyringAttribute *attribute =
-                &g_array_index(item->attributes, GnomeKeyringAttribute, j);
-            if (attributes_are_equal(attribute, required)) {
-                found = TRUE;
-                break;
-            }
-        }
-
-        if (!found) return FALSE;
+    GHashTableIter iter;
+    gpointer key, value;
+
+    g_hash_table_iter_init(&iter, attributes);
+    while (g_hash_table_iter_next(&iter, &key, &value)) {
+        gpointer item_value;
+
+        item_value = g_hash_table_lookup(item->attributes, key);
+        if (item_value == NULL || g_strcmp0(item_value, value) != 0)
+            return FALSE;
     }
 
     return TRUE;
@@ -98,24 +95,11 @@
 mocked_item_free(MockedItem *item)
 {
     g_free(item->display_name);
-    gnome_keyring_attribute_list_free(item->attributes);
+    g_hash_table_unref(item->attributes);
     g_free(item->secret);
     g_slice_free(MockedItem, item);
 }
 
-static MockedItem *
-mocked_keyring_get_item(MockedKeyring *keyring, guint32 item_id)
-{
-    GList *list;
-
-    for (list = keyring->items; list != NULL; list = g_list_next(list)) {
-        MockedItem *item = list->data;
-        if (item->id == item_id) return item;
-    }
-
-    return NULL;
-}
-
 static MockedKeyring *
 mocked_keyring_new()
 {
@@ -131,174 +115,153 @@
     g_hash_table_insert(keyrings, TEST_KEYRING, mocked_keyring_new());
 }
 
-GnomeKeyringResult
-gnome_keyring_get_default_keyring_sync(char **keyring)
+GList *
+find_items(const SecretSchema *schema,
+           GHashTable *attributes)
 {
-    *keyring = g_strdup(DEFAULT_KEYRING);
-    return GNOME_KEYRING_RESULT_OK;
+    GHashTableIter iter;
+    const gchar *keyring_name;
+    MockedKeyring *keyring;
+    GList *results = NULL;
+
+    g_return_val_if_fail (attributes != NULL, NULL);
+
+    g_hash_table_iter_init(&iter, keyrings);
+    while (g_hash_table_iter_next(&iter,
+                                  (gpointer)&keyring_name,
+                                  (gpointer)&keyring)) {
+        GList *list;
+
+        for (list = keyring->items; list != NULL; list = g_list_next(list)) {
+            MockedItem *item = list->data;
+            if (item->schema != schema) continue;
+
+            if (!mocked_item_has_attributes(item, attributes)) continue;
+
+            results = g_list_prepend(results, item);
+        }
+    }
+
+    return results;
 }
 
-GnomeKeyringResult
-gnome_keyring_item_create_sync(const char *keyring,
-                               GnomeKeyringItemType type,
-                               const char *display_name,
-                               GnomeKeyringAttributeList *attributes,
-                               const char *secret,
-                               gboolean update_if_exists,
-                               guint32 *item_id)
+gboolean
+secret_password_store_sync(const SecretSchema *schema,
+                           const gchar *collection,
+                           const gchar *display_name,
+                           const gchar *secret,
+                           G_GNUC_UNUSED GCancellable *cancellable,
+                           GError **error,
+                           ...)
 {
-    GList *list, *found = NULL;
-    GnomeKeyringFound *existing_result = NULL;
+    GList *found = NULL;
     MockedKeyring *mocked_keyring;
-
-    g_return_val_if_fail (keyring != NULL,
-                          GNOME_KEYRING_RESULT_BAD_ARGUMENTS);
-    g_return_val_if_fail (type < GNOME_KEYRING_ITEM_LAST_TYPE,
-                          GNOME_KEYRING_RESULT_BAD_ARGUMENTS);
-
-    mocked_keyring = g_hash_table_lookup (keyrings, keyring);
-    if (G_UNLIKELY (mocked_keyring == NULL))
-        return GNOME_KEYRING_RESULT_NO_SUCH_KEYRING;
-
-    gnome_keyring_find_items_sync(type, attributes, &found);
-    for (list = found; list != NULL; list = g_list_next(list)) {
-        GnomeKeyringFound *result = list->data;
-        if (g_strcmp0(result->keyring, keyring) == 0) {
-            existing_result = result;
-            break;
-        }
+    GHashTable *attributes;
+    gpointer existing_result;
+    va_list va;
+
+    g_return_val_if_fail (schema != NULL, FALSE);
+    g_return_val_if_fail (collection != NULL, FALSE);
+
+    g_debug("%s, collection %s", G_STRFUNC, collection);
+    mocked_keyring = g_hash_table_lookup (keyrings, collection);
+    if (G_UNLIKELY (mocked_keyring == NULL)) {
+        g_set_error_literal(error, G_DBUS_ERROR, G_DBUS_ERROR_BAD_ADDRESS,
+                            "No such keyring");
+        return FALSE;
     }
-    gnome_keyring_found_list_free(found);
+
+    va_start (va, error);
+    attributes = secret_attributes_buildv (schema, va);
+    va_end (va);
+
+    found = find_items(schema, attributes);
+    existing_result = (found != NULL) ? found->data : NULL;
+    g_list_free(found);
 
     if (existing_result != NULL) {
-        if (!update_if_exists) return GNOME_KEYRING_RESULT_ALREADY_EXISTS;
-
         /* Update the existing item */
-        MockedItem *item = mocked_keyring_get_item(mocked_keyring,
-                                                   existing_result->item_id);
-        g_assert(item != NULL);
+        MockedItem *item = existing_result;
 
         g_free(item->display_name);
         item->display_name = g_strdup(display_name);
 
         g_free(item->secret);
         item->secret = g_strdup(secret);
-
-        if (item_id != NULL)
-            *item_id = item->id;
     } else {
         MockedItem *item =
-            mocked_item_new(type, display_name, attributes, secret);
-        if (item_id != NULL)
-            *item_id = item->id;
+            mocked_item_new(schema, display_name, attributes, secret);
 
         mocked_keyring->items = g_list_prepend(mocked_keyring->items,
                                                item);
     }
-    return GNOME_KEYRING_RESULT_OK;
-}
-
-GnomeKeyringResult
-gnome_keyring_find_items_sync(GnomeKeyringItemType type,
-                              GnomeKeyringAttributeList *attributes,
-                              GList **found)
+
+    g_hash_table_unref(attributes);
+    return TRUE;
+}
+
+gchar *
+secret_password_lookup_sync(const SecretSchema *schema,
+                            G_GNUC_UNUSED GCancellable *cancellable,
+                            GError **error,
+                            ...)
+{
+    MockedItem *item;
+    GHashTable *attributes;
+    GList *found;
+    va_list va;
+
+    g_return_val_if_fail (schema != NULL, FALSE);
+    g_debug("%s", G_STRFUNC);
+
+    va_start (va, error);
+    attributes = secret_attributes_buildv (schema, va);
+    va_end (va);
+
+    found = find_items(schema, attributes);
+    item = (found != NULL) ? found->data : NULL;
+    g_list_free(found);
+
+    if (item) {
+        g_debug("Found: %s", item->secret);
+    } else {
+        g_debug("Item not found");
+    }
+    return item ? g_strdup(item->secret) : NULL;
+}
+
+gboolean
+secret_password_clearv_sync(const SecretSchema* schema,
+                            GHashTable *attributes,
+                            G_GNUC_UNUSED GCancellable *cancellable,
+                            G_GNUC_UNUSED GError **error)
 {
     GHashTableIter iter;
     const gchar *keyring_name;
     MockedKeyring *keyring;
-    GList *results = NULL;
+    gboolean found = FALSE;
 
-    g_return_val_if_fail (type < GNOME_KEYRING_ITEM_LAST_TYPE,
-                          GNOME_KEYRING_RESULT_BAD_ARGUMENTS);
+    g_return_val_if_fail (schema != NULL, FALSE);
+    g_debug("%s", G_STRFUNC);
 
     g_hash_table_iter_init(&iter, keyrings);
     while (g_hash_table_iter_next(&iter,
                                   (gpointer)&keyring_name,
                                   (gpointer)&keyring)) {
-        GList *list;
+        GList *list, *next;
 
-        for (list = keyring->items; list != NULL; list = g_list_next(list)) {
-            GnomeKeyringFound *found;
+        for (list = keyring->items; list != NULL; list = next) {
             MockedItem *item = list->data;
-            if (item->type != type) continue;
+            next = g_list_next(list);
+            if (item->schema != schema) continue;
 
             if (!mocked_item_has_attributes(item, attributes)) continue;
 
-            found = g_slice_new0(GnomeKeyringFound);
-            found->keyring = g_strdup(keyring_name);
-            found->item_id = item->id;
-            found->attributes =
-                gnome_keyring_attribute_list_copy(item->attributes);
-            found->secret = g_strdup(item->secret);
-            results = g_list_prepend(results, found);
+            g_debug("Found item!");
+            mocked_item_free(item);
+            keyring->items = g_list_delete_link(keyring->items, list);
+            found = TRUE;
         }
     }
-
-    *found = results;
-    return results != NULL ?
-        GNOME_KEYRING_RESULT_OK : GNOME_KEYRING_RESULT_NO_MATCH;
-}
-
-void
-gnome_keyring_found_free(GnomeKeyringFound *found)
-{
-    g_free(found->keyring);
-    gnome_keyring_attribute_list_free(found->attributes);
-    g_free(found->secret);
-    g_slice_free(GnomeKeyringFound, found);
-}
-
-GnomeKeyringResult
-gnome_keyring_item_get_info_sync(const char *keyring,
-                                 guint32 id,
-                                 GnomeKeyringItemInfo **info)
-{
-    GnomeKeyringItemInfo *result;
-    MockedKeyring *mocked_keyring;
-    MockedItem *item;
-
-    g_return_val_if_fail (keyring != NULL,
-                          GNOME_KEYRING_RESULT_BAD_ARGUMENTS);
-
-    mocked_keyring = g_hash_table_lookup (keyrings, keyring);
-    if (G_UNLIKELY (mocked_keyring == NULL))
-        return GNOME_KEYRING_RESULT_NO_SUCH_KEYRING;
-
-    item = mocked_keyring_get_item(mocked_keyring, id);
-    if (item == NULL) return GNOME_KEYRING_RESULT_NO_MATCH;
-
-    result = gnome_keyring_item_info_new();
-    gnome_keyring_item_info_set_type(result, item->type);
-    gnome_keyring_item_info_set_display_name(result, item->display_name);
-    gnome_keyring_item_info_set_secret(result, item->secret);
-    *info = result;
-    return GNOME_KEYRING_RESULT_OK;
-}
-
-GnomeKeyringResult
-gnome_keyring_item_delete_sync(const char *keyring,
-                               guint32 item_id)
-{
-    MockedKeyring *mocked_keyring;
-    MockedItem *item;
-    GList *list;
-
-    g_return_val_if_fail (keyring != NULL,
-                          GNOME_KEYRING_RESULT_BAD_ARGUMENTS);
-
-    mocked_keyring = g_hash_table_lookup (keyrings, keyring);
-    if (G_UNLIKELY (mocked_keyring == NULL))
-        return GNOME_KEYRING_RESULT_NO_SUCH_KEYRING;
-
-    for (list = mocked_keyring->items;
-         list != NULL;
-         list = g_list_next(list)) {
-        item = list->data;
-        if (item->id == item_id) break;
-    }
-
-    if (list == NULL) return GNOME_KEYRING_RESULT_NO_MATCH;
-    mocked_item_free(item);
-    mocked_keyring->items = g_list_delete_link(mocked_keyring->items, list);
-    return GNOME_KEYRING_RESULT_OK;
+    return found;
 }

=== modified file 'tests/tests.pro'
--- tests/tests.pro	2012-12-05 16:16:14 +0000
+++ tests/tests.pro	2013-06-25 07:19:28 +0000
@@ -15,7 +15,7 @@
 
 PKGCONFIG += \
     SignOnExtension \
-    gnome-keyring-1
+    libsecret-1
 
 HEADERS = \
     keyring-test.h