TEST_F(CyadCommandlineTest, help_short) {
prepare_argv({ "./cyad", "-h" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
auto result = std::dynamic_pointer_cast<Cynara::HelpCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
}
TEST_F(CyadCommandlineTest, deleteBucket_short) {
prepare_argv({ "./cyad", "-d", "bucket" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
auto result = std::dynamic_pointer_cast<Cynara::DeleteBucketCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ("bucket", result->bucketId());
}
TEST_F(CyadCommandlineTest, setPoliciesBulkStdin_short) {
prepare_argv({ "./cyad", "-s", "-f", "-" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
auto result = std::dynamic_pointer_cast<Cynara::SetPolicyBulkCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ("-", result->filename());
}
int cmd_upload_archive(int argc, const char **argv, const char *prefix)
{
const char *sent_argv[MAX_ARGS];
struct child_process cld = { sent_argv };
cld.out = cld.err = -1;
cld.git_cmd = 1;
if (argc != 2)
usage(upload_archive_usage);
if (!enter_repo(argv[1], 0))
die("'%s' does not appear to be a git repository", argv[1]);
prepare_argv(sent_argv, argv);
if (start_command(&cld)) {
int err = errno;
packet_write(1, "NACK fork failed on the remote side\n");
die("upload-archive: %s", strerror(err));
}
/* parent - read from child, multiplex and send out to fd#1 */
packet_write(1, "ACK\n");
packet_flush(1);
while (1) {
struct pollfd pfd[2];
int status;
pfd[0].fd = cld.out;
pfd[0].events = POLLIN;
pfd[1].fd = cld.err;
pfd[1].events = POLLIN;
if (poll(pfd, 2, -1) < 0) {
if (errno != EINTR) {
error("poll failed resuming: %s",
strerror(errno));
sleep(1);
}
continue;
}
if (pfd[1].revents & POLLIN)
/* Status stream ready */
if (process_input(pfd[1].fd, 2))
continue;
if (pfd[0].revents & POLLIN)
/* Data stream ready */
if (process_input(pfd[0].fd, 1))
continue;
if (waitpid(cld.pid, &status, 0) < 0)
error_clnt("%s", lostchild);
else if (!WIFEXITED(status) || WEXITSTATUS(status) > 0)
error_clnt("%s", deadchild);
packet_flush(1);
break;
}
return 0;
}
TEST_F(CyadCommandlineTest, setBucket_short) {
prepare_argv({ "./cyad", "-b", "bucket", "-t", "42" });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
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_TRUE(result->policyResult().metadata().empty());
}
TEST_F(CyadCommandlineTest, listPoliciesOtherBucket_short) {
prepare_argv({ "./cyad", "-l", "some-bucket",
"-c", "c", "-u", "u", "-p", "p"
});
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
auto result = std::dynamic_pointer_cast<Cynara::ListPoliciesCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ("some-bucket", result->bucketId());
ASSERT_EQ(Cynara::PolicyKey("c", "u", "p"), result->policyKey());
}
TEST_F(CyadCommandlineTest, listPoliciesDefault_short) {
prepare_argv({ "./cyad", "-l", "",
"-c", "client", "-u", "user", "-p", "privilege"
});
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
auto result = std::dynamic_pointer_cast<Cynara::ListPoliciesCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ(CYNARA_ADMIN_DEFAULT_BUCKET, result->bucketId());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
TEST_F(CyadCommandlineTest, eraseNonrecursive_short) {
prepare_argv({ "./cyad", "-e", "bucket", "-r", "no",
"-c", "client", "-u", "user", "-p", "privilege"
});
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
auto result = std::dynamic_pointer_cast<Cynara::EraseCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ("bucket", result->bucketId());
ASSERT_FALSE(result->recursive());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
}
TEST_F(CyadCommandlineTest, setBucketWithMetadata_short) {
const std::string ultimateAnswer = "Answer to The Ultimate Question of Life,"
" the Universe, and Everything";
prepare_argv({ "./cyad", "-b", "adams", "-t", "42", "-m", ultimateAnswer });
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
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(ultimateAnswer, result->policyResult().metadata());
}
TEST_F(CyadCommandlineTest, setPolicyInDefaultBucketNoOption_short) {
prepare_argv({ "./cyad", "-s",
"-c", "client", "-u", "user", "-p", "privilege",
"-t", "ALLOW", "-m", "some-metadata"
});
Cynara::CyadCommandlineParser parser(this->argc(), this->argv());
auto result = std::dynamic_pointer_cast<Cynara::SetPolicyCyadCommand>(parser.parseMain());
ASSERT_NE(nullptr, result);
ASSERT_EQ("", result->bucketId());
ASSERT_EQ(Cynara::PolicyKey("client", "user", "privilege"), result->policyKey());
ASSERT_EQ("ALLOW", result->policyResult().policyType());
ASSERT_EQ("some-metadata", result->policyResult().metadata());
}
/**
* @brief Verify if passing no options to commandline handler succeeds
* @test Expected result:
* - call handler indicates success
* - empty output stream
* - empty error stream
*/
TEST_F(CynaraCommandlineTest, noOption) {
std::string err;
std::string out;
clearOutput();
prepare_argv({ execName });
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_FALSE(options.m_error);
ASSERT_FALSE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, static_cast<mode_t>(-1));
ASSERT_EQ(options.m_uid, static_cast<uid_t>(-1));
ASSERT_EQ(options.m_gid, static_cast<gid_t>(-1));
ASSERT_TRUE(out.empty());
ASSERT_TRUE(err.empty());
}
/**
* @brief Verify if passing "version" option to commandline handler returns version message
* @test Expected result:
* - call handler indicates success
* - version message in output stream
* - empty error stream
*/
TEST_F(CynaraCommandlineTest, version) {
std::string err;
std::string out;
for (const auto &opt : { "-V", "--version" }) {
clearOutput();
prepare_argv({ execName, opt });
SCOPED_TRACE(opt);
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_FALSE(options.m_error);
ASSERT_TRUE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, static_cast<mode_t>(-1));
ASSERT_EQ(options.m_uid, static_cast<uid_t>(-1));
ASSERT_EQ(options.m_gid, static_cast<gid_t>(-1));
ASSERT_EQ(std::string(CYNARA_VERSION) + "\n", out);
ASSERT_TRUE(err.empty());
}
}
/**
* @brief Verify if passing no group option to commandline fails
* @test Expected result:
* - call handler indicates failure
* - help message in output stream
* - error message in error stream
*/
TEST_F(CynaraCommandlineTest, groupOptionNoParam) {
std::string err;
std::string out;
for (const auto &groupOpt : { "-g", "--group" }) {
clearOutput();
prepare_argv({ execName, groupOpt});
SCOPED_TRACE(groupOpt);
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_TRUE(options.m_error);
ASSERT_TRUE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, static_cast<mode_t>(-1));
ASSERT_EQ(options.m_uid, static_cast<uid_t>(-1));
ASSERT_EQ(options.m_gid, static_cast<gid_t>(-1));
ASSERT_EQ(helpMessage, out);
ASSERT_EQ(std::string("Missing argument for option: ") + groupOpt + "\n", err);
}
}
/**
* @brief Verify if passing unknown option to commandline handler returns error message
* @test Expected result:
* - call handler indicates failure
* - help message in output stream
* - error message in error stream
*/
TEST_F(CynaraCommandlineTest, unknownOption) {
std::string err;
std::string out;
for (const auto &badOpt : { "-b", "--badOption" }) {
clearOutput();
prepare_argv({ execName, badOpt });
SCOPED_TRACE(badOpt);
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_TRUE(options.m_error);
ASSERT_TRUE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, static_cast<mode_t>(-1));
ASSERT_EQ(options.m_uid, static_cast<uid_t>(-1));
ASSERT_EQ(options.m_gid, static_cast<gid_t>(-1));
ASSERT_EQ(helpMessage, out);
ASSERT_EQ(std::string("Unknown option: ") + badOpt + "\n", err);
}
}
/**
* @brief Verify if passing invalid group option to commandline fails
* @test Expected result:
* - call handler indicates success
* - help message in output stream
* - error message in error stream
*/
TEST_F(CynaraCommandlineTest, groupOptionInvalid) {
std::string err;
std::string out;
std::string groupParam("GroupThatDoNotExist");
for (const auto &groupOpt : { "-g", "--group" }) {
clearOutput();
prepare_argv({ execName, groupOpt, groupParam});
SCOPED_TRACE(groupOpt);
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_TRUE(options.m_error);
ASSERT_TRUE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, static_cast<mode_t>(-1));
ASSERT_EQ(options.m_uid, static_cast<uid_t>(-1));
ASSERT_EQ(options.m_gid, static_cast<gid_t>(-1));
ASSERT_EQ(helpMessage, out);
ASSERT_EQ("Invalid param: GroupThatDoNotExist\n", err);
}
}
/**
* @brief Verify if passing group option to commandline succeeds
* @test Expected result:
* - call handler indicates success
* - empty output stream
* - empty error stream
*/
TEST_F(CynaraCommandlineTest, groupOptionGid) {
std::string err;
std::string out;
std::string groupParam("1234");
for (const auto &groupOpt : { "-g", "--group" }) {
clearOutput();
prepare_argv({ execName, groupOpt, groupParam});
SCOPED_TRACE(groupOpt);
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_FALSE(options.m_error);
ASSERT_FALSE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, static_cast<mode_t>(-1));
ASSERT_EQ(options.m_uid, static_cast<uid_t>(-1));
ASSERT_EQ(options.m_gid, 1234);
ASSERT_TRUE(out.empty());
ASSERT_TRUE(err.empty());
}
}
/**
* @brief Verify if passing user option to commandline succeeds
* @test Expected result:
* - call handler indicates success
* - empty output stream
* - empty error stream
*/
TEST_F(CynaraCommandlineTest, userOptionName) {
std::string err;
std::string out;
std::string userParam("root");
for (const auto &userOpt : { "-u", "--user" }) {
clearOutput();
prepare_argv({ execName, userOpt, userParam});
SCOPED_TRACE(userOpt);
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_FALSE(options.m_error);
ASSERT_FALSE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, static_cast<mode_t>(-1));
ASSERT_EQ(options.m_uid, 0);
ASSERT_EQ(options.m_gid, static_cast<gid_t>(-1));
ASSERT_TRUE(out.empty());
ASSERT_TRUE(err.empty());
}
}
/**
* @brief Verify if passing mask option to commandline succeeds
* @test Expected result:
* - call handler indicates success
* - empty output stream
* - empty error stream
*/
TEST_F(CynaraCommandlineTest, maskOption) {
std::string err;
std::string out;
std::string maskParam("0666");
for (const auto &maskOpt : { "-m", "--mask" }) {
clearOutput();
prepare_argv({ execName, maskOpt, maskParam});
SCOPED_TRACE(maskOpt);
const auto options = Parser::handleCmdlineOptions(this->argc(), this->argv());
getOutput(out, err);
ASSERT_FALSE(options.m_error);
ASSERT_FALSE(options.m_exit);
ASSERT_FALSE(options.m_daemon);
ASSERT_EQ(options.m_mask, 0666);
ASSERT_EQ(options.m_uid, static_cast<uid_t>(-1));
ASSERT_EQ(options.m_gid, static_cast<gid_t>(-1));
ASSERT_TRUE(out.empty());
ASSERT_TRUE(err.empty());
}
}
