/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace AdminPolicyParser {
-CynaraAdminPolicies parse(const std::shared_ptr<std::istream> &input) {
+CynaraAdminPolicies parse(const std::shared_ptr<std::istream> &input,
+ std::function<PolicyType(const std::string &)> translatePolicy) {
CynaraAdminPolicies policies;
+ auto nextToken = [] (const std::string &line, std::size_t &beginToken) -> std::string {
+ auto endToken = line.find(StorageSerializer::fieldSeparator(), beginToken);
+ if (endToken != std::string::npos) {
+ auto token = line.substr(beginToken, endToken - beginToken);
+ beginToken = endToken + 1;
+ return token;
+ }
+
+ throw BucketRecordCorruptedException(line);
+ };
+
+ auto lastToken = [] (const std::string &line, std::size_t &beginToken) -> std::string {
+ if (beginToken < line.size()) {
+ auto ret = line.substr(beginToken);
+ beginToken = line.size();
+ return ret;
+ }
+
+ return std::string();
+ };
+
for (std::size_t lineNum = 1; !input->eof(); ++lineNum) {
std::string line;
std::getline(*input, line, StorageSerializer::recordSeparator());
try {
std::size_t beginToken = 0;
- auto bucketId = StorageDeserializer::parseBucketId(line, beginToken);
+ auto bucketId = nextToken(line, beginToken);
auto policyKey = BucketDeserializer::parseKey(line, beginToken);
- auto policyType = StorageDeserializer::parsePolicyType(line, beginToken);
- auto metadata = StorageDeserializer::parseMetadata(line, beginToken);
+ auto policyType = translatePolicy(nextToken(line, beginToken));
+ auto metadata = lastToken(line, beginToken);
policies.add(bucketId, PolicyResult(policyType, metadata), policyKey);
} catch (const BucketRecordCorruptedException &ex) {
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace AdminPolicyParser {
-CynaraAdminPolicies parse(const std::shared_ptr<std::istream> &input);
+CynaraAdminPolicies parse(const std::shared_ptr<std::istream> &input,
+ std::function<PolicyType(const std::string &)>);
} /* namespace AdminPolicyParser */
${CYAD_PATH}/CommandsDispatcher.cpp
${CYAD_PATH}/DispatcherIO.cpp
${CYAD_PATH}/ErrorApiWrapper.cpp
+ ${CYAD_PATH}/PolicyTypeTranslator.cpp
${CYAD_PATH}/main.cpp
)
#include <types/PolicyBucketId.h>
#include <types/PolicyKey.h>
-#include <types/PolicyResult.h>
+#include <cyad/CommandlineParser/RawPolicyResult.h>
namespace Cynara {
class SetBucketCyadCommand : public CyadCommand {
public:
- SetBucketCyadCommand(const PolicyBucketId &bucketId, const PolicyResult &policyResult)
+ SetBucketCyadCommand(const PolicyBucketId &bucketId, const RawPolicyResult &policyResult)
: m_bucketId(bucketId), m_policyResult(policyResult) {}
virtual ~SetBucketCyadCommand() {}
return m_bucketId;
}
- const PolicyResult &policyResult(void) const {
+ const RawPolicyResult &policyResult(void) const {
return m_policyResult;
}
private:
PolicyBucketId m_bucketId;
- PolicyResult m_policyResult;
+ RawPolicyResult m_policyResult;
};
class DeleteBucketCyadCommand : public CyadCommand {
class SetPolicyCyadCommand : public CyadCommand {
public:
- SetPolicyCyadCommand(const PolicyBucketId &bucketId, const PolicyResult &policyResult,
+ SetPolicyCyadCommand(const PolicyBucketId &bucketId, const RawPolicyResult &policyResult,
const PolicyKey &policyKey)
: m_bucketId(bucketId), m_policyResult(policyResult), m_policyKey(policyKey) {}
return m_bucketId;
}
- const PolicyResult &policyResult(void) const {
+ const RawPolicyResult &policyResult(void) const {
return m_policyResult;
}
private:
PolicyBucketId m_bucketId;
- PolicyResult m_policyResult;
+ RawPolicyResult m_policyResult;
PolicyKey m_policyKey;
};
if (policy.empty())
return sharedError(Err::noType());
- try {
- auto policyType = HumanReadableParser::policyType(policy);
- return std::make_shared<SetBucketCyadCommand>(bucketId, PolicyResult(policyType, metadata));
- } catch (const PolicyParsingException &) {
- return sharedError(Err::invalidType());
- }
+ return std::make_shared<SetBucketCyadCommand>(bucketId, RawPolicyResult(policy, metadata));
}
std::shared_ptr<CyadCommand> CyadCommandlineParser::parseDeleteBucket(const std::string &bucketId) {
}
}
- try {
- auto policyType = HumanReadableParser::policyType(values[CmdlineOpt::Type]);
- auto policyResult = PolicyResult(policyType, metadata);
- return std::make_shared<SetPolicyCyadCommand>(bucket, policyResult,
- PolicyKey(values[CmdlineOpt::Client],
- values[CmdlineOpt::User],
- values[CmdlineOpt::Privilege]));
- } catch (const PolicyParsingException &) {
- return sharedError(Err::invalidType());
- }
-
- return sharedError(Err::unknownError());
+ auto policyResult = RawPolicyResult(values[CmdlineOpt::Type], metadata);
+ return std::make_shared<SetPolicyCyadCommand>(bucket, policyResult,
+ PolicyKey(values[CmdlineOpt::Client],
+ values[CmdlineOpt::User],
+ values[CmdlineOpt::Privilege]));
}
std::shared_ptr<CyadCommand> CyadCommandlineParser::parseErase(const std::string &bucketId) {
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file src/cyad/CommandlineParser/RawPolicyResult.h
+ * @author Aleksander Zdyb <a.zdyb@samsung.com>
+ * @version 1.0
+ * @brief An abstraction of raw PolicyType
+ */
+
+#ifndef SRC_CYAD_COMMANDLINEPARSER_RAWPOLICYRESULT_H_
+#define SRC_CYAD_COMMANDLINEPARSER_RAWPOLICYRESULT_H_
+
+namespace Cynara {
+
+class RawPolicyResult {
+public:
+ RawPolicyResult(const std::string &type, const std::string &metadata)
+ : m_type(type), m_metadata(metadata) {}
+ ~RawPolicyResult() {}
+
+ const std::string &policyType(void) const {
+ return m_type;
+ }
+ const std::string &metadata(void) const {
+ return m_metadata;
+ }
+
+private:
+ std::string m_type;
+ std::string m_metadata;
+
+};
+
+} /* namespace Cynara */
+
+#endif /* SRC_CYAD_COMMANDLINEPARSER_RAWPOLICYRESULT_H_ */
#include <cyad/AdminLibraryInitializationFailedException.h>
#include <cyad/AdminPolicyParser.h>
#include <cyad/CommandlineParser/CmdlineOpts.h>
+#include <cyad/CommandlineParser/PolicyParsingException.h>
#include <cyad/CynaraAdminPolicies.h>
#include "CommandsDispatcher.h"
printAdminApiError(ret);
throw AdminLibraryInitializationFailedException(ret);
}
+
+ try {
+ initPolicyTranslator();
+ } catch (int ret) {
+ printAdminApiError(ret);
+ // It's not really initialization error, but still nothing depends on user input
+ throw AdminLibraryInitializationFailedException(ret);
+ }
}
CommandsDispatcher::~CommandsDispatcher() {
const auto &policyResult = result.policyResult();
const char *metadata = policyResult.metadata().empty() ? nullptr
: policyResult.metadata().c_str();
- auto ret = m_adminApiWrapper.cynara_admin_set_bucket(m_cynaraAdmin,
- result.bucketId().c_str(),
- policyResult.policyType(), metadata);
- if (ret != CYNARA_API_SUCCESS)
- printAdminApiError(ret);
+ try {
+ int policyType = m_policyTranslator.translate(result.policyResult().policyType());
+ auto ret = m_adminApiWrapper.cynara_admin_set_bucket(m_cynaraAdmin,
+ result.bucketId().c_str(),
+ policyType, metadata);
- return ret;
+ if (ret != CYNARA_API_SUCCESS)
+ printAdminApiError(ret);
+
+ return ret;
+ } catch (const PolicyParsingException &) {
+ m_io.cerr() << "Invalid policy" << std::endl;
+ return CYNARA_API_INVALID_COMMANDLINE_PARAM;
+ }
}
int CommandsDispatcher::execute(SetPolicyCyadCommand &result) {
CynaraAdminPolicies policies;
- policies.add(result.bucketId(), result.policyResult(), result.policyKey());
- policies.seal();
+ try {
+ int policyType = m_policyTranslator.translate(result.policyResult().policyType());
+ policies.add(result.bucketId(), PolicyResult(policyType, result.policyResult().metadata()),
+ result.policyKey());
+ policies.seal();
+ } catch (const PolicyParsingException &) {
+ m_io.cerr() << "Invalid policy" << std::endl;
+ return CYNARA_API_INVALID_COMMANDLINE_PARAM;
+ }
auto ret = m_adminApiWrapper.cynara_admin_set_policies(m_cynaraAdmin, policies.data());
auto input = m_io.openFile(result.filename());
try {
- auto policies = Cynara::AdminPolicyParser::parse(input);
+ using Cynara::AdminPolicyParser::parse;
+ auto policies = parse(input, std::bind(&PolicyTypeTranslator::translate,
+ &m_policyTranslator, std::placeholders::_1));
auto ret = m_adminApiWrapper.cynara_admin_set_policies(m_cynaraAdmin, policies.data());
if (ret != CYNARA_API_SUCCESS)
printAdminApiError(ret);
} catch (const BucketRecordCorruptedException &ex) {
m_io.cerr() << ex.message();
return CYNARA_API_INVALID_COMMANDLINE_PARAM;
+ } catch (const PolicyParsingException &) {
+ m_io.cerr() << "Invalid policy" << std::endl;
+ return CYNARA_API_INVALID_COMMANDLINE_PARAM;
}
}
}
int CommandsDispatcher::execute(ListPoliciesDescCyadCommand &) {
- // Initialization is needed to make compiler happy (-Werror=maybe-uninitialized, FTW)
- cynara_admin_policy_descr **descs = nullptr;
-
- auto ret = m_adminApiWrapper.cynara_admin_list_policies_descriptions(m_cynaraAdmin, &descs);
-
- auto printPolicyDesc = [this] (cynara_admin_policy_descr *pd) {
- m_io.cout() << pd->result << ";"
- << pd->name << std::endl;
- };
-
- auto freePolicyDesc = [] (cynara_admin_policy_descr *pd) {
- free(pd->name);
- free(pd);
- };
- if (ret == CYNARA_API_SUCCESS) {
- for (int i = 0; descs[i]; ++i) {
- auto p = descs[i];
- printPolicyDesc(p);
- freePolicyDesc(p);
- }
- free(descs);
- } else {
- printAdminApiError(ret);
+ for (const auto desc : m_policyTranslator.descriptions()) {
+ m_io.cout() << desc.first << ";" << desc.second << std::endl;
}
- return ret;
+ return CYNARA_API_SUCCESS;
}
void CommandsDispatcher::printAdminApiError(int errnum) {
m_io.cerr() << "Unknown error (sic! sic!)" << std::endl;
}
+void CommandsDispatcher::initPolicyTranslator(void) {
+ // Initialization is needed to make compiler happy (-Werror=maybe-uninitialized, FTW)
+ cynara_admin_policy_descr **descs = nullptr;
+
+ auto ret = m_adminApiWrapper.cynara_admin_list_policies_descriptions(m_cynaraAdmin, &descs);
+
+ auto freePolicyDesc = [] (cynara_admin_policy_descr *pd) {
+ free(pd->name);
+ free(pd);
+ };
+
+ if (ret == CYNARA_API_SUCCESS) {
+ m_policyTranslator.setDescriptions(descs);
+ for (int i = 0; descs[i] != nullptr; ++i) {
+ freePolicyDesc(descs[i]);
+ }
+ free(descs);
+ } else {
+ throw ret;
+ }
+}
+
} /* namespace Cynara */
#include <cyad/BaseErrorApiWrapper.h>
#include <cyad/CommandlineParser/CyadCommand.h>
#include <cyad/DispatcherIO.h>
+#include <cyad/PolicyTypeTranslator.h>
struct cynara_admin;
struct cynara_admin_policy;
protected:
void printAdminApiError(int errnum);
+ void initPolicyTranslator(void);
private:
+ PolicyTypeTranslator m_policyTranslator;
BaseDispatcherIO &m_io;
BaseAdminApiWrapper &m_adminApiWrapper;
BaseErrorApiWrapper &m_errorApiWrapper;
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file src/cyad/PolicyTypeTranslator.cpp
+ * @author Aleksander Zdyb <a.zdyb@samsung.com>
+ * @version 1.0
+ * @brief A helper class to translate strings to PolicyType
+ */
+
+#include <algorithm>
+#include <stdexcept>
+
+#include <cynara-error.h>
+
+#include <cyad/CommandlineParser/PolicyParsingException.h>
+
+#include "PolicyTypeTranslator.h"
+
+namespace Cynara {
+
+PolicyTypeTranslator::PolicyTypeTranslator() {}
+
+PolicyTypeTranslator::~PolicyTypeTranslator() {}
+
+void PolicyTypeTranslator::setDescriptions(cynara_admin_policy_descr **descs) {
+ for (int i = 0; descs[i]; ++i) {
+ std::string name(descs[i]->name);
+ std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+ m_descs.push_back(std::make_pair(descs[i]->result, name));
+ }
+}
+
+PolicyType PolicyTypeTranslator::translate(const std::string &rawPolicy) {
+
+ std::string policy(rawPolicy);
+ std::transform(policy.begin(), policy.end(), policy.begin(), ::tolower);
+
+ auto descComp = [policy] (const PolicyDescriptions::value_type &it) -> bool {
+ return it.second == policy;
+ };
+
+ const auto it = std::find_if(m_descs.begin(), m_descs.end(), descComp);
+
+ if (it != m_descs.end())
+ return it->first;
+
+ if (policy == "none")
+ return CYNARA_ADMIN_NONE;
+ if (policy == "bucket")
+ return CYNARA_ADMIN_BUCKET;
+
+ try {
+ return std::stoi(policy, nullptr, 0);
+ } catch (const std::logic_error &) {
+ throw PolicyParsingException();
+ }
+}
+
+} /* namespace Cynara */
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @file src/cyad/PolicyTypeTranslator.h
+ * @author Aleksander Zdyb <a.zdyb@samsung.com>
+ * @version 1.0
+ * @brief A helper class to translate strings to PolicyType
+ */
+
+#ifndef SRC_CYAD_POLICYTYPETRANSLATOR_H_
+#define SRC_CYAD_POLICYTYPETRANSLATOR_H_
+
+#include <vector>
+
+#include <cynara-admin-types.h>
+
+#include <common/types/PolicyType.h>
+
+namespace Cynara {
+
+class PolicyTypeTranslator {
+private:
+ typedef std::vector<std::pair<int, std::string>> PolicyDescriptions;
+
+public:
+ PolicyTypeTranslator();
+
+ ~PolicyTypeTranslator();
+
+ PolicyType translate(const std::string &rawPolicy);
+
+ void setDescriptions(cynara_admin_policy_descr **descs);
+
+ const PolicyDescriptions &descriptions(void) const {
+ return m_descs;
+ }
+
+private:
+ PolicyDescriptions m_descs;
+};
+
+} /* namespace Cynara */
+
+#endif /* SRC_CYAD_POLICYTYPETRANSLATOR_H_ */
${CYNARA_SRC}/cyad/CommandlineParser/HumanReadableParser.cpp
${CYNARA_SRC}/cyad/CommandsDispatcher.cpp
${CYNARA_SRC}/cyad/CynaraAdminPolicies.cpp
+ ${CYNARA_SRC}/cyad/PolicyTypeTranslator.cpp
${CYNARA_SRC}/helpers/creds-commons/CredsCommonsInner.cpp
${CYNARA_SRC}/helpers/creds-commons/creds-commons.cpp
${CYNARA_SRC}/storage/BucketDeserializer.cpp
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#ifndef TEST_CYAD_CYADCOMMANDLINEDISPATCHERTEST_H_
#define TEST_CYAD_CYADCOMMANDLINEDISPATCHERTEST_H_
+#include <new>
+#include <stdexcept>
+
#include <gmock/gmock.h>
#include <gtest/gtest.h>
+#include <cynara-admin-types.h>
+#include <cynara-error.h>
+
+#include "FakeAdminApiWrapper.h"
#include "FakeDispatcherIO.h"
+#include "FakeErrorApiWrapper.h"
+
+#define MAX_POLICY_DESCRIPTIONS 15
class CyadCommandlineDispatcherTest : public ::testing::Test {
+private:
+ typedef cynara_admin_policy_descr DescrType;
+
+public:
+ void SetUp(void) {
+ auto arrSize = sizeof(DescrType *) * (MAX_POLICY_DESCRIPTIONS + 1);
+ m_policyDescs = static_cast<DescrType **>(malloc(arrSize));
+
+ if (m_policyDescs == nullptr)
+ throw std::bad_alloc();
+
+ m_policyDescs[0] = nullptr;
+ setupInitFinishExpectations();
+ setupDescriptionsExpectation();
+ }
+
+ void TearDown(void) {
+ if (m_policyDescs != nullptr)
+ freeDescriptions();
+ }
+
+ void addDescriptions(std::vector<std::pair<int, std::string>> toAdd) {
+ if (m_descCount + toAdd.size() > MAX_POLICY_DESCRIPTIONS) {
+ throw std::length_error("Descriptions count would exceed "
+ + std::to_string(MAX_POLICY_DESCRIPTIONS));
+ }
+
+ auto addDesc = [] (DescrType **desc, int result, const std::string &name) {
+ (*desc) = static_cast<DescrType *>(malloc(sizeof(DescrType)));
+ (*desc)->result = result;
+ (*desc)->name = strdup(name.data());
+ };
+
+ for (const auto &it : toAdd) {
+ addDesc(m_policyDescs + m_descCount, it.first, it.second);
+ ++m_descCount;
+ }
+
+ m_policyDescs[m_descCount] = nullptr;
+ }
+
protected:
+ void setupInitFinishExpectations() {
+ using ::testing::_;
+ using ::testing::Return;
+
+ EXPECT_CALL(m_adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
+ EXPECT_CALL(m_adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
+ }
+
+ void setupDescriptionsExpectation() {
+ using ::testing::_;
+ using ::testing::Return;
+ using ::testing::NotNull;
+ using ::testing::DoAll;
+ using ::testing::SetArgPointee;
+ using ::testing::Assign;
+
+ addDescriptions({
+ { 0, "DENY" },
+ { 0xFFFF, "ALLOW" },
+ });
+
+ EXPECT_CALL(m_adminApi, cynara_admin_list_policies_descriptions(_, NotNull()))
+ .WillOnce(DoAll(SetArgPointee<1>(m_policyDescs),
+ Assign(&m_policyDescs, nullptr),
+ Return(CYNARA_API_SUCCESS)));
+ }
+
FakeDispatcherIO m_io;
+ FakeAdminApiWrapper m_adminApi;
+ FakeErrorApiWrapper m_errorApi;
+
+private:
+ void freeDescriptions() {
+ auto freePolicyDesc = [] (DescrType *pd) {
+ free(pd->name);
+ free(pd);
+ };
+
+ for (int i = 0; m_policyDescs[i] != nullptr; ++i) {
+ freePolicyDesc(m_policyDescs[i]);
+ }
+ free(m_policyDescs);
+ }
+
+ DescrType **m_policyDescs = nullptr;
+ std::size_t m_descCount = 0;
};
#endif /* TEST_CYAD_CYADCOMMANDLINEDISPATCHERTEST_H_ */
auto result = std::dynamic_pointer_cast<Cynara::SetBucketCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ("bucket", result->bucketId());
- ASSERT_EQ(42, result->policyResult().policyType());
+ ASSERT_EQ("42", result->policyResult().policyType());
ASSERT_TRUE(result->policyResult().metadata().empty());
}
auto result = std::dynamic_pointer_cast<Cynara::SetBucketCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ("adams", result->bucketId());
- ASSERT_EQ(42, result->policyResult().policyType());
+ ASSERT_EQ("42", result->policyResult().policyType());
ASSERT_EQ(ultimateAnswer, result->policyResult().metadata());
}
ASSERT_EQ("some-bucket", result->bucketId());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
- ASSERT_EQ(42, result->policyResult().policyType());
+ ASSERT_EQ("42", result->policyResult().policyType());
ASSERT_TRUE(result->policyResult().metadata().empty());
}
ASSERT_EQ("some-bucket", result->bucketId());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
- ASSERT_EQ(42, result->policyResult().policyType());
+ ASSERT_EQ("42", result->policyResult().policyType());
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
ASSERT_NE(nullptr, result);
ASSERT_EQ("", result->bucketId());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
- ASSERT_EQ(CYNARA_ADMIN_ALLOW, result->policyResult().policyType());
+ ASSERT_EQ("ALLOW", result->policyResult().policyType());
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
ASSERT_NE(nullptr, result);
ASSERT_EQ("", result->bucketId());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
- ASSERT_EQ(CYNARA_ADMIN_ALLOW, result->policyResult().policyType());
+ ASSERT_EQ("ALLOW", result->policyResult().policyType());
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
ASSERT_ERROR_MSG(Cynara::CmdlineErrors::noType(), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setBucketInvalidPolicy) {
- prepare_argv({ "./cyad", "--set-bucket=bucket", "--type=NaN" });
- Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
- ASSERT_ERROR_MSG(Errors::invalidType(), parser.parseMain());
-}
-
TEST_F(CyadCommandlineTest, setBucketUnknownOption) {
prepare_argv({ "./cyad", "--set-bucket=bucket", "--unknown", "--type=42" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
#include <common/types/PolicyKey.h>
#include <common/types/PolicyResult.h>
+#include <common/types/PolicyType.h>
#include <cyad/CynaraAdminPolicies.h>
#include <cyad/CommandlineParser/CyadCommand.h>
#include <cyad/CommandsDispatcher.h>
#include "CyadCommandlineDispatcherTest.h"
-#include "FakeAdminApiWrapper.h"
-#include "FakeErrorApiWrapper.h"
#include "helpers.h"
/**
using ::testing::_;
using ::testing::Return;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::CyadCommand result;
Cynara::HelpCyadCommand helpResult;
using ::testing::StrEq;
using ::testing::IsNull;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::DeleteBucketCyadCommand result("test-bucket");
- EXPECT_CALL(adminApi,
+ EXPECT_CALL(m_adminApi,
cynara_admin_set_bucket(_, StrEq("test-bucket"), CYNARA_ADMIN_DELETE, IsNull()))
.WillOnce(Return(CYNARA_API_SUCCESS));
using ::testing::Return;
using ::testing::StrEq;
using ::testing::IsNull;
+ using ::testing::NotNull;
using Cynara::PolicyBucketId;
using Cynara::PolicyType;
using Cynara::PolicyResult;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
+ addDescriptions({ { 42, "hitchhiker" } });
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
- typedef std::tuple<PolicyBucketId, PolicyResult> BucketData;
+ typedef std::string RawPolicyType;
+ typedef std::string Metadata;
+ typedef std::tuple<PolicyBucketId, PolicyType, RawPolicyType, Metadata> BucketData;
typedef std::vector<BucketData> Buckets;
- const Buckets buckets = { BucketData("test-bucket-1", { CYNARA_ADMIN_ALLOW, "" }),
- BucketData("test-bucket-2", { CYNARA_ADMIN_DENY, "" }),
- BucketData("test-bucket-3", { CYNARA_ADMIN_BUCKET, "other-bucket" }),
- BucketData("test-bucket-2", { CYNARA_ADMIN_NONE, "" }),
- BucketData("test-bucket-4", { 42, "douglas-noel-adams" }) };
+ const Buckets buckets = {
+ BucketData("test-bucket-1", CYNARA_ADMIN_ALLOW, "ALLOW", ""),
+ BucketData("test-bucket-2", CYNARA_ADMIN_DENY, "DENY", ""),
+ BucketData("test-bucket-3", CYNARA_ADMIN_BUCKET, "BUCKET", "other-bucket"),
+ BucketData("test-bucket-2", CYNARA_ADMIN_NONE, "NONE", ""),
+ BucketData("test-bucket-4", 42, "hitchhiker", "douglas-noel-adams") };
for (const auto &bucket : buckets) {
const auto &bucketId = std::get<0>(bucket);
- const auto &policyResult = std::get<1>(bucket);
+ const auto &policyType = std::get<1>(bucket);
+ const auto &rawPolicyType = std::get<2>(bucket);
+ const auto &metadata = std::get<3>(bucket);
SCOPED_TRACE(bucketId);
- Cynara::SetBucketCyadCommand result(bucketId, policyResult);
+ Cynara::SetBucketCyadCommand result(bucketId, { rawPolicyType, metadata });
- if (policyResult.metadata().empty() == false) {
- EXPECT_CALL(adminApi,
- cynara_admin_set_bucket(_, StrEq(bucketId.c_str()), policyResult.policyType(),
- StrEq(policyResult.metadata().c_str())))
+ if (metadata.empty() == false) {
+ EXPECT_CALL(m_adminApi,
+ cynara_admin_set_bucket(_, StrEq(bucketId.c_str()), policyType,
+ StrEq(metadata.c_str())))
.WillOnce(Return(CYNARA_API_SUCCESS));
} else {
- EXPECT_CALL(adminApi,
- cynara_admin_set_bucket(_, StrEq(bucketId.c_str()), policyResult.policyType(),
- IsNull()))
+ EXPECT_CALL(m_adminApi,
+ cynara_admin_set_bucket(_, StrEq(bucketId.c_str()), policyType, IsNull()))
.WillOnce(Return(CYNARA_API_SUCCESS));
}
using ::testing::_;
using ::testing::Return;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
- Cynara::SetPolicyCyadCommand result("test-bucket", { CYNARA_ADMIN_ALLOW, "" },
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
+ Cynara::SetPolicyCyadCommand result("test-bucket", { "allow", "" },
{ "client", "user", "privilege" });
Cynara::CynaraAdminPolicies expectedPolicies;
{ "client", "user", "privilege"} );
expectedPolicies.seal();
- EXPECT_CALL(adminApi, cynara_admin_set_policies(_, AdmPolicyListEq(expectedPolicies.data())))
+ EXPECT_CALL(m_adminApi, cynara_admin_set_policies(_, AdmPolicyListEq(expectedPolicies.data())))
.WillOnce(Return(CYNARA_API_SUCCESS));
dispatcher.execute(result);
using ::testing::_;
using ::testing::Return;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
- Cynara::SetPolicyCyadCommand result("test-bucket", { CYNARA_ADMIN_ALLOW, "metadata" },
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
+ Cynara::SetPolicyCyadCommand result("test-bucket", { "allow", "metadata" },
Cynara::PolicyKey("client", "user", "privilege"));
Cynara::CynaraAdminPolicies expectedPolicies;
{ "client", "user", "privilege"} );
expectedPolicies.seal();
- EXPECT_CALL(adminApi, cynara_admin_set_policies(_, AdmPolicyListEq(expectedPolicies.data())))
+ EXPECT_CALL(m_adminApi, cynara_admin_set_policies(_, AdmPolicyListEq(expectedPolicies.data())))
.WillOnce(Return(CYNARA_API_SUCCESS));
dispatcher.execute(result);
using ::testing::_;
using ::testing::Return;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::SetPolicyBulkCyadCommand result("-");
// fake stdin ;)
m_io.file() << "bucket;cli;usr;privilege;0;metadata" << std::endl;
- m_io.file() << "bucket-2;cli;usr;privilege;0xFFFF";
+ m_io.file() << "bucket-2;cli;usr;privilege;0xFFFF;" << std::endl;
+ m_io.file() << "bucket-3;cli;usr;priv;bucket;bucket-2";
Cynara::CynaraAdminPolicies expectedPolicies;
expectedPolicies.add("bucket", { CYNARA_ADMIN_DENY, "metadata" }, {"cli", "usr", "privilege"} );
expectedPolicies.add("bucket-2", { CYNARA_ADMIN_ALLOW, "" }, {"cli", "usr", "privilege"} );
+ expectedPolicies.add("bucket-3", { CYNARA_ADMIN_BUCKET, "bucket-2" }, {"cli", "usr", "priv"} );
expectedPolicies.seal();
- EXPECT_CALL(adminApi, cynara_admin_set_policies(_, AdmPolicyListEq(expectedPolicies.data())))
+ EXPECT_CALL(m_adminApi, cynara_admin_set_policies(_, AdmPolicyListEq(expectedPolicies.data())))
.WillOnce(Return(CYNARA_API_SUCCESS));
dispatcher.execute(result);
using ::testing::_;
using ::testing::Return;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::SetPolicyBulkCyadCommand result("-");
// fake stdin ;)
using ::testing::Return;
using ::testing::StrEq;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::EraseCyadCommand command("", true, { "client", "user", "privilege" });
- EXPECT_CALL(adminApi, cynara_admin_erase(_, StrEq(""), true, StrEq("client"), StrEq("user"),
+ EXPECT_CALL(m_adminApi, cynara_admin_erase(_, StrEq(""), true, StrEq("client"), StrEq("user"),
StrEq("privilege")))
.WillOnce(Return(CYNARA_API_SUCCESS));
using ::testing::SetArgPointee;
using ::testing::StrEq;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::CheckCyadCommand command("", true, { "client", "user", "privilege" });
int result = 42;
- EXPECT_CALL(adminApi, cynara_admin_check(_, StrEq(""), true, StrEq("client"), StrEq("user"),
+ EXPECT_CALL(m_adminApi, cynara_admin_check(_, StrEq(""), true, StrEq("client"), StrEq("user"),
StrEq("privilege"), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<6>(result), SetArgPointee<7>(nullptr),
Return(CYNARA_API_SUCCESS)));
using ::testing::SetArgPointee;
using ::testing::StrEq;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::CheckCyadCommand command("", true, { "client", "user", "privilege" });
int result = 42;
char *resultExtra = strdup("adams");
- EXPECT_CALL(adminApi, cynara_admin_check(_, StrEq(""), true, StrEq("client"), StrEq("user"),
+ EXPECT_CALL(m_adminApi, cynara_admin_check(_, StrEq(""), true, StrEq("client"), StrEq("user"),
StrEq("privilege"), NotNull(), NotNull()))
.WillOnce(DoAll(SetArgPointee<6>(result), SetArgPointee<7>(resultExtra),
Return(CYNARA_API_SUCCESS)));
using ::testing::StrEq;
using ::testing::Unused;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::CheckCyadCommand command("", true, { "client", "user", "privilege" });
strncpy(buf, "Test error message", buflen);
};
- EXPECT_CALL(adminApi, cynara_admin_check(_, StrEq(""), true, StrEq("client"), StrEq("user"),
+ EXPECT_CALL(m_adminApi, cynara_admin_check(_, StrEq(""), true, StrEq("client"), StrEq("user"),
StrEq("privilege"), NotNull(), NotNull()))
.WillOnce(Return(CYNARA_API_UNKNOWN_ERROR));
// Should we expect some minimal buflen here?
- EXPECT_CALL(errorApi, cynara_strerror(CYNARA_API_UNKNOWN_ERROR, NotNull(), _))
+ EXPECT_CALL(m_errorApi, cynara_strerror(CYNARA_API_UNKNOWN_ERROR, NotNull(), _))
.WillOnce(DoAll(Invoke(setErrorMessage), Return(CYNARA_API_SUCCESS)));
dispatcher.execute(command);
using ::testing::SetArgPointee;
using ::testing::StrEq;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::ListPoliciesCyadCommand command("", { "client", "user", "privilege" });
resultPolicies.seal();
auto policies = resultPolicies.duplicate();
- EXPECT_CALL(adminApi, cynara_admin_list_policies(_, StrEq(""), StrEq("client"), StrEq("user"),
+ EXPECT_CALL(m_adminApi, cynara_admin_list_policies(_, StrEq(""), StrEq("client"), StrEq("user"),
StrEq("privilege"), NotNull()))
.WillOnce(DoAll(SetArgPointee<5>(policies), Return(CYNARA_API_SUCCESS)));
using ::testing::SetArgPointee;
using ::testing::StrEq;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::ListPoliciesCyadCommand command("", { "client", "user", "privilege" });
resultPolicies.seal();
auto policies = resultPolicies.duplicate();
- EXPECT_CALL(adminApi, cynara_admin_list_policies(_, StrEq(""), StrEq("client"), StrEq("user"),
+ EXPECT_CALL(m_adminApi, cynara_admin_list_policies(_, StrEq(""), StrEq("client"), StrEq("user"),
StrEq("privilege"), NotNull()))
.WillOnce(DoAll(SetArgPointee<5>(policies), Return(CYNARA_API_SUCCESS)));
m_io.coutRaw().str());
}
-TEST_F(CyadCommandlineDispatcherTest, listPoliciesDescNone) {
+TEST_F(CyadCommandlineDispatcherTest, listPoliciesDesc) {
using ::testing::_;
using ::testing::DoAll;
using ::testing::NotNull;
using ::testing::Return;
using ::testing::SetArgPointee;
+ using ::testing::HasSubstr;
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
-
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
-
- Cynara::ListPoliciesDescCyadCommand command;
-
- auto descs = static_cast<cynara_admin_policy_descr **>(
- calloc(1, sizeof(cynara_admin_policy_descr *)));
- descs[0] = nullptr;
-
- EXPECT_CALL(adminApi, cynara_admin_list_policies_descriptions(_, NotNull()))
- .WillOnce(DoAll(SetArgPointee<1>(descs), Return(CYNARA_API_SUCCESS)));
-
- dispatcher.execute(command);
-
- ASSERT_EQ("", m_io.coutRaw().str());
-}
-
-TEST_F(CyadCommandlineDispatcherTest, listPoliciesDescOne) {
- using ::testing::_;
- using ::testing::DoAll;
- using ::testing::NotNull;
- using ::testing::Return;
- using ::testing::SetArgPointee;
-
- FakeAdminApiWrapper adminApi;
- FakeErrorApiWrapper errorApi;
-
- EXPECT_CALL(adminApi, cynara_admin_initialize(_)).WillOnce(Return(CYNARA_API_SUCCESS));
- EXPECT_CALL(adminApi, cynara_admin_finish(_)).WillOnce(Return(CYNARA_API_SUCCESS));
+ addDescriptions({ { 42, "adams" } });
- Cynara::CommandsDispatcher dispatcher(m_io, adminApi, errorApi);
+ Cynara::CommandsDispatcher dispatcher(m_io, m_adminApi, m_errorApi);
Cynara::ListPoliciesDescCyadCommand command;
-
- auto descs = static_cast<cynara_admin_policy_descr **>(
- calloc(2, sizeof(cynara_admin_policy_descr *)));
-
- descs[0] = static_cast<cynara_admin_policy_descr *>(malloc(sizeof(cynara_admin_policy_descr)));
- descs[0]->result = 42;
- descs[0]->name = strdup("adams");
- descs[1] = nullptr;
-
- EXPECT_CALL(adminApi, cynara_admin_list_policies_descriptions(_, NotNull()))
- .WillOnce(DoAll(SetArgPointee<1>(descs), Return(CYNARA_API_SUCCESS)));
-
dispatcher.execute(command);
- ASSERT_EQ("42;adams\n", m_io.coutRaw().str());
+ EXPECT_THAT(m_io.coutRaw().str(), HasSubstr("42;adams\n"));
}
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <memory>
#include <sstream>
+#include <string>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <common/exceptions/BucketRecordCorruptedException.h>
#include <common/types/PolicyKey.h>
+#include <common/types/PolicyType.h>
#include <cyad/AdminPolicyParser.h>
#include "helpers.h"
+static Cynara::PolicyType translatePolicy(const std::string &rawPolicy) {
+ return std::stoi(rawPolicy);
+}
+
TEST(AdminPolicyParser, parseInvalid) {
auto input = std::make_shared<std::stringstream>();
*input << "invalid input" << std::endl;
- ASSERT_THROW(Cynara::AdminPolicyParser::parse(input), Cynara::BucketRecordCorruptedException);
+ ASSERT_THROW(Cynara::AdminPolicyParser::parse(input, translatePolicy),
+ Cynara::BucketRecordCorruptedException);
}
TEST(AdminPolicyParser, parse0) {
Cynara::CynaraAdminPolicies expectedPolicies;
expectedPolicies.seal();
- auto policies = Cynara::AdminPolicyParser::parse(input);
+ auto policies = Cynara::AdminPolicyParser::parse(input, translatePolicy);
ASSERT_TRUE(policies.sealed());
ASSERT_THAT(policies.data(), AdmPolicyListEq(expectedPolicies.data()));
expectedPolicies.add("b", { 0, "m" }, { "c", "u", "p" });
expectedPolicies.seal();
- auto policies = Cynara::AdminPolicyParser::parse(input);
+ auto policies = Cynara::AdminPolicyParser::parse(input, translatePolicy);
ASSERT_TRUE(policies.sealed());
ASSERT_THAT(policies.data(), AdmPolicyListEq(expectedPolicies.data()));
expectedPolicies.add("b2", { 0, "m2" }, { "c2", "u2", "p2" });
expectedPolicies.seal();
- auto policies = Cynara::AdminPolicyParser::parse(input);
+ auto policies = Cynara::AdminPolicyParser::parse(input, translatePolicy);
ASSERT_TRUE(policies.sealed());
ASSERT_THAT(policies.data(), AdmPolicyListEq(expectedPolicies.data()));
projects / platform / core / security / cynara.git / commitdiff