test/cyad/commandline_short.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  * @file        test/cyad/commandline_short.cpp
  18  * @author      Aleksander Zdyb <a.zdyb@samsung.com>
  19  * @version     1.0
  20  * @brief       Tests for CyadCommandlineParser (short opts)
  21  */
  22
  23 #include <memory>
  24
  25 #include <gmock/gmock.h>
  26 #include <gtest/gtest.h>
  27
  28 #include <cynara-admin-types.h>
  29
  30 #include <common/types/PolicyKey.h>
  31 #include <cyad/CommandlineParser/CyadCommand.h>
  32 #include <cyad/CommandlineParser/CyadCommandlineParser.h>
  33 #include <cyad/CommandlineParser/HumanReadableParser.h>
  34
  35 #include "CyadCommandlineTest.h"
  36
  37 TEST_F(CyadCommandlineTest, help_short) {
  38     prepare_argv({ "./cyad", "-h" });
  39     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
  40
  41     auto result = std::dynamic_pointer_cast<Cynara::HelpCyadCommand>(parser.parseMain());
  42     ASSERT_NE(nullptr, result);
  43 }
  44
  45 TEST_F(CyadCommandlineTest, deleteBucket_short) {
  46     prepare_argv({ "./cyad", "-d", "bucket" });
  47     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
  48
  49     auto result = std::dynamic_pointer_cast<Cynara::DeleteBucketCyadCommand>(parser.parseMain());
  50     ASSERT_NE(nullptr, result);
  51     ASSERT_EQ("bucket", result->bucketId());
  52 }
  53
  54 TEST_F(CyadCommandlineTest, setBucket_short) {
  55     prepare_argv({ "./cyad", "-b", "bucket", "-t", "42" });
  56     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
  57
  58     auto result = std::dynamic_pointer_cast<Cynara::SetBucketCyadCommand>(parser.parseMain());
  59     ASSERT_NE(nullptr, result);
  60     ASSERT_EQ("bucket", result->bucketId());
  61     ASSERT_EQ("42", result->policyResult().policyType());
  62     ASSERT_TRUE(result->policyResult().metadata().empty());
  63 }
  64
  65 TEST_F(CyadCommandlineTest, setBucketWithMetadata_short) {
  66     const std::string ultimateAnswer = "Answer to The Ultimate Question of Life,"
  67                                        " the Universe, and Everything";
  68
  69     prepare_argv({ "./cyad", "-b", "adams", "-t", "42", "-m", ultimateAnswer });
  70     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
  71
  72     auto result = std::dynamic_pointer_cast<Cynara::SetBucketCyadCommand>(parser.parseMain());
  73     ASSERT_NE(nullptr, result);
  74     ASSERT_EQ("adams", result->bucketId());
  75     ASSERT_EQ("42", result->policyResult().policyType());
  76     ASSERT_EQ(ultimateAnswer, result->policyResult().metadata());
  77 }
  78
  79 TEST_F(CyadCommandlineTest, setPolicy_short) {
  80     prepare_argv({ "./cyad", "-s", "-k", "some-bucket",
  81                    "-c", "client", "-u", "user", "-p", "privilege",
  82                    "-t", "42" });
  83     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
  84
  85     auto result = std::dynamic_pointer_cast<Cynara::SetPolicyCyadCommand>(parser.parseMain());
  86     ASSERT_NE(nullptr, result);
  87     ASSERT_EQ("some-bucket", result->bucketId());
  88
  89     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
  90     ASSERT_EQ("42", result->policyResult().policyType());
  91     ASSERT_TRUE(result->policyResult().metadata().empty());
  92 }
  93
  94 TEST_F(CyadCommandlineTest, setPolicyWithMetadata_short) {
  95     prepare_argv({ "./cyad", "-s", "-k", "some-bucket",
  96                    "-c", "client", "-u", "user", "-p", "privilege",
  97                    "-t", "42", "-m", "some-metadata" });
  98     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
  99
 100     auto result = std::dynamic_pointer_cast<Cynara::SetPolicyCyadCommand>(parser.parseMain());
 101     ASSERT_NE(nullptr, result);
 102     ASSERT_EQ("some-bucket", result->bucketId());
 103
 104     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
 105     ASSERT_EQ("42", result->policyResult().policyType());
 106     ASSERT_EQ("some-metadata", result->policyResult().metadata());
 107 }
 108
 109 TEST_F(CyadCommandlineTest, setPolicyInDefaultBucket_short) {
 110     prepare_argv({ "./cyad", "-s", "-k", "",
 111                    "-c", "client", "-u", "user", "-p", "privilege",
 112                    "-t", "ALLOW", "-m", "some-metadata" });
 113     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 114
 115     auto result = std::dynamic_pointer_cast<Cynara::SetPolicyCyadCommand>(parser.parseMain());
 116     ASSERT_NE(nullptr, result);
 117     ASSERT_EQ("", result->bucketId());
 118     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
 119     ASSERT_EQ("ALLOW", result->policyResult().policyType());
 120     ASSERT_EQ("some-metadata", result->policyResult().metadata());
 121 }
 122
 123 TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketNoOption_short) {
 124     prepare_argv({ "./cyad", "-s",
 125                    "-c", "client", "-u", "user", "-p", "privilege",
 126                    "-t", "ALLOW", "-m", "some-metadata" });
 127     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 128
 129     auto result = std::dynamic_pointer_cast<Cynara::SetPolicyCyadCommand>(parser.parseMain());
 130     ASSERT_NE(nullptr, result);
 131     ASSERT_EQ("", result->bucketId());
 132     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
 133     ASSERT_EQ("ALLOW", result->policyResult().policyType());
 134     ASSERT_EQ("some-metadata", result->policyResult().metadata());
 135 }
 136
 137 TEST_F(CyadCommandlineTest, parsePolicyTypeBase10_short) {
 138     auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
 139         return Cynara::HumanReadableParser::policyType(rawPolicy);
 140     };
 141
 142     ASSERT_EQ(CYNARA_ADMIN_DENY,   parsePolicyType("0"));
 143     ASSERT_EQ(CYNARA_ADMIN_NONE,   parsePolicyType("1"));
 144     ASSERT_EQ(CYNARA_ADMIN_BUCKET, parsePolicyType("65534"));
 145     ASSERT_EQ(CYNARA_ADMIN_ALLOW,  parsePolicyType("65535"));
 146 }
 147
 148 TEST_F(CyadCommandlineTest, parsePolicyTypeBase16_short) {
 149     auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
 150         return Cynara::HumanReadableParser::policyType(rawPolicy);
 151     };
 152
 153     ASSERT_EQ(CYNARA_ADMIN_DENY,   parsePolicyType("0x0"));
 154     ASSERT_EQ(CYNARA_ADMIN_NONE,   parsePolicyType("0x1"));
 155     ASSERT_EQ(CYNARA_ADMIN_BUCKET, parsePolicyType("0xFFFE"));
 156     ASSERT_EQ(CYNARA_ADMIN_ALLOW,  parsePolicyType("0xFFFF"));
 157 }
 158
 159 TEST_F(CyadCommandlineTest, parsePolicyTypeHuman_short) {
 160     auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
 161         return Cynara::HumanReadableParser::policyType(rawPolicy);
 162     };
 163
 164     ASSERT_EQ(CYNARA_ADMIN_DENY,   parsePolicyType("DENY"));
 165     ASSERT_EQ(CYNARA_ADMIN_NONE,   parsePolicyType("NONE"));
 166     ASSERT_EQ(CYNARA_ADMIN_BUCKET, parsePolicyType("BUCKET"));
 167     ASSERT_EQ(CYNARA_ADMIN_ALLOW,  parsePolicyType("ALLOW"));
 168 }
 169
 170 TEST_F(CyadCommandlineTest, setPoliciesBulkFilename_short) {
 171     prepare_argv({ "./cyad", "-s", "-f", "/tmp/input_file" });
 172     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 173
 174     auto result = std::dynamic_pointer_cast<Cynara::SetPolicyBulkCyadCommand>(parser.parseMain());
 175     ASSERT_NE(nullptr, result);
 176     ASSERT_EQ("/tmp/input_file", result->filename());
 177 }
 178
 179 TEST_F(CyadCommandlineTest, setPoliciesBulkStdin_short) {
 180     prepare_argv({ "./cyad", "-s", "-f", "-" });
 181     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 182
 183     auto result = std::dynamic_pointer_cast<Cynara::SetPolicyBulkCyadCommand>(parser.parseMain());
 184     ASSERT_NE(nullptr, result);
 185     ASSERT_EQ("-", result->filename());
 186 }
 187
 188 TEST_F(CyadCommandlineTest, eraseRecursive_short) {
 189     prepare_argv({ "./cyad", "-e", "bucket", "-r", "yes",
 190                    "-c", "client", "-u", "user", "-p", "privilege" });
 191     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 192
 193     auto result = std::dynamic_pointer_cast<Cynara::EraseCyadCommand>(parser.parseMain());
 194     ASSERT_NE(nullptr, result);
 195     ASSERT_EQ("bucket", result->bucketId());
 196     ASSERT_TRUE(result->recursive());
 197     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
 198 }
 199
 200 TEST_F(CyadCommandlineTest, eraseNonrecursive_short) {
 201     prepare_argv({ "./cyad", "-e", "bucket", "-r", "no",
 202                    "-c", "client", "-u", "user", "-p", "privilege" });
 203     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 204
 205     auto result = std::dynamic_pointer_cast<Cynara::EraseCyadCommand>(parser.parseMain());
 206     ASSERT_NE(nullptr, result);
 207     ASSERT_EQ("bucket", result->bucketId());
 208     ASSERT_FALSE(result->recursive());
 209     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
 210 }
 211
 212 TEST_F(CyadCommandlineTest, checkDefaultRecursive_short) {
 213     prepare_argv({ "./cyad", "-a", "-r", "no",
 214                    "-c", "client", "-u", "user", "-p", "privilege" });
 215     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 216
 217     auto result = std::dynamic_pointer_cast<Cynara::CheckCyadCommand>(parser.parseMain());
 218     ASSERT_NE(nullptr, result);
 219     ASSERT_EQ(CYNARA_ADMIN_DEFAULT_BUCKET, result->bucketId());
 220     ASSERT_FALSE(result->recursive());
 221     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
 222 }
 223
 224 TEST_F(CyadCommandlineTest, listPoliciesDefault_short) {
 225     prepare_argv({ "./cyad", "-l", "",
 226                    "-c", "client", "-u", "user", "-p", "privilege" });
 227     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 228
 229     auto result = std::dynamic_pointer_cast<Cynara::ListPoliciesCyadCommand>(parser.parseMain());
 230     ASSERT_NE(nullptr, result);
 231     ASSERT_EQ(CYNARA_ADMIN_DEFAULT_BUCKET, result->bucketId());
 232     ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
 233 }
 234
 235 TEST_F(CyadCommandlineTest, listPoliciesOtherBucket_short) {
 236     prepare_argv({ "./cyad", "-l", "some-bucket",
 237                    "-c", "c", "-u", "u", "-p", "p" });
 238     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 239
 240     auto result = std::dynamic_pointer_cast<Cynara::ListPoliciesCyadCommand>(parser.parseMain());
 241     ASSERT_NE(nullptr, result);
 242     ASSERT_EQ("some-bucket", result->bucketId());
 243     ASSERT_EQ(Cynara::PolicyKey("c", "u", "p"), result->policyKey());
 244 }
 245
 246 TEST_F(CyadCommandlineTest, listPoliciesDesc_short) {
 247     prepare_argv({ "./cyad", "-g" });
 248     Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
 249
 250     auto result = std::dynamic_pointer_cast<Cynara::ListPoliciesDescCyadCommand>(
 251                                                                                 parser.parseMain());
 252     ASSERT_NE(nullptr, result);
 253 }