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