Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Refactor and add a unit test

Browse Source
pull/1144/head
Yang Gao 10 years ago
parent 48bbd000eb
commit b946b5ea74
7 changed files with 374 additions and 67 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 50
      Makefile
  2. 17
      build.json
  3. 106
      test/cpp/util/cli_call.cc
  4. 53
      test/cpp/util/cli_call.h
  5. 131
      test/cpp/util/cli_call_test.cc
  6. 79
      test/cpp/util/grpc_cli.cc
  7. 5
      tools/run_tests/tests.json

50
Makefile
View File

File diff suppressed because one or more lines are too long

17
build.json
Unescape View File

@ -482,6 +482,7 @@
"test/cpp/util/messages.proto",
"test/cpp/util/echo.proto",
"test/cpp/util/echo_duplicate.proto",
"test/cpp/util/cli_call.cc",
"test/cpp/util/create_test_channel.cc"
]
},
@ -1706,6 +1707,22 @@
"gpr"
]
},
{
"name": "cli_call_test",
"build": "test",
"language": "c++",
"src": [
"test/cpp/util/cli_call_test.cc"
],
"deps": [
"grpc++_test_util",
"grpc_test_util",
"grpc++",
"grpc",
"gpr_test_util",
"gpr"
]
},
{
"name": "credentials_test",
"build": "test",

106
test/cpp/util/cli_call.cc
Unescape View File

@ -0,0 +1,106 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "test/cpp/util/cli_call.h"
#include <iostream>
#include <grpc++/byte_buffer.h>
#include <grpc++/channel_interface.h>
#include <grpc++/client_context.h>
#include <grpc++/generic_stub.h>
#include <grpc++/status.h>
#include <grpc++/stream.h>
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/slice.h>
namespace grpc {
namespace testing {
namespace {
void* tag(int i) { return (void*)(gpr_intptr) i; }
} // namespace
void CliCall::Call(std::shared_ptr<grpc::ChannelInterface> channel,
const grpc::string& method, const grpc::string& request,
grpc::string* response) {
std::unique_ptr<grpc::GenericStub> stub(new grpc::GenericStub(channel));
grpc::ClientContext ctx;
grpc::CompletionQueue cq;
std::unique_ptr<grpc::GenericClientAsyncReaderWriter> call(
stub->Call(&ctx, method, &cq, tag(1)));
void* got_tag;
bool ok;
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
gpr_slice s = gpr_slice_from_copied_string(request.c_str());
grpc::Slice req_slice(s, grpc::Slice::STEAL_REF);
grpc::ByteBuffer send_buffer(&req_slice, 1);
call->Write(send_buffer, tag(2));
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
call->WritesDone(tag(3));
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
grpc::ByteBuffer recv_buffer;
call->Read(&recv_buffer, tag(4));
cq.Next(&got_tag, &ok);
if (!ok) {
std::cout << "Failed to read response." << std::endl;
return;
}
grpc::Status status;
call->Finish(&status, tag(5));
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
if (status.IsOk()) {
std::cout << "RPC finished with OK status." << std::endl;
std::vector<grpc::Slice> slices;
recv_buffer.Dump(&slices);
response->clear();
for (size_t i = 0; i < slices.size(); i++) {
response->append(reinterpret_cast<const char*>(slices[i].begin()),
slices[i].size());
}
} else {
std::cout << "RPC finished with status code " << status.code()
<< " details: " << status.details() << std::endl;
}
}
} // namespace testing
} // namespace grpc

53
test/cpp/util/cli_call.h
Unescape View File

@ -0,0 +1,53 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#ifndef GRPC_TEST_CPP_UTIL_CLI_CALL_H
#define GRPC_TEST_CPP_UTIL_CLI_CALL_H
#include <grpc++/channel_interface.h>
#include <grpc++/config.h>
namespace grpc {
namespace testing {
class CliCall GRPC_FINAL {
public:
static void Call(std::shared_ptr<grpc::ChannelInterface> channel,
const grpc::string& method, const grpc::string& request,
grpc::string* response);
};
} // namespace testing
} // namespace grpc
#endif // GRPC_TEST_CPP_UTIL_CLI_CALL_H

131
test/cpp/util/cli_call_test.cc
Unescape View File

@ -0,0 +1,131 @@
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "test/core/util/test_config.h"
#include "test/cpp/util/cli_call.h"
#include "test/cpp/util/echo.pb.h"
#include "src/cpp/server/thread_pool.h"
#include <grpc++/channel_arguments.h>
#include <grpc++/channel_interface.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/credentials.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc++/server_credentials.h>
#include <grpc++/status.h>
#include "test/core/util/port.h"
#include <gtest/gtest.h>
#include <grpc/grpc.h>
using grpc::cpp::test::util::EchoRequest;
using grpc::cpp::test::util::EchoResponse;
namespace grpc {
namespace testing {
class TestServiceImpl : public ::grpc::cpp::test::util::TestService::Service {
public:
Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE {
response->set_message(request->message());
return Status::OK;
}
};
class CliCallTest : public ::testing::Test {
protected:
CliCallTest() : thread_pool_(2) {}
void SetUp() GRPC_OVERRIDE {
int port = grpc_pick_unused_port_or_die();
server_address_ << "localhost:" << port;
// Setup server
ServerBuilder builder;
builder.AddListeningPort(server_address_.str(),
InsecureServerCredentials());
builder.RegisterService(&service_);
builder.SetThreadPool(&thread_pool_);
server_ = builder.BuildAndStart();
}
void TearDown() GRPC_OVERRIDE { server_->Shutdown(); }
void ResetStub() {
channel_ = CreateChannel(server_address_.str(), InsecureCredentials(),
ChannelArguments());
stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel_));
}
std::shared_ptr<ChannelInterface> channel_;
std::unique_ptr<grpc::cpp::test::util::TestService::Stub> stub_;
std::unique_ptr<Server> server_;
std::ostringstream server_address_;
TestServiceImpl service_;
ThreadPool thread_pool_;
};
// Send a rpc with a normal stub and then a CliCall. Verify they match.
TEST_F(CliCallTest, SimpleRpc) {
ResetStub();
// Normal stub.
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
ClientContext context;
Status s = stub_->Echo(&context, request, &response);
EXPECT_EQ(response.message(), request.message());
EXPECT_TRUE(s.IsOk());
const grpc::string kMethod("/grpc.cpp.test.util.TestService/Echo");
grpc::string request_bin, response_bin, expected_response_bin;
EXPECT_TRUE(request.SerializeToString(&request_bin));
EXPECT_TRUE(response.SerializeToString(&expected_response_bin));
CliCall::Call(channel_, kMethod, request_bin, &response_bin);
EXPECT_EQ(expected_response_bin, response_bin);
}
} // namespace testing
} // namespace grpc
int main(int argc, char** argv) {
grpc_test_init(argc, argv);
grpc_init();
::testing::InitGoogleTest(&argc, argv);
int result = RUN_ALL_TESTS();
grpc_shutdown();
return result;
}

