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