#include <cynara-admin-types.h>
#include <common/types/PolicyKey.h>
+#include <cyad/CommandlineParser/CmdlineErrors.h>
#include <cyad/CommandlineParser/CyadCommand.h>
#include <cyad/CommandlineParser/CyadCommandlineParser.h>
#include <cyad/CommandlineParser/HumanReadableParser.h>
#include "CyadCommandlineTest.h"
-TEST_F(CyadCommandlineTest, help) {
+TEST_F(CyadCommandlineTest, helpPositive) {
prepare_argv({ "./cyad", "--help" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_NE(nullptr, result);
}
-TEST_F(CyadCommandlineTest, deleteBucket) {
+TEST_F(CyadCommandlineTest, deleteBucketPositive) {
prepare_argv({ "./cyad", "--delete-bucket=bucket" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ("bucket", result->bucketId());
}
-TEST_F(CyadCommandlineTest, setBucket) {
+TEST_F(CyadCommandlineTest, setBucketPositive) {
prepare_argv({ "./cyad", "--set-bucket=bucket", "--type=42" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_TRUE(result->policyResult().metadata().empty());
}
-TEST_F(CyadCommandlineTest, setBucketWithMetadata) {
+TEST_F(CyadCommandlineTest, setBucketWithMetadataPositive) {
const std::string ultimateAnswer = "Answer to The Ultimate Question of Life,"
" the Universe, and Everything";
ASSERT_EQ(ultimateAnswer, result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, setPolicy) {
+TEST_F(CyadCommandlineTest, setPolicyPositive) {
prepare_argv({ "./cyad", "--set-policy", "--bucket=some-bucket",
"--client=client", "--user=user", "--privilege=privilege",
"--type=42" });
ASSERT_TRUE(result->policyResult().metadata().empty());
}
-TEST_F(CyadCommandlineTest, setPolicyWithMetadata) {
+TEST_F(CyadCommandlineTest, setPolicyWithMetadataPositive) {
prepare_argv({ "./cyad", "--set-policy", "--bucket=some-bucket",
"--client=client", "--user=user", "--privilege=privilege",
"--type=42", "--metadata=some-metadata" });
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, setPolicyInDefaultBucket) {
+TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketPositive) {
prepare_argv({ "./cyad", "--set-policy", "--bucket=",
"--client=client", "--user=user", "--privilege=privilege",
"--type=ALLOW", "--metadata=some-metadata" });
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketNoOption) {
+TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketNoOptionPositive) {
prepare_argv({ "./cyad", "--set-policy",
"--client=client", "--user=user", "--privilege=privilege",
"--type=ALLOW", "--metadata=some-metadata" });
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, parsePolicyTypeBase10) {
+TEST_F(CyadCommandlineTest, parsePolicyTypeBase10Positive) {
auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
return Cynara::HumanReadableParser::policyType(rawPolicy);
};
ASSERT_EQ(CYNARA_ADMIN_ALLOW, parsePolicyType("65535"));
}
-TEST_F(CyadCommandlineTest, parsePolicyTypeBase16) {
+TEST_F(CyadCommandlineTest, parsePolicyTypeBase16Positive) {
auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
return Cynara::HumanReadableParser::policyType(rawPolicy);
};
ASSERT_EQ(CYNARA_ADMIN_ALLOW, parsePolicyType("0xFFFF"));
}
-TEST_F(CyadCommandlineTest, parsePolicyTypeHuman) {
+TEST_F(CyadCommandlineTest, parsePolicyTypeHumanPositive) {
auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
return Cynara::HumanReadableParser::policyType(rawPolicy);
};
ASSERT_EQ(CYNARA_ADMIN_ALLOW, parsePolicyType("ALLOW"));
}
-TEST_F(CyadCommandlineTest, setPoliciesBulkFilename) {
+TEST_F(CyadCommandlineTest, setPoliciesBulkFilenamePositive) {
prepare_argv({ "./cyad", "--set-policy", "--bulk=/tmp/input_file" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ("/tmp/input_file", result->filename());
}
-TEST_F(CyadCommandlineTest, setPoliciesBulkStdin) {
+TEST_F(CyadCommandlineTest, setPoliciesBulkStdinPositive) {
prepare_argv({ "./cyad", "--set-policy", "--bulk=-" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ("-", result->filename());
}
-TEST_F(CyadCommandlineTest, eraseRecursive) {
+TEST_F(CyadCommandlineTest, eraseRecursivePositive) {
prepare_argv({ "./cyad", "--erase=bucket", "--recursive=yes",
"--client=client", "--user=user", "--privilege=privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, eraseNonrecursive) {
+TEST_F(CyadCommandlineTest, eraseNonRecursivePositive) {
prepare_argv({ "./cyad", "--erase=bucket", "--recursive=no",
"--client=client", "--user=user", "--privilege=privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, checkDefaultRecursive) {
+TEST_F(CyadCommandlineTest, checkDefaultRecursivePositive) {
prepare_argv({ "./cyad", "--check", "--recursive=no",
"--client=client", "--user=user", "--privilege=privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesDefault) {
+TEST_F(CyadCommandlineTest, listPoliciesDefaultPositive) {
prepare_argv({ "./cyad", "--list-policies=",
"--client=client", "--user=user", "--privilege=privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesOtherBucket) {
+TEST_F(CyadCommandlineTest, listPoliciesOtherBucketPositive) {
prepare_argv({ "./cyad", "--list-policies=some-bucket",
"--client=c", "--user=u", "--privilege=p" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("c", "u", "p"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesAll) {
+TEST_F(CyadCommandlineTest, listPoliciesAllPositive) {
prepare_argv({ "./cyad", "--list-policies=",
"--all" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOption) {
+TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOptionPositive) {
prepare_argv({ "./cyad", "--list-policies=",
"--all", "--user=u" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOptions) {
+TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOptionsPositive) {
prepare_argv({ "./cyad", "--list-policies=",
"--all", "--user=u", "--client=c", "--privilege=p" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesDesc) {
+TEST_F(CyadCommandlineTest, listPoliciesDescPositive) {
prepare_argv({ "./cyad", "--list-policies-descriptions" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
- auto result = std::dynamic_pointer_cast<Cynara::ListPoliciesDescCyadCommand>(
- parser.parseMain());
+ auto result =
+ std::dynamic_pointer_cast<Cynara::ListPoliciesDescCyadCommand>(parser.parseMain());
+ ASSERT_NE(nullptr, result);
+}
+
+TEST_F(CyadCommandlineTest, backupPositive) {
+ prepare_argv({ "./cyad", "--backup" });
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+
+ auto result =
+ std::dynamic_pointer_cast<Cynara::BackupCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
}
ASSERT_EQ(msg, result->message()); \
}
-TEST_F(CyadCommandlineTest, noOption) {
+TEST_F(CyadCommandlineTest, noOptionNegative) {
prepare_argv({ "./cyad" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::noOption(), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, unknownOption) {
+TEST_F(CyadCommandlineTest, unknownOptionNegative) {
const char *unknown = "--unknown-option";
prepare_argv({ "./cyad", unknown });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::unknownOption(unknown), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, deleteBucketNoBucket) {
+TEST_F(CyadCommandlineTest, deleteBucketNoBucketNegative) {
prepare_argv({ "./cyad", "--delete-bucket" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::DeleteBucket), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, deleteBucketUnknownOption) {
+TEST_F(CyadCommandlineTest, deleteBucketUnknownOptionNegative) {
const char *unknown = "--unknown";
prepare_argv({ "./cyad", "--delete-bucket=bucket", unknown });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::unknownOption(unknown, CmdlineOpt::DeleteBucket), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setBucketNoBucket) {
+TEST_F(CyadCommandlineTest, setBucketNoBucketNegative) {
prepare_argv({ "./cyad", "--set-bucket" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::SetBucket), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setBucketNoPolicy) {
+TEST_F(CyadCommandlineTest, setBucketNoPolicyTypeNegative) {
prepare_argv({ "./cyad", "--set-bucket=bucket" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Type}, CmdlineOpt::SetBucket),
parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setBucketUnknownOption) {
+TEST_F(CyadCommandlineTest, setBucketUnknownOptionNegative) {
const char *unknown = "--unknown";
- prepare_argv({ "./cyad", "--set-bucket=bucket", "--unknown", "--type=42" });
+ prepare_argv({ "./cyad", "--set-bucket=bucket", unknown, "--type=42" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::unknownOption(unknown, CmdlineOpt::SetBucket), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setBucketMetadataNoPolicy) {
+TEST_F(CyadCommandlineTest, setBucketMetadataNoPolicyNegative) {
prepare_argv({ "./cyad", "--set-bucket=bucket", "--metadata=some-meta" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Type}, CmdlineOpt::SetBucket),
parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setPolicyNoOption) {
+TEST_F(CyadCommandlineTest, setBucketPolicyNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--set-bucket=bucket","--type"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Type, CmdlineOpt::SetBucket),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, setPolicyWithArgumentNegative) {
+ const char *setPolicyWithArgument = "--set-policy=unknown";
+ prepare_argv({ "./cyad", setPolicyWithArgument});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::unknownOption(setPolicyWithArgument), parser.parseMain());
+}
+
+
+TEST_F(CyadCommandlineTest, setPolicyNoOptionNegative) {
prepare_argv({ "./cyad", "--set-policy" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::optionsMissing(
{CmdlineOpt::Client, CmdlineOpt::User,
parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setPolicyUnknownOption) {
+TEST_F(CyadCommandlineTest, setPolicyUnknownOptionNegative) {
const char *unknown = "--unknown-option";
prepare_argv({ "./cyad", "--set-policy", unknown });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::unknownOption(unknown, CmdlineOpt::SetPolicy), parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setPolicyArgumentMissing) {
+TEST_F(CyadCommandlineTest, setPolicyArgumentMissingNegative) {
prepare_argv({ "./cyad", "--set-policy", "--bucket" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Bucket, CmdlineOpt::SetPolicy),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, setPolicyNoClientNegative) {
+ prepare_argv({ "./cyad", "--set-policy", "--bucket=some-bucket",
+ "--user=user", "--privilege=privilege", "--type=42" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
- ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Bucket, CmdlineOpt::SetPolicy), parser.parseMain());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Client}, CmdlineOpt::SetPolicy),
+ parser.parseMain());
}
-TEST_F(CyadCommandlineTest, setPolicyNoPolicy) {
+TEST_F(CyadCommandlineTest, setPolicyClientNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--set-policy", "--bucket=some-bucket",
+ "--user=user", "--privilege=privilege", "--type=42", "--client" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Client, CmdlineOpt::SetPolicy),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, setPolicyNoUserNegative) {
+ prepare_argv({ "./cyad", "--set-policy", "--bucket=some-bucket",
+ "--client=client", "--privilege=privilege", "--type=42"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::User}, CmdlineOpt::SetPolicy),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, setPolicyUserNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--set-policy", "--bucket=some-bucket",
+ "--client=client", "--privilege=privilege", "--type=42", "--user" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::User, CmdlineOpt::SetPolicy),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, setPolicyNoPrivilegeNegative) {
+ prepare_argv({ "./cyad", "--set-policy", "--client=client",
+ "--user=user", "--type=42" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Privilege}, CmdlineOpt::SetPolicy),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, setPolicyPrivilegeNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--set-policy", "--client=client",
+ "--user=user", "--type=42", "--privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Privilege, CmdlineOpt::SetPolicy),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, setPolicyNoPolicyTypeNegative) {
prepare_argv({ "./cyad", "--set-policy", "--bucket=some-bucket",
"--client=client", "--user=user", "--privilege=privilege" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Type}, CmdlineOpt::SetPolicy),
parser.parseMain());
}
-TEST_F(CyadCommandlineTest, eraseNoRecursive) {
- prepare_argv({ "./cyad", "--erase=",
- "--client=client", "--user=user", "--privilege=privilege" });
+TEST_F(CyadCommandlineTest, eraseNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--erase"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Erase), parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, eraseNoOptionsNegative) {
+ prepare_argv({ "./cyad", "--erase=bucket"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing(
+ {CmdlineOpt::Recursive, CmdlineOpt::Client,
+ CmdlineOpt::User, CmdlineOpt::Privilege},
+ CmdlineOpt::Erase),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, eraseUnknownOptionNegative) {
+ const char *unknown = "--unknown-option";
+ prepare_argv({ "./cyad", "--erase=bucket", unknown});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::unknownOption(unknown, CmdlineOpt::Erase), parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, eraseNoRecursiveNegative) {
+ prepare_argv({ "./cyad", "--erase=", "--client=client", "--user=user",
+ "--privilege=privilege" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Recursive}, CmdlineOpt::Erase),
parser.parseMain());
}
-// Error should be argument missing, but getopt acts weird
-TEST_F(CyadCommandlineTest, listPoliciesNoBucket) {
- prepare_argv({ "./cyad", "--list-policies",
- "--client=client", "--user=user", "--privilege=privilege" });
+TEST_F(CyadCommandlineTest, eraseRecursiveNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--erase=", "--client=client", "--user=user",
+ "--privilege=privilege", "--recursive" });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
- ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Client}, CmdlineOpt::ListPolicies),
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Recursive, CmdlineOpt::Erase),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, eraseNoClientNegative) {
+ prepare_argv({ "./cyad", "--erase=bucket", "--recursive=yes",
+ "--user=user", "--privilege=privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Client}, CmdlineOpt::Erase),
parser.parseMain());
}
-TEST_F(CyadCommandlineTest, listPoliciesAllWithArgument) {
+TEST_F(CyadCommandlineTest, eraseClientNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--erase=bucket", "--recursive=yes",
+ "--user=user", "--privilege=privilege", "--client" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Client, CmdlineOpt::Erase),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, eraseNoUserNegative) {
+ prepare_argv({ "./cyad", "--erase=bucket", "--recursive=yes",
+ "--client=client", "--privilege=privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::User}, CmdlineOpt::Erase),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, eraseUserNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--erase=bucket", "--recursive=yes",
+ "--client=client", "--privilege=privilege", "--user" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ auto result = std::dynamic_pointer_cast<Cynara::EraseCyadCommand>(parser.parseMain());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::User, CmdlineOpt::Erase),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, eraseNoPrivilegeNegative) {
+ prepare_argv({ "./cyad", "--erase=bucket", "--recursive=yes",
+ "--client=client", "--user=user" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ auto result = std::dynamic_pointer_cast<Cynara::EraseCyadCommand>(parser.parseMain());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Privilege}, CmdlineOpt::Erase),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, erasePrivilegeNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--erase=bucket", "--recursive=yes",
+ "--client=client", "--user=user", "--privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ auto result = std::dynamic_pointer_cast<Cynara::EraseCyadCommand>(parser.parseMain());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Privilege, CmdlineOpt::Erase),
+ parser.parseMain());
+}
+
+/* This one is undoable:
+ *
+ * getopt_long cannot distinguish between "--list-policies properBucketName" and
+ * "--list-policies --someLegitOtherOption". The way the below string is parsed is:
+ * opt: --list-policies optarg: --client=client
+ * Maybe there is some switch for getopt_long to force usage of '=', but it cannot
+ * be switched on now, because it could break some already existing usage of cyad.
+ *
+ * // Error should be argument missing, but getopt acts weird
+ * TEST_F(CyadCommandlineTest, listPoliciesNoBucket) {
+ * prepare_argv({ "./cyad", "--list-policies",
+ * "--client=client", "--user=user", "--privilege=privilege" });
+ * Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ * ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::ListPolicies), parser.parseMain());
+ * }
+ */
+
+TEST_F(CyadCommandlineTest, listPoliciesNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--list-policies"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::ListPolicies), parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listPoliciesUnknownOptionNegative) {
+ const char *unknown = "--unknown-option";
+ prepare_argv({ "./cyad", "--list-policies=", unknown});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::unknownOption(unknown, CmdlineOpt::ListPolicies), parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listPoliciesAllWithArgumentNegative) {
const char *all = "--all=all";
- prepare_argv({ "./cyad", "--list-policies",
- "", all });
+ prepare_argv({ "./cyad", "--list-policies=", all });
+
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_ERROR_MSG(Errors::unknownOption(all, CmdlineOpt::ListPolicies), parser.parseMain());
}
+
+TEST_F(CyadCommandlineTest, listPoliciesNoOptionsNegative) {
+ prepare_argv({ "./cyad", "--list-policies=" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing(
+ {CmdlineOpt::Client, CmdlineOpt::User,
+ CmdlineOpt::Privilege},
+ CmdlineOpt::ListPolicies),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listPoliciesNoClientNegative) {
+ prepare_argv({ "./cyad", "--list-policies=", "--user=user",
+ "--privilege=privilege"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Client}, CmdlineOpt::ListPolicies),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listPoliciesClientNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--list-policies=", "--user=user",
+ "--privilege=privilege", "--client"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Client, CmdlineOpt::ListPolicies),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listPoliciesNoUserNegative) {
+ prepare_argv({ "./cyad", "--list-policies=", "--client=client",
+ "--privilege=privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::User}, CmdlineOpt::ListPolicies),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listPoliciesUserNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--list-policies=", "--client=client",
+ "--privilege=privilege", "--user" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::User, CmdlineOpt::ListPolicies),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listPoliciesNoPrivilegeNegative) {
+ prepare_argv({ "./cyad", "--list-policies=", "--client=client",
+ "--user=user"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Privilege}, CmdlineOpt::ListPolicies),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, ListPoliciesPrivilegeNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--list-policies=", "--client=client",
+ "--user=user", "--privilege"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Privilege, CmdlineOpt::ListPolicies),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkWithArgumentNegative) {
+ const char *checkWithArgument = "--check=unknown";
+ prepare_argv({ "./cyad", checkWithArgument});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::unknownOption(checkWithArgument), parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkNoOptionsNegative) {
+ prepare_argv({ "./cyad", "--check"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing(
+ {CmdlineOpt::Recursive, CmdlineOpt::Client,
+ CmdlineOpt::User, CmdlineOpt::Privilege},
+ CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkUnknownOptionNegative) {
+ const char *unknown = "--unknown-option";
+ prepare_argv({ "./cyad", "--check", unknown});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::unknownOption(unknown, CmdlineOpt::Check), parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkNoRecursiveNegative) {
+ prepare_argv({ "./cyad", "--check", "--client=client", "--user=user",
+ "--privilege=privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Recursive}, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkRecursiveNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--check", "--client=client", "--user=user",
+ "--privilege=privilege", "--recursive" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Recursive, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkNoClientNegative) {
+ prepare_argv({ "./cyad", "--check", "--recursive=yes",
+ "--user=user", "--privilege=privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Client}, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkClientNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--check", "--recursive=yes",
+ "--user=user", "--privilege=privilege", "--client" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Client, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkNoUserNegative) {
+ prepare_argv({ "./cyad", "--check", "--recursive=yes",
+ "--client=client", "--privilege=privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::User}, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkUserNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--check", "--recursive=yes",
+ "--client=client", "--privilege=privilege", "--user" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::User, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkNoPrivilegeNegative) {
+ prepare_argv({ "./cyad", "--check", "--recursive=yes",
+ "--client=client", "--user=user" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::optionsMissing({CmdlineOpt::Privilege}, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkPrivilegeNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--check", "--recursive=yes",
+ "--client=client", "--user=user", "--privilege" });
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Privilege, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, checkBucketNoArgumentNegative) {
+ prepare_argv({ "./cyad", "--check", "--recursive=yes",
+ "--client=client", "--user=user", "--privilege=privilege",
+ "--bucket"});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::argumentMissing(CmdlineOpt::Bucket, CmdlineOpt::Check),
+ parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, listDescriptionsWithArgumentNegative) {
+ const char *listDescriptionsWithArgument = "--list-policies-descriptions=unknown";
+ prepare_argv({ "./cyad", listDescriptionsWithArgument});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::unknownOption(listDescriptionsWithArgument), parser.parseMain());
+}
+
+TEST_F(CyadCommandlineTest, backupWithArgumentNegative) {
+ const char *backupWithArgument = "--backup=unknown";
+ prepare_argv({ "./cyad", backupWithArgument});
+
+ Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
+ ASSERT_ERROR_MSG(Errors::unknownOption(backupWithArgument), parser.parseMain());
+}
+
#include "CyadCommandlineTest.h"
-TEST_F(CyadCommandlineTest, help_short) {
+TEST_F(CyadCommandlineTest, helpShortPositive) {
prepare_argv({ "./cyad", "-h" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_NE(nullptr, result);
}
-TEST_F(CyadCommandlineTest, deleteBucket_short) {
+TEST_F(CyadCommandlineTest, deleteBucketShortPositive) {
prepare_argv({ "./cyad", "-d", "bucket" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ("bucket", result->bucketId());
}
-TEST_F(CyadCommandlineTest, setBucket_short) {
+TEST_F(CyadCommandlineTest, setBucketShortPositive) {
prepare_argv({ "./cyad", "-b", "bucket", "-t", "42" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_TRUE(result->policyResult().metadata().empty());
}
-TEST_F(CyadCommandlineTest, setBucketWithMetadata_short) {
+TEST_F(CyadCommandlineTest, setBucketWithMetadataShortPositive) {
const std::string ultimateAnswer = "Answer to The Ultimate Question of Life,"
" the Universe, and Everything";
ASSERT_EQ(ultimateAnswer, result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, setPolicy_short) {
+TEST_F(CyadCommandlineTest, setPolicyShortPositive) {
prepare_argv({ "./cyad", "-s", "-k", "some-bucket",
"-c", "client", "-u", "user", "-p", "privilege",
"-t", "42" });
ASSERT_TRUE(result->policyResult().metadata().empty());
}
-TEST_F(CyadCommandlineTest, setPolicyWithMetadata_short) {
+TEST_F(CyadCommandlineTest, setPolicyWithMetadataShortPositive) {
prepare_argv({ "./cyad", "-s", "-k", "some-bucket",
"-c", "client", "-u", "user", "-p", "privilege",
"-t", "42", "-m", "some-metadata" });
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, setPolicyInDefaultBucket_short) {
+TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketShortPositive) {
prepare_argv({ "./cyad", "-s", "-k", "",
"-c", "client", "-u", "user", "-p", "privilege",
"-t", "ALLOW", "-m", "some-metadata" });
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketNoOption_short) {
+TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketNoOptionShortPositive) {
prepare_argv({ "./cyad", "-s",
"-c", "client", "-u", "user", "-p", "privilege",
"-t", "ALLOW", "-m", "some-metadata" });
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
-TEST_F(CyadCommandlineTest, parsePolicyTypeBase10_short) {
+TEST_F(CyadCommandlineTest, parsePolicyTypeBase10ShortPositive) {
auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
return Cynara::HumanReadableParser::policyType(rawPolicy);
};
ASSERT_EQ(CYNARA_ADMIN_ALLOW, parsePolicyType("65535"));
}
-TEST_F(CyadCommandlineTest, parsePolicyTypeBase16_short) {
+TEST_F(CyadCommandlineTest, parsePolicyTypeBase16ShortPositive) {
auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
return Cynara::HumanReadableParser::policyType(rawPolicy);
};
ASSERT_EQ(CYNARA_ADMIN_ALLOW, parsePolicyType("0xFFFF"));
}
-TEST_F(CyadCommandlineTest, parsePolicyTypeHuman_short) {
+TEST_F(CyadCommandlineTest, parsePolicyTypeHumanShortPositive) {
auto parsePolicyType = [] (const char *rawPolicy) -> Cynara::PolicyType {
return Cynara::HumanReadableParser::policyType(rawPolicy);
};
ASSERT_EQ(CYNARA_ADMIN_ALLOW, parsePolicyType("ALLOW"));
}
-TEST_F(CyadCommandlineTest, setPoliciesBulkFilename_short) {
+TEST_F(CyadCommandlineTest, setPoliciesBulkFilenameShortPositive) {
prepare_argv({ "./cyad", "-s", "-f", "/tmp/input_file" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ("/tmp/input_file", result->filename());
}
-TEST_F(CyadCommandlineTest, setPoliciesBulkStdin_short) {
+TEST_F(CyadCommandlineTest, setPoliciesBulkStdinShortPositive) {
prepare_argv({ "./cyad", "-s", "-f", "-" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ("-", result->filename());
}
-TEST_F(CyadCommandlineTest, eraseRecursive_short) {
+TEST_F(CyadCommandlineTest, eraseRecursiveShortPositive) {
prepare_argv({ "./cyad", "-e", "bucket", "-r", "yes",
"-c", "client", "-u", "user", "-p", "privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, eraseNonrecursive_short) {
+TEST_F(CyadCommandlineTest, eraseNonrecursiveShortPositive) {
prepare_argv({ "./cyad", "-e", "bucket", "-r", "no",
"-c", "client", "-u", "user", "-p", "privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, checkDefaultRecursive_short) {
+TEST_F(CyadCommandlineTest, checkDefaultRecursiveShortPositive) {
prepare_argv({ "./cyad", "-a", "-r", "no",
"-c", "client", "-u", "user", "-p", "privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesDefault_short) {
+TEST_F(CyadCommandlineTest, listPoliciesDefaultShortPositive) {
prepare_argv({ "./cyad", "-l", "",
"-c", "client", "-u", "user", "-p", "privilege" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesOtherBucket_short) {
+TEST_F(CyadCommandlineTest, listPoliciesOtherBucketShortPositive) {
prepare_argv({ "./cyad", "-l", "some-bucket",
"-c", "c", "-u", "u", "-p", "p" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
ASSERT_EQ(Cynara::PolicyKey("c", "u", "p"), result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesAll_short) {
+TEST_F(CyadCommandlineTest, listPoliciesAllShortPositive) {
prepare_argv({ "./cyad", "-l", "",
"-A" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOption_short) {
+TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOptionShortPositive) {
prepare_argv({ "./cyad", "-l", "",
"-A", "-u", "u" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOptions_short) {
+TEST_F(CyadCommandlineTest, listPoliciesAllAdditionalOptionsShortPositive) {
prepare_argv({ "./cyad", "-l", "",
"-A", "-c", "c", "-u", "u", "-p", "p" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
result->policyKey());
}
-TEST_F(CyadCommandlineTest, listPoliciesDesc_short) {
+TEST_F(CyadCommandlineTest, listPoliciesDescShortPositive) {
prepare_argv({ "./cyad", "-g" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
projects / platform / core / security / cynara.git / commitdiff