libsecret/tests/test-service.c

   1 /* libsecret - GLib wrapper for Secret Service
   2  *
   3  * Copyright 2011 Collabora Ltd.
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public License as published
   7  * by the Free Software Foundation; either version 2 of the licence or (at
   8  * your option) any later version.
   9  *
  10  * See the included COPYING file for more information.
  11  */
  12
  13
  14 #include "config.h"
  15
  16 #include "secret-collection.h"
  17 #include "secret-item.h"
  18 #include "secret-service.h"
  19 #include "secret-paths.h"
  20 #include "secret-private.h"
  21
  22 #include "mock-service.h"
  23
  24 #include "egg/egg-testing.h"
  25
  26 #include <glib.h>
  27
  28 #include <errno.h>
  29 #include <stdlib.h>
  30
  31 typedef struct {
  32         SecretService *service;
  33 } Test;
  34
  35 static void
  36 setup_mock (Test *test,
  37             gconstpointer data)
  38 {
  39         GError *error = NULL;
  40         const gchar *mock_script = data;
  41
  42         mock_service_start (mock_script, &error);
  43         g_assert_no_error (error);
  44 }
  45
  46 static void
  47 teardown_mock (Test *test,
  48                gconstpointer unused)
  49 {
  50         mock_service_stop ();
  51 }
  52
  53 static void
  54 on_complete_get_result (GObject *source,
  55                         GAsyncResult *result,
  56                         gpointer user_data)
  57 {
  58         GAsyncResult **ret = user_data;
  59         g_assert (ret != NULL);
  60         g_assert (*ret == NULL);
  61         *ret = g_object_ref (result);
  62         egg_test_wait_stop ();
  63 }
  64
  65 static void
  66 test_get_sync (void)
  67 {
  68         SecretService *service1;
  69         SecretService *service2;
  70         SecretService *service3;
  71         GError *error = NULL;
  72
  73         /* Both these sohuld point to the same thing */
  74
  75         service1 = secret_service_get_sync (SECRET_SERVICE_NONE, NULL, &error);
  76         g_assert_no_error (error);
  77
  78         service2 = secret_service_get_sync (SECRET_SERVICE_NONE, NULL, &error);
  79         g_assert_no_error (error);
  80
  81         g_assert (SECRET_IS_SERVICE (service1));
  82         g_assert (service1 == service2);
  83
  84         g_object_unref (service1);
  85         g_assert (G_IS_OBJECT (service1));
  86
  87         g_object_unref (service2);
  88         secret_service_disconnect ();
  89         egg_assert_not_object (service2);
  90
  91         /* Services were disconnected, so this should create a new one */
  92         service3 = secret_service_get_sync (SECRET_SERVICE_NONE, NULL, &error);
  93         g_assert (SECRET_IS_SERVICE (service3));
  94         g_assert_no_error (error);
  95
  96         g_object_unref (service3);
  97         secret_service_disconnect ();
  98         egg_assert_not_object (service3);
  99 }
 100
 101 static void
 102 test_get_async (void)
 103 {
 104         SecretService *service1;
 105         SecretService *service2;
 106         SecretService *service3;
 107         GAsyncResult *result = NULL;
 108         GError *error = NULL;
 109
 110         /* Both these sohuld point to the same thing */
 111
 112         secret_service_get (SECRET_SERVICE_NONE, NULL, on_complete_get_result, &result);
 113         g_assert (result == NULL);
 114         egg_test_wait ();
 115         service1 = secret_service_get_finish (result, &error);
 116         g_assert_no_error (error);
 117         g_clear_object (&result);
 118
 119         secret_service_get (SECRET_SERVICE_NONE, NULL, on_complete_get_result, &result);
 120         g_assert (result == NULL);
 121         egg_test_wait ();
 122         service2 = secret_service_get_finish (result, &error);
 123         g_assert_no_error (error);
 124         g_clear_object (&result);
 125
 126         g_assert (SECRET_IS_SERVICE (service1));
 127         g_assert (service1 == service2);
 128
 129         g_object_unref (service1);
 130         g_assert (G_IS_OBJECT (service1));
 131
 132         g_object_unref (service2);
 133         secret_service_disconnect ();
 134         egg_assert_not_object (service2);
 135
 136         /* Services were unreffed, so this should create a new one */
 137         secret_service_get (SECRET_SERVICE_NONE, NULL, on_complete_get_result, &result);
 138         g_assert (result == NULL);
 139         egg_test_wait ();
 140         service3 = secret_service_get_finish (result, &error);
 141         g_assert_no_error (error);
 142         g_clear_object (&result);
 143
 144         g_object_unref (service3);
 145         secret_service_disconnect ();
 146         egg_assert_not_object (service3);
 147 }
 148
 149 static void
 150 test_get_more_sync (Test *test,
 151                     gconstpointer data)
 152 {
 153         SecretService *service;
 154         SecretService *service2;
 155         GError *error = NULL;
 156         const gchar *path;
 157         GList *collections;
 158
 159         service = secret_service_get_sync (SECRET_SERVICE_NONE, NULL, &error);
 160         g_assert_no_error (error);
 161
 162         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_NONE);
 163
 164         service2 = secret_service_get_sync (SECRET_SERVICE_LOAD_COLLECTIONS, NULL, &error);
 165         g_assert_no_error (error);
 166
 167         g_assert (SECRET_IS_SERVICE (service));
 168         g_assert (service == service2);
 169
 170         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_LOAD_COLLECTIONS);
 171         collections = secret_service_get_collections (service);
 172         g_assert (collections != NULL);
 173         g_list_free_full (collections, g_object_unref);
 174
 175         g_object_unref (service2);
 176
 177         service2 = secret_service_get_sync (SECRET_SERVICE_OPEN_SESSION, NULL, &error);
 178         g_assert_no_error (error);
 179
 180         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_OPEN_SESSION | SECRET_SERVICE_LOAD_COLLECTIONS);
 181         path = secret_service_get_session_dbus_path (service);
 182         g_assert (path != NULL);
 183
 184         g_object_unref (service2);
 185
 186         g_object_unref (service);
 187         secret_service_disconnect ();
 188         egg_assert_not_object (service);
 189 }
 190
 191 static void
 192 test_get_more_async (Test *test,
 193                      gconstpointer data)
 194 {
 195         GAsyncResult *result = NULL;
 196         SecretService *service;
 197         GError *error = NULL;
 198         const gchar *path;
 199         GList *collections;
 200
 201         secret_service_get (SECRET_SERVICE_LOAD_COLLECTIONS | SECRET_SERVICE_OPEN_SESSION, NULL, on_complete_get_result, &result);
 202         g_assert (result == NULL);
 203
 204         egg_test_wait ();
 205
 206         service = secret_service_get_finish (result, &error);
 207         g_assert_no_error (error);
 208         g_object_unref (result);
 209         result = NULL;
 210
 211         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_OPEN_SESSION | SECRET_SERVICE_LOAD_COLLECTIONS);
 212         path = secret_service_get_session_dbus_path (service);
 213         g_assert (path != NULL);
 214
 215         collections = secret_service_get_collections (service);
 216         g_assert (collections != NULL);
 217         g_list_free_full (collections, g_object_unref);
 218
 219         g_object_unref (service);
 220         secret_service_disconnect ();
 221         egg_assert_not_object (service);
 222
 223         /* Now get a session with just collections */
 224
 225         secret_service_get (SECRET_SERVICE_LOAD_COLLECTIONS, NULL, on_complete_get_result, &result);
 226         g_assert (result == NULL);
 227
 228         egg_test_wait ();
 229
 230         service = secret_service_get_finish (result, &error);
 231         g_assert_no_error (error);
 232         g_object_unref (result);
 233
 234         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_LOAD_COLLECTIONS);
 235         path = secret_service_get_session_dbus_path (service);
 236         g_assert (path == NULL);
 237
 238         collections = secret_service_get_collections (service);
 239         g_assert (collections != NULL);
 240         g_list_free_full (collections, g_object_unref);
 241
 242         g_object_unref (service);
 243         secret_service_disconnect ();
 244         egg_assert_not_object (service);
 245 }
 246
 247 static void
 248 test_new_sync (void)
 249 {
 250         SecretService *service1;
 251         SecretService *service2;
 252         GError *error = NULL;
 253
 254         /* Both these sohuld point to different things */
 255
 256         service1 = secret_service_new_sync (SECRET_TYPE_SERVICE, NULL,
 257                                             SECRET_SERVICE_NONE, NULL, &error);
 258         g_assert_no_error (error);
 259
 260         service2 = secret_service_new_sync (SECRET_TYPE_SERVICE, NULL,
 261                                             SECRET_SERVICE_NONE, NULL, &error);
 262         g_assert_no_error (error);
 263
 264         g_assert (SECRET_IS_SERVICE (service1));
 265         g_assert (SECRET_IS_SERVICE (service2));
 266         g_assert (service1 != service2);
 267
 268         g_object_unref (service1);
 269         egg_assert_not_object (service1);
 270
 271         g_object_unref (service2);
 272         egg_assert_not_object (service2);
 273 }
 274
 275 static void
 276 test_new_async (void)
 277 {
 278         SecretService *service1;
 279         SecretService *service2;
 280         GAsyncResult *result = NULL;
 281         GError *error = NULL;
 282
 283         /* Both these sohuld point to different things */
 284
 285         secret_service_new (SECRET_TYPE_SERVICE, NULL, SECRET_SERVICE_NONE,
 286                             NULL, on_complete_get_result, &result);
 287         g_assert (result == NULL);
 288         egg_test_wait ();
 289         service1 = secret_service_new_finish (result, &error);
 290         g_assert_no_error (error);
 291         g_clear_object (&result);
 292
 293         secret_service_new (SECRET_TYPE_SERVICE, NULL, SECRET_SERVICE_NONE, NULL,
 294                             on_complete_get_result, &result);
 295         g_assert (result == NULL);
 296         egg_test_wait ();
 297         service2 = secret_service_new_finish (result, &error);
 298         g_assert_no_error (error);
 299         g_clear_object (&result);
 300
 301         g_assert (SECRET_IS_SERVICE (service1));
 302         g_assert (SECRET_IS_SERVICE (service2));
 303         g_assert (service1 != service2);
 304
 305         g_object_unref (service1);
 306         egg_assert_not_object (service1);
 307
 308         g_object_unref (service2);
 309         egg_assert_not_object (service2);
 310 }
 311
 312 static void
 313 test_new_more_sync (Test *test,
 314                     gconstpointer data)
 315 {
 316         SecretService *service;
 317         GError *error = NULL;
 318         const gchar *path;
 319         GList *collections;
 320
 321         service = secret_service_new_sync (SECRET_TYPE_SERVICE, NULL, SECRET_SERVICE_NONE,
 322                                            NULL, &error);
 323         g_assert_no_error (error);
 324         g_assert (SECRET_IS_SERVICE (service));
 325
 326         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_NONE);
 327         g_assert (secret_service_get_collections (service) == NULL);
 328         g_assert (secret_service_get_session_dbus_path (service) == NULL);
 329
 330         g_object_unref (service);
 331         egg_assert_not_object (service);
 332
 333         service = secret_service_new_sync (SECRET_TYPE_SERVICE, NULL,
 334                                            SECRET_SERVICE_LOAD_COLLECTIONS, NULL, &error);
 335         g_assert_no_error (error);
 336         g_assert (SECRET_IS_SERVICE (service));
 337
 338         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_LOAD_COLLECTIONS);
 339         collections = secret_service_get_collections (service);
 340         g_assert (collections != NULL);
 341         g_list_free_full (collections, g_object_unref);
 342         g_assert (secret_service_get_session_dbus_path (service) == NULL);
 343
 344         g_object_unref (service);
 345         egg_assert_not_object (service);
 346
 347         service = secret_service_new_sync (SECRET_TYPE_SERVICE, NULL,
 348                                            SECRET_SERVICE_OPEN_SESSION, NULL, &error);
 349         g_assert_no_error (error);
 350         g_assert (SECRET_IS_SERVICE (service));
 351
 352         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_OPEN_SESSION);
 353         g_assert (secret_service_get_collections (service) == NULL);
 354         path = secret_service_get_session_dbus_path (service);
 355         g_assert (path != NULL);
 356
 357         g_object_unref (service);
 358         egg_assert_not_object (service);
 359 }
 360
 361 static void
 362 test_new_more_async (Test *test,
 363                      gconstpointer data)
 364 {
 365         GAsyncResult *result = NULL;
 366         SecretService *service;
 367         GError *error = NULL;
 368         const gchar *path;
 369         GList *collections;
 370
 371         secret_service_new (SECRET_TYPE_SERVICE, NULL,
 372                             SECRET_SERVICE_LOAD_COLLECTIONS | SECRET_SERVICE_OPEN_SESSION, NULL, on_complete_get_result, &result);
 373         g_assert (result == NULL);
 374
 375         egg_test_wait ();
 376
 377         service = secret_service_new_finish (result, &error);
 378         g_assert_no_error (error);
 379         g_object_unref (result);
 380         result = NULL;
 381
 382         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_OPEN_SESSION | SECRET_SERVICE_LOAD_COLLECTIONS);
 383         path = secret_service_get_session_dbus_path (service);
 384         g_assert (path != NULL);
 385
 386         collections = secret_service_get_collections (service);
 387         g_assert (collections != NULL);
 388         g_list_free_full (collections, g_object_unref);
 389
 390         g_object_unref (service);
 391         egg_assert_not_object (service);
 392
 393         /* Now get a session with just collections */
 394
 395         secret_service_new (SECRET_TYPE_SERVICE, NULL, SECRET_SERVICE_LOAD_COLLECTIONS,
 396                             NULL, on_complete_get_result, &result);
 397         g_assert (result == NULL);
 398
 399         egg_test_wait ();
 400
 401         service = secret_service_new_finish (result, &error);
 402         g_assert_no_error (error);
 403         g_object_unref (result);
 404
 405         g_assert_cmpuint (secret_service_get_flags (service), ==, SECRET_SERVICE_LOAD_COLLECTIONS);
 406         path = secret_service_get_session_dbus_path (service);
 407         g_assert (path == NULL);
 408
 409         collections = secret_service_get_collections (service);
 410         g_assert (collections != NULL);
 411         g_list_free_full (collections, g_object_unref);
 412
 413         g_object_unref (service);
 414         egg_assert_not_object (service);
 415 }
 416
 417 static void
 418 test_connect_async (Test *test,
 419                     gconstpointer used)
 420 {
 421         GError *error = NULL;
 422         GAsyncResult *result = NULL;
 423         SecretService *service;
 424         const gchar *path;
 425
 426         /* Passing false, not session */
 427         secret_service_get (SECRET_SERVICE_NONE, NULL, on_complete_get_result, &result);
 428         g_assert (result == NULL);
 429
 430         egg_test_wait ();
 431
 432         service = secret_service_get_finish (result, &error);
 433         g_assert (SECRET_IS_SERVICE (service));
 434         g_assert_no_error (error);
 435         g_object_unref (result);
 436
 437         path = secret_service_get_session_dbus_path (service);
 438         g_assert (path == NULL);
 439
 440         g_object_unref (service);
 441         secret_service_disconnect ();
 442         egg_assert_not_object (service);
 443 }
 444
 445 static void
 446 test_connect_ensure_async (Test *test,
 447                            gconstpointer used)
 448 {
 449         GError *error = NULL;
 450         GAsyncResult *result = NULL;
 451         SecretService *service;
 452         const gchar *path;
 453
 454         /* Passing true, ensures session is established */
 455         secret_service_get (SECRET_SERVICE_OPEN_SESSION, NULL, on_complete_get_result, &result);
 456         g_assert (result == NULL);
 457
 458         egg_test_wait ();
 459
 460         service = secret_service_get_finish (result, &error);
 461         g_assert_no_error (error);
 462         g_assert (SECRET_IS_SERVICE (service));
 463         g_object_unref (result);
 464
 465         path = secret_service_get_session_dbus_path (service);
 466         g_assert (path != NULL);
 467
 468         g_object_unref (service);
 469         secret_service_disconnect ();
 470         egg_assert_not_object (service);
 471 }
 472
 473 static void
 474 test_ensure_sync (Test *test,
 475                   gconstpointer used)
 476 {
 477         GError *error = NULL;
 478         SecretService *service;
 479         SecretServiceFlags flags;
 480         gboolean ret;
 481
 482         /* Passing true, ensures session is established */
 483         service = secret_service_new_sync (SECRET_TYPE_SERVICE, NULL,
 484                                            SECRET_SERVICE_NONE, NULL, &error);
 485         g_assert_no_error (error);
 486         g_assert (service != NULL);
 487
 488         flags = secret_service_get_flags (service);
 489         g_assert_cmpuint (flags, ==, SECRET_SERVICE_NONE);
 490
 491         ret = secret_service_load_collections_sync (service, NULL, &error);
 492         g_assert_no_error (error);
 493         g_assert (ret == TRUE);
 494
 495         g_object_get (service, "flags", &flags, NULL);
 496         g_assert_cmpuint (flags, ==, SECRET_SERVICE_LOAD_COLLECTIONS);
 497
 498         ret = secret_service_ensure_session_sync (service, NULL, &error);
 499         g_assert_no_error (error);
 500         g_assert (ret == TRUE);
 501
 502         flags = secret_service_get_flags (service);
 503         g_assert_cmpuint (flags, ==, SECRET_SERVICE_OPEN_SESSION | SECRET_SERVICE_LOAD_COLLECTIONS);
 504
 505         g_object_unref (service);
 506         egg_assert_not_object (service);
 507 }
 508
 509 static void
 510 test_ensure_async (Test *test,
 511                    gconstpointer used)
 512 {
 513         GAsyncResult *result = NULL;
 514         SecretServiceFlags flags;
 515         SecretService *service;
 516         GError *error = NULL;
 517         gboolean ret;
 518
 519         /* Passing true, ensures session is established */
 520         service = secret_service_new_sync (SECRET_TYPE_SERVICE, NULL,
 521                                            SECRET_SERVICE_NONE, NULL, &error);
 522         g_assert_no_error (error);
 523         g_assert (service != NULL);
 524
 525         flags = secret_service_get_flags (service);
 526         g_assert_cmpuint (flags, ==, SECRET_SERVICE_NONE);
 527
 528         secret_service_load_collections (service, NULL, on_complete_get_result, &result);
 529         g_assert (result == NULL);
 530
 531         egg_test_wait ();
 532
 533         ret = secret_service_load_collections_finish (service, result, &error);
 534         g_assert_no_error (error);
 535         g_assert (ret == TRUE);
 536         g_object_unref (result);
 537         result = NULL;
 538
 539         g_object_get (service, "flags", &flags, NULL);
 540         g_assert_cmpuint (flags, ==, SECRET_SERVICE_LOAD_COLLECTIONS);
 541
 542         secret_service_ensure_session (service, NULL, on_complete_get_result, &result);
 543         g_assert (result == NULL);
 544
 545         egg_test_wait ();
 546
 547         ret = secret_service_ensure_session_finish (service, result, &error);
 548         g_assert_no_error (error);
 549         g_assert (ret == TRUE);
 550         g_object_unref (result);
 551         result = NULL;
 552
 553         flags = secret_service_get_flags (service);
 554         g_assert_cmpuint (flags, ==, SECRET_SERVICE_OPEN_SESSION | SECRET_SERVICE_LOAD_COLLECTIONS);
 555
 556         g_object_unref (service);
 557         egg_assert_not_object (service);
 558 }
 559
 560 int
 561 main (int argc, char **argv)
 562 {
 563         g_test_init (&argc, &argv, NULL);
 564         g_set_prgname ("test-service");
 565         g_type_init ();
 566
 567         g_test_add_func ("/service/get-sync", test_get_sync);
 568         g_test_add_func ("/service/get-async", test_get_async);
 569         g_test_add ("/service/get-more-sync", Test, "mock-service-normal.py", setup_mock, test_get_more_sync, teardown_mock);
 570         g_test_add ("/service/get-more-async", Test, "mock-service-normal.py", setup_mock, test_get_more_async, teardown_mock);
 571
 572         g_test_add_func ("/service/new-sync", test_new_sync);
 573         g_test_add_func ("/service/new-async", test_new_async);
 574         g_test_add ("/service/new-more-sync", Test, "mock-service-normal.py", setup_mock, test_new_more_sync, teardown_mock);
 575         g_test_add ("/service/new-more-async", Test, "mock-service-normal.py", setup_mock, test_new_more_async, teardown_mock);
 576
 577         g_test_add ("/service/connect-sync", Test, "mock-service-normal.py", setup_mock, test_connect_async, teardown_mock);
 578         g_test_add ("/service/connect-ensure-sync", Test, "mock-service-normal.py", setup_mock, test_connect_ensure_async, teardown_mock);
 579         g_test_add ("/service/ensure-sync", Test, "mock-service-normal.py", setup_mock, test_ensure_sync, teardown_mock);
 580         g_test_add ("/service/ensure-async", Test, "mock-service-normal.py", setup_mock, test_ensure_async, teardown_mock);
 581
 582         return egg_tests_run_with_loop ();
 583 }