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 int hookflag;
 191
 192 void on_create(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 193 {
 194         hookflag |= afb_hook_flag_session_create;
 195 }
 196
 197 void on_close(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 198 {
 199         hookflag |= afb_hook_flag_session_close;
 200 }
 201
 202 void on_destroy(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 203 {
 204         hookflag |= afb_hook_flag_session_destroy;
 205 }
 206
 207 void on_renew(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 208 {
 209         hookflag |= afb_hook_flag_session_renew;
 210 }
 211
 212 void on_addref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 213 {
 214         hookflag |= afb_hook_flag_session_addref;
 215 }
 216
 217 void on_unref(void *closure, const struct afb_hookid *hookid, struct afb_session *session)
 218 {
 219         hookflag |= afb_hook_flag_session_unref;
 220 }
 221
 222 struct afb_hook_session_itf hookitf = {
 223         .hook_session_create = on_create,
 224         .hook_session_close = on_close,
 225         .hook_session_destroy = on_destroy,
 226         .hook_session_renew = on_renew,
 227         .hook_session_addref = on_addref,
 228         .hook_session_unref = on_unref
 229 };
 230
 231 extern void afb_hook_session_create(struct afb_session *session);
 232 extern void afb_hook_session_close(struct afb_session *session);
 233 extern void afb_hook_session_destroy(struct afb_session *session);
 234 extern void afb_hook_session_renew(struct afb_session *session);
 235 extern void afb_hook_session_addref(struct afb_session *session);
 236 extern void afb_hook_session_unref(struct afb_session *session);
 237
 238 extern struct afb_hook_session *afb_hook_create_session(const char *pattern, int flags, struct afb_hook_session_itf *itf, void *closure);
 239 extern struct afb_hook_session *afb_hook_addref_session(struct afb_hook_session *hook);
 240 extern void afb_hook_unref_session(struct afb_hook_session *hook);
 241
 242
 243 START_TEST (check_hooking)
 244 {
 245         struct afb_hook_session *hs;
 246         struct afb_session *s;
 247
 248         /* init */
 249         ck_assert_int_eq(0, afb_session_init(10, 3600, GOOD_UUID));
 250
 251         /* create the hooking */
 252         hs = afb_hook_create_session(NULL, afb_hook_flags_session_all, &hookitf, NULL);
 253         ck_assert_ptr_ne(hs, 0);
 254
 255         /* create a session */
 256         hookflag = 0;
 257         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 258         ck_assert_ptr_ne(s, 0);
 259         ck_assert_int_eq(hookflag, afb_hook_flag_session_create);
 260
 261         /* addref session */
 262         hookflag = 0;
 263         afb_session_addref(s);
 264         ck_assert_int_eq(hookflag, afb_hook_flag_session_addref);
 265
 266         /* unref session */
 267         hookflag = 0;
 268         afb_session_unref(s);
 269         ck_assert_int_eq(hookflag, afb_hook_flag_session_unref);
 270
 271         /* renew session token */
 272         hookflag = 0;
 273         afb_session_new_token(s);
 274         ck_assert_int_eq(hookflag, afb_hook_flag_session_renew);
 275
 276         /* close session */
 277         hookflag = 0;
 278         afb_session_close(s);
 279         ck_assert_int_eq(hookflag, afb_hook_flag_session_close);
 280
 281         /* unref session */
 282         hookflag = 0;
 283         afb_session_unref(s);
 284         ck_assert_int_eq(hookflag, afb_hook_flag_session_unref);
 285
 286         /* purge */
 287         hookflag = 0;
 288         afb_session_purge();
 289         ck_assert_int_eq(hookflag, afb_hook_flag_session_destroy);
 290
 291         /* drop hooks */
 292         hookflag = 0;
 293         afb_hook_unref_session(hs);
 294         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 295         ck_assert_ptr_ne(s, 0);
 296         ck_assert_int_eq(hookflag, 0);
 297         afb_session_unref(s);
 298         ck_assert_int_eq(hookflag, 0);
 299 }
 300 END_TEST
 301
 302 /*********************************************************************/
 303
 304
 305 static Suite *suite;
 306 static TCase *tcase;
 307
 308 void mksuite(const char *name) { suite = suite_create(name); }
 309 void addtcase(const char *name) { tcase = tcase_create(name); suite_add_tcase(suite, tcase); }
 310 void addtest(TFun fun) { tcase_add_test(tcase, fun); }
 311 int srun()
 312 {
 313         int nerr;
 314         SRunner *srunner = srunner_create(suite);
 315         srunner_run_all(srunner, CK_NORMAL);
 316         nerr = srunner_ntests_failed(srunner);
 317         srunner_free(srunner);
 318         return nerr;
 319 }
 320
 321 int main(int ac, char **av)
 322 {
 323         mksuite("session");
 324                 addtcase("session");
 325                         addtest(check_initialisation);
 326                         addtest(check_sanity);
 327                         addtest(check_creation);
 328                         addtest(check_capacity);
 329                         addtest(check_cookies);
 330                         addtest(check_hooking);
 331         return !!srun();
 332 }