test/common/protocols/admin/descriptionlistresponse.cpp

   1 /*
   2  * Copyright (c) 2014 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  * @version     1.0
  20  * @brief       Tests for Cynara::DescriptionListResponse usage in Cynara::ProtocolAdmin
  21  */
  22
  23 #include <vector>
  24
  25 #include <gtest/gtest.h>
  26
  27 #include <protocol/ProtocolAdmin.h>
  28 #include <response/DescriptionListResponse.h>
  29 #include <types/PolicyDescription.h>
  30
  31 #include <ResponseTestHelper.h>
  32 #include <TestDataCollection.h>
  33
  34 namespace {
  35
  36 template<>
  37 void compare(const Cynara::DescriptionListResponse &resp1,
  38              const Cynara::DescriptionListResponse &resp2) {
  39     ASSERT_EQ(resp1.descriptions().size(), resp2.descriptions().size());
  40     for (size_t i = 0U; i < resp1.descriptions().size(); ++i) {
  41         SCOPED_TRACE(std::to_string(i));
  42         EXPECT_EQ(resp1.descriptions()[i].name, resp2.descriptions()[i].name);
  43         EXPECT_EQ(resp1.descriptions()[i].type, resp2.descriptions()[i].type);
  44     }
  45 }
  46
  47 } /* namespace anonymous */
  48
  49 using namespace Cynara;
  50 using namespace ResponseTestHelper;
  51 using namespace TestDataCollection;
  52
  53 /* *** compare by objects test cases *** */
  54
  55 TEST(ProtocolAdmin, DescriptionListResponse01) {
  56     std::vector<PolicyDescription> descriptions = {
  57         PolicyDescription(Types::allow, "allow"),
  58     };
  59
  60     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::min);
  61     auto protocol = std::make_shared<ProtocolAdmin>();
  62     testResponse(response, protocol);
  63 }
  64
  65 TEST(ProtocolAdmin, DescriptionListResponse02) {
  66     std::vector<PolicyDescription> descriptions = {
  67         PolicyDescription(Types::bucket, "bucket"),
  68     };
  69
  70     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::min_1);
  71     auto protocol = std::make_shared<ProtocolAdmin>();
  72     testResponse(response, protocol);
  73 }
  74
  75 TEST(ProtocolAdmin, DescriptionListResponse03) {
  76     std::vector<PolicyDescription> descriptions = {
  77         PolicyDescription(Types::deny, "deny"),
  78     };
  79
  80     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::max);
  81     auto protocol = std::make_shared<ProtocolAdmin>();
  82     testResponse(response, protocol);
  83 }
  84
  85 TEST(ProtocolAdmin, DescriptionListResponse04) {
  86     std::vector<PolicyDescription> descriptions = {
  87         PolicyDescription(Types::none, "none"),
  88     };
  89
  90     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::max_1);
  91     auto protocol = std::make_shared<ProtocolAdmin>();
  92     testResponse(response, protocol);
  93 }
  94
  95 TEST(ProtocolAdmin, DescriptionListResponse05) {
  96     std::vector<PolicyDescription> descriptions = {
  97         PolicyDescription(Types::plugin_type, "plugin"),
  98     };
  99
 100     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::mid);
 101     auto protocol = std::make_shared<ProtocolAdmin>();
 102     testResponse(response, protocol);
 103 }
 104
 105 TEST(ProtocolAdmin, DescriptionListResponseMultipleDescriptions) {
 106     std::vector<PolicyDescription> descriptions = {
 107         PolicyDescription(Types::allow, "allow"),
 108         PolicyDescription(Types::bucket, "bucket"),
 109         PolicyDescription(Types::deny, "deny"),
 110         PolicyDescription(Types::none, "none"),
 111         PolicyDescription(Types::plugin_type, ""),
 112         PolicyDescription(Types::plugin_type, "plugin"),
 113         PolicyDescription(Types::plugin_type, "plugin"),
 114     };
 115
 116     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::max_2);
 117     auto protocol = std::make_shared<ProtocolAdmin>();
 118     testResponse(response, protocol);
 119 }
 120
 121 TEST(ProtocolAdmin, DescriptionListResponseEmptyDescriptions) {
 122     std::vector<PolicyDescription> descriptions;
 123
 124     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::min_2);
 125     auto protocol = std::make_shared<ProtocolAdmin>();
 126     testResponse(response, protocol);
 127 }
 128
 129 /* *** compare by serialized data test cases *** */
 130
 131 TEST(ProtocolAdmin, DescriptionListResponseBinary01) {
 132     std::vector<PolicyDescription> descriptions = {
 133         PolicyDescription(Types::allow, "allow"),
 134     };
 135
 136     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::min);
 137     auto protocol = std::make_shared<ProtocolAdmin>();
 138     binaryTestResponse(response, protocol);
 139 }
 140
 141 TEST(ProtocolAdmin, DescriptionListResponseBinary02) {
 142     std::vector<PolicyDescription> descriptions = {
 143         PolicyDescription(Types::bucket, "bucket"),
 144     };
 145
 146     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::min_1);
 147     auto protocol = std::make_shared<ProtocolAdmin>();
 148     binaryTestResponse(response, protocol);
 149 }
 150
 151 TEST(ProtocolAdmin, DescriptionListResponseBinary03) {
 152     std::vector<PolicyDescription> descriptions = {
 153         PolicyDescription(Types::deny, "deny"),
 154     };
 155
 156     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::max);
 157     auto protocol = std::make_shared<ProtocolAdmin>();
 158     binaryTestResponse(response, protocol);
 159 }
 160
 161 TEST(ProtocolAdmin, DescriptionListResponseBinary04) {
 162     std::vector<PolicyDescription> descriptions = {
 163         PolicyDescription(Types::none, "none"),
 164     };
 165
 166     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::max_1);
 167     auto protocol = std::make_shared<ProtocolAdmin>();
 168     binaryTestResponse(response, protocol);
 169 }
 170
 171 TEST(ProtocolAdmin, DescriptionListResponseBinary05) {
 172     std::vector<PolicyDescription> descriptions = {
 173         PolicyDescription(Types::plugin_type, "plugin"),
 174     };
 175
 176     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::mid);
 177     auto protocol = std::make_shared<ProtocolAdmin>();
 178     binaryTestResponse(response, protocol);
 179 }
 180
 181 TEST(ProtocolAdmin, DescriptionListResponseBinaryMultipleDescriptions) {
 182     std::vector<PolicyDescription> descriptions = {
 183         PolicyDescription(Types::allow, "allow"),
 184         PolicyDescription(Types::bucket, "bucket"),
 185         PolicyDescription(Types::deny, "deny"),
 186         PolicyDescription(Types::none, "none"),
 187         PolicyDescription(Types::plugin_type, ""),
 188         PolicyDescription(Types::plugin_type, "plugin"),
 189         PolicyDescription(Types::plugin_type, "plugin"),
 190     };
 191
 192     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::max_2);
 193     auto protocol = std::make_shared<ProtocolAdmin>();
 194     binaryTestResponse(response, protocol);
 195 }
 196
 197 TEST(ProtocolAdmin, DescriptionListResponseBinaryEmptyDescriptions) {
 198     std::vector<PolicyDescription> descriptions;
 199
 200     auto response = std::make_shared<DescriptionListResponse>(descriptions, SN::min_2);
 201     auto protocol = std::make_shared<ProtocolAdmin>();
 202     binaryTestResponse(response, protocol);
 203 }