• 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.ForwardingRulesClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.ForwardingRulesClient.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.HttpJsonForwardingRulesStub;
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.HashMap;
39 import java.util.List;
40 import java.util.Map;
41 import java.util.concurrent.ExecutionException;
42 import javax.annotation.Generated;
43 import org.junit.After;
44 import org.junit.AfterClass;
45 import org.junit.Assert;
46 import org.junit.Before;
47 import org.junit.BeforeClass;
48 import org.junit.Test;
49 
50 @Generated("by gapic-generator-java")
51 public class ForwardingRulesClientTest {
52   private static MockHttpService mockService;
53   private static ForwardingRulesClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() throws IOException {
57     mockService =
58         new MockHttpService(
59             HttpJsonForwardingRulesStub.getMethodDescriptors(),
60             ForwardingRulesSettings.getDefaultEndpoint());
61     ForwardingRulesSettings settings =
62         ForwardingRulesSettings.newBuilder()
63             .setTransportChannelProvider(
64                 ForwardingRulesSettings.defaultHttpJsonTransportProviderBuilder()
65                     .setHttpTransport(mockService)
66                     .build())
67             .setCredentialsProvider(NoCredentialsProvider.create())
68             .build();
69     client = ForwardingRulesClient.create(settings);
70   }
71 
72   @AfterClass
stopServer()73   public static void stopServer() {
74     client.close();
75   }
76 
77   @Before
setUp()78   public void setUp() {}
79 
80   @After
tearDown()81   public void tearDown() throws Exception {
82     mockService.reset();
83   }
84 
85   @Test
aggregatedListTest()86   public void aggregatedListTest() throws Exception {
87     ForwardingRulesScopedList responsesElement = ForwardingRulesScopedList.newBuilder().build();
88     ForwardingRuleAggregatedList expectedResponse =
89         ForwardingRuleAggregatedList.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, ForwardingRulesScopedList>> 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 region = "region-9622";
170     String forwardingRule = "forwardingRule-4031";
171 
172     Operation actualResponse = client.deleteAsync(project, region, forwardingRule).get();
173     Assert.assertEquals(expectedResponse, actualResponse);
174 
175     List<String> actualRequests = mockService.getRequestPaths();
176     Assert.assertEquals(1, actualRequests.size());
177 
178     String apiClientHeaderKey =
179         mockService
180             .getRequestHeaders()
181             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
182             .iterator()
183             .next();
184     Assert.assertTrue(
185         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
186             .matcher(apiClientHeaderKey)
187             .matches());
188   }
189 
190   @Test
deleteExceptionTest()191   public void deleteExceptionTest() throws Exception {
192     ApiException exception =
193         ApiExceptionFactory.createException(
194             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
195     mockService.addException(exception);
196 
197     try {
198       String project = "project-6911";
199       String region = "region-9622";
200       String forwardingRule = "forwardingRule-4031";
201       client.deleteAsync(project, region, forwardingRule).get();
202       Assert.fail("No exception raised");
203     } catch (ExecutionException e) {
204     }
205   }
206 
207   @Test
getTest()208   public void getTest() throws Exception {
209     ForwardingRule expectedResponse =
210         ForwardingRule.newBuilder()
211             .setIPAddress("iPAddress1698676973")
212             .setIPProtocol("iPProtocol1348929727")
213             .setAllPorts(true)
214             .setAllowGlobalAccess(true)
215             .setBackendService("backendService-1884714623")
216             .setBaseForwardingRule("baseForwardingRule124102858")
217             .setCreationTimestamp("creationTimestamp-370203401")
218             .setDescription("description-1724546052")
219             .setFingerprint("fingerprint-1375934236")
220             .setId(3355)
221             .setIpVersion("ipVersion-1161634383")
222             .setIsMirroringCollector(true)
223             .setKind("kind3292052")
224             .setLabelFingerprint("labelFingerprint379449680")
225             .putAllLabels(new HashMap<String, String>())
226             .setLoadBalancingScheme("loadBalancingScheme-1223583272")
227             .addAllMetadataFilters(new ArrayList<MetadataFilter>())
228             .setName("name3373707")
229             .setNetwork("network1843485230")
230             .setNetworkTier("networkTier-1940629200")
231             .setNoAutomateDnsZone(true)
232             .setPortRange("portRange1102895420")
233             .addAllPorts(new ArrayList<String>())
234             .setPscConnectionId(292082397)
235             .setPscConnectionStatus("pscConnectionStatus2068878160")
236             .setRegion("region-934795532")
237             .setSelfLink("selfLink1191800166")
238             .addAllServiceDirectoryRegistrations(
239                 new ArrayList<ForwardingRuleServiceDirectoryRegistration>())
240             .setServiceLabel("serviceLabel341946687")
241             .setServiceName("serviceName-1928572192")
242             .addAllSourceIpRanges(new ArrayList<String>())
243             .setSubnetwork("subnetwork-1302785042")
244             .setTarget("target-880905839")
245             .build();
246     mockService.addResponse(expectedResponse);
247 
248     String project = "project-6911";
249     String region = "region-9622";
250     String forwardingRule = "forwardingRule-4031";
251 
252     ForwardingRule actualResponse = client.get(project, region, forwardingRule);
253     Assert.assertEquals(expectedResponse, actualResponse);
254 
255     List<String> actualRequests = mockService.getRequestPaths();
256     Assert.assertEquals(1, actualRequests.size());
257 
258     String apiClientHeaderKey =
259         mockService
260             .getRequestHeaders()
261             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
262             .iterator()
263             .next();
264     Assert.assertTrue(
265         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
266             .matcher(apiClientHeaderKey)
267             .matches());
268   }
269 
270   @Test
getExceptionTest()271   public void getExceptionTest() throws Exception {
272     ApiException exception =
273         ApiExceptionFactory.createException(
274             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
275     mockService.addException(exception);
276 
277     try {
278       String project = "project-6911";
279       String region = "region-9622";
280       String forwardingRule = "forwardingRule-4031";
281       client.get(project, region, forwardingRule);
282       Assert.fail("No exception raised");
283     } catch (InvalidArgumentException e) {
284       // Expected exception.
285     }
286   }
287 
288   @Test
insertTest()289   public void insertTest() throws Exception {
290     Operation expectedResponse =
291         Operation.newBuilder()
292             .setClientOperationId("clientOperationId-1230366697")
293             .setCreationTimestamp("creationTimestamp-370203401")
294             .setDescription("description-1724546052")
295             .setEndTime("endTime-1607243192")
296             .setError(Error.newBuilder().build())
297             .setHttpErrorMessage("httpErrorMessage1577303431")
298             .setHttpErrorStatusCode(0)
299             .setId(3355)
300             .setInsertTime("insertTime966165798")
301             .setKind("kind3292052")
302             .setName("name3373707")
303             .setOperationGroupId("operationGroupId1716161683")
304             .setOperationType("operationType91999553")
305             .setProgress(-1001078227)
306             .setRegion("region-934795532")
307             .setSelfLink("selfLink1191800166")
308             .setStartTime("startTime-2129294769")
309             .setStatus(Status.DONE)
310             .setStatusMessage("statusMessage-958704715")
311             .setTargetId(-815576439)
312             .setTargetLink("targetLink486368555")
313             .setUser("user3599307")
314             .addAllWarnings(new ArrayList<Warnings>())
315             .setZone("zone3744684")
316             .build();
317     mockService.addResponse(expectedResponse);
318 
319     String project = "project-6911";
320     String region = "region-9622";
321     ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
322 
323     Operation actualResponse = client.insertAsync(project, region, forwardingRuleResource).get();
324     Assert.assertEquals(expectedResponse, actualResponse);
325 
326     List<String> actualRequests = mockService.getRequestPaths();
327     Assert.assertEquals(1, actualRequests.size());
328 
329     String apiClientHeaderKey =
330         mockService
331             .getRequestHeaders()
332             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
333             .iterator()
334             .next();
335     Assert.assertTrue(
336         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
337             .matcher(apiClientHeaderKey)
338             .matches());
339   }
340 
341   @Test
insertExceptionTest()342   public void insertExceptionTest() throws Exception {
343     ApiException exception =
344         ApiExceptionFactory.createException(
345             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
346     mockService.addException(exception);
347 
348     try {
349       String project = "project-6911";
350       String region = "region-9622";
351       ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
352       client.insertAsync(project, region, forwardingRuleResource).get();
353       Assert.fail("No exception raised");
354     } catch (ExecutionException e) {
355     }
356   }
357 
358   @Test
listTest()359   public void listTest() throws Exception {
360     ForwardingRule responsesElement = ForwardingRule.newBuilder().build();
361     ForwardingRuleList expectedResponse =
362         ForwardingRuleList.newBuilder()
363             .setNextPageToken("")
364             .addAllItems(Arrays.asList(responsesElement))
365             .build();
366     mockService.addResponse(expectedResponse);
367 
368     String project = "project-6911";
369     String region = "region-9622";
370 
371     ListPagedResponse pagedListResponse = client.list(project, region);
372 
373     List<ForwardingRule> resources = Lists.newArrayList(pagedListResponse.iterateAll());
374 
375     Assert.assertEquals(1, resources.size());
376     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
377 
378     List<String> actualRequests = mockService.getRequestPaths();
379     Assert.assertEquals(1, actualRequests.size());
380 
381     String apiClientHeaderKey =
382         mockService
383             .getRequestHeaders()
384             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
385             .iterator()
386             .next();
387     Assert.assertTrue(
388         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
389             .matcher(apiClientHeaderKey)
390             .matches());
391   }
392 
393   @Test
listExceptionTest()394   public void listExceptionTest() throws Exception {
395     ApiException exception =
396         ApiExceptionFactory.createException(
397             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
398     mockService.addException(exception);
399 
400     try {
401       String project = "project-6911";
402       String region = "region-9622";
403       client.list(project, region);
404       Assert.fail("No exception raised");
405     } catch (InvalidArgumentException e) {
406       // Expected exception.
407     }
408   }
409 
410   @Test
patchTest()411   public void patchTest() throws Exception {
412     Operation expectedResponse =
413         Operation.newBuilder()
414             .setClientOperationId("clientOperationId-1230366697")
415             .setCreationTimestamp("creationTimestamp-370203401")
416             .setDescription("description-1724546052")
417             .setEndTime("endTime-1607243192")
418             .setError(Error.newBuilder().build())
419             .setHttpErrorMessage("httpErrorMessage1577303431")
420             .setHttpErrorStatusCode(0)
421             .setId(3355)
422             .setInsertTime("insertTime966165798")
423             .setKind("kind3292052")
424             .setName("name3373707")
425             .setOperationGroupId("operationGroupId1716161683")
426             .setOperationType("operationType91999553")
427             .setProgress(-1001078227)
428             .setRegion("region-934795532")
429             .setSelfLink("selfLink1191800166")
430             .setStartTime("startTime-2129294769")
431             .setStatus(Status.DONE)
432             .setStatusMessage("statusMessage-958704715")
433             .setTargetId(-815576439)
434             .setTargetLink("targetLink486368555")
435             .setUser("user3599307")
436             .addAllWarnings(new ArrayList<Warnings>())
437             .setZone("zone3744684")
438             .build();
439     mockService.addResponse(expectedResponse);
440 
441     String project = "project-6911";
442     String region = "region-9622";
443     String forwardingRule = "forwardingRule-4031";
444     ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
445 
446     Operation actualResponse =
447         client.patchAsync(project, region, forwardingRule, forwardingRuleResource).get();
448     Assert.assertEquals(expectedResponse, actualResponse);
449 
450     List<String> actualRequests = mockService.getRequestPaths();
451     Assert.assertEquals(1, actualRequests.size());
452 
453     String apiClientHeaderKey =
454         mockService
455             .getRequestHeaders()
456             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
457             .iterator()
458             .next();
459     Assert.assertTrue(
460         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
461             .matcher(apiClientHeaderKey)
462             .matches());
463   }
464 
465   @Test
patchExceptionTest()466   public void patchExceptionTest() throws Exception {
467     ApiException exception =
468         ApiExceptionFactory.createException(
469             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
470     mockService.addException(exception);
471 
472     try {
473       String project = "project-6911";
474       String region = "region-9622";
475       String forwardingRule = "forwardingRule-4031";
476       ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
477       client.patchAsync(project, region, forwardingRule, forwardingRuleResource).get();
478       Assert.fail("No exception raised");
479     } catch (ExecutionException e) {
480     }
481   }
482 
483   @Test
setLabelsTest()484   public void setLabelsTest() throws Exception {
485     Operation expectedResponse =
486         Operation.newBuilder()
487             .setClientOperationId("clientOperationId-1230366697")
488             .setCreationTimestamp("creationTimestamp-370203401")
489             .setDescription("description-1724546052")
490             .setEndTime("endTime-1607243192")
491             .setError(Error.newBuilder().build())
492             .setHttpErrorMessage("httpErrorMessage1577303431")
493             .setHttpErrorStatusCode(0)
494             .setId(3355)
495             .setInsertTime("insertTime966165798")
496             .setKind("kind3292052")
497             .setName("name3373707")
498             .setOperationGroupId("operationGroupId1716161683")
499             .setOperationType("operationType91999553")
500             .setProgress(-1001078227)
501             .setRegion("region-934795532")
502             .setSelfLink("selfLink1191800166")
503             .setStartTime("startTime-2129294769")
504             .setStatus(Status.DONE)
505             .setStatusMessage("statusMessage-958704715")
506             .setTargetId(-815576439)
507             .setTargetLink("targetLink486368555")
508             .setUser("user3599307")
509             .addAllWarnings(new ArrayList<Warnings>())
510             .setZone("zone3744684")
511             .build();
512     mockService.addResponse(expectedResponse);
513 
514     String project = "project-6911";
515     String region = "region-9622";
516     String resource = "resource-756";
517     RegionSetLabelsRequest regionSetLabelsRequestResource =
518         RegionSetLabelsRequest.newBuilder().build();
519 
520     Operation actualResponse =
521         client.setLabelsAsync(project, region, resource, regionSetLabelsRequestResource).get();
522     Assert.assertEquals(expectedResponse, actualResponse);
523 
524     List<String> actualRequests = mockService.getRequestPaths();
525     Assert.assertEquals(1, actualRequests.size());
526 
527     String apiClientHeaderKey =
528         mockService
529             .getRequestHeaders()
530             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
531             .iterator()
532             .next();
533     Assert.assertTrue(
534         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
535             .matcher(apiClientHeaderKey)
536             .matches());
537   }
538 
539   @Test
setLabelsExceptionTest()540   public void setLabelsExceptionTest() throws Exception {
541     ApiException exception =
542         ApiExceptionFactory.createException(
543             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
544     mockService.addException(exception);
545 
546     try {
547       String project = "project-6911";
548       String region = "region-9622";
549       String resource = "resource-756";
550       RegionSetLabelsRequest regionSetLabelsRequestResource =
551           RegionSetLabelsRequest.newBuilder().build();
552       client.setLabelsAsync(project, region, resource, regionSetLabelsRequestResource).get();
553       Assert.fail("No exception raised");
554     } catch (ExecutionException e) {
555     }
556   }
557 
558   @Test
setTargetTest()559   public void setTargetTest() throws Exception {
560     Operation expectedResponse =
561         Operation.newBuilder()
562             .setClientOperationId("clientOperationId-1230366697")
563             .setCreationTimestamp("creationTimestamp-370203401")
564             .setDescription("description-1724546052")
565             .setEndTime("endTime-1607243192")
566             .setError(Error.newBuilder().build())
567             .setHttpErrorMessage("httpErrorMessage1577303431")
568             .setHttpErrorStatusCode(0)
569             .setId(3355)
570             .setInsertTime("insertTime966165798")
571             .setKind("kind3292052")
572             .setName("name3373707")
573             .setOperationGroupId("operationGroupId1716161683")
574             .setOperationType("operationType91999553")
575             .setProgress(-1001078227)
576             .setRegion("region-934795532")
577             .setSelfLink("selfLink1191800166")
578             .setStartTime("startTime-2129294769")
579             .setStatus(Status.DONE)
580             .setStatusMessage("statusMessage-958704715")
581             .setTargetId(-815576439)
582             .setTargetLink("targetLink486368555")
583             .setUser("user3599307")
584             .addAllWarnings(new ArrayList<Warnings>())
585             .setZone("zone3744684")
586             .build();
587     mockService.addResponse(expectedResponse);
588 
589     String project = "project-6911";
590     String region = "region-9622";
591     String forwardingRule = "forwardingRule-4031";
592     TargetReference targetReferenceResource = TargetReference.newBuilder().build();
593 
594     Operation actualResponse =
595         client.setTargetAsync(project, region, forwardingRule, targetReferenceResource).get();
596     Assert.assertEquals(expectedResponse, actualResponse);
597 
598     List<String> actualRequests = mockService.getRequestPaths();
599     Assert.assertEquals(1, actualRequests.size());
600 
601     String apiClientHeaderKey =
602         mockService
603             .getRequestHeaders()
604             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
605             .iterator()
606             .next();
607     Assert.assertTrue(
608         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
609             .matcher(apiClientHeaderKey)
610             .matches());
611   }
612 
613   @Test
setTargetExceptionTest()614   public void setTargetExceptionTest() throws Exception {
615     ApiException exception =
616         ApiExceptionFactory.createException(
617             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
618     mockService.addException(exception);
619 
620     try {
621       String project = "project-6911";
622       String region = "region-9622";
623       String forwardingRule = "forwardingRule-4031";
624       TargetReference targetReferenceResource = TargetReference.newBuilder().build();
625       client.setTargetAsync(project, region, forwardingRule, targetReferenceResource).get();
626       Assert.fail("No exception raised");
627     } catch (ExecutionException e) {
628     }
629   }
630 }
631