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 <gtest/gtest.h>
20
21 #include "absl/log/check.h"
22 #include "google/protobuf/duration.upb.h"
23 #include "upb/mem/arena.hpp"
24
25 #include <grpc/grpc.h>
26 #include <grpcpp/support/config.h>
27
28 #include "src/core/lib/address_utils/sockaddr_utils.h"
29 #include "src/core/lib/iomgr/sockaddr.h"
30 #include "src/core/load_balancing/grpclb/load_balancer_api.h"
31 #include "src/proto/grpc/lb/v1/load_balancer.pb.h" // C++ version
32 #include "test/core/util/test_config.h"
33
34 namespace grpc {
35 namespace {
36
37 using grpc::lb::v1::LoadBalanceRequest;
38 using grpc::lb::v1::LoadBalanceResponse;
39
40 class GrpclbTest : public ::testing::Test {
41 protected:
SetUpTestSuite()42 static void SetUpTestSuite() { grpc_init(); }
43
TearDownTestSuite()44 static void TearDownTestSuite() { grpc_shutdown(); }
45 };
46
Ip4ToPackedString(const char * ip_str)47 std::string Ip4ToPackedString(const char* ip_str) {
48 struct in_addr ip4;
49 CHECK(inet_pton(AF_INET, ip_str, &ip4) == 1);
50 return std::string(reinterpret_cast<const char*>(&ip4), sizeof(ip4));
51 }
52
PackedStringToIp(const grpc_core::GrpcLbServer & server)53 std::string PackedStringToIp(const grpc_core::GrpcLbServer& server) {
54 char ip_str[46] = {0};
55 int af = -1;
56 if (server.ip_size == 4) {
57 af = AF_INET;
58 } else if (server.ip_size == 16) {
59 af = AF_INET6;
60 } else {
61 abort();
62 }
63 CHECK(inet_ntop(af, (void*)server.ip_addr, ip_str, 46) != nullptr);
64 return ip_str;
65 }
66
TEST_F(GrpclbTest,CreateRequest)67 TEST_F(GrpclbTest, CreateRequest) {
68 const std::string service_name = "AServiceName";
69 LoadBalanceRequest request;
70 upb::Arena arena;
71 grpc_slice slice =
72 grpc_core::GrpcLbRequestCreate(service_name.c_str(), arena.ptr());
73 const int num_bytes_written = GRPC_SLICE_LENGTH(slice);
74 EXPECT_GT(num_bytes_written, 0);
75 request.ParseFromArray(GRPC_SLICE_START_PTR(slice), num_bytes_written);
76 EXPECT_EQ(request.initial_request().name(), service_name);
77 grpc_slice_unref(slice);
78 }
79
TEST_F(GrpclbTest,ParseInitialResponse)80 TEST_F(GrpclbTest, ParseInitialResponse) {
81 // Construct response to parse.
82 LoadBalanceResponse response;
83 auto* initial_response = response.mutable_initial_response();
84 auto* client_stats_report_interval =
85 initial_response->mutable_client_stats_report_interval();
86 client_stats_report_interval->set_seconds(123);
87 client_stats_report_interval->set_nanos(456000000);
88 const std::string encoded_response = response.SerializeAsString();
89 grpc_slice encoded_slice =
90 grpc_slice_from_copied_string(encoded_response.c_str());
91 // Test parsing.
92 grpc_core::GrpcLbResponse resp;
93 upb::Arena arena;
94 ASSERT_TRUE(
95 grpc_core::GrpcLbResponseParse(encoded_slice, arena.ptr(), &resp));
96 grpc_slice_unref(encoded_slice);
97 EXPECT_EQ(resp.type, resp.INITIAL);
98 EXPECT_EQ(resp.client_stats_report_interval,
99 grpc_core::Duration::Milliseconds(123456));
100 EXPECT_EQ(resp.serverlist.size(), 0);
101 }
102
TEST_F(GrpclbTest,ParseResponseServerList)103 TEST_F(GrpclbTest, ParseResponseServerList) {
104 // Construct response to parse.
105 LoadBalanceResponse response;
106 auto* serverlist = response.mutable_server_list();
107 auto* server = serverlist->add_servers();
108 server->set_ip_address(Ip4ToPackedString("127.0.0.1"));
109 server->set_port(12345);
110 server->set_load_balance_token("rate_limting");
111 server->set_drop(true);
112 server = response.mutable_server_list()->add_servers();
113 server->set_ip_address(Ip4ToPackedString("10.0.0.1"));
114 server->set_port(54321);
115 server->set_load_balance_token("load_balancing");
116 server->set_drop(true);
117 const std::string encoded_response = response.SerializeAsString();
118 const grpc_slice encoded_slice = grpc_slice_from_copied_buffer(
119 encoded_response.data(), encoded_response.size());
120 // Test parsing.
121 grpc_core::GrpcLbResponse resp;
122 upb::Arena arena;
123 ASSERT_TRUE(
124 grpc_core::GrpcLbResponseParse(encoded_slice, arena.ptr(), &resp));
125 grpc_slice_unref(encoded_slice);
126 EXPECT_EQ(resp.type, resp.SERVERLIST);
127 EXPECT_EQ(resp.serverlist.size(), 2);
128 EXPECT_EQ(PackedStringToIp(resp.serverlist[0]), "127.0.0.1");
129 EXPECT_EQ(resp.serverlist[0].port, 12345);
130 EXPECT_STREQ(resp.serverlist[0].load_balance_token, "rate_limting");
131 EXPECT_TRUE(resp.serverlist[0].drop);
132 EXPECT_EQ(PackedStringToIp(resp.serverlist[1]), "10.0.0.1");
133 EXPECT_EQ(resp.serverlist[1].port, 54321);
134 EXPECT_STREQ(resp.serverlist[1].load_balance_token, "load_balancing");
135 EXPECT_TRUE(resp.serverlist[1].drop);
136 }
137
138 } // namespace
139 } // namespace grpc
140
main(int argc,char ** argv)141 int main(int argc, char** argv) {
142 grpc::testing::TestEnvironment env(&argc, argv);
143 ::testing::InitGoogleTest(&argc, argv);
144 int ret = RUN_ALL_TESTS();
145 return ret;
146 }
147