• 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.GlobalForwardingRulesClient.ListPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
23 import com.google.api.gax.httpjson.testing.MockHttpService;
24 import com.google.api.gax.rpc.ApiClientHeaderProvider;
25 import com.google.api.gax.rpc.ApiException;
26 import com.google.api.gax.rpc.ApiExceptionFactory;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.api.gax.rpc.testing.FakeStatusCode;
30 import com.google.cloud.compute.v1.Operation.Status;
31 import com.google.cloud.compute.v1.stub.HttpJsonGlobalForwardingRulesStub;
32 import com.google.common.collect.Lists;
33 import java.io.IOException;
34 import java.util.ArrayList;
35 import java.util.Arrays;
36 import java.util.HashMap;
37 import java.util.List;
38 import java.util.concurrent.ExecutionException;
39 import javax.annotation.Generated;
40 import org.junit.After;
41 import org.junit.AfterClass;
42 import org.junit.Assert;
43 import org.junit.Before;
44 import org.junit.BeforeClass;
45 import org.junit.Test;
46 
47 @Generated("by gapic-generator-java")
48 public class GlobalForwardingRulesClientTest {
49   private static MockHttpService mockService;
50   private static GlobalForwardingRulesClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() throws IOException {
54     mockService =
55         new MockHttpService(
56             HttpJsonGlobalForwardingRulesStub.getMethodDescriptors(),
57             GlobalForwardingRulesSettings.getDefaultEndpoint());
58     GlobalForwardingRulesSettings settings =
59         GlobalForwardingRulesSettings.newBuilder()
60             .setTransportChannelProvider(
61                 GlobalForwardingRulesSettings.defaultHttpJsonTransportProviderBuilder()
62                     .setHttpTransport(mockService)
63                     .build())
64             .setCredentialsProvider(NoCredentialsProvider.create())
65             .build();
66     client = GlobalForwardingRulesClient.create(settings);
67   }
68 
69   @AfterClass
stopServer()70   public static void stopServer() {
71     client.close();
72   }
73 
74   @Before
setUp()75   public void setUp() {}
76 
77   @After
tearDown()78   public void tearDown() throws Exception {
79     mockService.reset();
80   }
81 
82   @Test
deleteTest()83   public void deleteTest() throws Exception {
84     Operation expectedResponse =
85         Operation.newBuilder()
86             .setClientOperationId("clientOperationId-1230366697")
87             .setCreationTimestamp("creationTimestamp-370203401")
88             .setDescription("description-1724546052")
89             .setEndTime("endTime-1607243192")
90             .setError(Error.newBuilder().build())
91             .setHttpErrorMessage("httpErrorMessage1577303431")
92             .setHttpErrorStatusCode(0)
93             .setId(3355)
94             .setInsertTime("insertTime966165798")
95             .setKind("kind3292052")
96             .setName("name3373707")
97             .setOperationGroupId("operationGroupId1716161683")
98             .setOperationType("operationType91999553")
99             .setProgress(-1001078227)
100             .setRegion("region-934795532")
101             .setSelfLink("selfLink1191800166")
102             .setStartTime("startTime-2129294769")
103             .setStatus(Status.DONE)
104             .setStatusMessage("statusMessage-958704715")
105             .setTargetId(-815576439)
106             .setTargetLink("targetLink486368555")
107             .setUser("user3599307")
108             .addAllWarnings(new ArrayList<Warnings>())
109             .setZone("zone3744684")
110             .build();
111     mockService.addResponse(expectedResponse);
112 
113     String project = "project-6911";
114     String forwardingRule = "forwardingRule-4031";
115 
116     Operation actualResponse = client.deleteAsync(project, forwardingRule).get();
117     Assert.assertEquals(expectedResponse, actualResponse);
118 
119     List<String> actualRequests = mockService.getRequestPaths();
120     Assert.assertEquals(1, actualRequests.size());
121 
122     String apiClientHeaderKey =
123         mockService
124             .getRequestHeaders()
125             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
126             .iterator()
127             .next();
128     Assert.assertTrue(
129         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
130             .matcher(apiClientHeaderKey)
131             .matches());
132   }
133 
134   @Test
deleteExceptionTest()135   public void deleteExceptionTest() throws Exception {
136     ApiException exception =
137         ApiExceptionFactory.createException(
138             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
139     mockService.addException(exception);
140 
141     try {
142       String project = "project-6911";
143       String forwardingRule = "forwardingRule-4031";
144       client.deleteAsync(project, forwardingRule).get();
145       Assert.fail("No exception raised");
146     } catch (ExecutionException e) {
147     }
148   }
149 
150   @Test
getTest()151   public void getTest() throws Exception {
152     ForwardingRule expectedResponse =
153         ForwardingRule.newBuilder()
154             .setIPAddress("iPAddress1698676973")
155             .setIPProtocol("iPProtocol1348929727")
156             .setAllPorts(true)
157             .setAllowGlobalAccess(true)
158             .setBackendService("backendService-1884714623")
159             .setBaseForwardingRule("baseForwardingRule124102858")
160             .setCreationTimestamp("creationTimestamp-370203401")
161             .setDescription("description-1724546052")
162             .setFingerprint("fingerprint-1375934236")
163             .setId(3355)
164             .setIpVersion("ipVersion-1161634383")
165             .setIsMirroringCollector(true)
166             .setKind("kind3292052")
167             .setLabelFingerprint("labelFingerprint379449680")
168             .putAllLabels(new HashMap<String, String>())
169             .setLoadBalancingScheme("loadBalancingScheme-1223583272")
170             .addAllMetadataFilters(new ArrayList<MetadataFilter>())
171             .setName("name3373707")
172             .setNetwork("network1843485230")
173             .setNetworkTier("networkTier-1940629200")
174             .setNoAutomateDnsZone(true)
175             .setPortRange("portRange1102895420")
176             .addAllPorts(new ArrayList<String>())
177             .setPscConnectionId(292082397)
178             .setPscConnectionStatus("pscConnectionStatus2068878160")
179             .setRegion("region-934795532")
180             .setSelfLink("selfLink1191800166")
181             .addAllServiceDirectoryRegistrations(
182                 new ArrayList<ForwardingRuleServiceDirectoryRegistration>())
183             .setServiceLabel("serviceLabel341946687")
184             .setServiceName("serviceName-1928572192")
185             .addAllSourceIpRanges(new ArrayList<String>())
186             .setSubnetwork("subnetwork-1302785042")
187             .setTarget("target-880905839")
188             .build();
189     mockService.addResponse(expectedResponse);
190 
191     String project = "project-6911";
192     String forwardingRule = "forwardingRule-4031";
193 
194     ForwardingRule actualResponse = client.get(project, forwardingRule);
195     Assert.assertEquals(expectedResponse, actualResponse);
196 
197     List<String> actualRequests = mockService.getRequestPaths();
198     Assert.assertEquals(1, actualRequests.size());
199 
200     String apiClientHeaderKey =
201         mockService
202             .getRequestHeaders()
203             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
204             .iterator()
205             .next();
206     Assert.assertTrue(
207         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
208             .matcher(apiClientHeaderKey)
209             .matches());
210   }
211 
212   @Test
getExceptionTest()213   public void getExceptionTest() throws Exception {
214     ApiException exception =
215         ApiExceptionFactory.createException(
216             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
217     mockService.addException(exception);
218 
219     try {
220       String project = "project-6911";
221       String forwardingRule = "forwardingRule-4031";
222       client.get(project, forwardingRule);
223       Assert.fail("No exception raised");
224     } catch (InvalidArgumentException e) {
225       // Expected exception.
226     }
227   }
228 
229   @Test
insertTest()230   public void insertTest() throws Exception {
231     Operation expectedResponse =
232         Operation.newBuilder()
233             .setClientOperationId("clientOperationId-1230366697")
234             .setCreationTimestamp("creationTimestamp-370203401")
235             .setDescription("description-1724546052")
236             .setEndTime("endTime-1607243192")
237             .setError(Error.newBuilder().build())
238             .setHttpErrorMessage("httpErrorMessage1577303431")
239             .setHttpErrorStatusCode(0)
240             .setId(3355)
241             .setInsertTime("insertTime966165798")
242             .setKind("kind3292052")
243             .setName("name3373707")
244             .setOperationGroupId("operationGroupId1716161683")
245             .setOperationType("operationType91999553")
246             .setProgress(-1001078227)
247             .setRegion("region-934795532")
248             .setSelfLink("selfLink1191800166")
249             .setStartTime("startTime-2129294769")
250             .setStatus(Status.DONE)
251             .setStatusMessage("statusMessage-958704715")
252             .setTargetId(-815576439)
253             .setTargetLink("targetLink486368555")
254             .setUser("user3599307")
255             .addAllWarnings(new ArrayList<Warnings>())
256             .setZone("zone3744684")
257             .build();
258     mockService.addResponse(expectedResponse);
259 
260     String project = "project-6911";
261     ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
262 
263     Operation actualResponse = client.insertAsync(project, forwardingRuleResource).get();
264     Assert.assertEquals(expectedResponse, actualResponse);
265 
266     List<String> actualRequests = mockService.getRequestPaths();
267     Assert.assertEquals(1, actualRequests.size());
268 
269     String apiClientHeaderKey =
270         mockService
271             .getRequestHeaders()
272             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
273             .iterator()
274             .next();
275     Assert.assertTrue(
276         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
277             .matcher(apiClientHeaderKey)
278             .matches());
279   }
280 
281   @Test
insertExceptionTest()282   public void insertExceptionTest() throws Exception {
283     ApiException exception =
284         ApiExceptionFactory.createException(
285             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
286     mockService.addException(exception);
287 
288     try {
289       String project = "project-6911";
290       ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
291       client.insertAsync(project, forwardingRuleResource).get();
292       Assert.fail("No exception raised");
293     } catch (ExecutionException e) {
294     }
295   }
296 
297   @Test
listTest()298   public void listTest() throws Exception {
299     ForwardingRule responsesElement = ForwardingRule.newBuilder().build();
300     ForwardingRuleList expectedResponse =
301         ForwardingRuleList.newBuilder()
302             .setNextPageToken("")
303             .addAllItems(Arrays.asList(responsesElement))
304             .build();
305     mockService.addResponse(expectedResponse);
306 
307     String project = "project-6911";
308 
309     ListPagedResponse pagedListResponse = client.list(project);
310 
311     List<ForwardingRule> resources = Lists.newArrayList(pagedListResponse.iterateAll());
312 
313     Assert.assertEquals(1, resources.size());
314     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
315 
316     List<String> actualRequests = mockService.getRequestPaths();
317     Assert.assertEquals(1, actualRequests.size());
318 
319     String apiClientHeaderKey =
320         mockService
321             .getRequestHeaders()
322             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
323             .iterator()
324             .next();
325     Assert.assertTrue(
326         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
327             .matcher(apiClientHeaderKey)
328             .matches());
329   }
330 
331   @Test
listExceptionTest()332   public void listExceptionTest() throws Exception {
333     ApiException exception =
334         ApiExceptionFactory.createException(
335             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
336     mockService.addException(exception);
337 
338     try {
339       String project = "project-6911";
340       client.list(project);
341       Assert.fail("No exception raised");
342     } catch (InvalidArgumentException e) {
343       // Expected exception.
344     }
345   }
346 
347   @Test
patchTest()348   public void patchTest() throws Exception {
349     Operation expectedResponse =
350         Operation.newBuilder()
351             .setClientOperationId("clientOperationId-1230366697")
352             .setCreationTimestamp("creationTimestamp-370203401")
353             .setDescription("description-1724546052")
354             .setEndTime("endTime-1607243192")
355             .setError(Error.newBuilder().build())
356             .setHttpErrorMessage("httpErrorMessage1577303431")
357             .setHttpErrorStatusCode(0)
358             .setId(3355)
359             .setInsertTime("insertTime966165798")
360             .setKind("kind3292052")
361             .setName("name3373707")
362             .setOperationGroupId("operationGroupId1716161683")
363             .setOperationType("operationType91999553")
364             .setProgress(-1001078227)
365             .setRegion("region-934795532")
366             .setSelfLink("selfLink1191800166")
367             .setStartTime("startTime-2129294769")
368             .setStatus(Status.DONE)
369             .setStatusMessage("statusMessage-958704715")
370             .setTargetId(-815576439)
371             .setTargetLink("targetLink486368555")
372             .setUser("user3599307")
373             .addAllWarnings(new ArrayList<Warnings>())
374             .setZone("zone3744684")
375             .build();
376     mockService.addResponse(expectedResponse);
377 
378     String project = "project-6911";
379     String forwardingRule = "forwardingRule-4031";
380     ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
381 
382     Operation actualResponse =
383         client.patchAsync(project, forwardingRule, forwardingRuleResource).get();
384     Assert.assertEquals(expectedResponse, actualResponse);
385 
386     List<String> actualRequests = mockService.getRequestPaths();
387     Assert.assertEquals(1, actualRequests.size());
388 
389     String apiClientHeaderKey =
390         mockService
391             .getRequestHeaders()
392             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
393             .iterator()
394             .next();
395     Assert.assertTrue(
396         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
397             .matcher(apiClientHeaderKey)
398             .matches());
399   }
400 
401   @Test
patchExceptionTest()402   public void patchExceptionTest() throws Exception {
403     ApiException exception =
404         ApiExceptionFactory.createException(
405             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
406     mockService.addException(exception);
407 
408     try {
409       String project = "project-6911";
410       String forwardingRule = "forwardingRule-4031";
411       ForwardingRule forwardingRuleResource = ForwardingRule.newBuilder().build();
412       client.patchAsync(project, forwardingRule, forwardingRuleResource).get();
413       Assert.fail("No exception raised");
414     } catch (ExecutionException e) {
415     }
416   }
417 
418   @Test
setLabelsTest()419   public void setLabelsTest() throws Exception {
420     Operation expectedResponse =
421         Operation.newBuilder()
422             .setClientOperationId("clientOperationId-1230366697")
423             .setCreationTimestamp("creationTimestamp-370203401")
424             .setDescription("description-1724546052")
425             .setEndTime("endTime-1607243192")
426             .setError(Error.newBuilder().build())
427             .setHttpErrorMessage("httpErrorMessage1577303431")
428             .setHttpErrorStatusCode(0)
429             .setId(3355)
430             .setInsertTime("insertTime966165798")
431             .setKind("kind3292052")
432             .setName("name3373707")
433             .setOperationGroupId("operationGroupId1716161683")
434             .setOperationType("operationType91999553")
435             .setProgress(-1001078227)
436             .setRegion("region-934795532")
437             .setSelfLink("selfLink1191800166")
438             .setStartTime("startTime-2129294769")
439             .setStatus(Status.DONE)
440             .setStatusMessage("statusMessage-958704715")
441             .setTargetId(-815576439)
442             .setTargetLink("targetLink486368555")
443             .setUser("user3599307")
444             .addAllWarnings(new ArrayList<Warnings>())
445             .setZone("zone3744684")
446             .build();
447     mockService.addResponse(expectedResponse);
448 
449     String project = "project-6911";
450     String resource = "resource-756";
451     GlobalSetLabelsRequest globalSetLabelsRequestResource =
452         GlobalSetLabelsRequest.newBuilder().build();
453 
454     Operation actualResponse =
455         client.setLabelsAsync(project, resource, globalSetLabelsRequestResource).get();
456     Assert.assertEquals(expectedResponse, actualResponse);
457 
458     List<String> actualRequests = mockService.getRequestPaths();
459     Assert.assertEquals(1, actualRequests.size());
460 
461     String apiClientHeaderKey =
462         mockService
463             .getRequestHeaders()
464             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
465             .iterator()
466             .next();
467     Assert.assertTrue(
468         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
469             .matcher(apiClientHeaderKey)
470             .matches());
471   }
472 
473   @Test
setLabelsExceptionTest()474   public void setLabelsExceptionTest() throws Exception {
475     ApiException exception =
476         ApiExceptionFactory.createException(
477             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
478     mockService.addException(exception);
479 
480     try {
481       String project = "project-6911";
482       String resource = "resource-756";
483       GlobalSetLabelsRequest globalSetLabelsRequestResource =
484           GlobalSetLabelsRequest.newBuilder().build();
485       client.setLabelsAsync(project, resource, globalSetLabelsRequestResource).get();
486       Assert.fail("No exception raised");
487     } catch (ExecutionException e) {
488     }
489   }
490 
491   @Test
setTargetTest()492   public void setTargetTest() throws Exception {
493     Operation expectedResponse =
494         Operation.newBuilder()
495             .setClientOperationId("clientOperationId-1230366697")
496             .setCreationTimestamp("creationTimestamp-370203401")
497             .setDescription("description-1724546052")
498             .setEndTime("endTime-1607243192")
499             .setError(Error.newBuilder().build())
500             .setHttpErrorMessage("httpErrorMessage1577303431")
501             .setHttpErrorStatusCode(0)
502             .setId(3355)
503             .setInsertTime("insertTime966165798")
504             .setKind("kind3292052")
505             .setName("name3373707")
506             .setOperationGroupId("operationGroupId1716161683")
507             .setOperationType("operationType91999553")
508             .setProgress(-1001078227)
509             .setRegion("region-934795532")
510             .setSelfLink("selfLink1191800166")
511             .setStartTime("startTime-2129294769")
512             .setStatus(Status.DONE)
513             .setStatusMessage("statusMessage-958704715")
514             .setTargetId(-815576439)
515             .setTargetLink("targetLink486368555")
516             .setUser("user3599307")
517             .addAllWarnings(new ArrayList<Warnings>())
518             .setZone("zone3744684")
519             .build();
520     mockService.addResponse(expectedResponse);
521 
522     String project = "project-6911";
523     String forwardingRule = "forwardingRule-4031";
524     TargetReference targetReferenceResource = TargetReference.newBuilder().build();
525 
526     Operation actualResponse =
527         client.setTargetAsync(project, forwardingRule, targetReferenceResource).get();
528     Assert.assertEquals(expectedResponse, actualResponse);
529 
530     List<String> actualRequests = mockService.getRequestPaths();
531     Assert.assertEquals(1, actualRequests.size());
532 
533     String apiClientHeaderKey =
534         mockService
535             .getRequestHeaders()
536             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
537             .iterator()
538             .next();
539     Assert.assertTrue(
540         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
541             .matcher(apiClientHeaderKey)
542             .matches());
543   }
544 
545   @Test
setTargetExceptionTest()546   public void setTargetExceptionTest() throws Exception {
547     ApiException exception =
548         ApiExceptionFactory.createException(
549             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
550     mockService.addException(exception);
551 
552     try {
553       String project = "project-6911";
554       String forwardingRule = "forwardingRule-4031";
555       TargetReference targetReferenceResource = TargetReference.newBuilder().build();
556       client.setTargetAsync(project, forwardingRule, targetReferenceResource).get();
557       Assert.fail("No exception raised");
558     } catch (ExecutionException e) {
559     }
560   }
561 }
562