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

Code review comments: added invalid config tests and restructured

Browse Source 
testing code.
reviewable/pr22280/r18
Donna Dionne 5 years ago
parent 84b2b98af2
commit 71aef940c3
5 changed files with 274 additions and 163 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. 3
      src/core/ext/filters/client_channel/lb_policy/xds/xds_routing.cc
  2. 19
      src/core/ext/filters/client_channel/xds/xds_api.cc
  3. 30
      test/cpp/end2end/test_service_impl.cc
  4. 48
      test/cpp/end2end/test_service_impl.h
  5. 337
      test/cpp/end2end/xds_end2end_test.cc

3
src/core/ext/filters/client_channel/lb_policy/xds/xds_routing.cc
Unescape View File

@ -215,6 +215,9 @@ class XdsRoutingLb : public LoadBalancingPolicy {
XdsRoutingLb::PickResult XdsRoutingLb::RoutePicker::Pick(PickArgs args) {
absl::string_view path;
// TODO(roth): Using const auto& here trigger a warning in a macos or windows
// build:
//*(args.initial_metadata) is returning values not references.
for (const auto p : *(args.initial_metadata)) {
if (p.first == ":path") {
path = p.second;

19
src/core/ext/filters/client_channel/xds/xds_api.cc
Unescape View File

@ -1024,11 +1024,20 @@ grpc_error* RouteConfigParse(
if (envoy_api_v2_route_RouteMatch_has_prefix(match)) {
upb_strview prefix = envoy_api_v2_route_RouteMatch_prefix(match);
if (prefix.size > 0) {
if (prefix.data[0] != '/') {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Prefix is not starting with a /");
}
std::vector<absl::string_view> prefix_elements = absl::StrSplit(
absl::string_view(prefix.data, prefix.size).substr(1), '/');
if (prefix_elements.size() != 2) {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Prefix not in the required format of /service/");
} else if (!prefix_elements[1].empty()) {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Prefix is not ending with a /");
} else if (prefix_elements[0].empty()) {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Prefix cannot be empty");
}
rds_route.service = std::string(prefix_elements[0]);
}
@ -1038,11 +1047,21 @@ grpc_error* RouteConfigParse(
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Path if set cannot be empty");
}
if (path.data[0] != '/') {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Path is not starting with a /");
}
std::vector<absl::string_view> path_elements = absl::StrSplit(
absl::string_view(path.data, path.size).substr(1), '/');
if (path_elements.size() != 2) {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Path not in the required format of /service/method");
} else if (path_elements[0].empty()) {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Path service name cannot be empty");
} else if (path_elements[1].empty()) {
return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
"Path method name cannot be empty");
}
rds_route.service = std::string(path_elements[0]);
rds_route.method = std::string(path_elements[1]);

30
test/cpp/end2end/test_service_impl.cc
Unescape View File

@ -132,7 +132,7 @@ experimental::ServerUnaryReactor* CallbackTestServiceImpl::Echo(
error.error_message(), error.binary_error_details()));
return;
}
int server_try_cancel = GetIntValueFromMetadata(
int server_try_cancel = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, ctx_->client_metadata(), DO_NOT_CANCEL);
if (server_try_cancel != DO_NOT_CANCEL) {
// Since this is a unary RPC, by the time this server handler is called,
@ -147,7 +147,7 @@ experimental::ServerUnaryReactor* CallbackTestServiceImpl::Echo(
}
gpr_log(GPR_DEBUG, "Request message was %s", req_->message().c_str());
resp_->set_message(req_->message());
MaybeEchoDeadline(ctx_, req_, resp_);
internal::MaybeEchoDeadline(ctx_, req_, resp_);
if (service_->host_) {
resp_->mutable_param()->set_host(*service_->host_);
}
@ -201,9 +201,9 @@ experimental::ServerUnaryReactor* CallbackTestServiceImpl::Echo(
if (req_->has_param() &&
(req_->param().expected_client_identity().length() > 0 ||
req_->param().check_auth_context())) {
CheckServerAuthContext(ctx_,
req_->param().expected_transport_security_type(),
req_->param().expected_client_identity());
internal::CheckServerAuthContext(
ctx_, req_->param().expected_transport_security_type(),
req_->param().expected_client_identity());
}
if (req_->has_param() && req_->param().response_message_length() > 0) {
resp_->set_message(
@ -247,9 +247,9 @@ CallbackTestServiceImpl::CheckClientInitialMetadata(
class Reactor : public ::grpc::experimental::ServerUnaryReactor {
public:
explicit Reactor(experimental::CallbackServerContext* ctx) {
EXPECT_EQ(MetadataMatchCount(ctx->client_metadata(),
kCheckClientInitialMetadataKey,
kCheckClientInitialMetadataVal),
EXPECT_EQ(internal::MetadataMatchCount(ctx->client_metadata(),
kCheckClientInitialMetadataKey,
kCheckClientInitialMetadataVal),
1);
EXPECT_EQ(ctx->client_metadata().count(kCheckClientInitialMetadataKey),
1u);
@ -272,7 +272,7 @@ CallbackTestServiceImpl::RequestStream(
// is cancelled while the server is reading messages from the client
// CANCEL_AFTER_PROCESSING: The RPC is cancelled after the server reads
// all the messages from the client
int server_try_cancel = GetIntValueFromMetadata(
int server_try_cancel = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, context->client_metadata(), DO_NOT_CANCEL);
if (server_try_cancel == CANCEL_BEFORE_PROCESSING) {
ServerTryCancelNonblocking(context);
@ -358,7 +358,7 @@ CallbackTestServiceImpl::ResponseStream(
// is cancelled while the server is reading messages from the client
// CANCEL_AFTER_PROCESSING: The RPC is cancelled after the server reads
// all the messages from the client
int server_try_cancel = GetIntValueFromMetadata(
int server_try_cancel = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, context->client_metadata(), DO_NOT_CANCEL);
if (server_try_cancel == CANCEL_BEFORE_PROCESSING) {
ServerTryCancelNonblocking(context);
@ -370,9 +370,9 @@ CallbackTestServiceImpl::ResponseStream(
Reactor(experimental::CallbackServerContext* ctx,
const EchoRequest* request, int server_try_cancel)
: ctx_(ctx), request_(request), server_try_cancel_(server_try_cancel) {
server_coalescing_api_ = GetIntValueFromMetadata(
server_coalescing_api_ = internal::GetIntValueFromMetadata(
kServerUseCoalescingApi, ctx->client_metadata(), 0);
server_responses_to_send_ = GetIntValueFromMetadata(
server_responses_to_send_ = internal::GetIntValueFromMetadata(
kServerResponseStreamsToSend, ctx->client_metadata(),
kServerDefaultResponseStreamsToSend);
if (server_try_cancel_ == CANCEL_DURING_PROCESSING) {
@ -457,10 +457,10 @@ CallbackTestServiceImpl::BidiStream(
// is cancelled while the server is reading messages from the client
// CANCEL_AFTER_PROCESSING: The RPC is cancelled after the server reads
// all the messages from the client
server_try_cancel_ = GetIntValueFromMetadata(
server_try_cancel_ = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, ctx->client_metadata(), DO_NOT_CANCEL);
server_write_last_ = GetIntValueFromMetadata(kServerFinishAfterNReads,
ctx->client_metadata(), 0);
server_write_last_ = internal::GetIntValueFromMetadata(
kServerFinishAfterNReads, ctx->client_metadata(), 0);
if (server_try_cancel_ == CANCEL_BEFORE_PROCESSING) {
ServerTryCancelNonblocking(ctx);
} else {

48
test/cpp/end2end/test_service_impl.h
Unescape View File

@ -57,7 +57,7 @@ typedef enum {
CANCEL_AFTER_PROCESSING
} ServerTryCancelRequestPhase;
namespace {
namespace internal {
// When echo_deadline is requested, deadline seen in the ServerContext is set in
// the response in seconds.
void MaybeEchoDeadline(experimental::ServerContextBase* context,
@ -137,7 +137,7 @@ void ServerTryCancel(ServerContext* context) {
gpr_time_from_micros(1000, GPR_TIMESPAN)));
}
}
} // namespace
} // namespace internal
class TestServiceSignaller {
public:
@ -200,19 +200,19 @@ class TestMultipleServiceImpl : public RpcService {
return Status(static_cast<StatusCode>(error.code()),
error.error_message(), error.binary_error_details());
}
int server_try_cancel = GetIntValueFromMetadata(
int server_try_cancel = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, context->client_metadata(), DO_NOT_CANCEL);
if (server_try_cancel > DO_NOT_CANCEL) {
// Since this is a unary RPC, by the time this server handler is called,
// the 'request' message is already read from the client. So the scenarios
// in server_try_cancel don't make much sense. Just cancel the RPC as long
// as server_try_cancel is not DO_NOT_CANCEL
ServerTryCancel(context);
internal::ServerTryCancel(context);
return Status::CANCELLED;
}
response->set_message(request->message());
MaybeEchoDeadline(context, request, response);
internal::MaybeEchoDeadline(context, request, response);
if (host_) {
response->mutable_param()->set_host(*host_);
}
@ -269,7 +269,7 @@ class TestMultipleServiceImpl : public RpcService {
if (request->has_param() &&
(request->param().expected_client_identity().length() > 0 ||
request->param().check_auth_context())) {
CheckServerAuthContext(
internal::CheckServerAuthContext(
context, request->param().expected_transport_security_type(),
request->param().expected_client_identity());
}
@ -297,9 +297,9 @@ class TestMultipleServiceImpl : public RpcService {
Status CheckClientInitialMetadata(ServerContext* context,
const SimpleRequest* /*request*/,
SimpleResponse* /*response*/) {
EXPECT_EQ(MetadataMatchCount(context->client_metadata(),
kCheckClientInitialMetadataKey,
kCheckClientInitialMetadataVal),
EXPECT_EQ(internal::MetadataMatchCount(context->client_metadata(),
kCheckClientInitialMetadataKey,
kCheckClientInitialMetadataVal),
1);
EXPECT_EQ(1u,
context->client_metadata().count(kCheckClientInitialMetadataKey));
@ -319,21 +319,21 @@ class TestMultipleServiceImpl : public RpcService {
// reading messages from the client
// CANCEL_AFTER_PROCESSING: The RPC is cancelled after the server reads
// all the messages from the client
int server_try_cancel = GetIntValueFromMetadata(
int server_try_cancel = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, context->client_metadata(), DO_NOT_CANCEL);
EchoRequest request;
response->set_message("");
if (server_try_cancel == CANCEL_BEFORE_PROCESSING) {
ServerTryCancel(context);
internal::ServerTryCancel(context);
return Status::CANCELLED;
}
std::thread* server_try_cancel_thd = nullptr;
if (server_try_cancel == CANCEL_DURING_PROCESSING) {
server_try_cancel_thd =
new std::thread([context] { ServerTryCancel(context); });
new std::thread([context] { internal::ServerTryCancel(context); });
}
int num_msgs_read = 0;
@ -349,7 +349,7 @@ class TestMultipleServiceImpl : public RpcService {
}
if (server_try_cancel == CANCEL_AFTER_PROCESSING) {
ServerTryCancel(context);
internal::ServerTryCancel(context);
return Status::CANCELLED;
}
@ -368,18 +368,18 @@ class TestMultipleServiceImpl : public RpcService {
// writing messages to the client
// CANCEL_AFTER_PROCESSING: The RPC is cancelled after the server writes
// all the messages to the client
int server_try_cancel = GetIntValueFromMetadata(
int server_try_cancel = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, context->client_metadata(), DO_NOT_CANCEL);
int server_coalescing_api = GetIntValueFromMetadata(
int server_coalescing_api = internal::GetIntValueFromMetadata(
kServerUseCoalescingApi, context->client_metadata(), 0);
int server_responses_to_send = GetIntValueFromMetadata(
int server_responses_to_send = internal::GetIntValueFromMetadata(
kServerResponseStreamsToSend, context->client_metadata(),
kServerDefaultResponseStreamsToSend);
if (server_try_cancel == CANCEL_BEFORE_PROCESSING) {
ServerTryCancel(context);
internal::ServerTryCancel(context);
return Status::CANCELLED;
}
@ -387,7 +387,7 @@ class TestMultipleServiceImpl : public RpcService {
std::thread* server_try_cancel_thd = nullptr;
if (server_try_cancel == CANCEL_DURING_PROCESSING) {
server_try_cancel_thd =
new std::thread([context] { ServerTryCancel(context); });
new std::thread([context] { internal::ServerTryCancel(context); });
}
for (int i = 0; i < server_responses_to_send; i++) {
@ -406,7 +406,7 @@ class TestMultipleServiceImpl : public RpcService {
}
if (server_try_cancel == CANCEL_AFTER_PROCESSING) {
ServerTryCancel(context);
internal::ServerTryCancel(context);
return Status::CANCELLED;
}
@ -423,26 +423,26 @@ class TestMultipleServiceImpl : public RpcService {
// reading/writing messages from/to the client
// CANCEL_AFTER_PROCESSING: The RPC is cancelled after the server
// reads/writes all messages from/to the client
int server_try_cancel = GetIntValueFromMetadata(
int server_try_cancel = internal::GetIntValueFromMetadata(
kServerTryCancelRequest, context->client_metadata(), DO_NOT_CANCEL);
EchoRequest request;
EchoResponse response;
if (server_try_cancel == CANCEL_BEFORE_PROCESSING) {
ServerTryCancel(context);
internal::ServerTryCancel(context);
return Status::CANCELLED;
}
std::thread* server_try_cancel_thd = nullptr;
if (server_try_cancel == CANCEL_DURING_PROCESSING) {
server_try_cancel_thd =
new std::thread([context] { ServerTryCancel(context); });
new std::thread([context] { internal::ServerTryCancel(context); });
}
// kServerFinishAfterNReads suggests after how many reads, the server should
// write the last message and send status (coalesced using WriteLast)
int server_write_last = GetIntValueFromMetadata(
int server_write_last = internal::GetIntValueFromMetadata(
kServerFinishAfterNReads, context->client_metadata(), 0);
int read_counts = 0;
@ -464,7 +464,7 @@ class TestMultipleServiceImpl : public RpcService {
}
if (server_try_cancel == CANCEL_AFTER_PROCESSING) {
ServerTryCancel(context);
internal::ServerTryCancel(context);
return Status::CANCELLED;
}

337
test/cpp/end2end/xds_end2end_test.cc
Unescape View File

@ -1359,121 +1359,103 @@ class XdsEnd2endTest : public ::testing::TestWithParam<TestType> {
return backend_ports;
}
enum RpcServiceMethod {
TEST_ECHO,
TEST_ECHO1,
TEST_ECHO2,
TEST1_ECHO,
TEST1_ECHO1,
TEST1_ECHO2,
TEST2_ECHO,
TEST2_ECHO1,
TEST2_ECHO2,
enum RpcService {
SERVICE_ECHO,
SERVICE_ECHO1,
SERVICE_ECHO2,
};
enum RpcMethod {
METHOD_ECHO,
METHOD_ECHO1,
METHOD_ECHO2,
};
struct RpcOptions {
RpcServiceMethod service_method = TEST_ECHO;
EchoResponse* response = nullptr;
RpcService service = SERVICE_ECHO;
RpcMethod method = METHOD_ECHO;
int timeout_ms = 1000;
bool wait_for_ready = false;
bool server_fail = false;
int times = 1;
RpcOptions() {}
RpcOptions& set_rpc_service(RpcService rpc_service) {
service = rpc_service;
return *this;
}
RpcOptions& set_rpc_method(RpcMethod rpc_method) {
method = rpc_method;
return *this;
}
RpcOptions& set_timeout_ms(int rpc_timeout_ms) {
timeout_ms = rpc_timeout_ms;
return *this;
}
RpcOptions& set_wait_for_ready(bool rpc_wait_for_ready) {
wait_for_ready = rpc_wait_for_ready;
return *this;
}
RpcOptions& set_server_fail(bool rpc_server_fail) {
server_fail = rpc_server_fail;
return *this;
}
};
// TODO@donnadionne: Will replace SendRpc in all tests.
Status SendRpcNew(const RpcOptions& rpc_options,
EchoResponse* response = nullptr) {
const bool local_response = (response == nullptr);
if (local_response) response = new EchoResponse;
EchoRequest request;
request.set_message(kRequestMessage_);
if (rpc_options.server_fail) {
request.mutable_param()->mutable_expected_error()->set_code(
GRPC_STATUS_FAILED_PRECONDITION);
}
template <typename Stub>
Status SendRpcMethod(Stub* stub, const RpcOptions& rpc_options,
EchoRequest& request, EchoResponse* response) {
ClientContext context;
context.set_deadline(
grpc_timeout_milliseconds_to_deadline(rpc_options.timeout_ms));
if (rpc_options.wait_for_ready) context.set_wait_for_ready(true);
Status status;
switch (rpc_options.service_method) {
case TEST_ECHO:
status = stub_->Echo(&context, request, response);
break;
case TEST_ECHO1:
status = stub_->Echo1(&context, request, response);
break;
case TEST_ECHO2:
status = stub_->Echo2(&context, request, response);
break;
case TEST1_ECHO:
status = stub1_->Echo(&context, request, response);
break;
case TEST1_ECHO1:
status = stub1_->Echo1(&context, request, response);
break;
case TEST1_ECHO2:
status = stub1_->Echo2(&context, request, response);
break;
case TEST2_ECHO:
status = stub2_->Echo(&context, request, response);
break;
case TEST2_ECHO1:
status = stub2_->Echo1(&context, request, response);
break;
case TEST2_ECHO2:
status = stub2_->Echo2(&context, request, response);
break;
switch (rpc_options.method) {
case METHOD_ECHO:
return (*stub)->Echo(&context, request, response);
case METHOD_ECHO1:
return (*stub)->Echo1(&context, request, response);
case METHOD_ECHO2:
return (*stub)->Echo2(&context, request, response);
}
if (local_response) delete response;
return status;
}
// TODO@donnadionne: Will replace ChedkRpcSendOk in all tests.
void CheckRpcSendOkNew(const RpcOptions& rpc_options) {
for (size_t i = 0; i < rpc_options.times; ++i) {
EchoResponse response;
const Status status = SendRpcNew(rpc_options, &response);
EXPECT_TRUE(status.ok()) << "code=" << status.error_code()
<< " message=" << status.error_message();
EXPECT_EQ(response.message(), kRequestMessage_);
}
}
Status SendRpc(const string& method_name = "Echo",
EchoResponse* response = nullptr, int timeout_ms = 1000,
bool wait_for_ready = false, bool server_fail = false) {
Status SendRpc(const RpcOptions& rpc_options = RpcOptions(),
EchoResponse* response = nullptr) {
const bool local_response = (response == nullptr);
if (local_response) response = new EchoResponse;
EchoRequest request;
request.set_message(kRequestMessage_);
if (server_fail) {
if (rpc_options.server_fail) {
request.mutable_param()->mutable_expected_error()->set_code(
GRPC_STATUS_FAILED_PRECONDITION);
}
ClientContext context;
context.set_deadline(grpc_timeout_milliseconds_to_deadline(timeout_ms));
if (wait_for_ready) context.set_wait_for_ready(true);
Status status;
if (method_name == "Echo") {
status = stub_->Echo(&context, request, response);
} else if (method_name == "Echo1") {
status = stub1_->Echo1(&context, request, response);
} else if (method_name == "Echo2") {
status = stub2_->Echo2(&context, request, response);
switch (rpc_options.service) {
case SERVICE_ECHO:
status = SendRpcMethod(&stub_, rpc_options, request, response);
break;
case SERVICE_ECHO1:
status = SendRpcMethod(&stub1_, rpc_options, request, response);
break;
case SERVICE_ECHO2:
status = SendRpcMethod(&stub2_, rpc_options, request, response);
break;
}
if (local_response) delete response;
return status;
}
// TODO@donnadionne: Will replace ChedkRpcSendOk in all tests.
void CheckRpcSendOk(const size_t times = 1,
const string& method_name = "Echo",
const int timeout_ms = 1000,
bool wait_for_ready = false) {
const RpcOptions& rpc_options = RpcOptions()) {
for (size_t i = 0; i < times; ++i) {
EchoResponse response;
const Status status =
SendRpc(method_name, &response, timeout_ms, wait_for_ready);
const Status status = SendRpc(rpc_options, &response);
EXPECT_TRUE(status.ok()) << "code=" << status.error_code()
<< " message=" << status.error_message();
EXPECT_EQ(response.message(), kRequestMessage_);
@ -1482,7 +1464,7 @@ class XdsEnd2endTest : public ::testing::TestWithParam<TestType> {
void CheckRpcSendFailure(const size_t times = 1, bool server_fail = false) {
for (size_t i = 0; i < times; ++i) {
const Status status = SendRpc("Echo", nullptr, 1000, false, server_fail);
const Status status = SendRpc(RpcOptions().set_server_fail(server_fail));
EXPECT_FALSE(status.ok());
}
}
@ -1778,7 +1760,8 @@ TEST_P(BasicTest, InitiallyEmptyServerlist) {
kDefaultResourceName));
const auto t0 = system_clock::now();
// Client will block: LB will initially send empty serverlist.
CheckRpcSendOk(1, "Echo", kCallDeadlineMs, true /* wait_for_ready */);
CheckRpcSendOk(
1, RpcOptions().set_timeout_ms(kCallDeadlineMs).set_wait_for_ready(true));
const auto ellapsed_ms =
std::chrono::duration_cast<std::chrono::milliseconds>(
system_clock::now() - t0);
@ -1826,8 +1809,7 @@ TEST_P(BasicTest, BackendsRestart) {
CheckRpcSendFailure();
// Restart all backends. RPCs should start succeeding again.
StartAllBackends();
CheckRpcSendOk(1 /* times */, "Echo", 2000 /* timeout_ms */,
true /* wait_for_ready */);
CheckRpcSendOk(1, RpcOptions().set_timeout_ms(2000).set_wait_for_ready(true));
}
using XdsResolverOnlyTest = BasicTest;
@ -2232,15 +2214,126 @@ TEST_P(LdsTest, RouteMatchHasNonemptyPrefix) {
AdsServiceImpl::NACKED);
}
// Tests that LDS client should send a NACK if route match has empty path
// as the only route (default) in the LDS response.
TEST_P(LdsTest, RouteMatchHasEmptyPath) {
// Tests that LDS client should send a NACK if route match has a prefix
// not in the format "/service/": missing / or did not end with /.
TEST_P(LdsTest, RouteMatchHasInvalidPrefix) {
ResetStub(/*failover_timeout=*/0,
/*expected_targets=*/"",
/*xds_resource_does_not_exist_timeout*/ 0,
/*xds_routing_enabled=*/true);
RouteConfiguration route_config =
balancers_[0]->ads_service()->default_route_config();
auto* route1 = route_config.mutable_virtual_hosts(0)->mutable_routes(0);
// Invalid case 1: no /
route1->mutable_match()->set_prefix("grpc.testing.EchoTest1Service");
auto* default_route = route_config.mutable_virtual_hosts(0)->add_routes();
default_route->mutable_match()->set_prefix("");
default_route->mutable_route()->set_cluster(kDefaultResourceName);
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 2: missing / at the end
route1->mutable_match()->set_prefix("/grpc.testing.EchoTest1Service");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 3: missing / at the beginning
route1->mutable_match()->set_prefix("grpc.testing.EchoTest1Service/");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 4: extra content outside of "/service/"
route1->mutable_match()->set_prefix("/grpc.testing.EchoTest1Service/Echo1");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 5: empty prefix "//"
route1->mutable_match()->set_prefix("//");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
}
// Tests that LDS client should send a NACK if route match has path
// not in the format of "/service/method"
TEST_P(LdsTest, RouteMatchHasInvalidPath) {
ResetStub(/*failover_timeout=*/0,
/*expected_targets=*/"",
/*xds_resource_does_not_exist_timeout*/ 0,
/*xds_routing_enabled=*/true);
RouteConfiguration route_config =
balancers_[0]->ads_service()->default_route_config();
auto* route1 = route_config.mutable_virtual_hosts(0)->mutable_routes(0);
route1->mutable_match()->set_path("");
auto* default_route = route_config.mutable_virtual_hosts(0)->add_routes();
default_route->mutable_match()->set_prefix("");
default_route->mutable_route()->set_cluster(kDefaultResourceName);
// Invalid case 1: empty path
route1->mutable_match()->set_path("");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 2: missing / at the beginning
route1->mutable_match()->set_path("grpc.testing.EchoTest1Service/Echo1");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 3: extra / at the end
route1->mutable_match()->set_path("/grpc.testing.EchoTest1Service/Echo1/");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 4: missinga / in the middle
route1->mutable_match()->set_path("/grpc.testing.EchoTest1Service.Echo1");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 5: empty service "//Echo1"
route1->mutable_match()->set_path("//Echo1");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
CheckRpcSendFailure();
EXPECT_EQ(balancers_[0]->ads_service()->lds_response_state(),
AdsServiceImpl::NACKED);
// Invalid case 5: empty method "/grpc.testing.EchoTest1Service/"
route1->mutable_match()->set_path("/grpc.testing.EchoTest1Service/");
balancers_[0]->ads_service()->SetLdsResource(
AdsServiceImpl::BuildListener(route_config), kDefaultResourceName);
SetNextResolution({});
@ -2350,17 +2443,15 @@ TEST_P(LdsTest, XdsRoutingPathMatching) {
balancers_[0]->ads_service()->BuildListener(new_route_config);
balancers_[0]->ads_service()->SetLdsResource(listener, kDefaultResourceName);
WaitForAllBackends(0, 2);
RpcOptions rpc_options;
rpc_options.times = kNumEchoRpcs;
rpc_options.service_method = TEST_ECHO;
rpc_options.wait_for_ready = true;
CheckRpcSendOkNew(rpc_options);
rpc_options.times = kNumEcho1Rpcs;
rpc_options.service_method = TEST1_ECHO1;
CheckRpcSendOkNew(rpc_options);
rpc_options.times = kNumEcho2Rpcs;
rpc_options.service_method = TEST2_ECHO2;
CheckRpcSendOkNew(rpc_options);
CheckRpcSendOk(kNumEchoRpcs, RpcOptions().set_wait_for_ready(true));
CheckRpcSendOk(kNumEcho1Rpcs, RpcOptions()
.set_rpc_service(SERVICE_ECHO1)
.set_rpc_method(METHOD_ECHO1)
.set_wait_for_ready(true));
CheckRpcSendOk(kNumEcho2Rpcs, RpcOptions()
.set_rpc_service(SERVICE_ECHO2)
.set_rpc_method(METHOD_ECHO2)
.set_wait_for_ready(true));
// Make sure RPCs all go to the correct backend.
for (size_t i = 0; i < 2; ++i) {
EXPECT_EQ(kNumEchoRpcs / 2,
@ -2429,17 +2520,15 @@ TEST_P(LdsTest, XdsRoutingPrefixMatching) {
balancers_[0]->ads_service()->BuildListener(new_route_config);
balancers_[0]->ads_service()->SetLdsResource(listener, kDefaultResourceName);
WaitForAllBackends(0, 2);
RpcOptions rpc_options;
rpc_options.times = kNumEchoRpcs;
rpc_options.service_method = TEST_ECHO;
rpc_options.wait_for_ready = true;
CheckRpcSendOkNew(rpc_options);
rpc_options.times = kNumEcho1Rpcs;
rpc_options.service_method = TEST1_ECHO1;
CheckRpcSendOkNew(rpc_options);
rpc_options.times = kNumEcho2Rpcs;
rpc_options.service_method = TEST2_ECHO2;
CheckRpcSendOkNew(rpc_options);
CheckRpcSendOk(kNumEchoRpcs, RpcOptions().set_wait_for_ready(true));
CheckRpcSendOk(kNumEcho1Rpcs, RpcOptions()
.set_rpc_service(SERVICE_ECHO1)
.set_rpc_method(METHOD_ECHO1)
.set_wait_for_ready(true));
CheckRpcSendOk(kNumEcho2Rpcs, RpcOptions()
.set_rpc_service(SERVICE_ECHO2)
.set_rpc_method(METHOD_ECHO2)
.set_wait_for_ready(true));
// Make sure RPCs all go to the correct backend.
for (size_t i = 0; i < 2; ++i) {
EXPECT_EQ(kNumEchoRpcs / 2,
@ -2773,7 +2862,7 @@ TEST_P(LocalityMapTest, NoLocalities) {
// Tests that the locality map can work properly even when it contains a large
// number of localities.
TEST_P(LocalityMapTest, StressTest) {
/*TEST_P(LocalityMapTest, StressTest) {
SetNextResolution({});
SetNextResolutionForLbChannelAllBalancers();
const size_t kNumLocalities = 100;
@ -2797,13 +2886,13 @@ TEST_P(LocalityMapTest, StressTest) {
AdsServiceImpl::BuildEdsResource(args), 60 * 1000, kDefaultResourceName));
// Wait until backend 0 is ready, before which kNumLocalities localities are
// received and handled by the xds policy.
WaitForBackend(0, /*reset_counters=*/false);
WaitForBackend(0, /*reset_counters=*false);
EXPECT_EQ(0U, backends_[1]->backend_service()->request_count());
// Wait until backend 1 is ready, before which kNumLocalities localities are
// removed by the xds policy.
WaitForBackend(1);
delayed_resource_setter.join();
}
}*/
// Tests that the localities in a locality map are picked correctly after update
// (addition, modification, deletion).
@ -3149,7 +3238,7 @@ TEST_P(DropTest, Vanilla) {
size_t num_drops = 0;
for (size_t i = 0; i < kNumRpcs; ++i) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
if (!status.ok() &&
status.error_message() == "Call dropped by load balancing policy") {
++num_drops;
@ -3189,7 +3278,7 @@ TEST_P(DropTest, DropPerHundred) {
size_t num_drops = 0;
for (size_t i = 0; i < kNumRpcs; ++i) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
if (!status.ok() &&
status.error_message() == "Call dropped by load balancing policy") {
++num_drops;
@ -3228,7 +3317,7 @@ TEST_P(DropTest, DropPerTenThousand) {
size_t num_drops = 0;
for (size_t i = 0; i < kNumRpcs; ++i) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
if (!status.ok() &&
status.error_message() == "Call dropped by load balancing policy") {
++num_drops;
@ -3271,7 +3360,7 @@ TEST_P(DropTest, Update) {
gpr_log(GPR_INFO, "========= BEFORE FIRST BATCH ==========");
for (size_t i = 0; i < kNumRpcs; ++i) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
if (!status.ok() &&
status.error_message() == "Call dropped by load balancing policy") {
++num_drops;
@ -3303,7 +3392,7 @@ TEST_P(DropTest, Update) {
size_t num_rpcs = kNumRpcs;
while (seen_drop_rate < kDropRateThreshold) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
++num_rpcs;
if (!status.ok() &&
status.error_message() == "Call dropped by load balancing policy") {
@ -3320,7 +3409,7 @@ TEST_P(DropTest, Update) {
gpr_log(GPR_INFO, "========= BEFORE SECOND BATCH ==========");
for (size_t i = 0; i < kNumRpcs; ++i) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
if (!status.ok() &&
status.error_message() == "Call dropped by load balancing policy") {
++num_drops;
@ -3357,7 +3446,7 @@ TEST_P(DropTest, DropAll) {
// Send kNumRpcs RPCs and all of them are dropped.
for (size_t i = 0; i < kNumRpcs; ++i) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
EXPECT_EQ(status.error_code(), StatusCode::UNAVAILABLE);
EXPECT_EQ(status.error_message(), "Call dropped by load balancing policy");
}
@ -3752,7 +3841,7 @@ TEST_P(ClientLoadReportingWithDropTest, Vanilla) {
// Send kNumRpcs RPCs and count the drops.
for (size_t i = 0; i < kNumRpcs; ++i) {
EchoResponse response;
const Status status = SendRpc("Echo", &response);
const Status status = SendRpc(RpcOptions(), &response);
if (!status.ok() &&
status.error_message() == "Call dropped by load balancing policy") {
++num_drops;

Write Preview
Loading…
Cancel
Save