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