• 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.InstanceTemplatesClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.InstanceTemplatesClient.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.HttpJsonInstanceTemplatesStub;
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 InstanceTemplatesClientTest {
51   private static MockHttpService mockService;
52   private static InstanceTemplatesClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonInstanceTemplatesStub.getMethodDescriptors(),
59             InstanceTemplatesSettings.getDefaultEndpoint());
60     InstanceTemplatesSettings settings =
61         InstanceTemplatesSettings.newBuilder()
62             .setTransportChannelProvider(
63                 InstanceTemplatesSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = InstanceTemplatesClient.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     InstanceTemplatesScopedList responsesElement = InstanceTemplatesScopedList.newBuilder().build();
87     InstanceTemplateAggregatedList expectedResponse =
88         InstanceTemplateAggregatedList.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, InstanceTemplatesScopedList>> 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 instanceTemplate = "instanceTemplate-5147";
169 
170     Operation actualResponse = client.deleteAsync(project, instanceTemplate).get();
171     Assert.assertEquals(expectedResponse, actualResponse);
172 
173     List<String> actualRequests = mockService.getRequestPaths();
174     Assert.assertEquals(1, actualRequests.size());
175 
176     String apiClientHeaderKey =
177         mockService
178             .getRequestHeaders()
179             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
180             .iterator()
181             .next();
182     Assert.assertTrue(
183         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
184             .matcher(apiClientHeaderKey)
185             .matches());
186   }
187 
188   @Test
deleteExceptionTest()189   public void deleteExceptionTest() throws Exception {
190     ApiException exception =
191         ApiExceptionFactory.createException(
192             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
193     mockService.addException(exception);
194 
195     try {
196       String project = "project-6911";
197       String instanceTemplate = "instanceTemplate-5147";
198       client.deleteAsync(project, instanceTemplate).get();
199       Assert.fail("No exception raised");
200     } catch (ExecutionException e) {
201     }
202   }
203 
204   @Test
getTest()205   public void getTest() throws Exception {
206     InstanceTemplate expectedResponse =
207         InstanceTemplate.newBuilder()
208             .setCreationTimestamp("creationTimestamp-370203401")
209             .setDescription("description-1724546052")
210             .setId(3355)
211             .setKind("kind3292052")
212             .setName("name3373707")
213             .setProperties(InstanceProperties.newBuilder().build())
214             .setRegion("region-934795532")
215             .setSelfLink("selfLink1191800166")
216             .setSourceInstance("sourceInstance-808380976")
217             .setSourceInstanceParams(SourceInstanceParams.newBuilder().build())
218             .build();
219     mockService.addResponse(expectedResponse);
220 
221     String project = "project-6911";
222     String instanceTemplate = "instanceTemplate-5147";
223 
224     InstanceTemplate actualResponse = client.get(project, instanceTemplate);
225     Assert.assertEquals(expectedResponse, actualResponse);
226 
227     List<String> actualRequests = mockService.getRequestPaths();
228     Assert.assertEquals(1, actualRequests.size());
229 
230     String apiClientHeaderKey =
231         mockService
232             .getRequestHeaders()
233             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
234             .iterator()
235             .next();
236     Assert.assertTrue(
237         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
238             .matcher(apiClientHeaderKey)
239             .matches());
240   }
241 
242   @Test
getExceptionTest()243   public void getExceptionTest() throws Exception {
244     ApiException exception =
245         ApiExceptionFactory.createException(
246             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
247     mockService.addException(exception);
248 
249     try {
250       String project = "project-6911";
251       String instanceTemplate = "instanceTemplate-5147";
252       client.get(project, instanceTemplate);
253       Assert.fail("No exception raised");
254     } catch (InvalidArgumentException e) {
255       // Expected exception.
256     }
257   }
258 
259   @Test
getIamPolicyTest()260   public void getIamPolicyTest() throws Exception {
261     Policy expectedResponse =
262         Policy.newBuilder()
263             .addAllAuditConfigs(new ArrayList<AuditConfig>())
264             .addAllBindings(new ArrayList<Binding>())
265             .setEtag("etag3123477")
266             .setIamOwned(true)
267             .addAllRules(new ArrayList<Rule>())
268             .setVersion(351608024)
269             .build();
270     mockService.addResponse(expectedResponse);
271 
272     String project = "project-6911";
273     String resource = "resource-756";
274 
275     Policy actualResponse = client.getIamPolicy(project, resource);
276     Assert.assertEquals(expectedResponse, actualResponse);
277 
278     List<String> actualRequests = mockService.getRequestPaths();
279     Assert.assertEquals(1, actualRequests.size());
280 
281     String apiClientHeaderKey =
282         mockService
283             .getRequestHeaders()
284             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
285             .iterator()
286             .next();
287     Assert.assertTrue(
288         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
289             .matcher(apiClientHeaderKey)
290             .matches());
291   }
292 
293   @Test
getIamPolicyExceptionTest()294   public void getIamPolicyExceptionTest() throws Exception {
295     ApiException exception =
296         ApiExceptionFactory.createException(
297             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
298     mockService.addException(exception);
299 
300     try {
301       String project = "project-6911";
302       String resource = "resource-756";
303       client.getIamPolicy(project, resource);
304       Assert.fail("No exception raised");
305     } catch (InvalidArgumentException e) {
306       // Expected exception.
307     }
308   }
309 
310   @Test
insertTest()311   public void insertTest() throws Exception {
312     Operation expectedResponse =
313         Operation.newBuilder()
314             .setClientOperationId("clientOperationId-1230366697")
315             .setCreationTimestamp("creationTimestamp-370203401")
316             .setDescription("description-1724546052")
317             .setEndTime("endTime-1607243192")
318             .setError(Error.newBuilder().build())
319             .setHttpErrorMessage("httpErrorMessage1577303431")
320             .setHttpErrorStatusCode(0)
321             .setId(3355)
322             .setInsertTime("insertTime966165798")
323             .setKind("kind3292052")
324             .setName("name3373707")
325             .setOperationGroupId("operationGroupId1716161683")
326             .setOperationType("operationType91999553")
327             .setProgress(-1001078227)
328             .setRegion("region-934795532")
329             .setSelfLink("selfLink1191800166")
330             .setStartTime("startTime-2129294769")
331             .setStatus(Status.DONE)
332             .setStatusMessage("statusMessage-958704715")
333             .setTargetId(-815576439)
334             .setTargetLink("targetLink486368555")
335             .setUser("user3599307")
336             .addAllWarnings(new ArrayList<Warnings>())
337             .setZone("zone3744684")
338             .build();
339     mockService.addResponse(expectedResponse);
340 
341     String project = "project-6911";
342     InstanceTemplate instanceTemplateResource = InstanceTemplate.newBuilder().build();
343 
344     Operation actualResponse = client.insertAsync(project, instanceTemplateResource).get();
345     Assert.assertEquals(expectedResponse, actualResponse);
346 
347     List<String> actualRequests = mockService.getRequestPaths();
348     Assert.assertEquals(1, actualRequests.size());
349 
350     String apiClientHeaderKey =
351         mockService
352             .getRequestHeaders()
353             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
354             .iterator()
355             .next();
356     Assert.assertTrue(
357         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
358             .matcher(apiClientHeaderKey)
359             .matches());
360   }
361 
362   @Test
insertExceptionTest()363   public void insertExceptionTest() throws Exception {
364     ApiException exception =
365         ApiExceptionFactory.createException(
366             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
367     mockService.addException(exception);
368 
369     try {
370       String project = "project-6911";
371       InstanceTemplate instanceTemplateResource = InstanceTemplate.newBuilder().build();
372       client.insertAsync(project, instanceTemplateResource).get();
373       Assert.fail("No exception raised");
374     } catch (ExecutionException e) {
375     }
376   }
377 
378   @Test
listTest()379   public void listTest() throws Exception {
380     InstanceTemplate responsesElement = InstanceTemplate.newBuilder().build();
381     InstanceTemplateList expectedResponse =
382         InstanceTemplateList.newBuilder()
383             .setNextPageToken("")
384             .addAllItems(Arrays.asList(responsesElement))
385             .build();
386     mockService.addResponse(expectedResponse);
387 
388     String project = "project-6911";
389 
390     ListPagedResponse pagedListResponse = client.list(project);
391 
392     List<InstanceTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
393 
394     Assert.assertEquals(1, resources.size());
395     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
396 
397     List<String> actualRequests = mockService.getRequestPaths();
398     Assert.assertEquals(1, actualRequests.size());
399 
400     String apiClientHeaderKey =
401         mockService
402             .getRequestHeaders()
403             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
404             .iterator()
405             .next();
406     Assert.assertTrue(
407         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
408             .matcher(apiClientHeaderKey)
409             .matches());
410   }
411 
412   @Test
listExceptionTest()413   public void listExceptionTest() throws Exception {
414     ApiException exception =
415         ApiExceptionFactory.createException(
416             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
417     mockService.addException(exception);
418 
419     try {
420       String project = "project-6911";
421       client.list(project);
422       Assert.fail("No exception raised");
423     } catch (InvalidArgumentException e) {
424       // Expected exception.
425     }
426   }
427 
428   @Test
setIamPolicyTest()429   public void setIamPolicyTest() throws Exception {
430     Policy expectedResponse =
431         Policy.newBuilder()
432             .addAllAuditConfigs(new ArrayList<AuditConfig>())
433             .addAllBindings(new ArrayList<Binding>())
434             .setEtag("etag3123477")
435             .setIamOwned(true)
436             .addAllRules(new ArrayList<Rule>())
437             .setVersion(351608024)
438             .build();
439     mockService.addResponse(expectedResponse);
440 
441     String project = "project-6911";
442     String resource = "resource-756";
443     GlobalSetPolicyRequest globalSetPolicyRequestResource =
444         GlobalSetPolicyRequest.newBuilder().build();
445 
446     Policy actualResponse = client.setIamPolicy(project, resource, globalSetPolicyRequestResource);
447     Assert.assertEquals(expectedResponse, actualResponse);
448 
449     List<String> actualRequests = mockService.getRequestPaths();
450     Assert.assertEquals(1, actualRequests.size());
451 
452     String apiClientHeaderKey =
453         mockService
454             .getRequestHeaders()
455             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
456             .iterator()
457             .next();
458     Assert.assertTrue(
459         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
460             .matcher(apiClientHeaderKey)
461             .matches());
462   }
463 
464   @Test
setIamPolicyExceptionTest()465   public void setIamPolicyExceptionTest() throws Exception {
466     ApiException exception =
467         ApiExceptionFactory.createException(
468             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
469     mockService.addException(exception);
470 
471     try {
472       String project = "project-6911";
473       String resource = "resource-756";
474       GlobalSetPolicyRequest globalSetPolicyRequestResource =
475           GlobalSetPolicyRequest.newBuilder().build();
476       client.setIamPolicy(project, resource, globalSetPolicyRequestResource);
477       Assert.fail("No exception raised");
478     } catch (InvalidArgumentException e) {
479       // Expected exception.
480     }
481   }
482 
483   @Test
testIamPermissionsTest()484   public void testIamPermissionsTest() throws Exception {
485     TestPermissionsResponse expectedResponse =
486         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
487     mockService.addResponse(expectedResponse);
488 
489     String project = "project-6911";
490     String resource = "resource-756";
491     TestPermissionsRequest testPermissionsRequestResource =
492         TestPermissionsRequest.newBuilder().build();
493 
494     TestPermissionsResponse actualResponse =
495         client.testIamPermissions(project, resource, testPermissionsRequestResource);
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
testIamPermissionsExceptionTest()514   public void testIamPermissionsExceptionTest() 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 resource = "resource-756";
523       TestPermissionsRequest testPermissionsRequestResource =
524           TestPermissionsRequest.newBuilder().build();
525       client.testIamPermissions(project, resource, testPermissionsRequestResource);
526       Assert.fail("No exception raised");
527     } catch (InvalidArgumentException e) {
528       // Expected exception.
529     }
530   }
531 }
532