• 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.RegionCommitmentsClient.AggregatedListPagedResponse;
20 import static com.google.cloud.compute.v1.RegionCommitmentsClient.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.HttpJsonRegionCommitmentsStub;
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 RegionCommitmentsClientTest {
51   private static MockHttpService mockService;
52   private static RegionCommitmentsClient client;
53 
54   @BeforeClass
startStaticServer()55   public static void startStaticServer() throws IOException {
56     mockService =
57         new MockHttpService(
58             HttpJsonRegionCommitmentsStub.getMethodDescriptors(),
59             RegionCommitmentsSettings.getDefaultEndpoint());
60     RegionCommitmentsSettings settings =
61         RegionCommitmentsSettings.newBuilder()
62             .setTransportChannelProvider(
63                 RegionCommitmentsSettings.defaultHttpJsonTransportProviderBuilder()
64                     .setHttpTransport(mockService)
65                     .build())
66             .setCredentialsProvider(NoCredentialsProvider.create())
67             .build();
68     client = RegionCommitmentsClient.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     CommitmentsScopedList responsesElement = CommitmentsScopedList.newBuilder().build();
87     CommitmentAggregatedList expectedResponse =
88         CommitmentAggregatedList.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, CommitmentsScopedList>> 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
getTest()137   public void getTest() throws Exception {
138     Commitment expectedResponse =
139         Commitment.newBuilder()
140             .setAutoRenew(true)
141             .setCategory("category50511102")
142             .setCreationTimestamp("creationTimestamp-370203401")
143             .setDescription("description-1724546052")
144             .setEndTimestamp("endTimestamp-356088197")
145             .setId(3355)
146             .setKind("kind3292052")
147             .setLicenseResource(LicenseResourceCommitment.newBuilder().build())
148             .addAllMergeSourceCommitments(new ArrayList<String>())
149             .setName("name3373707")
150             .setPlan("plan3443497")
151             .setRegion("region-934795532")
152             .addAllReservations(new ArrayList<Reservation>())
153             .addAllResources(new ArrayList<ResourceCommitment>())
154             .setSelfLink("selfLink1191800166")
155             .setSplitSourceCommitment("splitSourceCommitment-455879478")
156             .setStartTimestamp("startTimestamp-299216172")
157             .setStatus("status-892481550")
158             .setStatusMessage("statusMessage-958704715")
159             .setType("type3575610")
160             .build();
161     mockService.addResponse(expectedResponse);
162 
163     String project = "project-6911";
164     String region = "region-9622";
165     String commitment = "commitment-6197";
166 
167     Commitment actualResponse = client.get(project, region, commitment);
168     Assert.assertEquals(expectedResponse, actualResponse);
169 
170     List<String> actualRequests = mockService.getRequestPaths();
171     Assert.assertEquals(1, actualRequests.size());
172 
173     String apiClientHeaderKey =
174         mockService
175             .getRequestHeaders()
176             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
177             .iterator()
178             .next();
179     Assert.assertTrue(
180         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
181             .matcher(apiClientHeaderKey)
182             .matches());
183   }
184 
185   @Test
getExceptionTest()186   public void getExceptionTest() throws Exception {
187     ApiException exception =
188         ApiExceptionFactory.createException(
189             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
190     mockService.addException(exception);
191 
192     try {
193       String project = "project-6911";
194       String region = "region-9622";
195       String commitment = "commitment-6197";
196       client.get(project, region, commitment);
197       Assert.fail("No exception raised");
198     } catch (InvalidArgumentException e) {
199       // Expected exception.
200     }
201   }
202 
203   @Test
insertTest()204   public void insertTest() throws Exception {
205     Operation expectedResponse =
206         Operation.newBuilder()
207             .setClientOperationId("clientOperationId-1230366697")
208             .setCreationTimestamp("creationTimestamp-370203401")
209             .setDescription("description-1724546052")
210             .setEndTime("endTime-1607243192")
211             .setError(Error.newBuilder().build())
212             .setHttpErrorMessage("httpErrorMessage1577303431")
213             .setHttpErrorStatusCode(0)
214             .setId(3355)
215             .setInsertTime("insertTime966165798")
216             .setKind("kind3292052")
217             .setName("name3373707")
218             .setOperationGroupId("operationGroupId1716161683")
219             .setOperationType("operationType91999553")
220             .setProgress(-1001078227)
221             .setRegion("region-934795532")
222             .setSelfLink("selfLink1191800166")
223             .setStartTime("startTime-2129294769")
224             .setStatus(Status.DONE)
225             .setStatusMessage("statusMessage-958704715")
226             .setTargetId(-815576439)
227             .setTargetLink("targetLink486368555")
228             .setUser("user3599307")
229             .addAllWarnings(new ArrayList<Warnings>())
230             .setZone("zone3744684")
231             .build();
232     mockService.addResponse(expectedResponse);
233 
234     String project = "project-6911";
235     String region = "region-9622";
236     Commitment commitmentResource = Commitment.newBuilder().build();
237 
238     Operation actualResponse = client.insertAsync(project, region, commitmentResource).get();
239     Assert.assertEquals(expectedResponse, actualResponse);
240 
241     List<String> actualRequests = mockService.getRequestPaths();
242     Assert.assertEquals(1, actualRequests.size());
243 
244     String apiClientHeaderKey =
245         mockService
246             .getRequestHeaders()
247             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
248             .iterator()
249             .next();
250     Assert.assertTrue(
251         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
252             .matcher(apiClientHeaderKey)
253             .matches());
254   }
255 
256   @Test
insertExceptionTest()257   public void insertExceptionTest() throws Exception {
258     ApiException exception =
259         ApiExceptionFactory.createException(
260             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
261     mockService.addException(exception);
262 
263     try {
264       String project = "project-6911";
265       String region = "region-9622";
266       Commitment commitmentResource = Commitment.newBuilder().build();
267       client.insertAsync(project, region, commitmentResource).get();
268       Assert.fail("No exception raised");
269     } catch (ExecutionException e) {
270     }
271   }
272 
273   @Test
listTest()274   public void listTest() throws Exception {
275     Commitment responsesElement = Commitment.newBuilder().build();
276     CommitmentList expectedResponse =
277         CommitmentList.newBuilder()
278             .setNextPageToken("")
279             .addAllItems(Arrays.asList(responsesElement))
280             .build();
281     mockService.addResponse(expectedResponse);
282 
283     String project = "project-6911";
284     String region = "region-9622";
285 
286     ListPagedResponse pagedListResponse = client.list(project, region);
287 
288     List<Commitment> resources = Lists.newArrayList(pagedListResponse.iterateAll());
289 
290     Assert.assertEquals(1, resources.size());
291     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
292 
293     List<String> actualRequests = mockService.getRequestPaths();
294     Assert.assertEquals(1, actualRequests.size());
295 
296     String apiClientHeaderKey =
297         mockService
298             .getRequestHeaders()
299             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
300             .iterator()
301             .next();
302     Assert.assertTrue(
303         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
304             .matcher(apiClientHeaderKey)
305             .matches());
306   }
307 
308   @Test
listExceptionTest()309   public void listExceptionTest() throws Exception {
310     ApiException exception =
311         ApiExceptionFactory.createException(
312             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
313     mockService.addException(exception);
314 
315     try {
316       String project = "project-6911";
317       String region = "region-9622";
318       client.list(project, region);
319       Assert.fail("No exception raised");
320     } catch (InvalidArgumentException e) {
321       // Expected exception.
322     }
323   }
324 
325   @Test
updateTest()326   public void updateTest() throws Exception {
327     Operation expectedResponse =
328         Operation.newBuilder()
329             .setClientOperationId("clientOperationId-1230366697")
330             .setCreationTimestamp("creationTimestamp-370203401")
331             .setDescription("description-1724546052")
332             .setEndTime("endTime-1607243192")
333             .setError(Error.newBuilder().build())
334             .setHttpErrorMessage("httpErrorMessage1577303431")
335             .setHttpErrorStatusCode(0)
336             .setId(3355)
337             .setInsertTime("insertTime966165798")
338             .setKind("kind3292052")
339             .setName("name3373707")
340             .setOperationGroupId("operationGroupId1716161683")
341             .setOperationType("operationType91999553")
342             .setProgress(-1001078227)
343             .setRegion("region-934795532")
344             .setSelfLink("selfLink1191800166")
345             .setStartTime("startTime-2129294769")
346             .setStatus(Status.DONE)
347             .setStatusMessage("statusMessage-958704715")
348             .setTargetId(-815576439)
349             .setTargetLink("targetLink486368555")
350             .setUser("user3599307")
351             .addAllWarnings(new ArrayList<Warnings>())
352             .setZone("zone3744684")
353             .build();
354     mockService.addResponse(expectedResponse);
355 
356     String project = "project-6911";
357     String region = "region-9622";
358     String commitment = "commitment-6197";
359     Commitment commitmentResource = Commitment.newBuilder().build();
360 
361     Operation actualResponse =
362         client.updateAsync(project, region, commitment, commitmentResource).get();
363     Assert.assertEquals(expectedResponse, actualResponse);
364 
365     List<String> actualRequests = mockService.getRequestPaths();
366     Assert.assertEquals(1, actualRequests.size());
367 
368     String apiClientHeaderKey =
369         mockService
370             .getRequestHeaders()
371             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
372             .iterator()
373             .next();
374     Assert.assertTrue(
375         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
376             .matcher(apiClientHeaderKey)
377             .matches());
378   }
379 
380   @Test
updateExceptionTest()381   public void updateExceptionTest() throws Exception {
382     ApiException exception =
383         ApiExceptionFactory.createException(
384             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
385     mockService.addException(exception);
386 
387     try {
388       String project = "project-6911";
389       String region = "region-9622";
390       String commitment = "commitment-6197";
391       Commitment commitmentResource = Commitment.newBuilder().build();
392       client.updateAsync(project, region, commitment, commitmentResource).get();
393       Assert.fail("No exception raised");
394     } catch (ExecutionException e) {
395     }
396   }
397 }
398