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 void tca01_initialize_func()
  40 {
  41     Client client;
  42 }
  43
  44 void tca02_empty_cache_miss_func()
  45 {
  46     std::string testNo("02");
  47     Client client;
  48
  49     client.checkCache({testNo}, CYNARA_API_CACHE_MISS);
  50     client.checkCache({testNo}, CYNARA_API_CACHE_MISS);
  51 }
  52
  53 void tca03_create_max_requests_func()
  54 {
  55     std::string testNo("03");
  56     cynara_check_id id;
  57     RequestEntity callbackData = {RequestFunction(), 0, CYNARA_CALL_CAUSE_FINISH};
  58
  59     Client client;
  60
  61     for (auto i = 0; i <= UINT16_MAX; ++i) {
  62         client.createRequest({testNo, i}, id, callbackData, CYNARA_API_SUCCESS);
  63         client.assertStatus(READWRITE);
  64     }
  65
  66     client.createRequest({testNo}, id, callbackData, CYNARA_API_MAX_PENDING_REQUESTS);
  67     client.assertStatus(READWRITE);
  68 }
  69
  70 void tca04_request_and_process_func()
  71 {
  72     std::string testNo("04");
  73     cynara_check_id id;
  74     RequestEntity callbackData = {RequestFunction(),
  75                                   CYNARA_API_ACCESS_DENIED,
  76                                   CYNARA_CALL_CAUSE_ANSWER};
  77
  78     Client client;
  79
  80     client.createRequest({testNo}, id, callbackData);
  81     client.assertStatus(READWRITE);
  82
  83     //send request
  84     client.process();
  85     client.assertStatus(READ);
  86
  87     //get answer
  88     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
  89 }
  90
  91 void tca05_request_and_cancel1_func()
  92 {
  93     std::string testNo("05");
  94     int subtest = 1;
  95     cynara_check_id id;
  96     RequestEntity callbackData = {RequestFunction(),
  97                                   CYNARA_API_ACCESS_DENIED,
  98                                   CYNARA_CALL_CAUSE_CANCEL};
  99
 100     Client client;
 101
 102     client.createRequest({testNo, subtest}, id, callbackData);
 103     client.assertStatus(READWRITE);
 104
 105     client.cancel(id);
 106     client.assertStatus(READWRITE);
 107
 108     //send request and cancel
 109     client.process();
 110     client.assertStatus(READ);
 111
 112     //get answer
 113     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 114 }
 115
 116 void tca05_request_and_cancel2_func()
 117 {
 118     std::string testNo("05");
 119     int subtest = 2;
 120     cynara_check_id id1, id2;
 121     Client client;
 122
 123     RequestEntity callbackData1 = {[&]()->void {client.cancel(id2);},
 124                                    CYNARA_API_ACCESS_DENIED,
 125                                    CYNARA_CALL_CAUSE_ANSWER};
 126     RequestEntity callbackData2 = {RequestFunction(),
 127                                    CYNARA_API_ACCESS_DENIED,
 128                                    CYNARA_CALL_CAUSE_CANCEL};
 129
 130     client.createRequest({testNo, subtest}, id1, callbackData1);
 131     client.createRequest({testNo, subtest}, id2, callbackData2);
 132     client.assertStatus(READWRITE);
 133
 134     //send requests
 135     client.process();
 136     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 137     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 138 }
 139
 140 void tca05_request_and_cancel3_func()
 141 {
 142     std::string testNo("05");
 143     int subtest = 3;
 144     cynara_check_id id;
 145     RequestEntity callbackData = {RequestFunction(),
 146                                   CYNARA_API_ACCESS_DENIED,
 147                                   CYNARA_CALL_CAUSE_ANSWER};
 148
 149     Client client;
 150
 151     client.createRequest({testNo, subtest}, id, callbackData);
 152     client.assertStatus(READWRITE);
 153
 154     //send request
 155     client.process();
 156     client.assertStatus(READ);
 157
 158     //get answer
 159     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 160     client.assertStatus(READ);
 161
 162     client.cancel(id, CYNARA_API_INVALID_PARAM);
 163 }
 164
 165 void tca06_cancel_fail_func()
 166 {
 167     cynara_check_id id = 0xDEAD;
 168
 169     Client client;
 170
 171     client.cancel(id, CYNARA_API_INVALID_PARAM);
 172 }
 173
 174 void tca07_request_with_data_insertion_func()
 175 {
 176     std::string testNo("07");
 177     Admin admin;
 178     const char *bucket = CYNARA_ADMIN_DEFAULT_BUCKET;
 179     const int resultAllow = CYNARA_ADMIN_ALLOW;
 180     CheckData data[2] = {{testNo, 1}, {testNo, 2}};
 181     RequestEntity callbackAllow = {RequestFunction(),
 182                                    CYNARA_API_ACCESS_ALLOWED,
 183                                    CYNARA_CALL_CAUSE_ANSWER};
 184     RequestEntity callbackDeny = {RequestFunction(),
 185                                   CYNARA_API_ACCESS_DENIED,
 186                                   CYNARA_CALL_CAUSE_ANSWER};
 187     cynara_check_id id;
 188     Client client;
 189
 190     client.checkCache(data[0], CYNARA_API_CACHE_MISS);
 191     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 192
 193     client.createRequest(data[0], id, callbackDeny);
 194     client.assertStatus(READWRITE);
 195     client.process();
 196     client.assertStatus(READ);
 197     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 198     client.assertStatus(READ);
 199
 200     client.checkCache(data[0], CYNARA_API_ACCESS_DENIED);
 201     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 202
 203     {
 204         CynaraPoliciesContainer cp;
 205         cp.add(bucket, data[0].toAdminPolicy(), resultAllow);
 206         admin.setPolicies(cp);
 207     }
 208
 209     client.checkCache(data[0], CYNARA_API_CACHE_MISS);
 210     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 211
 212     client.createRequest(data[0], id, callbackAllow);
 213     client.assertStatus(READWRITE);
 214     client.process();
 215     client.assertStatus(READ);
 216     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 217     client.assertStatus(READ);
 218
 219     client.checkCache(data[0], CYNARA_API_ACCESS_ALLOWED);
 220     client.checkCache(data[1], CYNARA_API_CACHE_MISS);
 221 }
 222
 223 void tca08_disconnect1_func()
 224 {
 225     std::string testNo("08");
 226     int subtest = 1;
 227     cynara_check_id id;
 228     RequestEntity callbackData = {RequestFunction(),
 229                                   CYNARA_API_ACCESS_DENIED,
 230                                   CYNARA_CALL_CAUSE_ANSWER};
 231     Client client;
 232
 233     client.createRequest({testNo, subtest}, id, callbackData);
 234     client.assertStatus(READWRITE);
 235
 236     restartCynaraServiceAndSockets();
 237
 238     client.process();
 239     client.assertStatus(READ);
 240     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 241 }
 242
 243 void tca08_disconnect2_func()
 244 {
 245     std::string testNo("08");
 246     int subtest = 2;
 247     cynara_check_id id;
 248     RequestEntity callbackData = {RequestFunction(),
 249                                   CYNARA_API_ACCESS_DENIED,
 250                                   CYNARA_CALL_CAUSE_ANSWER};
 251     Client client;
 252
 253     client.createRequest({testNo, subtest}, id, callbackData);
 254     client.assertStatus(READWRITE);
 255
 256     restartCynaraServiceAndSockets();
 257
 258     client.process();
 259     client.assertStatus(READ);
 260
 261     restartCynaraServiceAndSockets();
 262
 263     client.process();
 264     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 265 }
 266
 267 void tca08_disconnect3_func()
 268 {
 269     std::string testNo("08");
 270     int subtest = 2;
 271     cynara_check_id id;
 272     RequestEntity callbackData = {restartCynaraServiceAndSockets,
 273                                   CYNARA_API_ACCESS_DENIED,
 274                                   CYNARA_CALL_CAUSE_ANSWER};
 275     Client client;
 276
 277     client.createRequest({testNo, subtest}, id, callbackData);
 278     client.assertStatus(READWRITE);
 279
 280     client.process();
 281     client.assertStatus(READ);
 282
 283     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 284     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 285 }
 286
 287 void tca09_disconnect_and_cancel1_func()
 288 {
 289     std::string testNo("09");
 290     int subtest = 1;
 291     cynara_check_id id;
 292     RequestEntity callbackData = {RequestFunction(),
 293                                   CYNARA_API_ACCESS_DENIED,
 294                                   CYNARA_CALL_CAUSE_CANCEL};
 295
 296     Client client;
 297
 298     client.createRequest({testNo, subtest}, id, callbackData);
 299     client.assertStatus(READWRITE);
 300
 301     //send request
 302     client.process();
 303     client.assertStatus(READ);
 304
 305     restartCynaraServiceAndSockets();
 306
 307     client.cancel(id);
 308     client.assertStatus(READWRITE);
 309
 310     //send cancel
 311     client.process();
 312     client.assertStatus(READ);
 313
 314     //get answer
 315     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 316     client.assertStatus(READ);
 317 }
 318
 319 void tca09_disconnect_and_cancel2_func()
 320 {
 321     std::string testNo("09");
 322     int subtest = 2;
 323     cynara_check_id id;
 324     RequestEntity callbackData = {RequestFunction(),
 325                                   CYNARA_API_ACCESS_DENIED,
 326                                   CYNARA_CALL_CAUSE_CANCEL};
 327
 328     Client client;
 329
 330     client.createRequest({testNo, subtest}, id, callbackData);
 331     client.assertStatus(READWRITE);
 332
 333     //send request
 334     client.process();
 335     client.assertStatus(READ);
 336
 337     client.cancel(id);
 338     client.assertStatus(READWRITE);
 339
 340     restartCynaraServiceAndSockets();
 341
 342     //handle reconnect
 343     client.process();
 344     client.assertStatus(READ);
 345
 346     //get answer
 347     client.process(CYNARA_API_SUCCESS, Client::EXPECT_TIMEOUT);
 348     client.assertStatus(READ);
 349 }
 350
 351 void tca10_double_request_func()
 352 {
 353     std::string testNo("10");
 354     cynara_check_id id, id2;
 355     Client client;
 356
 357     RequestEntity callbackData2 = {RequestFunction(),
 358                                   CYNARA_API_ACCESS_DENIED,
 359                                   CYNARA_CALL_CAUSE_ANSWER};
 360
 361     RequestEntity callbackData = {[&](){client.createRequest({testNo}, id2, callbackData2);},
 362                                   CYNARA_API_ACCESS_DENIED,
 363                                   CYNARA_CALL_CAUSE_ANSWER};
 364
 365
 366     client.createRequest({testNo}, id, callbackData);
 367     client.assertStatus(READWRITE);
 368
 369     client.process();
 370     client.process();
 371     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 372     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 373 }
 374
 375 void tca11_double_request_with_restart_func()
 376 {
 377     std::string testNo("11");
 378     cynara_check_id id, id2;
 379     Client client;
 380
 381     RequestEntity callbackData2 = {RequestFunction(),
 382                                   CYNARA_API_ACCESS_DENIED,
 383                                   CYNARA_CALL_CAUSE_ANSWER};
 384
 385     RequestEntity callbackData = {[&](){
 386                                       restartCynaraServiceAndSockets();
 387                                       client.createRequest({testNo}, id2, callbackData2);
 388                                   },
 389                                   CYNARA_API_ACCESS_DENIED,
 390                                   CYNARA_CALL_CAUSE_ANSWER};
 391
 392
 393     client.createRequest({testNo}, id, callbackData);
 394     client.assertStatus(READWRITE);
 395
 396     client.process();
 397     client.process();
 398     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 399     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 400 }
 401
 402 void tca12_multiple_connections_without_requests_func()
 403 {
 404     std::string testNo("12");
 405
 406     cynara_check_id id;
 407     RequestEntity callbackData = {RequestFunction(),
 408                                   CYNARA_API_ACCESS_DENIED,
 409                                   CYNARA_CALL_CAUSE_FINISH};
 410
 411     ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 412     pid_t before = serviceManager.getServicePid();
 413     timeval beforeTimestamp = serviceManager.getServiceStartTimestamp();
 414
 415     for (int i = 0; i < 10; ++i)
 416     {
 417         Client client;
 418         client.createRequest({testNo}, id, callbackData);
 419         client.assertStatus(READWRITE);
 420     }
 421
 422 //wait until cynara possibly restarts
 423     sleep(3);
 424
 425     pid_t after = serviceManager.getServicePid();
 426     timeval afterTimestamp = serviceManager.getServiceStartTimestamp();
 427     RUNNER_ASSERT_MSG(after != 0,
 428                          "cynara service not running. After = " << after << ".");
 429     RUNNER_ASSERT_MSG(before == after
 430                       && beforeTimestamp.tv_sec == afterTimestamp.tv_sec
 431                       && beforeTimestamp.tv_usec == afterTimestamp.tv_usec,
 432                          "cynara service was restarted during the test. Before pid / timestamp = "
 433                              << before << " / " << beforeTimestamp.tv_sec << "."
 434                              << beforeTimestamp.tv_usec << " and after pid / timestamp = "
 435                              << after << " / " << afterTimestamp.tv_sec << "."
 436                              << afterTimestamp.tv_usec);
 437 }
 438
 439 RUNNER_TEST_GROUP_INIT(cynara_async_tests)
 440
 441 RUN_CYNARA_TEST(tca01_initialize)
 442 RUN_CYNARA_TEST(tca02_empty_cache_miss)
 443 RUN_CYNARA_TEST(tca03_create_max_requests)
 444 RUN_CYNARA_TEST(tca04_request_and_process)
 445 RUN_CYNARA_TEST(tca05_request_and_cancel1)
 446 RUN_CYNARA_TEST(tca05_request_and_cancel2)
 447 RUN_CYNARA_TEST(tca05_request_and_cancel3)
 448 RUN_CYNARA_TEST(tca06_cancel_fail)
 449 RUN_CYNARA_TEST(tca07_request_with_data_insertion)
 450 RUN_CYNARA_TEST(tca08_disconnect1)
 451 RUN_CYNARA_TEST(tca08_disconnect2)
 452 RUN_CYNARA_TEST(tca08_disconnect3)
 453 RUN_CYNARA_TEST(tca09_disconnect_and_cancel1)
 454 RUN_CYNARA_TEST(tca09_disconnect_and_cancel2)
 455 RUN_CYNARA_TEST(tca10_double_request)
 456 RUN_CYNARA_TEST(tca11_double_request_with_restart)
 457 RUN_CYNARA_TEST(tca12_multiple_connections_without_requests)