← Back to branch summary

~noskcaj/ubuntu/vivid/gnome-keyring/3.15.90

« back to all changes in this revision

Viewing changes to pkcs11/secret-store/tests/unit-test-secret-search.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach
  • Date: 2012-05-14 22:13:02 UTC
  • mfrom: (1.3.1)
  • mto: (80.2.8 experimental) (1.1.77)
  • mto: This revision was merged to the branch mainline in revision 148.
  • Revision ID: package-import@ubuntu.com-20120514221302-0l3gjmqpe6xopond
Import upstream version 3.4.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
pkcs11/secret-store/tests/unit-test-secret-search.c
1
 
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2
 
/* unit-test-secret-collection.c: Test the collection keyring
3
 
 
4
 
   Copyright (C) 2009 Stefan Walter
5
 
 
6
 
   The Gnome Keyring Library is free software; you can redistribute it and/or
7
 
   modify it under the terms of the GNU Library General Public License as
8
 
   published by the Free Software Foundation; either version 2 of the
9
 
   License, or (at your option) any later version.
10
 
 
11
 
   The Gnome Keyring Library is distributed in the hope that it will be useful,
12
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 
   Library General Public License for more details.
15
 
 
16
 
   You should have received a copy of the GNU Library General Public
17
 
   License along with the Gnome Library; see the file COPYING.LIB.  If not,
18
 
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19
 
   Boston, MA 02111-1307, USA.
20
 
 
21
 
   Author: Stef Walter <stef@memberwebs.com>
22
 
*/
23
 
 
24
 
#include "config.h"
25
 
 
26
 
#include "test-suite.h"
27
 
#include "test-secret-module.h"
28
 
 
29
 
#include "gkm-secret-collection.h"
30
 
#include "gkm-secret-fields.h"
31
 
#include "gkm-secret-item.h"
32
 
#include "gkm-secret-search.h"
33
 
 
34
 
#include "gkm/gkm-session.h"
35
 
#include "gkm/gkm-transaction.h"
36
 
 
37
 
#include "pkcs11/pkcs11i.h"
38
 
 
39
 
#include <glib.h>
40
 
 
41
 
#include <stdlib.h>
42
 
#include <stdio.h>
43
 
#include <string.h>
44
 
 
45
 
static GkmModule *module = NULL;
46
 
static GkmSession *session = NULL;
47
 
static GkmFactory *factory = NULL;
48
 
static GkmSecretCollection *collection = NULL;
49
 
static GkmSecretItem *item = NULL;
50
 
 
51
 
TESTING_SETUP(secret_search)
52
 
{
53
 
        GHashTable *fields;
54
 
 
55
 
        module = test_secret_module_initialize_and_enter ();
56
 
        session = test_secret_module_open_session (TRUE);
57
 
        factory = GKM_FACTORY_SECRET_SEARCH;
58
 
        g_assert (factory);
59
 
 
60
 
        collection = g_object_new (GKM_TYPE_SECRET_COLLECTION,
61
 
                                   "module", module,
62
 
                                   "manager", gkm_session_get_manager (session),
63
 
                                   "identifier", "test-collection",
64
 
                                   NULL);
65
 
 
66
 
        /* Create an item */
67
 
        item = gkm_secret_collection_new_item (collection, "test-item");
68
 
        fields = gkm_secret_fields_new ();
69
 
        gkm_secret_fields_add (fields, "name1", "value1");
70
 
        gkm_secret_fields_add (fields, "name2", "value2");
71
 
        gkm_secret_item_set_fields (item, fields);
72
 
        g_hash_table_unref (fields);
73
 
 
74
 
        gkm_object_expose (GKM_OBJECT (collection), TRUE);
75
 
}
76
 
 
77
 
TESTING_TEARDOWN(secret_search)
78
 
{
79
 
        g_object_unref (collection);
80
 
 
81
 
        test_secret_module_leave_and_finalize ();
82
 
        module = NULL;
83
 
        session = NULL;
84
 
}
85
 
 
86
 
TESTING_TEST(create_search_incomplete)
87
 
{
88
 
        CK_ATTRIBUTE attrs[1];
89
 
        GkmObject *object = NULL;
90
 
        GkmTransaction *transaction = gkm_transaction_new ();
91
 
 
92
 
        object = gkm_session_create_object_for_factory (session, factory, transaction, attrs, 0);
93
 
        g_assert (gkm_transaction_complete_and_unref (transaction) == CKR_TEMPLATE_INCOMPLETE);
94
 
        g_assert (object == NULL);
95
 
}
96
 
 
97
 
TESTING_TEST(create_search_bad_fields)
98
 
{
99
 
        CK_ATTRIBUTE attrs[] = {
100
 
                { CKA_G_FIELDS, "bad-value", 9 },
101
 
        };
102
 
 
103
 
        GkmObject *object = NULL;
104
 
        GkmTransaction *transaction = gkm_transaction_new ();
105
 
 
106
 
        object = gkm_session_create_object_for_factory (session, factory, transaction, attrs, 1);
107
 
        g_assert (gkm_transaction_complete_and_unref (transaction) == CKR_ATTRIBUTE_VALUE_INVALID);
108
 
        g_assert (object == NULL);
109
 
}
110
 
 
111
 
