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