src/cynara-tests/test_cases_monitor.cpp

   1 /*
   2  * Copyright (c) 2015 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_agent.cpp
  19  * @author      Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
  20  * @author      Radoslaw Bartosiak <r.bartosiak@samsung.com>
  21  * @version     1.0
  22  * @brief       Tests for libcynara-agent
  23  */
  24
  25 #include <chrono>
  26 #include <string>
  27
  28 #include <cynara-client-async.h>
  29 #include <cynara-monitor.h>
  30
  31 #include <dpl/test/test_runner.h>
  32 #include <cynara_test_client_async_client.h>
  33 #include <cynara_test_commons.h>
  34 #include <cynara_test_env.h>
  35 #include <service_manager.h>
  36 #include <timeout.h>
  37
  38 using namespace CynaraTestClientAsync;
  39
  40 void getAgentRequest(Agent &agent, AgentRequest &request, Client &client,
  41                      int expectedResult = CYNARA_API_SUCCESS,
  42                      Timeout::ExpectMode expectTimeoutMode = Timeout::ExpectMode::TIMEOUT)
  43 {
  44     auto timeLimit = std::chrono::seconds(2);
  45     auto hangOnGetRequest = [&agent, &request, &expectedResult]() {
  46         agent.getRequest(request, expectedResult);
  47     };
  48     Timeout::CancelFunction sendClientRequest = [&client]() {
  49         client.process();
  50         client.assertStatus(READ);
  51     };
  52
  53     Timeout::callAndWait(timeLimit, expectTimeoutMode,
  54                          sendClientRequest, hangOnGetRequest);
  55 }
  56
  57 void tcm01_config_invalid_param()
  58 {
  59     int ret = cynara_monitor_configuration_create(nullptr);
  60     RUNNER_ASSERT_MSG(ret != CYNARA_API_SUCCESS,
  61                       "cynara_monitor_configuration_create accepted nullptr as placeholder");
  62     RUNNER_ASSERT_MSG(ret != CYNARA_API_INVALID_PARAM,
  63                       "cynara_monitor_configuration_create returned wrong error : " << ret);
  64 }
  65
  66 void tcm02_config_buffer_oversize()
  67 {
  68     cynara_monitor_configuration *p_conf;
  69     int ret = cynara_monitor_configuration_create(&p_conf);
  70     RUNNER_ASSERT_MSG(ret == CYNARA_API_SUCCESS, "cynara_monitor_configuration_create failed with "
  71                       << ret);
  72     std::unique_ptr<cynara_monitor_configuration, void(cynara_monitor_configuration*)>
  73         confPtr(p_conf, cynara_monitor_configuration_destroy);
  74     size_t oversize = CYNARA_MAX_MONITOR_BUFFER_SIZE + 1
  75     ret = cynara_monitor_configuration_set_buffer_size(p_conf, oversize);
  76     RUNNER_ASSERT_MSG(ret == CYNARA_API_INVALID_PARAM,
  77                       "cynara_monitor_configuration_set_buffer_size accepted buffer of size "
  78                        << oversize);
  79 }
  80
  81 void tcm03_init_invalid_param()
  82 {
  83     int ret = cynara_monitor_initialize(nullptr, nullptr);
  84     RUNNER_ASSERT_MSG(ret != CYNARA_API_SUCCESS,
  85                       "cynara_monitor_configuration_create accepted nullptr as placeholder");
  86     RUNNER_ASSERT_MSG(ret != CYNARA_API_INVALID_PARAM,
  87                       "cynara_monitor_configuration_create returned wrong error : " << ret);
  88 }
  89
  90 void tcag01_set_agent_type_policy_without_plugin_func()
  91 {
  92     loadServicePlugins(DirectoryPaths());
  93     setAgentPolicy(CYNARA_API_INVALID_PARAM);
  94 }
  95
  96 void tcag02_set_agent_type_policy_with_plugin_loaded_func()
  97 {
  98     loadAgentPlugin();
  99     setAgentPolicy();
 100 }
 101
 102 void tcag03_check_with_no_agent_func()
 103 {
 104     std::string testNo("03");
 105     cynara_check_id id;
 106     RequestEntity callbackData = {RequestFunction(),
 107                                   CYNARA_API_ACCESS_DENIED,
 108                                   CYNARA_CALL_CAUSE_ANSWER};
 109
 110     loadAgentPlugin();
 111     setAgentPolicy();
 112
 113     Client client;
 114     client.createRequest({testNo}, id, callbackData);
 115     client.assertStatus(READWRITE);
 116
 117     //send requests
 118     client.process();
 119     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 120 }
 121
 122 void tcag04_agent_initialize_func()
 123 {
 124     Agent();
 125 }
 126
 127 void tcag05_agent_request_timeout_func()
 128 {
 129     Agent agent;
 130     AgentRequest request;
 131
 132     auto testTimeLimit = std::chrono::seconds(2);
 133     auto hangOnGetRequest = [&agent, &request]() {
 134         agent.getRequest(request, CYNARA_API_SERVICE_NOT_AVAILABLE);
 135     };
 136
 137     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::TIMEOUT,
 138                          restartCynaraServiceAndSockets, hangOnGetRequest);
 139 }
 140
 141 void tcag06_check_with_unregistered_agent_func()
 142 {
 143     std::string testNo("06");
 144     cynara_check_id id;
 145     RequestEntity callbackData = {RequestFunction(),
 146                                   CYNARA_API_ACCESS_DENIED,
 147                                   CYNARA_CALL_CAUSE_ANSWER};
 148
 149     loadAgentPlugin();
 150     setAgentPolicy();
 151
 152     Agent agent;
 153
 154     Client client;
 155     client.createRequest({testNo}, id, callbackData);
 156     client.assertStatus(READWRITE);
 157
 158     //send requests
 159     client.process();
 160     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 161 }
 162
 163 void tcag07_get_request_func()
 164 {
 165     std::string testNo("07");
 166     CheckData data(testNo);
 167     cynara_check_id id;
 168     RequestEntity callbackData = {RequestFunction(),
 169                                   CYNARA_API_ACCESS_ALLOWED,
 170                                   CYNARA_CALL_CAUSE_ANSWER};
 171
 172     loadAgentPlugin();
 173     setAgentPolicy();
 174
 175     Agent agent;
 176     AgentRequest agentRequest;
 177     Client client;
 178     client.createRequest(data, id, callbackData);
 179     client.assertStatus(READWRITE);
 180
 181     auto testTimeLimit = std::chrono::seconds(5);
 182     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 183                          restartCynaraServiceAndSockets, getAgentRequest,
 184                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 185                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 186
 187     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 188     agent.putResponse(AgentResponse::createAllow(agentRequest.id()));
 189     client.process();
 190 }
 191
 192 void tcag08_get_request_and_respond_with_wrong_id_func()
 193 {
 194     std::string testNo("08");
 195     CheckData data(testNo);
 196     cynara_check_id id;
 197     RequestEntity callbackData = {RequestFunction(),
 198                                   CYNARA_API_SUCCESS,
 199                                   CYNARA_CALL_CAUSE_FINISH};
 200
 201     loadAgentPlugin();
 202     setAgentPolicy();
 203
 204     Agent agent;
 205     AgentRequest agentRequest;
 206     Client client;
 207     client.createRequest(data, id, callbackData);
 208     client.assertStatus(READWRITE);
 209
 210     auto testTimeLimit = std::chrono::seconds(5);
 211     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 212                          restartCynaraServiceAndSockets, getAgentRequest,
 213                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 214                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 215     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 216     agent.putResponse(AgentResponse::createAllow(agentRequest.id() + 1));
 217     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_TIMEOUT, 2);
 218 }
 219
 220 void tcag09_get_request_and_correct_responded_id_func()
 221 {
 222     std::string testNo("09");
 223     CheckData data(testNo);
 224     cynara_check_id id;
 225     RequestEntity callbackData = {RequestFunction(),
 226                                   CYNARA_API_ACCESS_ALLOWED,
 227                                   CYNARA_CALL_CAUSE_ANSWER};
 228
 229     loadAgentPlugin();
 230     setAgentPolicy();
 231
 232     Agent agent;
 233     AgentRequest agentRequest;
 234     Client client;
 235     client.createRequest(data, id, callbackData);
 236     client.assertStatus(READWRITE);
 237
 238     auto testTimeLimit = std::chrono::seconds(5);
 239     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 240                          restartCynaraServiceAndSockets, getAgentRequest,
 241                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 242                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 243     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 244     agent.putResponse(AgentResponse::createAllow(agentRequest.id() + 1));
 245     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_TIMEOUT, 2);
 246     agent.putResponse(AgentResponse::createAllow(agentRequest.id()));
 247     client.process();
 248 }
 249
 250 void tcag10_cancel_request_func()
 251 {
 252     std::string testNo("10");
 253     CheckData data(testNo);
 254     cynara_check_id id;
 255     RequestEntity callbackData = {RequestFunction(),
 256                                   CYNARA_API_ACCESS_ALLOWED,
 257                                   CYNARA_CALL_CAUSE_CANCEL};
 258
 259     loadAgentPlugin();
 260     setAgentPolicy();
 261
 262     Agent agent;
 263     AgentRequest agentRequest;
 264
 265     Client client;
 266     client.createRequest(data, id, callbackData);
 267     client.assertStatus(READWRITE);
 268
 269     auto testTimeLimit = std::chrono::seconds(5);
 270     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 271                          restartCynaraServiceAndSockets, getAgentRequest,
 272                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 273                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 274     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 275     client.cancel(id);
 276     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 277                          restartCynaraServiceAndSockets, getAgentRequest,
 278                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 279                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 280     agentRequest.assertCancel();
 281     agent.putResponse(AgentResponse::createCancel(id));
 282     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 283 }
 284
 285 void tcag11_cancel_processed_request_func()
 286 {
 287     std::string testNo("11");
 288     CheckData data(testNo);
 289     cynara_check_id id;
 290     RequestEntity callbackData = {RequestFunction(),
 291                                   CYNARA_API_ACCESS_ALLOWED,
 292                                   CYNARA_CALL_CAUSE_CANCEL};
 293
 294     loadAgentPlugin();
 295     setAgentPolicy();
 296
 297     Agent agent;
 298     AgentRequest agentRequest;
 299
 300     Client client;
 301     client.createRequest(data, id, callbackData);
 302     client.assertStatus(READWRITE);
 303
 304     auto testTimeLimit = std::chrono::seconds(5);
 305     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 306                          restartCynaraServiceAndSockets, getAgentRequest,
 307                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 308                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 309     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 310     agent.putResponse(AgentResponse::createCancel(id));
 311     client.cancel(id);
 312     // we do not expect getting the cancel request in the agent
 313     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::TIMEOUT,
 314                          restartCynaraServiceAndSockets, getAgentRequest,
 315                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 316                          CYNARA_API_SERVICE_NOT_AVAILABLE, Timeout::ExpectMode::TIMEOUT);
 317     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 318 }
 319
 320 void tcag12_create_two_requests_func()
 321 {
 322     std::string testNo("12");
 323     CheckData data1(testNo, 1), data2(testNo, 2);
 324     cynara_check_id id1, id2;
 325     RequestEntity callbackData1 = {RequestFunction(),
 326                                    CYNARA_API_ACCESS_DENIED,
 327                                    CYNARA_CALL_CAUSE_ANSWER};
 328     RequestEntity callbackData2 = {RequestFunction(),
 329                                    CYNARA_API_ACCESS_ALLOWED,
 330                                    CYNARA_CALL_CAUSE_CANCEL};
 331
 332     loadAgentPlugin();
 333     setAgentPolicy();
 334
 335     Agent agent;
 336     AgentRequest agentRequest1, agentRequest2, agentRequest3;
 337     Client client;
 338     client.createRequest(data1, id1, callbackData1);
 339     client.assertStatus(READWRITE);
 340     client.createRequest(data2, id2, callbackData2);
 341     client.assertStatus(READWRITE);
 342
 343     auto testTimeLimit = std::chrono::seconds(5);
 344     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 345                          restartCynaraServiceAndSockets, getAgentRequest,
 346                          std::ref(agent), std::ref(agentRequest1), std::ref(client),
 347                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 348     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 349                          restartCynaraServiceAndSockets, getAgentRequest,
 350                          std::ref(agent), std::ref(agentRequest2), std::ref(client),
 351                          CYNARA_API_SUCCESS, Timeout::ExpectMode::IGNORE);
 352     client.cancel(id2);
 353     client.assertStatus(READWRITE);
 354     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 355                          restartCynaraServiceAndSockets, getAgentRequest,
 356                          std::ref(agent), std::ref(agentRequest3), std::ref(client),
 357                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 358     agentRequest1.assertAction(data1.m_client, data1.m_user, data1.m_privilege);
 359     agentRequest2.assertAction(data2.m_client, data2.m_user, data2.m_privilege);
 360     agentRequest3.assertCancel();
 361
 362     agent.putResponse(AgentResponse::createDeny(id1));
 363     agent.putResponse(AgentResponse::createCancel(id2));
 364
 365     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 3);
 366     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::IGNORE_TIMEOUT, 1);
 367 }
 368
 369 void tcag13_create_many_requests_func()
 370 {
 371     const int numberOfRequests = 4;
 372     std::string testNo("13");
 373     cynara_check_id ids[numberOfRequests];
 374     RequestEntity callbackData = {RequestFunction(),
 375                                   CYNARA_API_ACCESS_DENIED,
 376                                   CYNARA_CALL_CAUSE_ANSWER};
 377     loadAgentPlugin();
 378     setAgentPolicy();
 379
 380     Agent agent;
 381     AgentRequest agentRequests[numberOfRequests];
 382     Client client;
 383     for (int i = 0; i < numberOfRequests; i++) {
 384         CheckData data(testNo, i);
 385         client.createRequest(data, ids[i], callbackData);
 386         client.assertStatus(READWRITE);
 387         auto testTimeLimit = std::chrono::seconds(5);
 388         Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 389                              restartCynaraServiceAndSockets, getAgentRequest,
 390                              std::ref(agent), std::ref(agentRequests[i]), std::ref(client),
 391                              CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 392         agentRequests[i].assertAction(data.m_client, data.m_user, data.m_privilege);
 393     };
 394     for (int i = numberOfRequests - 1; i >= 0; i--) {
 395         agent.putResponse(AgentResponse::createDeny(ids[i]));
 396         client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 397     }
 398 }
 399
 400 void tcag14_client_disconnects_func()
 401 {
 402     std::string testNo("14");
 403     CheckData data(testNo);
 404     cynara_check_id id;
 405     RequestEntity callbackData = {RequestFunction(),
 406                                   CYNARA_API_ACCESS_ALLOWED,
 407                                   CYNARA_CALL_CAUSE_FINISH};
 408
 409     loadAgentPlugin();
 410     setAgentPolicy();
 411     Agent agent;
 412     AgentRequest agentRequest;
 413     auto testTimeLimit = std::chrono::seconds(5);
 414     {
 415         Client client;
 416         client.createRequest(data, id, callbackData);
 417         client.assertStatus(READWRITE);
 418         Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 419                              restartCynaraServiceAndSockets, getAgentRequest,
 420                              std::ref(agent), std::ref(agentRequest), std::ref(client),
 421                              CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 422     };
 423     auto getAgentRequestWrap = [&agent, &agentRequest]() {
 424             agent.getRequest(agentRequest, CYNARA_API_SUCCESS);
 425         };
 426     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 427                          restartCynaraServiceAndSockets, getAgentRequestWrap);
 428     agentRequest.assertCancel();
 429 }
 430
 431 void tcag15_agent_disconnects_func()
 432 {
 433     std::string testNo("15");
 434     CheckData data(testNo);
 435     cynara_check_id id;
 436     RequestEntity callbackData = {RequestFunction(),
 437                                   CYNARA_API_ACCESS_DENIED,
 438                                   CYNARA_CALL_CAUSE_ANSWER};
 439
 440     loadAgentPlugin();
 441     setAgentPolicy();
 442     Client client;
 443     client.createRequest(data, id, callbackData);
 444     client.assertStatus(READWRITE);
 445     AgentRequest agentRequest;
 446     {
 447         Agent agent;
 448         auto testTimeLimit = std::chrono::seconds(5);
 449         Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 450                              restartCynaraServiceAndSockets, getAgentRequest,
 451                              std::ref(agent), std::ref(agentRequest), std::ref(client),
 452                              CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 453     };
 454     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 455 }
 456
 457 RUNNER_TEST_GROUP_INIT(cynara_agent_tests)
 458
 459 RUN_CYNARA_TEST(tcag01_set_agent_type_policy_without_plugin)
 460 RUN_CYNARA_TEST(tcag02_set_agent_type_policy_with_plugin_loaded)
 461 RUN_CYNARA_TEST(tcag03_check_with_no_agent)
 462 RUN_CYNARA_TEST(tcag04_agent_initialize)
 463 RUN_CYNARA_TEST(tcag05_agent_request_timeout)
 464 RUN_CYNARA_TEST(tcag06_check_with_unregistered_agent)
 465 RUN_CYNARA_TEST(tcag07_get_request)
 466 RUN_CYNARA_TEST(tcag08_get_request_and_respond_with_wrong_id)
 467 RUN_CYNARA_TEST(tcag09_get_request_and_correct_responded_id)
 468 RUN_CYNARA_TEST(tcag10_cancel_request)
 469 RUN_CYNARA_TEST(tcag11_cancel_processed_request)
 470 RUN_CYNARA_TEST(tcag12_create_two_requests)
 471 RUN_CYNARA_TEST(tcag13_create_many_requests)
 472 RUN_CYNARA_TEST(tcag14_client_disconnects)
 473 RUN_CYNARA_TEST(tcag15_agent_disconnects)