Imported Upstream version 1.27.0

[platform/upstream/grpc.git] / test / cpp / grpclb / grpclb_api_test.cc

diff --git a/test/cpp/grpclb/grpclb_api_test.cc b/test/cpp/grpclb/grpclb_api_test.cc
index 62e7c06..a74c7b1 100644 (file)
--- a/test/cpp/grpclb/grpclb_api_test.cc
+++ b/test/cpp/grpclb/grpclb_api_test.cc
@@ -45,18 +45,17 @@ grpc::string Ip4ToPackedString(const char* ip_str) {
   return grpc::string(reinterpret_cast<const char*>(&ip4), sizeof(ip4));
 }
 
-grpc::string PackedStringToIp(
-    const grpc_core::grpc_grpclb_server_ip_address& pb_ip) {
+grpc::string PackedStringToIp(const grpc_core::GrpcLbServer& server) {
   char ip_str[46] = {0};
   int af = -1;
-  if (pb_ip.size == 4) {
+  if (server.ip_size == 4) {
     af = AF_INET;
-  } else if (pb_ip.size == 16) {
+  } else if (server.ip_size == 16) {
     af = AF_INET6;
   } else {
     abort();
   }
-  GPR_ASSERT(inet_ntop(af, (void*)pb_ip.data, ip_str, 46) != nullptr);
+  GPR_ASSERT(inet_ntop(af, (void*)server.ip_addr, ip_str, 46) != nullptr);
   return ip_str;
 }
 
@@ -64,9 +63,8 @@ TEST_F(GrpclbTest, CreateRequest) {
   const grpc::string service_name = "AServiceName";
   LoadBalanceRequest request;
   upb::Arena arena;
-  grpc_core::grpc_grpclb_request* c_req =
-      grpc_core::grpc_grpclb_request_create(service_name.c_str(), arena.ptr());
-  grpc_slice slice = grpc_core::grpc_grpclb_request_encode(c_req, arena.ptr());
+  grpc_slice slice =
+      grpc_core::GrpcLbRequestCreate(service_name.c_str(), arena.ptr());
   const int num_bytes_written = GRPC_SLICE_LENGTH(slice);
   EXPECT_GT(num_bytes_written, 0);
   request.ParseFromArray(GRPC_SLICE_START_PTR(slice), num_bytes_written);
@@ -75,34 +73,29 @@ TEST_F(GrpclbTest, CreateRequest) {
 }
 
 TEST_F(GrpclbTest, ParseInitialResponse) {
+  // Construct response to parse.
   LoadBalanceResponse response;
   auto* initial_response = response.mutable_initial_response();
   auto* client_stats_report_interval =
       initial_response->mutable_client_stats_report_interval();
   client_stats_report_interval->set_seconds(123);
-  client_stats_report_interval->set_nanos(456);
+  client_stats_report_interval->set_nanos(456000000);
   const grpc::string encoded_response = response.SerializeAsString();
   grpc_slice encoded_slice =
       grpc_slice_from_copied_string(encoded_response.c_str());
-
+  // Test parsing.
+  grpc_core::GrpcLbResponse resp;
   upb::Arena arena;
-  const grpc_core::grpc_grpclb_initial_response* c_initial_response =
-      grpc_core::grpc_grpclb_initial_response_parse(encoded_slice, arena.ptr());
-
-  upb_strview load_balancer_delegate =
-      grpc_lb_v1_InitialLoadBalanceResponse_load_balancer_delegate(
-          c_initial_response);
-  EXPECT_EQ(load_balancer_delegate.size, 0);
-
-  const google_protobuf_Duration* report_interval =
-      grpc_lb_v1_InitialLoadBalanceResponse_client_stats_report_interval(
-          c_initial_response);
-  EXPECT_EQ(google_protobuf_Duration_seconds(report_interval), 123);
-  EXPECT_EQ(google_protobuf_Duration_nanos(report_interval), 456);
+  ASSERT_TRUE(
+      grpc_core::GrpcLbResponseParse(encoded_slice, arena.ptr(), &resp));
   grpc_slice_unref(encoded_slice);
+  EXPECT_EQ(resp.type, resp.INITIAL);
+  EXPECT_EQ(resp.client_stats_report_interval, 123456);
+  EXPECT_EQ(resp.serverlist.size(), 0);
 }
 
 TEST_F(GrpclbTest, ParseResponseServerList) {
+  // Construct response to parse.
   LoadBalanceResponse response;
   auto* serverlist = response.mutable_server_list();
   auto* server = serverlist->add_servers();
@@ -115,26 +108,25 @@ TEST_F(GrpclbTest, ParseResponseServerList) {
   server->set_port(54321);
   server->set_load_balance_token("load_balancing");
   server->set_drop(true);
-
   const grpc::string encoded_response = response.SerializeAsString();
   const grpc_slice encoded_slice = grpc_slice_from_copied_buffer(
       encoded_response.data(), encoded_response.size());
-  grpc_core::grpc_grpclb_serverlist* c_serverlist =
-      grpc_core::grpc_grpclb_response_parse_serverlist(encoded_slice);
-  ASSERT_EQ(c_serverlist->num_servers, 2ul);
-  EXPECT_EQ(PackedStringToIp(c_serverlist->servers[0]->ip_address),
-            "127.0.0.1");
-  EXPECT_EQ(c_serverlist->servers[0]->port, 12345);
-  EXPECT_STREQ(c_serverlist->servers[0]->load_balance_token, "rate_limting");
-  EXPECT_TRUE(c_serverlist->servers[0]->drop);
-
-  EXPECT_EQ(PackedStringToIp(c_serverlist->servers[1]->ip_address), "10.0.0.1");
-  EXPECT_EQ(c_serverlist->servers[1]->port, 54321);
-  EXPECT_STREQ(c_serverlist->servers[1]->load_balance_token, "load_balancing");
-  EXPECT_TRUE(c_serverlist->servers[1]->drop);
-
+  // Test parsing.
+  grpc_core::GrpcLbResponse resp;
+  upb::Arena arena;
+  ASSERT_TRUE(
+      grpc_core::GrpcLbResponseParse(encoded_slice, arena.ptr(), &resp));
   grpc_slice_unref(encoded_slice);
-  grpc_grpclb_destroy_serverlist(c_serverlist);
+  EXPECT_EQ(resp.type, resp.SERVERLIST);
+  EXPECT_EQ(resp.serverlist.size(), 2);
+  EXPECT_EQ(PackedStringToIp(resp.serverlist[0]), "127.0.0.1");
+  EXPECT_EQ(resp.serverlist[0].port, 12345);
+  EXPECT_STREQ(resp.serverlist[0].load_balance_token, "rate_limting");
+  EXPECT_TRUE(resp.serverlist[0].drop);
+  EXPECT_EQ(PackedStringToIp(resp.serverlist[1]), "10.0.0.1");
+  EXPECT_EQ(resp.serverlist[1].port, 54321);
+  EXPECT_STREQ(resp.serverlist[1].load_balance_token, "load_balancing");
+  EXPECT_TRUE(resp.serverlist[1].drop);
 }
 
 }  // namespace