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