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