• 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.compute.v1;
18 
19 import static com.google.cloud.compute.v1.TargetHttpsProxiesClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.TargetHttpsProxiesClient.ListPagedResponse;
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.compute.v1.Operation.Status;
32 import com.google.cloud.compute.v1.stub.HttpJsonTargetHttpsProxiesStub;
33 import com.google.common.collect.Lists;
34 import java.io.IOException;
35 import java.util.ArrayList;
36 import java.util.Arrays;
37 import java.util.Collections;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.concurrent.ExecutionException;
41 import javax.annotation.Generated;
42 import org.junit.After;
43 import org.junit.AfterClass;
44 import org.junit.Assert;
45 import org.junit.Before;
46 import org.junit.BeforeClass;
47 import org.junit.Test;
48 
49 @Generated("by gapic-generator-java")
50 public class TargetHttpsProxiesClientTest {
51   private static MockHttpService mockService;
52   private static TargetHttpsProxiesClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonTargetHttpsProxiesStub.getMethodDescriptors(),
59             TargetHttpsProxiesSettings.getDefaultEndpoint());
60     TargetHttpsProxiesSettings settings =
61         TargetHttpsProxiesSettings.newBuilder()
62             .setTransportChannelProvider(
63                 TargetHttpsProxiesSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = TargetHttpsProxiesClient.create(settings);
69   }
70 
71   @AfterClass
stopServer()72   public static void stopServer() {
73     client.close();
74   }
75 
76   @Before
setUp()77   public void setUp() {}
78 
79   @After
tearDown()80   public void tearDown() throws Exception {
81     mockService.reset();
82   }
83 
84   @Test
aggregatedListTest()85   public void aggregatedListTest() throws Exception {
86     TargetHttpsProxiesScopedList responsesElement =
87         TargetHttpsProxiesScopedList.newBuilder().build();
88     TargetHttpsProxyAggregatedList expectedResponse =
89         TargetHttpsProxyAggregatedList.newBuilder()
90             .setNextPageToken("")
91             .putAllItems(Collections.singletonMap("items", responsesElement))
92             .build();
93     mockService.addResponse(expectedResponse);
94 
95     String project = "project-6911";
96 
97     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
98 
99     List<Map.Entry<String, TargetHttpsProxiesScopedList>> resources =
100         Lists.newArrayList(pagedListResponse.iterateAll());
101 
102     Assert.assertEquals(1, resources.size());
103     Assert.assertEquals(
104         expectedResponse.getItemsMap().entrySet().iterator().next(), 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
aggregatedListExceptionTest()122   public void aggregatedListExceptionTest() 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       String project = "project-6911";
130       client.aggregatedList(project);
131       Assert.fail("No exception raised");
132     } catch (InvalidArgumentException e) {
133       // Expected exception.
134     }
135   }
136 
137   @Test
deleteTest()138   public void deleteTest() throws Exception {
139     Operation expectedResponse =
140         Operation.newBuilder()
141             .setClientOperationId("clientOperationId-1230366697")
142             .setCreationTimestamp("creationTimestamp-370203401")
143             .setDescription("description-1724546052")
144             .setEndTime("endTime-1607243192")
145             .setError(Error.newBuilder().build())
146             .setHttpErrorMessage("httpErrorMessage1577303431")
147             .setHttpErrorStatusCode(0)
148             .setId(3355)
149             .setInsertTime("insertTime966165798")
150             .setKind("kind3292052")
151             .setName("name3373707")
152             .setOperationGroupId("operationGroupId1716161683")
153             .setOperationType("operationType91999553")
154             .setProgress(-1001078227)
155             .setRegion("region-934795532")
156             .setSelfLink("selfLink1191800166")
157             .setStartTime("startTime-2129294769")
158             .setStatus(Status.DONE)
159             .setStatusMessage("statusMessage-958704715")
160             .setTargetId(-815576439)
161             .setTargetLink("targetLink486368555")
162             .setUser("user3599307")
163             .addAllWarnings(new ArrayList<Warnings>())
164             .setZone("zone3744684")
165             .build();
166     mockService.addResponse(expectedResponse);
167 
168     String project = "project-6911";
169     String targetHttpsProxy = "targetHttpsProxy-1958";
170 
171     Operation actualResponse = client.deleteAsync(project, targetHttpsProxy).get();
172     Assert.assertEquals(expectedResponse, actualResponse);
173 
174     List<String> actualRequests = mockService.getRequestPaths();
175     Assert.assertEquals(1, actualRequests.size());
176 
177     String apiClientHeaderKey =
178         mockService
179             .getRequestHeaders()
180             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
181             .iterator()
182             .next();
183     Assert.assertTrue(
184         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
185             .matcher(apiClientHeaderKey)
186             .matches());
187   }
188 
189   @Test
deleteExceptionTest()190   public void deleteExceptionTest() throws Exception {
191     ApiException exception =
192         ApiExceptionFactory.createException(
193             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
194     mockService.addException(exception);
195 
196     try {
197       String project = "project-6911";
198       String targetHttpsProxy = "targetHttpsProxy-1958";
199       client.deleteAsync(project, targetHttpsProxy).get();
200       Assert.fail("No exception raised");
201     } catch (ExecutionException e) {
202     }
203   }
204 
205   @Test
getTest()206   public void getTest() throws Exception {
207     TargetHttpsProxy expectedResponse =
208         TargetHttpsProxy.newBuilder()
209             .setAuthorizationPolicy("authorizationPolicy1042707211")
210             .setCertificateMap("certificateMap1494413381")
211             .setCreationTimestamp("creationTimestamp-370203401")
212             .setDescription("description-1724546052")
213             .setFingerprint("fingerprint-1375934236")
214             .setId(3355)
215             .setKind("kind3292052")
216             .setName("name3373707")
217             .setProxyBind(true)
218             .setQuicOverride("quicOverride502760490")
219             .setRegion("region-934795532")
220             .setSelfLink("selfLink1191800166")
221             .setServerTlsPolicy("serverTlsPolicy-1897015798")
222             .addAllSslCertificates(new ArrayList<String>())
223             .setSslPolicy("sslPolicy618174046")
224             .setUrlMap("urlMap-836780691")
225             .build();
226     mockService.addResponse(expectedResponse);
227 
228     String project = "project-6911";
229     String targetHttpsProxy = "targetHttpsProxy-1958";
230 
231     TargetHttpsProxy actualResponse = client.get(project, targetHttpsProxy);
232     Assert.assertEquals(expectedResponse, actualResponse);
233 
234     List<String> actualRequests = mockService.getRequestPaths();
235     Assert.assertEquals(1, actualRequests.size());
236 
237     String apiClientHeaderKey =
238         mockService
239             .getRequestHeaders()
240             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
241             .iterator()
242             .next();
243     Assert.assertTrue(
244         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
245             .matcher(apiClientHeaderKey)
246             .matches());
247   }
248 
249   @Test
getExceptionTest()250   public void getExceptionTest() throws Exception {
251     ApiException exception =
252         ApiExceptionFactory.createException(
253             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
254     mockService.addException(exception);
255 
256     try {
257       String project = "project-6911";
258       String targetHttpsProxy = "targetHttpsProxy-1958";
259       client.get(project, targetHttpsProxy);
260       Assert.fail("No exception raised");
261     } catch (InvalidArgumentException e) {
262       // Expected exception.
263     }
264   }
265 
266   @Test
insertTest()267   public void insertTest() throws Exception {
268     Operation expectedResponse =
269         Operation.newBuilder()
270             .setClientOperationId("clientOperationId-1230366697")
271             .setCreationTimestamp("creationTimestamp-370203401")
272             .setDescription("description-1724546052")
273             .setEndTime("endTime-1607243192")
274             .setError(Error.newBuilder().build())
275             .setHttpErrorMessage("httpErrorMessage1577303431")
276             .setHttpErrorStatusCode(0)
277             .setId(3355)
278             .setInsertTime("insertTime966165798")
279             .setKind("kind3292052")
280             .setName("name3373707")
281             .setOperationGroupId("operationGroupId1716161683")
282             .setOperationType("operationType91999553")
283             .setProgress(-1001078227)
284             .setRegion("region-934795532")
285             .setSelfLink("selfLink1191800166")
286             .setStartTime("startTime-2129294769")
287             .setStatus(Status.DONE)
288             .setStatusMessage("statusMessage-958704715")
289             .setTargetId(-815576439)
290             .setTargetLink("targetLink486368555")
291             .setUser("user3599307")
292             .addAllWarnings(new ArrayList<Warnings>())
293             .setZone("zone3744684")
294             .build();
295     mockService.addResponse(expectedResponse);
296 
297     String project = "project-6911";
298     TargetHttpsProxy targetHttpsProxyResource = TargetHttpsProxy.newBuilder().build();
299 
300     Operation actualResponse = client.insertAsync(project, targetHttpsProxyResource).get();
301     Assert.assertEquals(expectedResponse, actualResponse);
302 
303     List<String> actualRequests = mockService.getRequestPaths();
304     Assert.assertEquals(1, actualRequests.size());
305 
306     String apiClientHeaderKey =
307         mockService
308             .getRequestHeaders()
309             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
310             .iterator()
311             .next();
312     Assert.assertTrue(
313         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
314             .matcher(apiClientHeaderKey)
315             .matches());
316   }
317 
318   @Test
insertExceptionTest()319   public void insertExceptionTest() throws Exception {
320     ApiException exception =
321         ApiExceptionFactory.createException(
322             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
323     mockService.addException(exception);
324 
325     try {
326       String project = "project-6911";
327       TargetHttpsProxy targetHttpsProxyResource = TargetHttpsProxy.newBuilder().build();
328       client.insertAsync(project, targetHttpsProxyResource).get();
329       Assert.fail("No exception raised");
330     } catch (ExecutionException e) {
331     }
332   }
333 
334   @Test
listTest()335   public void listTest() throws Exception {
336     TargetHttpsProxy responsesElement = TargetHttpsProxy.newBuilder().build();
337     TargetHttpsProxyList expectedResponse =
338         TargetHttpsProxyList.newBuilder()
339             .setNextPageToken("")
340             .addAllItems(Arrays.asList(responsesElement))
341             .build();
342     mockService.addResponse(expectedResponse);
343 
344     String project = "project-6911";
345 
346     ListPagedResponse pagedListResponse = client.list(project);
347 
348     List<TargetHttpsProxy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
349 
350     Assert.assertEquals(1, resources.size());
351     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
352 
353     List<String> actualRequests = mockService.getRequestPaths();
354     Assert.assertEquals(1, actualRequests.size());
355 
356     String apiClientHeaderKey =
357         mockService
358             .getRequestHeaders()
359             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
360             .iterator()
361             .next();
362     Assert.assertTrue(
363         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
364             .matcher(apiClientHeaderKey)
365             .matches());
366   }
367 
368   @Test
listExceptionTest()369   public void listExceptionTest() throws Exception {
370     ApiException exception =
371         ApiExceptionFactory.createException(
372             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
373     mockService.addException(exception);
374 
375     try {
376       String project = "project-6911";
377       client.list(project);
378       Assert.fail("No exception raised");
379     } catch (InvalidArgumentException e) {
380       // Expected exception.
381     }
382   }
383 
384   @Test
patchTest()385   public void patchTest() throws Exception {
386     Operation expectedResponse =
387         Operation.newBuilder()
388             .setClientOperationId("clientOperationId-1230366697")
389             .setCreationTimestamp("creationTimestamp-370203401")
390             .setDescription("description-1724546052")
391             .setEndTime("endTime-1607243192")
392             .setError(Error.newBuilder().build())
393             .setHttpErrorMessage("httpErrorMessage1577303431")
394             .setHttpErrorStatusCode(0)
395             .setId(3355)
396             .setInsertTime("insertTime966165798")
397             .setKind("kind3292052")
398             .setName("name3373707")
399             .setOperationGroupId("operationGroupId1716161683")
400             .setOperationType("operationType91999553")
401             .setProgress(-1001078227)
402             .setRegion("region-934795532")
403             .setSelfLink("selfLink1191800166")
404             .setStartTime("startTime-2129294769")
405             .setStatus(Status.DONE)
406             .setStatusMessage("statusMessage-958704715")
407             .setTargetId(-815576439)
408             .setTargetLink("targetLink486368555")
409             .setUser("user3599307")
410             .addAllWarnings(new ArrayList<Warnings>())
411             .setZone("zone3744684")
412             .build();
413     mockService.addResponse(expectedResponse);
414 
415     String project = "project-6911";
416     String targetHttpsProxy = "targetHttpsProxy-1958";
417     TargetHttpsProxy targetHttpsProxyResource = TargetHttpsProxy.newBuilder().build();
418 
419     Operation actualResponse =
420         client.patchAsync(project, targetHttpsProxy, targetHttpsProxyResource).get();
421     Assert.assertEquals(expectedResponse, actualResponse);
422 
423     List<String> actualRequests = mockService.getRequestPaths();
424     Assert.assertEquals(1, actualRequests.size());
425 
426     String apiClientHeaderKey =
427         mockService
428             .getRequestHeaders()
429             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
430             .iterator()
431             .next();
432     Assert.assertTrue(
433         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
434             .matcher(apiClientHeaderKey)
435             .matches());
436   }
437 
438   @Test
patchExceptionTest()439   public void patchExceptionTest() throws Exception {
440     ApiException exception =
441         ApiExceptionFactory.createException(
442             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
443     mockService.addException(exception);
444 
445     try {
446       String project = "project-6911";
447       String targetHttpsProxy = "targetHttpsProxy-1958";
448       TargetHttpsProxy targetHttpsProxyResource = TargetHttpsProxy.newBuilder().build();
449       client.patchAsync(project, targetHttpsProxy, targetHttpsProxyResource).get();
450       Assert.fail("No exception raised");
451     } catch (ExecutionException e) {
452     }
453   }
454 
455   @Test
setCertificateMapTest()456   public void setCertificateMapTest() throws Exception {
457     Operation expectedResponse =
458         Operation.newBuilder()
459             .setClientOperationId("clientOperationId-1230366697")
460             .setCreationTimestamp("creationTimestamp-370203401")
461             .setDescription("description-1724546052")
462             .setEndTime("endTime-1607243192")
463             .setError(Error.newBuilder().build())
464             .setHttpErrorMessage("httpErrorMessage1577303431")
465             .setHttpErrorStatusCode(0)
466             .setId(3355)
467             .setInsertTime("insertTime966165798")
468             .setKind("kind3292052")
469             .setName("name3373707")
470             .setOperationGroupId("operationGroupId1716161683")
471             .setOperationType("operationType91999553")
472             .setProgress(-1001078227)
473             .setRegion("region-934795532")
474             .setSelfLink("selfLink1191800166")
475             .setStartTime("startTime-2129294769")
476             .setStatus(Status.DONE)
477             .setStatusMessage("statusMessage-958704715")
478             .setTargetId(-815576439)
479             .setTargetLink("targetLink486368555")
480             .setUser("user3599307")
481             .addAllWarnings(new ArrayList<Warnings>())
482             .setZone("zone3744684")
483             .build();
484     mockService.addResponse(expectedResponse);
485 
486     String project = "project-6911";
487     String targetHttpsProxy = "targetHttpsProxy-1958";
488     TargetHttpsProxiesSetCertificateMapRequest targetHttpsProxiesSetCertificateMapRequestResource =
489         TargetHttpsProxiesSetCertificateMapRequest.newBuilder().build();
490 
491     Operation actualResponse =
492         client
493             .setCertificateMapAsync(
494                 project, targetHttpsProxy, targetHttpsProxiesSetCertificateMapRequestResource)
495             .get();
496     Assert.assertEquals(expectedResponse, actualResponse);
497 
498     List<String> actualRequests = mockService.getRequestPaths();
499     Assert.assertEquals(1, actualRequests.size());
500 
501     String apiClientHeaderKey =
502         mockService
503             .getRequestHeaders()
504             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
505             .iterator()
506             .next();
507     Assert.assertTrue(
508         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
509             .matcher(apiClientHeaderKey)
510             .matches());
511   }
512 
513   @Test
setCertificateMapExceptionTest()514   public void setCertificateMapExceptionTest() throws Exception {
515     ApiException exception =
516         ApiExceptionFactory.createException(
517             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
518     mockService.addException(exception);
519 
520     try {
521       String project = "project-6911";
522       String targetHttpsProxy = "targetHttpsProxy-1958";
523       TargetHttpsProxiesSetCertificateMapRequest
524           targetHttpsProxiesSetCertificateMapRequestResource =
525               TargetHttpsProxiesSetCertificateMapRequest.newBuilder().build();
526       client
527           .setCertificateMapAsync(
528               project, targetHttpsProxy, targetHttpsProxiesSetCertificateMapRequestResource)
529           .get();
530       Assert.fail("No exception raised");
531     } catch (ExecutionException e) {
532     }
533   }
534 
535   @Test
setQuicOverrideTest()536   public void setQuicOverrideTest() throws Exception {
537     Operation expectedResponse =
538         Operation.newBuilder()
539             .setClientOperationId("clientOperationId-1230366697")
540             .setCreationTimestamp("creationTimestamp-370203401")
541             .setDescription("description-1724546052")
542             .setEndTime("endTime-1607243192")
543             .setError(Error.newBuilder().build())
544             .setHttpErrorMessage("httpErrorMessage1577303431")
545             .setHttpErrorStatusCode(0)
546             .setId(3355)
547             .setInsertTime("insertTime966165798")
548             .setKind("kind3292052")
549             .setName("name3373707")
550             .setOperationGroupId("operationGroupId1716161683")
551             .setOperationType("operationType91999553")
552             .setProgress(-1001078227)
553             .setRegion("region-934795532")
554             .setSelfLink("selfLink1191800166")
555             .setStartTime("startTime-2129294769")
556             .setStatus(Status.DONE)
557             .setStatusMessage("statusMessage-958704715")
558             .setTargetId(-815576439)
559             .setTargetLink("targetLink486368555")
560             .setUser("user3599307")
561             .addAllWarnings(new ArrayList<Warnings>())
562             .setZone("zone3744684")
563             .build();
564     mockService.addResponse(expectedResponse);
565 
566     String project = "project-6911";
567     String targetHttpsProxy = "targetHttpsProxy-1958";
568     TargetHttpsProxiesSetQuicOverrideRequest targetHttpsProxiesSetQuicOverrideRequestResource =
569         TargetHttpsProxiesSetQuicOverrideRequest.newBuilder().build();
570 
571     Operation actualResponse =
572         client
573             .setQuicOverrideAsync(
574                 project, targetHttpsProxy, targetHttpsProxiesSetQuicOverrideRequestResource)
575             .get();
576     Assert.assertEquals(expectedResponse, actualResponse);
577 
578     List<String> actualRequests = mockService.getRequestPaths();
579     Assert.assertEquals(1, actualRequests.size());
580 
581     String apiClientHeaderKey =
582         mockService
583             .getRequestHeaders()
584             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
585             .iterator()
586             .next();
587     Assert.assertTrue(
588         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
589             .matcher(apiClientHeaderKey)
590             .matches());
591   }
592 
593   @Test
setQuicOverrideExceptionTest()594   public void setQuicOverrideExceptionTest() throws Exception {
595     ApiException exception =
596         ApiExceptionFactory.createException(
597             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
598     mockService.addException(exception);
599 
600     try {
601       String project = "project-6911";
602       String targetHttpsProxy = "targetHttpsProxy-1958";
603       TargetHttpsProxiesSetQuicOverrideRequest targetHttpsProxiesSetQuicOverrideRequestResource =
604           TargetHttpsProxiesSetQuicOverrideRequest.newBuilder().build();
605       client
606           .setQuicOverrideAsync(
607               project, targetHttpsProxy, targetHttpsProxiesSetQuicOverrideRequestResource)
608           .get();
609       Assert.fail("No exception raised");
610     } catch (ExecutionException e) {
611     }
612   }
613 
614   @Test
setSslCertificatesTest()615   public void setSslCertificatesTest() throws Exception {
616     Operation expectedResponse =
617         Operation.newBuilder()
618             .setClientOperationId("clientOperationId-1230366697")
619             .setCreationTimestamp("creationTimestamp-370203401")
620             .setDescription("description-1724546052")
621             .setEndTime("endTime-1607243192")
622             .setError(Error.newBuilder().build())
623             .setHttpErrorMessage("httpErrorMessage1577303431")
624             .setHttpErrorStatusCode(0)
625             .setId(3355)
626             .setInsertTime("insertTime966165798")
627             .setKind("kind3292052")
628             .setName("name3373707")
629             .setOperationGroupId("operationGroupId1716161683")
630             .setOperationType("operationType91999553")
631             .setProgress(-1001078227)
632             .setRegion("region-934795532")
633             .setSelfLink("selfLink1191800166")
634             .setStartTime("startTime-2129294769")
635             .setStatus(Status.DONE)
636             .setStatusMessage("statusMessage-958704715")
637             .setTargetId(-815576439)
638             .setTargetLink("targetLink486368555")
639             .setUser("user3599307")
640             .addAllWarnings(new ArrayList<Warnings>())
641             .setZone("zone3744684")
642             .build();
643     mockService.addResponse(expectedResponse);
644 
645     String project = "project-6911";
646     String targetHttpsProxy = "targetHttpsProxy-1958";
647     TargetHttpsProxiesSetSslCertificatesRequest
648         targetHttpsProxiesSetSslCertificatesRequestResource =
649             TargetHttpsProxiesSetSslCertificatesRequest.newBuilder().build();
650 
651     Operation actualResponse =
652         client
653             .setSslCertificatesAsync(
654                 project, targetHttpsProxy, targetHttpsProxiesSetSslCertificatesRequestResource)
655             .get();
656     Assert.assertEquals(expectedResponse, actualResponse);
657 
658     List<String> actualRequests = mockService.getRequestPaths();
659     Assert.assertEquals(1, actualRequests.size());
660 
661     String apiClientHeaderKey =
662         mockService
663             .getRequestHeaders()
664             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
665             .iterator()
666             .next();
667     Assert.assertTrue(
668         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
669             .matcher(apiClientHeaderKey)
670             .matches());
671   }
672 
673   @Test
setSslCertificatesExceptionTest()674   public void setSslCertificatesExceptionTest() throws Exception {
675     ApiException exception =
676         ApiExceptionFactory.createException(
677             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
678     mockService.addException(exception);
679 
680     try {
681       String project = "project-6911";
682       String targetHttpsProxy = "targetHttpsProxy-1958";
683       TargetHttpsProxiesSetSslCertificatesRequest
684           targetHttpsProxiesSetSslCertificatesRequestResource =
685               TargetHttpsProxiesSetSslCertificatesRequest.newBuilder().build();
686       client
687           .setSslCertificatesAsync(
688               project, targetHttpsProxy, targetHttpsProxiesSetSslCertificatesRequestResource)
689           .get();
690       Assert.fail("No exception raised");
691     } catch (ExecutionException e) {
692     }
693   }
694 
695   @Test
setSslPolicyTest()696   public void setSslPolicyTest() throws Exception {
697     Operation expectedResponse =
698         Operation.newBuilder()
699             .setClientOperationId("clientOperationId-1230366697")
700             .setCreationTimestamp("creationTimestamp-370203401")
701             .setDescription("description-1724546052")
702             .setEndTime("endTime-1607243192")
703             .setError(Error.newBuilder().build())
704             .setHttpErrorMessage("httpErrorMessage1577303431")
705             .setHttpErrorStatusCode(0)
706             .setId(3355)
707             .setInsertTime("insertTime966165798")
708             .setKind("kind3292052")
709             .setName("name3373707")
710             .setOperationGroupId("operationGroupId1716161683")
711             .setOperationType("operationType91999553")
712             .setProgress(-1001078227)
713             .setRegion("region-934795532")
714             .setSelfLink("selfLink1191800166")
715             .setStartTime("startTime-2129294769")
716             .setStatus(Status.DONE)
717             .setStatusMessage("statusMessage-958704715")
718             .setTargetId(-815576439)
719             .setTargetLink("targetLink486368555")
720             .setUser("user3599307")
721             .addAllWarnings(new ArrayList<Warnings>())
722             .setZone("zone3744684")
723             .build();
724     mockService.addResponse(expectedResponse);
725 
726     String project = "project-6911";
727     String targetHttpsProxy = "targetHttpsProxy-1958";
728     SslPolicyReference sslPolicyReferenceResource = SslPolicyReference.newBuilder().build();
729 
730     Operation actualResponse =
731         client.setSslPolicyAsync(project, targetHttpsProxy, sslPolicyReferenceResource).get();
732     Assert.assertEquals(expectedResponse, actualResponse);
733 
734     List<String> actualRequests = mockService.getRequestPaths();
735     Assert.assertEquals(1, actualRequests.size());
736 
737     String apiClientHeaderKey =
738         mockService
739             .getRequestHeaders()
740             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
741             .iterator()
742             .next();
743     Assert.assertTrue(
744         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
745             .matcher(apiClientHeaderKey)
746             .matches());
747   }
748 
749   @Test
setSslPolicyExceptionTest()750   public void setSslPolicyExceptionTest() throws Exception {
751     ApiException exception =
752         ApiExceptionFactory.createException(
753             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
754     mockService.addException(exception);
755 
756     try {
757       String project = "project-6911";
758       String targetHttpsProxy = "targetHttpsProxy-1958";
759       SslPolicyReference sslPolicyReferenceResource = SslPolicyReference.newBuilder().build();
760       client.setSslPolicyAsync(project, targetHttpsProxy, sslPolicyReferenceResource).get();
761       Assert.fail("No exception raised");
762     } catch (ExecutionException e) {
763     }
764   }
765 
766   @Test
setUrlMapTest()767   public void setUrlMapTest() throws Exception {
768     Operation expectedResponse =
769         Operation.newBuilder()
770             .setClientOperationId("clientOperationId-1230366697")
771             .setCreationTimestamp("creationTimestamp-370203401")
772             .setDescription("description-1724546052")
773             .setEndTime("endTime-1607243192")
774             .setError(Error.newBuilder().build())
775             .setHttpErrorMessage("httpErrorMessage1577303431")
776             .setHttpErrorStatusCode(0)
777             .setId(3355)
778             .setInsertTime("insertTime966165798")
779             .setKind("kind3292052")
780             .setName("name3373707")
781             .setOperationGroupId("operationGroupId1716161683")
782             .setOperationType("operationType91999553")
783             .setProgress(-1001078227)
784             .setRegion("region-934795532")
785             .setSelfLink("selfLink1191800166")
786             .setStartTime("startTime-2129294769")
787             .setStatus(Status.DONE)
788             .setStatusMessage("statusMessage-958704715")
789             .setTargetId(-815576439)
790             .setTargetLink("targetLink486368555")
791             .setUser("user3599307")
792             .addAllWarnings(new ArrayList<Warnings>())
793             .setZone("zone3744684")
794             .build();
795     mockService.addResponse(expectedResponse);
796 
797     String project = "project-6911";
798     String targetHttpsProxy = "targetHttpsProxy-1958";
799     UrlMapReference urlMapReferenceResource = UrlMapReference.newBuilder().build();
800 
801     Operation actualResponse =
802         client.setUrlMapAsync(project, targetHttpsProxy, urlMapReferenceResource).get();
803     Assert.assertEquals(expectedResponse, actualResponse);
804 
805     List<String> actualRequests = mockService.getRequestPaths();
806     Assert.assertEquals(1, actualRequests.size());
807 
808     String apiClientHeaderKey =
809         mockService
810             .getRequestHeaders()
811             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
812             .iterator()
813             .next();
814     Assert.assertTrue(
815         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
816             .matcher(apiClientHeaderKey)
817             .matches());
818   }
819 
820   @Test
setUrlMapExceptionTest()821   public void setUrlMapExceptionTest() throws Exception {
822     ApiException exception =
823         ApiExceptionFactory.createException(
824             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
825     mockService.addException(exception);
826 
827     try {
828       String project = "project-6911";
829       String targetHttpsProxy = "targetHttpsProxy-1958";
830       UrlMapReference urlMapReferenceResource = UrlMapReference.newBuilder().build();
831       client.setUrlMapAsync(project, targetHttpsProxy, urlMapReferenceResource).get();
832       Assert.fail("No exception raised");
833     } catch (ExecutionException e) {
834     }
835   }
836 }
837