1 // Copyright 2017 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include "google/cloud/bigtable/client_options.h"
16 #include "google/cloud/bigtable/internal/client_options_defaults.h"
17 #include "google/cloud/status.h"
18 #include "google/cloud/testing_util/assert_ok.h"
19 #include "google/cloud/testing_util/scoped_environment.h"
20 #include <gmock/gmock.h>
21 #include <cstdlib>
22 
23 namespace google {
24 namespace cloud {
25 namespace bigtable {
26 inline namespace BIGTABLE_CLIENT_NS {
27 struct ClientOptionsTestTraits {
InstanceAdminEndpointgoogle::cloud::bigtable::BIGTABLE_CLIENT_NS::ClientOptionsTestTraits28   static std::string const& InstanceAdminEndpoint(
29       bigtable::ClientOptions const& options) {
30     return options.instance_admin_endpoint();
31   }
32 };
33 
34 namespace {
35 
36 using ::testing::HasSubstr;
37 
TEST(ClientOptionsTest,ClientOptionsDefaultSettings)38 TEST(ClientOptionsTest, ClientOptionsDefaultSettings) {
39   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
40   EXPECT_EQ("bigtable.googleapis.com", client_options_object.data_endpoint());
41   EXPECT_EQ("bigtableadmin.googleapis.com",
42             client_options_object.admin_endpoint());
43   EXPECT_EQ(typeid(grpc::GoogleDefaultCredentials()),
44             typeid(client_options_object.credentials()));
45 
46   EXPECT_EQ("", client_options_object.connection_pool_name());
47   // The number of connections should be >= 1, we "know" what the actual value
48   // is, but we do not want a change-detection-test.
49   EXPECT_LE(1UL, client_options_object.connection_pool_size());
50 }
51 
52 class ClientOptionsDefaultEndpointTest : public ::testing::Test {
53  public:
ClientOptionsDefaultEndpointTest()54   ClientOptionsDefaultEndpointTest()
55       : bigtable_emulator_host_("BIGTABLE_EMULATOR_HOST",
56                                 "testendpoint.googleapis.com"),
57         bigtable_instance_admin_emulator_host_(
58             "BIGTABLE_INSTANCE_ADMIN_EMULATOR_HOST", {}),
59         google_cloud_enable_direct_path_("GOOGLE_CLOUD_ENABLE_DIRECT_PATH",
60                                          {}) {}
61 
62  protected:
GetInstanceAdminEndpoint(ClientOptions const & options)63   static std::string GetInstanceAdminEndpoint(ClientOptions const& options) {
64     return ClientOptionsTestTraits::InstanceAdminEndpoint(options);
65   }
66 
67  protected:
68   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host_;
69   google::cloud::testing_util::ScopedEnvironment
70       bigtable_instance_admin_emulator_host_;
71   google::cloud::testing_util::ScopedEnvironment
72       google_cloud_enable_direct_path_;
73 };
74 
TEST_F(ClientOptionsDefaultEndpointTest,Default)75 TEST_F(ClientOptionsDefaultEndpointTest, Default) {
76   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
77   EXPECT_EQ("testendpoint.googleapis.com",
78             client_options_object.data_endpoint());
79   EXPECT_EQ("testendpoint.googleapis.com",
80             client_options_object.admin_endpoint());
81   EXPECT_EQ("testendpoint.googleapis.com",
82             GetInstanceAdminEndpoint(client_options_object));
83 }
84 
TEST_F(ClientOptionsDefaultEndpointTest,WithCredentials)85 TEST_F(ClientOptionsDefaultEndpointTest, WithCredentials) {
86   auto credentials = grpc::GoogleDefaultCredentials();
87   bigtable::ClientOptions tested(credentials);
88   EXPECT_EQ("bigtable.googleapis.com", tested.data_endpoint());
89   EXPECT_EQ("bigtableadmin.googleapis.com", tested.admin_endpoint());
90   EXPECT_EQ(credentials.get(), tested.credentials().get());
91 }
92 
TEST_F(ClientOptionsDefaultEndpointTest,DefaultNoEmulator)93 TEST_F(ClientOptionsDefaultEndpointTest, DefaultNoEmulator) {
94   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
95       "BIGTABLE_EMULATOR_HOST", {});
96 
97   auto credentials = grpc::GoogleDefaultCredentials();
98   bigtable::ClientOptions tested(credentials);
99   EXPECT_EQ("bigtable.googleapis.com", tested.data_endpoint());
100   EXPECT_EQ("bigtableadmin.googleapis.com", tested.admin_endpoint());
101   EXPECT_EQ("bigtableadmin.googleapis.com", GetInstanceAdminEndpoint(tested));
102 }
103 
TEST_F(ClientOptionsDefaultEndpointTest,SeparateEmulators)104 TEST_F(ClientOptionsDefaultEndpointTest, SeparateEmulators) {
105   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
106       "BIGTABLE_EMULATOR_HOST", "emulator-host:8000");
107   google::cloud::testing_util::ScopedEnvironment
108       bigtable_instance_admin_emulator_host(
109           "BIGTABLE_INSTANCE_ADMIN_EMULATOR_HOST",
110           "instance-emulator-host:9000");
111   bigtable::ClientOptions actual = bigtable::ClientOptions();
112   EXPECT_EQ("emulator-host:8000", actual.data_endpoint());
113   EXPECT_EQ("emulator-host:8000", actual.admin_endpoint());
114   EXPECT_EQ("instance-emulator-host:9000", GetInstanceAdminEndpoint(actual));
115 }
116 
TEST_F(ClientOptionsDefaultEndpointTest,DataNoEnv)117 TEST_F(ClientOptionsDefaultEndpointTest, DataNoEnv) {
118   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
119       "BIGTABLE_EMULATOR_HOST", {});
120 
121   EXPECT_EQ("bigtable.googleapis.com", internal::DefaultDataEndpoint());
122 }
123 
TEST_F(ClientOptionsDefaultEndpointTest,DataDirectPathMismatched)124 TEST_F(ClientOptionsDefaultEndpointTest, DataDirectPathMismatched) {
125   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
126       "BIGTABLE_EMULATOR_HOST", {});
127   google::cloud::testing_util::ScopedEnvironment
128       google_cloud_enable_direct_path(
129           "GOOGLE_CLOUD_ENABLE_DIRECT_PATH",
130           "bad-name-for-bigtable,bigtable-no-no,bar");
131 
132   EXPECT_EQ("bigtable.googleapis.com", internal::DefaultDataEndpoint());
133 }
134 
TEST_F(ClientOptionsDefaultEndpointTest,DataDirectPath)135 TEST_F(ClientOptionsDefaultEndpointTest, DataDirectPath) {
136   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
137       "BIGTABLE_EMULATOR_HOST", {});
138   google::cloud::testing_util::ScopedEnvironment
139       google_cloud_enable_direct_path("GOOGLE_CLOUD_ENABLE_DIRECT_PATH",
140                                       "bigtable-mismatch,bigtable");
141 
142   EXPECT_EQ("directpath-bigtable.googleapis.com",
143             internal::DefaultDataEndpoint());
144 }
145 
TEST_F(ClientOptionsDefaultEndpointTest,DataEmulatorOverridesDirectPath)146 TEST_F(ClientOptionsDefaultEndpointTest, DataEmulatorOverridesDirectPath) {
147   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
148       "BIGTABLE_EMULATOR_HOST", "127.0.0.1:1234");
149   google::cloud::testing_util::ScopedEnvironment
150       google_cloud_enable_direct_path("GOOGLE_CLOUD_ENABLE_DIRECT_PATH",
151                                       "bigtable");
152 
153   EXPECT_EQ("127.0.0.1:1234", internal::DefaultDataEndpoint());
154 }
155 
TEST_F(ClientOptionsDefaultEndpointTest,AdminNoEnv)156 TEST_F(ClientOptionsDefaultEndpointTest, AdminNoEnv) {
157   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
158       "BIGTABLE_EMULATOR_HOST", {});
159 
160   EXPECT_EQ("bigtableadmin.googleapis.com", internal::DefaultAdminEndpoint());
161 }
162 
TEST_F(ClientOptionsDefaultEndpointTest,AdminDirectPathNoEffect)163 TEST_F(ClientOptionsDefaultEndpointTest, AdminDirectPathNoEffect) {
164   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
165       "BIGTABLE_EMULATOR_HOST", {});
166   google::cloud::testing_util::ScopedEnvironment
167       google_cloud_enable_direct_path("GOOGLE_CLOUD_ENABLE_DIRECT_PATH",
168                                       "bigtable");
169 
170   EXPECT_EQ("bigtableadmin.googleapis.com", internal::DefaultAdminEndpoint());
171 }
172 
TEST_F(ClientOptionsDefaultEndpointTest,AdminEmulatorOverrides)173 TEST_F(ClientOptionsDefaultEndpointTest, AdminEmulatorOverrides) {
174   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
175       "BIGTABLE_EMULATOR_HOST", "127.0.0.1:1234");
176 
177   EXPECT_EQ("127.0.0.1:1234", internal::DefaultAdminEndpoint());
178 }
179 
TEST_F(ClientOptionsDefaultEndpointTest,AdminInstanceAdminNoEffect)180 TEST_F(ClientOptionsDefaultEndpointTest, AdminInstanceAdminNoEffect) {
181   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
182       "BIGTABLE_EMULATOR_HOST", {});
183   google::cloud::testing_util::ScopedEnvironment
184       bigtable_instance_admin_emulator_host(
185           "BIGTABLE_INSTANCE_ADMIN_EMULATOR_HOST", "127.0.0.1:1234");
186 
187   EXPECT_EQ("bigtableadmin.googleapis.com", internal::DefaultAdminEndpoint());
188 }
189 
TEST_F(ClientOptionsDefaultEndpointTest,InstanceAdminNoEnv)190 TEST_F(ClientOptionsDefaultEndpointTest, InstanceAdminNoEnv) {
191   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
192       "BIGTABLE_EMULATOR_HOST", {});
193 
194   EXPECT_EQ("bigtableadmin.googleapis.com",
195             internal::DefaultInstanceAdminEndpoint());
196 }
197 
TEST_F(ClientOptionsDefaultEndpointTest,InstanceAdminDirectPathNoEffect)198 TEST_F(ClientOptionsDefaultEndpointTest, InstanceAdminDirectPathNoEffect) {
199   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
200       "BIGTABLE_EMULATOR_HOST", {});
201   google::cloud::testing_util::ScopedEnvironment
202       google_cloud_enable_direct_path("GOOGLE_CLOUD_ENABLE_DIRECT_PATH",
203                                       "bigtable");
204 
205   EXPECT_EQ("bigtableadmin.googleapis.com",
206             internal::DefaultInstanceAdminEndpoint());
207 }
208 
TEST_F(ClientOptionsDefaultEndpointTest,InstanceAdminEmulatorOverrides)209 TEST_F(ClientOptionsDefaultEndpointTest, InstanceAdminEmulatorOverrides) {
210   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
211       "BIGTABLE_EMULATOR_HOST", "127.0.0.1:1234");
212 
213   EXPECT_EQ("127.0.0.1:1234", internal::DefaultInstanceAdminEndpoint());
214 }
215 
TEST_F(ClientOptionsDefaultEndpointTest,InstanceAdminInstanceAdminOverrides)216 TEST_F(ClientOptionsDefaultEndpointTest, InstanceAdminInstanceAdminOverrides) {
217   google::cloud::testing_util::ScopedEnvironment bigtable_emulator_host(
218       "BIGTABLE_EMULATOR_HOST", "unused");
219   google::cloud::testing_util::ScopedEnvironment
220       bigtable_instance_admin_emulator_host(
221           "BIGTABLE_INSTANCE_ADMIN_EMULATOR_HOST", "127.0.0.1:1234");
222 
223   EXPECT_EQ("127.0.0.1:1234", internal::DefaultInstanceAdminEndpoint());
224 }
225 
TEST(ClientOptionsTest,EditDataEndpoint)226 TEST(ClientOptionsTest, EditDataEndpoint) {
227   bigtable::ClientOptions client_options_object;
228   client_options_object =
229       client_options_object.set_data_endpoint("customendpoint.com");
230   EXPECT_EQ("customendpoint.com", client_options_object.data_endpoint());
231 }
232 
TEST(ClientOptionsTest,EditAdminEndpoint)233 TEST(ClientOptionsTest, EditAdminEndpoint) {
234   bigtable::ClientOptions client_options_object;
235   client_options_object =
236       client_options_object.set_admin_endpoint("customendpoint.com");
237   EXPECT_EQ("customendpoint.com", client_options_object.admin_endpoint());
238   EXPECT_EQ(
239       "customendpoint.com",
240       ClientOptionsTestTraits::InstanceAdminEndpoint(client_options_object));
241 }
242 
TEST(ClientOptionsTest,EditCredentials)243 TEST(ClientOptionsTest, EditCredentials) {
244   bigtable::ClientOptions client_options_object;
245   client_options_object =
246       client_options_object.SetCredentials(grpc::InsecureChannelCredentials());
247   EXPECT_EQ(typeid(grpc::InsecureChannelCredentials()),
248             typeid(client_options_object.credentials()));
249 }
250 
TEST(ClientOptionsTest,EditConnectionPoolName)251 TEST(ClientOptionsTest, EditConnectionPoolName) {
252   bigtable::ClientOptions client_options_object;
253   auto& returned = client_options_object.set_connection_pool_name("foo");
254   EXPECT_EQ(&returned, &client_options_object);
255   EXPECT_EQ("foo", returned.connection_pool_name());
256 }
257 
TEST(ClientOptionsTest,EditConnectionPoolSize)258 TEST(ClientOptionsTest, EditConnectionPoolSize) {
259   bigtable::ClientOptions client_options_object;
260   auto& returned = client_options_object.set_connection_pool_size(42);
261   EXPECT_EQ(&returned, &client_options_object);
262   EXPECT_EQ(42UL, returned.connection_pool_size());
263 }
264 
TEST(ClientOptionsTest,ResetToDefaultConnectionPoolSize)265 TEST(ClientOptionsTest, ResetToDefaultConnectionPoolSize) {
266   bigtable::ClientOptions client_options_object;
267   auto& returned = client_options_object.set_connection_pool_size(0);
268   EXPECT_EQ(&returned, &client_options_object);
269   // The number of connections should be >= 1, we "know" what the actual value
270   // is, but we do not want a change-detection-test.
271   EXPECT_LE(1UL, returned.connection_pool_size());
272 }
273 
TEST(ClientOptionsTest,SetGrpclbFallbackTimeoutMS)274 TEST(ClientOptionsTest, SetGrpclbFallbackTimeoutMS) {
275   // Test milliseconds are set properly to channel_arguments
276   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
277   ASSERT_STATUS_OK(client_options_object.SetGrpclbFallbackTimeout(
278       std::chrono::milliseconds(5)));
279   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
280   grpc_channel_args test_args = c_args.c_channel_args();
281   ASSERT_EQ(4UL, test_args.num_args);
282   // Use the low-level C API because grpc::ChannelArguments lacks high-level
283   // accessors.
284   // test_args now has 3 default arguments. Added max send/receive message size
285   // SetGrpclbFallbackTimeout() inserts new argument to args_ hence comparing
286   // 4th element of test_args.
287   EXPECT_EQ(GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS,
288             grpc::string(test_args.args[3].key));
289 }
290 
TEST(ClientOptionsTest,SetGrpclbFallbackTimeoutSec)291 TEST(ClientOptionsTest, SetGrpclbFallbackTimeoutSec) {
292   // Test seconds are converted into milliseconds
293   bigtable::ClientOptions client_options_object_second =
294       bigtable::ClientOptions();
295   ASSERT_STATUS_OK(client_options_object_second.SetGrpclbFallbackTimeout(
296       std::chrono::seconds(5)));
297   grpc::ChannelArguments c_args_second =
298       client_options_object_second.channel_arguments();
299   grpc_channel_args test_args_second = c_args_second.c_channel_args();
300   ASSERT_EQ(4UL, test_args_second.num_args);
301   EXPECT_EQ(GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS,
302             grpc::string(test_args_second.args[3].key));
303 }
304 
TEST(ClientOptionsTest,SetGrpclbFallbackTimeoutException)305 TEST(ClientOptionsTest, SetGrpclbFallbackTimeoutException) {
306   // Test if fallback_timeout exceeds int range and StatusCode
307   // matches kOutOfRange
308   bigtable::ClientOptions client_options_object_third =
309       bigtable::ClientOptions();
310   EXPECT_EQ(client_options_object_third
311                 .SetGrpclbFallbackTimeout(std::chrono::hours(999))
312                 .code(),
313             google::cloud::StatusCode::kOutOfRange);
314 }
315 
TEST(ClientOptionsTest,SetCompressionAlgorithm)316 TEST(ClientOptionsTest, SetCompressionAlgorithm) {
317   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
318   client_options_object.SetCompressionAlgorithm(GRPC_COMPRESS_NONE);
319   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
320   grpc_channel_args test_args = c_args.c_channel_args();
321   ASSERT_EQ(4UL, test_args.num_args);
322   // Use the low-level C API because grpc::ChannelArguments lacks high-level
323   // accessors.
324   // test_args now has 3 default arguments. Added max send/receive message size
325   // SetCompressionAlgorithm() inserts new argument to args_ hence comparing 4th
326   // element of test_args.
327   EXPECT_EQ(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM,
328             grpc::string(test_args.args[3].key));
329 }
330 
TEST(ClientOptionsTest,SetMaxReceiveMessageSize)331 TEST(ClientOptionsTest, SetMaxReceiveMessageSize) {
332   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
333   client_options_object.SetMaxReceiveMessageSize(256 * 1024L * 1024L);
334   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
335   grpc_channel_args test_args = c_args.c_channel_args();
336   ASSERT_EQ(4UL, test_args.num_args);
337   // Use the low-level C API because grpc::ChannelArguments lacks high-level
338   // accessors.
339   // test_args now has 3 default arguments. Added max send/receive message size
340   // SetMaxReceiveMessageSize() inserts new argument to args_ hence comparing
341   // 4th element of test_args.
342   EXPECT_EQ(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH,
343             grpc::string(test_args.args[3].key));
344 
345   EXPECT_EQ(test_args.args[3].value.integer, (256 * 1024L * 1024L));
346 }
347 
TEST(ClientOptionsTest,SetMaxSendMessageSize)348 TEST(ClientOptionsTest, SetMaxSendMessageSize) {
349   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
350   client_options_object.SetMaxSendMessageSize(256 * 1024L * 1024L);
351   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
352   grpc_channel_args test_args = c_args.c_channel_args();
353   ASSERT_EQ(4UL, test_args.num_args);
354   // Use the low-level C API because grpc::ChannelArguments lacks high-level
355   // accessors.
356   // test_args now has 3 default arguments. Added max send/receive message size
357   // SetMaxSendMessageSize() inserts new argument to args_ hence comparing 4th
358   // element of test_args.
359   EXPECT_EQ(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH,
360             grpc::string(test_args.args[3].key));
361 
362   EXPECT_EQ(test_args.args[3].value.integer, 256 * 1024L * 1024L);
363 }
364 
TEST(ClientOptionsTest,SetLoadBalancingPolicyName)365 TEST(ClientOptionsTest, SetLoadBalancingPolicyName) {
366   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
367   client_options_object.SetLoadBalancingPolicyName("test-policy-name");
368   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
369   grpc_channel_args test_args = c_args.c_channel_args();
370   ASSERT_EQ(4UL, test_args.num_args);
371   // Use the low-level C API because grpc::ChannelArguments lacks high-level
372   // accessors.
373   // test_args now has 3 default arguments. Added max send/receive message size
374   // SetLoadBalancingPolicyName() inserts new argument to args_ hence comparing
375   // 4th element of test_args.
376   EXPECT_EQ(GRPC_ARG_LB_POLICY_NAME, grpc::string(test_args.args[3].key));
377 }
378 
TEST(ClientOptionsTest,SetServiceConfigJSON)379 TEST(ClientOptionsTest, SetServiceConfigJSON) {
380   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
381   client_options_object.SetServiceConfigJSON("test-config");
382   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
383   grpc_channel_args test_args = c_args.c_channel_args();
384   ASSERT_EQ(4UL, test_args.num_args);
385   // Use the low-level C API because grpc::ChannelArguments lacks high-level
386   // accessors.
387   // test_args now has 3 default arguments. Added max send/receive message size
388   // SetServiceConfigJSON() inserts new argument to args_ hence comparing 4th
389   // element of test_args.
390   EXPECT_EQ(GRPC_ARG_SERVICE_CONFIG, grpc::string(test_args.args[3].key));
391 }
392 
TEST(ClientOptionsTest,SetUserAgentPrefix)393 TEST(ClientOptionsTest, SetUserAgentPrefix) {
394   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
395   client_options_object.SetUserAgentPrefix("test_prefix");
396   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
397   grpc_channel_args test_args = c_args.c_channel_args();
398   ASSERT_EQ(3UL, test_args.num_args);
399   // Use the low-level C API because grpc::ChannelArguments lacks high-level
400   // accessors.
401   // test_args now has 3 default arguments. Added max send/receive message size
402   // SetUserAgentPrefix() appends the new prefix to existing prefix hence
403   // comparing 1st element of test_args.
404   EXPECT_EQ(GRPC_ARG_PRIMARY_USER_AGENT_STRING,
405             grpc::string(test_args.args[0].key));
406 }
407 
TEST(ClientOptionsTest,SetSslTargetNameOverride)408 TEST(ClientOptionsTest, SetSslTargetNameOverride) {
409   bigtable::ClientOptions client_options_object = bigtable::ClientOptions();
410   client_options_object.SetSslTargetNameOverride("test-name");
411   grpc::ChannelArguments c_args = client_options_object.channel_arguments();
412   grpc_channel_args test_args = c_args.c_channel_args();
413   ASSERT_EQ(4UL, test_args.num_args);
414   // Use the low-level C API because grpc::ChannelArguments lacks high-level
415   // accessors.
416   // test_args now has 3 default arguments. Added max send/receive message size
417   // SetSslTargetNameOverride() inserts new argument to args_ hence comparing
418   // 4th element of test_args.
419   EXPECT_EQ(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG,
420             grpc::string(test_args.args[3].key));
421 }
422 
TEST(ClientOptionsTest,UserAgentPrefix)423 TEST(ClientOptionsTest, UserAgentPrefix) {
424   std::string const actual = bigtable::ClientOptions::UserAgentPrefix();
425 
426   EXPECT_THAT(actual, HasSubstr("gcloud-cpp/"));
427 }
428 
429 }  // namespace
430 }  // namespace BIGTABLE_CLIENT_NS
431 }  // namespace bigtable
432 }  // namespace cloud
433 }  // namespace google
434