• 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.PacketMirroringsClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.PacketMirroringsClient.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.HttpJsonPacketMirroringsStub;
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 PacketMirroringsClientTest {
51   private static MockHttpService mockService;
52   private static PacketMirroringsClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonPacketMirroringsStub.getMethodDescriptors(),
59             PacketMirroringsSettings.getDefaultEndpoint());
60     PacketMirroringsSettings settings =
61         PacketMirroringsSettings.newBuilder()
62             .setTransportChannelProvider(
63                 PacketMirroringsSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = PacketMirroringsClient.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     PacketMirroringsScopedList responsesElement = PacketMirroringsScopedList.newBuilder().build();
87     PacketMirroringAggregatedList expectedResponse =
88         PacketMirroringAggregatedList.newBuilder()
89             .setNextPageToken("")
90             .putAllItems(Collections.singletonMap("items", responsesElement))
91             .build();
92     mockService.addResponse(expectedResponse);
93 
94     String project = "project-6911";
95 
96     AggregatedListPagedResponse pagedListResponse = client.aggregatedList(project);
97 
98     List<Map.Entry<String, PacketMirroringsScopedList>> resources =
99         Lists.newArrayList(pagedListResponse.iterateAll());
100 
101     Assert.assertEquals(1, resources.size());
102     Assert.assertEquals(
103         expectedResponse.getItemsMap().entrySet().iterator().next(), resources.get(0));
104 
105     List<String> actualRequests = mockService.getRequestPaths();
106     Assert.assertEquals(1, actualRequests.size());
107 
108     String apiClientHeaderKey =
109         mockService
110             .getRequestHeaders()
111             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
112             .iterator()
113             .next();
114     Assert.assertTrue(
115         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
116             .matcher(apiClientHeaderKey)
117             .matches());
118   }
119 
120   @Test
aggregatedListExceptionTest()121   public void aggregatedListExceptionTest() throws Exception {
122     ApiException exception =
123         ApiExceptionFactory.createException(
124             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
125     mockService.addException(exception);
126 
127     try {
128       String project = "project-6911";
129       client.aggregatedList(project);
130       Assert.fail("No exception raised");
131     } catch (InvalidArgumentException e) {
132       // Expected exception.
133     }
134   }
135 
136   @Test
deleteTest()137   public void deleteTest() throws Exception {
138     Operation expectedResponse =
139         Operation.newBuilder()
140             .setClientOperationId("clientOperationId-1230366697")
141             .setCreationTimestamp("creationTimestamp-370203401")
142             .setDescription("description-1724546052")
143             .setEndTime("endTime-1607243192")
144             .setError(Error.newBuilder().build())
145             .setHttpErrorMessage("httpErrorMessage1577303431")
146             .setHttpErrorStatusCode(0)
147             .setId(3355)
148             .setInsertTime("insertTime966165798")
149             .setKind("kind3292052")
150             .setName("name3373707")
151             .setOperationGroupId("operationGroupId1716161683")
152             .setOperationType("operationType91999553")
153             .setProgress(-1001078227)
154             .setRegion("region-934795532")
155             .setSelfLink("selfLink1191800166")
156             .setStartTime("startTime-2129294769")
157             .setStatus(Status.DONE)
158             .setStatusMessage("statusMessage-958704715")
159             .setTargetId(-815576439)
160             .setTargetLink("targetLink486368555")
161             .setUser("user3599307")
162             .addAllWarnings(new ArrayList<Warnings>())
163             .setZone("zone3744684")
164             .build();
165     mockService.addResponse(expectedResponse);
166 
167     String project = "project-6911";
168     String region = "region-9622";
169     String packetMirroring = "packetMirroring-5695";
170 
171     Operation actualResponse = client.deleteAsync(project, region, packetMirroring).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 region = "region-9622";
199       String packetMirroring = "packetMirroring-5695";
200       client.deleteAsync(project, region, packetMirroring).get();
201       Assert.fail("No exception raised");
202     } catch (ExecutionException e) {
203     }
204   }
205 
206   @Test
getTest()207   public void getTest() throws Exception {
208     PacketMirroring expectedResponse =
209         PacketMirroring.newBuilder()
210             .setCollectorIlb(PacketMirroringForwardingRuleInfo.newBuilder().build())
211             .setCreationTimestamp("creationTimestamp-370203401")
212             .setDescription("description-1724546052")
213             .setEnable("enable-1298848381")
214             .setFilter(PacketMirroringFilter.newBuilder().build())
215             .setId(3355)
216             .setKind("kind3292052")
217             .setMirroredResources(PacketMirroringMirroredResourceInfo.newBuilder().build())
218             .setName("name3373707")
219             .setNetwork(PacketMirroringNetworkInfo.newBuilder().build())
220             .setPriority(-1165461084)
221             .setRegion("region-934795532")
222             .setSelfLink("selfLink1191800166")
223             .build();
224     mockService.addResponse(expectedResponse);
225 
226     String project = "project-6911";
227     String region = "region-9622";
228     String packetMirroring = "packetMirroring-5695";
229 
230     PacketMirroring actualResponse = client.get(project, region, packetMirroring);
231     Assert.assertEquals(expectedResponse, actualResponse);
232 
233     List<String> actualRequests = mockService.getRequestPaths();
234     Assert.assertEquals(1, actualRequests.size());
235 
236     String apiClientHeaderKey =
237         mockService
238             .getRequestHeaders()
239             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
240             .iterator()
241             .next();
242     Assert.assertTrue(
243         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
244             .matcher(apiClientHeaderKey)
245             .matches());
246   }
247 
248   @Test
getExceptionTest()249   public void getExceptionTest() throws Exception {
250     ApiException exception =
251         ApiExceptionFactory.createException(
252             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
253     mockService.addException(exception);
254 
255     try {
256       String project = "project-6911";
257       String region = "region-9622";
258       String packetMirroring = "packetMirroring-5695";
259       client.get(project, region, packetMirroring);
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     String region = "region-9622";
299     PacketMirroring packetMirroringResource = PacketMirroring.newBuilder().build();
300 
301     Operation actualResponse = client.insertAsync(project, region, packetMirroringResource).get();
302     Assert.assertEquals(expectedResponse, actualResponse);
303 
304     List<String> actualRequests = mockService.getRequestPaths();
305     Assert.assertEquals(1, actualRequests.size());
306 
307     String apiClientHeaderKey =
308         mockService
309             .getRequestHeaders()
310             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
311             .iterator()
312             .next();
313     Assert.assertTrue(
314         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
315             .matcher(apiClientHeaderKey)
316             .matches());
317   }
318 
319   @Test
insertExceptionTest()320   public void insertExceptionTest() throws Exception {
321     ApiException exception =
322         ApiExceptionFactory.createException(
323             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
324     mockService.addException(exception);
325 
326     try {
327       String project = "project-6911";
328       String region = "region-9622";
329       PacketMirroring packetMirroringResource = PacketMirroring.newBuilder().build();
330       client.insertAsync(project, region, packetMirroringResource).get();
331       Assert.fail("No exception raised");
332     } catch (ExecutionException e) {
333     }
334   }
335 
336   @Test
listTest()337   public void listTest() throws Exception {
338     PacketMirroring responsesElement = PacketMirroring.newBuilder().build();
339     PacketMirroringList expectedResponse =
340         PacketMirroringList.newBuilder()
341             .setNextPageToken("")
342             .addAllItems(Arrays.asList(responsesElement))
343             .build();
344     mockService.addResponse(expectedResponse);
345 
346     String project = "project-6911";
347     String region = "region-9622";
348 
349     ListPagedResponse pagedListResponse = client.list(project, region);
350 
351     List<PacketMirroring> resources = Lists.newArrayList(pagedListResponse.iterateAll());
352 
353     Assert.assertEquals(1, resources.size());
354     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
355 
356     List<String> actualRequests = mockService.getRequestPaths();
357     Assert.assertEquals(1, actualRequests.size());
358 
359     String apiClientHeaderKey =
360         mockService
361             .getRequestHeaders()
362             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
363             .iterator()
364             .next();
365     Assert.assertTrue(
366         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
367             .matcher(apiClientHeaderKey)
368             .matches());
369   }
370 
371   @Test
listExceptionTest()372   public void listExceptionTest() throws Exception {
373     ApiException exception =
374         ApiExceptionFactory.createException(
375             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
376     mockService.addException(exception);
377 
378     try {
379       String project = "project-6911";
380       String region = "region-9622";
381       client.list(project, region);
382       Assert.fail("No exception raised");
383     } catch (InvalidArgumentException e) {
384       // Expected exception.
385     }
386   }
387 
388   @Test
patchTest()389   public void patchTest() throws Exception {
390     Operation expectedResponse =
391         Operation.newBuilder()
392             .setClientOperationId("clientOperationId-1230366697")
393             .setCreationTimestamp("creationTimestamp-370203401")
394             .setDescription("description-1724546052")
395             .setEndTime("endTime-1607243192")
396             .setError(Error.newBuilder().build())
397             .setHttpErrorMessage("httpErrorMessage1577303431")
398             .setHttpErrorStatusCode(0)
399             .setId(3355)
400             .setInsertTime("insertTime966165798")
401             .setKind("kind3292052")
402             .setName("name3373707")
403             .setOperationGroupId("operationGroupId1716161683")
404             .setOperationType("operationType91999553")
405             .setProgress(-1001078227)
406             .setRegion("region-934795532")
407             .setSelfLink("selfLink1191800166")
408             .setStartTime("startTime-2129294769")
409             .setStatus(Status.DONE)
410             .setStatusMessage("statusMessage-958704715")
411             .setTargetId(-815576439)
412             .setTargetLink("targetLink486368555")
413             .setUser("user3599307")
414             .addAllWarnings(new ArrayList<Warnings>())
415             .setZone("zone3744684")
416             .build();
417     mockService.addResponse(expectedResponse);
418 
419     String project = "project-6911";
420     String region = "region-9622";
421     String packetMirroring = "packetMirroring-5695";
422     PacketMirroring packetMirroringResource = PacketMirroring.newBuilder().build();
423 
424     Operation actualResponse =
425         client.patchAsync(project, region, packetMirroring, packetMirroringResource).get();
426     Assert.assertEquals(expectedResponse, actualResponse);
427 
428     List<String> actualRequests = mockService.getRequestPaths();
429     Assert.assertEquals(1, actualRequests.size());
430 
431     String apiClientHeaderKey =
432         mockService
433             .getRequestHeaders()
434             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
435             .iterator()
436             .next();
437     Assert.assertTrue(
438         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
439             .matcher(apiClientHeaderKey)
440             .matches());
441   }
442 
443   @Test
patchExceptionTest()444   public void patchExceptionTest() throws Exception {
445     ApiException exception =
446         ApiExceptionFactory.createException(
447             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
448     mockService.addException(exception);
449 
450     try {
451       String project = "project-6911";
452       String region = "region-9622";
453       String packetMirroring = "packetMirroring-5695";
454       PacketMirroring packetMirroringResource = PacketMirroring.newBuilder().build();
455       client.patchAsync(project, region, packetMirroring, packetMirroringResource).get();
456       Assert.fail("No exception raised");
457     } catch (ExecutionException e) {
458     }
459   }
460 
461   @Test
testIamPermissionsTest()462   public void testIamPermissionsTest() throws Exception {
463     TestPermissionsResponse expectedResponse =
464         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
465     mockService.addResponse(expectedResponse);
466 
467     String project = "project-6911";
468     String region = "region-9622";
469     String resource = "resource-756";
470     TestPermissionsRequest testPermissionsRequestResource =
471         TestPermissionsRequest.newBuilder().build();
472 
473     TestPermissionsResponse actualResponse =
474         client.testIamPermissions(project, region, resource, testPermissionsRequestResource);
475     Assert.assertEquals(expectedResponse, actualResponse);
476 
477     List<String> actualRequests = mockService.getRequestPaths();
478     Assert.assertEquals(1, actualRequests.size());
479 
480     String apiClientHeaderKey =
481         mockService
482             .getRequestHeaders()
483             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
484             .iterator()
485             .next();
486     Assert.assertTrue(
487         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
488             .matcher(apiClientHeaderKey)
489             .matches());
490   }
491 
492   @Test
testIamPermissionsExceptionTest()493   public void testIamPermissionsExceptionTest() throws Exception {
494     ApiException exception =
495         ApiExceptionFactory.createException(
496             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
497     mockService.addException(exception);
498 
499     try {
500       String project = "project-6911";
501       String region = "region-9622";
502       String resource = "resource-756";
503       TestPermissionsRequest testPermissionsRequestResource =
504           TestPermissionsRequest.newBuilder().build();
505       client.testIamPermissions(project, region, resource, testPermissionsRequestResource);
506       Assert.fail("No exception raised");
507     } catch (InvalidArgumentException e) {
508       // Expected exception.
509     }
510   }
511 }
512