test/db/dbtest.c

   1 /* vi: set et sw=4 ts=4 cino=t0,(0: */
   2 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   3 /*
   4  * This file is part of gsignond
   5  *
   6  * Copyright (C) 2012 Intel Corporation.
   7  *
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  22  * 02110-1301 USA
  23  */
  24
  25 #include <check.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sqlite3.h>
  29 #include <glib/gstdio.h>
  30
  31 #include "gsignond/gsignond-config.h"
  32 #include "gsignond/gsignond-log.h"
  33 #include "gsignond/gsignond-credentials.h"
  34 #include "gsignond/gsignond-secret-storage.h"
  35 #include "common/db/gsignond-db-error.h"
  36 #include "common/db/gsignond-db-secret-database.h"
  37 #include "common/db/gsignond-db-sql-database.h"
  38 #include "daemon/gsignond-daemon.h"
  39 #include "daemon/db/gsignond-db-metadata-database.h"
  40 #include "daemon/db/gsignond-db-credentials-database.h"
  41
  42 static GSequence*
  43 _sequence_new (gchar *data)
  44 {
  45     GSequence *value = NULL;
  46     value = g_sequence_new (NULL);
  47     g_sequence_append (value, (guint8 *)data);
  48     return value;
  49 }
  50
  51 typedef struct {
  52     GHashTable *table;
  53     int status;
  54 } Data;
  55
  56 static void
  57 _compare_key_value(
  58         gchar *key,
  59         GVariant *value,
  60         Data *user_data)
  61 {
  62     GVariant *value2 = (GVariant *)g_hash_table_lookup (user_data->table, key);
  63
  64     if (value2 && g_variant_get_size (value) == g_variant_get_size (value2)
  65                && memcmp (g_variant_get_data(value2),
  66                           g_variant_get_data(value),
  67                           g_variant_get_size(value2)) == 0
  68                && g_variant_is_of_type(value2, g_variant_get_type (value)))  {
  69         return;
  70     }
  71     user_data->status = 0;
  72 }
  73
  74 static GSignondIdentityInfo *
  75 _get_filled_identity_info_2 (
  76         GSignondIdentityInfo **identity_inp,
  77         gboolean add_creds,
  78         gboolean add_methods,
  79         gboolean add_realms,
  80         gboolean add_acl,
  81         gboolean add_owner)
  82 {
  83     guint32 type = 456;
  84     const gchar *username = "username1";
  85     const gchar *secret = "secret1";
  86     const gchar *caption = "caption1";
  87     GSignondIdentityInfo *identity = NULL;
  88     GSignondSecurityContextList *ctx_list = NULL;
  89     GSignondSecurityContext *ctx1, *ctx2, *ctx3 ;
  90     GHashTable *methods = NULL;
  91     GSequence *seq1 = NULL, *seq_realms;
  92     identity = *identity_inp;
  93
  94     if (identity == NULL)
  95         identity = gsignond_identity_info_new ();
  96     gsignond_identity_info_set_identity_new (identity);
  97     gsignond_identity_info_set_secret (identity, secret);
  98     gsignond_identity_info_set_store_secret (identity, TRUE);
  99     if (add_creds) {
 100         gsignond_identity_info_set_username (identity, username);
 101         gsignond_identity_info_set_username_secret (identity, TRUE);
 102         gsignond_identity_info_set_caption (identity, caption);
 103     }
 104
 105     /*realms*/
 106     if (add_realms) {
 107         seq_realms = _sequence_new("realms1");
 108         gsignond_identity_info_set_realms (identity, seq_realms);
 109         g_sequence_free (seq_realms);
 110     }
 111
 112     /*methods*/
 113     if (add_methods) {
 114         methods = g_hash_table_new_full ((GHashFunc)g_str_hash,
 115                 (GEqualFunc)g_str_equal,
 116                 (GDestroyNotify)NULL,
 117                 (GDestroyNotify)g_sequence_free);
 118         seq1 = _sequence_new("mech11"); g_sequence_append (seq1, "mech12");
 119         g_hash_table_insert (methods, "method1", seq1);
 120         g_hash_table_insert (methods, "method2", _sequence_new("mech21"));
 121         g_hash_table_insert (methods, "method3", _sequence_new("mech31"));
 122         gsignond_identity_info_set_methods (identity, methods);
 123         g_hash_table_unref (methods);
 124     }
 125
 126     /*acl*/
 127     ctx1 = gsignond_security_context_new_from_values ("sysctx1", "appctx1");
 128     ctx2 = gsignond_security_context_new_from_values ("sysctx2", "appctx2");
 129     ctx3 = gsignond_security_context_new_from_values ("sysctx3", "appctx3");
 130     ctx_list = g_list_append (ctx_list,ctx1);
 131     ctx_list = g_list_append (ctx_list,ctx2);
 132     ctx_list = g_list_append (ctx_list,ctx3);
 133     if (add_acl) {
 134         gsignond_identity_info_set_access_control_list (identity, ctx_list);
 135     }
 136
 137     /*owners*/
 138     if (add_owner) {
 139         gsignond_identity_info_set_owner (identity, ctx1);
 140     }
 141     gsignond_security_context_list_free (ctx_list);
 142
 143     gsignond_identity_info_set_validated (identity, FALSE);
 144     gsignond_identity_info_set_identity_type (identity, type);
 145     return identity;
 146 }
 147
 148 static GSignondIdentityInfo *
 149 _get_filled_identity_info (void)
 150 {
 151     GSignondIdentityInfo *identity = NULL;
 152     return _get_filled_identity_info_2 (&identity,
 153             TRUE, TRUE, TRUE, TRUE, TRUE);
 154 }
 155
 156 static gboolean
 157 _gsignond_query_read_int (
 158         sqlite3_stmt *stmt,
 159         gint *status)
 160 {
 161     *status = sqlite3_column_int (stmt, 0);
 162     return TRUE;
 163 }
 164 static gboolean
 165 _gsignond_query_read_string (
 166         sqlite3_stmt *stmt,
 167         gint *status)
 168 {
 169     const gchar* str = NULL;
 170     *status = 0;
 171     str = (const gchar *)sqlite3_column_text (stmt, 0);
 172     if (str && strlen(str) > 0 &&
 173         g_strcmp0 (str, "username1") == 0) {
 174         *status = 1;
 175     }
 176     return TRUE;
 177 }
 178
 179 START_TEST (test_sql_database)
 180 {
 181     GSignondDbSecretDatabase *database = NULL;
 182     gchar *filename = NULL;
 183     const gchar *dir = NULL;
 184     GSignondCredentials *creds = NULL;
 185     guint32 id = 1, method = 2;
 186     GHashTable *data = NULL;
 187     GSignondDictionary *data2 = NULL;
 188     Data input;
 189     sqlite3_stmt *stmt = NULL;
 190     gint status=0;
 191     GList *list = NULL;
 192     GHashTable* hashtable = NULL;
 193     GArray *array = NULL;
 194     GSignondDbSqlDatabase *sqldb = NULL;
 195     GError *error = NULL;
 196
 197     /* Secret Storage */
 198     database = gsignond_db_secret_database_new ();
 199     fail_if (database == NULL);
 200     sqldb = GSIGNOND_DB_SQL_DATABASE (database);
 201
 202     fail_unless (gsignond_db_sql_database_clear (sqldb) == FALSE);
 203     fail_unless (gsignond_db_sql_database_is_open (sqldb) == FALSE);
 204     fail_unless (gsignond_db_secret_database_load_credentials (
 205             database, 1) == NULL);
 206     fail_unless (gsignond_db_secret_database_update_credentials (
 207             database, NULL) == FALSE);
 208     fail_unless (gsignond_db_secret_database_remove_credentials (
 209             database, 1) == FALSE);
 210     fail_unless (gsignond_db_secret_database_load_data (
 211             database, 1, 2) == NULL);
 212     fail_unless (gsignond_db_secret_database_update_data (
 213             database, 1, 2, NULL) == FALSE);
 214     fail_unless (gsignond_db_secret_database_remove_data (
 215             database, 1, 2) == FALSE);
 216
 217     dir = "/tmp/gsignond";
 218     g_mkdir_with_parents (dir, S_IRWXU);
 219     filename = g_build_filename (dir, "sql_db_test.db", NULL);
 220     fail_unless (gsignond_db_sql_database_open (sqldb, filename,
 221             SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE) == TRUE);
 222     /* don't open the db again if its already open */
 223     fail_unless (gsignond_db_sql_database_open (sqldb, filename,
 224             SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE) == TRUE);
 225     g_free (filename);
 226
 227     creds = gsignond_credentials_new ();
 228     fail_if (creds == NULL);
 229
 230     fail_unless (gsignond_credentials_set_data (
 231             creds, id, "user 1", "pass 1") == TRUE);
 232
 233     fail_unless (gsignond_db_secret_database_update_credentials (
 234             database, creds) == TRUE);
 235     g_object_unref (creds); creds = NULL;
 236
 237     creds = gsignond_db_secret_database_load_credentials (database, id);
 238     fail_if (creds == NULL);
 239     g_object_unref (creds);
 240
 241     /* remove the added credentials */
 242     fail_unless (gsignond_db_secret_database_remove_credentials (
 243             database, id) == TRUE);
 244
 245     /* add data to store */
 246     data = g_hash_table_new_full ((GHashFunc)g_str_hash,
 247             (GEqualFunc)g_str_equal,
 248             (GDestroyNotify)NULL,
 249             (GDestroyNotify)g_variant_unref);
 250     fail_if (data == NULL);
 251
 252     GVariantBuilder builder;
 253     g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
 254     g_variant_builder_add (&builder, "{sv}", "key1", g_variant_new_string ("string_value"));
 255     g_variant_builder_add (&builder, "{sv}", "key2",g_variant_new_double (12223.4223));
 256     g_variant_builder_add (&builder, "{sv}", "key3",g_variant_new_uint16(20));
 257     g_variant_builder_add (&builder, "{sv}", "key4",g_variant_new("^ay", "byte_value"));
 258
 259     g_hash_table_insert (data, "dummy_client_id", g_variant_builder_end (&builder));
 260
 261     fail_unless (gsignond_db_secret_database_update_data (
 262             database, id, method, data) == TRUE);
 263     data2 = gsignond_db_secret_database_load_data (database, id, method);
 264     fail_if (data2 == NULL);
 265     input.table = data;
 266     input.status = 1;
 267     g_hash_table_foreach (data2, (GHFunc)_compare_key_value, &input);
 268     fail_if (input.status != 1);
 269
 270     gsignond_dictionary_unref (data2);
 271     g_hash_table_unref(data);
 272
 273
 274     /*sql database tests*/
 275     fail_unless (gsignond_db_sql_database_clear (sqldb) == TRUE);
 276     stmt = gsignond_db_sql_database_prepare_statement (
 277             sqldb, "INSERT INTO CREDENTIALS "
 278             "(id, username, password) VALUES (1, \"username1\",\"password\");");
 279     fail_if (stmt == NULL);
 280     fail_unless (sqlite3_finalize (stmt) == SQLITE_OK); stmt = NULL;
 281
 282     fail_unless (gsignond_db_sql_database_exec (
 283             sqldb, "INSERT INTO CREDENTIALS (id, username, password) "
 284                     "VALUES (1, \"username1\",\"password\");") == TRUE);
 285
 286     fail_unless (gsignond_db_sql_database_exec (
 287             sqldb, "INSERT INTO CREDENTIALS (id, username, password) "
 288                     "VALUES (2, \"username2\",\"password2\");") == TRUE);
 289
 290     fail_unless (gsignond_db_sql_database_exec (
 291             sqldb, "SELECT id from CREDENTIALS limit 1;") == TRUE);
 292
 293     fail_unless (gsignond_db_sql_database_query_exec (
 294             sqldb, "SELECT id from CREDENTIALS limit 1;",
 295             (GSignondDbSqlDatabaseQueryCallback)_gsignond_query_read_int,
 296             &status) == 1);
 297     fail_unless (status == 1);
 298
 299     fail_unless (gsignond_db_sql_database_query_exec (
 300             sqldb, "SELECT username from CREDENTIALS where id=1;",
 301             (GSignondDbSqlDatabaseQueryCallback)_gsignond_query_read_string,
 302             &status) == 1);
 303     fail_unless (status == 1);
 304
 305     list = gsignond_db_sql_database_query_exec_string_list (
 306             sqldb, "SELECT username from CREDENTIALS;");
 307     fail_if (list == NULL);
 308     fail_unless (g_list_length (list) == 2);
 309     g_list_free_full (list, g_free);
 310
 311     hashtable = gsignond_db_sql_database_query_exec_string_tuple (
 312             sqldb, "SELECT username, password from CREDENTIALS;");
 313     fail_if (hashtable == NULL);
 314     fail_unless (g_hash_table_size (hashtable) == 2);
 315     g_hash_table_unref (hashtable);
 316
 317     hashtable = gsignond_db_sql_database_query_exec_int_string_tuple (
 318             sqldb, "SELECT id, username from CREDENTIALS "
 319                         "where password=\"password2\";");
 320     fail_if (hashtable == NULL);
 321     fail_unless (g_hash_table_size (hashtable) == 1);
 322     g_hash_table_unref (hashtable);
 323
 324     fail_unless (gsignond_db_sql_database_query_exec_int (
 325             sqldb,"SELECT id from CREDENTIALS where username=\"username2\";",
 326             &status) == TRUE);
 327     fail_unless (status == 2);
 328
 329     array = gsignond_db_sql_database_query_exec_int_array (
 330             sqldb,"SELECT id from CREDENTIALS;");
 331     fail_if (array == NULL);
 332     fail_unless (array->len == 2);
 333     g_array_free (array, TRUE);
 334
 335     stmt = gsignond_db_sql_database_prepare_statement (
 336             sqldb, "SELECT id from CREDENTIALS where username=\"username1\";");
 337     fail_if (stmt == NULL);
 338     fail_unless (gsignond_db_sql_database_query_exec_stmt (
 339             sqldb, stmt, NULL, NULL) == 1);
 340     stmt = NULL;
 341
 342     fail_unless (gsignond_db_sql_database_start_transaction (sqldb) == TRUE);
 343     fail_unless (gsignond_db_sql_database_commit_transaction (sqldb) == TRUE);
 344     fail_unless (gsignond_db_sql_database_start_transaction (sqldb) == TRUE);
 345     fail_unless (gsignond_db_sql_database_rollback_transaction (sqldb) == TRUE);
 346     fail_unless (gsignond_db_sql_database_start_transaction (sqldb) == TRUE);
 347     fail_unless (gsignond_db_sql_database_start_transaction (sqldb) == FALSE);
 348     fail_unless (gsignond_db_sql_database_rollback_transaction (sqldb) == TRUE);
 349
 350     fail_unless (gsignond_db_sql_database_transaction_exec (
 351             sqldb, "SELECT id from CREDENTIALS "
 352                    "where username=\"username1\";") == TRUE);
 353
 354     fail_unless (gsignond_db_sql_database_get_db_version (
 355             sqldb, "PRAGMA user_version;") == 1);
 356
 357     error = gsignond_db_create_error(GSIGNOND_DB_ERROR_UNKNOWN,"Unknown error");
 358     gsignond_db_sql_database_clear_last_error (sqldb);
 359     fail_unless (gsignond_db_sql_database_get_last_error (sqldb) == NULL);
 360     gsignond_db_sql_database_set_last_error (sqldb, error);
 361     fail_unless (gsignond_db_sql_database_get_last_error (sqldb) != NULL);
 362     gsignond_db_sql_database_clear_last_error (sqldb);
 363     fail_unless (gsignond_db_sql_database_get_last_error (sqldb) == NULL);
 364
 365     fail_unless (gsignond_db_sql_database_exec (
 366             sqldb, "INSERT INTO CREDENTIALS (id, username, password) "
 367                     "VALUES (4, \"username4\",\"password3\");") == TRUE);
 368     fail_unless (gsignond_db_sql_database_get_last_insert_rowid (
 369             sqldb) == 4);
 370
 371     fail_unless (gsignond_db_secret_database_remove_data (
 372             database, id, method) == TRUE);
 373     fail_unless (gsignond_db_sql_database_clear (sqldb) == TRUE);
 374     fail_unless (gsignond_db_sql_database_close (sqldb) == TRUE);
 375     g_object_unref(database);
 376 }
 377 END_TEST
 378
 379 START_TEST (test_secret_storage)
 380 {
 381     GSignondSecretStorage *storage = NULL;
 382     GSignondConfig *config = NULL;
 383     GSignondCredentials *creds = NULL;
 384     guint32 id = 1, method = 2;
 385     GHashTable *data = NULL;
 386     GHashTable *data2 = NULL;
 387     Data input;
 388     const gchar *dir = NULL;
 389
 390     config = gsignond_config_new ();
 391     gsignond_config_set_string (config, GSIGNOND_CONFIG_GENERAL_SECURE_DIR, "/tmp/gsignond");
 392
 393     /* Secret Storage */
 394     storage = g_object_new (GSIGNOND_TYPE_SECRET_STORAGE,
 395             "config", config, NULL);
 396     g_object_unref(config);
 397     fail_if (storage == NULL);
 398
 399     dir = gsignond_config_get_string (config,
 400             GSIGNOND_CONFIG_GENERAL_SECURE_DIR);
 401     if (!dir) {
 402         dir = g_get_user_data_dir ();
 403     }
 404     g_mkdir_with_parents (dir, S_IRWXU);
 405
 406     fail_unless (gsignond_secret_storage_get_last_error (storage) == NULL);
 407     fail_unless (gsignond_secret_storage_clear_db (storage) == FALSE);
 408     fail_unless (gsignond_secret_storage_is_open_db (storage) == FALSE);
 409     fail_unless (gsignond_secret_storage_load_credentials (storage, 1) == NULL);
 410     fail_unless (gsignond_secret_storage_update_credentials (
 411             storage, NULL) == FALSE);
 412     fail_unless (gsignond_secret_storage_remove_credentials (
 413             storage, 1) == FALSE);
 414     fail_unless (gsignond_secret_storage_load_data (
 415             storage, 1, 2) == NULL);
 416     fail_unless (gsignond_secret_storage_update_data (
 417             storage, 1, 2, NULL) == FALSE);
 418     fail_unless (gsignond_secret_storage_remove_data (
 419             storage, 1, 2) == FALSE);
 420
 421     fail_unless (gsignond_secret_storage_open_db (storage) == TRUE);
 422     /* don't open the db again if its already open */
 423     fail_unless (gsignond_secret_storage_open_db (storage) == TRUE);
 424
 425     creds = gsignond_credentials_new ();
 426     fail_if (creds == NULL);
 427
 428     fail_unless (gsignond_credentials_set_data (
 429             creds, id, "user 1", "pass 1") == TRUE);
 430
 431     fail_unless (gsignond_secret_storage_update_credentials (
 432             storage, creds) == TRUE);
 433     g_object_unref (creds); creds = NULL;
 434
 435     creds = gsignond_secret_storage_load_credentials (storage, id);
 436     fail_if (creds == NULL);
 437
 438     fail_unless (gsignond_secret_storage_check_credentials (
 439             storage, creds) == TRUE);
 440
 441     gsignond_credentials_set_id (creds, 3);
 442     fail_unless (gsignond_secret_storage_check_credentials (
 443             storage, creds) == FALSE);
 444     g_object_unref (creds);
 445
 446     /* remove the added credentials */
 447     fail_unless (gsignond_secret_storage_remove_credentials (
 448             storage, id) == TRUE);
 449
 450     /* add data to store */
 451     data = g_hash_table_new_full ((GHashFunc)g_str_hash,
 452             (GEqualFunc)g_str_equal,
 453             (GDestroyNotify)NULL,
 454             (GDestroyNotify)g_variant_unref);
 455     fail_if (data == NULL);
 456
 457     g_hash_table_insert (data,"key1",g_variant_new_string ("string_value"));
 458     g_hash_table_insert (data,"key2",g_variant_new_double (12223.4223));
 459     g_hash_table_insert (data,"key3",g_variant_new_uint16(20));
 460     g_hash_table_insert (data,"key4",g_variant_new("^ay", "byte_value"));
 461
 462     fail_unless (gsignond_secret_storage_update_data (
 463             storage, id, method, data) == TRUE);
 464     data2 = gsignond_secret_storage_load_data (storage, id, method);
 465     fail_if (data2 == NULL);
 466     input.table = data;
 467     input.status = 1;
 468     g_hash_table_foreach (data2, (GHFunc)_compare_key_value, &input);
 469     fail_if (input.status != 1);
 470
 471     gsignond_dictionary_unref(data2);
 472     g_hash_table_unref(data);
 473
 474     fail_unless (gsignond_secret_storage_remove_data (
 475             storage, id, method) == TRUE);
 476     fail_unless (gsignond_secret_storage_clear_db (storage) == TRUE);
 477     fail_unless (gsignond_secret_storage_close_db (storage) == TRUE);
 478     g_object_unref(storage);
 479 }
 480 END_TEST
 481
 482 START_TEST (test_metadata_database)
 483 {
 484     GSignondConfig *config = NULL;
 485     guint32 methodid = 0;
 486     guint32 identity_id = 5;
 487     const gchar *method1 = "method1";
 488     GSignondIdentityInfo *identity = NULL, *identity2= NULL;
 489     GSignondIdentityInfoList *identities = NULL;
 490     GSignondSecurityContext *ctx1 = NULL;
 491     GList *methods = NULL, *reflist = NULL;
 492     GSignondSecurityContextList *acl;
 493     GSignondSecurityContext *owner = NULL;
 494
 495     config = gsignond_config_new ();
 496     gsignond_config_set_string (config, GSIGNOND_CONFIG_GENERAL_SECURE_DIR, "/tmp/gsignond");
 497     GSignondDbMetadataDatabase* metadata_db = NULL;
 498     metadata_db = gsignond_db_metadata_database_new (config);
 499     g_object_unref(config);
 500     fail_if (metadata_db == NULL);
 501
 502     ctx1 = gsignond_security_context_new_from_values ("sysctx1", "appctx1");
 503     identity = _get_filled_identity_info_2 (&identity,
 504             FALSE, FALSE, FALSE, FALSE, FALSE);
 505     fail_unless (gsignond_db_metadata_database_insert_method (
 506             metadata_db, method1, &methodid) == FALSE);
 507     fail_unless (gsignond_db_metadata_database_get_method_id (
 508             metadata_db, method1) == 0);
 509     fail_unless (gsignond_db_metadata_database_get_methods (
 510             metadata_db, identity_id, ctx1) == NULL);
 511     fail_unless (gsignond_db_metadata_database_get_methods (
 512             metadata_db, identity_id, ctx1) == NULL);
 513     fail_unless (gsignond_db_metadata_database_update_identity (
 514             metadata_db, identity) == FALSE);
 515     fail_unless (gsignond_db_metadata_database_get_identity (
 516             metadata_db, identity_id) == NULL);
 517     fail_unless (gsignond_db_metadata_database_get_identities (
 518             metadata_db, NULL) == NULL);
 519     fail_unless (gsignond_db_metadata_database_remove_identity (
 520             metadata_db, identity_id) == FALSE);
 521     fail_unless (gsignond_db_metadata_database_remove_reference (
 522             metadata_db, identity_id, ctx1, "reference1") == FALSE);
 523     fail_unless (gsignond_db_metadata_database_get_references (
 524             metadata_db, identity_id, ctx1) == NULL);
 525     fail_unless (gsignond_db_metadata_database_get_accesscontrol_list (
 526             metadata_db, identity_id) == NULL);
 527     fail_unless (gsignond_db_metadata_database_get_owner (
 528             metadata_db, identity_id) == NULL);
 529
 530     fail_unless (gsignond_db_metadata_database_open (metadata_db) == TRUE);
 531
 532     fail_unless (gsignond_db_metadata_database_open (metadata_db) == TRUE);
 533
 534     fail_unless (gsignond_db_sql_database_clear (
 535             GSIGNOND_DB_SQL_DATABASE (metadata_db)) == TRUE);
 536
 537     fail_unless (gsignond_db_metadata_database_get_accesscontrol_list (
 538             metadata_db, identity_id) == NULL);
 539
 540     fail_unless (gsignond_db_metadata_database_get_owner (
 541             metadata_db, identity_id) == NULL);
 542
 543     fail_unless (gsignond_db_metadata_database_get_method_id (
 544             metadata_db, method1) == 0);
 545     fail_unless (gsignond_db_metadata_database_insert_method (
 546                         metadata_db, method1, &methodid) == TRUE);
 547
 548     fail_unless (methodid == gsignond_db_metadata_database_get_method_id (
 549             metadata_db, method1));
 550
 551     /*update_identity*/
 552     identity = _get_filled_identity_info_2 (&identity,
 553             TRUE, FALSE, FALSE, FALSE, FALSE);
 554     fail_unless (gsignond_db_metadata_database_update_identity (
 555             metadata_db, identity) == 0);
 556
 557     identity = _get_filled_identity_info_2 (&identity,
 558             FALSE, TRUE, FALSE, FALSE, FALSE);
 559     fail_unless (gsignond_db_metadata_database_update_identity (
 560             metadata_db, identity) == 0);
 561
 562     identity = _get_filled_identity_info_2 (&identity,
 563             FALSE, FALSE, TRUE, FALSE, FALSE);
 564     fail_unless (gsignond_db_metadata_database_update_identity (
 565             metadata_db, identity) == 0);
 566
 567     identity = _get_filled_identity_info_2 (&identity,
 568             FALSE, FALSE, FALSE, TRUE, FALSE);
 569     fail_unless (gsignond_db_metadata_database_update_identity (
 570             metadata_db, identity) == 0);
 571
 572     identity = _get_filled_identity_info_2 (&identity,
 573            FALSE, FALSE, FALSE, FALSE, TRUE);
 574     identity_id = gsignond_db_metadata_database_update_identity (
 575             metadata_db, identity);
 576     fail_unless (identity_id != 0);
 577     gsignond_identity_info_set_id (identity, identity_id);
 578
 579     identity2 = gsignond_db_metadata_database_get_identity (
 580             metadata_db, identity_id);
 581     fail_if (identity2 == NULL);
 582     gsignond_identity_info_unref (identity2);
 583
 584     /*get_identity/identities*/
 585     fail_unless (gsignond_db_metadata_database_get_identity (
 586             metadata_db, 2222) == NULL);
 587
 588     identities = gsignond_db_metadata_database_get_identities (metadata_db, NULL);
 589     fail_unless (identities != NULL);
 590     fail_unless (g_list_length (identities) == 1);
 591     gsignond_identity_info_list_free (identities);
 592
 593     /*methods*/
 594     methods = gsignond_db_metadata_database_get_methods (metadata_db,
 595                 identity_id, ctx1);
 596     fail_if (methods == NULL);
 597     g_list_free_full (methods, g_free);
 598
 599     /*references*/
 600     fail_unless (gsignond_db_metadata_database_get_references (
 601                 metadata_db, identity_id, ctx1) == NULL);
 602     fail_unless (gsignond_db_metadata_database_remove_reference (
 603             metadata_db, identity_id, ctx1, "reference1" ) == FALSE);
 604
 605     fail_unless (gsignond_db_metadata_database_insert_reference (
 606             metadata_db, identity_id, ctx1, "reference1") == TRUE);
 607
 608     fail_unless (gsignond_db_metadata_database_insert_reference (
 609             metadata_db, identity_id, ctx1, "reference1") == TRUE);
 610
 611     reflist = gsignond_db_metadata_database_get_references (
 612             metadata_db, identity_id, ctx1);
 613     fail_if (reflist == NULL);
 614     fail_unless (g_list_length (reflist) == 1);
 615     g_list_free_full (reflist, g_free);
 616
 617     fail_unless (gsignond_db_metadata_database_remove_reference (
 618             metadata_db, identity_id, ctx1, "reference1" ) == TRUE);
 619     gsignond_security_context_free (ctx1);
 620
 621     /*acl*/
 622     acl = gsignond_db_metadata_database_get_accesscontrol_list (metadata_db,
 623             identity_id);
 624     fail_if (acl == NULL);
 625     gsignond_security_context_list_free (acl);
 626
 627     /*owner*/
 628     owner = gsignond_db_metadata_database_get_owner (metadata_db,
 629             identity_id);
 630     fail_if (owner == NULL);
 631
 632     fail_unless (gsignond_db_metadata_database_remove_identity (
 633             metadata_db, identity_id) == TRUE);
 634     fail_unless (gsignond_db_metadata_database_get_identities (
 635             metadata_db, NULL) == NULL);
 636
 637     fail_unless (gsignond_db_metadata_database_get_methods (
 638             metadata_db, identity_id, owner) == NULL);
 639
 640     gsignond_security_context_free (owner);
 641
 642     gsignond_identity_info_unref (identity);
 643
 644     fail_unless (gsignond_db_sql_database_close (
 645             GSIGNOND_DB_SQL_DATABASE (metadata_db)) == TRUE);
 646     g_object_unref(metadata_db);
 647 }
 648 END_TEST
 649
 650 START_TEST (test_credentials_database)
 651 {
 652     GSignondConfig *config = NULL;
 653     guint32 identity_id = 5;
 654     GSignondIdentityInfo *identity = NULL, *identity2= NULL;
 655     GSignondIdentityInfoList *identities = NULL;
 656     GSignondSecurityContext *ctx1 = NULL;
 657     GList *methods = NULL, *reflist = NULL;
 658     GSignondSecurityContextList *acl = NULL ;
 659     GSignondSecurityContext *owner = NULL;
 660     GSignondDbCredentialsDatabase *credentials_db = NULL;
 661     GSignondSecretStorage *storage =NULL;
 662     GHashTable *data = NULL;
 663     GHashTable *data2 = NULL;
 664     Data input;
 665     GSignondDictionary *cap_filter = NULL;
 666     GSignondDictionary *type_filter = NULL;
 667     GSignondDictionary *cap_type_filter = NULL;
 668     GSignondDictionary *no_cap_filter = NULL;
 669
 670     config = gsignond_config_new ();
 671     gsignond_config_set_string (config, GSIGNOND_CONFIG_GENERAL_SECURE_DIR, "/tmp/gsignond");
 672     storage = g_object_new (GSIGNOND_TYPE_SECRET_STORAGE,
 673             "config", config, NULL);
 674     g_object_unref(config);
 675     credentials_db = gsignond_db_credentials_database_new (
 676             config, storage);
 677     g_object_unref (storage);
 678     fail_if (credentials_db == NULL);
 679
 680     fail_unless (gsignond_db_credentials_database_open_secret_storage (
 681             credentials_db) == TRUE);
 682
 683     fail_unless (gsignond_db_credentials_database_clear (
 684             credentials_db) == TRUE);
 685
 686     identity = _get_filled_identity_info ();
 687
 688     /*identity load/update*/
 689     identity_id = gsignond_db_credentials_database_update_identity (
 690             credentials_db, identity);
 691     fail_unless (identity_id != 0);
 692     gsignond_identity_info_set_id (identity, identity_id);
 693
 694     fail_unless (gsignond_db_credentials_database_load_identity (
 695                 credentials_db, 555, FALSE) == NULL);
 696     identity2 = gsignond_db_credentials_database_load_identity (
 697             credentials_db, identity_id, FALSE);
 698     fail_if (identity2 == NULL);
 699     gsignond_identity_info_unref (identity2);
 700
 701     identity2 = gsignond_db_credentials_database_load_identity (
 702             credentials_db, identity_id, TRUE);
 703     fail_if (identity2 == NULL);
 704
 705     fail_unless (g_strcmp0 (gsignond_identity_info_get_username (
 706             identity2), "username1") == 0);
 707     fail_unless (g_strcmp0 (gsignond_identity_info_get_secret (
 708             identity2), "secret1") == 0);
 709     gsignond_identity_info_unref (identity2);
 710
 711     fail_unless (gsignond_db_credentials_database_check_secret (
 712             credentials_db, identity_id, "username2", "secret1") == FALSE);
 713
 714     fail_unless (gsignond_db_credentials_database_check_secret (
 715             credentials_db, identity_id, "username1", "secret2") == FALSE);
 716
 717     fail_unless (gsignond_db_credentials_database_check_secret (
 718             credentials_db, 0, "username1", "secret2") == FALSE);
 719
 720     fail_unless (gsignond_db_credentials_database_check_secret (
 721             credentials_db, identity_id, "username1", "secret1") == TRUE);
 722
 723     ctx1 = gsignond_security_context_new_from_values ("sysctx1", "appctx1");
 724     methods = gsignond_db_credentials_database_get_methods (credentials_db,
 725                 identity_id, ctx1);
 726     fail_if (methods == NULL);
 727     g_list_free_full (methods, g_free);
 728
 729     /* add data to store */
 730     data = g_hash_table_new_full ((GHashFunc)g_str_hash,
 731             (GEqualFunc)g_str_equal,
 732             (GDestroyNotify)NULL,
 733             (GDestroyNotify)g_variant_unref);
 734     g_hash_table_insert (data,"key1",g_variant_new_string ("string_value"));
 735     g_hash_table_insert (data,"key2",g_variant_new_double (12223.4223));
 736     g_hash_table_insert (data,"key3",g_variant_new_uint16(20));
 737     g_hash_table_insert (data,"key4",g_variant_new("^ay", "byte_value"));
 738
 739     fail_unless (gsignond_db_credentials_database_update_data (
 740             credentials_db, 0, "method1", data) == FALSE);
 741
 742     fail_unless (gsignond_db_credentials_database_update_data (
 743             credentials_db, identity_id, "method1", data) == TRUE);
 744
 745     fail_unless (gsignond_db_credentials_database_update_data (
 746             credentials_db, identity_id, "method1", data) == TRUE);
 747
 748     fail_unless (gsignond_db_credentials_database_load_data (
 749             credentials_db, 0, "method1") == NULL);
 750     fail_unless (gsignond_db_credentials_database_load_data (
 751             credentials_db, identity_id, "method2") == NULL);
 752
 753     data2 = gsignond_db_credentials_database_load_data (credentials_db,
 754             identity_id, "method1");
 755     fail_if (data2 == NULL);
 756     input.table = data;
 757     input.status = 1;
 758     g_hash_table_foreach (data2, (GHFunc)_compare_key_value, &input);
 759     fail_if (input.status != 1);
 760     gsignond_dictionary_unref(data2);
 761     g_hash_table_unref(data);
 762
 763     fail_unless (gsignond_db_credentials_database_remove_data (
 764             credentials_db, 0, "method1") == FALSE);
 765
 766     fail_unless (gsignond_db_credentials_database_remove_data (
 767             credentials_db, identity_id, "method1") == TRUE);
 768
 769     /*references*/
 770     fail_unless (gsignond_db_credentials_database_insert_reference (
 771             credentials_db, identity_id, ctx1, "reference1") == TRUE);
 772
 773     reflist = gsignond_db_credentials_database_get_references (credentials_db,
 774                 identity_id, ctx1);
 775     fail_if (reflist == NULL);
 776     fail_unless (g_list_length (reflist) == 1);
 777     g_list_free_full (reflist, g_free);
 778
 779     fail_unless (gsignond_db_credentials_database_remove_reference (
 780             credentials_db, identity_id, ctx1, "reference2") == FALSE);
 781
 782     fail_unless (gsignond_db_credentials_database_remove_reference (
 783             credentials_db, identity_id, ctx1, "reference1") == TRUE);
 784     gsignond_security_context_free (ctx1);
 785
 786     acl = gsignond_db_credentials_database_get_accesscontrol_list (
 787             credentials_db, identity_id);
 788     fail_if (acl == NULL);
 789     gsignond_security_context_list_free (acl);
 790
 791     owner = gsignond_db_credentials_database_get_owner (
 792             credentials_db, identity_id);
 793     fail_if (owner == NULL);
 794     gsignond_security_context_free (owner);
 795
 796     owner = gsignond_db_credentials_database_get_identity_owner (
 797             credentials_db, identity_id);
 798     fail_if (owner == NULL);
 799     gsignond_security_context_free (owner);
 800
 801     /* load_identities : matched with caption and security context */
 802     cap_filter = gsignond_dictionary_new ();
 803     GSignondSecurityContext *ctx =
 804                 gsignond_security_context_new_from_values("sysctx1", "appctx1");
 805     gsignond_dictionary_set_string (cap_filter, "Caption", "cap");
 806     gsignond_dictionary_set(cap_filter, "Owner",
 807                  gsignond_security_context_to_variant(ctx));
 808     gsignond_security_context_free (ctx);
 809     identities = gsignond_db_credentials_database_load_identities (
 810             credentials_db, cap_filter);
 811     gsignond_dictionary_unref (cap_filter);
 812
 813     fail_if (identities == NULL);
 814     fail_unless (g_list_length (identities) == 1);
 815     gsignond_identity_info_list_free (identities);
 816
 817     /* load_identities: matched with type */
 818     type_filter = gsignond_dictionary_new();
 819     gsignond_dictionary_set_int32 (type_filter, "Type", 456);
 820     identities = gsignond_db_credentials_database_load_identities (
 821             credentials_db, type_filter);
 822     gsignond_dictionary_unref (type_filter);
 823
 824     fail_if (identities == NULL);
 825     fail_unless (g_list_length (identities) == 1);
 826     gsignond_identity_info_list_free (identities);
 827
 828     /* load_identities: matched with type and caption */
 829     cap_type_filter = gsignond_dictionary_new();
 830     gsignond_dictionary_set_int32 (cap_type_filter, "Type", 456);
 831     gsignond_dictionary_set_string (cap_type_filter, "Caption", "CAP");
 832     identities = gsignond_db_credentials_database_load_identities (
 833             credentials_db, cap_type_filter);
 834     gsignond_dictionary_unref (cap_type_filter);
 835
 836     fail_if (identities == NULL);
 837     fail_unless (g_list_length (identities) == 1);
 838     gsignond_identity_info_list_free (identities);
 839
 840     /* Negative load_identities query */
 841     no_cap_filter = gsignond_dictionary_new();
 842     gsignond_dictionary_set_string (no_cap_filter, "Caption", "non_existing");
 843
 844     identities = gsignond_db_credentials_database_load_identities (
 845             credentials_db, no_cap_filter);
 846     gsignond_dictionary_unref (no_cap_filter);
 847     fail_unless (identities == NULL);
 848
 849     fail_unless (gsignond_db_credentials_database_remove_identity (
 850             credentials_db, identity_id) == TRUE);
 851     gsignond_identity_info_unref (identity);
 852
 853     g_object_unref(credentials_db);
 854 }
 855 END_TEST
 856
 857 Suite* db_suite (void)
 858 {
 859     Suite *s = suite_create ("Database");
 860
 861     TCase *tc_core = tcase_create ("Tests");
 862
 863     tcase_add_test (tc_core, test_sql_database);
 864     tcase_add_test (tc_core, test_secret_storage);
 865     tcase_add_test (tc_core, test_metadata_database);
 866     tcase_add_test (tc_core, test_credentials_database);
 867     suite_add_tcase (s, tc_core);
 868     return s;
 869 }
 870
 871 int main (void)
 872 {
 873     int number_failed;
 874
 875 #if !GLIB_CHECK_VERSION (2, 36, 0)
 876     g_type_init ();
 877 #endif
 878
 879     Suite *s = db_suite ();
 880     SRunner *sr = srunner_create (s);
 881     srunner_run_all (sr, CK_NORMAL);
 882     number_failed = srunner_ntests_failed (sr);
 883     srunner_free (sr);
 884     return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 885 }
 886