• 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.TargetGrpcProxiesClient.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.HttpJsonTargetGrpcProxiesStub;
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 TargetGrpcProxiesClientTest {
48   private static MockHttpService mockService;
49   private static TargetGrpcProxiesClient client;
50 
51   @BeforeClass
startStaticServer()52   public static void startStaticServer() throws IOException {
53     mockService =
54         new MockHttpService(
55             HttpJsonTargetGrpcProxiesStub.getMethodDescriptors(),
56             TargetGrpcProxiesSettings.getDefaultEndpoint());
57     TargetGrpcProxiesSettings settings =
58         TargetGrpcProxiesSettings.newBuilder()
59             .setTransportChannelProvider(
60                 TargetGrpcProxiesSettings.defaultHttpJsonTransportProviderBuilder()
61                     .setHttpTransport(mockService)
62                     .build())
63             .setCredentialsProvider(NoCredentialsProvider.create())
64             .build();
65     client = TargetGrpcProxiesClient.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 targetGrpcProxy = "targetGrpcProxy-2485";
114 
115     Operation actualResponse = client.deleteAsync(project, targetGrpcProxy).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 targetGrpcProxy = "targetGrpcProxy-2485";
143       client.deleteAsync(project, targetGrpcProxy).get();
144       Assert.fail("No exception raised");
145     } catch (ExecutionException e) {
146     }
147   }
148 
149   @Test
getTest()150   public void getTest() throws Exception {
151     TargetGrpcProxy expectedResponse =
152         TargetGrpcProxy.newBuilder()
153             .setCreationTimestamp("creationTimestamp-370203401")
154             .setDescription("description-1724546052")
155             .setFingerprint("fingerprint-1375934236")
156             .setId(3355)
157             .setKind("kind3292052")
158             .setName("name3373707")
159             .setSelfLink("selfLink1191800166")
160             .setSelfLinkWithId("selfLinkWithId-776809081")
161             .setUrlMap("urlMap-836780691")
162             .setValidateForProxyless(true)
163             .build();
164     mockService.addResponse(expectedResponse);
165 
166     String project = "project-6911";
167     String targetGrpcProxy = "targetGrpcProxy-2485";
168 
169     TargetGrpcProxy actualResponse = client.get(project, targetGrpcProxy);
170     Assert.assertEquals(expectedResponse, actualResponse);
171 
172     List<String> actualRequests = mockService.getRequestPaths();
173     Assert.assertEquals(1, actualRequests.size());
174 
175     String apiClientHeaderKey =
176         mockService
177             .getRequestHeaders()
178             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
179             .iterator()
180             .next();
181     Assert.assertTrue(
182         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
183             .matcher(apiClientHeaderKey)
184             .matches());
185   }
186 
187   @Test
getExceptionTest()188   public void getExceptionTest() throws Exception {
189     ApiException exception =
190         ApiExceptionFactory.createException(
191             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
192     mockService.addException(exception);
193 
194     try {
195       String project = "project-6911";
196       String targetGrpcProxy = "targetGrpcProxy-2485";
197       client.get(project, targetGrpcProxy);
198       Assert.fail("No exception raised");
199     } catch (InvalidArgumentException e) {
200       // Expected exception.
201     }
202   }
203 
204   @Test
insertTest()205   public void insertTest() throws Exception {
206     Operation expectedResponse =
207         Operation.newBuilder()
208             .setClientOperationId("clientOperationId-1230366697")
209             .setCreationTimestamp("creationTimestamp-370203401")
210             .setDescription("description-1724546052")
211             .setEndTime("endTime-1607243192")
212             .setError(Error.newBuilder().build())
213             .setHttpErrorMessage("httpErrorMessage1577303431")
214             .setHttpErrorStatusCode(0)
215             .setId(3355)
216             .setInsertTime("insertTime966165798")
217             .setKind("kind3292052")
218             .setName("name3373707")
219             .setOperationGroupId("operationGroupId1716161683")
220             .setOperationType("operationType91999553")
221             .setProgress(-1001078227)
222             .setRegion("region-934795532")
223             .setSelfLink("selfLink1191800166")
224             .setStartTime("startTime-2129294769")
225             .setStatus(Status.DONE)
226             .setStatusMessage("statusMessage-958704715")
227             .setTargetId(-815576439)
228             .setTargetLink("targetLink486368555")
229             .setUser("user3599307")
230             .addAllWarnings(new ArrayList<Warnings>())
231             .setZone("zone3744684")
232             .build();
233     mockService.addResponse(expectedResponse);
234 
235     String project = "project-6911";
236     TargetGrpcProxy targetGrpcProxyResource = TargetGrpcProxy.newBuilder().build();
237 
238     Operation actualResponse = client.insertAsync(project, targetGrpcProxyResource).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       TargetGrpcProxy targetGrpcProxyResource = TargetGrpcProxy.newBuilder().build();
266       client.insertAsync(project, targetGrpcProxyResource).get();
267       Assert.fail("No exception raised");
268     } catch (ExecutionException e) {
269     }
270   }
271 
272   @Test
listTest()273   public void listTest() throws Exception {
274     TargetGrpcProxy responsesElement = TargetGrpcProxy.newBuilder().build();
275     TargetGrpcProxyList expectedResponse =
276         TargetGrpcProxyList.newBuilder()
277             .setNextPageToken("")
278             .addAllItems(Arrays.asList(responsesElement))
279             .build();
280     mockService.addResponse(expectedResponse);
281 
282     String project = "project-6911";
283 
284     ListPagedResponse pagedListResponse = client.list(project);
285 
286     List<TargetGrpcProxy> resources = Lists.newArrayList(pagedListResponse.iterateAll());
287 
288     Assert.assertEquals(1, resources.size());
289     Assert.assertEquals(expectedResponse.getItemsList().get(0), resources.get(0));
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
listExceptionTest()307   public void listExceptionTest() 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       client.list(project);
316       Assert.fail("No exception raised");
317     } catch (InvalidArgumentException e) {
318       // Expected exception.
319     }
320   }
321 
322   @Test
patchTest()323   public void patchTest() throws Exception {
324     Operation expectedResponse =
325         Operation.newBuilder()
326             .setClientOperationId("clientOperationId-1230366697")
327             .setCreationTimestamp("creationTimestamp-370203401")
328             .setDescription("description-1724546052")
329             .setEndTime("endTime-1607243192")
330             .setError(Error.newBuilder().build())
331             .setHttpErrorMessage("httpErrorMessage1577303431")
332             .setHttpErrorStatusCode(0)
333             .setId(3355)
334             .setInsertTime("insertTime966165798")
335             .setKind("kind3292052")
336             .setName("name3373707")
337             .setOperationGroupId("operationGroupId1716161683")
338             .setOperationType("operationType91999553")
339             .setProgress(-1001078227)
340             .setRegion("region-934795532")
341             .setSelfLink("selfLink1191800166")
342             .setStartTime("startTime-2129294769")
343             .setStatus(Status.DONE)
344             .setStatusMessage("statusMessage-958704715")
345             .setTargetId(-815576439)
346             .setTargetLink("targetLink486368555")
347             .setUser("user3599307")
348             .addAllWarnings(new ArrayList<Warnings>())
349             .setZone("zone3744684")
350             .build();
351     mockService.addResponse(expectedResponse);
352 
353     String project = "project-6911";
354     String targetGrpcProxy = "targetGrpcProxy-2485";
355     TargetGrpcProxy targetGrpcProxyResource = TargetGrpcProxy.newBuilder().build();
356 
357     Operation actualResponse =
358         client.patchAsync(project, targetGrpcProxy, targetGrpcProxyResource).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
patchExceptionTest()377   public void patchExceptionTest() 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 targetGrpcProxy = "targetGrpcProxy-2485";
386       TargetGrpcProxy targetGrpcProxyResource = TargetGrpcProxy.newBuilder().build();
387       client.patchAsync(project, targetGrpcProxy, targetGrpcProxyResource).get();
388       Assert.fail("No exception raised");
389     } catch (ExecutionException e) {
390     }
391   }
392 }
393