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
  11 #define GOOD_UUID  "123456789012345678901234567890123456"
  12 #define BAD_UUID   "1234567890123456789012345678901234567"
  13
  14 START_TEST (test_initialisation)
  15 {
  16         ck_assert_int_eq(0, afb_session_init(0, 0, NULL));
  17         ck_assert_int_eq(0, afb_session_init(200, 0, NULL));
  18         ck_assert_int_eq(0, afb_session_init(10, 0, GOOD_UUID));
  19         ck_assert_str_eq(GOOD_UUID, afb_session_initial_token());
  20         ck_assert_int_eq(-1, afb_session_init(10, 0, BAD_UUID));
  21         ck_assert_int_eq(errno, EINVAL);
  22 }
  23 END_TEST
  24
  25
  26 START_TEST (test_sanity)
  27 {
  28         struct afb_session *s;
  29         s = afb_session_addref(NULL);
  30         ck_assert(!s);
  31         afb_session_unref(NULL);
  32         ck_assert(1);
  33 }
  34 END_TEST
  35
  36
  37 START_TEST (test_creation)
  38 {
  39         char *uuid;
  40         struct afb_session *s, *x;
  41
  42         /* init */
  43         ck_assert_int_eq(0, afb_session_init(10, 3600, GOOD_UUID));
  44
  45         /* create a session */
  46         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
  47         ck_assert(s);
  48
  49         /* the session is valid */
  50         ck_assert(afb_session_uuid(s) != NULL);
  51         ck_assert(afb_session_token(s) != NULL);
  52         ck_assert(!afb_session_is_closed(s));
  53
  54         /* token is the initial one */
  55         ck_assert_str_eq(afb_session_token(s), GOOD_UUID);
  56         ck_assert(afb_session_check_token(s, GOOD_UUID));
  57         ck_assert(afb_session_check_token(s, afb_session_token(s)));
  58
  59         /* token can be renewed */
  60         afb_session_new_token(s);
  61         ck_assert(strcmp(afb_session_token(s), GOOD_UUID));
  62         ck_assert(!afb_session_check_token(s, GOOD_UUID));
  63         ck_assert(afb_session_check_token(s, afb_session_token(s)));
  64
  65         /* query the session */
  66         uuid = strdup(afb_session_uuid(s));
  67         x = afb_session_search(uuid);
  68         ck_assert(x == s);
  69
  70         /* still alive after search */
  71         afb_session_unref(x);
  72         afb_session_unref(s);
  73         s = afb_session_search(uuid);
  74         ck_assert(s);
  75         ck_assert(x == s);
  76
  77         /* but not after closing */
  78         afb_session_close(s);
  79         ck_assert(afb_session_is_closed(s));
  80         afb_session_unref(s);
  81         afb_session_purge();
  82         s = afb_session_search(uuid);
  83         ck_assert(!s);
  84         free(uuid);
  85 }
  86 END_TEST
  87
  88
  89 START_TEST (test_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 void *mkcookie_got;
 113 void *mkcookie(void *closure)
 114 {
 115         mkcookie_got = closure;
 116         return closure;
 117 }
 118
 119 void *freecookie_got;
 120 void freecookie(void *item)
 121 {
 122         freecookie_got = item;
 123 }
 124
 125 START_TEST (test_cookies)
 126 {
 127         char *k[] = { "key1", "key2", "key3", NULL }, *p, *q, *d = "default";
 128         struct afb_session *s;
 129         int i, j;
 130
 131         /* init */
 132         ck_assert_int_eq(0, afb_session_init(10, 3600, GOOD_UUID));
 133
 134 extern void *afb_session_cookie(struct afb_session *session, const void *key, void *(*makecb)(void *closure), void (*freecb)(void *item), void *closure, int replace);
 135
 136         /* create a session */
 137         s = afb_session_create(AFB_SESSION_TIMEOUT_DEFAULT);
 138         ck_assert(s);
 139
 140         /* set the cookie */
 141         for (i = 0 ; k[i] ; i++) {
 142                 for (j = 0 ; k[j] ; j++) {
 143                         /* retrieve the previous value */
 144                         mkcookie_got = freecookie_got = NULL;
 145                         p = afb_session_cookie(s, k[j], NULL, NULL, NULL, 0);
 146                         if (!p) {
 147                                 /* never set (i = 0) */
 148                                 q = afb_session_cookie(s, k[j], NULL, NULL, d, 0);
 149                                 ck_assert(q == d);
 150                                 p = afb_session_cookie(s, k[j], NULL, NULL, NULL, 0);
 151                                 ck_assert(!p);
 152                         }
 153                         q = afb_session_cookie(s, k[j], mkcookie, freecookie, k[i], 1);
 154                         ck_assert(q == k[i]);
 155                         ck_assert(mkcookie_got == q);
 156                         ck_assert(freecookie_got == p);
 157                 }
 158         }
 159
 160         /* drop cookies */
 161         for (i = 1 ; k[i] ; i++) {
 162                 mkcookie_got = freecookie_got = NULL;
 163                 p = afb_session_cookie(s, k[i], NULL, NULL, NULL, 0);
 164                 ck_assert(!freecookie_got);
 165                 q = afb_session_cookie(s, k[i], NULL, NULL, NULL, 1);
 166                 ck_assert(!q);
 167                 ck_assert(freecookie_got == p);
 168         }
 169
 170         /* closing session */
 171         p = afb_session_cookie(s, k[0], NULL, NULL, NULL, 0);
 172         mkcookie_got = freecookie_got = NULL;
 173         afb_session_close(s);
 174         ck_assert(freecookie_got == p);
 175         p = afb_session_cookie(s, k[0], NULL, NULL, NULL, 0);
 176         ck_assert(!p);
 177         afb_session_unref(s);
 178 }
 179 END_TEST
 180
 181 static Suite *suite;
 182 static TCase *tcase;
 183
 184 void mksuite(const char *name) { suite = suite_create(name); }
 185 void addtcase(const char *name) { tcase = tcase_create(name); suite_add_tcase(suite, tcase); }
 186 void addtest(TFun fun) { tcase_add_test(tcase, fun); }
 187 int srun()
 188 {
 189         int nerr;
 190         SRunner *srunner = srunner_create(suite);
 191         srunner_run_all(srunner, CK_NORMAL);
 192         nerr = srunner_ntests_failed(srunner);
 193         srunner_free(srunner);
 194         return nerr;
 195 }
 196
 197 int main(int ac, char **av)
 198 {
 199         mksuite("session");
 200                 addtcase("session");
 201                         addtest(test_initialisation);
 202                         addtest(test_sanity);
 203                         addtest(test_creation);
 204                         addtest(test_capacity);
 205                         addtest(test_cookies);
 206         return !!srun();
 207 }