TESTING_TEST(create_search)
112
 
{
113
 
        CK_ATTRIBUTE attrs[] = {
114
 
                { CKA_G_FIELDS, "test\0value\0two\0value2", 22 },
115
 
        };
116
 
 
117
 
        const gchar *identifier;
118
 
        GkmObject *object = NULL;
119
 
        GHashTable *fields;
120
 
        gpointer vdata;
121
 
        gulong vulong;
122
 
        gboolean vbool;
123
 
        gsize vsize;
124
 
 
125
 
        object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
126
 
        g_assert (object != NULL);
127
 
        g_assert (GKM_IS_SECRET_SEARCH (object));
128
 
 
129
 
        if (!gkm_object_get_attribute_ulong (object, session, CKA_CLASS, &vulong))
130
 
                g_assert_not_reached ();
131
 
        g_assert (vulong == CKO_G_SEARCH);
132
 
 
133
 
        if (!gkm_object_get_attribute_boolean (object, session, CKA_MODIFIABLE, &vbool))
134
 
                g_assert_not_reached ();
135
 
        g_assert (vbool == CK_TRUE);
136
 
 
137
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_FIELDS, &vsize);
138
 
        g_assert (vdata);
139
 
        g_assert (vsize == attrs[0].ulValueLen);
140
 
        g_free (vdata);
141
 
 
142
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_COLLECTION, &vsize);
143
 
        g_assert (vdata);
144
 
        g_assert (vsize == 0);
145
 
        g_free (vdata);
146
 
 
147
 
        /* No objects matched */
148
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
149
 
        g_assert (vdata);
150
 
        g_assert (vsize == 0);
151
 
        g_free (vdata);
152
 
 
153
 
        /* Get the fields object and check */
154
 
        fields = gkm_secret_search_get_fields (GKM_SECRET_SEARCH (object));
155
 
        g_assert (fields);
156
 
        g_assert_cmpstr (gkm_secret_fields_get (fields, "test"), ==, "value");
157
 
 
158
 
        /* No collection */
159
 
        identifier = gkm_secret_search_get_collection_id (GKM_SECRET_SEARCH (object));
160
 
        g_assert (identifier == NULL);
161
 
 
162
 
        g_object_unref (object);
163
 
}
164
 
 
165
 
TESTING_TEST(create_search_and_match)
166
 
{
167
 
        CK_ATTRIBUTE attrs[] = {
168
 
                { CKA_G_FIELDS, "name1\0value1\0name2\0value2", 26 },
169
 
        };
170
 
 
171
 
        GkmObject *object = NULL;
172
 
        gpointer vdata;
173
 
        gsize vsize;
174
 
 
175
 
        object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
176
 
        g_assert (object != NULL);
177
 
        g_assert (GKM_IS_SECRET_SEARCH (object));
178
 
 
179
 
        /* One object matched */
180
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
181
 
        g_assert (vdata);
182
 
        g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
183
 
        g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
184
 
        g_free (vdata);
185
 
 
186
 
        g_object_unref (object);
187
 
}
188
 
 
189
 
TESTING_TEST(create_search_and_change_to_match)
190
 
{
191
 
        CK_ATTRIBUTE attrs[] = {
192
 
                { CKA_G_FIELDS, "name1\0value1", 13 },
193
 
        };
194
 
 
195
 
        GkmObject *object = NULL;
196
 
        GHashTable *fields;
197
 
        gpointer vdata;
198
 
        gsize vsize;
199
 
 
200
 
        /* Make it not match */
201
 
        fields = gkm_secret_fields_new ();
202
 
        gkm_secret_item_set_fields (item, fields);
203
 
        g_hash_table_unref (fields);
204
 
 
205
 
        object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
206
 
        g_assert (object != NULL);
207
 
        g_assert (GKM_IS_SECRET_SEARCH (object));
208
 
 
209
 
        /* Nothing matched */
210
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
211
 
        g_assert (vsize == 0);
212
 
        g_free (vdata);
213
 
 
214
 
        /* Make it match */
215
 
        fields = gkm_secret_fields_new ();
216
 
        gkm_secret_fields_add (fields, "name1", "value1");
217
 
        gkm_secret_fields_add (fields, "name2", "value2");
218
 
        gkm_secret_item_set_fields (item, fields);
219
 
        g_hash_table_unref (fields);
220
 
 
221
 
        /* One object matched */
222
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
223
 
        g_assert (vdata);
224
 
        g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
225
 
        g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
226
 
        g_free (vdata);
227
 
 
228
 
        g_object_unref (object);
229
 
}
230
 
 
231
 
TESTING_TEST(create_search_and_change_to_not_match)
232
 
