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