• 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.InterconnectsClient.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.HttpJsonInterconnectsStub;
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 InterconnectsClientTest {
48   private static MockHttpService mockService;
49   private static InterconnectsClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonInterconnectsStub.getMethodDescriptors(),
56             InterconnectsSettings.getDefaultEndpoint());
57     InterconnectsSettings settings =
58         InterconnectsSettings.newBuilder()
59             .setTransportChannelProvider(
60                 InterconnectsSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = InterconnectsClient.create(settings);
66   }
67 
68   @AfterClass
stopServer()69   public static void stopServer() {
70     client.close();
71   }
72 
73   @Before
setUp()74   public void setUp() {}
75 
76   @After
tearDown()77   public void tearDown() throws Exception {
78     mockService.reset();
79   }
80 
81   @Test
deleteTest()82   public void deleteTest() throws Exception {
83     Operation expectedResponse =
84         Operation.newBuilder()
85             .setClientOperationId("clientOperationId-1230366697")
86             .setCreationTimestamp("creationTimestamp-370203401")
87             .setDescription("description-1724546052")
88             .setEndTime("endTime-1607243192")
89             .setError(Error.newBuilder().build())
90             .setHttpErrorMessage("httpErrorMessage1577303431")
91             .setHttpErrorStatusCode(0)
92             .setId(3355)
93             .setInsertTime("insertTime966165798")
94             .setKind("kind3292052")
95             .setName("name3373707")
96             .setOperationGroupId("operationGroupId1716161683")
97             .setOperationType("operationType91999553")
98             .setProgress(-1001078227)
99             .setRegion("region-934795532")
100             .setSelfLink("selfLink1191800166")
101             .setStartTime("startTime-2129294769")
102             .setStatus(Status.DONE)
103             .setStatusMessage("statusMessage-958704715")
104             .setTargetId(-815576439)
105             .setTargetLink("targetLink486368555")
106             .setUser("user3599307")
107             .addAllWarnings(new ArrayList<Warnings>())
108             .setZone("zone3744684")
109             .build();
110     mockService.addResponse(expectedResponse);
111 
112     String project = "project-6911";
113     String interconnect = "interconnect-4596";
114 
115     Operation actualResponse = client.deleteAsync(project, interconnect).get();
116     Assert.assertEquals(expectedResponse, actualResponse);
117 
118     List<String> actualRequests = mockService.getRequestPaths();
119     Assert.assertEquals(1, actualRequests.size());
120 
121     String apiClientHeaderKey =
122         mockService
123             .getRequestHeaders()
124             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
125             .iterator()
126             .next();
127     Assert.assertTrue(
128         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
129             .matcher(apiClientHeaderKey)
130             .matches());
131   }
132 
133   @Test
deleteExceptionTest()134   public void deleteExceptionTest() throws Exception {
135     ApiException exception =
136         ApiExceptionFactory.createException(
137             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
138     mockService.addException(exception);
139 
140     try {
141       String project = "project-6911";
142       String interconnect = "interconnect-4596";
143       client.deleteAsync(project, interconnect).get();
144       Assert.fail("No exception raised");
145     } catch (ExecutionException e) {
146     }
147   }
148 
149   @Test
getTest()150   public void getTest() throws Exception {
151     Interconnect expectedResponse =
152         Interconnect.newBuilder()
153             .setAdminEnabled(true)
154             .addAllCircuitInfos(new ArrayList<InterconnectCircuitInfo>())
155             .setCreationTimestamp("creationTimestamp-370203401")
156             .setCustomerName("customerName900157321")
157             .setDescription("description-1724546052")
158             .addAllExpectedOutages(new ArrayList<InterconnectOutageNotification>())
159             .setGoogleIpAddress("googleIpAddress-1542975852")
160             .setGoogleReferenceId("googleReferenceId600178125")
161             .setId(3355)
162             .addAllInterconnectAttachments(new ArrayList<String>())
163             .setInterconnectType("interconnectType1730818280")
164             .setKind("kind3292052")
165             .setLinkType("linkType1194206804")
166             .setLocation("location1901043637")
167             .setName("name3373707")
168             .setNocContactEmail("nocContactEmail480425790")
169             .setOperationalStatus("operationalStatus-2103166364")
170             .setPeerIpAddress("peerIpAddress-1037076085")
171             .setProvisionedLinkCount(-1199724171)
172             .setRequestedLinkCount(1118793211)
173             .setSatisfiesPzs(true)
174             .setSelfLink("selfLink1191800166")
175             .setState("state109757585")
176             .build();
177     mockService.addResponse(expectedResponse);
178 
179     String project = "project-6911";
180     String interconnect = "interconnect-4596";
181 
182     Interconnect actualResponse = client.get(project, interconnect);
183     Assert.assertEquals(expectedResponse, actualResponse);
184 
185     List<String> actualRequests = mockService.getRequestPaths();
186     Assert.assertEquals(1, actualRequests.size());
187 
188     String apiClientHeaderKey =
189         mockService
190             .getRequestHeaders()
191             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
192             .iterator()
193             .next();
194     Assert.assertTrue(
195         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
196             .matcher(apiClientHeaderKey)
197             .matches());
198   }
199 
200   @Test
getExceptionTest()201   public void getExceptionTest() throws Exception {
202     ApiException exception =
203         ApiExceptionFactory.createException(
204             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
205     mockService.addException(exception);
206 
207     try {
208       String project = "project-6911";
209       String interconnect = "interconnect-4596";
210       client.get(project, interconnect);
211       Assert.fail("No exception raised");
212     } catch (InvalidArgumentException e) {
213       // Expected exception.
214     }
215   }
216 
217   @Test
getDiagnosticsTest()218   public void getDiagnosticsTest() throws Exception {
219     InterconnectsGetDiagnosticsResponse expectedResponse =
220         InterconnectsGetDiagnosticsResponse.newBuilder()
221             .setResult(InterconnectDiagnostics.newBuilder().build())
222             .build();
223     mockService.addResponse(expectedResponse);
224 
225     String project = "project-6911";
226     String interconnect = "interconnect-4596";
227 
228     InterconnectsGetDiagnosticsResponse actualResponse =
229         client.getDiagnostics(project, interconnect);
230     Assert.assertEquals(expectedResponse, actualResponse);
231 
232     List<String> actualRequests = mockService.getRequestPaths();
233     Assert.assertEquals(1, actualRequests.size());
234 
235     String apiClientHeaderKey =
236         mockService
237             .getRequestHeaders()
238             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
239             .iterator()
240             .next();
241     Assert.assertTrue(
242         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
243             .matcher(apiClientHeaderKey)
244             .matches());
245   }
246 
247   @Test
getDiagnosticsExceptionTest()248   public void getDiagnosticsExceptionTest() throws Exception {
249     ApiException exception =
250         ApiExceptionFactory.createException(
251             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
252     mockService.addException(exception);
253 
254     try {
255       String project = "project-6911";
256       String interconnect = "interconnect-4596";
257       client.getDiagnostics(project, interconnect);
258       Assert.fail("No exception raised");
259     } catch (InvalidArgumentException e) {
260       // Expected exception.
261     }
262   }
263 
264   @Test
insertTest()265   public void insertTest() throws Exception {
266     Operation expectedResponse =
267         Operation.newBuilder()
268             .setClientOperationId("clientOperationId-1230366697")
269             .setCreationTimestamp("creationTimestamp-370203401")
270             .setDescription("description-1724546052")
271             .setEndTime("endTime-1607243192")
272             .setError(Error.newBuilder().build())
273             .setHttpErrorMessage("httpErrorMessage1577303431")
274             .setHttpErrorStatusCode(0)
275             .setId(3355)
276             .setInsertTime("insertTime966165798")
277             .setKind("kind3292052")
278             .setName("name3373707")
279             .setOperationGroupId("operationGroupId1716161683")
280             .setOperationType("operationType91999553")
281             .setProgress(-1001078227)
282             .setRegion("region-934795532")
283             .setSelfLink("selfLink1191800166")
284             .setStartTime("startTime-2129294769")
285             .setStatus(Status.DONE)
286             .setStatusMessage("statusMessage-958704715")
287             .setTargetId(-815576439)
288             .setTargetLink("targetLink486368555")
289             .setUser("user3599307")
290             .addAllWarnings(new ArrayList<Warnings>())
291             .setZone("zone3744684")
292             .build();
293     mockService.addResponse(expectedResponse);
294 
295     String project = "project-6911";
296     Interconnect interconnectResource = Interconnect.newBuilder().build();
297 
298     Operation actualResponse = client.insertAsync(project, interconnectResource).get();
299     Assert.assertEquals(expectedResponse, actualResponse);
300 
301     List<String> actualRequests = mockService.getRequestPaths();
302     Assert.assertEquals(1, actualRequests.size());
303 
304     String apiClientHeaderKey =
305         mockService
306             .getRequestHeaders()
307             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
308             .iterator()
309             .next();
310     Assert.assertTrue(
311         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
312             .matcher(apiClientHeaderKey)
313             .matches());
314   }
315 
316   @Test
insertExceptionTest()317   public void insertExceptionTest() throws Exception {
318     ApiException exception =
319         ApiExceptionFactory.createException(
320             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
321     mockService.addException(exception);
322 
323     try {
324       String project = "project-6911";
325       Interconnect interconnectResource = Interconnect.newBuilder().build();
326       client.insertAsync(project, interconnectResource).get();
327       Assert.fail("No exception raised");
328     } catch (ExecutionException e) {
329     }
330   }
331 
332   @Test
listTest()333   public void listTest() throws Exception {
334     Interconnect responsesElement = Interconnect.newBuilder().build();
335     InterconnectList expectedResponse =
336         InterconnectList.newBuilder()
337             .setNextPageToken("")
338             .addAllItems(Arrays.asList(responsesElement))
339             .build();
340     mockService.addResponse(expectedResponse);
341 
342     String project = "project-6911";
343 
344     ListPagedResponse pagedListResponse = client.list(project);
345 
346     List<Interconnect> resources = Lists.newArrayList(pagedListResponse.iterateAll());
347 
348     Assert.assertEquals(1, resources.size());
349     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
350 
351     List<String> actualRequests = mockService.getRequestPaths();
352     Assert.assertEquals(1, actualRequests.size());
353 
354     String apiClientHeaderKey =
355         mockService
356             .getRequestHeaders()
357             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
358             .iterator()
359             .next();
360     Assert.assertTrue(
361         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
362             .matcher(apiClientHeaderKey)
363             .matches());
364   }
365 
366   @Test
listExceptionTest()367   public void listExceptionTest() throws Exception {
368     ApiException exception =
369         ApiExceptionFactory.createException(
370             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
371     mockService.addException(exception);
372 
373     try {
374       String project = "project-6911";
375       client.list(project);
376       Assert.fail("No exception raised");
377     } catch (InvalidArgumentException e) {
378       // Expected exception.
379     }
380   }
381 
382   @Test
patchTest()383   public void patchTest() throws Exception {
384     Operation expectedResponse =
385         Operation.newBuilder()
386             .setClientOperationId("clientOperationId-1230366697")
387             .setCreationTimestamp("creationTimestamp-370203401")
388             .setDescription("description-1724546052")
389             .setEndTime("endTime-1607243192")
390             .setError(Error.newBuilder().build())
391             .setHttpErrorMessage("httpErrorMessage1577303431")
392             .setHttpErrorStatusCode(0)
393             .setId(3355)
394             .setInsertTime("insertTime966165798")
395             .setKind("kind3292052")
396             .setName("name3373707")
397             .setOperationGroupId("operationGroupId1716161683")
398             .setOperationType("operationType91999553")
399             .setProgress(-1001078227)
400             .setRegion("region-934795532")
401             .setSelfLink("selfLink1191800166")
402             .setStartTime("startTime-2129294769")
403             .setStatus(Status.DONE)
404             .setStatusMessage("statusMessage-958704715")
405             .setTargetId(-815576439)
406             .setTargetLink("targetLink486368555")
407             .setUser("user3599307")
408             .addAllWarnings(new ArrayList<Warnings>())
409             .setZone("zone3744684")
410             .build();
411     mockService.addResponse(expectedResponse);
412 
413     String project = "project-6911";
414     String interconnect = "interconnect-4596";
415     Interconnect interconnectResource = Interconnect.newBuilder().build();
416 
417     Operation actualResponse = client.patchAsync(project, interconnect, interconnectResource).get();
418     Assert.assertEquals(expectedResponse, actualResponse);
419 
420     List<String> actualRequests = mockService.getRequestPaths();
421     Assert.assertEquals(1, actualRequests.size());
422 
423     String apiClientHeaderKey =
424         mockService
425             .getRequestHeaders()
426             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
427             .iterator()
428             .next();
429     Assert.assertTrue(
430         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
431             .matcher(apiClientHeaderKey)
432             .matches());
433   }
434 
435   @Test
patchExceptionTest()436   public void patchExceptionTest() throws Exception {
437     ApiException exception =
438         ApiExceptionFactory.createException(
439             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
440     mockService.addException(exception);
441 
442     try {
443       String project = "project-6911";
444       String interconnect = "interconnect-4596";
445       Interconnect interconnectResource = Interconnect.newBuilder().build();
446       client.patchAsync(project, interconnect, interconnectResource).get();
447       Assert.fail("No exception raised");
448     } catch (ExecutionException e) {
449     }
450   }
451 
452   @Test
setLabelsTest()453   public void setLabelsTest() throws Exception {
454     Operation expectedResponse =
455         Operation.newBuilder()
456             .setClientOperationId("clientOperationId-1230366697")
457             .setCreationTimestamp("creationTimestamp-370203401")
458             .setDescription("description-1724546052")
459             .setEndTime("endTime-1607243192")
460             .setError(Error.newBuilder().build())
461             .setHttpErrorMessage("httpErrorMessage1577303431")
462             .setHttpErrorStatusCode(0)
463             .setId(3355)
464             .setInsertTime("insertTime966165798")
465             .setKind("kind3292052")
466             .setName("name3373707")
467             .setOperationGroupId("operationGroupId1716161683")
468             .setOperationType("operationType91999553")
469             .setProgress(-1001078227)
470             .setRegion("region-934795532")
471             .setSelfLink("selfLink1191800166")
472             .setStartTime("startTime-2129294769")
473             .setStatus(Status.DONE)
474             .setStatusMessage("statusMessage-958704715")
475             .setTargetId(-815576439)
476             .setTargetLink("targetLink486368555")
477             .setUser("user3599307")
478             .addAllWarnings(new ArrayList<Warnings>())
479             .setZone("zone3744684")
480             .build();
481     mockService.addResponse(expectedResponse);
482 
483     String project = "project-6911";
484     String resource = "resource-756";
485     GlobalSetLabelsRequest globalSetLabelsRequestResource =
486         GlobalSetLabelsRequest.newBuilder().build();
487 
488     Operation actualResponse =
489         client.setLabelsAsync(project, resource, globalSetLabelsRequestResource).get();
490     Assert.assertEquals(expectedResponse, actualResponse);
491 
492     List<String> actualRequests = mockService.getRequestPaths();
493     Assert.assertEquals(1, actualRequests.size());
494 
495     String apiClientHeaderKey =
496         mockService
497             .getRequestHeaders()
498             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
499             .iterator()
500             .next();
501     Assert.assertTrue(
502         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
503             .matcher(apiClientHeaderKey)
504             .matches());
505   }
506 
507   @Test
setLabelsExceptionTest()508   public void setLabelsExceptionTest() throws Exception {
509     ApiException exception =
510         ApiExceptionFactory.createException(
511             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
512     mockService.addException(exception);
513 
514     try {
515       String project = "project-6911";
516       String resource = "resource-756";
517       GlobalSetLabelsRequest globalSetLabelsRequestResource =
518           GlobalSetLabelsRequest.newBuilder().build();
519       client.setLabelsAsync(project, resource, globalSetLabelsRequestResource).get();
520       Assert.fail("No exception raised");
521     } catch (ExecutionException e) {
522     }
523   }
524 }
525