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.
 
 
 
 
 
 

595 lines
19 KiB

/*
*
* Copyright 2019 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.
*
*/
#import <Cronet/Cronet.h>
#import <XCTest/XCTest.h>
#import <grpc/grpc_cronet.h>
#import <grpcpp/create_channel.h>
#import <grpcpp/impl/codegen/client_context.h>
#import <grpcpp/impl/codegen/config.h>
#import <grpcpp/resource_quota.h>
#import <grpcpp/security/cronet_credentials.h>
#import <grpcpp/server_builder.h>
#import <grpcpp/server_context.h>
#import <grpcpp/support/client_interceptor.h>
#import <src/proto/grpc/testing/echo.grpc.pb.h>
#import "TestHelper.h"
#import "test/core/end2end/data/ssl_test_data.h"
#import <map>
#import <sstream>
#import <thread>
#import <vector>
using namespace grpc::testing;
using std::chrono::system_clock;
using grpc::Status;
using grpc::ServerContext;
using grpc::ClientContext;
@interface CppCronetEnd2EndTests : XCTestCase
@end
@implementation CppCronetEnd2EndTests {
std::unique_ptr<grpc::Server> _server;
TestServiceImpl _service;
TestServiceImpl _foo_service;
}
// The setUp() function is run before the test cases run and only run once
+ (void)setUp {
[super setUp];
configureCronet();
}
- (void)startServer {
if (_server) {
// server is already running
return;
}
grpc::ServerBuilder builder;
grpc::SslServerCredentialsOptions ssl_opts;
ssl_opts.pem_root_certs = "";
grpc::SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key, test_server1_cert};
ssl_opts.pem_key_cert_pairs.push_back(pkcp);
auto server_creds = SslServerCredentials(ssl_opts);
builder.AddListeningPort("localhost:5000", server_creds);
builder.RegisterService(&_service);
builder.RegisterService("foo.test.youtube.com", &_foo_service);
_server = builder.BuildAndStart();
}
- (void)stopServer {
_server.reset();
}
- (void)restartServer {
[self stopServer];
[self startServer];
}
- (void)setUp {
[self startServer];
}
- (void)sendRPCWithStub:(EchoTestService::Stub*)stub
numRPCs:(int)num_rpcs
withBinaryMetadata:(BOOL)with_binary_metadata {
EchoRequest request;
EchoResponse response;
request.set_message("Hello hello hello hello");
for (int i = 0; i < num_rpcs; ++i) {
ClientContext context;
if (with_binary_metadata) {
char bytes[8] = {'\0', '\1', '\2', '\3', '\4', '\5', '\6', static_cast<char>(i)};
context.AddMetadata("custom-bin", std::string(bytes, 8));
}
context.set_compression_algorithm(GRPC_COMPRESS_GZIP);
Status s = stub->Echo(&context, request, &response);
XCTAssertEqual(response.message(), request.message());
XCTAssertTrue(s.ok());
}
}
- (std::shared_ptr<::grpc::Channel>)getChannel {
stream_engine* cronetEngine = [Cronet getGlobalEngine];
auto cronetChannelCredentials = grpc::CronetChannelCredentials(cronetEngine);
grpc::ChannelArguments args;
args.SetSslTargetNameOverride("foo.test.google.fr");
args.SetUserAgentPrefix("custom_prefix");
args.SetString(GRPC_ARG_SECONDARY_USER_AGENT_STRING, "end2end_test");
auto channel = grpc::CreateCustomChannel("127.0.0.1:5000", cronetChannelCredentials, args);
return channel;
}
- (std::shared_ptr<::grpc::Channel>)getChannelWithInterceptors:
(std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>>)creators {
stream_engine* cronetEngine = [Cronet getGlobalEngine];
auto cronetChannelCredentials = grpc::CronetChannelCredentials(cronetEngine);
grpc::ChannelArguments args;
args.SetSslTargetNameOverride("foo.test.google.fr");
args.SetUserAgentPrefix("custom_prefix");
args.SetString(GRPC_ARG_SECONDARY_USER_AGENT_STRING, "end2end_test");
auto channel = grpc::experimental::CreateCustomChannelWithInterceptors(
"127.0.01:5000", cronetChannelCredentials, args, std::move(creators));
return channel;
}
- (std::unique_ptr<EchoTestService::Stub>)getStub {
auto channel = [self getChannel];
auto stub = EchoTestService::NewStub(channel);
return stub;
}
- (void)testUserAgent {
ClientContext context;
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
request.mutable_param()->set_echo_metadata(true);
auto stub = [self getStub];
Status s = stub->Echo(&context, request, &response);
XCTAssertTrue(s.ok());
const auto& trailing_metadata = context.GetServerTrailingMetadata();
auto iter = trailing_metadata.find("user-agent");
XCTAssert(iter->second.starts_with("custom_prefix grpc-c++"));
}
- (void)testMultipleRPCs {
auto stub = [self getStub];
std::vector<std::thread> threads;
threads.reserve(10);
for (int i = 0; i < 10; ++i) {
threads.emplace_back(
[self, &stub]() { [self sendRPCWithStub:stub.get() numRPCs:10 withBinaryMetadata:NO]; });
}
for (int i = 0; i < 10; ++i) {
threads[i].join();
}
}
- (void)testMultipleRPCsWithBinaryMetadata {
auto stub = [self getStub];
std::vector<std::thread> threads;
threads.reserve(10);
for (int i = 0; i < 10; ++i) {
threads.emplace_back(
[self, &stub]() { [self sendRPCWithStub:stub.get() numRPCs:10 withBinaryMetadata:YES]; });
}
for (int i = 0; i < 10; ++i) {
threads[i].join();
}
}
- (void)testEmptyBinaryMetadata {
EchoRequest request;
EchoResponse response;
request.set_message("Hello hello hello hello");
ClientContext context;
context.AddMetadata("custom-bin", "");
auto stub = [self getStub];
Status s = stub->Echo(&context, request, &response);
XCTAssertEqual(response.message(), request.message());
XCTAssertTrue(s.ok());
}
- (void)testReconnectChannel {
auto stub = [self getStub];
[self sendRPCWithStub:stub.get() numRPCs:1 withBinaryMetadata:NO];
[self restartServer];
[self sendRPCWithStub:stub.get() numRPCs:1 withBinaryMetadata:NO];
}
- (void)testRequestStreamOneRequest {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
auto stream = stub->RequestStream(&context, &response);
request.set_message("hello");
XCTAssertTrue(stream->Write(request));
stream->WritesDone();
Status s = stream->Finish();
XCTAssertEqual(response.message(), request.message());
XCTAssertTrue(s.ok());
XCTAssertTrue(context.debug_error_string().empty());
}
- (void)testRequestStreamOneRequestWithCoalescingApi {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
context.set_initial_metadata_corked(true);
auto stream = stub->RequestStream(&context, &response);
request.set_message("hello");
XCTAssertTrue(stream->Write(request));
stream->WritesDone();
Status s = stream->Finish();
XCTAssertEqual(response.message(), request.message());
XCTAssertTrue(s.ok());
}
- (void)testRequestStreamTwoRequests {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
auto stream = stub->RequestStream(&context, &response);
request.set_message("hello");
XCTAssertTrue(stream->Write(request));
XCTAssertTrue(stream->Write(request));
stream->WritesDone();
Status s = stream->Finish();
XCTAssertEqual(response.message(), "hellohello");
XCTAssertTrue(s.ok());
}
- (void)testResponseStream {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
request.set_message("hello");
auto stream = stub->ResponseStream(&context, request);
for (int i = 0; i < kServerDefaultResponseStreamsToSend; ++i) {
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message() + std::to_string(i));
}
XCTAssertFalse(stream->Read(&response));
Status s = stream->Finish();
XCTAssertTrue(s.ok());
}
- (void)testBidiStream {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
std::string msg("hello");
auto stream = stub->BidiStream(&context);
for (int i = 0; i < kServerDefaultResponseStreamsToSend; ++i) {
request.set_message(msg + std::to_string(i));
XCTAssertTrue(stream->Write(request));
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message());
}
stream->WritesDone();
XCTAssertFalse(stream->Read(&response));
XCTAssertFalse(stream->Read(&response));
Status s = stream->Finish();
XCTAssertTrue(s.ok());
}
- (void)testBidiStreamWithCoalescingApi {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
context.AddMetadata(kServerFinishAfterNReads, "3");
context.set_initial_metadata_corked(true);
std::string msg("hello");
auto stream = stub->BidiStream(&context);
request.set_message(msg + "0");
XCTAssertTrue(stream->Write(request));
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message());
request.set_message(msg + "1");
XCTAssertTrue(stream->Write(request));
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message());
request.set_message(msg + "2");
stream->WriteLast(request, grpc::WriteOptions());
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message());
XCTAssertFalse(stream->Read(&response));
XCTAssertFalse(stream->Read(&response));
Status s = stream->Finish();
XCTAssertTrue(s.ok());
}
- (void)testCancelBeforeStart {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
request.set_message("hello");
context.TryCancel();
Status s = stub->Echo(&context, request, &response);
XCTAssertEqual("", response.message());
XCTAssertEqual(grpc::StatusCode::CANCELLED, s.error_code());
}
- (void)testClientCancelsRequestStream {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
request.set_message("hello");
auto stream = stub->RequestStream(&context, &response);
XCTAssertTrue(stream->Write(request));
XCTAssertTrue(stream->Write(request));
context.TryCancel();
Status s = stream->Finish();
XCTAssertEqual(grpc::StatusCode::CANCELLED, s.error_code());
XCTAssertEqual(response.message(), "");
}
- (void)testClientCancelsResponseStream {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
request.set_message("hello");
auto stream = stub->ResponseStream(&context, request);
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message() + "0");
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message() + "1");
context.TryCancel();
// The cancellation races with responses, so there might be zero or
// one responses pending, read till failure
if (stream->Read(&response)) {
XCTAssertEqual(response.message(), request.message() + "2");
// Since we have cancelled, we expect the next attempt to read to fail
XCTAssertFalse(stream->Read(&response));
}
}
- (void)testlClientCancelsBidiStream {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
std::string msg("hello");
auto stream = stub->BidiStream(&context);
request.set_message(msg + "0");
XCTAssertTrue(stream->Write(request));
XCTAssertTrue(stream->Read(&response));
XCTAssertEqual(response.message(), request.message());
request.set_message(msg + "1");
XCTAssertTrue(stream->Write(request));
context.TryCancel();
// The cancellation races with responses, so there might be zero or
// one responses pending, read till failure
if (stream->Read(&response)) {
XCTAssertEqual(response.message(), request.message());
// Since we have cancelled, we expect the next attempt to read to fail
XCTAssertFalse(stream->Read(&response));
}
Status s = stream->Finish();
XCTAssertEqual(grpc::StatusCode::CANCELLED, s.error_code());
}
- (void)testNonExistingService {
auto channel = [self getChannel];
auto stub = grpc::testing::UnimplementedEchoService::NewStub(channel);
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
ClientContext context;
Status s = stub->Unimplemented(&context, request, &response);
XCTAssertEqual(grpc::StatusCode::UNIMPLEMENTED, s.error_code());
XCTAssertEqual("", s.error_message());
}
- (void)testBinaryTrailer {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
ClientContext context;
request.mutable_param()->set_echo_metadata(true);
DebugInfo* info = request.mutable_param()->mutable_debug_info();
info->add_stack_entries("stack_entry_1");
info->add_stack_entries("stack_entry_2");
info->add_stack_entries("stack_entry_3");
info->set_detail("detailed debug info");
std::string expected_string = info->SerializeAsString();
request.set_message("Hello");
Status s = stub->Echo(&context, request, &response);
XCTAssertFalse(s.ok());
auto trailers = context.GetServerTrailingMetadata();
XCTAssertEqual(1u, trailers.count(kDebugInfoTrailerKey));
auto iter = trailers.find(kDebugInfoTrailerKey);
XCTAssertEqual(expected_string, iter->second);
// Parse the returned trailer into a DebugInfo proto.
DebugInfo returned_info;
XCTAssertTrue(returned_info.ParseFromString(ToString(iter->second)));
}
- (void)testExpectError {
auto stub = [self getStub];
std::vector<ErrorStatus> expected_status;
expected_status.emplace_back();
expected_status.back().set_code(13); // INTERNAL
// No Error message or details
expected_status.emplace_back();
expected_status.back().set_code(13); // INTERNAL
expected_status.back().set_error_message("text error message");
expected_status.back().set_binary_error_details("text error details");
expected_status.emplace_back();
expected_status.back().set_code(13); // INTERNAL
expected_status.back().set_error_message("text error message");
expected_status.back().set_binary_error_details("\x0\x1\x2\x3\x4\x5\x6\x8\x9\xA\xB");
for (auto iter = expected_status.begin(); iter != expected_status.end(); ++iter) {
EchoRequest request;
EchoResponse response;
ClientContext context;
request.set_message("Hello");
auto* error = request.mutable_param()->mutable_expected_error();
error->set_code(iter->code());
error->set_error_message(iter->error_message());
error->set_binary_error_details(iter->binary_error_details());
Status s = stub->Echo(&context, request, &response);
XCTAssertFalse(s.ok());
XCTAssertEqual(iter->code(), s.error_code());
XCTAssertEqual(iter->error_message(), s.error_message());
XCTAssertEqual(iter->binary_error_details(), s.error_details());
XCTAssertTrue(context.debug_error_string().find("created") != std::string::npos);
XCTAssertTrue(context.debug_error_string().find("file") != std::string::npos);
XCTAssertTrue(context.debug_error_string().find("line") != std::string::npos);
XCTAssertTrue(context.debug_error_string().find("status") != std::string::npos);
XCTAssertTrue(context.debug_error_string().find("13") != std::string::npos);
}
}
- (void)testRpcDeadlineExpires {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
request.mutable_param()->set_skip_cancelled_check(true);
// Let server sleep for 40 ms first to guarantee expiry.
request.mutable_param()->set_server_sleep_us(40 * 1000);
ClientContext context;
std::chrono::system_clock::time_point deadline =
std::chrono::system_clock::now() + std::chrono::milliseconds(1);
context.set_deadline(deadline);
Status s = stub->Echo(&context, request, &response);
XCTAssertEqual(grpc::StatusCode::DEADLINE_EXCEEDED, s.error_code());
}
- (void)testRpcLongDeadline {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
ClientContext context;
std::chrono::system_clock::time_point deadline =
std::chrono::system_clock::now() + std::chrono::hours(1);
context.set_deadline(deadline);
Status s = stub->Echo(&context, request, &response);
XCTAssertEqual(response.message(), request.message());
XCTAssertTrue(s.ok());
}
- (void)testEchoDeadlineForNoDeadlineRpc {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
request.mutable_param()->set_echo_deadline(true);
ClientContext context;
Status s = stub->Echo(&context, request, &response);
XCTAssertEqual(response.message(), request.message());
XCTAssertTrue(s.ok());
XCTAssertEqual(response.param().request_deadline(), gpr_inf_future(GPR_CLOCK_REALTIME).tv_sec);
}
- (void)testEchoDeadline {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
request.mutable_param()->set_echo_deadline(true);
ClientContext context;
std::chrono::system_clock::time_point deadline =
std::chrono::system_clock::now() + std::chrono::seconds(100);
context.set_deadline(deadline);
Status s = stub->Echo(&context, request, &response);
XCTAssertEqual(response.message(), request.message());
XCTAssertTrue(s.ok());
gpr_timespec sent_deadline;
grpc::Timepoint2Timespec(deadline, &sent_deadline);
// We want to allow some reasonable error given:
// - request_deadline() only has 1sec resolution so the best we can do is +-1
// - if sent_deadline.tv_nsec is very close to the next second's boundary we
// can end up being off by 2 in one direction.
XCTAssertLessThanOrEqual(response.param().request_deadline() - sent_deadline.tv_sec, 2);
XCTAssertGreaterThanOrEqual(response.param().request_deadline() - sent_deadline.tv_sec, -1);
NSLog(@"request deadline: %d sent_deadline: %d", response.param().request_deadline(),
sent_deadline.tv_sec);
}
- (void)testPeer {
auto stub = [self getStub];
EchoRequest request;
EchoResponse response;
request.set_message("Hello");
ClientContext context;
Status s = stub->Echo(&context, request, &response);
XCTAssertTrue(s.ok());
XCTAssertTrue(CheckIsLocalhost(context.peer()));
}
- (void)testClientInterceptor {
PhonyInterceptor::Reset();
std::vector<std::unique_ptr<grpc::experimental::ClientInterceptorFactoryInterface>> creators;
// Add 20 phony interceptors
for (auto i = 0; i < 20; i++) {
creators.push_back(std::unique_ptr<PhonyInterceptorFactory>(new PhonyInterceptorFactory()));
}
auto channel = [self getChannelWithInterceptors:std::move(creators)];
auto stub = EchoTestService::NewStub(channel);
EchoRequest request;
EchoResponse response;
ClientContext context;
request.set_message("Hello");
Status s = stub->Echo(&context, request, &response);
XCTAssertTrue(s.ok());
XCTAssertEqual(PhonyInterceptor::GetNumTimesRun(), 20);
}
@end