test/cpp/util/grpc_tool_test.cc

   1 /*
   2  *
   3  * Copyright 2016 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include "test/cpp/util/grpc_tool.h"
  20
  21 #include <grpc/grpc.h>
  22 #include <grpc/support/alloc.h>
  23 #include <grpcpp/channel.h>
  24 #include <grpcpp/client_context.h>
  25 #include <grpcpp/create_channel.h>
  26 #include <grpcpp/ext/proto_server_reflection_plugin.h>
  27 #include <grpcpp/server.h>
  28 #include <grpcpp/server_builder.h>
  29 #include <grpcpp/server_context.h>
  30 #include <gtest/gtest.h>
  31
  32 #include <chrono>
  33 #include <sstream>
  34
  35 #include "absl/flags/declare.h"
  36 #include "absl/flags/flag.h"
  37 #include "src/core/lib/gpr/env.h"
  38 #include "src/core/lib/iomgr/load_file.h"
  39 #include "src/proto/grpc/testing/echo.grpc.pb.h"
  40 #include "src/proto/grpc/testing/echo.pb.h"
  41 #include "test/core/util/port.h"
  42 #include "test/core/util/test_config.h"
  43 #include "test/cpp/util/cli_credentials.h"
  44 #include "test/cpp/util/string_ref_helper.h"
  45
  46 #define CA_CERT_PATH "src/core/tsi/test_creds/ca.pem"
  47 #define SERVER_CERT_PATH "src/core/tsi/test_creds/server1.pem"
  48 #define SERVER_KEY_PATH "src/core/tsi/test_creds/server1.key"
  49
  50 using grpc::testing::EchoRequest;
  51 using grpc::testing::EchoResponse;
  52
  53 #define USAGE_REGEX "(  grpc_cli .+\n){2,10}"
  54
  55 #define ECHO_TEST_SERVICE_SUMMARY \
  56   "Echo\n"                        \
  57   "Echo1\n"                       \
  58   "Echo2\n"                       \
  59   "CheckDeadlineUpperBound\n"     \
  60   "CheckDeadlineSet\n"            \
  61   "CheckClientInitialMetadata\n"  \
  62   "RequestStream\n"               \
  63   "ResponseStream\n"              \
  64   "BidiStream\n"                  \
  65   "Unimplemented\n"               \
  66   "UnimplementedBidi\n"
  67
  68 #define ECHO_TEST_SERVICE_DESCRIPTION                                          \
  69   "filename: src/proto/grpc/testing/echo.proto\n"                              \
  70   "package: grpc.testing;\n"                                                   \
  71   "service EchoTestService {\n"                                                \
  72   "  rpc Echo(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) "  \
  73   "{}\n"                                                                       \
  74   "  rpc Echo1(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
  75   "{}\n"                                                                       \
  76   "  rpc Echo2(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
  77   "{}\n"                                                                       \
  78   "  rpc CheckDeadlineUpperBound(grpc.testing.SimpleRequest) returns "         \
  79   "(grpc.testing.StringValue) {}\n"                                            \
  80   "  rpc CheckDeadlineSet(grpc.testing.SimpleRequest) returns "                \
  81   "(grpc.testing.StringValue) {}\n"                                            \
  82   "  rpc CheckClientInitialMetadata(grpc.testing.SimpleRequest) returns "      \
  83   "(grpc.testing.SimpleResponse) {}\n"                                         \
  84   "  rpc RequestStream(stream grpc.testing.EchoRequest) returns "              \
  85   "(grpc.testing.EchoResponse) {}\n"                                           \
  86   "  rpc ResponseStream(grpc.testing.EchoRequest) returns (stream "            \
  87   "grpc.testing.EchoResponse) {}\n"                                            \
  88   "  rpc BidiStream(stream grpc.testing.EchoRequest) returns (stream "         \
  89   "grpc.testing.EchoResponse) {}\n"                                            \
  90   "  rpc Unimplemented(grpc.testing.EchoRequest) returns "                     \
  91   "(grpc.testing.EchoResponse) {}\n"                                           \
  92   "  rpc UnimplementedBidi(stream grpc.testing.EchoRequest) returns (stream "  \
  93   "grpc.testing.EchoResponse) {}\n"                                            \
  94   "}\n"                                                                        \
  95   "\n"
  96
  97 #define ECHO_METHOD_DESCRIPTION                                               \
  98   "  rpc Echo(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
  99   "{}\n"
 100
 101 #define ECHO_RESPONSE_MESSAGE_TEXT_FORMAT \
 102   "message: \"echo\"\n"                   \
 103   "param {\n"                             \
 104   "  host: \"localhost\"\n"               \
 105   "  peer: \"peer\"\n"                    \
 106   "}\n\n"
 107
 108 #define ECHO_RESPONSE_MESSAGE_JSON_FORMAT \
 109   "{\n"                                   \
 110   " \"message\": \"echo\",\n"             \
 111   " \"param\": {\n"                       \
 112   "  \"host\": \"localhost\",\n"          \
 113   "  \"peer\": \"peer\"\n"                \
 114   " }\n"                                  \
 115   "}\n\n"
 116
 117 ABSL_DECLARE_FLAG(std::string, channel_creds_type);
 118 ABSL_DECLARE_FLAG(std::string, ssl_target);
 119 ABSL_DECLARE_FLAG(bool, binary_input);
 120 ABSL_DECLARE_FLAG(bool, binary_output);
 121 ABSL_DECLARE_FLAG(bool, json_input);
 122 ABSL_DECLARE_FLAG(bool, json_output);
 123 ABSL_DECLARE_FLAG(bool, l);
 124 ABSL_DECLARE_FLAG(bool, batch);
 125 ABSL_DECLARE_FLAG(std::string, metadata);
 126 ABSL_DECLARE_FLAG(std::string, protofiles);
 127 ABSL_DECLARE_FLAG(std::string, proto_path);
 128 ABSL_DECLARE_FLAG(std::string, default_service_config);
 129 ABSL_DECLARE_FLAG(double, timeout);
 130
 131 namespace grpc {
 132 namespace testing {
 133 namespace {
 134
 135 const int kServerDefaultResponseStreamsToSend = 3;
 136
 137 class TestCliCredentials final : public grpc::testing::CliCredentials {
 138  public:
 139   explicit TestCliCredentials(bool secure = false) : secure_(secure) {}
 140   std::shared_ptr<grpc::ChannelCredentials> GetChannelCredentials()
 141       const override {
 142     if (!secure_) {
 143       return InsecureChannelCredentials();
 144     }
 145     grpc_slice ca_slice;
 146     GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
 147                                  grpc_load_file(CA_CERT_PATH, 1, &ca_slice)));
 148     const char* test_root_cert =
 149         reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
 150     SslCredentialsOptions ssl_opts = {test_root_cert, "", ""};
 151     std::shared_ptr<grpc::ChannelCredentials> credential_ptr =
 152         grpc::SslCredentials(grpc::SslCredentialsOptions(ssl_opts));
 153     grpc_slice_unref(ca_slice);
 154     return credential_ptr;
 155   }
 156   std::string GetCredentialUsage() const override { return ""; }
 157
 158  private:
 159   const bool secure_;
 160 };
 161
 162 bool PrintStream(std::stringstream* ss, const std::string& output) {
 163   (*ss) << output;
 164   return true;
 165 }
 166
 167 template <typename T>
 168 size_t ArraySize(T& a) {
 169   return ((sizeof(a) / sizeof(*(a))) /
 170           static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))));
 171 }
 172
 173 class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
 174  public:
 175   Status Echo(ServerContext* context, const EchoRequest* request,
 176               EchoResponse* response) override {
 177     if (!context->client_metadata().empty()) {
 178       for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
 179                iter = context->client_metadata().begin();
 180            iter != context->client_metadata().end(); ++iter) {
 181         context->AddInitialMetadata(ToString(iter->first),
 182                                     ToString(iter->second));
 183       }
 184     }
 185     context->AddTrailingMetadata("trailing_key", "trailing_value");
 186     response->set_message(request->message());
 187     return Status::OK;
 188   }
 189
 190   Status CheckDeadlineSet(ServerContext* context,
 191                           const SimpleRequest* /*request*/,
 192                           StringValue* response) override {
 193     response->set_message(context->deadline() !=
 194                                   std::chrono::system_clock::time_point::max()
 195                               ? "true"
 196                               : "false");
 197     return Status::OK;
 198   }
 199
 200   // Check if deadline - current time <= timeout
 201   // If deadline set, timeout + current time should be an upper bound for it
 202   Status CheckDeadlineUpperBound(ServerContext* context,
 203                                  const SimpleRequest* /*request*/,
 204                                  StringValue* response) override {
 205     auto seconds = std::chrono::duration_cast<std::chrono::seconds>(
 206         context->deadline() - std::chrono::system_clock::now());
 207
 208     // Returning string instead of bool to avoid using embedded messages in
 209     // proto3
 210     response->set_message(
 211         seconds.count() <= absl::GetFlag(FLAGS_timeout) ? "true" : "false");
 212     return Status::OK;
 213   }
 214
 215   Status RequestStream(ServerContext* context,
 216                        ServerReader<EchoRequest>* reader,
 217                        EchoResponse* response) override {
 218     EchoRequest request;
 219     response->set_message("");
 220     if (!context->client_metadata().empty()) {
 221       for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
 222                iter = context->client_metadata().begin();
 223            iter != context->client_metadata().end(); ++iter) {
 224         context->AddInitialMetadata(ToString(iter->first),
 225                                     ToString(iter->second));
 226       }
 227     }
 228     context->AddTrailingMetadata("trailing_key", "trailing_value");
 229     while (reader->Read(&request)) {
 230       response->mutable_message()->append(request.message());
 231     }
 232
 233     return Status::OK;
 234   }
 235
 236   Status ResponseStream(ServerContext* context, const EchoRequest* request,
 237                         ServerWriter<EchoResponse>* writer) override {
 238     if (!context->client_metadata().empty()) {
 239       for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
 240                iter = context->client_metadata().begin();
 241            iter != context->client_metadata().end(); ++iter) {
 242         context->AddInitialMetadata(ToString(iter->first),
 243                                     ToString(iter->second));
 244       }
 245     }
 246     context->AddTrailingMetadata("trailing_key", "trailing_value");
 247
 248     EchoResponse response;
 249     for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
 250       response.set_message(request->message() + std::to_string(i));
 251       writer->Write(response);
 252     }
 253
 254     return Status::OK;
 255   }
 256
 257   Status BidiStream(
 258       ServerContext* context,
 259       ServerReaderWriter<EchoResponse, EchoRequest>* stream) override {
 260     EchoRequest request;
 261     EchoResponse response;
 262     if (!context->client_metadata().empty()) {
 263       for (std::multimap<grpc::string_ref, grpc::string_ref>::const_iterator
 264                iter = context->client_metadata().begin();
 265            iter != context->client_metadata().end(); ++iter) {
 266         context->AddInitialMetadata(ToString(iter->first),
 267                                     ToString(iter->second));
 268       }
 269     }
 270     context->AddTrailingMetadata("trailing_key", "trailing_value");
 271
 272     while (stream->Read(&request)) {
 273       response.set_message(request.message());
 274       stream->Write(response);
 275     }
 276
 277     return Status::OK;
 278   }
 279 };
 280
 281 }  // namespace
 282
 283 class GrpcToolTest : public ::testing::Test {
 284  protected:
 285   GrpcToolTest() {}
 286
 287   // SetUpServer cannot be used with EXPECT_EXIT. grpc_pick_unused_port_or_die()
 288   // uses atexit() to free chosen ports, and it will spawn a new thread in
 289   // resolve_address_posix.c:192 at exit time.
 290   std::string SetUpServer(bool secure = false) {
 291     std::ostringstream server_address;
 292     int port = grpc_pick_unused_port_or_die();
 293     server_address << "localhost:" << port;
 294     // Setup server
 295     ServerBuilder builder;
 296     std::shared_ptr<grpc::ServerCredentials> creds;
 297     grpc_slice cert_slice, key_slice;
 298     GPR_ASSERT(GRPC_LOG_IF_ERROR(
 299         "load_file", grpc_load_file(SERVER_CERT_PATH, 1, &cert_slice)));
 300     GPR_ASSERT(GRPC_LOG_IF_ERROR(
 301         "load_file", grpc_load_file(SERVER_KEY_PATH, 1, &key_slice)));
 302     const char* server_cert =
 303         reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
 304     const char* server_key =
 305         reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
 306     SslServerCredentialsOptions::PemKeyCertPair pkcp = {server_key,
 307                                                         server_cert};
 308     if (secure) {
 309       SslServerCredentialsOptions ssl_opts;
 310       ssl_opts.pem_root_certs = "";
 311       ssl_opts.pem_key_cert_pairs.push_back(pkcp);
 312       creds = SslServerCredentials(ssl_opts);
 313     } else {
 314       creds = InsecureServerCredentials();
 315     }
 316     builder.AddListeningPort(server_address.str(), creds);
 317     builder.RegisterService(&service_);
 318     server_ = builder.BuildAndStart();
 319     grpc_slice_unref(cert_slice);
 320     grpc_slice_unref(key_slice);
 321     return server_address.str();
 322   }
 323
 324   void ShutdownServer() { server_->Shutdown(); }
 325
 326   std::unique_ptr<Server> server_;
 327   TestServiceImpl service_;
 328   reflection::ProtoServerReflectionPlugin plugin_;
 329 };
 330
 331 TEST_F(GrpcToolTest, NoCommand) {
 332   // Test input "grpc_cli"
 333   std::stringstream output_stream;
 334   const char* argv[] = {"grpc_cli"};
 335   // Exit with 1, print usage instruction in stderr
 336   EXPECT_EXIT(
 337       GrpcToolMainLib(
 338           ArraySize(argv), argv, TestCliCredentials(),
 339           std::bind(PrintStream, &output_stream, std::placeholders::_1)),
 340       ::testing::ExitedWithCode(1), "No command specified\n" USAGE_REGEX);
 341   // No output
 342   EXPECT_TRUE(0 == output_stream.tellp());
 343 }
 344
 345 TEST_F(GrpcToolTest, InvalidCommand) {
 346   // Test input "grpc_cli"
 347   std::stringstream output_stream;
 348   const char* argv[] = {"grpc_cli", "abc"};
 349   // Exit with 1, print usage instruction in stderr
 350   EXPECT_EXIT(
 351       GrpcToolMainLib(
 352           ArraySize(argv), argv, TestCliCredentials(),
 353           std::bind(PrintStream, &output_stream, std::placeholders::_1)),
 354       ::testing::ExitedWithCode(1), "Invalid command 'abc'\n" USAGE_REGEX);
 355   // No output
 356   EXPECT_TRUE(0 == output_stream.tellp());
 357 }
 358
 359 TEST_F(GrpcToolTest, HelpCommand) {
 360   // Test input "grpc_cli help"
 361   std::stringstream output_stream;
 362   const char* argv[] = {"grpc_cli", "help"};
 363   // Exit with 1, print usage instruction in stderr
 364   EXPECT_EXIT(GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 365                               std::bind(PrintStream, &output_stream,
 366                                         std::placeholders::_1)),
 367               ::testing::ExitedWithCode(1), USAGE_REGEX);
 368   // No output
 369   EXPECT_TRUE(0 == output_stream.tellp());
 370 }
 371
 372 TEST_F(GrpcToolTest, ListCommand) {
 373   // Test input "grpc_cli list localhost:<port>"
 374   std::stringstream output_stream;
 375
 376   const std::string server_address = SetUpServer();
 377   const char* argv[] = {"grpc_cli", "ls", server_address.c_str()};
 378
 379   absl::SetFlag(&FLAGS_l, false);
 380   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 381                                    std::bind(PrintStream, &output_stream,
 382                                              std::placeholders::_1)));
 383   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
 384                           "grpc.testing.EchoTestService\n"
 385                           "grpc.reflection.v1alpha.ServerReflection\n"));
 386
 387   ShutdownServer();
 388 }
 389
 390 TEST_F(GrpcToolTest, ListOneService) {
 391   // Test input "grpc_cli list localhost:<port> grpc.testing.EchoTestService"
 392   std::stringstream output_stream;
 393
 394   const std::string server_address = SetUpServer();
 395   const char* argv[] = {"grpc_cli", "ls", server_address.c_str(),
 396                         "grpc.testing.EchoTestService"};
 397   // without -l flag
 398   absl::SetFlag(&FLAGS_l, false);
 399   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 400                                    std::bind(PrintStream, &output_stream,
 401                                              std::placeholders::_1)));
 402   // Expected output: ECHO_TEST_SERVICE_SUMMARY
 403   EXPECT_TRUE(0 ==
 404               strcmp(output_stream.str().c_str(), ECHO_TEST_SERVICE_SUMMARY));
 405
 406   // with -l flag
 407   output_stream.str(std::string());
 408   output_stream.clear();
 409   absl::SetFlag(&FLAGS_l, true);
 410   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 411                                    std::bind(PrintStream, &output_stream,
 412                                              std::placeholders::_1)));
 413   // Expected output: ECHO_TEST_SERVICE_DESCRIPTION
 414   EXPECT_TRUE(
 415       0 == strcmp(output_stream.str().c_str(), ECHO_TEST_SERVICE_DESCRIPTION));
 416
 417   ShutdownServer();
 418 }
 419
 420 TEST_F(GrpcToolTest, TypeCommand) {
 421   // Test input "grpc_cli type localhost:<port> grpc.testing.EchoRequest"
 422   std::stringstream output_stream;
 423
 424   const std::string server_address = SetUpServer();
 425   const char* argv[] = {"grpc_cli", "type", server_address.c_str(),
 426                         "grpc.testing.EchoRequest"};
 427
 428   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 429                                    std::bind(PrintStream, &output_stream,
 430                                              std::placeholders::_1)));
 431   const grpc::protobuf::Descriptor* desc =
 432       grpc::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName(
 433           "grpc.testing.EchoRequest");
 434   // Expected output: the DebugString of grpc.testing.EchoRequest
 435   EXPECT_TRUE(0 ==
 436               strcmp(output_stream.str().c_str(), desc->DebugString().c_str()));
 437
 438   ShutdownServer();
 439 }
 440
 441 TEST_F(GrpcToolTest, ListOneMethod) {
 442   // Test input "grpc_cli list localhost:<port> grpc.testing.EchoTestService"
 443   std::stringstream output_stream;
 444
 445   const std::string server_address = SetUpServer();
 446   const char* argv[] = {"grpc_cli", "ls", server_address.c_str(),
 447                         "grpc.testing.EchoTestService.Echo"};
 448   // without -l flag
 449   absl::SetFlag(&FLAGS_l, false);
 450   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 451                                    std::bind(PrintStream, &output_stream,
 452                                              std::placeholders::_1)));
 453   // Expected output: "Echo"
 454   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(), "Echo\n"));
 455
 456   // with -l flag
 457   output_stream.str(std::string());
 458   output_stream.clear();
 459   absl::SetFlag(&FLAGS_l, true);
 460   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 461                                    std::bind(PrintStream, &output_stream,
 462                                              std::placeholders::_1)));
 463   // Expected output: ECHO_METHOD_DESCRIPTION
 464   EXPECT_TRUE(0 ==
 465               strcmp(output_stream.str().c_str(), ECHO_METHOD_DESCRIPTION));
 466
 467   ShutdownServer();
 468 }
 469
 470 TEST_F(GrpcToolTest, TypeNotFound) {
 471   // Test input "grpc_cli type localhost:<port> grpc.testing.PhonyRequest"
 472   std::stringstream output_stream;
 473
 474   const std::string server_address = SetUpServer();
 475   const char* argv[] = {"grpc_cli", "type", server_address.c_str(),
 476                         "grpc.testing.PhonyRequest"};
 477
 478   EXPECT_TRUE(1 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 479                                    std::bind(PrintStream, &output_stream,
 480                                              std::placeholders::_1)));
 481   ShutdownServer();
 482 }
 483
 484 TEST_F(GrpcToolTest, CallCommand) {
 485   // Test input "grpc_cli call localhost:<port> Echo "message: 'Hello'"
 486   std::stringstream output_stream;
 487
 488   const std::string server_address = SetUpServer();
 489   const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
 490                         "message: 'Hello'"};
 491
 492   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 493                                    std::bind(PrintStream, &output_stream,
 494                                              std::placeholders::_1)));
 495   // Expected output: "message: \"Hello\""
 496   EXPECT_TRUE(nullptr !=
 497               strstr(output_stream.str().c_str(), "message: \"Hello\""));
 498
 499   // with json_output
 500   output_stream.str(std::string());
 501   output_stream.clear();
 502
 503   // TODO(Capstan): Consider using absl::FlagSaver
 504   absl::SetFlag(&FLAGS_json_output, true);
 505   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 506                                    std::bind(PrintStream, &output_stream,
 507                                              std::placeholders::_1)));
 508   absl::SetFlag(&FLAGS_json_output, false);
 509
 510   // Expected output:
 511   // {
 512   //  "message": "Hello"
 513   // }
 514   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 515                                 "{\n \"message\": \"Hello\"\n}"));
 516
 517   ShutdownServer();
 518 }
 519
 520 TEST_F(GrpcToolTest, CallCommandJsonInput) {
 521   // Test input "grpc_cli call localhost:<port> Echo "{ \"message\": \"Hello\"}"
 522   std::stringstream output_stream;
 523
 524   const std::string server_address = SetUpServer();
 525   const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
 526                         "{ \"message\": \"Hello\"}"};
 527
 528   absl::SetFlag(&FLAGS_json_input, true);
 529   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 530                                    std::bind(PrintStream, &output_stream,
 531                                              std::placeholders::_1)));
 532   // Expected output: "message: \"Hello\""
 533   EXPECT_TRUE(nullptr !=
 534               strstr(output_stream.str().c_str(), "message: \"Hello\""));
 535
 536   // with json_output
 537   output_stream.str(std::string());
 538   output_stream.clear();
 539
 540   absl::SetFlag(&FLAGS_json_output, true);
 541   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 542                                    std::bind(PrintStream, &output_stream,
 543                                              std::placeholders::_1)));
 544   absl::SetFlag(&FLAGS_json_output, false);
 545   absl::SetFlag(&FLAGS_json_input, false);
 546
 547   // Expected output:
 548   // {
 549   //  "message": "Hello"
 550   // }
 551   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 552                                 "{\n \"message\": \"Hello\"\n}"));
 553
 554   ShutdownServer();
 555 }
 556
 557 TEST_F(GrpcToolTest, CallCommandBatch) {
 558   // Test input "grpc_cli call Echo"
 559   std::stringstream output_stream;
 560
 561   const std::string server_address = SetUpServer();
 562   const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
 563                         "message: 'Hello0'"};
 564
 565   // Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
 566   std::streambuf* orig = std::cin.rdbuf();
 567   std::istringstream ss("message: 'Hello1'\n\n message: 'Hello2'\n\n");
 568   std::cin.rdbuf(ss.rdbuf());
 569
 570   absl::SetFlag(&FLAGS_batch, true);
 571   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 572                                    std::bind(PrintStream, &output_stream,
 573                                              std::placeholders::_1)));
 574   absl::SetFlag(&FLAGS_batch, false);
 575
 576   // Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
 577   // "Hello2"\n"
 578   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 579                                 "message: \"Hello0\"\nmessage: "
 580                                 "\"Hello1\"\nmessage: \"Hello2\"\n"));
 581   // with json_output
 582   output_stream.str(std::string());
 583   output_stream.clear();
 584   ss.clear();
 585   ss.seekg(0);
 586   std::cin.rdbuf(ss.rdbuf());
 587
 588   absl::SetFlag(&FLAGS_batch, true);
 589   absl::SetFlag(&FLAGS_json_output, true);
 590   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 591                                    std::bind(PrintStream, &output_stream,
 592                                              std::placeholders::_1)));
 593   absl::SetFlag(&FLAGS_json_output, false);
 594   absl::SetFlag(&FLAGS_batch, false);
 595
 596   // Expected output:
 597   // {
 598   //  "message": "Hello0"
 599   // }
 600   // {
 601   //  "message": "Hello1"
 602   // }
 603   // {
 604   //  "message": "Hello2"
 605   // }
 606   // Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
 607   // "Hello2"\n"
 608   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 609                                 "{\n \"message\": \"Hello0\"\n}\n"
 610                                 "{\n \"message\": \"Hello1\"\n}\n"
 611                                 "{\n \"message\": \"Hello2\"\n}\n"));
 612
 613   std::cin.rdbuf(orig);
 614   ShutdownServer();
 615 }
 616
 617 TEST_F(GrpcToolTest, CallCommandBatchJsonInput) {
 618   // Test input "grpc_cli call Echo"
 619   std::stringstream output_stream;
 620
 621   const std::string server_address = SetUpServer();
 622   const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
 623                         "{\"message\": \"Hello0\"}"};
 624
 625   // Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
 626   std::streambuf* orig = std::cin.rdbuf();
 627   std::istringstream ss(
 628       "{\"message\": \"Hello1\"}\n\n{\"message\": \"Hello2\" }\n\n");
 629   std::cin.rdbuf(ss.rdbuf());
 630
 631   absl::SetFlag(&FLAGS_json_input, true);
 632   absl::SetFlag(&FLAGS_batch, true);
 633   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 634                                    std::bind(PrintStream, &output_stream,
 635                                              std::placeholders::_1)));
 636   absl::SetFlag(&FLAGS_batch, false);
 637
 638   // Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
 639   // "Hello2"\n"
 640   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 641                                 "message: \"Hello0\"\nmessage: "
 642                                 "\"Hello1\"\nmessage: \"Hello2\"\n"));
 643   // with json_output
 644   output_stream.str(std::string());
 645   output_stream.clear();
 646   ss.clear();
 647   ss.seekg(0);
 648   std::cin.rdbuf(ss.rdbuf());
 649
 650   absl::SetFlag(&FLAGS_batch, true);
 651   absl::SetFlag(&FLAGS_json_output, true);
 652   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 653                                    std::bind(PrintStream, &output_stream,
 654                                              std::placeholders::_1)));
 655   absl::SetFlag(&FLAGS_json_output, false);
 656   absl::SetFlag(&FLAGS_batch, false);
 657   absl::SetFlag(&FLAGS_json_input, false);
 658
 659   // Expected output:
 660   // {
 661   //  "message": "Hello0"
 662   // }
 663   // {
 664   //  "message": "Hello1"
 665   // }
 666   // {
 667   //  "message": "Hello2"
 668   // }
 669   // Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
 670   // "Hello2"\n"
 671   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 672                                 "{\n \"message\": \"Hello0\"\n}\n"
 673                                 "{\n \"message\": \"Hello1\"\n}\n"
 674                                 "{\n \"message\": \"Hello2\"\n}\n"));
 675
 676   std::cin.rdbuf(orig);
 677   ShutdownServer();
 678 }
 679
 680 TEST_F(GrpcToolTest, CallCommandBatchWithBadRequest) {
 681   // Test input "grpc_cli call Echo"
 682   std::stringstream output_stream;
 683
 684   const std::string server_address = SetUpServer();
 685   const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
 686                         "message: 'Hello0'"};
 687
 688   // Mock std::cin input "message: 1\n\n message: 'Hello2'\n\n"
 689   std::streambuf* orig = std::cin.rdbuf();
 690   std::istringstream ss("message: 1\n\n message: 'Hello2'\n\n");
 691   std::cin.rdbuf(ss.rdbuf());
 692
 693   absl::SetFlag(&FLAGS_batch, true);
 694   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 695                                    std::bind(PrintStream, &output_stream,
 696                                              std::placeholders::_1)));
 697   absl::SetFlag(&FLAGS_batch, false);
 698
 699   // Expected output: "message: "Hello0"\nmessage: "Hello2"\n"
 700   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 701                                 "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
 702
 703   // with json_output
 704   output_stream.str(std::string());
 705   output_stream.clear();
 706   ss.clear();
 707   ss.seekg(0);
 708   std::cin.rdbuf(ss.rdbuf());
 709
 710   absl::SetFlag(&FLAGS_batch, true);
 711   absl::SetFlag(&FLAGS_json_output, true);
 712   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 713                                    std::bind(PrintStream, &output_stream,
 714                                              std::placeholders::_1)));
 715   absl::SetFlag(&FLAGS_json_output, false);
 716   absl::SetFlag(&FLAGS_batch, false);
 717
 718   // Expected output:
 719   // {
 720   //  "message": "Hello0"
 721   // }
 722   // {
 723   //  "message": "Hello2"
 724   // }
 725   // Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
 726   // "Hello2"\n"
 727   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 728                                 "{\n \"message\": \"Hello0\"\n}\n"
 729                                 "{\n \"message\": \"Hello2\"\n}\n"));
 730
 731   std::cin.rdbuf(orig);
 732   ShutdownServer();
 733 }
 734
 735 TEST_F(GrpcToolTest, CallCommandBatchJsonInputWithBadRequest) {
 736   // Test input "grpc_cli call Echo"
 737   std::stringstream output_stream;
 738
 739   const std::string server_address = SetUpServer();
 740   const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
 741                         "{ \"message\": \"Hello0\"}"};
 742
 743   // Mock std::cin input "message: 1\n\n message: 'Hello2'\n\n"
 744   std::streambuf* orig = std::cin.rdbuf();
 745   std::istringstream ss(
 746       "{ \"message\": 1 }\n\n { \"message\": \"Hello2\" }\n\n");
 747   std::cin.rdbuf(ss.rdbuf());
 748
 749   absl::SetFlag(&FLAGS_batch, true);
 750   absl::SetFlag(&FLAGS_json_input, true);
 751   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 752                                    std::bind(PrintStream, &output_stream,
 753                                              std::placeholders::_1)));
 754   absl::SetFlag(&FLAGS_json_input, false);
 755   absl::SetFlag(&FLAGS_batch, false);
 756
 757   // Expected output: "message: "Hello0"\nmessage: "Hello2"\n"
 758   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 759                                 "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
 760
 761   // with json_output
 762   output_stream.str(std::string());
 763   output_stream.clear();
 764   ss.clear();
 765   ss.seekg(0);
 766   std::cin.rdbuf(ss.rdbuf());
 767
 768   absl::SetFlag(&FLAGS_batch, true);
 769   absl::SetFlag(&FLAGS_json_input, true);
 770   absl::SetFlag(&FLAGS_json_output, true);
 771   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 772                                    std::bind(PrintStream, &output_stream,
 773                                              std::placeholders::_1)));
 774   absl::SetFlag(&FLAGS_json_output, false);
 775   absl::SetFlag(&FLAGS_json_input, false);
 776   absl::SetFlag(&FLAGS_batch, false);
 777
 778   // Expected output:
 779   // {
 780   //  "message": "Hello0"
 781   // }
 782   // {
 783   //  "message": "Hello2"
 784   // }
 785   // Expected output: "message: "Hello0"\nmessage: "Hello1"\nmessage:
 786   // "Hello2"\n"
 787   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 788                                 "{\n \"message\": \"Hello0\"\n}\n"
 789                                 "{\n \"message\": \"Hello2\"\n}\n"));
 790
 791   std::cin.rdbuf(orig);
 792   ShutdownServer();
 793 }
 794
 795 TEST_F(GrpcToolTest, CallCommandRequestStream) {
 796   // Test input: grpc_cli call localhost:<port> RequestStream "message:
 797   // 'Hello0'"
 798   std::stringstream output_stream;
 799
 800   const std::string server_address = SetUpServer();
 801   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 802                         "RequestStream", "message: 'Hello0'"};
 803
 804   // Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
 805   std::streambuf* orig = std::cin.rdbuf();
 806   std::istringstream ss("message: 'Hello1'\n\n message: 'Hello2'\n\n");
 807   std::cin.rdbuf(ss.rdbuf());
 808
 809   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 810                                    std::bind(PrintStream, &output_stream,
 811                                              std::placeholders::_1)));
 812
 813   // Expected output: "message: \"Hello0Hello1Hello2\""
 814   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 815                                 "message: \"Hello0Hello1Hello2\""));
 816   std::cin.rdbuf(orig);
 817   ShutdownServer();
 818 }
 819
 820 TEST_F(GrpcToolTest, CallCommandRequestStreamJsonInput) {
 821   // Test input: grpc_cli call localhost:<port> RequestStream "{ \"message\":
 822   // \"Hello0\"}"
 823   std::stringstream output_stream;
 824
 825   const std::string server_address = SetUpServer();
 826   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 827                         "RequestStream", "{ \"message\": \"Hello0\" }"};
 828
 829   // Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
 830   std::streambuf* orig = std::cin.rdbuf();
 831   std::istringstream ss(
 832       "{ \"message\": \"Hello1\" }\n\n{ \"message\": \"Hello2\" }\n\n");
 833   std::cin.rdbuf(ss.rdbuf());
 834
 835   absl::SetFlag(&FLAGS_json_input, true);
 836   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 837                                    std::bind(PrintStream, &output_stream,
 838                                              std::placeholders::_1)));
 839   absl::SetFlag(&FLAGS_json_input, false);
 840
 841   // Expected output: "message: \"Hello0Hello1Hello2\""
 842   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
 843                                 "message: \"Hello0Hello1Hello2\""));
 844   std::cin.rdbuf(orig);
 845   ShutdownServer();
 846 }
 847
 848 TEST_F(GrpcToolTest, CallCommandRequestStreamWithBadRequest) {
 849   // Test input: grpc_cli call localhost:<port> RequestStream "message:
 850   // 'Hello0'"
 851   std::stringstream output_stream;
 852
 853   const std::string server_address = SetUpServer();
 854   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 855                         "RequestStream", "message: 'Hello0'"};
 856
 857   // Mock std::cin input "bad_field: 'Hello1'\n\n message: 'Hello2'\n\n"
 858   std::streambuf* orig = std::cin.rdbuf();
 859   std::istringstream ss("bad_field: 'Hello1'\n\n message: 'Hello2'\n\n");
 860   std::cin.rdbuf(ss.rdbuf());
 861
 862   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 863                                    std::bind(PrintStream, &output_stream,
 864                                              std::placeholders::_1)));
 865
 866   // Expected output: "message: \"Hello0Hello2\""
 867   EXPECT_TRUE(nullptr !=
 868               strstr(output_stream.str().c_str(), "message: \"Hello0Hello2\""));
 869   std::cin.rdbuf(orig);
 870   ShutdownServer();
 871 }
 872
 873 TEST_F(GrpcToolTest, CallCommandRequestStreamWithBadRequestJsonInput) {
 874   // Test input: grpc_cli call localhost:<port> RequestStream "message:
 875   // 'Hello0'"
 876   std::stringstream output_stream;
 877
 878   const std::string server_address = SetUpServer();
 879   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 880                         "RequestStream", "{ \"message\": \"Hello0\" }"};
 881
 882   // Mock std::cin input "bad_field: 'Hello1'\n\n message: 'Hello2'\n\n"
 883   std::streambuf* orig = std::cin.rdbuf();
 884   std::istringstream ss(
 885       "{ \"bad_field\": \"Hello1\" }\n\n{ \"message\": \"Hello2\" }\n\n");
 886   std::cin.rdbuf(ss.rdbuf());
 887
 888   absl::SetFlag(&FLAGS_json_input, true);
 889   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 890                                    std::bind(PrintStream, &output_stream,
 891                                              std::placeholders::_1)));
 892   absl::SetFlag(&FLAGS_json_input, false);
 893
 894   // Expected output: "message: \"Hello0Hello2\""
 895   EXPECT_TRUE(nullptr !=
 896               strstr(output_stream.str().c_str(), "message: \"Hello0Hello2\""));
 897   std::cin.rdbuf(orig);
 898   ShutdownServer();
 899 }
 900
 901 TEST_F(GrpcToolTest, CallCommandWithTimeoutDeadlineSet) {
 902   // Test input "grpc_cli call CheckDeadlineSet --timeout=5000.25"
 903   std::stringstream output_stream;
 904
 905   const std::string server_address = SetUpServer();
 906   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 907                         "CheckDeadlineSet"};
 908
 909   // Set timeout to 5000.25 seconds
 910   absl::SetFlag(&FLAGS_timeout, 5000.25);
 911
 912   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 913                                    std::bind(PrintStream, &output_stream,
 914                                              std::placeholders::_1)));
 915
 916   // Expected output: "message: "true"", deadline set
 917   EXPECT_TRUE(nullptr !=
 918               strstr(output_stream.str().c_str(), "message: \"true\""));
 919   ShutdownServer();
 920 }
 921
 922 TEST_F(GrpcToolTest, CallCommandWithTimeoutDeadlineUpperBound) {
 923   // Test input "grpc_cli call CheckDeadlineUpperBound --timeout=900"
 924   std::stringstream output_stream;
 925
 926   const std::string server_address = SetUpServer();
 927   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 928                         "CheckDeadlineUpperBound"};
 929
 930   // Set timeout to 900 seconds
 931   absl::SetFlag(&FLAGS_timeout, 900);
 932
 933   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 934                                    std::bind(PrintStream, &output_stream,
 935                                              std::placeholders::_1)));
 936
 937   // Expected output: "message: "true""
 938   // deadline not greater than timeout + current time
 939   EXPECT_TRUE(nullptr !=
 940               strstr(output_stream.str().c_str(), "message: \"true\""));
 941   ShutdownServer();
 942 }
 943
 944 TEST_F(GrpcToolTest, CallCommandWithNegativeTimeoutValue) {
 945   // Test input "grpc_cli call CheckDeadlineSet --timeout=-5"
 946   std::stringstream output_stream;
 947
 948   const std::string server_address = SetUpServer();
 949   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 950                         "CheckDeadlineSet"};
 951
 952   // Set timeout to -5 (deadline not set)
 953   absl::SetFlag(&FLAGS_timeout, -5);
 954
 955   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 956                                    std::bind(PrintStream, &output_stream,
 957                                              std::placeholders::_1)));
 958
 959   // Expected output: "message: "false"", deadline not set
 960   EXPECT_TRUE(nullptr !=
 961               strstr(output_stream.str().c_str(), "message: \"false\""));
 962
 963   ShutdownServer();
 964 }
 965
 966 TEST_F(GrpcToolTest, CallCommandWithDefaultTimeoutValue) {
 967   // Test input "grpc_cli call CheckDeadlineSet --timeout=-1"
 968   std::stringstream output_stream;
 969
 970   const std::string server_address = SetUpServer();
 971   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 972                         "CheckDeadlineSet"};
 973
 974   // Set timeout to -1 (default value, deadline not set)
 975   absl::SetFlag(&FLAGS_timeout, -1);
 976
 977   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 978                                    std::bind(PrintStream, &output_stream,
 979                                              std::placeholders::_1)));
 980
 981   // Expected output: "message: "false"", deadline not set
 982   EXPECT_TRUE(nullptr !=
 983               strstr(output_stream.str().c_str(), "message: \"false\""));
 984
 985   ShutdownServer();
 986 }
 987
 988 TEST_F(GrpcToolTest, CallCommandResponseStream) {
 989   // Test input: grpc_cli call localhost:<port> ResponseStream "message:
 990   // 'Hello'"
 991   std::stringstream output_stream;
 992
 993   const std::string server_address = SetUpServer();
 994   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
 995                         "ResponseStream", "message: 'Hello'"};
 996
 997   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
 998                                    std::bind(PrintStream, &output_stream,
 999                                              std::placeholders::_1)));
