1 /*
2 *
3 * Copyright 2016 gRPC authors.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 */
18
19 #include <algorithm>
20 #include <memory>
21 #include <mutex>
22 #include <random>
23 #include <set>
24 #include <string>
25 #include <thread>
26
27 #include <gmock/gmock.h>
28 #include <gtest/gtest.h>
29
30 #include "absl/memory/memory.h"
31 #include "absl/strings/str_cat.h"
32
33 #include <grpc/grpc.h>
34 #include <grpc/support/alloc.h>
35 #include <grpc/support/atm.h>
36 #include <grpc/support/log.h>
37 #include <grpc/support/time.h>
38 #include <grpcpp/channel.h>
39 #include <grpcpp/client_context.h>
40 #include <grpcpp/create_channel.h>
41 #include <grpcpp/health_check_service_interface.h>
42 #include <grpcpp/impl/codegen/sync.h>
43 #include <grpcpp/server.h>
44 #include <grpcpp/server_builder.h>
45 #include <grpcpp/support/validate_service_config.h>
46
47 #include "src/core/ext/filters/client_channel/backup_poller.h"
48 #include "src/core/ext/filters/client_channel/global_subchannel_pool.h"
49 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
50 #include "src/core/ext/filters/client_channel/server_address.h"
51 #include "src/core/lib/address_utils/parse_address.h"
52 #include "src/core/lib/backoff/backoff.h"
53 #include "src/core/lib/channel/channel_args.h"
54 #include "src/core/lib/gprpp/debug_location.h"
55 #include "src/core/lib/gprpp/ref_counted_ptr.h"
56 #include "src/core/lib/iomgr/tcp_client.h"
57 #include "src/core/lib/security/credentials/fake/fake_credentials.h"
58 #include "src/cpp/client/secure_credentials.h"
59 #include "src/cpp/server/secure_server_credentials.h"
60 #include "src/proto/grpc/testing/echo.grpc.pb.h"
61 #include "test/core/util/port.h"
62 #include "test/core/util/resolve_localhost_ip46.h"
63 #include "test/core/util/test_config.h"
64 #include "test/cpp/end2end/test_service_impl.h"
65
66 using grpc::testing::EchoRequest;
67 using grpc::testing::EchoResponse;
68
69 namespace grpc {
70 namespace testing {
71 namespace {
72
73 // Subclass of TestServiceImpl that increments a request counter for
74 // every call to the Echo RPC.
75 class MyTestServiceImpl : public TestServiceImpl {
76 public:
MyTestServiceImpl()77 MyTestServiceImpl() : request_count_(0) {}
78
Echo(ServerContext * context,const EchoRequest * request,EchoResponse * response)79 Status Echo(ServerContext* context, const EchoRequest* request,
80 EchoResponse* response) override {
81 {
82 grpc::internal::MutexLock lock(&mu_);
83 ++request_count_;
84 }
85 AddClient(context->peer());
86 return TestServiceImpl::Echo(context, request, response);
87 }
88
request_count()89 int request_count() {
90 grpc::internal::MutexLock lock(&mu_);
91 return request_count_;
92 }
93
ResetCounters()94 void ResetCounters() {
95 grpc::internal::MutexLock lock(&mu_);
96 request_count_ = 0;
97 }
98
clients()99 std::set<std::string> clients() {
100 grpc::internal::MutexLock lock(&clients_mu_);
101 return clients_;
102 }
103
104 private:
AddClient(const std::string & client)105 void AddClient(const std::string& client) {
106 grpc::internal::MutexLock lock(&clients_mu_);
107 clients_.insert(client);
108 }
109
110 grpc::internal::Mutex mu_;
111 int request_count_;
112 grpc::internal::Mutex clients_mu_;
113 std::set<std::string> clients_;
114 };
115
116 class ServiceConfigEnd2endTest : public ::testing::Test {
117 protected:
ServiceConfigEnd2endTest()118 ServiceConfigEnd2endTest()
119 : server_host_("localhost"),
120 kRequestMessage_("Live long and prosper."),
121 creds_(new SecureChannelCredentials(
122 grpc_fake_transport_security_credentials_create())) {}
123
SetUpTestCase()124 static void SetUpTestCase() {
125 // Make the backup poller poll very frequently in order to pick up
126 // updates from all the subchannels's FDs.
127 GPR_GLOBAL_CONFIG_SET(grpc_client_channel_backup_poll_interval_ms, 1);
128 }
129
SetUp()130 void SetUp() override {
131 grpc_init();
132 response_generator_ =
133 grpc_core::MakeRefCounted<grpc_core::FakeResolverResponseGenerator>();
134 bool localhost_resolves_to_ipv4 = false;
135 bool localhost_resolves_to_ipv6 = false;
136 grpc_core::LocalhostResolves(&localhost_resolves_to_ipv4,
137 &localhost_resolves_to_ipv6);
138 ipv6_only_ = !localhost_resolves_to_ipv4 && localhost_resolves_to_ipv6;
139 }
140
TearDown()141 void TearDown() override {
142 for (size_t i = 0; i < servers_.size(); ++i) {
143 servers_[i]->Shutdown();
144 }
145 // Explicitly destroy all the members so that we can make sure grpc_shutdown
146 // has finished by the end of this function, and thus all the registered
147 // LB policy factories are removed.
148 stub_.reset();
149 servers_.clear();
150 creds_.reset();
151 grpc_shutdown();
152 }
153
CreateServers(size_t num_servers,std::vector<int> ports=std::vector<int> ())154 void CreateServers(size_t num_servers,
155 std::vector<int> ports = std::vector<int>()) {
156 servers_.clear();
157 for (size_t i = 0; i < num_servers; ++i) {
158 int port = 0;
159 if (ports.size() == num_servers) port = ports[i];
160 servers_.emplace_back(new ServerData(port));
161 }
162 }
163
StartServer(size_t index)164 void StartServer(size_t index) { servers_[index]->Start(server_host_); }
165
StartServers(size_t num_servers,std::vector<int> ports=std::vector<int> ())166 void StartServers(size_t num_servers,
167 std::vector<int> ports = std::vector<int>()) {
168 CreateServers(num_servers, std::move(ports));
169 for (size_t i = 0; i < num_servers; ++i) {
170 StartServer(i);
171 }
172 }
173
BuildFakeResults(const std::vector<int> & ports)174 grpc_core::Resolver::Result BuildFakeResults(const std::vector<int>& ports) {
175 grpc_core::Resolver::Result result;
176 for (const int& port : ports) {
177 std::string lb_uri_str =
178 absl::StrCat(ipv6_only_ ? "ipv6:[::1]:" : "ipv4:127.0.0.1:", port);
179 absl::StatusOr<grpc_core::URI> lb_uri = grpc_core::URI::Parse(lb_uri_str);
180 GPR_ASSERT(lb_uri.ok());
181 grpc_resolved_address address;
182 GPR_ASSERT(grpc_parse_uri(*lb_uri, &address));
183 result.addresses.emplace_back(address.addr, address.len,
184 nullptr /* args */);
185 }
186 return result;
187 }
188
SetNextResolutionNoServiceConfig(const std::vector<int> & ports)189 void SetNextResolutionNoServiceConfig(const std::vector<int>& ports) {
190 grpc_core::ExecCtx exec_ctx;
191 grpc_core::Resolver::Result result = BuildFakeResults(ports);
192 response_generator_->SetResponse(result);
193 }
194
SetNextResolutionValidServiceConfig(const std::vector<int> & ports)195 void SetNextResolutionValidServiceConfig(const std::vector<int>& ports) {
196 grpc_core::ExecCtx exec_ctx;
197 grpc_core::Resolver::Result result = BuildFakeResults(ports);
198 result.service_config = grpc_core::ServiceConfig::Create(
199 nullptr, "{}", &result.service_config_error);
200 response_generator_->SetResponse(result);
201 }
202
SetNextResolutionInvalidServiceConfig(const std::vector<int> & ports)203 void SetNextResolutionInvalidServiceConfig(const std::vector<int>& ports) {
204 grpc_core::ExecCtx exec_ctx;
205 grpc_core::Resolver::Result result = BuildFakeResults(ports);
206 result.service_config = grpc_core::ServiceConfig::Create(
207 nullptr, "{", &result.service_config_error);
208 response_generator_->SetResponse(result);
209 }
210
SetNextResolutionWithServiceConfig(const std::vector<int> & ports,const char * svc_cfg)211 void SetNextResolutionWithServiceConfig(const std::vector<int>& ports,
212 const char* svc_cfg) {
213 grpc_core::ExecCtx exec_ctx;
214 grpc_core::Resolver::Result result = BuildFakeResults(ports);
215 result.service_config = grpc_core::ServiceConfig::Create(
216 nullptr, svc_cfg, &result.service_config_error);
217 response_generator_->SetResponse(result);
218 }
219
GetServersPorts(size_t start_index=0)220 std::vector<int> GetServersPorts(size_t start_index = 0) {
221 std::vector<int> ports;
222 for (size_t i = start_index; i < servers_.size(); ++i) {
223 ports.push_back(servers_[i]->port_);
224 }
225 return ports;
226 }
227
BuildStub(const std::shared_ptr<Channel> & channel)228 std::unique_ptr<grpc::testing::EchoTestService::Stub> BuildStub(
229 const std::shared_ptr<Channel>& channel) {
230 return grpc::testing::EchoTestService::NewStub(channel);
231 }
232
BuildChannel()233 std::shared_ptr<Channel> BuildChannel() {
234 ChannelArguments args;
235 args.SetPointer(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR,
236 response_generator_.get());
237 return ::grpc::CreateCustomChannel("fake:///", creds_, args);
238 }
239
BuildChannelWithDefaultServiceConfig()240 std::shared_ptr<Channel> BuildChannelWithDefaultServiceConfig() {
241 ChannelArguments args;
242 EXPECT_THAT(grpc::experimental::ValidateServiceConfigJSON(
243 ValidDefaultServiceConfig()),
244 ::testing::StrEq(""));
245 args.SetServiceConfigJSON(ValidDefaultServiceConfig());
246 args.SetPointer(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR,
247 response_generator_.get());
248 return ::grpc::CreateCustomChannel("fake:///", creds_, args);
249 }
250
BuildChannelWithInvalidDefaultServiceConfig()251 std::shared_ptr<Channel> BuildChannelWithInvalidDefaultServiceConfig() {
252 ChannelArguments args;
253 EXPECT_THAT(grpc::experimental::ValidateServiceConfigJSON(
254 InvalidDefaultServiceConfig()),
255 ::testing::HasSubstr("JSON parse error"));
256 args.SetServiceConfigJSON(InvalidDefaultServiceConfig());
257 args.SetPointer(GRPC_ARG_FAKE_RESOLVER_RESPONSE_GENERATOR,
258 response_generator_.get());
259 return ::grpc::CreateCustomChannel("fake:///", creds_, args);
260 }
261
SendRpc(const std::unique_ptr<grpc::testing::EchoTestService::Stub> & stub,EchoResponse * response=nullptr,int timeout_ms=1000,Status * result=nullptr,bool wait_for_ready=false)262 bool SendRpc(
263 const std::unique_ptr<grpc::testing::EchoTestService::Stub>& stub,
264 EchoResponse* response = nullptr, int timeout_ms = 1000,
265 Status* result = nullptr, bool wait_for_ready = false) {
266 const bool local_response = (response == nullptr);
267 if (local_response) response = new EchoResponse;
268 EchoRequest request;
269 request.set_message(kRequestMessage_);
270 ClientContext context;
271 context.set_deadline(grpc_timeout_milliseconds_to_deadline(timeout_ms));
272 if (wait_for_ready) context.set_wait_for_ready(true);
273 Status status = stub->Echo(&context, request, response);
274 if (result != nullptr) *result = status;
275 if (local_response) delete response;
276 return status.ok();
277 }
278
CheckRpcSendOk(const std::unique_ptr<grpc::testing::EchoTestService::Stub> & stub,const grpc_core::DebugLocation & location,bool wait_for_ready=false)279 void CheckRpcSendOk(
280 const std::unique_ptr<grpc::testing::EchoTestService::Stub>& stub,
281 const grpc_core::DebugLocation& location, bool wait_for_ready = false) {
282 EchoResponse response;
283 Status status;
284 const bool success =
285 SendRpc(stub, &response, 2000, &status, wait_for_ready);
286 ASSERT_TRUE(success) << "From " << location.file() << ":" << location.line()
287 << "\n"
288 << "Error: " << status.error_message() << " "
289 << status.error_details();
290 ASSERT_EQ(response.message(), kRequestMessage_)
291 << "From " << location.file() << ":" << location.line();
292 if (!success) abort();
293 }
294
CheckRpcSendFailure(const std::unique_ptr<grpc::testing::EchoTestService::Stub> & stub)295 void CheckRpcSendFailure(
296 const std::unique_ptr<grpc::testing::EchoTestService::Stub>& stub) {
297 const bool success = SendRpc(stub);
298 EXPECT_FALSE(success);
299 }
300
301 struct ServerData {
302 const int port_;
303 std::unique_ptr<Server> server_;
304 MyTestServiceImpl service_;
305 std::unique_ptr<std::thread> thread_;
306
307 grpc::internal::Mutex mu_;
308 grpc::internal::CondVar cond_;
309 bool server_ready_ ABSL_GUARDED_BY(mu_) = false;
310 bool started_ ABSL_GUARDED_BY(mu_) = false;
311
ServerDatagrpc::testing::__anonc7bc6e570111::ServiceConfigEnd2endTest::ServerData312 explicit ServerData(int port = 0)
313 : port_(port > 0 ? port : grpc_pick_unused_port_or_die()) {}
314
Startgrpc::testing::__anonc7bc6e570111::ServiceConfigEnd2endTest::ServerData315 void Start(const std::string& server_host) {
316 gpr_log(GPR_INFO, "starting server on port %d", port_);
317 grpc::internal::MutexLock lock(&mu_);
318 started_ = true;
319 thread_ = absl::make_unique<std::thread>(
320 std::bind(&ServerData::Serve, this, server_host));
321 while (!server_ready_) {
322 cond_.Wait(&mu_);
323 }
324 server_ready_ = false;
325 gpr_log(GPR_INFO, "server startup complete");
326 }
327
Servegrpc::testing::__anonc7bc6e570111::ServiceConfigEnd2endTest::ServerData328 void Serve(const std::string& server_host) {
329 std::ostringstream server_address;
330 server_address << server_host << ":" << port_;
331 ServerBuilder builder;
332 std::shared_ptr<ServerCredentials> creds(new SecureServerCredentials(
333 grpc_fake_transport_security_server_credentials_create()));
334 builder.AddListeningPort(server_address.str(), std::move(creds));
335 builder.RegisterService(&service_);
336 server_ = builder.BuildAndStart();
337 grpc::internal::MutexLock lock(&mu_);
338 server_ready_ = true;
339 cond_.Signal();
340 }
341
Shutdowngrpc::testing::__anonc7bc6e570111::ServiceConfigEnd2endTest::ServerData342 void Shutdown() {
343 grpc::internal::MutexLock lock(&mu_);
344 if (!started_) return;
345 server_->Shutdown(grpc_timeout_milliseconds_to_deadline(0));
346 thread_->join();
347 started_ = false;
348 }
349
SetServingStatusgrpc::testing::__anonc7bc6e570111::ServiceConfigEnd2endTest::ServerData350 void SetServingStatus(const std::string& service, bool serving) {
351 server_->GetHealthCheckService()->SetServingStatus(service, serving);
352 }
353 };
354
ResetCounters()355 void ResetCounters() {
356 for (const auto& server : servers_) server->service_.ResetCounters();
357 }
358
WaitForServer(const std::unique_ptr<grpc::testing::EchoTestService::Stub> & stub,size_t server_idx,const grpc_core::DebugLocation & location,bool ignore_failure=false)359 void WaitForServer(
360 const std::unique_ptr<grpc::testing::EchoTestService::Stub>& stub,
361 size_t server_idx, const grpc_core::DebugLocation& location,
362 bool ignore_failure = false) {
363 do {
364 if (ignore_failure) {
365 SendRpc(stub);
366 } else {
367 CheckRpcSendOk(stub, location, true);
368 }
369 } while (servers_[server_idx]->service_.request_count() == 0);
370 ResetCounters();
371 }
372
WaitForChannelNotReady(Channel * channel,int timeout_seconds=5)373 bool WaitForChannelNotReady(Channel* channel, int timeout_seconds = 5) {
374 const gpr_timespec deadline =
375 grpc_timeout_seconds_to_deadline(timeout_seconds);
376 grpc_connectivity_state state;
377 while ((state = channel->GetState(false /* try_to_connect */)) ==
378 GRPC_CHANNEL_READY) {
379 if (!channel->WaitForStateChange(state, deadline)) return false;
380 }
381 return true;
382 }
383
WaitForChannelReady(Channel * channel,int timeout_seconds=5)384 bool WaitForChannelReady(Channel* channel, int timeout_seconds = 5) {
385 const gpr_timespec deadline =
386 grpc_timeout_seconds_to_deadline(timeout_seconds);
387 grpc_connectivity_state state;
388 while ((state = channel->GetState(true /* try_to_connect */)) !=
389 GRPC_CHANNEL_READY) {
390 if (!channel->WaitForStateChange(state, deadline)) return false;
391 }
392 return true;
393 }
394
SeenAllServers()395 bool SeenAllServers() {
396 for (const auto& server : servers_) {
397 if (server->service_.request_count() == 0) return false;
398 }
399 return true;
400 }
401
402 // Updates \a connection_order by appending to it the index of the newly
403 // connected server. Must be called after every single RPC.
UpdateConnectionOrder(const std::vector<std::unique_ptr<ServerData>> & servers,std::vector<int> * connection_order)404 void UpdateConnectionOrder(
405 const std::vector<std::unique_ptr<ServerData>>& servers,
406 std::vector<int>* connection_order) {
407 for (size_t i = 0; i < servers.size(); ++i) {
408 if (servers[i]->service_.request_count() == 1) {
409 // Was the server index known? If not, update connection_order.
410 const auto it =
411 std::find(connection_order->begin(), connection_order->end(), i);
412 if (it == connection_order->end()) {
413 connection_order->push_back(i);
414 return;
415 }
416 }
417 }
418 }
419
ValidServiceConfigV1()420 const char* ValidServiceConfigV1() { return "{\"version\": \"1\"}"; }
421
ValidServiceConfigV2()422 const char* ValidServiceConfigV2() { return "{\"version\": \"2\"}"; }
423
ValidDefaultServiceConfig()424 const char* ValidDefaultServiceConfig() {
425 return "{\"version\": \"valid_default\"}";
426 }
427
InvalidDefaultServiceConfig()428 const char* InvalidDefaultServiceConfig() {
429 return "{\"version\": \"invalid_default\"";
430 }
431
432 bool ipv6_only_ = false;
433 const std::string server_host_;
434 std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
435 std::vector<std::unique_ptr<ServerData>> servers_;
436 grpc_core::RefCountedPtr<grpc_core::FakeResolverResponseGenerator>
437 response_generator_;
438 const std::string kRequestMessage_;
439 std::shared_ptr<ChannelCredentials> creds_;
440 };
441
TEST_F(ServiceConfigEnd2endTest,NoServiceConfigTest)442 TEST_F(ServiceConfigEnd2endTest, NoServiceConfigTest) {
443 StartServers(1);
444 auto channel = BuildChannel();
445 auto stub = BuildStub(channel);
446 SetNextResolutionNoServiceConfig(GetServersPorts());
447 CheckRpcSendOk(stub, DEBUG_LOCATION);
448 EXPECT_STREQ("{}", channel->GetServiceConfigJSON().c_str());
449 }
450
TEST_F(ServiceConfigEnd2endTest,NoServiceConfigWithDefaultConfigTest)451 TEST_F(ServiceConfigEnd2endTest, NoServiceConfigWithDefaultConfigTest) {
452 StartServers(1);
453 auto channel = BuildChannelWithDefaultServiceConfig();
454 auto stub = BuildStub(channel);
455 SetNextResolutionNoServiceConfig(GetServersPorts());
456 CheckRpcSendOk(stub, DEBUG_LOCATION);
457 EXPECT_STREQ(ValidDefaultServiceConfig(),
458 channel->GetServiceConfigJSON().c_str());
459 }
460
TEST_F(ServiceConfigEnd2endTest,InvalidServiceConfigTest)461 TEST_F(ServiceConfigEnd2endTest, InvalidServiceConfigTest) {
462 StartServers(1);
463 auto channel = BuildChannel();
464 auto stub = BuildStub(channel);
465 SetNextResolutionInvalidServiceConfig(GetServersPorts());
466 CheckRpcSendFailure(stub);
467 }
468
TEST_F(ServiceConfigEnd2endTest,ValidServiceConfigUpdatesTest)469 TEST_F(ServiceConfigEnd2endTest, ValidServiceConfigUpdatesTest) {
470 StartServers(1);
471 auto channel = BuildChannel();
472 auto stub = BuildStub(channel);
473 SetNextResolutionWithServiceConfig(GetServersPorts(), ValidServiceConfigV1());
474 CheckRpcSendOk(stub, DEBUG_LOCATION);
475 EXPECT_STREQ(ValidServiceConfigV1(), channel->GetServiceConfigJSON().c_str());
476 SetNextResolutionWithServiceConfig(GetServersPorts(), ValidServiceConfigV2());
477 CheckRpcSendOk(stub, DEBUG_LOCATION);
478 EXPECT_STREQ(ValidServiceConfigV2(), channel->GetServiceConfigJSON().c_str());
479 }
480
TEST_F(ServiceConfigEnd2endTest,NoServiceConfigUpdateAfterValidServiceConfigTest)481 TEST_F(ServiceConfigEnd2endTest,
482 NoServiceConfigUpdateAfterValidServiceConfigTest) {
483 StartServers(1);
484 auto channel = BuildChannel();
485 auto stub = BuildStub(channel);
486 SetNextResolutionWithServiceConfig(GetServersPorts(), ValidServiceConfigV1());
487 CheckRpcSendOk(stub, DEBUG_LOCATION);
488 EXPECT_STREQ(ValidServiceConfigV1(), channel->GetServiceConfigJSON().c_str());
489 SetNextResolutionNoServiceConfig(GetServersPorts());
490 CheckRpcSendOk(stub, DEBUG_LOCATION);
491 EXPECT_STREQ("{}", channel->GetServiceConfigJSON().c_str());
492 }
493
TEST_F(ServiceConfigEnd2endTest,NoServiceConfigUpdateAfterValidServiceConfigWithDefaultConfigTest)494 TEST_F(ServiceConfigEnd2endTest,
495 NoServiceConfigUpdateAfterValidServiceConfigWithDefaultConfigTest) {
496 StartServers(1);
497 auto channel = BuildChannelWithDefaultServiceConfig();
498 auto stub = BuildStub(channel);
499 SetNextResolutionWithServiceConfig(GetServersPorts(), ValidServiceConfigV1());
500 CheckRpcSendOk(stub, DEBUG_LOCATION);
501 EXPECT_STREQ(ValidServiceConfigV1(), channel->GetServiceConfigJSON().c_str());
502 SetNextResolutionNoServiceConfig(GetServersPorts());
503 CheckRpcSendOk(stub, DEBUG_LOCATION);
504 EXPECT_STREQ(ValidDefaultServiceConfig(),
505 channel->GetServiceConfigJSON().c_str());
506 }
507
TEST_F(ServiceConfigEnd2endTest,InvalidServiceConfigUpdateAfterValidServiceConfigTest)508 TEST_F(ServiceConfigEnd2endTest,
509 InvalidServiceConfigUpdateAfterValidServiceConfigTest) {
510 StartServers(1);
511 auto channel = BuildChannel();
512 auto stub = BuildStub(channel);
513 SetNextResolutionWithServiceConfig(GetServersPorts(), ValidServiceConfigV1());
514 CheckRpcSendOk(stub, DEBUG_LOCATION);
515 EXPECT_STREQ(ValidServiceConfigV1(), channel->GetServiceConfigJSON().c_str());
516 SetNextResolutionInvalidServiceConfig(GetServersPorts());
517 CheckRpcSendOk(stub, DEBUG_LOCATION);
518 EXPECT_STREQ(ValidServiceConfigV1(), channel->GetServiceConfigJSON().c_str());
519 }
520
TEST_F(ServiceConfigEnd2endTest,InvalidServiceConfigUpdateAfterValidServiceConfigWithDefaultConfigTest)521 TEST_F(ServiceConfigEnd2endTest,
522 InvalidServiceConfigUpdateAfterValidServiceConfigWithDefaultConfigTest) {
523 StartServers(1);
524 auto channel = BuildChannelWithDefaultServiceConfig();
525 auto stub = BuildStub(channel);
526 SetNextResolutionWithServiceConfig(GetServersPorts(), ValidServiceConfigV1());
527 CheckRpcSendOk(stub, DEBUG_LOCATION);
528 EXPECT_STREQ(ValidServiceConfigV1(), channel->GetServiceConfigJSON().c_str());
529 SetNextResolutionInvalidServiceConfig(GetServersPorts());
530 CheckRpcSendOk(stub, DEBUG_LOCATION);
531 EXPECT_STREQ(ValidServiceConfigV1(), channel->GetServiceConfigJSON().c_str());
532 }
533
TEST_F(ServiceConfigEnd2endTest,ValidServiceConfigAfterInvalidServiceConfigTest)534 TEST_F(ServiceConfigEnd2endTest,
535 ValidServiceConfigAfterInvalidServiceConfigTest) {
536 StartServers(1);
537 auto channel = BuildChannel();
538 auto stub = BuildStub(channel);
539 SetNextResolutionInvalidServiceConfig(GetServersPorts());
540 CheckRpcSendFailure(stub);
541 SetNextResolutionValidServiceConfig(GetServersPorts());
542 CheckRpcSendOk(stub, DEBUG_LOCATION);
543 }
544
TEST_F(ServiceConfigEnd2endTest,NoServiceConfigAfterInvalidServiceConfigTest)545 TEST_F(ServiceConfigEnd2endTest, NoServiceConfigAfterInvalidServiceConfigTest) {
546 StartServers(1);
547 auto channel = BuildChannel();
548 auto stub = BuildStub(channel);
549 SetNextResolutionInvalidServiceConfig(GetServersPorts());
550 CheckRpcSendFailure(stub);
551 SetNextResolutionNoServiceConfig(GetServersPorts());
552 CheckRpcSendOk(stub, DEBUG_LOCATION);
553 EXPECT_STREQ("{}", channel->GetServiceConfigJSON().c_str());
554 }
555
TEST_F(ServiceConfigEnd2endTest,AnotherInvalidServiceConfigAfterInvalidServiceConfigTest)556 TEST_F(ServiceConfigEnd2endTest,
557 AnotherInvalidServiceConfigAfterInvalidServiceConfigTest) {
558 StartServers(1);
559 auto channel = BuildChannel();
560 auto stub = BuildStub(channel);
561 SetNextResolutionInvalidServiceConfig(GetServersPorts());
562 CheckRpcSendFailure(stub);
563 SetNextResolutionInvalidServiceConfig(GetServersPorts());
564 CheckRpcSendFailure(stub);
565 }
566
TEST_F(ServiceConfigEnd2endTest,InvalidDefaultServiceConfigTest)567 TEST_F(ServiceConfigEnd2endTest, InvalidDefaultServiceConfigTest) {
568 StartServers(1);
569 auto channel = BuildChannelWithInvalidDefaultServiceConfig();
570 auto stub = BuildStub(channel);
571 // An invalid default service config results in a lame channel which fails all
572 // RPCs
573 CheckRpcSendFailure(stub);
574 }
575
TEST_F(ServiceConfigEnd2endTest,InvalidDefaultServiceConfigTestWithValidServiceConfig)576 TEST_F(ServiceConfigEnd2endTest,
577 InvalidDefaultServiceConfigTestWithValidServiceConfig) {
578 StartServers(1);
579 auto channel = BuildChannelWithInvalidDefaultServiceConfig();
580 auto stub = BuildStub(channel);
581 CheckRpcSendFailure(stub);
582 // An invalid default service config results in a lame channel which fails all
583 // RPCs
584 SetNextResolutionValidServiceConfig(GetServersPorts());
585 CheckRpcSendFailure(stub);
586 }
587
TEST_F(ServiceConfigEnd2endTest,InvalidDefaultServiceConfigTestWithInvalidServiceConfig)588 TEST_F(ServiceConfigEnd2endTest,
589 InvalidDefaultServiceConfigTestWithInvalidServiceConfig) {
590 StartServers(1);
591 auto channel = BuildChannelWithInvalidDefaultServiceConfig();
592 auto stub = BuildStub(channel);
593 CheckRpcSendFailure(stub);
594 // An invalid default service config results in a lame channel which fails all
595 // RPCs
596 SetNextResolutionInvalidServiceConfig(GetServersPorts());
597 CheckRpcSendFailure(stub);
598 }
599
TEST_F(ServiceConfigEnd2endTest,InvalidDefaultServiceConfigTestWithNoServiceConfig)600 TEST_F(ServiceConfigEnd2endTest,
601 InvalidDefaultServiceConfigTestWithNoServiceConfig) {
602 StartServers(1);
603 auto channel = BuildChannelWithInvalidDefaultServiceConfig();
604 auto stub = BuildStub(channel);
605 CheckRpcSendFailure(stub);
606 // An invalid default service config results in a lame channel which fails all
607 // RPCs
608 SetNextResolutionNoServiceConfig(GetServersPorts());
609 CheckRpcSendFailure(stub);
610 }
611
612 } // namespace
613 } // namespace testing
614 } // namespace grpc
615
main(int argc,char ** argv)616 int main(int argc, char** argv) {
617 ::testing::InitGoogleTest(&argc, argv);
618 grpc::testing::TestEnvironment env(argc, argv);
619 const auto result = RUN_ALL_TESTS();
620 return result;
621 }
622