mirror of https://github.com/grpc/grpc.git
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)
https://grpc.io/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
978 lines
35 KiB
978 lines
35 KiB
// |
|
// |
|
// Copyright 2016 gRPC authors. |
|
// |
|
// Licensed under the Apache License, Version 2.0 (the "License"); |
|
// you may not use this file except in compliance with the License. |
|
// You may obtain a copy of the License at |
|
// |
|
// http://www.apache.org/licenses/LICENSE-2.0 |
|
// |
|
// Unless required by applicable law or agreed to in writing, software |
|
// distributed under the License is distributed on an "AS IS" BASIS, |
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
// See the License for the specific language governing permissions and |
|
// limitations under the License. |
|
// |
|
// |
|
|
|
#include <memory> |
|
#include <thread> |
|
|
|
#include <gtest/gtest.h> |
|
|
|
#include "absl/log/check.h" |
|
|
|
#include <grpc/grpc.h> |
|
#include <grpcpp/channel.h> |
|
#include <grpcpp/client_context.h> |
|
#include <grpcpp/create_channel.h> |
|
#include <grpcpp/generic/async_generic_service.h> |
|
#include <grpcpp/server.h> |
|
#include <grpcpp/server_builder.h> |
|
#include <grpcpp/server_context.h> |
|
|
|
#include "src/core/lib/gprpp/env.h" |
|
#include "src/core/lib/iomgr/iomgr.h" |
|
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h" |
|
#include "src/proto/grpc/testing/echo.grpc.pb.h" |
|
#include "test/core/test_util/port.h" |
|
#include "test/core/test_util/test_config.h" |
|
#include "test/cpp/end2end/test_service_impl.h" |
|
#include "test/cpp/util/byte_buffer_proto_helper.h" |
|
|
|
namespace grpc { |
|
namespace testing { |
|
namespace { |
|
|
|
void* tag(int i) { return reinterpret_cast<void*>(i); } |
|
|
|
bool VerifyReturnSuccess(CompletionQueue* cq, int i) { |
|
void* got_tag; |
|
bool ok; |
|
EXPECT_TRUE(cq->Next(&got_tag, &ok)); |
|
EXPECT_EQ(tag(i), got_tag); |
|
return ok; |
|
} |
|
|
|
void Verify(CompletionQueue* cq, int i, bool expect_ok) { |
|
EXPECT_EQ(expect_ok, VerifyReturnSuccess(cq, i)); |
|
} |
|
|
|
// Handlers to handle async request at a server. To be run in a separate thread. |
|
template <class Service> |
|
void HandleEcho(Service* service, ServerCompletionQueue* cq, bool dup_service) { |
|
ServerContext srv_ctx; |
|
grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx); |
|
EchoRequest recv_request; |
|
EchoResponse send_response; |
|
service->RequestEcho(&srv_ctx, &recv_request, &response_writer, cq, cq, |
|
tag(1)); |
|
Verify(cq, 1, true); |
|
send_response.set_message(recv_request.message()); |
|
if (dup_service) { |
|
send_response.mutable_message()->append("_dup"); |
|
} |
|
response_writer.Finish(send_response, Status::OK, tag(2)); |
|
Verify(cq, 2, true); |
|
} |
|
|
|
// Handlers to handle raw request at a server. To be run in a |
|
// separate thread. Note that this is the same as the async version, except |
|
// that the req/resp are ByteBuffers |
|
template <class Service> |
|
void HandleRawEcho(Service* service, ServerCompletionQueue* cq, |
|
bool /*dup_service*/) { |
|
ServerContext srv_ctx; |
|
GenericServerAsyncResponseWriter response_writer(&srv_ctx); |
|
ByteBuffer recv_buffer; |
|
service->RequestEcho(&srv_ctx, &recv_buffer, &response_writer, cq, cq, |
|
tag(1)); |
|
Verify(cq, 1, true); |
|
EchoRequest recv_request; |
|
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request)); |
|
EchoResponse send_response; |
|
send_response.set_message(recv_request.message()); |
|
auto send_buffer = SerializeToByteBuffer(&send_response); |
|
response_writer.Finish(*send_buffer, Status::OK, tag(2)); |
|
Verify(cq, 2, true); |
|
} |
|
|
|
template <class Service> |
|
void HandleClientStreaming(Service* service, ServerCompletionQueue* cq) { |
|
ServerContext srv_ctx; |
|
EchoRequest recv_request; |
|
EchoResponse send_response; |
|
ServerAsyncReader<EchoResponse, EchoRequest> srv_stream(&srv_ctx); |
|
service->RequestRequestStream(&srv_ctx, &srv_stream, cq, cq, tag(1)); |
|
Verify(cq, 1, true); |
|
int i = 1; |
|
do { |
|
i++; |
|
send_response.mutable_message()->append(recv_request.message()); |
|
srv_stream.Read(&recv_request, tag(i)); |
|
} while (VerifyReturnSuccess(cq, i)); |
|
srv_stream.Finish(send_response, Status::OK, tag(100)); |
|
Verify(cq, 100, true); |
|
} |
|
|
|
template <class Service> |
|
void HandleRawClientStreaming(Service* service, ServerCompletionQueue* cq) { |
|
ServerContext srv_ctx; |
|
ByteBuffer recv_buffer; |
|
EchoRequest recv_request; |
|
EchoResponse send_response; |
|
GenericServerAsyncReader srv_stream(&srv_ctx); |
|
service->RequestRequestStream(&srv_ctx, &srv_stream, cq, cq, tag(1)); |
|
Verify(cq, 1, true); |
|
int i = 1; |
|
while (true) { |
|
i++; |
|
srv_stream.Read(&recv_buffer, tag(i)); |
|
if (!VerifyReturnSuccess(cq, i)) { |
|
break; |
|
} |
|
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request)); |
|
send_response.mutable_message()->append(recv_request.message()); |
|
} |
|
auto send_buffer = SerializeToByteBuffer(&send_response); |
|
srv_stream.Finish(*send_buffer, Status::OK, tag(100)); |
|
Verify(cq, 100, true); |
|
} |
|
|
|
template <class Service> |
|
void HandleServerStreaming(Service* service, ServerCompletionQueue* cq) { |
|
ServerContext srv_ctx; |
|
EchoRequest recv_request; |
|
EchoResponse send_response; |
|
ServerAsyncWriter<EchoResponse> srv_stream(&srv_ctx); |
|
service->RequestResponseStream(&srv_ctx, &recv_request, &srv_stream, cq, cq, |
|
tag(1)); |
|
Verify(cq, 1, true); |
|
send_response.set_message(recv_request.message() + "0"); |
|
srv_stream.Write(send_response, tag(2)); |
|
Verify(cq, 2, true); |
|
send_response.set_message(recv_request.message() + "1"); |
|
srv_stream.Write(send_response, tag(3)); |
|
Verify(cq, 3, true); |
|
send_response.set_message(recv_request.message() + "2"); |
|
srv_stream.Write(send_response, tag(4)); |
|
Verify(cq, 4, true); |
|
srv_stream.Finish(Status::OK, tag(5)); |
|
Verify(cq, 5, true); |
|
} |
|
|
|
void HandleGenericEcho(GenericServerAsyncReaderWriter* stream, |
|
CompletionQueue* cq) { |
|
ByteBuffer recv_buffer; |
|
stream->Read(&recv_buffer, tag(2)); |
|
Verify(cq, 2, true); |
|
EchoRequest recv_request; |
|
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request)); |
|
EchoResponse send_response; |
|
send_response.set_message(recv_request.message()); |
|
auto send_buffer = SerializeToByteBuffer(&send_response); |
|
stream->Write(*send_buffer, tag(3)); |
|
Verify(cq, 3, true); |
|
stream->Finish(Status::OK, tag(4)); |
|
Verify(cq, 4, true); |
|
} |
|
|
|
void HandleGenericRequestStream(GenericServerAsyncReaderWriter* stream, |
|
CompletionQueue* cq) { |
|
ByteBuffer recv_buffer; |
|
EchoRequest recv_request; |
|
EchoResponse send_response; |
|
int i = 1; |
|
while (true) { |
|
i++; |
|
stream->Read(&recv_buffer, tag(i)); |
|
if (!VerifyReturnSuccess(cq, i)) { |
|
break; |
|
} |
|
EXPECT_TRUE(ParseFromByteBuffer(&recv_buffer, &recv_request)); |
|
send_response.mutable_message()->append(recv_request.message()); |
|
} |
|
auto send_buffer = SerializeToByteBuffer(&send_response); |
|
stream->Write(*send_buffer, tag(99)); |
|
Verify(cq, 99, true); |
|
stream->Finish(Status::OK, tag(100)); |
|
Verify(cq, 100, true); |
|
} |
|
|
|
// Request and handle one generic call. |
|
void HandleGenericCall(AsyncGenericService* service, |
|
ServerCompletionQueue* cq) { |
|
GenericServerContext srv_ctx; |
|
GenericServerAsyncReaderWriter stream(&srv_ctx); |
|
service->RequestCall(&srv_ctx, &stream, cq, cq, tag(1)); |
|
Verify(cq, 1, true); |
|
if (srv_ctx.method() == "/grpc.testing.EchoTestService/Echo") { |
|
HandleGenericEcho(&stream, cq); |
|
} else if (srv_ctx.method() == |
|
"/grpc.testing.EchoTestService/RequestStream") { |
|
HandleGenericRequestStream(&stream, cq); |
|
} else { // other methods not handled yet. |
|
gpr_log(GPR_ERROR, "method: %s", srv_ctx.method().c_str()); |
|
CHECK(0); |
|
} |
|
} |
|
|
|
class TestServiceImplDupPkg |
|
: public grpc::testing::duplicate::EchoTestService::Service { |
|
public: |
|
Status Echo(ServerContext* /*context*/, const EchoRequest* request, |
|
EchoResponse* response) override { |
|
response->set_message(request->message() + "_dup"); |
|
return Status::OK; |
|
} |
|
}; |
|
|
|
class HybridEnd2endTest : public ::testing::TestWithParam<bool> { |
|
protected: |
|
HybridEnd2endTest() {} |
|
|
|
static void SetUpTestSuite() { |
|
#if TARGET_OS_IPHONE |
|
// Workaround Apple CFStream bug |
|
grpc_core::SetEnv("grpc_cfstream", "0"); |
|
#endif |
|
} |
|
|
|
void SetUp() override { |
|
inproc_ = (::testing::UnitTest::GetInstance() |
|
->current_test_info() |
|
->value_param() != nullptr) |
|
? GetParam() |
|
: false; |
|
} |
|
|
|
bool SetUpServer(grpc::Service* service1, grpc::Service* service2, |
|
AsyncGenericService* generic_service, |
|
CallbackGenericService* callback_generic_service, |
|
int max_message_size = 0) { |
|
int port = grpc_pick_unused_port_or_die(); |
|
server_address_ << "localhost:" << port; |
|
|
|
// Setup server |
|
ServerBuilder builder; |
|
builder.AddListeningPort(server_address_.str(), |
|
grpc::InsecureServerCredentials()); |
|
// Always add a sync unimplemented service: we rely on having at least one |
|
// synchronous method to get a listening cq |
|
builder.RegisterService(&unimplemented_service_); |
|
builder.RegisterService(service1); |
|
if (service2) { |
|
builder.RegisterService(service2); |
|
} |
|
if (generic_service) { |
|
builder.RegisterAsyncGenericService(generic_service); |
|
} |
|
if (callback_generic_service) { |
|
builder.RegisterCallbackGenericService(callback_generic_service); |
|
} |
|
|
|
if (max_message_size != 0) { |
|
builder.SetMaxMessageSize(max_message_size); |
|
} |
|
|
|
// Create a separate cq for each potential handler. |
|
for (int i = 0; i < 5; i++) { |
|
cqs_.push_back(builder.AddCompletionQueue(false)); |
|
} |
|
server_ = builder.BuildAndStart(); |
|
|
|
// If there is a generic callback service, this setup is only successful if |
|
// we have an iomgr that can run in the background or are inprocess |
|
return !callback_generic_service || grpc_iomgr_run_in_background() || |
|
inproc_; |
|
} |
|
|
|
void TearDown() override { |
|
if (server_) { |
|
server_->Shutdown(); |
|
} |
|
void* ignored_tag; |
|
bool ignored_ok; |
|
for (auto it = cqs_.begin(); it != cqs_.end(); ++it) { |
|
(*it)->Shutdown(); |
|
while ((*it)->Next(&ignored_tag, &ignored_ok)) { |
|
} |
|
} |
|
} |
|
|
|
void ResetStub() { |
|
std::shared_ptr<Channel> channel = |
|
inproc_ ? server_->InProcessChannel(ChannelArguments()) |
|
: grpc::CreateChannel(server_address_.str(), |
|
InsecureChannelCredentials()); |
|
stub_ = grpc::testing::EchoTestService::NewStub(channel); |
|
} |
|
|
|
// Test all rpc methods. |
|
void TestAllMethods() { |
|
SendEcho(); |
|
SendSimpleClientStreaming(); |
|
SendSimpleServerStreaming(); |
|
SendBidiStreaming(); |
|
} |
|
|
|
void SendEcho() { |
|
EchoRequest send_request; |
|
EchoResponse recv_response; |
|
ClientContext cli_ctx; |
|
cli_ctx.set_wait_for_ready(true); |
|
send_request.set_message("Hello"); |
|
Status recv_status = stub_->Echo(&cli_ctx, send_request, &recv_response); |
|
EXPECT_EQ(send_request.message(), recv_response.message()); |
|
EXPECT_TRUE(recv_status.ok()); |
|
} |
|
|
|
void SendEchoToDupService() { |
|
std::shared_ptr<Channel> channel = grpc::CreateChannel( |
|
server_address_.str(), InsecureChannelCredentials()); |
|
auto stub = grpc::testing::duplicate::EchoTestService::NewStub(channel); |
|
EchoRequest send_request; |
|
EchoResponse recv_response; |
|
ClientContext cli_ctx; |
|
cli_ctx.set_wait_for_ready(true); |
|
send_request.set_message("Hello"); |
|
Status recv_status = stub->Echo(&cli_ctx, send_request, &recv_response); |
|
EXPECT_EQ(send_request.message() + "_dup", recv_response.message()); |
|
EXPECT_TRUE(recv_status.ok()); |
|
} |
|
|
|
void SendSimpleClientStreaming() { |
|
EchoRequest send_request; |
|
EchoResponse recv_response; |
|
std::string expected_message; |
|
ClientContext cli_ctx; |
|
cli_ctx.set_wait_for_ready(true); |
|
send_request.set_message("Hello"); |
|
auto stream = stub_->RequestStream(&cli_ctx, &recv_response); |
|
for (int i = 0; i < 5; i++) { |
|
EXPECT_TRUE(stream->Write(send_request)); |
|
expected_message.append(send_request.message()); |
|
} |
|
stream->WritesDone(); |
|
Status recv_status = stream->Finish(); |
|
EXPECT_EQ(expected_message, recv_response.message()); |
|
EXPECT_TRUE(recv_status.ok()); |
|
} |
|
|
|
void SendSimpleServerStreaming() { |
|
EchoRequest request; |
|
EchoResponse response; |
|
ClientContext context; |
|
context.set_wait_for_ready(true); |
|
request.set_message("hello"); |
|
|
|
auto stream = stub_->ResponseStream(&context, request); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message() + "0"); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message() + "1"); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message() + "2"); |
|
EXPECT_FALSE(stream->Read(&response)); |
|
|
|
Status s = stream->Finish(); |
|
EXPECT_TRUE(s.ok()); |
|
} |
|
|
|
void SendSimpleServerStreamingToDupService() { |
|
std::shared_ptr<Channel> channel = grpc::CreateChannel( |
|
server_address_.str(), InsecureChannelCredentials()); |
|
auto stub = grpc::testing::duplicate::EchoTestService::NewStub(channel); |
|
EchoRequest request; |
|
EchoResponse response; |
|
ClientContext context; |
|
context.set_wait_for_ready(true); |
|
request.set_message("hello"); |
|
|
|
auto stream = stub->ResponseStream(&context, request); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message() + "0_dup"); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message() + "1_dup"); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message() + "2_dup"); |
|
EXPECT_FALSE(stream->Read(&response)); |
|
|
|
Status s = stream->Finish(); |
|
EXPECT_TRUE(s.ok()); |
|
} |
|
|
|
void SendBidiStreaming() { |
|
EchoRequest request; |
|
EchoResponse response; |
|
ClientContext context; |
|
context.set_wait_for_ready(true); |
|
std::string msg("hello"); |
|
|
|
auto stream = stub_->BidiStream(&context); |
|
|
|
request.set_message(msg + "0"); |
|
EXPECT_TRUE(stream->Write(request)); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message()); |
|
|
|
request.set_message(msg + "1"); |
|
EXPECT_TRUE(stream->Write(request)); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message()); |
|
|
|
request.set_message(msg + "2"); |
|
EXPECT_TRUE(stream->Write(request)); |
|
EXPECT_TRUE(stream->Read(&response)); |
|
EXPECT_EQ(response.message(), request.message()); |
|
|
|
stream->WritesDone(); |
|
EXPECT_FALSE(stream->Read(&response)); |
|
EXPECT_FALSE(stream->Read(&response)); |
|
|
|
Status s = stream->Finish(); |
|
EXPECT_TRUE(s.ok()); |
|
} |
|
|
|
grpc::testing::UnimplementedEchoService::Service unimplemented_service_; |
|
std::vector<std::unique_ptr<ServerCompletionQueue>> cqs_; |
|
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_; |
|
std::unique_ptr<Server> server_; |
|
std::ostringstream server_address_; |
|
bool inproc_; |
|
}; |
|
|
|
TEST_F(HybridEnd2endTest, AsyncEcho) { |
|
typedef EchoTestService::WithAsyncMethod_Echo<TestServiceImpl> SType; |
|
SType service; |
|
SetUpServer(&service, nullptr, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread echo_handler_thread(HandleEcho<SType>, &service, cqs_[0].get(), |
|
false); |
|
TestAllMethods(); |
|
echo_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, RawEcho) { |
|
typedef EchoTestService::WithRawMethod_Echo<TestServiceImpl> SType; |
|
SType service; |
|
SetUpServer(&service, nullptr, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread echo_handler_thread(HandleRawEcho<SType>, &service, cqs_[0].get(), |
|
false); |
|
TestAllMethods(); |
|
echo_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, RawRequestStream) { |
|
typedef EchoTestService::WithRawMethod_RequestStream<TestServiceImpl> SType; |
|
SType service; |
|
SetUpServer(&service, nullptr, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread request_stream_handler_thread(HandleRawClientStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
TestAllMethods(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, AsyncEchoRawRequestStream) { |
|
typedef EchoTestService::WithRawMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_Echo<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
SetUpServer(&service, nullptr, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread echo_handler_thread(HandleEcho<SType>, &service, cqs_[0].get(), |
|
false); |
|
std::thread request_stream_handler_thread(HandleRawClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
request_stream_handler_thread.join(); |
|
echo_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, GenericEchoRawRequestStream) { |
|
typedef EchoTestService::WithRawMethod_RequestStream< |
|
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
AsyncGenericService generic_service; |
|
SetUpServer(&service, nullptr, &generic_service, nullptr); |
|
ResetStub(); |
|
std::thread generic_handler_thread(HandleGenericCall, &generic_service, |
|
cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleRawClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
generic_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, AsyncEchoRequestStream) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_Echo<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
SetUpServer(&service, nullptr, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread echo_handler_thread(HandleEcho<SType>, &service, cqs_[0].get(), |
|
false); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
echo_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, AsyncRequestStreamResponseStream) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
SetUpServer(&service, nullptr, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service with one sync method. |
|
TEST_F(HybridEnd2endTest, AsyncRequestStreamResponseStreamSyncDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
TestServiceImplDupPkg dup_service; |
|
SetUpServer(&service, &dup_service, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
SendEchoToDupService(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service with one sync streamed unary method. |
|
class StreamedUnaryDupPkg |
|
: public duplicate::EchoTestService::WithStreamedUnaryMethod_Echo< |
|
TestServiceImplDupPkg> { |
|
public: |
|
Status StreamedEcho( |
|
ServerContext* /*context*/, |
|
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override { |
|
EchoRequest req; |
|
EchoResponse resp; |
|
uint32_t next_msg_sz; |
|
stream->NextMessageSize(&next_msg_sz); |
|
gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz); |
|
CHECK(stream->Read(&req)); |
|
resp.set_message(req.message() + "_dup"); |
|
CHECK(stream->Write(resp)); |
|
return Status::OK; |
|
} |
|
}; |
|
|
|
TEST_F(HybridEnd2endTest, |
|
AsyncRequestStreamResponseStreamSyncStreamedUnaryDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
StreamedUnaryDupPkg dup_service; |
|
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
SendEchoToDupService(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service that is fully Streamed Unary |
|
class FullyStreamedUnaryDupPkg |
|
: public duplicate::EchoTestService::StreamedUnaryService { |
|
public: |
|
Status StreamedEcho( |
|
ServerContext* /*context*/, |
|
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override { |
|
EchoRequest req; |
|
EchoResponse resp; |
|
uint32_t next_msg_sz; |
|
stream->NextMessageSize(&next_msg_sz); |
|
gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz); |
|
CHECK(stream->Read(&req)); |
|
resp.set_message(req.message() + "_dup"); |
|
CHECK(stream->Write(resp)); |
|
return Status::OK; |
|
} |
|
}; |
|
|
|
TEST_F(HybridEnd2endTest, |
|
AsyncRequestStreamResponseStreamSyncFullyStreamedUnaryDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
FullyStreamedUnaryDupPkg dup_service; |
|
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
SendEchoToDupService(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service with one sync split server streaming method. |
|
class SplitResponseStreamDupPkg |
|
: public duplicate::EchoTestService:: |
|
WithSplitStreamingMethod_ResponseStream<TestServiceImplDupPkg> { |
|
public: |
|
Status StreamedResponseStream( |
|
ServerContext* /*context*/, |
|
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override { |
|
EchoRequest req; |
|
EchoResponse resp; |
|
uint32_t next_msg_sz; |
|
stream->NextMessageSize(&next_msg_sz); |
|
gpr_log(GPR_INFO, "Split Streamed Next Message Size is %u", next_msg_sz); |
|
CHECK(stream->Read(&req)); |
|
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) { |
|
resp.set_message(req.message() + std::to_string(i) + "_dup"); |
|
CHECK(stream->Write(resp)); |
|
} |
|
return Status::OK; |
|
} |
|
}; |
|
|
|
TEST_F(HybridEnd2endTest, |
|
AsyncRequestStreamResponseStreamSyncSplitStreamedDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
SplitResponseStreamDupPkg dup_service; |
|
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
SendSimpleServerStreamingToDupService(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service that is fully split server streamed |
|
class FullySplitStreamedDupPkg |
|
: public duplicate::EchoTestService::SplitStreamedService { |
|
public: |
|
Status StreamedResponseStream( |
|
ServerContext* /*context*/, |
|
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override { |
|
EchoRequest req; |
|
EchoResponse resp; |
|
uint32_t next_msg_sz; |
|
stream->NextMessageSize(&next_msg_sz); |
|
gpr_log(GPR_INFO, "Split Streamed Next Message Size is %u", next_msg_sz); |
|
CHECK(stream->Read(&req)); |
|
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) { |
|
resp.set_message(req.message() + std::to_string(i) + "_dup"); |
|
CHECK(stream->Write(resp)); |
|
} |
|
return Status::OK; |
|
} |
|
}; |
|
|
|
TEST_F(HybridEnd2endTest, |
|
asyncRequestStreamResponseStreamFullySplitStreamedDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
FullySplitStreamedDupPkg dup_service; |
|
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
SendSimpleServerStreamingToDupService(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service that is fully server streamed |
|
class FullyStreamedDupPkg : public duplicate::EchoTestService::StreamedService { |
|
public: |
|
Status StreamedEcho( |
|
ServerContext* /*context*/, |
|
ServerUnaryStreamer<EchoRequest, EchoResponse>* stream) override { |
|
EchoRequest req; |
|
EchoResponse resp; |
|
uint32_t next_msg_sz; |
|
stream->NextMessageSize(&next_msg_sz); |
|
gpr_log(GPR_INFO, "Streamed Unary Next Message Size is %u", next_msg_sz); |
|
CHECK(stream->Read(&req)); |
|
resp.set_message(req.message() + "_dup"); |
|
CHECK(stream->Write(resp)); |
|
return Status::OK; |
|
} |
|
Status StreamedResponseStream( |
|
ServerContext* /*context*/, |
|
ServerSplitStreamer<EchoRequest, EchoResponse>* stream) override { |
|
EchoRequest req; |
|
EchoResponse resp; |
|
uint32_t next_msg_sz; |
|
stream->NextMessageSize(&next_msg_sz); |
|
gpr_log(GPR_INFO, "Split Streamed Next Message Size is %u", next_msg_sz); |
|
CHECK(stream->Read(&req)); |
|
for (int i = 0; i < kServerDefaultResponseStreamsToSend; i++) { |
|
resp.set_message(req.message() + std::to_string(i) + "_dup"); |
|
CHECK(stream->Write(resp)); |
|
} |
|
return Status::OK; |
|
} |
|
}; |
|
|
|
TEST_F(HybridEnd2endTest, |
|
AsyncRequestStreamResponseStreamFullyStreamedDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
FullyStreamedDupPkg dup_service; |
|
SetUpServer(&service, &dup_service, nullptr, nullptr, 8192); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
SendEchoToDupService(); |
|
SendSimpleServerStreamingToDupService(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service with one async method. |
|
TEST_F(HybridEnd2endTest, AsyncRequestStreamResponseStreamAsyncDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
duplicate::EchoTestService::AsyncService dup_service; |
|
SetUpServer(&service, &dup_service, nullptr, nullptr); |
|
ResetStub(); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
std::thread echo_handler_thread( |
|
HandleEcho<duplicate::EchoTestService::AsyncService>, &dup_service, |
|
cqs_[2].get(), true); |
|
TestAllMethods(); |
|
SendEchoToDupService(); |
|
response_stream_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
echo_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, GenericEcho) { |
|
EchoTestService::WithGenericMethod_Echo<TestServiceImpl> service; |
|
AsyncGenericService generic_service; |
|
SetUpServer(&service, nullptr, &generic_service, nullptr); |
|
ResetStub(); |
|
std::thread generic_handler_thread(HandleGenericCall, &generic_service, |
|
cqs_[0].get()); |
|
TestAllMethods(); |
|
generic_handler_thread.join(); |
|
} |
|
|
|
TEST_P(HybridEnd2endTest, CallbackGenericEcho) { |
|
EchoTestService::WithGenericMethod_Echo<TestServiceImpl> service; |
|
class GenericEchoService : public CallbackGenericService { |
|
private: |
|
ServerGenericBidiReactor* CreateReactor( |
|
GenericCallbackServerContext* context) override { |
|
EXPECT_EQ(context->method(), "/grpc.testing.EchoTestService/Echo"); |
|
gpr_log(GPR_DEBUG, "Constructor of generic service %d", |
|
static_cast<int>(context->deadline().time_since_epoch().count())); |
|
|
|
class Reactor : public ServerGenericBidiReactor { |
|
public: |
|
Reactor() { StartRead(&request_); } |
|
|
|
private: |
|
void OnDone() override { delete this; } |
|
void OnReadDone(bool ok) override { |
|
if (!ok) { |
|
EXPECT_EQ(reads_complete_, 1); |
|
} else { |
|
EXPECT_EQ(reads_complete_++, 0); |
|
response_ = request_; |
|
StartWrite(&response_); |
|
StartRead(&request_); |
|
} |
|
} |
|
void OnWriteDone(bool ok) override { |
|
Finish(ok ? Status::OK |
|
: Status(StatusCode::UNKNOWN, "Unexpected failure")); |
|
} |
|
ByteBuffer request_; |
|
ByteBuffer response_; |
|
std::atomic_int reads_complete_{0}; |
|
}; |
|
return new Reactor; |
|
} |
|
} generic_service; |
|
|
|
if (!SetUpServer(&service, nullptr, nullptr, &generic_service)) { |
|
return; |
|
} |
|
ResetStub(); |
|
TestAllMethods(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStream) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
AsyncGenericService generic_service; |
|
SetUpServer(&service, nullptr, &generic_service, nullptr); |
|
ResetStub(); |
|
std::thread generic_handler_thread(HandleGenericCall, &generic_service, |
|
cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
generic_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service with one sync method. |
|
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStreamSyncDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
AsyncGenericService generic_service; |
|
TestServiceImplDupPkg dup_service; |
|
SetUpServer(&service, &dup_service, &generic_service, nullptr); |
|
ResetStub(); |
|
std::thread generic_handler_thread(HandleGenericCall, &generic_service, |
|
cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
TestAllMethods(); |
|
SendEchoToDupService(); |
|
generic_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
} |
|
|
|
// Add a second service with one async method. |
|
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStreamAsyncDupService) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithGenericMethod_Echo<TestServiceImpl>> |
|
SType; |
|
SType service; |
|
AsyncGenericService generic_service; |
|
duplicate::EchoTestService::AsyncService dup_service; |
|
SetUpServer(&service, &dup_service, &generic_service, nullptr); |
|
ResetStub(); |
|
std::thread generic_handler_thread(HandleGenericCall, &generic_service, |
|
cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
std::thread echo_handler_thread( |
|
HandleEcho<duplicate::EchoTestService::AsyncService>, &dup_service, |
|
cqs_[2].get(), true); |
|
TestAllMethods(); |
|
SendEchoToDupService(); |
|
generic_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
echo_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, GenericEchoAsyncRequestStreamResponseStream) { |
|
typedef EchoTestService::WithAsyncMethod_RequestStream< |
|
EchoTestService::WithGenericMethod_Echo< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>> |
|
SType; |
|
SType service; |
|
AsyncGenericService generic_service; |
|
SetUpServer(&service, nullptr, &generic_service, nullptr); |
|
ResetStub(); |
|
std::thread generic_handler_thread(HandleGenericCall, &generic_service, |
|
cqs_[0].get()); |
|
std::thread request_stream_handler_thread(HandleClientStreaming<SType>, |
|
&service, cqs_[1].get()); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[2].get()); |
|
TestAllMethods(); |
|
generic_handler_thread.join(); |
|
request_stream_handler_thread.join(); |
|
response_stream_handler_thread.join(); |
|
} |
|
|
|
TEST_F(HybridEnd2endTest, GenericEchoRequestStreamAsyncResponseStream) { |
|
typedef EchoTestService::WithGenericMethod_RequestStream< |
|
EchoTestService::WithGenericMethod_Echo< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>> |
|
SType; |
|
SType service; |
|
AsyncGenericService generic_service; |
|
SetUpServer(&service, nullptr, &generic_service, nullptr); |
|
ResetStub(); |
|
std::thread generic_handler_thread(HandleGenericCall, &generic_service, |
|
cqs_[0].get()); |
|
std::thread generic_handler_thread2(HandleGenericCall, &generic_service, |
|
cqs_[1].get()); |
|
std::thread response_stream_handler_thread(HandleServerStreaming<SType>, |
|
&service, cqs_[2].get()); |
|
TestAllMethods(); |
|
generic_handler_thread.join(); |
|
generic_handler_thread2.join(); |
|
response_stream_handler_thread.join(); |
|
} |
|
|
|
// If WithGenericMethod is called and no generic service is registered, the |
|
// server will fail to build. |
|
TEST_F(HybridEnd2endTest, GenericMethodWithoutGenericService) { |
|
EchoTestService::WithGenericMethod_RequestStream< |
|
EchoTestService::WithGenericMethod_Echo< |
|
EchoTestService::WithAsyncMethod_ResponseStream<TestServiceImpl>>> |
|
service; |
|
SetUpServer(&service, nullptr, nullptr, nullptr); |
|
EXPECT_EQ(nullptr, server_.get()); |
|
} |
|
|
|
INSTANTIATE_TEST_SUITE_P(HybridEnd2endTest, HybridEnd2endTest, |
|
::testing::Bool()); |
|
|
|
} // namespace |
|
} // namespace testing |
|
} // namespace grpc |
|
|
|
int main(int argc, char** argv) { |
|
grpc::testing::TestEnvironment env(&argc, argv); |
|
::testing::InitGoogleTest(&argc, argv); |
|
return RUN_ALL_TESTS(); |
|
}
|
|
|