1000
1001   // Expected output: "message: \"Hello{n}\""
1002   for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
1003     std::string expected_response_text =
1004         "message: \"Hello" + std::to_string(i) + "\"\n";
1005     EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
1006                                   expected_response_text.c_str()));
1007   }
1008
1009   // with json_output
1010   output_stream.str(std::string());
1011   output_stream.clear();
1012
1013   absl::SetFlag(&FLAGS_json_output, true);
1014   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1015                                    std::bind(PrintStream, &output_stream,
1016                                              std::placeholders::_1)));
1017   absl::SetFlag(&FLAGS_json_output, false);
1018
1019   // Expected output: "{\n \"message\": \"Hello{n}\"\n}\n"
1020   for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
1021     std::string expected_response_text =
1022         "{\n \"message\": \"Hello" + std::to_string(i) + "\"\n}\n";
1023     EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
1024                                   expected_response_text.c_str()));
1025   }
1026
1027   ShutdownServer();
1028 }
1029
1030 TEST_F(GrpcToolTest, CallCommandBidiStream) {
1031   // Test input: grpc_cli call localhost:<port> BidiStream "message: 'Hello0'"
1032   std::stringstream output_stream;
1033
1034   const std::string server_address = SetUpServer();
1035   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
1036                         "BidiStream", "message: 'Hello0'"};
1037
1038   // Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
1039   std::streambuf* orig = std::cin.rdbuf();
1040   std::istringstream ss("message: 'Hello1'\n\n message: 'Hello2'\n\n");
1041   std::cin.rdbuf(ss.rdbuf());
1042
1043   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1044                                    std::bind(PrintStream, &output_stream,
1045                                              std::placeholders::_1)));
1046
1047   // Expected output: "message: \"Hello0\"\nmessage: \"Hello1\"\nmessage:
1048   // \"Hello2\"\n\n"
1049   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
1050                                 "message: \"Hello0\"\nmessage: "
1051                                 "\"Hello1\"\nmessage: \"Hello2\"\n"));
1052   std::cin.rdbuf(orig);
1053   ShutdownServer();
1054 }
1055
1056 TEST_F(GrpcToolTest, CallCommandBidiStreamWithBadRequest) {
1057   // Test input: grpc_cli call localhost:<port> BidiStream "message: 'Hello0'"
1058   std::stringstream output_stream;
1059
1060   const std::string server_address = SetUpServer();
1061   const char* argv[] = {"grpc_cli", "call", server_address.c_str(),
1062                         "BidiStream", "message: 'Hello0'"};
1063
1064   // Mock std::cin input "message: 'Hello1'\n\n message: 'Hello2'\n\n"
1065   std::streambuf* orig = std::cin.rdbuf();
1066   std::istringstream ss("message: 1.0\n\n message: 'Hello2'\n\n");
1067   std::cin.rdbuf(ss.rdbuf());
1068
1069   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1070                                    std::bind(PrintStream, &output_stream,
1071                                              std::placeholders::_1)));
1072
1073   // Expected output: "message: \"Hello0\"\nmessage: \"Hello1\"\nmessage:
1074   // \"Hello2\"\n\n"
1075   EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
1076                                 "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
1077   std::cin.rdbuf(orig);
1078
1079   ShutdownServer();
1080 }
1081
1082 TEST_F(GrpcToolTest, ParseCommand) {
1083   // Test input "grpc_cli parse localhost:<port> grpc.testing.EchoResponse
1084   // ECHO_RESPONSE_MESSAGE"
1085   std::stringstream output_stream;
1086   std::stringstream binary_output_stream;
1087
1088   const std::string server_address = SetUpServer();
1089   const char* argv[] = {"grpc_cli", "parse", server_address.c_str(),
1090                         "grpc.testing.EchoResponse",
1091                         ECHO_RESPONSE_MESSAGE_TEXT_FORMAT};
1092
1093   absl::SetFlag(&FLAGS_binary_input, false);
1094   absl::SetFlag(&FLAGS_binary_output, false);
1095   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1096                                    std::bind(PrintStream, &output_stream,
1097                                              std::placeholders::_1)));
1098   // Expected output: ECHO_RESPONSE_MESSAGE_TEXT_FORMAT
1099   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
1100                           ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
1101
1102   // with json_output
1103   output_stream.str(std::string());
1104   output_stream.clear();
1105
1106   absl::SetFlag(&FLAGS_json_output, true);
1107   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1108                                    std::bind(PrintStream, &output_stream,
1109                                              std::placeholders::_1)));
1110   absl::SetFlag(&FLAGS_json_output, false);
1111
1112   // Expected output: ECHO_RESPONSE_MESSAGE_JSON_FORMAT
1113   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
1114                           ECHO_RESPONSE_MESSAGE_JSON_FORMAT));
1115
1116   // Parse text message to binary message and then parse it back to text message
1117   output_stream.str(std::string());
1118   output_stream.clear();
1119   absl::SetFlag(&FLAGS_binary_output, true);
1120   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1121                                    std::bind(PrintStream, &output_stream,
1122                                              std::placeholders::_1)));
1123   std::string binary_data = output_stream.str();
1124   output_stream.str(std::string());
1125   output_stream.clear();
1126   argv[4] = binary_data.c_str();
1127   absl::SetFlag(&FLAGS_binary_input, true);
1128   absl::SetFlag(&FLAGS_binary_output, false);
1129   EXPECT_TRUE(0 == GrpcToolMainLib(5, argv, TestCliCredentials(),
1130                                    std::bind(PrintStream, &output_stream,
1131                                              std::placeholders::_1)));
1132
1133   // Expected output: ECHO_RESPONSE_MESSAGE
1134   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
1135                           ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
1136
1137   absl::SetFlag(&FLAGS_binary_input, false);
1138   absl::SetFlag(&FLAGS_binary_output, false);
1139   ShutdownServer();
1140 }
1141
1142 TEST_F(GrpcToolTest, ParseCommandJsonFormat) {
1143   // Test input "grpc_cli parse localhost:<port> grpc.testing.EchoResponse
1144   // ECHO_RESPONSE_MESSAGE_JSON_FORMAT"
1145   std::stringstream output_stream;
1146   std::stringstream binary_output_stream;
1147
1148   const std::string server_address = SetUpServer();
1149   const char* argv[] = {"grpc_cli", "parse", server_address.c_str(),
1150                         "grpc.testing.EchoResponse",
1151                         ECHO_RESPONSE_MESSAGE_JSON_FORMAT};
1152
1153   absl::SetFlag(&FLAGS_json_input, true);
1154   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1155                                    std::bind(PrintStream, &output_stream,
1156                                              std::placeholders::_1)));
1157
1158   // Expected output: ECHO_RESPONSE_MESSAGE_TEXT_FORMAT
1159   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
1160                           ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
1161
1162   // with json_output
1163   output_stream.str(std::string());
1164   output_stream.clear();
1165
1166   absl::SetFlag(&FLAGS_json_output, true);
1167   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1168                                    std::bind(PrintStream, &output_stream,
1169                                              std::placeholders::_1)));
1170   absl::SetFlag(&FLAGS_json_output, false);
1171   absl::SetFlag(&FLAGS_json_input, false);
1172
1173   // Expected output: ECHO_RESPONSE_MESSAGE_JSON_FORMAT
1174   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
1175                           ECHO_RESPONSE_MESSAGE_JSON_FORMAT));
1176
1177   ShutdownServer();
1178 }
1179
1180 TEST_F(GrpcToolTest, TooFewArguments) {
1181   // Test input "grpc_cli call Echo"
1182   std::stringstream output_stream;
1183   const char* argv[] = {"grpc_cli", "call", "Echo"};
1184
1185   // Exit with 1
1186   EXPECT_EXIT(
1187       GrpcToolMainLib(
1188           ArraySize(argv), argv, TestCliCredentials(),
1189           std::bind(PrintStream, &output_stream, std::placeholders::_1)),
1190       ::testing::ExitedWithCode(1), ".*Wrong number of arguments for call.*");
1191   // No output
1192   EXPECT_TRUE(0 == output_stream.tellp());
1193 }
1194
1195 TEST_F(GrpcToolTest, TooManyArguments) {
1196   // Test input "grpc_cli call localhost:<port> Echo Echo "message: 'Hello'"
1197   std::stringstream output_stream;
1198   const char* argv[] = {"grpc_cli", "call", "localhost:10000",
1199                         "Echo",     "Echo", "message: 'Hello'"};
1200
1201   // Exit with 1
1202   EXPECT_EXIT(
1203       GrpcToolMainLib(
1204           ArraySize(argv), argv, TestCliCredentials(),
1205           std::bind(PrintStream, &output_stream, std::placeholders::_1)),
1206       ::testing::ExitedWithCode(1), ".*Wrong number of arguments for call.*");
1207   // No output
1208   EXPECT_TRUE(0 == output_stream.tellp());
1209 }
1210
1211 TEST_F(GrpcToolTest, CallCommandWithMetadata) {
1212   // Test input "grpc_cli call localhost:<port> Echo "message: 'Hello'"
1213   const std::string server_address = SetUpServer();
1214   const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
1215                         "message: 'Hello'"};
1216
1217   {
1218     std::stringstream output_stream;
1219     absl::SetFlag(&FLAGS_metadata, "key0:val0:key1:valq:key2:val2");
1220     EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv,
1221                                      TestCliCredentials(),
1222                                      std::bind(PrintStream, &output_stream,
1223                                                std::placeholders::_1)));
1224     // Expected output: "message: \"Hello\""
1225     EXPECT_TRUE(nullptr !=
1226                 strstr(output_stream.str().c_str(), "message: \"Hello\""));
1227   }
1228
1229   {
1230     std::stringstream output_stream;
1231     absl::SetFlag(&FLAGS_metadata, "key:val\\:val");
1232     EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv,
1233                                      TestCliCredentials(),
1234                                      std::bind(PrintStream, &output_stream,
1235                                                std::placeholders::_1)));
1236     // Expected output: "message: \"Hello\""
1237     EXPECT_TRUE(nullptr !=
1238                 strstr(output_stream.str().c_str(), "message: \"Hello\""));
1239   }
1240
1241   {
1242     std::stringstream output_stream;
1243     absl::SetFlag(&FLAGS_metadata, "key:val\\\\val");
1244     EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv,
1245                                      TestCliCredentials(),
1246                                      std::bind(PrintStream, &output_stream,
1247                                                std::placeholders::_1)));
1248     // Expected output: "message: \"Hello\""
1249     EXPECT_TRUE(nullptr !=
1250                 strstr(output_stream.str().c_str(), "message: \"Hello\""));
1251   }
1252
1253   absl::SetFlag(&FLAGS_metadata, "");
1254   ShutdownServer();
1255 }
1256
1257 TEST_F(GrpcToolTest, CallCommandWithBadMetadata) {
1258   // Test input "grpc_cli call localhost:10000 Echo "message: 'Hello'"
1259   const char* argv[] = {"grpc_cli", "call", "localhost:10000",
1260                         "grpc.testing.EchoTestService.Echo",
1261                         "message: 'Hello'"};
1262   absl::SetFlag(&FLAGS_protofiles, "src/proto/grpc/testing/echo.proto");
1263   char* test_srcdir = gpr_getenv("TEST_SRCDIR");
1264   if (test_srcdir != nullptr) {
1265     absl::SetFlag(&FLAGS_proto_path,
1266                   test_srcdir + std::string("/com_github_grpc_grpc"));
1267   }
1268
1269   {
1270     std::stringstream output_stream;
1271     absl::SetFlag(&FLAGS_metadata, "key0:val0:key1");
1272     // Exit with 1
1273     EXPECT_EXIT(
1274         GrpcToolMainLib(
1275             ArraySize(argv), argv, TestCliCredentials(),
1276             std::bind(PrintStream, &output_stream, std::placeholders::_1)),
1277         ::testing::ExitedWithCode(1), ".*Failed to parse metadata flag.*");
1278   }
1279
1280   {
1281     std::stringstream output_stream;
1282     absl::SetFlag(&FLAGS_metadata, "key:val\\val");
1283     // Exit with 1
1284     EXPECT_EXIT(
1285         GrpcToolMainLib(
1286             ArraySize(argv), argv, TestCliCredentials(),
1287             std::bind(PrintStream, &output_stream, std::placeholders::_1)),
1288         ::testing::ExitedWithCode(1), ".*Failed to parse metadata flag.*");
1289   }
1290
1291   absl::SetFlag(&FLAGS_metadata, "");
1292   absl::SetFlag(&FLAGS_protofiles, "");
1293
1294   gpr_free(test_srcdir);
1295 }
1296
1297 TEST_F(GrpcToolTest, ListCommand_OverrideSslHostName) {
1298   const std::string server_address = SetUpServer(true);
1299
1300   // Test input "grpc_cli ls localhost:<port> --channel_creds_type=ssl
1301   // --ssl_target=z.test.google.fr"
1302   std::stringstream output_stream;
1303   const char* argv[] = {"grpc_cli", "ls", server_address.c_str()};
1304   absl::SetFlag(&FLAGS_l, false);
1305   absl::SetFlag(&FLAGS_channel_creds_type, "ssl");
1306   absl::SetFlag(&FLAGS_ssl_target, "z.test.google.fr");
1307   EXPECT_TRUE(
1308       0 == GrpcToolMainLib(
1309                ArraySize(argv), argv, TestCliCredentials(true),
1310                std::bind(PrintStream, &output_stream, std::placeholders::_1)));
1311   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
1312                           "grpc.testing.EchoTestService\n"
1313                           "grpc.reflection.v1alpha.ServerReflection\n"));
1314
1315   absl::SetFlag(&FLAGS_channel_creds_type, "");
1316   absl::SetFlag(&FLAGS_ssl_target, "");
1317   ShutdownServer();
1318 }
1319
1320 TEST_F(GrpcToolTest, ConfiguringDefaultServiceConfig) {
1321   // Test input "grpc_cli list localhost:<port>
1322   // --default_service_config={\"loadBalancingConfig\":[{\"pick_first\":{}}]}"
1323   std::stringstream output_stream;
1324   const std::string server_address = SetUpServer();
1325   const char* argv[] = {"grpc_cli", "ls", server_address.c_str()};
1326   // Just check that the tool is still operational when --default_service_config
1327   // is configured. This particular service config is in reality redundant with
1328   // the channel's default configuration.
1329   absl::SetFlag(&FLAGS_l, false);
1330   absl::SetFlag(&FLAGS_default_service_config,
1331                 "{\"loadBalancingConfig\":[{\"pick_first\":{}}]}");
1332   EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
1333                                    std::bind(PrintStream, &output_stream,
1334                                              std::placeholders::_1)));
1335   absl::SetFlag(&FLAGS_default_service_config, "");
1336   EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(),
1337                           "grpc.testing.EchoTestService\n"
1338                           "grpc.reflection.v1alpha.ServerReflection\n"));
1339   ShutdownServer();
1340 }
1341
1342 }  // namespace testing
1343 }  // namespace grpc
1344
1345 int main(int argc, char** argv) {
1346   grpc::testing::TestEnvironment env(argc, argv);
1347   ::testing::InitGoogleTest(&argc, argv);
1348   ::testing::FLAGS_gtest_death_test_style = "threadsafe";
1349   return RUN_ALL_TESTS();
1350 }