src/tests/session/test-session.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <stdarg.h>
   4 #include <errno.h>
   5 #include <string.h>
   6
   7 #include <check.h>
   8
   9 #include "afb-session.h"
  10 #include "afb-hook.h"
  11
  12 #define GOOD_UUID  "123456789012345678901234567890123456"
  13 #define BAD_UUID   "1234567890123456789012345678901234567"
  14
  15 /*********************************************************************/
  16 /* check the initialisation */
  17 START_TEST (check_initialisation)
  18 {
  19         ck_assert_int_eq(0, afb_session_init(0, 0, NULL));
  20         ck_assert_int_eq(0, afb_session_init(200, 0, NULL));
  21         ck_assert_int_eq(0, afb_session_init(10, 0, GOOD_UUID));
  22         ck_assert_str_eq(GOOD_UUID, afb_session_initial_token());
  23         ck_assert_int_eq(-1, afb_session_init(10, 0, BAD_UUID));
  24         ck_assert_int_eq(errno, EINVAL);
  25 }
  26 END_TEST
  27
  28 /*********************************************************************/
  29 /* check that NULL is a valid value for addref/unref */
  30 START_TEST (check_sanity)
  31 {
  32         struct afb_session *s;
  33         s = afb_session_addref(NULL);
  34         ck_assert(!s);
  35         afb_session_unref(NULL);
  36         ck_assert(1);
  37 }
  38 END_TEST
  39
  40 /*********************************************************************/
  41 /* check creation and retrieval of sessions */
  42 START_TEST (check_creation)
  43 {
  44         char *uuid;
  45         struct afb_session *s, *x;
  46
  47         /* init */
  48         ck_assert_int_eq(0, afb_session_init(10, 3600, GOOD_UUID));
  49
  50         /* create a session */
  51         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
  52         ck_assert(s);
  53
  54         /* the session is valid */
  55         ck_assert(afb_session_uuid(s) != NULL);
  56         ck_assert(afb_session_token(s) != NULL);
  57         ck_assert(!afb_session_is_closed(s));
  58
  59         /* token is the initial one */
  60         ck_assert_str_eq(afb_session_token(s), GOOD_UUID);
  61         ck_assert(afb_session_check_token(s, GOOD_UUID));
  62         ck_assert(afb_session_check_token(s, afb_session_token(s)));
  63
  64         /* token can be renewed */
  65         afb_session_new_token(s);
  66         ck_assert(strcmp(afb_session_token(s), GOOD_UUID));
  67         ck_assert(!afb_session_check_token(s, GOOD_UUID));
  68         ck_assert(afb_session_check_token(s, afb_session_token(s)));
  69
  70         /* query the session */
  71         uuid = strdup(afb_session_uuid(s));
  72         x = afb_session_search(uuid);
  73         ck_assert(x == s);
  74
  75         /* still alive after search */
  76         afb_session_unref(x);
  77         afb_session_unref(s);
  78         s = afb_session_search(uuid);
  79         ck_assert(s);
  80         ck_assert(x == s);
  81
  82         /* but not after closing */
  83         afb_session_close(s);
  84         ck_assert(afb_session_is_closed(s));
  85         afb_session_unref(s);
  86         afb_session_purge();
  87         s = afb_session_search(uuid);
  88         ck_assert(!s);
  89         free(uuid);
  90 }
  91 END_TEST
  92
  93 /*********************************************************************/
  94 /* check that the maximum capacity is ensured */
  95 START_TEST (check_capacity)
  96 {
  97         struct afb_session *s[3];
  98         ck_assert_int_eq(0, afb_session_init(2, 3600, GOOD_UUID));
  99         s[0] = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 100         ck_assert(s[0]);
 101         s[1] = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 102         ck_assert(s[1]);
 103         s[2] = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 104         ck_assert(!s[2]);
 105         afb_session_close(s[0]);
 106         afb_session_unref(s[0]);
 107         s[2] = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 108         ck_assert(s[2]);
 109         s[0] = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 110         ck_assert(!s[0]);
 111         afb_session_unref(s[0]);
 112         afb_session_unref(s[1]);
 113         afb_session_unref(s[2]);
 114 }
 115 END_TEST
 116
 117 /*********************************************************************/
 118 /* check the handling of cookies */
 119 void *mkcookie_got;
 120 void *mkcookie(void *closure)
 121 {
 122         mkcookie_got = closure;
 123         return closure;
 124 }
 125
 126 void *freecookie_got;
 127 void freecookie(void *item)
 128 {
 129         freecookie_got = item;
 130 }
 131
 132 START_TEST (check_cookies)
 133 {
 134         char *k[] = { "key1", "key2", "key3", NULL }, *p, *q, *d = "default";
 135         struct afb_session *s;
 136         int i, j;
 137
 138         /* init */
 139         ck_assert_int_eq(0, afb_session_init(10, 3600, GOOD_UUID));
 140
 141         /* create a session */
 142         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 143         ck_assert(s);
 144
 145         /* set the cookie */
 146         for (i = 0 ; k[i] ; i++) {
 147                 for (j = 0 ; k[j] ; j++) {
 148                         /* retrieve the previous value */
 149                         mkcookie_got = freecookie_got = NULL;
 150                         p = afb_session_cookie(s, k[j], NULL, NULL, NULL, 0);
 151                         if (!p) {
 152                                 /* never set (i = 0) */
 153                                 q = afb_session_cookie(s, k[j], NULL, NULL, d, 0);
 154                                 ck_assert(q == d);
 155                                 p = afb_session_cookie(s, k[j], NULL, NULL, NULL, 0);
 156                                 ck_assert(!p);
 157                         }
 158                         q = afb_session_cookie(s, k[j], mkcookie, freecookie, k[i], 1);
 159                         ck_assert(q == k[i]);
 160                         ck_assert(mkcookie_got == q);
 161                         ck_assert(freecookie_got == p);
 162                 }
 163         }
 164
 165         /* drop cookies */
 166         for (i = 1 ; k[i] ; i++) {
 167                 mkcookie_got = freecookie_got = NULL;
 168                 p = afb_session_cookie(s, k[i], NULL, NULL, NULL, 0);
 169                 ck_assert(!freecookie_got);
 170                 q = afb_session_cookie(s, k[i], NULL, NULL, NULL, 1);
 171                 ck_assert(!q);
 172                 ck_assert(freecookie_got == p);
 173         }
 174
 175         /* closing session */
 176         p = afb_session_cookie(s, k[0], NULL, NULL, NULL, 0);
 177         mkcookie_got = freecookie_got = NULL;
 178         afb_session_close(s);
 179         ck_assert(freecookie_got == p);
 180         p = afb_session_cookie(s, k[0], NULL, NULL, NULL, 0);
 181         ck_assert(!p);
 182         afb_session_unref(s);
 183 }
 184 END_TEST
 185
 186
 187 /*********************************************************************/
 188 /* check hooking */
 189
 190 #if WITH_AFB_HOOK
 191 int hookflag;
 192
 193 void on_create(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 194 {
 195         hookflag |= afb_hook_flag_session_create;
 196 }
 197
 198 void on_close(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 199 {
 200         hookflag |= afb_hook_flag_session_close;
 201 }
 202
 203 void on_destroy(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 204 {
 205         hookflag |= afb_hook_flag_session_destroy;
 206 }
 207
 208 void on_renew(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 209 {
 210         hookflag |= afb_hook_flag_session_renew;
 211 }
 212
 213 void on_addref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 214 {
 215         hookflag |= afb_hook_flag_session_addref;
 216 }
 217
 218 void on_unref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 219 {
 220         hookflag |= afb_hook_flag_session_unref;
 221 }
 222
 223 struct afb_hook_session_itf hookitf = {
 224         .hook_session_create = on_create,
 225         .hook_session_close = on_close,
 226         .hook_session_destroy = on_destroy,
 227         .hook_session_renew = on_renew,
 228         .hook_session_addref = on_addref,
 229         .hook_session_unref = on_unref
 230 };
 231
 232 extern void afb_hook_session_create(struct afb_session *session);
 233 extern void afb_hook_session_close(struct afb_session *session);
 234 extern void afb_hook_session_destroy(struct afb_session *session);
 235 extern void afb_hook_session_renew(struct afb_session *session);
 236 extern void afb_hook_session_addref(struct afb_session *session);
 237 extern void afb_hook_session_unref(struct afb_session *session);
 238
 239 extern struct afb_hook_session *afb_hook_create_session(const char *pattern, int flags, struct afb_hook_session_itf *itf, void *closure);
 240 extern struct afb_hook_session *afb_hook_addref_session(struct afb_hook_session *hook);
 241 extern void afb_hook_unref_session(struct afb_hook_session *hook);
 242
 243
 244 START_TEST (check_hooking)
 245 {
 246         struct afb_hook_session *hs;
 247         struct afb_session *s;
 248
 249         /* init */
 250         ck_assert_int_eq(0, afb_session_init(10, 3600, GOOD_UUID));
 251
 252         /* create the hooking */
 253         hs = afb_hook_create_session(NULL, afb_hook_flags_session_all, &hookitf, NULL);
 254         ck_assert_ptr_ne(hs, 0);
 255
 256         /* create a session */
 257         hookflag = 0;
 258         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 259         ck_assert_ptr_ne(s, 0);
 260         ck_assert_int_eq(hookflag, afb_hook_flag_session_create);
 261
 262         /* addref session */
 263         hookflag = 0;
 264         afb_session_addref(s);
 265         ck_assert_int_eq(hookflag, afb_hook_flag_session_addref);
 266
 267         /* unref session */
 268         hookflag = 0;
 269         afb_session_unref(s);
 270         ck_assert_int_eq(hookflag, afb_hook_flag_session_unref);
 271
 272         /* renew session token */
 273         hookflag = 0;
 274         afb_session_new_token(s);
 275         ck_assert_int_eq(hookflag, afb_hook_flag_session_renew);
 276
 277         /* close session */
 278         hookflag = 0;
 279         afb_session_close(s);
 280         ck_assert_int_eq(hookflag, afb_hook_flag_session_close);
 281
 282         /* unref session */
 283         hookflag = 0;
 284         afb_session_unref(s);
 285         ck_assert_int_eq(hookflag, afb_hook_flag_session_unref);
 286
 287         /* purge */
 288         hookflag = 0;
 289         afb_session_purge();
 290         ck_assert_int_eq(hookflag, afb_hook_flag_session_destroy);
 291
 292         /* drop hooks */
 293         hookflag = 0;
 294         afb_hook_unref_session(hs);
 295         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 296         ck_assert_ptr_ne(s, 0);
 297         ck_assert_int_eq(hookflag, 0);
 298         afb_session_unref(s);
 299         ck_assert_int_eq(hookflag, 0);
 300 }
 301 END_TEST
 302
 303 #endif
 304
 305 /*********************************************************************/
 306
 307
 308 static Suite *suite;
 309 static TCase *tcase;
 310
 311 void mksuite(const char *name) { suite = suite_create(name); }
 312 void addtcase(const char *name) { tcase = tcase_create(name); suite_add_tcase(suite, tcase); }
 313 void addtest(TFun fun) { tcase_add_test(tcase, fun); }
 314 int srun()
 315 {
 316         int nerr;
 317         SRunner *srunner = srunner_create(suite);
 318         srunner_run_all(srunner, CK_NORMAL);
 319         nerr = srunner_ntests_failed(srunner);
 320         srunner_free(srunner);
 321         return nerr;
 322 }
 323
 324 int main(int ac, char **av)
 325 {
 326         mksuite("session");
 327                 addtcase("session");
 328                         addtest(check_initialisation);
 329                         addtest(check_sanity);
 330                         addtest(check_creation);
 331                         addtest(check_capacity);
 332                         addtest(check_cookies);
 333 #if WITH_AFB_HOOK
 334                         addtest(check_hooking);
 335 #endif
 336         return !!srun();
 337 }