79
test/cpp/util/grpc_cli.cc
Unescape View File

@ -62,19 +62,13 @@
#include <sstream>
#include <gflags/gflags.h>
#include <grpc++/byte_buffer.h>
#include "test/cpp/util/cli_call.h"
#include <grpc++/channel_arguments.h>
#include <grpc++/channel_interface.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/credentials.h>
#include <grpc++/generic_stub.h>
#include <grpc++/status.h>
#include <grpc++/stream.h>
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/slice.h>
// In some distros, gflags is in the namespace google, and in some others,
// in gflags. This hack is enabling us to find both.
@ -90,63 +84,6 @@ DEFINE_string(input_binary_file, "",
DEFINE_string(output_binary_file, "output.bin",
"Path to output file to write serialized response.");
void* tag(int i) { return (void*)(gpr_intptr) i; }
void Call(std::shared_ptr<grpc::ChannelInterface> channel,
const grpc::string& method) {
std::unique_ptr<grpc::GenericStub> stub(new grpc::GenericStub(channel));
grpc::ClientContext ctx;
grpc::CompletionQueue cq;
std::unique_ptr<grpc::GenericClientAsyncReaderWriter> call(
stub->Call(&ctx, method, &cq, tag(1)));
void* got_tag;
bool ok;
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
std::ifstream input_file(FLAGS_input_binary_file,
std::ios::in | std::ios::binary);
std::stringstream input_stream;
input_stream << input_file.rdbuf();
gpr_slice s = gpr_slice_from_copied_string(input_stream.str().c_str());
grpc::Slice req_slice(s, grpc::Slice::STEAL_REF);
grpc::ByteBuffer request(&req_slice, 1);
call->Write(request, tag(2));
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
call->WritesDone(tag(3));
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
grpc::ByteBuffer recv_buffer;
call->Read(&recv_buffer, tag(4));
cq.Next(&got_tag, &ok);
if (!ok) {
std::cout << "Failed to read response." << std::endl;
return;
}
grpc::Status status;
call->Finish(&status, tag(5));
cq.Next(&got_tag, &ok);
GPR_ASSERT(ok);
if (status.IsOk()) {
std::cout << "RPC finished with OK status." << std::endl;
std::vector<grpc::Slice> slices;
recv_buffer.Dump(&slices);
std::ofstream output_file(FLAGS_output_binary_file,
std::ios::trunc | std::ios::binary);
for (size_t i = 0; i < slices.size(); i++) {
output_file.write(reinterpret_cast<const char*>(slices[i].begin()),
slices[i].size());
}
} else {
std::cout << "RPC finished with status code " << status.code()
<< " details: " << status.details() << std::endl;
}
}
int main(int argc, char** argv) {
grpc_init();
@ -160,6 +97,7 @@ int main(int argc, char** argv) {
<< std::endl;
}
grpc::string server_address(argv[2]);
// TODO(yangg) basic check of method string
grpc::string method(argv[3]);
if (FLAGS_input_binary_file.empty()) {
@ -169,7 +107,10 @@ int main(int argc, char** argv) {
}
std::cout << "connecting to " << server_address << std::endl;
// TODO(yangg) basic check of method string
std::ifstream input_file(FLAGS_input_binary_file,
std::ios::in | std::ios::binary);
std::stringstream input_stream;
input_stream << input_file.rdbuf();
std::unique_ptr<grpc::Credentials> creds;
if (!FLAGS_enable_ssl) {
@ -184,7 +125,13 @@ int main(int argc, char** argv) {
std::shared_ptr<grpc::ChannelInterface> channel =
grpc::CreateChannel(server_address, creds, grpc::ChannelArguments());
Call(channel, method);
grpc::string response;
grpc::testing::CliCall::Call(channel, method, input_stream.str(), &response);
if (!response.empty()) {
std::ofstream output_file(FLAGS_output_binary_file,
std::ios::trunc | std::ios::binary);
output_file << response;
}
channel.reset();
grpc_shutdown();

5
tools/run_tests/tests.json
Unescape View File

@ -346,6 +346,11 @@
"language": "c++",
"name": "channel_arguments_test"
},
{
"flaky": false,
"language": "c++",
"name": "cli_call_test"
},
{
"flaky": false,
"language": "c++",

Write Preview
Loading…
Cancel
Save