{
233
 
        CK_ATTRIBUTE attrs[] = {
234
 
                { CKA_G_FIELDS, "name1\0value1", 13 },
235
 
        };
236
 
 
237
 
        GkmObject *object = NULL;
238
 
        GHashTable *fields;
239
 
        gpointer vdata;
240
 
        gsize vsize;
241
 
 
242
 
        object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 1);
243
 
        g_assert (object != NULL);
244
 
        g_assert (GKM_IS_SECRET_SEARCH (object));
245
 
 
246
 
        /* One object matched */
247
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
248
 
        g_assert (vdata);
249
 
        g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
250
 
        g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
251
 
        g_free (vdata);
252
 
 
253
 
        /* Make it not match */
254
 
        fields = gkm_secret_fields_new ();
255
 
        gkm_secret_item_set_fields (item, fields);
256
 
        g_hash_table_unref (fields);
257
 
 
258
 
        /* Nothing matched */
259
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
260
 
        g_assert (vsize == 0);
261
 
        g_free (vdata);
262
 
 
263
 
        g_object_unref (object);
264
 
}
265
 
 
266
 
TESTING_TEST(create_search_for_bad_collection)
267
 
{
268
 
        CK_ATTRIBUTE attrs[] = {
269
 
                { CKA_G_FIELDS, "name1\0value1", 13 },
270
 
                { CKA_G_COLLECTION, "bad-collection", 14 },
271
 
        };
272
 
 
273
 
        GkmObject *object = NULL;
274
 
        GkmTransaction *transaction = gkm_transaction_new ();
275
 
 
276
 
        object = gkm_session_create_object_for_factory (session, factory, transaction, attrs, 2);
277
 
        g_assert (gkm_transaction_complete_and_unref (transaction) == CKR_OK);
278
 
 
279
 
        g_object_unref (object);
280
 
}
281
 
 
282
 
TESTING_TEST(create_search_for_collection)
283
 
{
284
 
        CK_ATTRIBUTE attrs[] = {
285
 
                { CKA_G_FIELDS, "name1\0value1", 13 },
286
 
                { CKA_G_COLLECTION, "test-collection", 15 },
287
 
        };
288
 
 
289
 
        GkmObject *object = NULL;
290
 
        gpointer vdata;
291
 
        gsize vsize;
292
 
 
293
 
        object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 2);
294
 
        g_assert (object != NULL);
295
 
        g_assert (GKM_IS_SECRET_SEARCH (object));
296
 
 
297
 
        /* Should have the collection set properly */
298
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_COLLECTION , &vsize);
299
 
        g_assert (vdata);
300
 
        g_assert (vsize == 15);
301
 
        g_assert (memcmp (vdata, "test-collection", 15) == 0);
302
 
        g_free (vdata);
303
 
 
304
 
        /* One object matched */
305
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
306
 
        g_assert (vdata);
307
 
        g_assert (vsize == sizeof (CK_OBJECT_HANDLE));
308
 
        g_assert (*((CK_OBJECT_HANDLE_PTR)vdata) == gkm_object_get_handle (GKM_OBJECT (item)));
309
 
        g_free (vdata);
310
 
 
311
 
        g_object_unref (object);
312
 
}
313
 
 
314
 
TESTING_TEST(create_search_for_collection_no_match)
315
 
{
316
 
        CK_ATTRIBUTE attrs[] = {
317
 
                { CKA_G_FIELDS, "test\0value", 11 },
318
 
                { CKA_G_COLLECTION, "test-collection", 15 },
319
 
        };
320
 
 
321
 
        GkmObject *object = NULL;
322
 
        GkmSecretCollection *ocoll;
323
 
        GkmSecretItem *oitem;
324
 
        GHashTable *fields;
325
 
        gpointer vdata;
326
 
        gsize vsize;
327
 
 
328
 
        ocoll = g_object_new (GKM_TYPE_SECRET_COLLECTION,
329
 
                              "module", module,
330
 
                              "manager", gkm_session_get_manager (session),
331
 
                              "identifier", "other-collection",
332
 
                              NULL);
333
 
        oitem = gkm_secret_collection_new_item (ocoll, "other-item");
334
 
        gkm_object_expose (GKM_OBJECT (ocoll), TRUE);
335
 
 
336
 
        /* Make it match, but remember, wrong collection*/
337
 
        fields = gkm_secret_fields_new ();
338
 
        gkm_secret_fields_add (fields, "test", "value");
339
 
        gkm_secret_item_set_fields (oitem, fields);
340
 
        g_hash_table_unref (fields);
341
 
 
342
 
        object = gkm_session_create_object_for_factory (session, factory, NULL, attrs, 2);
343
 
        g_assert (object != NULL);
344
 
        g_assert (GKM_IS_SECRET_SEARCH (object));
345
 
 
346
 
        /* No objects matched */
347
 
        vdata = gkm_object_get_attribute_data (object, session, CKA_G_MATCHED, &vsize);
348
 
        g_assert (vsize == 0);
349
 
        g_free (vdata);
350
 
 
351
 
        g_object_unref (object);
352
 
        g_object_unref (ocoll);
353
 
}