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(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, wildcard, 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     setAgentPolicy(CYNARA_API_INVALID_PARAM);
  93 }
  94
  95 void tcag02_set_agent_type_policy_with_plugin_loaded_func()
  96 {
  97     loadAgentPlugin();
  98     setAgentPolicy();
  99 }
 100
 101 void tcag03_check_with_no_agent_func()
 102 {
 103     std::string testNo("03");
 104     cynara_check_id id;
 105     RequestEntity callbackData = {RequestFunction(),
 106                                   CYNARA_API_ACCESS_DENIED,
 107                                   CYNARA_CALL_CAUSE_ANSWER};
 108
 109     loadAgentPlugin();
 110     setAgentPolicy();
 111
 112     Client client;
 113     client.createRequest({testNo}, id, callbackData);
 114     client.assertStatus(READWRITE);
 115
 116     //send requests
 117     client.process();
 118     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 119 }
 120
 121 void tcag04_agent_initialize_func()
 122 {
 123     Agent();
 124 }
 125
 126 void tcag05_agent_request_timeout_func()
 127 {
 128     Agent agent;
 129     AgentRequest request;
 130
 131     auto testTimeLimit = std::chrono::seconds(2);
 132     auto hangOnGetRequest = [&agent, &request]() {
 133         agent.getRequest(request, CYNARA_API_SERVICE_NOT_AVAILABLE);
 134     };
 135
 136     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::TIMEOUT,
 137                          restartCynaraServiceAndSockets, hangOnGetRequest);
 138 }
 139
 140 void tcag06_check_with_unregistered_agent_func()
 141 {
 142     std::string testNo("06");
 143     cynara_check_id id;
 144     RequestEntity callbackData = {RequestFunction(),
 145                                   CYNARA_API_ACCESS_DENIED,
 146                                   CYNARA_CALL_CAUSE_ANSWER};
 147
 148     loadAgentPlugin();
 149     setAgentPolicy();
 150
 151     Agent agent;
 152
 153     Client client;
 154     client.createRequest({testNo}, id, callbackData);
 155     client.assertStatus(READWRITE);
 156
 157     //send requests
 158     client.process();
 159     client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
 160 }
 161
 162 void tcag07_get_request_func()
 163 {
 164     std::string testNo("07");
 165     CheckData data(testNo);
 166     cynara_check_id id;
 167     RequestEntity callbackData = {RequestFunction(),
 168                                   CYNARA_API_ACCESS_ALLOWED,
 169                                   CYNARA_CALL_CAUSE_ANSWER};
 170
 171     loadAgentPlugin();
 172     setAgentPolicy();
 173
 174     Agent agent;
 175     AgentRequest agentRequest;
 176     Client client;
 177     client.createRequest(data, id, callbackData);
 178     client.assertStatus(READWRITE);
 179
 180     auto testTimeLimit = std::chrono::seconds(5);
 181     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 182                          restartCynaraServiceAndSockets, getAgentRequest,
 183                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 184                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 185
 186     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 187     agent.putResponse(AgentResponse::createAllow(agentRequest.id()));
 188     client.process();
 189 }
 190
 191 void tcag08_get_request_and_respond_with_wrong_id_func()
 192 {
 193     std::string testNo("08");
 194     CheckData data(testNo);
 195     cynara_check_id id;
 196     RequestEntity callbackData = {RequestFunction(),
 197                                   CYNARA_API_SUCCESS,
 198                                   CYNARA_CALL_CAUSE_FINISH};
 199
 200     loadAgentPlugin();
 201     setAgentPolicy();
 202
 203     Agent agent;
 204     AgentRequest agentRequest;
 205     Client client;
 206     client.createRequest(data, id, callbackData);
 207     client.assertStatus(READWRITE);
 208
 209     auto testTimeLimit = std::chrono::seconds(5);
 210     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 211                          restartCynaraServiceAndSockets, getAgentRequest,
 212                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 213                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 214     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 215     agent.putResponse(AgentResponse::createAllow(agentRequest.id() + 1));
 216     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_TIMEOUT, 2);
 217 }
 218
 219 void tcag09_get_request_and_correct_responded_id_func()
 220 {
 221     std::string testNo("09");
 222     CheckData data(testNo);
 223     cynara_check_id id;
 224     RequestEntity callbackData = {RequestFunction(),
 225                                   CYNARA_API_ACCESS_ALLOWED,
 226                                   CYNARA_CALL_CAUSE_ANSWER};
 227
 228     loadAgentPlugin();
 229     setAgentPolicy();
 230
 231     Agent agent;
 232     AgentRequest agentRequest;
 233     Client client;
 234     client.createRequest(data, id, callbackData);
 235     client.assertStatus(READWRITE);
 236
 237     auto testTimeLimit = std::chrono::seconds(5);
 238     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 239                          restartCynaraServiceAndSockets, getAgentRequest,
 240                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 241                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 242     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 243     agent.putResponse(AgentResponse::createAllow(agentRequest.id() + 1));
 244     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_TIMEOUT, 2);
 245     agent.putResponse(AgentResponse::createAllow(agentRequest.id()));
 246     client.process();
 247 }
 248
 249 void tcag10_cancel_request_func()
 250 {
 251     std::string testNo("10");
 252     CheckData data(testNo);
 253     cynara_check_id id;
 254     RequestEntity callbackData = {RequestFunction(),
 255                                   CYNARA_API_ACCESS_ALLOWED,
 256                                   CYNARA_CALL_CAUSE_CANCEL};
 257
 258     loadAgentPlugin();
 259     setAgentPolicy();
 260
 261     Agent agent;
 262     AgentRequest agentRequest;
 263
 264     Client client;
 265     client.createRequest(data, id, callbackData);
 266     client.assertStatus(READWRITE);
 267
 268     auto testTimeLimit = std::chrono::seconds(5);
 269     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 270                          restartCynaraServiceAndSockets, getAgentRequest,
 271                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 272                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 273     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 274     client.cancel(id);
 275     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 276                          restartCynaraServiceAndSockets, getAgentRequest,
 277                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 278                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 279     agentRequest.assertCancel();
 280     agent.putResponse(AgentResponse::createCancel(id));
 281     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 282 }
 283
 284 void tcag11_cancel_processed_request_func()
 285 {
 286     std::string testNo("11");
 287     CheckData data(testNo);
 288     cynara_check_id id;
 289     RequestEntity callbackData = {RequestFunction(),
 290                                   CYNARA_API_ACCESS_ALLOWED,
 291                                   CYNARA_CALL_CAUSE_CANCEL};
 292
 293     loadAgentPlugin();
 294     setAgentPolicy();
 295
 296     Agent agent;
 297     AgentRequest agentRequest;
 298
 299     Client client;
 300     client.createRequest(data, id, callbackData);
 301     client.assertStatus(READWRITE);
 302
 303     auto testTimeLimit = std::chrono::seconds(5);
 304     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 305                          restartCynaraServiceAndSockets, getAgentRequest,
 306                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 307                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 308     agentRequest.assertAction(data.m_client, data.m_user, data.m_privilege);
 309     agent.putResponse(AgentResponse::createCancel(id));
 310     client.cancel(id);
 311     // we do not expect getting the cancel request in the agent
 312     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::TIMEOUT,
 313                          restartCynaraServiceAndSockets, getAgentRequest,
 314                          std::ref(agent), std::ref(agentRequest), std::ref(client),
 315                          CYNARA_API_SERVICE_NOT_AVAILABLE, Timeout::ExpectMode::TIMEOUT);
 316     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 317 }
 318
 319 void tcag12_create_two_requests_func()
 320 {
 321     std::string testNo("12");
 322     CheckData data1(testNo, 1), data2(testNo, 2);
 323     cynara_check_id id1, id2;
 324     RequestEntity callbackData1 = {RequestFunction(),
 325                                    CYNARA_API_ACCESS_DENIED,
 326                                    CYNARA_CALL_CAUSE_ANSWER};
 327     RequestEntity callbackData2 = {RequestFunction(),
 328                                    CYNARA_API_ACCESS_ALLOWED,
 329                                    CYNARA_CALL_CAUSE_CANCEL};
 330
 331     loadAgentPlugin();
 332     setAgentPolicy();
 333
 334     Agent agent;
 335     AgentRequest agentRequest1, agentRequest2, agentRequest3;
 336     Client client;
 337     client.createRequest(data1, id1, callbackData1);
 338     client.assertStatus(READWRITE);
 339     client.createRequest(data2, id2, callbackData2);
 340     client.assertStatus(READWRITE);
 341
 342     auto testTimeLimit = std::chrono::seconds(5);
 343     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 344                          restartCynaraServiceAndSockets, getAgentRequest,
 345                          std::ref(agent), std::ref(agentRequest1), std::ref(client),
 346                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 347     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 348                          restartCynaraServiceAndSockets, getAgentRequest,
 349                          std::ref(agent), std::ref(agentRequest2), std::ref(client),
 350                          CYNARA_API_SUCCESS, Timeout::ExpectMode::IGNORE);
 351     client.cancel(id2);
 352     client.assertStatus(READWRITE);
 353     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 354                          restartCynaraServiceAndSockets, getAgentRequest,
 355                          std::ref(agent), std::ref(agentRequest3), std::ref(client),
 356                          CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 357     agentRequest1.assertAction(data1.m_client, data1.m_user, data1.m_privilege);
 358     agentRequest2.assertAction(data2.m_client, data2.m_user, data2.m_privilege);
 359     agentRequest3.assertCancel();
 360
 361     agent.putResponse(AgentResponse::createDeny(id1));
 362     agent.putResponse(AgentResponse::createCancel(id2));
 363
 364     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 3);
 365     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::IGNORE_TIMEOUT, 1);
 366 }
 367
 368 void tcag13_create_many_requests_func()
 369 {
 370     const int numberOfRequests = 4;
 371     std::string testNo("13");
 372     cynara_check_id ids[numberOfRequests];
 373     RequestEntity callbackData = {RequestFunction(),
 374                                   CYNARA_API_ACCESS_DENIED,
 375                                   CYNARA_CALL_CAUSE_ANSWER};
 376     loadAgentPlugin();
 377     setAgentPolicy();
 378
 379     Agent agent;
 380     AgentRequest agentRequests[numberOfRequests];
 381     Client client;
 382     for (int i = 0; i < numberOfRequests; i++) {
 383         CheckData data(testNo, i);
 384         client.createRequest(data, ids[i], callbackData);
 385         client.assertStatus(READWRITE);
 386         auto testTimeLimit = std::chrono::seconds(5);
 387         Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 388                              restartCynaraServiceAndSockets, getAgentRequest,
 389                              std::ref(agent), std::ref(agentRequests[i]), std::ref(client),
 390                              CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 391         agentRequests[i].assertAction(data.m_client, data.m_user, data.m_privilege);
 392     };
 393     for (int i = numberOfRequests - 1; i >= 0; i--) {
 394         agent.putResponse(AgentResponse::createDeny(ids[i]));
 395         client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 396     }
 397 }
 398
 399 void tcag14_client_disconnects_func()
 400 {
 401     std::string testNo("14");
 402     CheckData data(testNo);
 403     cynara_check_id id;
 404     RequestEntity callbackData = {RequestFunction(),
 405                                   CYNARA_API_ACCESS_ALLOWED,
 406                                   CYNARA_CALL_CAUSE_FINISH};
 407
 408     loadAgentPlugin();
 409     setAgentPolicy();
 410     Agent agent;
 411     AgentRequest agentRequest;
 412     auto testTimeLimit = std::chrono::seconds(5);
 413     {
 414         Client client;
 415         client.createRequest(data, id, callbackData);
 416         client.assertStatus(READWRITE);
 417         Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 418                              restartCynaraServiceAndSockets, getAgentRequest,
 419                              std::ref(agent), std::ref(agentRequest), std::ref(client),
 420                              CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 421     };
 422     auto getAgentRequestWrap = [&agent, &agentRequest]() {
 423             agent.getRequest(agentRequest, CYNARA_API_SUCCESS);
 424         };
 425     Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 426                          restartCynaraServiceAndSockets, getAgentRequestWrap);
 427     agentRequest.assertCancel();
 428 }
 429
 430 void tcag15_agent_disconnects_func()
 431 {
 432     std::string testNo("15");
 433     CheckData data(testNo);
 434     cynara_check_id id;
 435     RequestEntity callbackData = {RequestFunction(),
 436                                   CYNARA_API_ACCESS_DENIED,
 437                                   CYNARA_CALL_CAUSE_ANSWER};
 438
 439     loadAgentPlugin();
 440     setAgentPolicy();
 441     Client client;
 442     client.createRequest(data, id, callbackData);
 443     client.assertStatus(READWRITE);
 444     AgentRequest agentRequest;
 445     {
 446         Agent agent;
 447         auto testTimeLimit = std::chrono::seconds(5);
 448         Timeout::callAndWait(testTimeLimit, Timeout::ExpectMode::FINISHED,
 449                              restartCynaraServiceAndSockets, getAgentRequest,
 450                              std::ref(agent), std::ref(agentRequest), std::ref(client),
 451                              CYNARA_API_SUCCESS, Timeout::ExpectMode::TIMEOUT);
 452     };
 453     client.process(CYNARA_API_SUCCESS, Client::TimeoutExpectation::EXPECT_NO_TIMEOUT, 2);
 454 }
 455
 456 RUNNER_TEST_GROUP_INIT(cynara_agent_tests)
 457
 458 RUN_CYNARA_TEST(tcag01_set_agent_type_policy_without_plugin)
 459 RUN_CYNARA_TEST(tcag02_set_agent_type_policy_with_plugin_loaded)
 460 RUN_CYNARA_TEST(tcag03_check_with_no_agent)
 461 RUN_CYNARA_TEST(tcag04_agent_initialize)
 462 RUN_CYNARA_TEST(tcag05_agent_request_timeout)
 463 RUN_CYNARA_TEST(tcag06_check_with_unregistered_agent)
 464 RUN_CYNARA_TEST(tcag07_get_request)
 465 RUN_CYNARA_TEST(tcag08_get_request_and_respond_with_wrong_id)
 466 RUN_CYNARA_TEST(tcag09_get_request_and_correct_responded_id)
 467 RUN_CYNARA_TEST(tcag10_cancel_request)
 468 RUN_CYNARA_TEST(tcag11_cancel_processed_request)
 469 RUN_CYNARA_TEST(tcag12_create_two_requests)
 470 RUN_CYNARA_TEST(tcag13_create_many_requests)
 471 RUN_CYNARA_TEST(tcag14_client_disconnects)
 472 RUN_CYNARA_TEST(tcag15_agent_disconnects)