• 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.NodeTemplatesClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.NodeTemplatesClient.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.HttpJsonNodeTemplatesStub;
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 NodeTemplatesClientTest {
52   private static MockHttpService mockService;
53   private static NodeTemplatesClient client;
54 
55   @BeforeClass
startStaticServer()56   public static void startStaticServer() throws IOException {
57     mockService =
58         new MockHttpService(
59             HttpJsonNodeTemplatesStub.getMethodDescriptors(),
60             NodeTemplatesSettings.getDefaultEndpoint());
61     NodeTemplatesSettings settings =
62         NodeTemplatesSettings.newBuilder()
63             .setTransportChannelProvider(
64                 NodeTemplatesSettings.defaultHttpJsonTransportProviderBuilder()
65                     .setHttpTransport(mockService)
66                     .build())
67             .setCredentialsProvider(NoCredentialsProvider.create())
68             .build();
69     client = NodeTemplatesClient.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     NodeTemplatesScopedList responsesElement = NodeTemplatesScopedList.newBuilder().build();
88     NodeTemplateAggregatedList expectedResponse =
89         NodeTemplateAggregatedList.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, NodeTemplatesScopedList>> 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 nodeTemplate = "nodeTemplate-1374";
171 
172     Operation actualResponse = client.deleteAsync(project, region, nodeTemplate).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 nodeTemplate = "nodeTemplate-1374";
201       client.deleteAsync(project, region, nodeTemplate).get();
202       Assert.fail("No exception raised");
203     } catch (ExecutionException e) {
204     }
205   }
206 
207   @Test
getTest()208   public void getTest() throws Exception {
209     NodeTemplate expectedResponse =
210         NodeTemplate.newBuilder()
211             .addAllAccelerators(new ArrayList<AcceleratorConfig>())
212             .setCpuOvercommitType("cpuOvercommitType708789421")
213             .setCreationTimestamp("creationTimestamp-370203401")
214             .setDescription("description-1724546052")
215             .addAllDisks(new ArrayList<LocalDisk>())
216             .setId(3355)
217             .setKind("kind3292052")
218             .setName("name3373707")
219             .putAllNodeAffinityLabels(new HashMap<String, String>())
220             .setNodeType("nodeType1123082332")
221             .setNodeTypeFlexibility(NodeTemplateNodeTypeFlexibility.newBuilder().build())
222             .setRegion("region-934795532")
223             .setSelfLink("selfLink1191800166")
224             .setServerBinding(ServerBinding.newBuilder().build())
225             .setStatus("status-892481550")
226             .setStatusMessage("statusMessage-958704715")
227             .build();
228     mockService.addResponse(expectedResponse);
229 
230     String project = "project-6911";
231     String region = "region-9622";
232     String nodeTemplate = "nodeTemplate-1374";
233 
234     NodeTemplate actualResponse = client.get(project, region, nodeTemplate);
235     Assert.assertEquals(expectedResponse, actualResponse);
236 
237     List<String> actualRequests = mockService.getRequestPaths();
238     Assert.assertEquals(1, actualRequests.size());
239 
240     String apiClientHeaderKey =
241         mockService
242             .getRequestHeaders()
243             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
244             .iterator()
245             .next();
246     Assert.assertTrue(
247         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
248             .matcher(apiClientHeaderKey)
249             .matches());
250   }
251 
252   @Test
getExceptionTest()253   public void getExceptionTest() throws Exception {
254     ApiException exception =
255         ApiExceptionFactory.createException(
256             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
257     mockService.addException(exception);
258 
259     try {
260       String project = "project-6911";
261       String region = "region-9622";
262       String nodeTemplate = "nodeTemplate-1374";
263       client.get(project, region, nodeTemplate);
264       Assert.fail("No exception raised");
265     } catch (InvalidArgumentException e) {
266       // Expected exception.
267     }
268   }
269 
270   @Test
getIamPolicyTest()271   public void getIamPolicyTest() throws Exception {
272     Policy expectedResponse =
273         Policy.newBuilder()
274             .addAllAuditConfigs(new ArrayList<AuditConfig>())
275             .addAllBindings(new ArrayList<Binding>())
276             .setEtag("etag3123477")
277             .setIamOwned(true)
278             .addAllRules(new ArrayList<Rule>())
279             .setVersion(351608024)
280             .build();
281     mockService.addResponse(expectedResponse);
282 
283     String project = "project-6911";
284     String region = "region-9622";
285     String resource = "resource-756";
286 
287     Policy actualResponse = client.getIamPolicy(project, region, resource);
288     Assert.assertEquals(expectedResponse, actualResponse);
289 
290     List<String> actualRequests = mockService.getRequestPaths();
291     Assert.assertEquals(1, actualRequests.size());
292 
293     String apiClientHeaderKey =
294         mockService
295             .getRequestHeaders()
296             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
297             .iterator()
298             .next();
299     Assert.assertTrue(
300         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
301             .matcher(apiClientHeaderKey)
302             .matches());
303   }
304 
305   @Test
getIamPolicyExceptionTest()306   public void getIamPolicyExceptionTest() throws Exception {
307     ApiException exception =
308         ApiExceptionFactory.createException(
309             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
310     mockService.addException(exception);
311 
312     try {
313       String project = "project-6911";
314       String region = "region-9622";
315       String resource = "resource-756";
316       client.getIamPolicy(project, region, resource);
317       Assert.fail("No exception raised");
318     } catch (InvalidArgumentException e) {
319       // Expected exception.
320     }
321   }
322 
323   @Test
insertTest()324   public void insertTest() throws Exception {
325     Operation expectedResponse =
326         Operation.newBuilder()
327             .setClientOperationId("clientOperationId-1230366697")
328             .setCreationTimestamp("creationTimestamp-370203401")
329             .setDescription("description-1724546052")
330             .setEndTime("endTime-1607243192")
331             .setError(Error.newBuilder().build())
332             .setHttpErrorMessage("httpErrorMessage1577303431")
333             .setHttpErrorStatusCode(0)
334             .setId(3355)
335             .setInsertTime("insertTime966165798")
336             .setKind("kind3292052")
337             .setName("name3373707")
338             .setOperationGroupId("operationGroupId1716161683")
339             .setOperationType("operationType91999553")
340             .setProgress(-1001078227)
341             .setRegion("region-934795532")
342             .setSelfLink("selfLink1191800166")
343             .setStartTime("startTime-2129294769")
344             .setStatus(Status.DONE)
345             .setStatusMessage("statusMessage-958704715")
346             .setTargetId(-815576439)
347             .setTargetLink("targetLink486368555")
348             .setUser("user3599307")
349             .addAllWarnings(new ArrayList<Warnings>())
350             .setZone("zone3744684")
351             .build();
352     mockService.addResponse(expectedResponse);
353 
354     String project = "project-6911";
355     String region = "region-9622";
356     NodeTemplate nodeTemplateResource = NodeTemplate.newBuilder().build();
357 
358     Operation actualResponse = client.insertAsync(project, region, nodeTemplateResource).get();
359     Assert.assertEquals(expectedResponse, actualResponse);
360 
361     List<String> actualRequests = mockService.getRequestPaths();
362     Assert.assertEquals(1, actualRequests.size());
363 
364     String apiClientHeaderKey =
365         mockService
366             .getRequestHeaders()
367             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
368             .iterator()
369             .next();
370     Assert.assertTrue(
371         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
372             .matcher(apiClientHeaderKey)
373             .matches());
374   }
375 
376   @Test
insertExceptionTest()377   public void insertExceptionTest() throws Exception {
378     ApiException exception =
379         ApiExceptionFactory.createException(
380             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
381     mockService.addException(exception);
382 
383     try {
384       String project = "project-6911";
385       String region = "region-9622";
386       NodeTemplate nodeTemplateResource = NodeTemplate.newBuilder().build();
387       client.insertAsync(project, region, nodeTemplateResource).get();
388       Assert.fail("No exception raised");
389     } catch (ExecutionException e) {
390     }
391   }
392 
393   @Test
listTest()394   public void listTest() throws Exception {
395     NodeTemplate responsesElement = NodeTemplate.newBuilder().build();
396     NodeTemplateList expectedResponse =
397         NodeTemplateList.newBuilder()
398             .setNextPageToken("")
399             .addAllItems(Arrays.asList(responsesElement))
400             .build();
401     mockService.addResponse(expectedResponse);
402 
403     String project = "project-6911";
404     String region = "region-9622";
405 
406     ListPagedResponse pagedListResponse = client.list(project, region);
407 
408     List<NodeTemplate> resources = Lists.newArrayList(pagedListResponse.iterateAll());
409 
410     Assert.assertEquals(1, resources.size());
411     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
412 
413     List<String> actualRequests = mockService.getRequestPaths();
414     Assert.assertEquals(1, actualRequests.size());
415 
416     String apiClientHeaderKey =
417         mockService
418             .getRequestHeaders()
419             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
420             .iterator()
421             .next();
422     Assert.assertTrue(
423         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
424             .matcher(apiClientHeaderKey)
425             .matches());
426   }
427 
428   @Test
listExceptionTest()429   public void listExceptionTest() throws Exception {
430     ApiException exception =
431         ApiExceptionFactory.createException(
432             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
433     mockService.addException(exception);
434 
435     try {
436       String project = "project-6911";
437       String region = "region-9622";
438       client.list(project, region);
439       Assert.fail("No exception raised");
440     } catch (InvalidArgumentException e) {
441       // Expected exception.
442     }
443   }
444 
445   @Test
setIamPolicyTest()446   public void setIamPolicyTest() throws Exception {
447     Policy expectedResponse =
448         Policy.newBuilder()
449             .addAllAuditConfigs(new ArrayList<AuditConfig>())
450             .addAllBindings(new ArrayList<Binding>())
451             .setEtag("etag3123477")
452             .setIamOwned(true)
453             .addAllRules(new ArrayList<Rule>())
454             .setVersion(351608024)
455             .build();
456     mockService.addResponse(expectedResponse);
457 
458     String project = "project-6911";
459     String region = "region-9622";
460     String resource = "resource-756";
461     RegionSetPolicyRequest regionSetPolicyRequestResource =
462         RegionSetPolicyRequest.newBuilder().build();
463 
464     Policy actualResponse =
465         client.setIamPolicy(project, region, resource, regionSetPolicyRequestResource);
466     Assert.assertEquals(expectedResponse, actualResponse);
467 
468     List<String> actualRequests = mockService.getRequestPaths();
469     Assert.assertEquals(1, actualRequests.size());
470 
471     String apiClientHeaderKey =
472         mockService
473             .getRequestHeaders()
474             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
475             .iterator()
476             .next();
477     Assert.assertTrue(
478         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
479             .matcher(apiClientHeaderKey)
480             .matches());
481   }
482 
483   @Test
setIamPolicyExceptionTest()484   public void setIamPolicyExceptionTest() throws Exception {
485     ApiException exception =
486         ApiExceptionFactory.createException(
487             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
488     mockService.addException(exception);
489 
490     try {
491       String project = "project-6911";
492       String region = "region-9622";
493       String resource = "resource-756";
494       RegionSetPolicyRequest regionSetPolicyRequestResource =
495           RegionSetPolicyRequest.newBuilder().build();
496       client.setIamPolicy(project, region, resource, regionSetPolicyRequestResource);
497       Assert.fail("No exception raised");
498     } catch (InvalidArgumentException e) {
499       // Expected exception.
500     }
501   }
502 
503   @Test
testIamPermissionsTest()504   public void testIamPermissionsTest() throws Exception {
505     TestPermissionsResponse expectedResponse =
506         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
507     mockService.addResponse(expectedResponse);
508 
509     String project = "project-6911";
510     String region = "region-9622";
511     String resource = "resource-756";
512     TestPermissionsRequest testPermissionsRequestResource =
513         TestPermissionsRequest.newBuilder().build();
514 
515     TestPermissionsResponse actualResponse =
516         client.testIamPermissions(project, region, resource, testPermissionsRequestResource);
517     Assert.assertEquals(expectedResponse, actualResponse);
518 
519     List<String> actualRequests = mockService.getRequestPaths();
520     Assert.assertEquals(1, actualRequests.size());
521 
522     String apiClientHeaderKey =
523         mockService
524             .getRequestHeaders()
525             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
526             .iterator()
527             .next();
528     Assert.assertTrue(
529         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
530             .matcher(apiClientHeaderKey)
531             .matches());
532   }
533 
534   @Test
testIamPermissionsExceptionTest()535   public void testIamPermissionsExceptionTest() throws Exception {
536     ApiException exception =
537         ApiExceptionFactory.createException(
538             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
539     mockService.addException(exception);
540 
541     try {
542       String project = "project-6911";
543       String region = "region-9622";
544       String resource = "resource-756";
545       TestPermissionsRequest testPermissionsRequestResource =
546           TestPermissionsRequest.newBuilder().build();
547       client.testIamPermissions(project, region, resource, testPermissionsRequestResource);
548       Assert.fail("No exception raised");
549     } catch (InvalidArgumentException e) {
550       // Expected exception.
551     }
552   }
553 }
554