• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.cloud.gkehub.v1;
18 
19 import static com.google.cloud.gkehub.v1.GkeHubClient.ListFeaturesPagedResponse;
20 import static com.google.cloud.gkehub.v1.GkeHubClient.ListMembershipsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.common.collect.Lists;
31 import com.google.longrunning.Operation;
32 import com.google.protobuf.AbstractMessage;
33 import com.google.protobuf.Any;
34 import com.google.protobuf.ByteString;
35 import com.google.protobuf.Empty;
36 import com.google.protobuf.FieldMask;
37 import com.google.protobuf.Timestamp;
38 import io.grpc.StatusRuntimeException;
39 import java.io.IOException;
40 import java.util.ArrayList;
41 import java.util.Arrays;
42 import java.util.HashMap;
43 import java.util.List;
44 import java.util.UUID;
45 import java.util.concurrent.ExecutionException;
46 import javax.annotation.Generated;
47 import org.junit.After;
48 import org.junit.AfterClass;
49 import org.junit.Assert;
50 import org.junit.Before;
51 import org.junit.BeforeClass;
52 import org.junit.Test;
53 
54 @Generated("by gapic-generator-java")
55 public class GkeHubClientTest {
56   private static MockGkeHub mockGkeHub;
57   private static MockServiceHelper mockServiceHelper;
58   private LocalChannelProvider channelProvider;
59   private GkeHubClient client;
60 
61   @BeforeClass
startStaticServer()62   public static void startStaticServer() {
63     mockGkeHub = new MockGkeHub();
64     mockServiceHelper =
65         new MockServiceHelper(
66             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockGkeHub));
67     mockServiceHelper.start();
68   }
69 
70   @AfterClass
stopServer()71   public static void stopServer() {
72     mockServiceHelper.stop();
73   }
74 
75   @Before
setUp()76   public void setUp() throws IOException {
77     mockServiceHelper.reset();
78     channelProvider = mockServiceHelper.createChannelProvider();
79     GkeHubSettings settings =
80         GkeHubSettings.newBuilder()
81             .setTransportChannelProvider(channelProvider)
82             .setCredentialsProvider(NoCredentialsProvider.create())
83             .build();
84     client = GkeHubClient.create(settings);
85   }
86 
87   @After
tearDown()88   public void tearDown() throws Exception {
89     client.close();
90   }
91 
92   @Test
listMembershipsTest()93   public void listMembershipsTest() throws Exception {
94     Membership responsesElement = Membership.newBuilder().build();
95     ListMembershipsResponse expectedResponse =
96         ListMembershipsResponse.newBuilder()
97             .setNextPageToken("")
98             .addAllResources(Arrays.asList(responsesElement))
99             .build();
100     mockGkeHub.addResponse(expectedResponse);
101 
102     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
103 
104     ListMembershipsPagedResponse pagedListResponse = client.listMemberships(parent);
105 
106     List<Membership> resources = Lists.newArrayList(pagedListResponse.iterateAll());
107 
108     Assert.assertEquals(1, resources.size());
109     Assert.assertEquals(expectedResponse.getResourcesList().get(0), resources.get(0));
110 
111     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
112     Assert.assertEquals(1, actualRequests.size());
113     ListMembershipsRequest actualRequest = ((ListMembershipsRequest) actualRequests.get(0));
114 
115     Assert.assertEquals(parent.toString(), actualRequest.getParent());
116     Assert.assertTrue(
117         channelProvider.isHeaderSent(
118             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
119             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
120   }
121 
122   @Test
listMembershipsExceptionTest()123   public void listMembershipsExceptionTest() throws Exception {
124     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
125     mockGkeHub.addException(exception);
126 
127     try {
128       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
129       client.listMemberships(parent);
130       Assert.fail("No exception raised");
131     } catch (InvalidArgumentException e) {
132       // Expected exception.
133     }
134   }
135 
136   @Test
listMembershipsTest2()137   public void listMembershipsTest2() throws Exception {
138     Membership responsesElement = Membership.newBuilder().build();
139     ListMembershipsResponse expectedResponse =
140         ListMembershipsResponse.newBuilder()
141             .setNextPageToken("")
142             .addAllResources(Arrays.asList(responsesElement))
143             .build();
144     mockGkeHub.addResponse(expectedResponse);
145 
146     String parent = "parent-995424086";
147 
148     ListMembershipsPagedResponse pagedListResponse = client.listMemberships(parent);
149 
150     List<Membership> resources = Lists.newArrayList(pagedListResponse.iterateAll());
151 
152     Assert.assertEquals(1, resources.size());
153     Assert.assertEquals(expectedResponse.getResourcesList().get(0), resources.get(0));
154 
155     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
156     Assert.assertEquals(1, actualRequests.size());
157     ListMembershipsRequest actualRequest = ((ListMembershipsRequest) actualRequests.get(0));
158 
159     Assert.assertEquals(parent, actualRequest.getParent());
160     Assert.assertTrue(
161         channelProvider.isHeaderSent(
162             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
163             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
164   }
165 
166   @Test
listMembershipsExceptionTest2()167   public void listMembershipsExceptionTest2() throws Exception {
168     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
169     mockGkeHub.addException(exception);
170 
171     try {
172       String parent = "parent-995424086";
173       client.listMemberships(parent);
174       Assert.fail("No exception raised");
175     } catch (InvalidArgumentException e) {
176       // Expected exception.
177     }
178   }
179 
180   @Test
listFeaturesTest()181   public void listFeaturesTest() throws Exception {
182     Feature responsesElement = Feature.newBuilder().build();
183     ListFeaturesResponse expectedResponse =
184         ListFeaturesResponse.newBuilder()
185             .setNextPageToken("")
186             .addAllResources(Arrays.asList(responsesElement))
187             .build();
188     mockGkeHub.addResponse(expectedResponse);
189 
190     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
191 
192     ListFeaturesPagedResponse pagedListResponse = client.listFeatures(parent);
193 
194     List<Feature> resources = Lists.newArrayList(pagedListResponse.iterateAll());
195 
196     Assert.assertEquals(1, resources.size());
197     Assert.assertEquals(expectedResponse.getResourcesList().get(0), resources.get(0));
198 
199     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
200     Assert.assertEquals(1, actualRequests.size());
201     ListFeaturesRequest actualRequest = ((ListFeaturesRequest) actualRequests.get(0));
202 
203     Assert.assertEquals(parent.toString(), actualRequest.getParent());
204     Assert.assertTrue(
205         channelProvider.isHeaderSent(
206             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
207             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
208   }
209 
210   @Test
listFeaturesExceptionTest()211   public void listFeaturesExceptionTest() throws Exception {
212     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
213     mockGkeHub.addException(exception);
214 
215     try {
216       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
217       client.listFeatures(parent);
218       Assert.fail("No exception raised");
219     } catch (InvalidArgumentException e) {
220       // Expected exception.
221     }
222   }
223 
224   @Test
listFeaturesTest2()225   public void listFeaturesTest2() throws Exception {
226     Feature responsesElement = Feature.newBuilder().build();
227     ListFeaturesResponse expectedResponse =
228         ListFeaturesResponse.newBuilder()
229             .setNextPageToken("")
230             .addAllResources(Arrays.asList(responsesElement))
231             .build();
232     mockGkeHub.addResponse(expectedResponse);
233 
234     String parent = "parent-995424086";
235 
236     ListFeaturesPagedResponse pagedListResponse = client.listFeatures(parent);
237 
238     List<Feature> resources = Lists.newArrayList(pagedListResponse.iterateAll());
239 
240     Assert.assertEquals(1, resources.size());
241     Assert.assertEquals(expectedResponse.getResourcesList().get(0), resources.get(0));
242 
243     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
244     Assert.assertEquals(1, actualRequests.size());
245     ListFeaturesRequest actualRequest = ((ListFeaturesRequest) actualRequests.get(0));
246 
247     Assert.assertEquals(parent, actualRequest.getParent());
248     Assert.assertTrue(
249         channelProvider.isHeaderSent(
250             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
251             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
252   }
253 
254   @Test
listFeaturesExceptionTest2()255   public void listFeaturesExceptionTest2() throws Exception {
256     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
257     mockGkeHub.addException(exception);
258 
259     try {
260       String parent = "parent-995424086";
261       client.listFeatures(parent);
262       Assert.fail("No exception raised");
263     } catch (InvalidArgumentException e) {
264       // Expected exception.
265     }
266   }
267 
268   @Test
getMembershipTest()269   public void getMembershipTest() throws Exception {
270     Membership expectedResponse =
271         Membership.newBuilder()
272             .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
273             .putAllLabels(new HashMap<String, String>())
274             .setDescription("description-1724546052")
275             .setState(MembershipState.newBuilder().build())
276             .setCreateTime(Timestamp.newBuilder().build())
277             .setUpdateTime(Timestamp.newBuilder().build())
278             .setDeleteTime(Timestamp.newBuilder().build())
279             .setExternalId("externalId-1699764666")
280             .setLastConnectionTime(Timestamp.newBuilder().build())
281             .setUniqueId("uniqueId-294460212")
282             .setAuthority(Authority.newBuilder().build())
283             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
284             .build();
285     mockGkeHub.addResponse(expectedResponse);
286 
287     MembershipName name = MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
288 
289     Membership actualResponse = client.getMembership(name);
290     Assert.assertEquals(expectedResponse, actualResponse);
291 
292     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
293     Assert.assertEquals(1, actualRequests.size());
294     GetMembershipRequest actualRequest = ((GetMembershipRequest) actualRequests.get(0));
295 
296     Assert.assertEquals(name.toString(), actualRequest.getName());
297     Assert.assertTrue(
298         channelProvider.isHeaderSent(
299             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
300             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
301   }
302 
303   @Test
getMembershipExceptionTest()304   public void getMembershipExceptionTest() throws Exception {
305     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
306     mockGkeHub.addException(exception);
307 
308     try {
309       MembershipName name = MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
310       client.getMembership(name);
311       Assert.fail("No exception raised");
312     } catch (InvalidArgumentException e) {
313       // Expected exception.
314     }
315   }
316 
317   @Test
getMembershipTest2()318   public void getMembershipTest2() throws Exception {
319     Membership expectedResponse =
320         Membership.newBuilder()
321             .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
322             .putAllLabels(new HashMap<String, String>())
323             .setDescription("description-1724546052")
324             .setState(MembershipState.newBuilder().build())
325             .setCreateTime(Timestamp.newBuilder().build())
326             .setUpdateTime(Timestamp.newBuilder().build())
327             .setDeleteTime(Timestamp.newBuilder().build())
328             .setExternalId("externalId-1699764666")
329             .setLastConnectionTime(Timestamp.newBuilder().build())
330             .setUniqueId("uniqueId-294460212")
331             .setAuthority(Authority.newBuilder().build())
332             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
333             .build();
334     mockGkeHub.addResponse(expectedResponse);
335 
336     String name = "name3373707";
337 
338     Membership actualResponse = client.getMembership(name);
339     Assert.assertEquals(expectedResponse, actualResponse);
340 
341     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
342     Assert.assertEquals(1, actualRequests.size());
343     GetMembershipRequest actualRequest = ((GetMembershipRequest) actualRequests.get(0));
344 
345     Assert.assertEquals(name, actualRequest.getName());
346     Assert.assertTrue(
347         channelProvider.isHeaderSent(
348             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
349             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
350   }
351 
352   @Test
getMembershipExceptionTest2()353   public void getMembershipExceptionTest2() throws Exception {
354     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
355     mockGkeHub.addException(exception);
356 
357     try {
358       String name = "name3373707";
359       client.getMembership(name);
360       Assert.fail("No exception raised");
361     } catch (InvalidArgumentException e) {
362       // Expected exception.
363     }
364   }
365 
366   @Test
getFeatureTest()367   public void getFeatureTest() throws Exception {
368     Feature expectedResponse =
369         Feature.newBuilder()
370             .setName(FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]").toString())
371             .putAllLabels(new HashMap<String, String>())
372             .setResourceState(FeatureResourceState.newBuilder().build())
373             .setSpec(CommonFeatureSpec.newBuilder().build())
374             .putAllMembershipSpecs(new HashMap<String, MembershipFeatureSpec>())
375             .setState(CommonFeatureState.newBuilder().build())
376             .putAllMembershipStates(new HashMap<String, MembershipFeatureState>())
377             .setCreateTime(Timestamp.newBuilder().build())
378             .setUpdateTime(Timestamp.newBuilder().build())
379             .setDeleteTime(Timestamp.newBuilder().build())
380             .build();
381     mockGkeHub.addResponse(expectedResponse);
382 
383     FeatureName name = FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]");
384 
385     Feature actualResponse = client.getFeature(name);
386     Assert.assertEquals(expectedResponse, actualResponse);
387 
388     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
389     Assert.assertEquals(1, actualRequests.size());
390     GetFeatureRequest actualRequest = ((GetFeatureRequest) actualRequests.get(0));
391 
392     Assert.assertEquals(name.toString(), actualRequest.getName());
393     Assert.assertTrue(
394         channelProvider.isHeaderSent(
395             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
396             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
397   }
398 
399   @Test
getFeatureExceptionTest()400   public void getFeatureExceptionTest() throws Exception {
401     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
402     mockGkeHub.addException(exception);
403 
404     try {
405       FeatureName name = FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]");
406       client.getFeature(name);
407       Assert.fail("No exception raised");
408     } catch (InvalidArgumentException e) {
409       // Expected exception.
410     }
411   }
412 
413   @Test
getFeatureTest2()414   public void getFeatureTest2() throws Exception {
415     Feature expectedResponse =
416         Feature.newBuilder()
417             .setName(FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]").toString())
418             .putAllLabels(new HashMap<String, String>())
419             .setResourceState(FeatureResourceState.newBuilder().build())
420             .setSpec(CommonFeatureSpec.newBuilder().build())
421             .putAllMembershipSpecs(new HashMap<String, MembershipFeatureSpec>())
422             .setState(CommonFeatureState.newBuilder().build())
423             .putAllMembershipStates(new HashMap<String, MembershipFeatureState>())
424             .setCreateTime(Timestamp.newBuilder().build())
425             .setUpdateTime(Timestamp.newBuilder().build())
426             .setDeleteTime(Timestamp.newBuilder().build())
427             .build();
428     mockGkeHub.addResponse(expectedResponse);
429 
430     String name = "name3373707";
431 
432     Feature actualResponse = client.getFeature(name);
433     Assert.assertEquals(expectedResponse, actualResponse);
434 
435     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
436     Assert.assertEquals(1, actualRequests.size());
437     GetFeatureRequest actualRequest = ((GetFeatureRequest) actualRequests.get(0));
438 
439     Assert.assertEquals(name, actualRequest.getName());
440     Assert.assertTrue(
441         channelProvider.isHeaderSent(
442             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
443             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
444   }
445 
446   @Test
getFeatureExceptionTest2()447   public void getFeatureExceptionTest2() throws Exception {
448     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
449     mockGkeHub.addException(exception);
450 
451     try {
452       String name = "name3373707";
453       client.getFeature(name);
454       Assert.fail("No exception raised");
455     } catch (InvalidArgumentException e) {
456       // Expected exception.
457     }
458   }
459 
460   @Test
createMembershipTest()461   public void createMembershipTest() throws Exception {
462     Membership expectedResponse =
463         Membership.newBuilder()
464             .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
465             .putAllLabels(new HashMap<String, String>())
466             .setDescription("description-1724546052")
467             .setState(MembershipState.newBuilder().build())
468             .setCreateTime(Timestamp.newBuilder().build())
469             .setUpdateTime(Timestamp.newBuilder().build())
470             .setDeleteTime(Timestamp.newBuilder().build())
471             .setExternalId("externalId-1699764666")
472             .setLastConnectionTime(Timestamp.newBuilder().build())
473             .setUniqueId("uniqueId-294460212")
474             .setAuthority(Authority.newBuilder().build())
475             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
476             .build();
477     Operation resultOperation =
478         Operation.newBuilder()
479             .setName("createMembershipTest")
480             .setDone(true)
481             .setResponse(Any.pack(expectedResponse))
482             .build();
483     mockGkeHub.addResponse(resultOperation);
484 
485     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
486     Membership resource = Membership.newBuilder().build();
487     String membershipId = "membershipId517665681";
488 
489     Membership actualResponse = client.createMembershipAsync(parent, resource, membershipId).get();
490     Assert.assertEquals(expectedResponse, actualResponse);
491 
492     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
493     Assert.assertEquals(1, actualRequests.size());
494     CreateMembershipRequest actualRequest = ((CreateMembershipRequest) actualRequests.get(0));
495 
496     Assert.assertEquals(parent.toString(), actualRequest.getParent());
497     Assert.assertEquals(resource, actualRequest.getResource());
498     Assert.assertEquals(membershipId, actualRequest.getMembershipId());
499     Assert.assertTrue(
500         channelProvider.isHeaderSent(
501             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
502             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
503   }
504 
505   @Test
createMembershipExceptionTest()506   public void createMembershipExceptionTest() throws Exception {
507     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
508     mockGkeHub.addException(exception);
509 
510     try {
511       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
512       Membership resource = Membership.newBuilder().build();
513       String membershipId = "membershipId517665681";
514       client.createMembershipAsync(parent, resource, membershipId).get();
515       Assert.fail("No exception raised");
516     } catch (ExecutionException e) {
517       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
518       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
519       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
520     }
521   }
522 
523   @Test
createMembershipTest2()524   public void createMembershipTest2() throws Exception {
525     Membership expectedResponse =
526         Membership.newBuilder()
527             .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
528             .putAllLabels(new HashMap<String, String>())
529             .setDescription("description-1724546052")
530             .setState(MembershipState.newBuilder().build())
531             .setCreateTime(Timestamp.newBuilder().build())
532             .setUpdateTime(Timestamp.newBuilder().build())
533             .setDeleteTime(Timestamp.newBuilder().build())
534             .setExternalId("externalId-1699764666")
535             .setLastConnectionTime(Timestamp.newBuilder().build())
536             .setUniqueId("uniqueId-294460212")
537             .setAuthority(Authority.newBuilder().build())
538             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
539             .build();
540     Operation resultOperation =
541         Operation.newBuilder()
542             .setName("createMembershipTest")
543             .setDone(true)
544             .setResponse(Any.pack(expectedResponse))
545             .build();
546     mockGkeHub.addResponse(resultOperation);
547 
548     String parent = "parent-995424086";
549     Membership resource = Membership.newBuilder().build();
550     String membershipId = "membershipId517665681";
551 
552     Membership actualResponse = client.createMembershipAsync(parent, resource, membershipId).get();
553     Assert.assertEquals(expectedResponse, actualResponse);
554 
555     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
556     Assert.assertEquals(1, actualRequests.size());
557     CreateMembershipRequest actualRequest = ((CreateMembershipRequest) actualRequests.get(0));
558 
559     Assert.assertEquals(parent, actualRequest.getParent());
560     Assert.assertEquals(resource, actualRequest.getResource());
561     Assert.assertEquals(membershipId, actualRequest.getMembershipId());
562     Assert.assertTrue(
563         channelProvider.isHeaderSent(
564             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
565             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
566   }
567 
568   @Test
createMembershipExceptionTest2()569   public void createMembershipExceptionTest2() throws Exception {
570     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
571     mockGkeHub.addException(exception);
572 
573     try {
574       String parent = "parent-995424086";
575       Membership resource = Membership.newBuilder().build();
576       String membershipId = "membershipId517665681";
577       client.createMembershipAsync(parent, resource, membershipId).get();
578       Assert.fail("No exception raised");
579     } catch (ExecutionException e) {
580       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
581       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
582       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
583     }
584   }
585 
586   @Test
createFeatureTest()587   public void createFeatureTest() throws Exception {
588     Feature expectedResponse =
589         Feature.newBuilder()
590             .setName(FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]").toString())
591             .putAllLabels(new HashMap<String, String>())
592             .setResourceState(FeatureResourceState.newBuilder().build())
593             .setSpec(CommonFeatureSpec.newBuilder().build())
594             .putAllMembershipSpecs(new HashMap<String, MembershipFeatureSpec>())
595             .setState(CommonFeatureState.newBuilder().build())
596             .putAllMembershipStates(new HashMap<String, MembershipFeatureState>())
597             .setCreateTime(Timestamp.newBuilder().build())
598             .setUpdateTime(Timestamp.newBuilder().build())
599             .setDeleteTime(Timestamp.newBuilder().build())
600             .build();
601     Operation resultOperation =
602         Operation.newBuilder()
603             .setName("createFeatureTest")
604             .setDone(true)
605             .setResponse(Any.pack(expectedResponse))
606             .build();
607     mockGkeHub.addResponse(resultOperation);
608 
609     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
610     Feature resource = Feature.newBuilder().build();
611     String featureId = "featureId-420503887";
612 
613     Feature actualResponse = client.createFeatureAsync(parent, resource, featureId).get();
614     Assert.assertEquals(expectedResponse, actualResponse);
615 
616     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
617     Assert.assertEquals(1, actualRequests.size());
618     CreateFeatureRequest actualRequest = ((CreateFeatureRequest) actualRequests.get(0));
619 
620     Assert.assertEquals(parent.toString(), actualRequest.getParent());
621     Assert.assertEquals(resource, actualRequest.getResource());
622     Assert.assertEquals(featureId, actualRequest.getFeatureId());
623     Assert.assertTrue(
624         channelProvider.isHeaderSent(
625             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
626             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
627   }
628 
629   @Test
createFeatureExceptionTest()630   public void createFeatureExceptionTest() throws Exception {
631     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
632     mockGkeHub.addException(exception);
633 
634     try {
635       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
636       Feature resource = Feature.newBuilder().build();
637       String featureId = "featureId-420503887";
638       client.createFeatureAsync(parent, resource, featureId).get();
639       Assert.fail("No exception raised");
640     } catch (ExecutionException e) {
641       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
642       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
643       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
644     }
645   }
646 
647   @Test
createFeatureTest2()648   public void createFeatureTest2() throws Exception {
649     Feature expectedResponse =
650         Feature.newBuilder()
651             .setName(FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]").toString())
652             .putAllLabels(new HashMap<String, String>())
653             .setResourceState(FeatureResourceState.newBuilder().build())
654             .setSpec(CommonFeatureSpec.newBuilder().build())
655             .putAllMembershipSpecs(new HashMap<String, MembershipFeatureSpec>())
656             .setState(CommonFeatureState.newBuilder().build())
657             .putAllMembershipStates(new HashMap<String, MembershipFeatureState>())
658             .setCreateTime(Timestamp.newBuilder().build())
659             .setUpdateTime(Timestamp.newBuilder().build())
660             .setDeleteTime(Timestamp.newBuilder().build())
661             .build();
662     Operation resultOperation =
663         Operation.newBuilder()
664             .setName("createFeatureTest")
665             .setDone(true)
666             .setResponse(Any.pack(expectedResponse))
667             .build();
668     mockGkeHub.addResponse(resultOperation);
669 
670     String parent = "parent-995424086";
671     Feature resource = Feature.newBuilder().build();
672     String featureId = "featureId-420503887";
673 
674     Feature actualResponse = client.createFeatureAsync(parent, resource, featureId).get();
675     Assert.assertEquals(expectedResponse, actualResponse);
676 
677     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
678     Assert.assertEquals(1, actualRequests.size());
679     CreateFeatureRequest actualRequest = ((CreateFeatureRequest) actualRequests.get(0));
680 
681     Assert.assertEquals(parent, actualRequest.getParent());
682     Assert.assertEquals(resource, actualRequest.getResource());
683     Assert.assertEquals(featureId, actualRequest.getFeatureId());
684     Assert.assertTrue(
685         channelProvider.isHeaderSent(
686             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
687             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
688   }
689 
690   @Test
createFeatureExceptionTest2()691   public void createFeatureExceptionTest2() throws Exception {
692     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
693     mockGkeHub.addException(exception);
694 
695     try {
696       String parent = "parent-995424086";
697       Feature resource = Feature.newBuilder().build();
698       String featureId = "featureId-420503887";
699       client.createFeatureAsync(parent, resource, featureId).get();
700       Assert.fail("No exception raised");
701     } catch (ExecutionException e) {
702       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
703       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
704       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
705     }
706   }
707 
708   @Test
deleteMembershipTest()709   public void deleteMembershipTest() throws Exception {
710     Empty expectedResponse = Empty.newBuilder().build();
711     Operation resultOperation =
712         Operation.newBuilder()
713             .setName("deleteMembershipTest")
714             .setDone(true)
715             .setResponse(Any.pack(expectedResponse))
716             .build();
717     mockGkeHub.addResponse(resultOperation);
718 
719     MembershipName name = MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
720 
721     client.deleteMembershipAsync(name).get();
722 
723     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
724     Assert.assertEquals(1, actualRequests.size());
725     DeleteMembershipRequest actualRequest = ((DeleteMembershipRequest) actualRequests.get(0));
726 
727     Assert.assertEquals(name.toString(), actualRequest.getName());
728     Assert.assertTrue(
729         channelProvider.isHeaderSent(
730             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
731             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
732   }
733 
734   @Test
deleteMembershipExceptionTest()735   public void deleteMembershipExceptionTest() throws Exception {
736     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
737     mockGkeHub.addException(exception);
738 
739     try {
740       MembershipName name = MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
741       client.deleteMembershipAsync(name).get();
742       Assert.fail("No exception raised");
743     } catch (ExecutionException e) {
744       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
745       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
746       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
747     }
748   }
749 
750   @Test
deleteMembershipTest2()751   public void deleteMembershipTest2() throws Exception {
752     Empty expectedResponse = Empty.newBuilder().build();
753     Operation resultOperation =
754         Operation.newBuilder()
755             .setName("deleteMembershipTest")
756             .setDone(true)
757             .setResponse(Any.pack(expectedResponse))
758             .build();
759     mockGkeHub.addResponse(resultOperation);
760 
761     String name = "name3373707";
762 
763     client.deleteMembershipAsync(name).get();
764 
765     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
766     Assert.assertEquals(1, actualRequests.size());
767     DeleteMembershipRequest actualRequest = ((DeleteMembershipRequest) actualRequests.get(0));
768 
769     Assert.assertEquals(name, actualRequest.getName());
770     Assert.assertTrue(
771         channelProvider.isHeaderSent(
772             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
773             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
774   }
775 
776   @Test
deleteMembershipExceptionTest2()777   public void deleteMembershipExceptionTest2() throws Exception {
778     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
779     mockGkeHub.addException(exception);
780 
781     try {
782       String name = "name3373707";
783       client.deleteMembershipAsync(name).get();
784       Assert.fail("No exception raised");
785     } catch (ExecutionException e) {
786       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
787       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
788       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
789     }
790   }
791 
792   @Test
deleteFeatureTest()793   public void deleteFeatureTest() throws Exception {
794     Empty expectedResponse = Empty.newBuilder().build();
795     Operation resultOperation =
796         Operation.newBuilder()
797             .setName("deleteFeatureTest")
798             .setDone(true)
799             .setResponse(Any.pack(expectedResponse))
800             .build();
801     mockGkeHub.addResponse(resultOperation);
802 
803     FeatureName name = FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]");
804 
805     client.deleteFeatureAsync(name).get();
806 
807     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
808     Assert.assertEquals(1, actualRequests.size());
809     DeleteFeatureRequest actualRequest = ((DeleteFeatureRequest) actualRequests.get(0));
810 
811     Assert.assertEquals(name.toString(), actualRequest.getName());
812     Assert.assertTrue(
813         channelProvider.isHeaderSent(
814             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
815             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
816   }
817 
818   @Test
deleteFeatureExceptionTest()819   public void deleteFeatureExceptionTest() throws Exception {
820     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
821     mockGkeHub.addException(exception);
822 
823     try {
824       FeatureName name = FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]");
825       client.deleteFeatureAsync(name).get();
826       Assert.fail("No exception raised");
827     } catch (ExecutionException e) {
828       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
829       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
830       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
831     }
832   }
833 
834   @Test
deleteFeatureTest2()835   public void deleteFeatureTest2() throws Exception {
836     Empty expectedResponse = Empty.newBuilder().build();
837     Operation resultOperation =
838         Operation.newBuilder()
839             .setName("deleteFeatureTest")
840             .setDone(true)
841             .setResponse(Any.pack(expectedResponse))
842             .build();
843     mockGkeHub.addResponse(resultOperation);
844 
845     String name = "name3373707";
846 
847     client.deleteFeatureAsync(name).get();
848 
849     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
850     Assert.assertEquals(1, actualRequests.size());
851     DeleteFeatureRequest actualRequest = ((DeleteFeatureRequest) actualRequests.get(0));
852 
853     Assert.assertEquals(name, actualRequest.getName());
854     Assert.assertTrue(
855         channelProvider.isHeaderSent(
856             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
857             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
858   }
859 
860   @Test
deleteFeatureExceptionTest2()861   public void deleteFeatureExceptionTest2() throws Exception {
862     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
863     mockGkeHub.addException(exception);
864 
865     try {
866       String name = "name3373707";
867       client.deleteFeatureAsync(name).get();
868       Assert.fail("No exception raised");
869     } catch (ExecutionException e) {
870       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
871       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
872       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
873     }
874   }
875 
876   @Test
updateMembershipTest()877   public void updateMembershipTest() throws Exception {
878     Membership expectedResponse =
879         Membership.newBuilder()
880             .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
881             .putAllLabels(new HashMap<String, String>())
882             .setDescription("description-1724546052")
883             .setState(MembershipState.newBuilder().build())
884             .setCreateTime(Timestamp.newBuilder().build())
885             .setUpdateTime(Timestamp.newBuilder().build())
886             .setDeleteTime(Timestamp.newBuilder().build())
887             .setExternalId("externalId-1699764666")
888             .setLastConnectionTime(Timestamp.newBuilder().build())
889             .setUniqueId("uniqueId-294460212")
890             .setAuthority(Authority.newBuilder().build())
891             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
892             .build();
893     Operation resultOperation =
894         Operation.newBuilder()
895             .setName("updateMembershipTest")
896             .setDone(true)
897             .setResponse(Any.pack(expectedResponse))
898             .build();
899     mockGkeHub.addResponse(resultOperation);
900 
901     MembershipName name = MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
902     Membership resource = Membership.newBuilder().build();
903     FieldMask updateMask = FieldMask.newBuilder().build();
904 
905     Membership actualResponse = client.updateMembershipAsync(name, resource, updateMask).get();
906     Assert.assertEquals(expectedResponse, actualResponse);
907 
908     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
909     Assert.assertEquals(1, actualRequests.size());
910     UpdateMembershipRequest actualRequest = ((UpdateMembershipRequest) actualRequests.get(0));
911 
912     Assert.assertEquals(name.toString(), actualRequest.getName());
913     Assert.assertEquals(resource, actualRequest.getResource());
914     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
915     Assert.assertTrue(
916         channelProvider.isHeaderSent(
917             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
918             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
919   }
920 
921   @Test
updateMembershipExceptionTest()922   public void updateMembershipExceptionTest() throws Exception {
923     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
924     mockGkeHub.addException(exception);
925 
926     try {
927       MembershipName name = MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
928       Membership resource = Membership.newBuilder().build();
929       FieldMask updateMask = FieldMask.newBuilder().build();
930       client.updateMembershipAsync(name, resource, updateMask).get();
931       Assert.fail("No exception raised");
932     } catch (ExecutionException e) {
933       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
934       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
935       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
936     }
937   }
938 
939   @Test
updateMembershipTest2()940   public void updateMembershipTest2() throws Exception {
941     Membership expectedResponse =
942         Membership.newBuilder()
943             .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
944             .putAllLabels(new HashMap<String, String>())
945             .setDescription("description-1724546052")
946             .setState(MembershipState.newBuilder().build())
947             .setCreateTime(Timestamp.newBuilder().build())
948             .setUpdateTime(Timestamp.newBuilder().build())
949             .setDeleteTime(Timestamp.newBuilder().build())
950             .setExternalId("externalId-1699764666")
951             .setLastConnectionTime(Timestamp.newBuilder().build())
952             .setUniqueId("uniqueId-294460212")
953             .setAuthority(Authority.newBuilder().build())
954             .setMonitoringConfig(MonitoringConfig.newBuilder().build())
955             .build();
956     Operation resultOperation =
957         Operation.newBuilder()
958             .setName("updateMembershipTest")
959             .setDone(true)
960             .setResponse(Any.pack(expectedResponse))
961             .build();
962     mockGkeHub.addResponse(resultOperation);
963 
964     String name = "name3373707";
965     Membership resource = Membership.newBuilder().build();
966     FieldMask updateMask = FieldMask.newBuilder().build();
967 
968     Membership actualResponse = client.updateMembershipAsync(name, resource, updateMask).get();
969     Assert.assertEquals(expectedResponse, actualResponse);
970 
971     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
972     Assert.assertEquals(1, actualRequests.size());
973     UpdateMembershipRequest actualRequest = ((UpdateMembershipRequest) actualRequests.get(0));
974 
975     Assert.assertEquals(name, actualRequest.getName());
976     Assert.assertEquals(resource, actualRequest.getResource());
977     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
978     Assert.assertTrue(
979         channelProvider.isHeaderSent(
980             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
981             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
982   }
983 
984   @Test
updateMembershipExceptionTest2()985   public void updateMembershipExceptionTest2() throws Exception {
986     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
987     mockGkeHub.addException(exception);
988 
989     try {
990       String name = "name3373707";
991       Membership resource = Membership.newBuilder().build();
992       FieldMask updateMask = FieldMask.newBuilder().build();
993       client.updateMembershipAsync(name, resource, updateMask).get();
994       Assert.fail("No exception raised");
995     } catch (ExecutionException e) {
996       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
997       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
998       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
999     }
1000   }
1001 
1002   @Test
updateFeatureTest()1003   public void updateFeatureTest() throws Exception {
1004     Feature expectedResponse =
1005         Feature.newBuilder()
1006             .setName(FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]").toString())
1007             .putAllLabels(new HashMap<String, String>())
1008             .setResourceState(FeatureResourceState.newBuilder().build())
1009             .setSpec(CommonFeatureSpec.newBuilder().build())
1010             .putAllMembershipSpecs(new HashMap<String, MembershipFeatureSpec>())
1011             .setState(CommonFeatureState.newBuilder().build())
1012             .putAllMembershipStates(new HashMap<String, MembershipFeatureState>())
1013             .setCreateTime(Timestamp.newBuilder().build())
1014             .setUpdateTime(Timestamp.newBuilder().build())
1015             .setDeleteTime(Timestamp.newBuilder().build())
1016             .build();
1017     Operation resultOperation =
1018         Operation.newBuilder()
1019             .setName("updateFeatureTest")
1020             .setDone(true)
1021             .setResponse(Any.pack(expectedResponse))
1022             .build();
1023     mockGkeHub.addResponse(resultOperation);
1024 
1025     FeatureName name = FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]");
1026     Feature resource = Feature.newBuilder().build();
1027     FieldMask updateMask = FieldMask.newBuilder().build();
1028 
1029     Feature actualResponse = client.updateFeatureAsync(name, resource, updateMask).get();
1030     Assert.assertEquals(expectedResponse, actualResponse);
1031 
1032     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
1033     Assert.assertEquals(1, actualRequests.size());
1034     UpdateFeatureRequest actualRequest = ((UpdateFeatureRequest) actualRequests.get(0));
1035 
1036     Assert.assertEquals(name.toString(), actualRequest.getName());
1037     Assert.assertEquals(resource, actualRequest.getResource());
1038     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1039     Assert.assertTrue(
1040         channelProvider.isHeaderSent(
1041             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1042             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1043   }
1044 
1045   @Test
updateFeatureExceptionTest()1046   public void updateFeatureExceptionTest() throws Exception {
1047     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1048     mockGkeHub.addException(exception);
1049 
1050     try {
1051       FeatureName name = FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]");
1052       Feature resource = Feature.newBuilder().build();
1053       FieldMask updateMask = FieldMask.newBuilder().build();
1054       client.updateFeatureAsync(name, resource, updateMask).get();
1055       Assert.fail("No exception raised");
1056     } catch (ExecutionException e) {
1057       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1058       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1059       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1060     }
1061   }
1062 
1063   @Test
updateFeatureTest2()1064   public void updateFeatureTest2() throws Exception {
1065     Feature expectedResponse =
1066         Feature.newBuilder()
1067             .setName(FeatureName.of("[PROJECT]", "[LOCATION]", "[FEATURE]").toString())
1068             .putAllLabels(new HashMap<String, String>())
1069             .setResourceState(FeatureResourceState.newBuilder().build())
1070             .setSpec(CommonFeatureSpec.newBuilder().build())
1071             .putAllMembershipSpecs(new HashMap<String, MembershipFeatureSpec>())
1072             .setState(CommonFeatureState.newBuilder().build())
1073             .putAllMembershipStates(new HashMap<String, MembershipFeatureState>())
1074             .setCreateTime(Timestamp.newBuilder().build())
1075             .setUpdateTime(Timestamp.newBuilder().build())
1076             .setDeleteTime(Timestamp.newBuilder().build())
1077             .build();
1078     Operation resultOperation =
1079         Operation.newBuilder()
1080             .setName("updateFeatureTest")
1081             .setDone(true)
1082             .setResponse(Any.pack(expectedResponse))
1083             .build();
1084     mockGkeHub.addResponse(resultOperation);
1085 
1086     String name = "name3373707";
1087     Feature resource = Feature.newBuilder().build();
1088     FieldMask updateMask = FieldMask.newBuilder().build();
1089 
1090     Feature actualResponse = client.updateFeatureAsync(name, resource, updateMask).get();
1091     Assert.assertEquals(expectedResponse, actualResponse);
1092 
1093     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
1094     Assert.assertEquals(1, actualRequests.size());
1095     UpdateFeatureRequest actualRequest = ((UpdateFeatureRequest) actualRequests.get(0));
1096 
1097     Assert.assertEquals(name, actualRequest.getName());
1098     Assert.assertEquals(resource, actualRequest.getResource());
1099     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1100     Assert.assertTrue(
1101         channelProvider.isHeaderSent(
1102             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1103             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1104   }
1105 
1106   @Test
updateFeatureExceptionTest2()1107   public void updateFeatureExceptionTest2() throws Exception {
1108     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1109     mockGkeHub.addException(exception);
1110 
1111     try {
1112       String name = "name3373707";
1113       Feature resource = Feature.newBuilder().build();
1114       FieldMask updateMask = FieldMask.newBuilder().build();
1115       client.updateFeatureAsync(name, resource, updateMask).get();
1116       Assert.fail("No exception raised");
1117     } catch (ExecutionException e) {
1118       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1119       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1120       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1121     }
1122   }
1123 
1124   @Test
generateConnectManifestTest()1125   public void generateConnectManifestTest() throws Exception {
1126     GenerateConnectManifestResponse expectedResponse =
1127         GenerateConnectManifestResponse.newBuilder()
1128             .addAllManifest(new ArrayList<ConnectAgentResource>())
1129             .build();
1130     mockGkeHub.addResponse(expectedResponse);
1131 
1132     GenerateConnectManifestRequest request =
1133         GenerateConnectManifestRequest.newBuilder()
1134             .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
1135             .setNamespace("namespace1252218203")
1136             .setProxy(ByteString.EMPTY)
1137             .setVersion("version351608024")
1138             .setIsUpgrade(true)
1139             .setRegistry("registry-690212803")
1140             .setImagePullSecretContent(ByteString.EMPTY)
1141             .build();
1142 
1143     GenerateConnectManifestResponse actualResponse = client.generateConnectManifest(request);
1144     Assert.assertEquals(expectedResponse, actualResponse);
1145 
1146     List<AbstractMessage> actualRequests = mockGkeHub.getRequests();
1147     Assert.assertEquals(1, actualRequests.size());
1148     GenerateConnectManifestRequest actualRequest =
1149         ((GenerateConnectManifestRequest) actualRequests.get(0));
1150 
1151     Assert.assertEquals(request.getName(), actualRequest.getName());
1152     Assert.assertEquals(request.getNamespace(), actualRequest.getNamespace());
1153     Assert.assertEquals(request.getProxy(), actualRequest.getProxy());
1154     Assert.assertEquals(request.getVersion(), actualRequest.getVersion());
1155     Assert.assertEquals(request.getIsUpgrade(), actualRequest.getIsUpgrade());
1156     Assert.assertEquals(request.getRegistry(), actualRequest.getRegistry());
1157     Assert.assertEquals(
1158         request.getImagePullSecretContent(), actualRequest.getImagePullSecretContent());
1159     Assert.assertTrue(
1160         channelProvider.isHeaderSent(
1161             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1162             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1163   }
1164 
1165   @Test
generateConnectManifestExceptionTest()1166   public void generateConnectManifestExceptionTest() throws Exception {
1167     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1168     mockGkeHub.addException(exception);
1169 
1170     try {
1171       GenerateConnectManifestRequest request =
1172           GenerateConnectManifestRequest.newBuilder()
1173               .setName(MembershipName.of("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]").toString())
1174               .setNamespace("namespace1252218203")
1175               .setProxy(ByteString.EMPTY)
1176               .setVersion("version351608024")
1177               .setIsUpgrade(true)
1178               .setRegistry("registry-690212803")
1179               .setImagePullSecretContent(ByteString.EMPTY)
1180               .build();
1181       client.generateConnectManifest(request);
1182       Assert.fail("No exception raised");
1183     } catch (InvalidArgumentException e) {
1184       // Expected exception.
1185     }
1186   }
1187 }
1188