• 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.networkmanagement.v1beta1;
18 
19 import static com.google.cloud.networkmanagement.v1beta1.ReachabilityServiceClient.ListConnectivityTestsPagedResponse;
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.networkmanagement.v1beta1.stub.HttpJsonReachabilityServiceStub;
31 import com.google.common.collect.Lists;
32 import com.google.longrunning.Operation;
33 import com.google.protobuf.Any;
34 import com.google.protobuf.Empty;
35 import com.google.protobuf.FieldMask;
36 import com.google.protobuf.Timestamp;
37 import java.io.IOException;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.HashMap;
41 import java.util.List;
42 import java.util.concurrent.ExecutionException;
43 import javax.annotation.Generated;
44 import org.junit.After;
45 import org.junit.AfterClass;
46 import org.junit.Assert;
47 import org.junit.Before;
48 import org.junit.BeforeClass;
49 import org.junit.Test;
50 
51 @Generated("by gapic-generator-java")
52 public class ReachabilityServiceClientHttpJsonTest {
53   private static MockHttpService mockService;
54   private static ReachabilityServiceClient client;
55 
56   @BeforeClass
startStaticServer()57   public static void startStaticServer() throws IOException {
58     mockService =
59         new MockHttpService(
60             HttpJsonReachabilityServiceStub.getMethodDescriptors(),
61             ReachabilityServiceSettings.getDefaultEndpoint());
62     ReachabilityServiceSettings settings =
63         ReachabilityServiceSettings.newHttpJsonBuilder()
64             .setTransportChannelProvider(
65                 ReachabilityServiceSettings.defaultHttpJsonTransportProviderBuilder()
66                     .setHttpTransport(mockService)
67                     .build())
68             .setCredentialsProvider(NoCredentialsProvider.create())
69             .build();
70     client = ReachabilityServiceClient.create(settings);
71   }
72 
73   @AfterClass
stopServer()74   public static void stopServer() {
75     client.close();
76   }
77 
78   @Before
setUp()79   public void setUp() {}
80 
81   @After
tearDown()82   public void tearDown() throws Exception {
83     mockService.reset();
84   }
85 
86   @Test
listConnectivityTestsTest()87   public void listConnectivityTestsTest() throws Exception {
88     ConnectivityTest responsesElement = ConnectivityTest.newBuilder().build();
89     ListConnectivityTestsResponse expectedResponse =
90         ListConnectivityTestsResponse.newBuilder()
91             .setNextPageToken("")
92             .addAllResources(Arrays.asList(responsesElement))
93             .build();
94     mockService.addResponse(expectedResponse);
95 
96     ListConnectivityTestsRequest request =
97         ListConnectivityTestsRequest.newBuilder()
98             .setParent("projects/project-6156/locations/global")
99             .setPageSize(883849137)
100             .setPageToken("pageToken873572522")
101             .setFilter("filter-1274492040")
102             .setOrderBy("orderBy-1207110587")
103             .build();
104 
105     ListConnectivityTestsPagedResponse pagedListResponse = client.listConnectivityTests(request);
106 
107     List<ConnectivityTest> resources = Lists.newArrayList(pagedListResponse.iterateAll());
108 
109     Assert.assertEquals(1, resources.size());
110     Assert.assertEquals(expectedResponse.getResourcesList().get(0), resources.get(0));
111 
112     List<String> actualRequests = mockService.getRequestPaths();
113     Assert.assertEquals(1, actualRequests.size());
114 
115     String apiClientHeaderKey =
116         mockService
117             .getRequestHeaders()
118             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
119             .iterator()
120             .next();
121     Assert.assertTrue(
122         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
123             .matcher(apiClientHeaderKey)
124             .matches());
125   }
126 
127   @Test
listConnectivityTestsExceptionTest()128   public void listConnectivityTestsExceptionTest() throws Exception {
129     ApiException exception =
130         ApiExceptionFactory.createException(
131             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
132     mockService.addException(exception);
133 
134     try {
135       ListConnectivityTestsRequest request =
136           ListConnectivityTestsRequest.newBuilder()
137               .setParent("projects/project-6156/locations/global")
138               .setPageSize(883849137)
139               .setPageToken("pageToken873572522")
140               .setFilter("filter-1274492040")
141               .setOrderBy("orderBy-1207110587")
142               .build();
143       client.listConnectivityTests(request);
144       Assert.fail("No exception raised");
145     } catch (InvalidArgumentException e) {
146       // Expected exception.
147     }
148   }
149 
150   @Test
getConnectivityTestTest()151   public void getConnectivityTestTest() throws Exception {
152     ConnectivityTest expectedResponse =
153         ConnectivityTest.newBuilder()
154             .setName("name3373707")
155             .setDescription("description-1724546052")
156             .setSource(Endpoint.newBuilder().build())
157             .setDestination(Endpoint.newBuilder().build())
158             .setProtocol("protocol-989163880")
159             .addAllRelatedProjects(new ArrayList<String>())
160             .setDisplayName("displayName1714148973")
161             .putAllLabels(new HashMap<String, String>())
162             .setCreateTime(Timestamp.newBuilder().build())
163             .setUpdateTime(Timestamp.newBuilder().build())
164             .setReachabilityDetails(ReachabilityDetails.newBuilder().build())
165             .setProbingDetails(ProbingDetails.newBuilder().build())
166             .build();
167     mockService.addResponse(expectedResponse);
168 
169     GetConnectivityTestRequest request =
170         GetConnectivityTestRequest.newBuilder()
171             .setName(
172                 "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
173             .build();
174 
175     ConnectivityTest actualResponse = client.getConnectivityTest(request);
176     Assert.assertEquals(expectedResponse, actualResponse);
177 
178     List<String> actualRequests = mockService.getRequestPaths();
179     Assert.assertEquals(1, actualRequests.size());
180 
181     String apiClientHeaderKey =
182         mockService
183             .getRequestHeaders()
184             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
185             .iterator()
186             .next();
187     Assert.assertTrue(
188         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
189             .matcher(apiClientHeaderKey)
190             .matches());
191   }
192 
193   @Test
getConnectivityTestExceptionTest()194   public void getConnectivityTestExceptionTest() throws Exception {
195     ApiException exception =
196         ApiExceptionFactory.createException(
197             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
198     mockService.addException(exception);
199 
200     try {
201       GetConnectivityTestRequest request =
202           GetConnectivityTestRequest.newBuilder()
203               .setName(
204                   "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
205               .build();
206       client.getConnectivityTest(request);
207       Assert.fail("No exception raised");
208     } catch (InvalidArgumentException e) {
209       // Expected exception.
210     }
211   }
212 
213   @Test
createConnectivityTestTest()214   public void createConnectivityTestTest() throws Exception {
215     ConnectivityTest expectedResponse =
216         ConnectivityTest.newBuilder()
217             .setName("name3373707")
218             .setDescription("description-1724546052")
219             .setSource(Endpoint.newBuilder().build())
220             .setDestination(Endpoint.newBuilder().build())
221             .setProtocol("protocol-989163880")
222             .addAllRelatedProjects(new ArrayList<String>())
223             .setDisplayName("displayName1714148973")
224             .putAllLabels(new HashMap<String, String>())
225             .setCreateTime(Timestamp.newBuilder().build())
226             .setUpdateTime(Timestamp.newBuilder().build())
227             .setReachabilityDetails(ReachabilityDetails.newBuilder().build())
228             .setProbingDetails(ProbingDetails.newBuilder().build())
229             .build();
230     Operation resultOperation =
231         Operation.newBuilder()
232             .setName("createConnectivityTestTest")
233             .setDone(true)
234             .setResponse(Any.pack(expectedResponse))
235             .build();
236     mockService.addResponse(resultOperation);
237 
238     CreateConnectivityTestRequest request =
239         CreateConnectivityTestRequest.newBuilder()
240             .setParent("projects/project-6156/locations/global")
241             .setTestId("testId-877170355")
242             .setResource(ConnectivityTest.newBuilder().build())
243             .build();
244 
245     ConnectivityTest actualResponse = client.createConnectivityTestAsync(request).get();
246     Assert.assertEquals(expectedResponse, actualResponse);
247 
248     List<String> actualRequests = mockService.getRequestPaths();
249     Assert.assertEquals(1, actualRequests.size());
250 
251     String apiClientHeaderKey =
252         mockService
253             .getRequestHeaders()
254             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
255             .iterator()
256             .next();
257     Assert.assertTrue(
258         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
259             .matcher(apiClientHeaderKey)
260             .matches());
261   }
262 
263   @Test
createConnectivityTestExceptionTest()264   public void createConnectivityTestExceptionTest() throws Exception {
265     ApiException exception =
266         ApiExceptionFactory.createException(
267             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
268     mockService.addException(exception);
269 
270     try {
271       CreateConnectivityTestRequest request =
272           CreateConnectivityTestRequest.newBuilder()
273               .setParent("projects/project-6156/locations/global")
274               .setTestId("testId-877170355")
275               .setResource(ConnectivityTest.newBuilder().build())
276               .build();
277       client.createConnectivityTestAsync(request).get();
278       Assert.fail("No exception raised");
279     } catch (ExecutionException e) {
280     }
281   }
282 
283   @Test
updateConnectivityTestTest()284   public void updateConnectivityTestTest() throws Exception {
285     ConnectivityTest expectedResponse =
286         ConnectivityTest.newBuilder()
287             .setName("name3373707")
288             .setDescription("description-1724546052")
289             .setSource(Endpoint.newBuilder().build())
290             .setDestination(Endpoint.newBuilder().build())
291             .setProtocol("protocol-989163880")
292             .addAllRelatedProjects(new ArrayList<String>())
293             .setDisplayName("displayName1714148973")
294             .putAllLabels(new HashMap<String, String>())
295             .setCreateTime(Timestamp.newBuilder().build())
296             .setUpdateTime(Timestamp.newBuilder().build())
297             .setReachabilityDetails(ReachabilityDetails.newBuilder().build())
298             .setProbingDetails(ProbingDetails.newBuilder().build())
299             .build();
300     Operation resultOperation =
301         Operation.newBuilder()
302             .setName("updateConnectivityTestTest")
303             .setDone(true)
304             .setResponse(Any.pack(expectedResponse))
305             .build();
306     mockService.addResponse(resultOperation);
307 
308     UpdateConnectivityTestRequest request =
309         UpdateConnectivityTestRequest.newBuilder()
310             .setUpdateMask(FieldMask.newBuilder().build())
311             .setResource(
312                 ConnectivityTest.newBuilder()
313                     .setName(
314                         "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
315                     .setDescription("description-1724546052")
316                     .setSource(Endpoint.newBuilder().build())
317                     .setDestination(Endpoint.newBuilder().build())
318                     .setProtocol("protocol-989163880")
319                     .addAllRelatedProjects(new ArrayList<String>())
320                     .setDisplayName("displayName1714148973")
321                     .putAllLabels(new HashMap<String, String>())
322                     .setCreateTime(Timestamp.newBuilder().build())
323                     .setUpdateTime(Timestamp.newBuilder().build())
324                     .setReachabilityDetails(ReachabilityDetails.newBuilder().build())
325                     .setProbingDetails(ProbingDetails.newBuilder().build())
326                     .build())
327             .build();
328 
329     ConnectivityTest actualResponse = client.updateConnectivityTestAsync(request).get();
330     Assert.assertEquals(expectedResponse, actualResponse);
331 
332     List<String> actualRequests = mockService.getRequestPaths();
333     Assert.assertEquals(1, actualRequests.size());
334 
335     String apiClientHeaderKey =
336         mockService
337             .getRequestHeaders()
338             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
339             .iterator()
340             .next();
341     Assert.assertTrue(
342         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
343             .matcher(apiClientHeaderKey)
344             .matches());
345   }
346 
347   @Test
updateConnectivityTestExceptionTest()348   public void updateConnectivityTestExceptionTest() throws Exception {
349     ApiException exception =
350         ApiExceptionFactory.createException(
351             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
352     mockService.addException(exception);
353 
354     try {
355       UpdateConnectivityTestRequest request =
356           UpdateConnectivityTestRequest.newBuilder()
357               .setUpdateMask(FieldMask.newBuilder().build())
358               .setResource(
359                   ConnectivityTest.newBuilder()
360                       .setName(
361                           "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
362                       .setDescription("description-1724546052")
363                       .setSource(Endpoint.newBuilder().build())
364                       .setDestination(Endpoint.newBuilder().build())
365                       .setProtocol("protocol-989163880")
366                       .addAllRelatedProjects(new ArrayList<String>())
367                       .setDisplayName("displayName1714148973")
368                       .putAllLabels(new HashMap<String, String>())
369                       .setCreateTime(Timestamp.newBuilder().build())
370                       .setUpdateTime(Timestamp.newBuilder().build())
371                       .setReachabilityDetails(ReachabilityDetails.newBuilder().build())
372                       .setProbingDetails(ProbingDetails.newBuilder().build())
373                       .build())
374               .build();
375       client.updateConnectivityTestAsync(request).get();
376       Assert.fail("No exception raised");
377     } catch (ExecutionException e) {
378     }
379   }
380 
381   @Test
rerunConnectivityTestTest()382   public void rerunConnectivityTestTest() throws Exception {
383     ConnectivityTest expectedResponse =
384         ConnectivityTest.newBuilder()
385             .setName("name3373707")
386             .setDescription("description-1724546052")
387             .setSource(Endpoint.newBuilder().build())
388             .setDestination(Endpoint.newBuilder().build())
389             .setProtocol("protocol-989163880")
390             .addAllRelatedProjects(new ArrayList<String>())
391             .setDisplayName("displayName1714148973")
392             .putAllLabels(new HashMap<String, String>())
393             .setCreateTime(Timestamp.newBuilder().build())
394             .setUpdateTime(Timestamp.newBuilder().build())
395             .setReachabilityDetails(ReachabilityDetails.newBuilder().build())
396             .setProbingDetails(ProbingDetails.newBuilder().build())
397             .build();
398     Operation resultOperation =
399         Operation.newBuilder()
400             .setName("rerunConnectivityTestTest")
401             .setDone(true)
402             .setResponse(Any.pack(expectedResponse))
403             .build();
404     mockService.addResponse(resultOperation);
405 
406     RerunConnectivityTestRequest request =
407         RerunConnectivityTestRequest.newBuilder()
408             .setName(
409                 "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
410             .build();
411 
412     ConnectivityTest actualResponse = client.rerunConnectivityTestAsync(request).get();
413     Assert.assertEquals(expectedResponse, actualResponse);
414 
415     List<String> actualRequests = mockService.getRequestPaths();
416     Assert.assertEquals(1, actualRequests.size());
417 
418     String apiClientHeaderKey =
419         mockService
420             .getRequestHeaders()
421             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
422             .iterator()
423             .next();
424     Assert.assertTrue(
425         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
426             .matcher(apiClientHeaderKey)
427             .matches());
428   }
429 
430   @Test
rerunConnectivityTestExceptionTest()431   public void rerunConnectivityTestExceptionTest() throws Exception {
432     ApiException exception =
433         ApiExceptionFactory.createException(
434             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
435     mockService.addException(exception);
436 
437     try {
438       RerunConnectivityTestRequest request =
439           RerunConnectivityTestRequest.newBuilder()
440               .setName(
441                   "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
442               .build();
443       client.rerunConnectivityTestAsync(request).get();
444       Assert.fail("No exception raised");
445     } catch (ExecutionException e) {
446     }
447   }
448 
449   @Test
deleteConnectivityTestTest()450   public void deleteConnectivityTestTest() throws Exception {
451     Empty expectedResponse = Empty.newBuilder().build();
452     Operation resultOperation =
453         Operation.newBuilder()
454             .setName("deleteConnectivityTestTest")
455             .setDone(true)
456             .setResponse(Any.pack(expectedResponse))
457             .build();
458     mockService.addResponse(resultOperation);
459 
460     DeleteConnectivityTestRequest request =
461         DeleteConnectivityTestRequest.newBuilder()
462             .setName(
463                 "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
464             .build();
465 
466     client.deleteConnectivityTestAsync(request).get();
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
deleteConnectivityTestExceptionTest()484   public void deleteConnectivityTestExceptionTest() 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       DeleteConnectivityTestRequest request =
492           DeleteConnectivityTestRequest.newBuilder()
493               .setName(
494                   "projects/project-4569/locations/global/connectivityTests/connectivityTest-4569")
495               .build();
496       client.deleteConnectivityTestAsync(request).get();
497       Assert.fail("No exception raised");
498     } catch (ExecutionException e) {
499     }
500   }
501 }
502