src/cynara-tests/test_cases_async.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 /*
  18  * @file        test_cases_async.cpp
  19  * @author      Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
  20  * @version     1.0
  21  * @brief       Tests for libcynara-client-async
  22  */
  23
  24 #include <cynara_test_admin.h>
  25 #include <cynara_test_commons.h>
  26 #include <cynara_test_client_async_client.h>
  27
  28 #include <service_manager.h>
  29 #include <dpl/test/test_runner.h>
  30
  31 #include <cynara-client-async.h>
  32
  33 #include <cstdint>
  34 #include <unistd.h>
  35
  36 using namespace CynaraTestClientAsync;
  37 using namespace CynaraTestAdmin;
  38
  39 RUNNER_TEST_GROUP_INIT(cynara_async_tests)
  40
  41 RUN_CYNARA_TEST(tca01_initialize)
  42 {
  43     Client client;
  44 }
  45
  46 RUN_CYNARA_TEST(tca02_empty_cache_miss)
  47 {
  48     std::string testNo("02");
  49     Client client;
  50
  51     client.checkCache({testNo}, CYNARA_API_CACHE_MISS);
  52     client.checkCache({testNo}, CYNARA_API_CACHE_MISS);
  53 }
  54
  55 RUN_CYNARA_TEST(tca03_create_max_requests)
  56 {
  57     std::string testNo("03");
  58     cynara_check_id id;
  59     RequestEntity callbackData = {RequestFunction(), 0, CYNARA_CALL_CAUSE_FINISH};
  60
  61     Client client;
  62
  63     for (auto i = 0; i <= UINT16_MAX; ++i) {
  64         client.createRequest({testNo, i}, id, callbackData, CYNARA_API_SUCCESS);
  65         client.assertStatus(READWRITE);
  66     }
  67
  68     client.createRequest({testNo}, id, callbackData, CYNARA_API_MAX_PENDING_REQUESTS);
  69     client.assertStatus(READWRITE);
  70 }
  71
  72 RUN_CYNARA_TEST(tca04_request_and_process)
  73 {
  74     std::string testNo("04");
  75     cynara_check_id id;
  76     RequestEntity callbackData = {RequestFunction(),
  77                                   CYNARA_API_ACCESS_DENIED,
  78                                   CYNARA_CALL_CAUSE_ANSWER};
  79
  80     Client client;
  81
  82     client.createRequest({testNo}, id, callbackData);
  83     client.assertStatus(READWRITE);
  84
  85     //send request
  86     client.process();
  87     client.assertStatus(READ);
  88
  89     //get answer
  90     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
  91 }
  92
  93 RUN_CYNARA_TEST(tca05_request_and_cancel1)
  94 {
  95     std::string testNo("05");
  96     int subtest = 1;
  97     cynara_check_id id;
  98     RequestEntity callbackData = {RequestFunction(),
  99                                   CYNARA_API_ACCESS_DENIED,
 100                                   CYNARA_CALL_CAUSE_CANCEL};
 101
 102     Client client;
 103
 104     client.createRequest({testNo, subtest}, id, callbackData);
 105     client.assertStatus(READWRITE);
 106
 107     client.cancel(id);
 108     client.assertStatus(READWRITE);
 109
 110     //send request and cancel
 111     client.process();
 112     client.assertStatus(READ);
 113
 114     //get answer
 115     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 116 }
 117
 118 RUN_CYNARA_TEST(tca05_request_and_cancel2)
 119 {
 120     std::string testNo("05");
 121     int subtest = 2;
 122     cynara_check_id id1, id2;
 123     Client client;
 124
 125     RequestEntity callbackData1 = {[&]()->void {client.cancel(id2);},
 126                                    CYNARA_API_ACCESS_DENIED,
 127                                    CYNARA_CALL_CAUSE_ANSWER};
 128     RequestEntity callbackData2 = {RequestFunction(),
 129                                    CYNARA_API_ACCESS_DENIED,
 130                                    CYNARA_CALL_CAUSE_CANCEL};
 131
 132     client.createRequest({testNo, subtest}, id1, callbackData1);
 133     client.createRequest({testNo, subtest}, id2, callbackData2);
 134     client.assertStatus(READWRITE);
 135
 136     //send requests
 137     client.process();
 138     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 139     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 140 }
 141
 142 RUN_CYNARA_TEST(tca05_request_and_cancel3)
 143 {
 144     std::string testNo("05");
 145     int subtest = 3;
 146     cynara_check_id id;
 147     RequestEntity callbackData = {RequestFunction(),
 148                                   CYNARA_API_ACCESS_DENIED,
 149                                   CYNARA_CALL_CAUSE_ANSWER};
 150
 151     Client client;
 152
 153     client.createRequest({testNo, subtest}, id, callbackData);
 154     client.assertStatus(READWRITE);
 155
 156     //send request
 157     client.process();
 158     client.assertStatus(READ);
 159
 160     //get answer
 161     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 162     client.assertStatus(READ);
 163
 164     client.cancel(id, CYNARA_API_INVALID_PARAM);
 165 }
 166
 167 RUN_CYNARA_TEST(tca06_cancel_fail)
 168 {
 169     cynara_check_id id = 0xDEAD;
 170
 171     Client client;
 172
 173     client.cancel(id, CYNARA_API_INVALID_PARAM);
 174 }
 175
 176 RUN_CYNARA_TEST(tca07_request_with_data_insertion)
 177 {
 178     std::string testNo("07");
 179     Admin admin;
 180     const char *bucket = CYNARA_ADMIN_DEFAULT_BUCKET;
 181     const int resultAllow = CYNARA_ADMIN_ALLOW;
 182     CheckData data[2] = {{testNo, 1}, {testNo, 2}};
 183     RequestEntity callbackAllow = {RequestFunction(),
 184                                    CYNARA_API_ACCESS_ALLOWED,
 185                                    CYNARA_CALL_CAUSE_ANSWER};
 186     RequestEntity callbackDeny = {RequestFunction(),
 187                                   CYNARA_API_ACCESS_DENIED,
 188                                   CYNARA_CALL_CAUSE_ANSWER};
 189     cynara_check_id id;
 190     Client client;
 191
 192     client.checkCache(data[0], CYNARA_API_CACHE_MISS);
 193     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 194
 195     client.createRequest(data[0], id, callbackDeny);
 196     client.assertStatus(READWRITE);
 197     client.process();
 198     client.assertStatus(READ);
 199     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 200     client.assertStatus(READ);
 201
 202     client.checkCache(data[0], CYNARA_API_ACCESS_DENIED);
 203     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 204
 205     {
 206         CynaraPoliciesContainer cp;
 207         cp.add(bucket, data[0].toAdminPolicy(), resultAllow);
 208         admin.setPolicies(cp);
 209     }
 210
 211     client.checkCache(data[0], CYNARA_API_CACHE_MISS);
 212     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 213
 214     client.createRequest(data[0], id, callbackAllow);
 215     client.assertStatus(READWRITE);
 216     client.process();
 217     client.assertStatus(READ);
 218     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 219     client.assertStatus(READ);
 220
 221     client.checkCache(data[0], CYNARA_API_ACCESS_ALLOWED);
 222     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 223 }
 224
 225 RUN_CYNARA_TEST(tca08_disconnect1)
 226 {
 227     std::string testNo("08");
 228     int subtest = 1;
 229     cynara_check_id id;
 230     RequestEntity callbackData = {RequestFunction(),
 231                                   CYNARA_API_ACCESS_DENIED,
 232                                   CYNARA_CALL_CAUSE_ANSWER};
 233     Client client;
 234
 235     client.createRequest({testNo, subtest}, id, callbackData);
 236     client.assertStatus(READWRITE);
 237
 238     restartCynaraServiceAndSockets();
 239
 240     client.process();
 241     client.assertStatus(READ);
 242     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 243 }
 244
 245 RUN_CYNARA_TEST(tca08_disconnect2)
 246 {
 247     std::string testNo("08");
 248     int subtest = 2;
 249     cynara_check_id id;
 250     RequestEntity callbackData = {RequestFunction(),
 251                                   CYNARA_API_ACCESS_DENIED,
 252                                   CYNARA_CALL_CAUSE_ANSWER};
 253     Client client;
 254
 255     client.createRequest({testNo, subtest}, id, callbackData);
 256     client.assertStatus(READWRITE);
 257
 258     restartCynaraServiceAndSockets();
 259
 260     client.process();
 261     client.assertStatus(READ);
 262
 263     restartCynaraServiceAndSockets();
 264
 265     client.process();
 266     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 267 }
 268
 269 RUN_CYNARA_TEST(tca08_disconnect3)
 270 {
 271     std::string testNo("08");
 272     int subtest = 2;
 273     cynara_check_id id;
 274     RequestEntity callbackData = {restartCynaraServiceAndSockets,
 275                                   CYNARA_API_ACCESS_DENIED,
 276                                   CYNARA_CALL_CAUSE_ANSWER};
 277     Client client;
 278
 279     client.createRequest({testNo, subtest}, id, callbackData);
 280     client.assertStatus(READWRITE);
 281
 282     client.process();
 283     client.assertStatus(READ);
 284
 285     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 286     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 287 }
 288
 289 RUN_CYNARA_TEST(tca09_disconnect_and_cancel1)
 290 {
 291     std::string testNo("09");
 292     int subtest = 1;
 293     cynara_check_id id;
 294     RequestEntity callbackData = {RequestFunction(),
 295                                   CYNARA_API_ACCESS_DENIED,
 296                                   CYNARA_CALL_CAUSE_CANCEL};
 297
 298     Client client;
 299
 300     client.createRequest({testNo, subtest}, id, callbackData);
 301     client.assertStatus(READWRITE);
 302
 303     //send request
 304     client.process();
 305     client.assertStatus(READ);
 306
 307     restartCynaraServiceAndSockets();
 308
 309     client.cancel(id);
 310     client.assertStatus(READWRITE);
 311
 312     //send cancel
 313     client.process();
 314     client.assertStatus(READ);
 315
 316     //get answer
 317     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 318     client.assertStatus(READ);
 319 }
 320
 321 RUN_CYNARA_TEST(tca09_disconnect_and_cancel2)
 322 {
 323     std::string testNo("09");
 324     int subtest = 2;
 325     cynara_check_id id;
 326     RequestEntity callbackData = {RequestFunction(),
 327                                   CYNARA_API_ACCESS_DENIED,
 328                                   CYNARA_CALL_CAUSE_CANCEL};
 329
 330     Client client;
 331
 332     client.createRequest({testNo, subtest}, id, callbackData);
 333     client.assertStatus(READWRITE);
 334
 335     //send request
 336     client.process();
 337     client.assertStatus(READ);
 338
 339     client.cancel(id);
 340     client.assertStatus(READWRITE);
 341
 342     restartCynaraServiceAndSockets();
 343
 344     //handle reconnect
 345     client.process();
 346     client.assertStatus(READ);
 347
 348     //get answer
 349     client.process(CYNARA_API_SUCCESS, Client::EXPECT_TIMEOUT);
 350     client.assertStatus(READ);
 351 }
 352
 353 RUN_CYNARA_TEST(tca10_double_request)
 354 {
 355     std::string testNo("10");
 356     cynara_check_id id, id2;
 357     Client client;
 358
 359     RequestEntity callbackData2 = {RequestFunction(),
 360                                   CYNARA_API_ACCESS_DENIED,
 361                                   CYNARA_CALL_CAUSE_ANSWER};
 362
 363     RequestEntity callbackData = {[&](){client.createRequest({testNo}, id2, callbackData2);},
 364                                   CYNARA_API_ACCESS_DENIED,
 365                                   CYNARA_CALL_CAUSE_ANSWER};
 366
 367
 368     client.createRequest({testNo}, id, callbackData);
 369     client.assertStatus(READWRITE);
 370
 371     client.process();
 372     client.process();
 373     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 374     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 375 }
 376
 377 RUN_CYNARA_TEST(tca11_double_request_with_restart)
 378 {
 379     std::string testNo("11");
 380     cynara_check_id id, id2;
 381     Client client;
 382
 383     RequestEntity callbackData2 = {RequestFunction(),
 384                                   CYNARA_API_ACCESS_DENIED,
 385                                   CYNARA_CALL_CAUSE_ANSWER};
 386
 387     RequestEntity callbackData = {[&](){
 388                                       restartCynaraServiceAndSockets();
 389                                       client.createRequest({testNo}, id2, callbackData2);
 390                                   },
 391                                   CYNARA_API_ACCESS_DENIED,
 392                                   CYNARA_CALL_CAUSE_ANSWER};
 393
 394
 395     client.createRequest({testNo}, id, callbackData);
 396     client.assertStatus(READWRITE);
 397
 398     client.process();
 399     client.process();
 400     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 401     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 402 }
 403
 404 RUN_CYNARA_TEST(tca12_multiple_connections_without_requests)
 405 {
 406     std::string testNo("12");
 407
 408     cynara_check_id id;
 409     RequestEntity callbackData = {RequestFunction(),
 410                                   CYNARA_API_ACCESS_DENIED,
 411                                   CYNARA_CALL_CAUSE_FINISH};
 412
 413     ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 414     pid_t before = serviceManager.getServicePid();
 415     timeval beforeTimestamp = serviceManager.getServiceStartTimestamp();
 416
 417     for (int i = 0; i < 10; ++i)
 418     {
 419         Client client;
 420         client.createRequest({testNo}, id, callbackData);
 421         client.assertStatus(READWRITE);
 422     }
 423
 424 //wait until cynara possibly restarts
 425     sleep(3);
 426
 427     pid_t after = serviceManager.getServicePid();
 428     timeval afterTimestamp = serviceManager.getServiceStartTimestamp();
 429     RUNNER_ASSERT_MSG(after != 0,
 430                          "cynara service not running. After = " << after << ".");
 431     RUNNER_ASSERT_MSG(before == after
 432                       && beforeTimestamp.tv_sec == afterTimestamp.tv_sec
 433                       && beforeTimestamp.tv_usec == afterTimestamp.tv_usec,
 434                          "cynara service was restarted during the test. Before pid / timestamp = "
 435                              << before << " / " << beforeTimestamp.tv_sec << "."
 436                              << beforeTimestamp.tv_usec << " and after pid / timestamp = "
 437                              << after << " / " << afterTimestamp.tv_sec << "."
 438                              << afterTimestamp.tv_usec);
 439 }