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