test/cpp/end2end/service_config_end2end_test.cc

   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:
  77   MyTestServiceImpl() : request_count_(0) {}
  78
  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
  89   int request_count() {
  90     grpc::internal::MutexLock lock(&mu_);
  91     return request_count_;
  92   }
  93
  94   void ResetCounters() {
  95     grpc::internal::MutexLock lock(&mu_);
  96     request_count_ = 0;
  97   }
  98
  99   std::set<std::string> clients() {
 100     grpc::internal::MutexLock lock(&clients_mu_);
 101     return clients_;
 102   }
 103
 104  private:
 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:
 118   ServiceConfigEnd2endTest()
 119       : server_host_("localhost"),
 120         kRequestMessage_("Live long and prosper."),
 121         creds_(new SecureChannelCredentials(
 122             grpc_fake_transport_security_credentials_create())) {}
 123
 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
 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
 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
 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
 164   void StartServer(size_t index) { servers_[index]->Start(server_host_); }
 165
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 312     explicit ServerData(int port = 0)
 313         : port_(port > 0 ? port : grpc_pick_unused_port_or_die()) {}
 314
 315     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
 328     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
 342     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
 350     void SetServingStatus(const std::string& service, bool serving) {
 351       server_->GetHealthCheckService()->SetServingStatus(service, serving);
 352     }
 353   };
 354
 355   void ResetCounters() {
 356     for (const auto& server : servers_) server->service_.ResetCounters();
 357   }
 358
 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
 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
 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
 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.
 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
 420   const char* ValidServiceConfigV1() { return "{\"version\": \"1\"}"; }
 421
 422   const char* ValidServiceConfigV2() { return "{\"version\": \"2\"}"; }
 423
 424   const char* ValidDefaultServiceConfig() {
 425     return "{\"version\": \"valid_default\"}";
 426   }
 427
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 }