• 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.LicensesClient.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.HttpJsonLicensesStub;
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.List;
37 import java.util.concurrent.ExecutionException;
38 import javax.annotation.Generated;
39 import org.junit.After;
40 import org.junit.AfterClass;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.BeforeClass;
44 import org.junit.Test;
45 
46 @Generated("by gapic-generator-java")
47 public class LicensesClientTest {
48   private static MockHttpService mockService;
49   private static LicensesClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonLicensesStub.getMethodDescriptors(), LicensesSettings.getDefaultEndpoint());
56     LicensesSettings settings =
57         LicensesSettings.newBuilder()
58             .setTransportChannelProvider(
59                 LicensesSettings.defaultHttpJsonTransportProviderBuilder()
60                     .setHttpTransport(mockService)
61                     .build())
62             .setCredentialsProvider(NoCredentialsProvider.create())
63             .build();
64     client = LicensesClient.create(settings);
65   }
66 
67   @AfterClass
stopServer()68   public static void stopServer() {
69     client.close();
70   }
71 
72   @Before
setUp()73   public void setUp() {}
74 
75   @After
tearDown()76   public void tearDown() throws Exception {
77     mockService.reset();
78   }
79 
80   @Test
deleteTest()81   public void deleteTest() throws Exception {
82     Operation expectedResponse =
83         Operation.newBuilder()
84             .setClientOperationId("clientOperationId-1230366697")
85             .setCreationTimestamp("creationTimestamp-370203401")
86             .setDescription("description-1724546052")
87             .setEndTime("endTime-1607243192")
88             .setError(Error.newBuilder().build())
89             .setHttpErrorMessage("httpErrorMessage1577303431")
90             .setHttpErrorStatusCode(0)
91             .setId(3355)
92             .setInsertTime("insertTime966165798")
93             .setKind("kind3292052")
94             .setName("name3373707")
95             .setOperationGroupId("operationGroupId1716161683")
96             .setOperationType("operationType91999553")
97             .setProgress(-1001078227)
98             .setRegion("region-934795532")
99             .setSelfLink("selfLink1191800166")
100             .setStartTime("startTime-2129294769")
101             .setStatus(Status.DONE)
102             .setStatusMessage("statusMessage-958704715")
103             .setTargetId(-815576439)
104             .setTargetLink("targetLink486368555")
105             .setUser("user3599307")
106             .addAllWarnings(new ArrayList<Warnings>())
107             .setZone("zone3744684")
108             .build();
109     mockService.addResponse(expectedResponse);
110 
111     String project = "project-6911";
112     String license = "license-3417";
113 
114     Operation actualResponse = client.deleteAsync(project, license).get();
115     Assert.assertEquals(expectedResponse, actualResponse);
116 
117     List<String> actualRequests = mockService.getRequestPaths();
118     Assert.assertEquals(1, actualRequests.size());
119 
120     String apiClientHeaderKey =
121         mockService
122             .getRequestHeaders()
123             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
124             .iterator()
125             .next();
126     Assert.assertTrue(
127         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
128             .matcher(apiClientHeaderKey)
129             .matches());
130   }
131 
132   @Test
deleteExceptionTest()133   public void deleteExceptionTest() throws Exception {
134     ApiException exception =
135         ApiExceptionFactory.createException(
136             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
137     mockService.addException(exception);
138 
139     try {
140       String project = "project-6911";
141       String license = "license-3417";
142       client.deleteAsync(project, license).get();
143       Assert.fail("No exception raised");
144     } catch (ExecutionException e) {
145     }
146   }
147 
148   @Test
getTest()149   public void getTest() throws Exception {
150     License expectedResponse =
151         License.newBuilder()
152             .setChargesUseFee(true)
153             .setCreationTimestamp("creationTimestamp-370203401")
154             .setDescription("description-1724546052")
155             .setId(3355)
156             .setKind("kind3292052")
157             .setLicenseCode(1612079915)
158             .setName("name3373707")
159             .setResourceRequirements(LicenseResourceRequirements.newBuilder().build())
160             .setSelfLink("selfLink1191800166")
161             .setTransferable(true)
162             .build();
163     mockService.addResponse(expectedResponse);
164 
165     String project = "project-6911";
166     String license = "license-3417";
167 
168     License actualResponse = client.get(project, license);
169     Assert.assertEquals(expectedResponse, actualResponse);
170 
171     List<String> actualRequests = mockService.getRequestPaths();
172     Assert.assertEquals(1, actualRequests.size());
173 
174     String apiClientHeaderKey =
175         mockService
176             .getRequestHeaders()
177             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
178             .iterator()
179             .next();
180     Assert.assertTrue(
181         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
182             .matcher(apiClientHeaderKey)
183             .matches());
184   }
185 
186   @Test
getExceptionTest()187   public void getExceptionTest() throws Exception {
188     ApiException exception =
189         ApiExceptionFactory.createException(
190             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
191     mockService.addException(exception);
192 
193     try {
194       String project = "project-6911";
195       String license = "license-3417";
196       client.get(project, license);
197       Assert.fail("No exception raised");
198     } catch (InvalidArgumentException e) {
199       // Expected exception.
200     }
201   }
202 
203   @Test
getIamPolicyTest()204   public void getIamPolicyTest() throws Exception {
205     Policy expectedResponse =
206         Policy.newBuilder()
207             .addAllAuditConfigs(new ArrayList<AuditConfig>())
208             .addAllBindings(new ArrayList<Binding>())
209             .setEtag("etag3123477")
210             .setIamOwned(true)
211             .addAllRules(new ArrayList<Rule>())
212             .setVersion(351608024)
213             .build();
214     mockService.addResponse(expectedResponse);
215 
216     String project = "project-6911";
217     String resource = "resource-756";
218 
219     Policy actualResponse = client.getIamPolicy(project, resource);
220     Assert.assertEquals(expectedResponse, actualResponse);
221 
222     List<String> actualRequests = mockService.getRequestPaths();
223     Assert.assertEquals(1, actualRequests.size());
224 
225     String apiClientHeaderKey =
226         mockService
227             .getRequestHeaders()
228             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
229             .iterator()
230             .next();
231     Assert.assertTrue(
232         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
233             .matcher(apiClientHeaderKey)
234             .matches());
235   }
236 
237   @Test
getIamPolicyExceptionTest()238   public void getIamPolicyExceptionTest() throws Exception {
239     ApiException exception =
240         ApiExceptionFactory.createException(
241             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
242     mockService.addException(exception);
243 
244     try {
245       String project = "project-6911";
246       String resource = "resource-756";
247       client.getIamPolicy(project, resource);
248       Assert.fail("No exception raised");
249     } catch (InvalidArgumentException e) {
250       // Expected exception.
251     }
252   }
253 
254   @Test
insertTest()255   public void insertTest() throws Exception {
256     Operation expectedResponse =
257         Operation.newBuilder()
258             .setClientOperationId("clientOperationId-1230366697")
259             .setCreationTimestamp("creationTimestamp-370203401")
260             .setDescription("description-1724546052")
261             .setEndTime("endTime-1607243192")
262             .setError(Error.newBuilder().build())
263             .setHttpErrorMessage("httpErrorMessage1577303431")
264             .setHttpErrorStatusCode(0)
265             .setId(3355)
266             .setInsertTime("insertTime966165798")
267             .setKind("kind3292052")
268             .setName("name3373707")
269             .setOperationGroupId("operationGroupId1716161683")
270             .setOperationType("operationType91999553")
271             .setProgress(-1001078227)
272             .setRegion("region-934795532")
273             .setSelfLink("selfLink1191800166")
274             .setStartTime("startTime-2129294769")
275             .setStatus(Status.DONE)
276             .setStatusMessage("statusMessage-958704715")
277             .setTargetId(-815576439)
278             .setTargetLink("targetLink486368555")
279             .setUser("user3599307")
280             .addAllWarnings(new ArrayList<Warnings>())
281             .setZone("zone3744684")
282             .build();
283     mockService.addResponse(expectedResponse);
284 
285     String project = "project-6911";
286     License licenseResource = License.newBuilder().build();
287 
288     Operation actualResponse = client.insertAsync(project, licenseResource).get();
289     Assert.assertEquals(expectedResponse, actualResponse);
290 
291     List<String> actualRequests = mockService.getRequestPaths();
292     Assert.assertEquals(1, actualRequests.size());
293 
294     String apiClientHeaderKey =
295         mockService
296             .getRequestHeaders()
297             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
298             .iterator()
299             .next();
300     Assert.assertTrue(
301         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
302             .matcher(apiClientHeaderKey)
303             .matches());
304   }
305 
306   @Test
insertExceptionTest()307   public void insertExceptionTest() throws Exception {
308     ApiException exception =
309         ApiExceptionFactory.createException(
310             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
311     mockService.addException(exception);
312 
313     try {
314       String project = "project-6911";
315       License licenseResource = License.newBuilder().build();
316       client.insertAsync(project, licenseResource).get();
317       Assert.fail("No exception raised");
318     } catch (ExecutionException e) {
319     }
320   }
321 
322   @Test
listTest()323   public void listTest() throws Exception {
324     License responsesElement = License.newBuilder().build();
325     LicensesListResponse expectedResponse =
326         LicensesListResponse.newBuilder()
327             .setNextPageToken("")
328             .addAllItems(Arrays.asList(responsesElement))
329             .build();
330     mockService.addResponse(expectedResponse);
331 
332     String project = "project-6911";
333 
334     ListPagedResponse pagedListResponse = client.list(project);
335 
336     List<License> resources = Lists.newArrayList(pagedListResponse.iterateAll());
337 
338     Assert.assertEquals(1, resources.size());
339     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
340 
341     List<String> actualRequests = mockService.getRequestPaths();
342     Assert.assertEquals(1, actualRequests.size());
343 
344     String apiClientHeaderKey =
345         mockService
346             .getRequestHeaders()
347             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
348             .iterator()
349             .next();
350     Assert.assertTrue(
351         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
352             .matcher(apiClientHeaderKey)
353             .matches());
354   }
355 
356   @Test
listExceptionTest()357   public void listExceptionTest() throws Exception {
358     ApiException exception =
359         ApiExceptionFactory.createException(
360             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
361     mockService.addException(exception);
362 
363     try {
364       String project = "project-6911";
365       client.list(project);
366       Assert.fail("No exception raised");
367     } catch (InvalidArgumentException e) {
368       // Expected exception.
369     }
370   }
371 
372   @Test
setIamPolicyTest()373   public void setIamPolicyTest() throws Exception {
374     Policy expectedResponse =
375         Policy.newBuilder()
376             .addAllAuditConfigs(new ArrayList<AuditConfig>())
377             .addAllBindings(new ArrayList<Binding>())
378             .setEtag("etag3123477")
379             .setIamOwned(true)
380             .addAllRules(new ArrayList<Rule>())
381             .setVersion(351608024)
382             .build();
383     mockService.addResponse(expectedResponse);
384 
385     String project = "project-6911";
386     String resource = "resource-756";
387     GlobalSetPolicyRequest globalSetPolicyRequestResource =
388         GlobalSetPolicyRequest.newBuilder().build();
389 
390     Policy actualResponse = client.setIamPolicy(project, resource, globalSetPolicyRequestResource);
391     Assert.assertEquals(expectedResponse, actualResponse);
392 
393     List<String> actualRequests = mockService.getRequestPaths();
394     Assert.assertEquals(1, actualRequests.size());
395 
396     String apiClientHeaderKey =
397         mockService
398             .getRequestHeaders()
399             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
400             .iterator()
401             .next();
402     Assert.assertTrue(
403         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
404             .matcher(apiClientHeaderKey)
405             .matches());
406   }
407 
408   @Test
setIamPolicyExceptionTest()409   public void setIamPolicyExceptionTest() throws Exception {
410     ApiException exception =
411         ApiExceptionFactory.createException(
412             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
413     mockService.addException(exception);
414 
415     try {
416       String project = "project-6911";
417       String resource = "resource-756";
418       GlobalSetPolicyRequest globalSetPolicyRequestResource =
419           GlobalSetPolicyRequest.newBuilder().build();
420       client.setIamPolicy(project, resource, globalSetPolicyRequestResource);
421       Assert.fail("No exception raised");
422     } catch (InvalidArgumentException e) {
423       // Expected exception.
424     }
425   }
426 
427   @Test
testIamPermissionsTest()428   public void testIamPermissionsTest() throws Exception {
429     TestPermissionsResponse expectedResponse =
430         TestPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
431     mockService.addResponse(expectedResponse);
432 
433     String project = "project-6911";
434     String resource = "resource-756";
435     TestPermissionsRequest testPermissionsRequestResource =
436         TestPermissionsRequest.newBuilder().build();
437 
438     TestPermissionsResponse actualResponse =
439         client.testIamPermissions(project, resource, testPermissionsRequestResource);
440     Assert.assertEquals(expectedResponse, actualResponse);
441 
442     List<String> actualRequests = mockService.getRequestPaths();
443     Assert.assertEquals(1, actualRequests.size());
444 
445     String apiClientHeaderKey =
446         mockService
447             .getRequestHeaders()
448             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
449             .iterator()
450             .next();
451     Assert.assertTrue(
452         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
453             .matcher(apiClientHeaderKey)
454             .matches());
455   }
456 
457   @Test
testIamPermissionsExceptionTest()458   public void testIamPermissionsExceptionTest() throws Exception {
459     ApiException exception =
460         ApiExceptionFactory.createException(
461             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
462     mockService.addException(exception);
463 
464     try {
465       String project = "project-6911";
466       String resource = "resource-756";
467       TestPermissionsRequest testPermissionsRequestResource =
468           TestPermissionsRequest.newBuilder().build();
469       client.testIamPermissions(project, resource, testPermissionsRequestResource);
470       Assert.fail("No exception raised");
471     } catch (InvalidArgumentException e) {
472       // Expected exception.
473     }
474   }
475 }
476