test/common/protocols/admin/descriptionlistresponse.cpp

   1 /*
   2  * Copyright (c) 2014-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  * @file        test/common/protocols/admin/descriptionlistresponse.cpp
  18  * @author      Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
  19  * @author      Pawel Wieczorek <p.wieczorek2@samsung.com>
  20  * @version     1.0
  21  * @brief       Tests for Cynara::DescriptionListResponse usage in Cynara::ProtocolAdmin
  22  */
  23
  24 #include <vector>
  25
  26 #include <gtest/gtest.h>
  27
  28 #include <protocol/ProtocolAdmin.h>
  29 #include <response/DescriptionListResponse.h>
  30 #include <types/PolicyDescription.h>
  31
  32 #include <ResponseTestHelper.h>
  33 #include <TestDataCollection.h>
  34
  35 namespace {
  36
  37 template<>
  38 void compare(const Cynara::DescriptionListResponse &resp1,
  39              const Cynara::DescriptionListResponse &resp2) {
  40     ASSERT_EQ(resp1.descriptions().size(), resp2.descriptions().size());
  41     for (size_t i = 0U; i < resp1.descriptions().size(); ++i) {
  42         SCOPED_TRACE(std::to_string(i));
  43         EXPECT_EQ(resp1.descriptions()[i].name, resp2.descriptions()[i].name);
  44         EXPECT_EQ(resp1.descriptions()[i].type, resp2.descriptions()[i].type);
  45     }
  46     EXPECT_EQ(resp1.isDbCorrupted(), resp2.isDbCorrupted());
  47 }
  48
  49 static const bool DB_OK = false;
  50 static const bool DB_CORRUPTED = true;
  51
  52 } /* namespace anonymous */
  53
  54 using namespace Cynara;
  55 using namespace ResponseTestHelper;
  56 using namespace TestDataCollection;
  57
  58 /* *** compare by objects test cases *** */
  59
  60 TEST(ProtocolAdmin, DescriptionListResponse01) {
  61     std::vector<PolicyDescription> descriptions = {
  62         PolicyDescription(Types::allow, "allow"),
  63     };
  64
  65     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::min);
  66     auto protocol = std::make_shared<ProtocolAdmin>();
  67     testResponse(response, protocol);
  68 }
  69
  70 TEST(ProtocolAdmin, DescriptionListResponse02) {
  71     std::vector<PolicyDescription> descriptions = {
  72         PolicyDescription(Types::bucket, "bucket"),
  73     };
  74
  75     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::min_1);
  76     auto protocol = std::make_shared<ProtocolAdmin>();
  77     testResponse(response, protocol);
  78 }
  79
  80 TEST(ProtocolAdmin, DescriptionListResponse03) {
  81     std::vector<PolicyDescription> descriptions = {
  82         PolicyDescription(Types::deny, "deny"),
  83     };
  84
  85     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::max);
  86     auto protocol = std::make_shared<ProtocolAdmin>();
  87     testResponse(response, protocol);
  88 }
  89
  90 TEST(ProtocolAdmin, DescriptionListResponse04) {
  91     std::vector<PolicyDescription> descriptions = {
  92         PolicyDescription(Types::none, "none"),
  93     };
  94
  95     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::max_1);
  96     auto protocol = std::make_shared<ProtocolAdmin>();
  97     testResponse(response, protocol);
  98 }
  99
 100 TEST(ProtocolAdmin, DescriptionListResponse05) {
 101     std::vector<PolicyDescription> descriptions = {
 102         PolicyDescription(Types::plugin_type, "plugin"),
 103     };
 104
 105     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::mid);
 106     auto protocol = std::make_shared<ProtocolAdmin>();
 107     testResponse(response, protocol);
 108 }
 109
 110 TEST(ProtocolAdmin, DescriptionListResponseMultipleDescriptions) {
 111     std::vector<PolicyDescription> descriptions = {
 112         PolicyDescription(Types::allow, "allow"),
 113         PolicyDescription(Types::bucket, "bucket"),
 114         PolicyDescription(Types::deny, "deny"),
 115         PolicyDescription(Types::none, "none"),
 116         PolicyDescription(Types::plugin_type, ""),
 117         PolicyDescription(Types::plugin_type, "plugin"),
 118         PolicyDescription(Types::plugin_type, "plugin"),
 119     };
 120
 121     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::max_2);
 122     auto protocol = std::make_shared<ProtocolAdmin>();
 123     testResponse(response, protocol);
 124 }
 125
 126 TEST(ProtocolAdmin, DescriptionListResponseEmptyDescriptions) {
 127     std::vector<PolicyDescription> descriptions;
 128
 129     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::min_2);
 130     auto protocol = std::make_shared<ProtocolAdmin>();
 131     testResponse(response, protocol);
 132 }
 133
 134 /**
 135  * @brief   Verify if DescriptionListResponse is properly (de)serialized while database is corrupted
 136  * @test    Expected result:
 137  * - descriptions vector contains predefined policies ALLOW and DENY
 138  * - dbCorrupted flag set to true (DB_CORRUPTED)
 139  */
 140 TEST(ProtocolAdmin, DescriptionListResponseDatabaseCorrupted) {
 141     std::vector<PolicyDescription> descriptions = {
 142         PolicyDescription(Types::allow, "allow"),
 143         PolicyDescription(Types::bucket, "bucket"),
 144     };
 145
 146     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_CORRUPTED, SN::max);
 147     auto protocol = std::make_shared<ProtocolAdmin>();
 148     testResponse(response, protocol);
 149 }
 150
 151 /* *** compare by serialized data test cases *** */
 152
 153 TEST(ProtocolAdmin, DescriptionListResponseBinary01) {
 154     std::vector<PolicyDescription> descriptions = {
 155         PolicyDescription(Types::allow, "allow"),
 156     };
 157
 158     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::min);
 159     auto protocol = std::make_shared<ProtocolAdmin>();
 160     binaryTestResponse(response, protocol);
 161 }
 162
 163 TEST(ProtocolAdmin, DescriptionListResponseBinary02) {
 164     std::vector<PolicyDescription> descriptions = {
 165         PolicyDescription(Types::bucket, "bucket"),
 166     };
 167
 168     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::min_1);
 169     auto protocol = std::make_shared<ProtocolAdmin>();
 170     binaryTestResponse(response, protocol);
 171 }
 172
 173 TEST(ProtocolAdmin, DescriptionListResponseBinary03) {
 174     std::vector<PolicyDescription> descriptions = {
 175         PolicyDescription(Types::deny, "deny"),
 176     };
 177
 178     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::max);
 179     auto protocol = std::make_shared<ProtocolAdmin>();
 180     binaryTestResponse(response, protocol);
 181 }
 182
 183 TEST(ProtocolAdmin, DescriptionListResponseBinary04) {
 184     std::vector<PolicyDescription> descriptions = {
 185         PolicyDescription(Types::none, "none"),
 186     };
 187
 188     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::max_1);
 189     auto protocol = std::make_shared<ProtocolAdmin>();
 190     binaryTestResponse(response, protocol);
 191 }
 192
 193 TEST(ProtocolAdmin, DescriptionListResponseBinary05) {
 194     std::vector<PolicyDescription> descriptions = {
 195         PolicyDescription(Types::plugin_type, "plugin"),
 196     };
 197
 198     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::mid);
 199     auto protocol = std::make_shared<ProtocolAdmin>();
 200     binaryTestResponse(response, protocol);
 201 }
 202
 203 TEST(ProtocolAdmin, DescriptionListResponseBinaryMultipleDescriptions) {
 204     std::vector<PolicyDescription> descriptions = {
 205         PolicyDescription(Types::allow, "allow"),
 206         PolicyDescription(Types::bucket, "bucket"),
 207         PolicyDescription(Types::deny, "deny"),
 208         PolicyDescription(Types::none, "none"),
 209         PolicyDescription(Types::plugin_type, ""),
 210         PolicyDescription(Types::plugin_type, "plugin"),
 211         PolicyDescription(Types::plugin_type, "plugin"),
 212     };
 213
 214     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::max_2);
 215     auto protocol = std::make_shared<ProtocolAdmin>();
 216     binaryTestResponse(response, protocol);
 217 }
 218
 219 TEST(ProtocolAdmin, DescriptionListResponseBinaryEmptyDescriptions) {
 220     std::vector<PolicyDescription> descriptions;
 221
 222     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_OK, SN::min_2);
 223     auto protocol = std::make_shared<ProtocolAdmin>();
 224     binaryTestResponse(response, protocol);
 225 }
 226
 227 /**
 228  * @brief   Verify if DescriptionListResponse is properly (de)serialized while database is corrupted
 229  * @test    Expected result:
 230  * - descriptions vector contains predefined policies ALLOW and DENY
 231  * - dbCorrupted flag set to true (DB_CORRUPTED)
 232  */
 233 TEST(ProtocolAdmin, DescriptionListResponseBinaryDatabaseCorrupted) {
 234     std::vector<PolicyDescription> descriptions = {
 235         PolicyDescription(Types::allow, "allow"),
 236         PolicyDescription(Types::bucket, "bucket"),
 237     };
 238
 239     auto response = std::make_shared<DescriptionListResponse>(descriptions, DB_CORRUPTED, SN::max);
 240     auto protocol = std::make_shared<ProtocolAdmin>();
 241     binaryTestResponse(response, protocol);
 242 }