Chiebot-Mirror
/
grpc
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert "grpc_cli json support"

Browse Source
pull/16902/head
David G. Quintas 7 years ago committed by GitHub
parent 8e626a8de1
commit a464b4ce39
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 57 additions and 533 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      test/cpp/util/config_grpc_cli.h
  2. 67
      test/cpp/util/grpc_tool.cc
  3. 389
      test/cpp/util/grpc_tool_test.cc
  4. 59
      test/cpp/util/proto_file_parser.cc
  5. 52
      test/cpp/util/proto_file_parser.h

7
test/cpp/util/config_grpc_cli.h
Unescape View File

@ -40,11 +40,6 @@
#define GRPC_CUSTOM_TEXTFORMAT ::google::protobuf::TextFormat #define GRPC_CUSTOM_TEXTFORMAT ::google::protobuf::TextFormat
#endif #endif
#ifndef GRPC_CUSTOM_JSONUTIL
#include <google/protobuf/util/json_util.h>
#define GRPC_CUSTOM_JSONUTIL ::google::protobuf::util
#endif
#ifndef GRPC_CUSTOM_DISKSOURCETREE #ifndef GRPC_CUSTOM_DISKSOURCETREE
#include <google/protobuf/compiler/importer.h> #include <google/protobuf/compiler/importer.h>
#define GRPC_CUSTOM_DISKSOURCETREE ::google::protobuf::compiler::DiskSourceTree #define GRPC_CUSTOM_DISKSOURCETREE ::google::protobuf::compiler::DiskSourceTree
@ -63,8 +58,6 @@ typedef GRPC_CUSTOM_MERGEDDESCRIPTORDATABASE MergedDescriptorDatabase;
typedef GRPC_CUSTOM_TEXTFORMAT TextFormat; typedef GRPC_CUSTOM_TEXTFORMAT TextFormat;
namespace json = GRPC_CUSTOM_JSONUTIL;
namespace compiler { namespace compiler {
typedef GRPC_CUSTOM_DISKSOURCETREE DiskSourceTree; typedef GRPC_CUSTOM_DISKSOURCETREE DiskSourceTree;
typedef GRPC_CUSTOM_IMPORTER Importer; typedef GRPC_CUSTOM_IMPORTER Importer;

67
test/cpp/util/grpc_tool.cc
Unescape View File

@ -57,8 +57,6 @@ DEFINE_string(proto_path, ".", "Path to look for the proto file.");
DEFINE_string(protofiles, "", "Name of the proto file."); DEFINE_string(protofiles, "", "Name of the proto file.");
DEFINE_bool(binary_input, false, "Input in binary format"); DEFINE_bool(binary_input, false, "Input in binary format");
DEFINE_bool(binary_output, false, "Output in binary format"); DEFINE_bool(binary_output, false, "Output in binary format");
DEFINE_bool(json_input, false, "Input in json format");
DEFINE_bool(json_output, false, "Output in json format");
DEFINE_string(infile, "", "Input file (default is stdin)"); DEFINE_string(infile, "", "Input file (default is stdin)");
DEFINE_bool(batch, false, DEFINE_bool(batch, false,
"Input contains multiple requests. Please do not use this to send " "Input contains multiple requests. Please do not use this to send "
@ -90,8 +88,6 @@ class GrpcTool {
GrpcToolOutputCallback callback); GrpcToolOutputCallback callback);
bool ToText(int argc, const char** argv, const CliCredentials& cred, bool ToText(int argc, const char** argv, const CliCredentials& cred,
GrpcToolOutputCallback callback); GrpcToolOutputCallback callback);
bool ToJson(int argc, const char** argv, const CliCredentials& cred,
GrpcToolOutputCallback callback);
bool ToBinary(int argc, const char** argv, const CliCredentials& cred, bool ToBinary(int argc, const char** argv, const CliCredentials& cred,
GrpcToolOutputCallback callback); GrpcToolOutputCallback callback);
@ -193,9 +189,8 @@ void ReadResponse(CliCall* call, const grpc::string& method_name,
fprintf(stderr, "got response.\n"); fprintf(stderr, "got response.\n");
if (!FLAGS_binary_output) { if (!FLAGS_binary_output) {
gpr_mu_lock(parser_mu); gpr_mu_lock(parser_mu);
serialized_response_proto = parser->GetFormattedStringFromMethod( serialized_response_proto = parser->GetTextFormatFromMethod(
method_name, serialized_response_proto, false /* is_request */, method_name, serialized_response_proto, false /* is_request */);
FLAGS_json_output);
if (parser->HasError() && print_mode) { if (parser->HasError() && print_mode) {
fprintf(stderr, "Failed to parse response.\n"); fprintf(stderr, "Failed to parse response.\n");
} }
@ -238,7 +233,6 @@ const Command ops[] = {
{"parse", BindWith5Args(&GrpcTool::ParseMessage), 2, 3}, {"parse", BindWith5Args(&GrpcTool::ParseMessage), 2, 3},
{"totext", BindWith5Args(&GrpcTool::ToText), 2, 3}, {"totext", BindWith5Args(&GrpcTool::ToText), 2, 3},
{"tobinary", BindWith5Args(&GrpcTool::ToBinary), 2, 3}, {"tobinary", BindWith5Args(&GrpcTool::ToBinary), 2, 3},
{"tojson", BindWith5Args(&GrpcTool::ToJson), 2, 3},
}; };
void Usage(const grpc::string& msg) { void Usage(const grpc::string& msg) {
@ -250,7 +244,6 @@ void Usage(const grpc::string& msg) {
" grpc_cli type ... ; Print type\n" " grpc_cli type ... ; Print type\n"
" grpc_cli parse ... ; Parse message\n" " grpc_cli parse ... ; Parse message\n"
" grpc_cli totext ... ; Convert binary message to text\n" " grpc_cli totext ... ; Convert binary message to text\n"
" grpc_cli tojson ... ; Convert binary message to json\n"
" grpc_cli tobinary ... ; Convert text message to binary\n" " grpc_cli tobinary ... ; Convert text message to binary\n"
" grpc_cli help ... ; Print this message, or per-command usage\n" " grpc_cli help ... ; Print this message, or per-command usage\n"
"\n", "\n",
@ -472,9 +465,7 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
" --infile ; Input filename (defaults to stdin)\n" " --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n" " --outfile ; Output filename (defaults to stdout)\n"
" --binary_input ; Input in binary format\n" " --binary_input ; Input in binary format\n"
" --binary_output ; Output in binary format\n" " --binary_output ; Output in binary format\n" +
" --json_input ; Input in json format\n"
" --json_output ; Output in json format\n" +
cred.GetCredentialUsage()); cred.GetCredentialUsage());
std::stringstream output_ss; std::stringstream output_ss;
@ -557,8 +548,7 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
} else { } else {
gpr_mu_lock(&parser_mu); gpr_mu_lock(&parser_mu);
serialized_request_proto = parser->GetSerializedProtoFromMethod( serialized_request_proto = parser->GetSerializedProtoFromMethod(
method_name, request_text, true /* is_request */, method_name, request_text, true /* is_request */);
FLAGS_json_input);
request_text.clear(); request_text.clear();
if (parser->HasError()) { if (parser->HasError()) {
if (print_mode) { if (print_mode) {
@ -642,8 +632,7 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
request_text.clear(); request_text.clear();
} else { } else {
serialized_request_proto = parser->GetSerializedProtoFromMethod( serialized_request_proto = parser->GetSerializedProtoFromMethod(
method_name, request_text, true /* is_request */, method_name, request_text, true /* is_request */);
FLAGS_json_input);
request_text.clear(); request_text.clear();
if (parser->HasError()) { if (parser->HasError()) {
if (print_mode) { if (print_mode) {
@ -679,10 +668,9 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
break; break;
} }
} else { } else {
grpc::string response_text = parser->GetFormattedStringFromMethod( grpc::string response_text = parser->GetTextFormatFromMethod(
method_name, serialized_response_proto, method_name, serialized_response_proto,
false /* is_request */, FLAGS_json_output); false /* is_request */);
if (parser->HasError() && print_mode) { if (parser->HasError() && print_mode) {
fprintf(stderr, "Failed to parse response.\n"); fprintf(stderr, "Failed to parse response.\n");
} else { } else {
@ -739,7 +727,7 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
serialized_request_proto = request_text; serialized_request_proto = request_text;
} else { } else {
serialized_request_proto = parser->GetSerializedProtoFromMethod( serialized_request_proto = parser->GetSerializedProtoFromMethod(
method_name, request_text, true /* is_request */, FLAGS_json_input); method_name, request_text, true /* is_request */);
if (parser->HasError()) { if (parser->HasError()) {
fprintf(stderr, "Failed to parse request.\n"); fprintf(stderr, "Failed to parse request.\n");
return false; return false;
@ -763,15 +751,13 @@ bool GrpcTool::CallMethod(int argc, const char** argv,
receive_initial_metadata ? &server_initial_metadata : nullptr); receive_initial_metadata ? &server_initial_metadata : nullptr);
receive_initial_metadata = false) { receive_initial_metadata = false) {
if (!FLAGS_binary_output) { if (!FLAGS_binary_output) {
serialized_response_proto = parser->GetFormattedStringFromMethod( serialized_response_proto = parser->GetTextFormatFromMethod(
method_name, serialized_response_proto, false /* is_request */, method_name, serialized_response_proto, false /* is_request */);
FLAGS_json_output);
if (parser->HasError()) { if (parser->HasError()) {
fprintf(stderr, "Failed to parse response.\n"); fprintf(stderr, "Failed to parse response.\n");
return false; return false;
} }
} }
if (receive_initial_metadata) { if (receive_initial_metadata) {
PrintMetadata(server_initial_metadata, PrintMetadata(server_initial_metadata,
"Received initial metadata from server:"); "Received initial metadata from server:");
@ -811,9 +797,7 @@ bool GrpcTool::ParseMessage(int argc, const char** argv,
" --infile ; Input filename (defaults to stdin)\n" " --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n" " --outfile ; Output filename (defaults to stdout)\n"
" --binary_input ; Input in binary format\n" " --binary_input ; Input in binary format\n"
" --binary_output ; Output in binary format\n" " --binary_output ; Output in binary format\n" +
" --json_input ; Input in json format\n"
" --json_output ; Output in json format\n" +
cred.GetCredentialUsage()); cred.GetCredentialUsage());
std::stringstream output_ss; std::stringstream output_ss;
@ -860,8 +844,8 @@ bool GrpcTool::ParseMessage(int argc, const char** argv,
if (FLAGS_binary_input) { if (FLAGS_binary_input) {
serialized_request_proto = message_text; serialized_request_proto = message_text;
} else { } else {
serialized_request_proto = parser->GetSerializedProtoFromMessageType( serialized_request_proto =
type_name, message_text, FLAGS_json_input); parser->GetSerializedProtoFromMessageType(type_name, message_text);
if (parser->HasError()) { if (parser->HasError()) {
fprintf(stderr, "Failed to serialize the message.\n"); fprintf(stderr, "Failed to serialize the message.\n");
return false; return false;
@ -871,14 +855,12 @@ bool GrpcTool::ParseMessage(int argc, const char** argv,
if (FLAGS_binary_output) { if (FLAGS_binary_output) {
output_ss << serialized_request_proto; output_ss << serialized_request_proto;
} else { } else {
grpc::string output_text; grpc::string output_text = parser->GetTextFormatFromMessageType(
output_text = parser->GetFormattedStringFromMessageType( type_name, serialized_request_proto);
type_name, serialized_request_proto, FLAGS_json_output);
if (parser->HasError()) { if (parser->HasError()) {
fprintf(stderr, "Failed to deserialize the message.\n"); fprintf(stderr, "Failed to deserialize the message.\n");
return false; return false;
} }
output_ss << output_text << std::endl; output_ss << output_text << std::endl;
} }
@ -903,25 +885,6 @@ bool GrpcTool::ToText(int argc, const char** argv, const CliCredentials& cred,
return ParseMessage(argc, argv, cred, callback); return ParseMessage(argc, argv, cred, callback);
} }
bool GrpcTool::ToJson(int argc, const char** argv, const CliCredentials& cred,
GrpcToolOutputCallback callback) {
CommandUsage(
"Convert binary message to json\n"
" grpc_cli tojson <protofiles> <type>\n"
" <protofiles> ; Comma separated list of proto files\n"
" <type> ; Protocol buffer type name\n"
" --proto_path ; The search path of proto files\n"
" --infile ; Input filename (defaults to stdin)\n"
" --outfile ; Output filename (defaults to stdout)\n");
FLAGS_protofiles = argv[0];
FLAGS_remotedb = false;
FLAGS_binary_input = true;
FLAGS_binary_output = false;
FLAGS_json_output = true;
return ParseMessage(argc, argv, cred, callback);
}
bool GrpcTool::ToBinary(int argc, const char** argv, const CliCredentials& cred, bool GrpcTool::ToBinary(int argc, const char** argv, const CliCredentials& cred,
GrpcToolOutputCallback callback) { GrpcToolOutputCallback callback) {
CommandUsage( CommandUsage(

389
test/cpp/util/grpc_tool_test.cc
Unescape View File

@ -74,22 +74,13 @@ using grpc::testing::EchoResponse;
" rpc Echo(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \ " rpc Echo(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse) " \
"{}\n" "{}\n"
#define ECHO_RESPONSE_MESSAGE_TEXT_FORMAT \ #define ECHO_RESPONSE_MESSAGE \
"message: \"echo\"\n" \ "message: \"echo\"\n" \
"param {\n" \ "param {\n" \
" host: \"localhost\"\n" \ " host: \"localhost\"\n" \
" peer: \"peer\"\n" \ " peer: \"peer\"\n" \
"}\n\n" "}\n\n"
#define ECHO_RESPONSE_MESSAGE_JSON_FORMAT \
"{\n" \
" \"message\": \"echo\",\n" \
" \"param\": {\n" \
" \"host\": \"localhost\",\n" \
" \"peer\": \"peer\"\n" \
" }\n" \
"}\n\n"
DECLARE_string(channel_creds_type); DECLARE_string(channel_creds_type);
DECLARE_string(ssl_target); DECLARE_string(ssl_target);
@ -98,8 +89,6 @@ namespace testing {
DECLARE_bool(binary_input); DECLARE_bool(binary_input);
DECLARE_bool(binary_output); DECLARE_bool(binary_output);
DECLARE_bool(json_input);
DECLARE_bool(json_output);
DECLARE_bool(l); DECLARE_bool(l);
DECLARE_bool(batch); DECLARE_bool(batch);
DECLARE_string(metadata); DECLARE_string(metadata);
@ -437,61 +426,6 @@ TEST_F(GrpcToolTest, CallCommand) {
// Expected output: "message: \"Hello\"" // Expected output: "message: \"Hello\""
EXPECT_TRUE(nullptr != EXPECT_TRUE(nullptr !=
strstr(output_stream.str().c_str(), "message: \"Hello\"")); strstr(output_stream.str().c_str(), "message: \"Hello\""));
// with json_output
output_stream.str(grpc::string());
output_stream.clear();
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
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 grpc::string server_address = SetUpServer();
const char* argv[] = {"grpc_cli", "call", server_address.c_str(), "Echo",
"{ \"message\": \"Hello\"}"};
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(grpc::string());
output_stream.clear();
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_output = false;
FLAGS_json_input = false;
// Expected output:
// {
// "message": "Hello"
// }
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
"{\n \"message\": \"Hello\"\n}"));
ShutdownServer(); ShutdownServer();
} }
@ -519,101 +453,6 @@ TEST_F(GrpcToolTest, CallCommandBatch) {
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(), EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
"message: \"Hello0\"\nmessage: " "message: \"Hello0\"\nmessage: "
"\"Hello1\"\nmessage: \"Hello2\"\n")); "\"Hello1\"\nmessage: \"Hello2\"\n"));
// with json_output
output_stream.str(grpc::string());
output_stream.clear();
ss.clear();
ss.seekg(0);
std::cin.rdbuf(ss.rdbuf());
FLAGS_batch = true;
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_output = false;
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 grpc::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());
FLAGS_json_input = true;
FLAGS_batch = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
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(grpc::string());
output_stream.clear();
ss.clear();
ss.seekg(0);
std::cin.rdbuf(ss.rdbuf());
FLAGS_batch = true;
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_output = false;
FLAGS_batch = false;
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); std::cin.rdbuf(orig);
ShutdownServer(); ShutdownServer();
} }
@ -640,95 +479,6 @@ TEST_F(GrpcToolTest, CallCommandBatchWithBadRequest) {
// Expected output: "message: "Hello0"\nmessage: "Hello2"\n" // Expected output: "message: "Hello0"\nmessage: "Hello2"\n"
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(), EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
"message: \"Hello0\"\nmessage: \"Hello2\"\n")); "message: \"Hello0\"\nmessage: \"Hello2\"\n"));
// with json_output
output_stream.str(grpc::string());
output_stream.clear();
ss.clear();
ss.seekg(0);
std::cin.rdbuf(ss.rdbuf());
FLAGS_batch = true;
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_output = false;
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 grpc::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());
FLAGS_batch = true;
FLAGS_json_input = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_input = false;
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(grpc::string());
output_stream.clear();
ss.clear();
ss.seekg(0);
std::cin.rdbuf(ss.rdbuf());
FLAGS_batch = true;
FLAGS_json_input = true;
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_output = false;
FLAGS_json_input = false;
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); std::cin.rdbuf(orig);
ShutdownServer(); ShutdownServer();
} }
@ -758,34 +508,6 @@ TEST_F(GrpcToolTest, CallCommandRequestStream) {
ShutdownServer(); ShutdownServer();
} }
TEST_F(GrpcToolTest, CallCommandRequestStreamJsonInput) {
// Test input: grpc_cli call localhost:<port> RequestStream "{ \"message\":
// \"Hello0\"}"
std::stringstream output_stream;
const grpc::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());
FLAGS_json_input = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
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_F(GrpcToolTest, CallCommandRequestStreamWithBadRequest) {
// Test input: grpc_cli call localhost:<port> RequestStream "message: // Test input: grpc_cli call localhost:<port> RequestStream "message:
// 'Hello0'" // 'Hello0'"
@ -811,34 +533,6 @@ TEST_F(GrpcToolTest, CallCommandRequestStreamWithBadRequest) {
ShutdownServer(); ShutdownServer();
} }
TEST_F(GrpcToolTest, CallCommandRequestStreamWithBadRequestJsonInput) {
// Test input: grpc_cli call localhost:<port> RequestStream "message:
// 'Hello0'"
std::stringstream output_stream;
const grpc::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());
FLAGS_json_input = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
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, CallCommandResponseStream) { TEST_F(GrpcToolTest, CallCommandResponseStream) {
// Test input: grpc_cli call localhost:<port> ResponseStream "message: // Test input: grpc_cli call localhost:<port> ResponseStream "message:
// 'Hello'" // 'Hello'"
@ -860,24 +554,6 @@ TEST_F(GrpcToolTest, CallCommandResponseStream) {
expected_response_text.c_str())); expected_response_text.c_str()));
} }
// with json_output
output_stream.str(grpc::string());
output_stream.clear();
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_output = false;
// Expected output: "{\n \"message\": \"Hello{n}\"\n}\n"
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) {
grpc::string expected_response_text =
"{\n \"message\": \"Hello" + grpc::to_string(i) + "\"\n}\n";
EXPECT_TRUE(nullptr != strstr(output_stream.str().c_str(),
expected_response_text.c_str()));
}
ShutdownServer(); ShutdownServer();
} }
@ -941,31 +617,15 @@ TEST_F(GrpcToolTest, ParseCommand) {
const grpc::string server_address = SetUpServer(); const grpc::string server_address = SetUpServer();
const char* argv[] = {"grpc_cli", "parse", server_address.c_str(), const char* argv[] = {"grpc_cli", "parse", server_address.c_str(),
"grpc.testing.EchoResponse", "grpc.testing.EchoResponse", ECHO_RESPONSE_MESSAGE};
ECHO_RESPONSE_MESSAGE_TEXT_FORMAT};
FLAGS_binary_input = false; FLAGS_binary_input = false;
FLAGS_binary_output = false; FLAGS_binary_output = false;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(), EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream, std::bind(PrintStream, &output_stream,
std::placeholders::_1))); std::placeholders::_1)));
// Expected output: ECHO_RESPONSE_MESSAGE_TEXT_FORMAT // Expected output: ECHO_RESPONSE_MESSAGE
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(), EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(), ECHO_RESPONSE_MESSAGE));
ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
// with json_output
output_stream.str(grpc::string());
output_stream.clear();
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
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 // Parse text message to binary message and then parse it back to text message
output_stream.str(grpc::string()); output_stream.str(grpc::string());
@ -985,52 +645,13 @@ TEST_F(GrpcToolTest, ParseCommand) {
std::placeholders::_1))); std::placeholders::_1)));
// Expected output: ECHO_RESPONSE_MESSAGE // Expected output: ECHO_RESPONSE_MESSAGE
EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(), EXPECT_TRUE(0 == strcmp(output_stream.str().c_str(), ECHO_RESPONSE_MESSAGE));
ECHO_RESPONSE_MESSAGE_TEXT_FORMAT));
FLAGS_binary_input = false; FLAGS_binary_input = false;
FLAGS_binary_output = false; FLAGS_binary_output = false;
ShutdownServer(); 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 grpc::string server_address = SetUpServer();
const char* argv[] = {"grpc_cli", "parse", server_address.c_str(),
"grpc.testing.EchoResponse",
ECHO_RESPONSE_MESSAGE_JSON_FORMAT};
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(grpc::string());
output_stream.clear();
FLAGS_json_output = true;
EXPECT_TRUE(0 == GrpcToolMainLib(ArraySize(argv), argv, TestCliCredentials(),
std::bind(PrintStream, &output_stream,
std::placeholders::_1)));
FLAGS_json_output = false;
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_F(GrpcToolTest, TooFewArguments) {
// Test input "grpc_cli call Echo" // Test input "grpc_cli call Echo"
std::stringstream output_stream; std::stringstream output_stream;

59
test/cpp/util/proto_file_parser.cc
Unescape View File

@ -217,32 +217,31 @@ bool ProtoFileParser::IsStreaming(const grpc::string& method, bool is_request) {
} }
grpc::string ProtoFileParser::GetSerializedProtoFromMethod( grpc::string ProtoFileParser::GetSerializedProtoFromMethod(
const grpc::string& method, const grpc::string& formatted_proto, const grpc::string& method, const grpc::string& text_format_proto,
bool is_request, bool is_json_format) { bool is_request) {
has_error_ = false; has_error_ = false;
grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request); grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request);
if (has_error_) { if (has_error_) {
return ""; return "";
} }
return GetSerializedProtoFromMessageType(message_type_name, formatted_proto, return GetSerializedProtoFromMessageType(message_type_name,
is_json_format); text_format_proto);
} }
grpc::string ProtoFileParser::GetFormattedStringFromMethod( grpc::string ProtoFileParser::GetTextFormatFromMethod(
const grpc::string& method, const grpc::string& serialized_proto, const grpc::string& method, const grpc::string& serialized_proto,
bool is_request, bool is_json_format) { bool is_request) {
has_error_ = false; has_error_ = false;
grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request); grpc::string message_type_name = GetMessageTypeFromMethod(method, is_request);
if (has_error_) { if (has_error_) {
return ""; return "";
} }
return GetFormattedStringFromMessageType(message_type_name, serialized_proto, return GetTextFormatFromMessageType(message_type_name, serialized_proto);
is_json_format);
} }
grpc::string ProtoFileParser::GetSerializedProtoFromMessageType( grpc::string ProtoFileParser::GetSerializedProtoFromMessageType(
const grpc::string& message_type_name, const grpc::string& formatted_proto, const grpc::string& message_type_name,
bool is_json_format) { const grpc::string& text_format_proto) {
has_error_ = false; has_error_ = false;
grpc::string serialized; grpc::string serialized;
const protobuf::Descriptor* desc = const protobuf::Descriptor* desc =
@ -253,23 +252,11 @@ grpc::string ProtoFileParser::GetSerializedProtoFromMessageType(
} }
std::unique_ptr<grpc::protobuf::Message> msg( std::unique_ptr<grpc::protobuf::Message> msg(
dynamic_factory_->GetPrototype(desc)->New()); dynamic_factory_->GetPrototype(desc)->New());
bool ok = protobuf::TextFormat::ParseFromString(text_format_proto, msg.get());
bool ok;
if (is_json_format) {
ok = grpc::protobuf::json::JsonStringToMessage(formatted_proto, msg.get())
.ok();
if (!ok) {
LogError("Failed to convert json format to proto.");
return "";
}
} else {
ok = protobuf::TextFormat::ParseFromString(formatted_proto, msg.get());
if (!ok) { if (!ok) {
LogError("Failed to convert text format to proto."); LogError("Failed to parse text format to proto.");
return ""; return "";
} }
}
ok = msg->SerializeToString(&serialized); ok = msg->SerializeToString(&serialized);
if (!ok) { if (!ok) {
LogError("Failed to serialize proto."); LogError("Failed to serialize proto.");
@ -278,9 +265,9 @@ grpc::string ProtoFileParser::GetSerializedProtoFromMessageType(
return serialized; return serialized;
} }
grpc::string ProtoFileParser::GetFormattedStringFromMessageType( grpc::string ProtoFileParser::GetTextFormatFromMessageType(
const grpc::string& message_type_name, const grpc::string& serialized_proto, const grpc::string& message_type_name,
bool is_json_format) { const grpc::string& serialized_proto) {
has_error_ = false; has_error_ = false;
const protobuf::Descriptor* desc = const protobuf::Descriptor* desc =
desc_pool_->FindMessageTypeByName(message_type_name); desc_pool_->FindMessageTypeByName(message_type_name);
@ -294,24 +281,12 @@ grpc::string ProtoFileParser::GetFormattedStringFromMessageType(
LogError("Failed to deserialize proto."); LogError("Failed to deserialize proto.");
return ""; return "";
} }
grpc::string formatted_string; grpc::string text_format;
if (!protobuf::TextFormat::PrintToString(*msg.get(), &text_format)) {
if (is_json_format) {
grpc::protobuf::json::JsonPrintOptions jsonPrintOptions;
jsonPrintOptions.add_whitespace = true;
if (!grpc::protobuf::json::MessageToJsonString(
*msg.get(), &formatted_string, jsonPrintOptions)
.ok()) {
LogError("Failed to print proto message to json format");
return "";
}
} else {
if (!protobuf::TextFormat::PrintToString(*msg.get(), &formatted_string)) {
LogError("Failed to print proto message to text format"); LogError("Failed to print proto message to text format");
return ""; return "";
} }
} return text_format;
return formatted_string;
} }
void ProtoFileParser::LogError(const grpc::string& error_msg) { void ProtoFileParser::LogError(const grpc::string& error_msg) {

52
test/cpp/util/proto_file_parser.h
Unescape View File

@ -53,49 +53,21 @@ class ProtoFileParser {
// used as the argument of Stub::Call() // used as the argument of Stub::Call()
grpc::string GetFormattedMethodName(const grpc::string& method); grpc::string GetFormattedMethodName(const grpc::string& method);
/// Converts a text or json string to its binary proto representation for the grpc::string GetSerializedProtoFromMethod(
/// given method's input or return type. const grpc::string& method, const grpc::string& text_format_proto,
/// \param method the name of the method (does not need to be fully qualified bool is_request);
/// name)
/// \param formatted_proto the text- or json-formatted proto string grpc::string GetTextFormatFromMethod(const grpc::string& method,
/// \param is_request if \c true the resolved type is that of the input const grpc::string& serialized_proto,
/// parameter of the method, otherwise it is the output type bool is_request);
/// \param is_json_format if \c true the \c formatted_proto is treated as a
/// json-formatted proto, otherwise it is treated as a text-formatted
/// proto
/// \return the serialised binary proto represenation of \c formatted_proto
grpc::string GetSerializedProtoFromMethod(const grpc::string& method,
const grpc::string& formatted_proto,
bool is_request,
bool is_json_format);
/// Converts a text or json string to its proto representation for the given
/// message type.
/// \param formatted_proto the text- or json-formatted proto string
/// \return the serialised binary proto represenation of \c formatted_proto
grpc::string GetSerializedProtoFromMessageType( grpc::string GetSerializedProtoFromMessageType(
const grpc::string& message_type_name, const grpc::string& message_type_name,
const grpc::string& formatted_proto, bool is_json_format); const grpc::string& text_format_proto);
/// Converts a binary proto string to its text or json string representation grpc::string GetTextFormatFromMessageType(
/// for the given method's input or return type.
/// \param method the name of the method (does not need to be a fully
/// qualified name)
/// \param the serialised binary proto representation of type
/// \c message_type_name
/// \return the text- or json-formatted proto string of \c serialized_proto
grpc::string GetFormattedStringFromMethod(
const grpc::string& method, const grpc::string& serialized_proto,
bool is_request, bool is_json_format);
/// Converts a binary proto string to its text or json string representation
/// for the given message type.
/// \param the serialised binary proto representation of type
/// \c message_type_name
/// \return the text- or json-formatted proto string of \c serialized_proto
grpc::string GetFormattedStringFromMessageType(
const grpc::string& message_type_name, const grpc::string& message_type_name,
const grpc::string& serialized_proto, bool is_json_format); const grpc::string& serialized_proto);
bool IsStreaming(const grpc::string& method, bool is_request); bool IsStreaming(const grpc::string& method, bool is_request);

Write Preview
Loading…
Cancel
Save