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     ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 228     cynara_check_id id;
 229     RequestEntity callbackData = {RequestFunction(),
 230                                   CYNARA_API_ACCESS_DENIED,
 231                                   CYNARA_CALL_CAUSE_ANSWER};
 232     Client client;
 233
 234     client.createRequest({testNo, subtest}, id, callbackData);
 235     client.assertStatus(READWRITE);
 236
 237     serviceManager.restartService();
 238
 239     client.process();
 240     client.assertStatus(READ);
 241     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 242 }
 243
 244 void tca08_disconnect2_func()
 245 {
 246     std::string testNo("08");
 247     int subtest = 2;
 248     ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 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     serviceManager.restartService();
 259
 260     client.process();
 261     client.assertStatus(READ);
 262
 263     serviceManager.restartService();
 264
 265     client.process();
 266     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 267 }
 268
 269 void tca08_disconnect3_func()
 270 {
 271     std::string testNo("08");
 272     int subtest = 2;
 273     cynara_check_id id;
 274     RequestEntity callbackData = {[&](){
 275                                            ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 276                                            serviceManager.restartService();
 277                                        },
 278                                   CYNARA_API_ACCESS_DENIED,
 279                                   CYNARA_CALL_CAUSE_ANSWER};
 280     Client client;
 281
 282     client.createRequest({testNo, subtest}, id, callbackData);
 283     client.assertStatus(READWRITE);
 284
 285     client.process();
 286     client.assertStatus(READ);
 287
 288     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 289     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 290 }
 291
 292 void tca09_disconnect_and_cancel1_func()
 293 {
 294     std::string testNo("09");
 295     int subtest = 1;
 296     ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 297     cynara_check_id id;
 298     RequestEntity callbackData = {RequestFunction(),
 299                                   CYNARA_API_ACCESS_DENIED,
 300                                   CYNARA_CALL_CAUSE_CANCEL};
 301
 302     Client client;
 303
 304     client.createRequest({testNo, subtest}, id, callbackData);
 305     client.assertStatus(READWRITE);
 306
 307     //send request
 308     client.process();
 309     client.assertStatus(READ);
 310
 311     serviceManager.restartService();
 312
 313     client.cancel(id);
 314     client.assertStatus(READWRITE);
 315
 316     //send cancel
 317     client.process();
 318     client.assertStatus(READ);
 319
 320     //get answer
 321     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 322     client.assertStatus(READ);
 323 }
 324
 325 void tca09_disconnect_and_cancel2_func()
 326 {
 327     std::string testNo("09");
 328     int subtest = 2;
 329     ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 330     cynara_check_id id;
 331     RequestEntity callbackData = {RequestFunction(),
 332                                   CYNARA_API_ACCESS_DENIED,
 333                                   CYNARA_CALL_CAUSE_CANCEL};
 334
 335     Client client;
 336
 337     client.createRequest({testNo, subtest}, id, callbackData);
 338     client.assertStatus(READWRITE);
 339
 340     //send request
 341     client.process();
 342     client.assertStatus(READ);
 343
 344     client.cancel(id);
 345     client.assertStatus(READWRITE);
 346
 347     serviceManager.restartService();
 348
 349     //handle reconnect
 350     client.process();
 351     client.assertStatus(READ);
 352
 353     //get answer
 354     client.process(CYNARA_API_SUCCESS, Client::EXPECT_TIMEOUT);
 355     client.assertStatus(READ);
 356 }
 357
 358 void tca10_double_request_func()
 359 {
 360     std::string testNo("10");
 361     cynara_check_id id, id2;
 362     Client client;
 363
 364     RequestEntity callbackData2 = {RequestFunction(),
 365                                   CYNARA_API_ACCESS_DENIED,
 366                                   CYNARA_CALL_CAUSE_ANSWER};
 367
 368     RequestEntity callbackData = {[&](){client.createRequest({testNo}, id2, callbackData2);},
 369                                   CYNARA_API_ACCESS_DENIED,
 370                                   CYNARA_CALL_CAUSE_ANSWER};
 371
 372
 373     client.createRequest({testNo}, id, callbackData);
 374     client.assertStatus(READWRITE);
 375
 376     client.process();
 377     client.process();
 378     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 379     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 380 }
 381
 382 void tca11_double_request_with_restart_func()
 383 {
 384     std::string testNo("11");
 385     cynara_check_id id, id2;
 386     Client client;
 387
 388     RequestEntity callbackData2 = {RequestFunction(),
 389                                   CYNARA_API_ACCESS_DENIED,
 390                                   CYNARA_CALL_CAUSE_ANSWER};
 391
 392     RequestEntity callbackData = {[&](){
 393                                       ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 394                                       serviceManager.restartService();
 395                                       client.createRequest({testNo}, id2, callbackData2);
 396                                   },
 397                                   CYNARA_API_ACCESS_DENIED,
 398                                   CYNARA_CALL_CAUSE_ANSWER};
 399
 400
 401     client.createRequest({testNo}, id, callbackData);
 402     client.assertStatus(READWRITE);
 403
 404     client.process();
 405     client.process();
 406     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 407     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 408 }
 409
 410 void tca12_multiple_connections_without_requests_func()
 411 {
 412     std::string testNo("12");
 413
 414     cynara_check_id id;
 415     RequestEntity callbackData = {RequestFunction(),
 416                                   CYNARA_API_ACCESS_DENIED,
 417                                   CYNARA_CALL_CAUSE_FINISH};
 418
 419     ServiceManager serviceManager(CynaraTestConsts::SERVICE);
 420     pid_t before = serviceManager.getServicePid();
 421     timeval beforeTimestamp = serviceManager.getServiceStartTimestamp();
 422
 423     for (int i = 0; i < 10; ++i)
 424     {
 425         Client client;
 426         client.createRequest({testNo}, id, callbackData);
 427         client.assertStatus(READWRITE);
 428     }
 429
 430 //wait until cynara possibly restarts
 431     sleep(3);
 432
 433     pid_t after = serviceManager.getServicePid();
 434     timeval afterTimestamp = serviceManager.getServiceStartTimestamp();
 435     RUNNER_ASSERT_MSG(after != 0,
 436                          "cynara service not running. After = " << after << ".");
 437     RUNNER_ASSERT_MSG(before == after
 438                       && beforeTimestamp.tv_sec == afterTimestamp.tv_sec
 439                       && beforeTimestamp.tv_usec == afterTimestamp.tv_usec,
 440                          "cynara service was restarted during the test. Before pid / timestamp = "
 441                              << before << " / " << beforeTimestamp.tv_sec << "."
 442                              << beforeTimestamp.tv_usec << " and after pid / timestamp = "
 443                              << after << " / " << afterTimestamp.tv_sec << "."
 444                              << afterTimestamp.tv_usec);
 445 }
 446
 447 RUNNER_TEST_GROUP_INIT(cynara_async_tests)
 448
 449 RUN_CYNARA_TEST(tca01_initialize)
 450 RUN_CYNARA_TEST(tca02_empty_cache_miss)
 451 RUN_CYNARA_TEST(tca03_create_max_requests)
 452 RUN_CYNARA_TEST(tca04_request_and_process)
 453 RUN_CYNARA_TEST(tca05_request_and_cancel1)
 454 RUN_CYNARA_TEST(tca05_request_and_cancel2)
 455 RUN_CYNARA_TEST(tca05_request_and_cancel3)
 456 RUN_CYNARA_TEST(tca06_cancel_fail)
 457 RUN_CYNARA_TEST(tca07_request_with_data_insertion)
 458 RUN_CYNARA_TEST(tca08_disconnect1)
 459 RUN_CYNARA_TEST(tca08_disconnect2)
 460 RUN_CYNARA_TEST(tca08_disconnect3)
 461 RUN_CYNARA_TEST(tca09_disconnect_and_cancel1)
 462 RUN_CYNARA_TEST(tca09_disconnect_and_cancel2)
 463 RUN_CYNARA_TEST(tca10_double_request)
 464 RUN_CYNARA_TEST(tca11_double_request_with_restart)
 465 RUN_CYNARA_TEST(tca12_multiple_connections_without_requests)