|
|
|
//
|
|
|
|
//
|
|
|
|
// Copyright 2016 gRPC authors.
|
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
//
|
|
|
|
//
|
|
|
|
|
|
|
|
#include "test/cpp/util/grpc_tool.h"
|
|
|
|
|
|
|
|
#include <chrono>
|
|
|
|
#include <sstream>
|
|
|
|
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
|
|
|
|
#include "absl/flags/declare.h"
|
|
|
|
#include "absl/flags/flag.h"
|
|
|
|
|
|
|
|
#include <grpc/grpc.h>
|
|
|
|
#include <grpc/support/alloc.h>
|
|
|
|
#include <grpcpp/channel.h>
|
|
|
|
#include <grpcpp/client_context.h>
|
|
|
|
#include <grpcpp/create_channel.h>
|
|
|
|
#include <grpcpp/ext/proto_server_reflection_plugin.h>
|
|
|
|
#include <grpcpp/server.h>
|
|
|
|
#include <grpcpp/server_builder.h>
|
|
|
|
#include <grpcpp/server_context.h>
|
|
|
|
|
|
|
|
#include "src/core/lib/gprpp/env.h"
|
|
|
|
#include "src/core/lib/iomgr/load_file.h"
|
|
|
|
#include "src/proto/grpc/testing/echo.grpc.pb.h"
|
|
|
|
#include "src/proto/grpc/testing/echo.pb.h"
|
|
|
|
#include "test/core/util/port.h"
|
|
|
|
#include "test/core/util/test_config.h"
|
|
|
|
#include "test/cpp/util/cli_credentials.h"
|
|
|
|
#include "test/cpp/util/string_ref_helper.h"
|
|
|
|
#include "test/cpp/util/test_config.h"
|
|
|
|
|
|
|
|
#define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
|
|
|
|
#define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
|
|
|
|
#define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
|
|
|
|
|
|
|
|
using grpc::testing::EchoRequest;
|
|
|
|
using grpc::testing::EchoResponse;
|
|
|
|
|
|
|
|
#define USAGE_REGEX "( grpc_cli .+\n){2,10}"
|
|
|
|
|
|
|
|
#define ECHO_TEST_SERVICE_SUMMARY \
|
|
|
|
"Echo\n" \
|
|
|
|
"Echo1\n" \
|
|
|
|
"Echo2\n" \
|
|
|
|
"CheckDeadlineUpperBound\n" \
|
|
|
|
"CheckDeadlineSet\n" \
|
|
|
|
"CheckClientInitialMetadata\n" \
|
|
|
|
"RequestStream\n" \
|
|
|
|
"ResponseStream\n" \
|
|
|
|
"BidiStream\n" \
|
|
|
|
"Unimplemented\n" \
|
|
|
|
"UnimplementedBidi\n"
|
|
|
|
|
|
|
|
#define ECHO_TEST_SERVICE_DESCRIPTION \
|
|
|
|
"filename: src/proto/grpc/testing/echo.proto\n" \
|
|
|
|
"package: grpc.testing;\n" \
|
|
|
|
"service EchoTestService {\n" \
|
|
|
|
" rpc Echo(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
|
|
|
|
"{}\n" \
|
|
|
|
" rpc Echo1(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
|
|
|
|
"{}\n" \
|
|
|
|
" rpc Echo2(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
|
|
|
|
"{}\n" \
|
|
|
|
" rpc CheckDeadlineUpperBound(grpc.testing.SimpleRequest) returns " \
|
|
|
|
"(grpc.testing.StringValue) {}\n" \
|
|
|
|
" rpc CheckDeadlineSet(grpc.testing.SimpleRequest) returns " \
|
|
|
|
"(grpc.testing.StringValue) {}\n" \
|
|
|
|
" rpc CheckClientInitialMetadata(grpc.testing.SimpleRequest) returns " \
|
|
|
|
"(grpc.testing.SimpleResponse) {}\n" \
|
|
|
|
" rpc RequestStream(stream grpc.testing.EchoRequest) returns " \
|
|
|
|
"(grpc.testing.EchoResponse) {}\n" \
|
|
|
|
" rpc ResponseStream(grpc.testing.EchoRequest) returns (stream " \
|
|
|
|
"grpc.testing.EchoResponse) {}\n" \
|
|
|
|
" rpc BidiStream(stream grpc.testing.EchoRequest) returns (stream " \
|
|
|
|
"grpc.testing.EchoResponse) {}\n" \
|
|
|
|
" rpc Unimplemented(grpc.testing.EchoRequest) returns " \
|
|
|
|
"(grpc.testing.EchoResponse) {}\n" \
|
|
|
|
" rpc UnimplementedBidi(stream grpc.testing.EchoRequest) returns (stream " \
|
|
|
|
"grpc.testing.EchoResponse) {}\n" \
|
|
|
|
"}\n" \
|
|
|
|
"\n"
|
|
|
|
|
|
|
|
#define ECHO_METHOD_DESCRIPTION \
|
|
|
|
" rpc Echo(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
|
|
|
|
"{}\n"
|
|
|
|
|
|
|
|
#define ECHO_RESPONSE_MESSAGE_TEXT_FORMAT \
|
|
|
|
"message: \"echo\"\n" \
|
|
|
|
"param {\n" \
|
|
|
|
" host: \"localhost\"\n" \
|
|
|
|
" peer: \"peer\"\n" \
|
|
|
|
"}\n\n"
|
|
|
|
|
|
|
|
#define ECHO_RESPONSE_MESSAGE_JSON_FORMAT \
|
|
|
|
"{\n" \
|
|
|
|
" \"message\": \"echo\",\n" \
|
|
|
|
" \"param\": {\n" \
|
|
|
|
" \"host\": \"localhost\",\n" \
|
|
|
|
" \"peer\": \"peer\"\n" \
|
|
|
|
" }\n" \
|
|
|
|
"}\n\n"
|
|
|
|
|
|
|
|
ABSL_DECLARE_FLAG(std::string, channel_creds_type);
|
|
|
|
ABSL_DECLARE_FLAG(std::string, ssl_target);
|
|
|
|
ABSL_DECLARE_FLAG(bool, binary_input);
|
|
|
|
ABSL_DECLARE_FLAG(bool, binary_output);
|
|
|
|
ABSL_DECLARE_FLAG(bool, json_input);
|
|
|
|
ABSL_DECLARE_FLAG(bool, json_output);
|
|
|
|
ABSL_DECLARE_FLAG(bool, l);
|
|
|
|
ABSL_DECLARE_FLAG(bool, batch);
|
|
|
|
ABSL_DECLARE_FLAG(std::string, metadata);
|
|
|
|
ABSL_DECLARE_FLAG(std::string, protofiles);
|
|
|
|
ABSL_DECLARE_FLAG(std::string, proto_path);
|
|
|
|
ABSL_DECLARE_FLAG(std::string, default_service_config);
|
|
|
|
ABSL_DECLARE_FLAG(double, timeout);
|
|
|
|
ABSL_DECLARE_FLAG(int, max_recv_msg_size);
|
|
|
|
|
|
|
|
namespace grpc {
|
|
|
|
namespace testing {
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
const int kServerDefaultResponseStreamsToSend = 3;
|
|
|
|
|
|
|
|
class TestCliCredentials final : public grpc::testing::CliCredentials {
|
|
|
|
public:
|
|
|
|
explicit TestCliCredentials(bool secure = false) : secure_(secure) {}
|
|
|
|
std::shared_ptr<grpc::ChannelCredentials> GetChannelCredentials()
|
|
|
|
const override {
|
|
|
|
if (!secure_) {
|
|
|
|
return InsecureChannelCredentials();
|
|
|
|
}
|
|
|
|
grpc_slice ca_slice;
|
|
|
|
GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
|
|
|
|
grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
|
|
|
|
const char* test_root_cert =
|
|
|
|
reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
|
|
|
|
SslCredentialsOptions ssl_opts = {test_root_cert, "", ""};
|
|
|
|
std::shared_ptr<grpc::ChannelCredentials> credential_ptr =
|
|
|
|
grpc::SslCredentials(grpc::SslCredentialsOptions(ssl_opts));
|
|
|
|
grpc_slice_unref(ca_slice);
|
|
|
|
return credential_ptr;
|
|
|
|
}
|
|
|
|
std::string GetCredentialUsage() const override { return ""; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
const bool secure_;
|
|
|
|
};
|
|
|
|
|
|
|
|
bool PrintStream(std::stringstream* ss, const std::string& output) {
|
|
|
|
(*ss) << output;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
size_t ArraySize(T& a) {
|
|
|
|
return ((sizeof(a) / sizeof(*(a))) /
|
|
|
|
static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))));
|
|
|
|
}
|
|
|
|
|
|
|
|
class TestServiceImpl : public grpc::testing::EchoTestService::Service {
|
|
|
|
public:
|
|
|
|
Status Echo(ServerContext* context, const EchoRequest* request,
|
|
|
|
EchoResponse* response) override {
|
|
|
|
if (!context->client_metadata().empty()) {
|
|
|
|
for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
|
|
|
|
iter = context->client_metadata().begin();
|
|
|
|
iter != context->client_metadata().end(); ++iter) {
|
|
|
|
context->AddInitialMetadata(ToString(iter->first),
|
|
|
|
ToString(iter->second));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
context->AddTrailingMetadata("trailing_key", "trailing_value");
|
|
|
|
response->set_message(request->message());
|
|
|
|
return Status::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status CheckDeadlineSet(ServerContext* context,
|
|
|
|
const SimpleRequest* /*request*/,
|
|
|
|
StringValue* response) override {
|
|
|
|
response->set_message(context->deadline() !=
|
|
|
|
std::chrono::system_clock::time_point::max()
|
|
|
|
? "true"
|
|
|
|
: "false");
|
|
|
|
return Status::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if deadline - current time <= timeout
|
|
|
|
// If deadline set, timeout + current time should be an upper bound for it
|
|
|
|
Status CheckDeadlineUpperBound(ServerContext* context,
|
|
|
|
const SimpleRequest* /*request*/,
|
|
|
|
StringValue* response) override {
|
|
|
|
auto seconds = std::chrono::duration_cast<std::chrono::seconds>(
|
|
|
|
context->deadline() - std::chrono::system_clock::now());
|
|
|
|
|
|
|
|
// Returning string instead of bool to avoid using embedded messages in
|
|
|
|
// proto3
|
|
|
|
response->set_message(
|
|
|
|
seconds.count() <= absl::GetFlag(FLAGS_timeout) ? "true" : "false");
|
|
|
|
return Status::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status RequestStream(ServerContext* context,
|
|
|
|
ServerReader<EchoRequest>* reader,
|
|
|
|
EchoResponse* response) override {
|
|
|
|
EchoRequest request;
|
|
|
|
response->set_message("");
|
|
|
|
if (!context->client_metadata().empty()) {
|
|
|
|
for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
|
|
|
|
iter = context->client_metadata().begin();
|
|
|
|
iter != context->client_metadata().end(); ++iter) {
|
|
|
|
context->AddInitialMetadata(ToString(iter->first),
|
|
|
|
ToString(iter->second));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
context->AddTrailingMetadata("trailing_key", "trailing_value");
|
|
|
|
while (reader->Read(&request)) {
|
|
|
|
response->mutable_message()->append(request.message());
|
|
|
|
}
|
|
|
|
|
|
|
|
return Status::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status ResponseStream(ServerContext* context, const EchoRequest* request,
|
|
|
|
ServerWriter<EchoResponse>* writer) override {
|
|
|
|
if (!context->client_metadata().empty()) {
|
|
|
|
for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
|
|
|
|
iter = context->client_metadata().begin();
|
|
|
|
iter != context->client_metadata().end(); ++iter) {
|
|
|
|
context->AddInitialMetadata(ToString(iter->first),
|
|
|
|
ToString(iter->second));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
context->AddTrailingMetadata("trailing_key", "trailing_value");
|
|
|
|
|
|
|
|
EchoResponse response;
|
|
|
|
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
|
|
|
|
response.set_message(request->message() + std::to_string(i));
|
|
|
|
writer->Write(response);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Status::OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status BidiStream(
|
|
|
|
ServerContext* context,
|
|
|
|
ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
|
|
|
|
EchoRequest request;
|
|
|
|
EchoResponse response;
|
|
|
|
if (!context->client_metadata().empty()) {
|
|
|
|
for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
|
|
|
|
iter = context->client_metadata().begin();
|
|
|
|
iter != context->client_metadata().end(); ++iter) {
|
|
|
|
context->AddInitialMetadata(ToString(iter->first),
|
|
|
|
ToString(iter->second));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
context->AddTrailingMetadata("trailing_key", "trailing_value");
|
|
|
|
|
|
|
|
while (stream->Read(&request)) {
|
|
|
|
response.set_message(request.message());
|
|
|
|
stream->Write(response);
|
|
|
|
}
|
|
|
|
|
|
|
|
return Status::OK;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
class GrpcToolTest : public ::testing::Test {
|
|
|
|
protected:
|
|
|
|
GrpcToolTest() {}
|
|
|
|
|
|
|
|
// SetUpServer cannot be used with EXPECT_EXIT. grpc_pick_unused_port_or_die()
|
|
|
|
// uses atexit() to free chosen ports, and it will spawn a new thread in
|
|
|
|
// resolve_address_posix.c:192 at exit time.
|
|
|
|
std::string SetUpServer(bool secure = false) {
|
|
|
|
std::ostringstream server_address;
|
|
|
|
int port = grpc_pick_unused_port_or_die();
|
|
|
|
server_address << "localhost:" << port;
|
|
|
|
// Setup server
|
|
|
|
ServerBuilder builder;
|
|
|
|
std::shared_ptr<grpc::ServerCredentials> creds;
|
|
|
|
grpc_slice cert_slice, key_slice;
|
|
|
|
GPR_ASSERT(GRPC_LOG_IF_ERROR(
|
|
|
|
"load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
|
|
|
|
GPR_ASSERT(GRPC_LOG_IF_ERROR(
|
|
|
|
"load_file", grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
|
|
|
|
const char* server_cert =
|
|
|
|
reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
|
|
|
|
const char* server_key =
|
|
|
|
reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
|
|
|
|
SslServerCredentialsOptions::PemKeyCertPair pkcp = {server_key,
|
|
|
|
server_cert};
|
|
|
|
if (secure) {
|
|
|
|
SslServerCredentialsOptions ssl_opts;
|
|
|
|
ssl_opts.pem_root_certs = "";
|
|
|
|
ssl_opts.pem_key_cert_pairs.push_back(pkcp);
|
|
|
|
creds = SslServerCredentials(ssl_opts);
|
|
|
|
} else {
|
|
|
|
creds = InsecureServerCredentials();
|
|
|
|
}
|
|
|
|
builder.AddListeningPort(server_address.str(), creds);
|
|
|
|
builder.RegisterService(&service_);
|
|
|
|
server_ = builder.BuildAndStart();
|
|
|
|
grpc_slice_unref(cert_slice);
|
|
|
|
grpc_slice_unref(key_slice);
|
|
|
|
return server_address.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
void ShutdownServer() { server_->Shutdown(); }
|
|
|
|
|
|
|
|
std::unique_ptr<Server> server_;
|
|
|
|
TestServiceImpl service_;
|
|
|
|
reflection::ProtoServerReflectionPlugin plugin_;
|
|
|
|
};
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, NoCommand) {
|
|
|
|
// Test input "grpc_cli"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const char* argv[] = {"grpc_cli"};
|
|
|
|
// Exit with 1, print usage instruction in stderr
|
|
|
|
EXPECT_EXIT(
|
|
|
|
GrpcToolMainLib(
|
|
|
|
ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream, std::placeholders::_1)),
|
|
|
|
::testing::ExitedWithCode(1), "No command specified\n" USAGE_REGEX);
|
|
|
|
// No output
|
|
|
|
EXPECT_TRUE(0 == output_stream.tellp());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, InvalidCommand) {
|
|
|
|
// Test input "grpc_cli"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const char* argv[] = {"grpc_cli", "abc"};
|
|
|
|
// Exit with 1, print usage instruction in stderr
|
|
|
|
EXPECT_EXIT(
|
|
|
|
GrpcToolMainLib(
|
|
|
|
ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream, std::placeholders::_1)),
|
|
|
|
::testing::ExitedWithCode(1), "Invalid command 'abc'\n" USAGE_REGEX);
|
|
|
|
// No output
|
|
|
|
EXPECT_TRUE(0 == output_stream.tellp());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, HelpCommand) {
|
|
|
|
// Test input "grpc_cli help"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const char* argv[] = {"grpc_cli", "help"};
|
|
|
|
// Exit with 1, print usage instruction in stderr
|
|
|
|
EXPECT_EXIT(GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)),
|
|
|
|
::testing::ExitedWithCode(1), USAGE_REGEX);
|
|
|
|
// No output
|
|
|
|
EXPECT_TRUE(0 == output_stream.tellp());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, ListCommand) {
|
|
|
|
// Test input "grpc_cli list localhost:<port>"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "ls", server_address.c_str()};
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_l, false);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
"grpc.testing.EchoTestService\n"
|
|
|
|
"grpc.reflection.v1alpha.ServerReflection\n"));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, ListOneService) {
|
|
|
|
// Test input "grpc_cli list localhost:<port> grpc.testing.EchoTestService"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "ls", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoTestService"};
|
|
|
|
// without -l flag
|
|
|
|
absl::SetFlag(&FLAGS_l, false);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: ECHO_TEST_SERVICE_SUMMARY
|
|
|
|
EXPECT_TRUE(0 ==
|
|
|
|
strcmp(output_stream.str().c_str(), ECHO_TEST_SERVICE_SUMMARY));
|
|
|
|
|
|
|
|
// with -l flag
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
absl::SetFlag(&FLAGS_l, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: ECHO_TEST_SERVICE_DESCRIPTION
|
|
|
|
EXPECT_TRUE(
|
|
|
|
0 == strcmp(output_stream.str().c_str(), ECHO_TEST_SERVICE_DESCRIPTION));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, TypeCommand) {
|
|
|
|
// Test input "grpc_cli type localhost:<port> grpc.testing.EchoRequest"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "type", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoRequest"};
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
const grpc::protobuf::Descriptor* desc =
|
|
|
|
grpc::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName(
|
|
|
|
"grpc.testing.EchoRequest");
|
|
|
|
// Expected output: the DebugString of grpc.testing.EchoRequest
|
|
|
|
EXPECT_TRUE(0 ==
|
|
|
|
strcmp(output_stream.str().c_str(), desc->DebugString().c_str()));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, ListOneMethod) {
|
|
|
|
// Test input "grpc_cli list localhost:<port> grpc.testing.EchoTestService"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "ls", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoTestService.Echo"};
|
|
|
|
// without -l flag
|
|
|
|
absl::SetFlag(&FLAGS_l, false);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "Echo"
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(), "Echo\n"));
|
|
|
|
|
|
|
|
// with -l flag
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
absl::SetFlag(&FLAGS_l, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: ECHO_METHOD_DESCRIPTION
|
|
|
|
EXPECT_TRUE(0 ==
|
|
|
|
strcmp(output_stream.str().c_str(), ECHO_METHOD_DESCRIPTION));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, TypeNotFound) {
|
|
|
|
// Test input "grpc_cli type localhost:<port> grpc.testing.PhonyRequest"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "type", server_address.c_str(),
|
|
|
|
"grpc.testing.PhonyRequest"};
|
|
|
|
|
|
|
|
EXPECT_TRUE(1 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommand) {
|
|
|
|
// Test input "grpc_cli call localhost:<port> Echo "message: 'Hello'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
|
|
|
|
"message: 'Hello'"};
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
|
|
|
|
// TODO(Capstan): Consider using absl::FlagSaver
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
|
|
|
|
// Expected output:
|
|
|
|
// {
|
|
|
|
// "message": "Hello"
|
|
|
|
// }
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"{\n \"message\": \"Hello\"\n}"));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandJsonInput) {
|
|
|
|
// Test input "grpc_cli call localhost:<port> Echo "{ \"message\": \"Hello\"}"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
|
|
|
|
"{ \"message\": \"Hello\"}"};
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_input, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
absl::SetFlag(&FLAGS_json_input, false);
|
|
|
|
|
|
|
|
// Expected output:
|
|
|
|
// {
|
|
|
|
// "message": "Hello"
|
|
|
|
// }
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"{\n \"message\": \"Hello\"\n}"));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandBatch) {
|
|
|
|
// Test input "grpc_cli call Echo"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
|
|
|
|
"message: 'Hello0'"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss("message: 'Hello1'\n\n message: 'Hello2'\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
|
|
|
|
// "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0\"\nmessage: "
|
|
|
|
"\"Hello1\"\nmessage: \"Hello2\"\n"));
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
ss.clear();
|
|
|
|
ss.seekg(0);
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
|
|
|
|
// Expected output:
|
|
|
|
// {
|
|
|
|
// "message": "Hello0"
|
|
|
|
// }
|
|
|
|
// {
|
|
|
|
// "message": "Hello1"
|
|
|
|
// }
|
|
|
|
// {
|
|
|
|
// "message": "Hello2"
|
|
|
|
// }
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
|
|
|
|
// "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"{\n \"message\": \"Hello0\"\n}\n"
|
|
|
|
"{\n \"message\": \"Hello1\"\n}\n"
|
|
|
|
"{\n \"message\": \"Hello2\"\n}\n"));
|
|
|
|
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandBatchJsonInput) {
|
|
|
|
// Test input "grpc_cli call Echo"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
|
|
|
|
"{\"message\": \"Hello0\"}"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss(
|
|
|
|
"{\"message\": \"Hello1\"}\n\n{\"message\": \"Hello2\" }\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_input, true);
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
|
|
|
|
// "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0\"\nmessage: "
|
|
|
|
"\"Hello1\"\nmessage: \"Hello2\"\n"));
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
ss.clear();
|
|
|
|
ss.seekg(0);
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
absl::SetFlag(&FLAGS_json_input, false);
|
|
|
|
|
|
|
|
// Expected output:
|
|
|
|
// {
|
|
|
|
// "message": "Hello0"
|
|
|
|
// }
|
|
|
|
// {
|
|
|
|
// "message": "Hello1"
|
|
|
|
// }
|
|
|
|
// {
|
|
|
|
// "message": "Hello2"
|
|
|
|
// }
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
|
|
|
|
// "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"{\n \"message\": \"Hello0\"\n}\n"
|
|
|
|
"{\n \"message\": \"Hello1\"\n}\n"
|
|
|
|
"{\n \"message\": \"Hello2\"\n}\n"));
|
|
|
|
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandBatchWithBadRequest) {
|
|
|
|
// Test input "grpc_cli call Echo"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
|
|
|
|
"message: 'Hello0'"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 1\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss("message: 1\n\n message: 'Hello2'\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0\"\nmessage: \"Hello2\"\n"));
|
|
|
|
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
ss.clear();
|
|
|
|
ss.seekg(0);
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
|
|
|
|
// Expected output:
|
|
|
|
// {
|
|
|
|
// "message": "Hello0"
|
|
|
|
// }
|
|
|
|
// {
|
|
|
|
// "message": "Hello2"
|
|
|
|
// }
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
|
|
|
|
// "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"{\n \"message\": \"Hello0\"\n}\n"
|
|
|
|
"{\n \"message\": \"Hello2\"\n}\n"));
|
|
|
|
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandBatchJsonInputWithBadRequest) {
|
|
|
|
// Test input "grpc_cli call Echo"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
|
|
|
|
"{ \"message\": \"Hello0\"}"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 1\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss(
|
|
|
|
"{ \"message\": 1 }\n\n { \"message\": \"Hello2\" }\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
absl::SetFlag(&FLAGS_json_input, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_input, false);
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0\"\nmessage: \"Hello2\"\n"));
|
|
|
|
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
ss.clear();
|
|
|
|
ss.seekg(0);
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_batch, true);
|
|
|
|
absl::SetFlag(&FLAGS_json_input, true);
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
absl::SetFlag(&FLAGS_json_input, false);
|
|
|
|
absl::SetFlag(&FLAGS_batch, false);
|
|
|
|
|
|
|
|
// Expected output:
|
|
|
|
// {
|
|
|
|
// "message": "Hello0"
|
|
|
|
// }
|
|
|
|
// {
|
|
|
|
// "message": "Hello2"
|
|
|
|
// }
|
|
|
|
// Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
|
|
|
|
// "Hello2"\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"{\n \"message\": \"Hello0\"\n}\n"
|
|
|
|
"{\n \"message\": \"Hello2\"\n}\n"));
|
|
|
|
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandRequestStream) {
|
|
|
|
// Test input: grpc_cli call localhost:<port> RequestStream "message:
|
|
|
|
// 'Hello0'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"RequestStream", "message: 'Hello0'"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss("message: 'Hello1'\n\n message: 'Hello2'\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: \"Hello0Hello1Hello2\""
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0Hello1Hello2\""));
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandRequestStreamJsonInput) {
|
|
|
|
// Test input: grpc_cli call localhost:<port> RequestStream "{ \"message\":
|
|
|
|
// \"Hello0\"}"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"RequestStream", "{ \"message\": \"Hello0\" }"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss(
|
|
|
|
"{ \"message\": \"Hello1\" }\n\n{ \"message\": \"Hello2\" }\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_input, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_input, false);
|
|
|
|
|
|
|
|
// Expected output: "message: \"Hello0Hello1Hello2\""
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0Hello1Hello2\""));
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandRequestStreamWithBadRequest) {
|
|
|
|
// Test input: grpc_cli call localhost:<port> RequestStream "message:
|
|
|
|
// 'Hello0'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"RequestStream", "message: 'Hello0'"};
|
|
|
|
|
|
|
|
// Mock std::cin input "bad_field: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss("bad_field: 'Hello1'\n\n message: 'Hello2'\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: \"Hello0Hello2\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello0Hello2\""));
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandRequestStreamWithBadRequestJsonInput) {
|
|
|
|
// Test input: grpc_cli call localhost:<port> RequestStream "message:
|
|
|
|
// 'Hello0'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"RequestStream", "{ \"message\": \"Hello0\" }"};
|
|
|
|
|
|
|
|
// Mock std::cin input "bad_field: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss(
|
|
|
|
"{ \"bad_field\": \"Hello1\" }\n\n{ \"message\": \"Hello2\" }\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_input, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_input, false);
|
|
|
|
|
|
|
|
// Expected output: "message: \"Hello0Hello2\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello0Hello2\""));
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandWithTimeoutDeadlineSet) {
|
|
|
|
// Test input "grpc_cli call CheckDeadlineSet --timeout=5000.25"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"CheckDeadlineSet"};
|
|
|
|
|
|
|
|
// Set timeout to 5000.25 seconds
|
|
|
|
absl::SetFlag(&FLAGS_timeout, 5000.25);
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: "true"", deadline set
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"true\""));
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandWithTimeoutDeadlineUpperBound) {
|
|
|
|
// Test input "grpc_cli call CheckDeadlineUpperBound --timeout=900"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"CheckDeadlineUpperBound"};
|
|
|
|
|
|
|
|
// Set timeout to 900 seconds
|
|
|
|
absl::SetFlag(&FLAGS_timeout, 900);
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
std::string output = output_stream.str();
|
|
|
|
|
|
|
|
// Expected output: "message: "true""
|
|
|
|
// deadline not greater than timeout + current time
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output.c_str(), "message: \"true\"")) << output;
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandWithNegativeTimeoutValue) {
|
|
|
|
// Test input "grpc_cli call CheckDeadlineSet --timeout=-5"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"CheckDeadlineSet"};
|
|
|
|
|
|
|
|
// Set timeout to -5 (deadline not set)
|
|
|
|
absl::SetFlag(&FLAGS_timeout, -5);
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: "false"", deadline not set
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"false\""));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandWithDefaultTimeoutValue) {
|
|
|
|
// Test input "grpc_cli call CheckDeadlineSet --timeout=-1"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"CheckDeadlineSet"};
|
|
|
|
|
|
|
|
// Set timeout to -1 (default value, deadline not set)
|
|
|
|
absl::SetFlag(&FLAGS_timeout, -1);
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: "false"", deadline not set
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"false\""));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandResponseStream) {
|
|
|
|
// Test input: grpc_cli call localhost:<port> ResponseStream "message:
|
|
|
|
// 'Hello'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"ResponseStream", "message: 'Hello'"};
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: \"Hello{n}\""
|
|
|
|
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
|
|
|
|
std::string expected_response_text =
|
|
|
|
"message: \"Hello" + std::to_string(i) + "\"\n";
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
expected_response_text.c_str()));
|
|
|
|
}
|
|
|
|
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
|
|
|
|
// Expected output: "{\n \"message\": \"Hello{n}\"\n}\n"
|
|
|
|
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
|
|
|
|
std::string expected_response_text =
|
|
|
|
"{\n \"message\": \"Hello" + std::to_string(i) + "\"\n}\n";
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
expected_response_text.c_str()));
|
|
|
|
}
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandBidiStream) {
|
|
|
|
// Test input: grpc_cli call localhost:<port> BidiStream "message: 'Hello0'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"BidiStream", "message: 'Hello0'"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss("message: 'Hello1'\n\n message: 'Hello2'\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: \"Hello0\"\nmessage: \"Hello1\"\nmessage:
|
|
|
|
// \"Hello2\"\n\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0\"\nmessage: "
|
|
|
|
"\"Hello1\"\nmessage: \"Hello2\"\n"));
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandBidiStreamWithBadRequest) {
|
|
|
|
// Test input: grpc_cli call localhost:<port> BidiStream "message: 'Hello0'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"BidiStream", "message: 'Hello0'"};
|
|
|
|
|
|
|
|
// Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
|
|
|
|
std::streambuf* orig = std::cin.rdbuf();
|
|
|
|
std::istringstream ss("message: 1.0\n\n message: 'Hello2'\n\n");
|
|
|
|
std::cin.rdbuf(ss.rdbuf());
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: "message: \"Hello0\"\nmessage: \"Hello1\"\nmessage:
|
|
|
|
// \"Hello2\"\n\n"
|
|
|
|
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
|
|
|
|
"message: \"Hello0\"\nmessage: \"Hello2\"\n"));
|
|
|
|
std::cin.rdbuf(orig);
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, ParseCommand) {
|
|
|
|
// Test input "grpc_cli parse localhost:<port> grpc.testing.EchoResponse
|
|
|
|
// ECHO_RESPONSE_MESSAGE"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
std::stringstream binary_output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "parse", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoResponse",
|
|
|
|
ECHO_RESPONSE_MESSAGE_TEXT_FORMAT};
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_binary_input, false);
|
|
|
|
absl::SetFlag(&FLAGS_binary_output, false);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: ECHO_RESPONSE_MESSAGE_TEXT_FORMAT
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
|
|
|
|
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
|
|
|
|
// Expected output: ECHO_RESPONSE_MESSAGE_JSON_FORMAT
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
ECHO_RESPONSE_MESSAGE_JSON_FORMAT));
|
|
|
|
|
|
|
|
// Parse text message to binary message and then parse it back to text message
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
absl::SetFlag(&FLAGS_binary_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
std::string binary_data = output_stream.str();
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
argv[4] = binary_data.c_str();
|
|
|
|
absl::SetFlag(&FLAGS_binary_input, true);
|
|
|
|
absl::SetFlag(&FLAGS_binary_output, false);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(5, argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: ECHO_RESPONSE_MESSAGE
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_binary_input, false);
|
|
|
|
absl::SetFlag(&FLAGS_binary_output, false);
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, ParseCommandJsonFormat) {
|
|
|
|
// Test input "grpc_cli parse localhost:<port> grpc.testing.EchoResponse
|
|
|
|
// ECHO_RESPONSE_MESSAGE_JSON_FORMAT"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
std::stringstream binary_output_stream;
|
|
|
|
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "parse", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoResponse",
|
|
|
|
ECHO_RESPONSE_MESSAGE_JSON_FORMAT};
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_input, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
|
|
|
|
// Expected output: ECHO_RESPONSE_MESSAGE_TEXT_FORMAT
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
|
|
|
|
|
|
|
|
// with json_output
|
|
|
|
output_stream.str(std::string());
|
|
|
|
output_stream.clear();
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_json_output, true);
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_json_output, false);
|
|
|
|
absl::SetFlag(&FLAGS_json_input, false);
|
|
|
|
|
|
|
|
// Expected output: ECHO_RESPONSE_MESSAGE_JSON_FORMAT
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
ECHO_RESPONSE_MESSAGE_JSON_FORMAT));
|
|
|
|
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, TooFewArguments) {
|
|
|
|
// Test input "grpc_cli call Echo"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const char* argv[] = {"grpc_cli", "call", "Echo"};
|
|
|
|
|
|
|
|
// Exit with 1
|
|
|
|
EXPECT_EXIT(
|
|
|
|
GrpcToolMainLib(
|
|
|
|
ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream, std::placeholders::_1)),
|
|
|
|
::testing::ExitedWithCode(1), ".*Wrong number of arguments for call.*");
|
|
|
|
// No output
|
|
|
|
EXPECT_TRUE(0 == output_stream.tellp());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, TooManyArguments) {
|
|
|
|
// Test input "grpc_cli call localhost:<port> Echo Echo "message: 'Hello'"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const char* argv[] = {"grpc_cli", "call", "localhost:10000",
|
|
|
|
"Echo", "Echo", "message: 'Hello'"};
|
|
|
|
|
|
|
|
// Exit with 1
|
|
|
|
EXPECT_EXIT(
|
|
|
|
GrpcToolMainLib(
|
|
|
|
ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream, std::placeholders::_1)),
|
|
|
|
::testing::ExitedWithCode(1), ".*Wrong number of arguments for call.*");
|
|
|
|
// No output
|
|
|
|
EXPECT_TRUE(0 == output_stream.tellp());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandWithMetadata) {
|
|
|
|
// Test input "grpc_cli call localhost:<port> Echo "message: 'Hello'"
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
|
|
|
|
"message: 'Hello'"};
|
|
|
|
|
|
|
|
{
|
|
|
|
std::stringstream output_stream;
|
|
|
|
absl::SetFlag(&FLAGS_metadata, "key0:val0:key1:valq:key2:val2");
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv,
|
|
|
|
TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
std::stringstream output_stream;
|
|
|
|
absl::SetFlag(&FLAGS_metadata, "key:val\\:val");
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv,
|
|
|
|
TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
std::stringstream output_stream;
|
|
|
|
absl::SetFlag(&FLAGS_metadata, "key:val\\\\val");
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv,
|
|
|
|
TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
}
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_metadata, "");
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallCommandWithBadMetadata) {
|
|
|
|
// Test input "grpc_cli call localhost:10000 Echo "message: 'Hello'"
|
|
|
|
const char* argv[] = {"grpc_cli", "call", "localhost:10000",
|
|
|
|
"grpc.testing.EchoTestService.Echo",
|
|
|
|
"message: 'Hello'"};
|
|
|
|
absl::SetFlag(&FLAGS_protofiles, "src/proto/grpc/testing/echo.proto");
|
|
|
|
auto test_srcdir = grpc_core::GetEnv("TEST_SRCDIR");
|
|
|
|
if (test_srcdir.has_value()) {
|
|
|
|
absl::SetFlag(&FLAGS_proto_path,
|
|
|
|
*test_srcdir + std::string("/com_github_grpc_grpc"));
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
std::stringstream output_stream;
|
|
|
|
absl::SetFlag(&FLAGS_metadata, "key0:val0:key1");
|
|
|
|
// Exit with 1
|
|
|
|
EXPECT_EXIT(
|
|
|
|
GrpcToolMainLib(
|
|
|
|
ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream, std::placeholders::_1)),
|
|
|
|
::testing::ExitedWithCode(1), ".*Failed to parse metadata flag.*");
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
std::stringstream output_stream;
|
|
|
|
absl::SetFlag(&FLAGS_metadata, "key:val\\val");
|
|
|
|
// Exit with 1
|
|
|
|
EXPECT_EXIT(
|
|
|
|
GrpcToolMainLib(
|
|
|
|
ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream, std::placeholders::_1)),
|
|
|
|
::testing::ExitedWithCode(1), ".*Failed to parse metadata flag.*");
|
|
|
|
}
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_metadata, "");
|
|
|
|
absl::SetFlag(&FLAGS_protofiles, "");
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallMaxRecvMessageSizeSmall) {
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
// Test input "grpc_cli call localhost:10000 Echo "message: 'Hello'
|
|
|
|
// --max_recv_msg_size=4"
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoTestService.Echo",
|
|
|
|
"message: 'Hello'"};
|
|
|
|
|
|
|
|
// Set max_recv_msg_size to 4 which is not enough.
|
|
|
|
absl::SetFlag(&FLAGS_max_recv_msg_size, 4);
|
|
|
|
|
|
|
|
// This should fail.
|
|
|
|
EXPECT_FALSE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// No output expected.
|
|
|
|
EXPECT_TRUE(0 == output_stream.tellp());
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallMaxRecvMessageSizeEnough) {
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
// Test input "grpc_cli call localhost:10000 Echo "message: 'Hello'
|
|
|
|
// --max_recv_msg_size=1048576"
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoTestService.Echo",
|
|
|
|
"message: 'Hello'"};
|
|
|
|
|
|
|
|
// Set max_recv_msg_size to a large enough number.
|
|
|
|
absl::SetFlag(&FLAGS_max_recv_msg_size, 1024 * 1024);
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallMaxRecvMessageSizeDefault) {
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
// Test input "grpc_cli call localhost:10000 Echo "message: 'Hello'
|
|
|
|
// --max_recv_msg_size=0"
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoTestService.Echo",
|
|
|
|
"message: 'Hello'"};
|
|
|
|
|
|
|
|
// Set max_recv_msg_size to gRPC default, which should suffice.
|
|
|
|
absl::SetFlag(&FLAGS_max_recv_msg_size, 0);
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, CallMaxRecvMessageSizeUnlimited) {
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
// Test input "grpc_cli call localhost:10000 Echo "message: 'Hello'
|
|
|
|
// --max_recv_msg_size=-1"
|
|
|
|
const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
|
|
|
|
"grpc.testing.EchoTestService.Echo",
|
|
|
|
"message: 'Hello'"};
|
|
|
|
|
|
|
|
// Set max_recv_msg_size to unlimited (-1), which should work.
|
|
|
|
absl::SetFlag(&FLAGS_max_recv_msg_size, -1);
|
|
|
|
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
// Expected output: "message: \"Hello\""
|
|
|
|
EXPECT_TRUE(nullptr !=
|
|
|
|
strstr(output_stream.str().c_str(), "message: \"Hello\""));
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, ListCommandOverrideSslHostName) {
|
|
|
|
const std::string server_address = SetUpServer(true);
|
|
|
|
|
|
|
|
// Test input "grpc_cli ls localhost:<port> --channel_creds_type=ssl
|
|
|
|
// --ssl_target=z.test.google.fr"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const char* argv[] = {"grpc_cli", "ls", server_address.c_str()};
|
|
|
|
absl::SetFlag(&FLAGS_l, false);
|
|
|
|
absl::SetFlag(&FLAGS_channel_creds_type, "ssl");
|
|
|
|
absl::SetFlag(&FLAGS_ssl_target, "z.test.google.fr");
|
|
|
|
EXPECT_TRUE(
|
|
|
|
0 == GrpcToolMainLib(
|
|
|
|
ArraySize(argv), argv, TestCliCredentials(true),
|
|
|
|
std::bind(PrintStream, &output_stream, std::placeholders::_1)));
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
"grpc.testing.EchoTestService\n"
|
|
|
|
"grpc.reflection.v1alpha.ServerReflection\n"));
|
|
|
|
|
|
|
|
absl::SetFlag(&FLAGS_channel_creds_type, "");
|
|
|
|
absl::SetFlag(&FLAGS_ssl_target, "");
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST_F(GrpcToolTest, ConfiguringDefaultServiceConfig) {
|
|
|
|
// Test input "grpc_cli list localhost:<port>
|
|
|
|
// --default_service_config={\"loadBalancingConfig\":[{\"pick_first\":{}}]}"
|
|
|
|
std::stringstream output_stream;
|
|
|
|
const std::string server_address = SetUpServer();
|
|
|
|
const char* argv[] = {"grpc_cli", "ls", server_address.c_str()};
|
|
|
|
// Just check that the tool is still operational when --default_service_config
|
|
|
|
// is configured. This particular service config is in reality redundant with
|
|
|
|
// the channel's default configuration.
|
|
|
|
absl::SetFlag(&FLAGS_l, false);
|
|
|
|
absl::SetFlag(&FLAGS_default_service_config,
|
|
|
|
"{\"loadBalancingConfig\":[{\"pick_first\":{}}]}");
|
|
|
|
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
|
|
|
|
std::bind(PrintStream, &output_stream,
|
|
|
|
std::placeholders::_1)));
|
|
|
|
absl::SetFlag(&FLAGS_default_service_config, "");
|
|
|
|
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
|
|
|
|
"grpc.testing.EchoTestService\n"
|
|
|
|
"grpc.reflection.v1alpha.ServerReflection\n"));
|
|
|
|
ShutdownServer();
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace testing
|
|
|
|
} // namespace grpc
|
|
|
|
|
|
|
|
int main(int argc, char** argv) {
|
|
|
|
grpc::testing::TestEnvironment env(&argc, argv);
|
|
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
|
|
GTEST_FLAG_SET(death_test_style, "threadsafe");
|
|
|
|
return RUN_ALL_TESTS();
|
|
|
|
}
|