• 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.functions.v1;
18 
19 import static com.google.cloud.functions.v1.CloudFunctionsServiceClient.ListFunctionsPagedResponse;
20 import static com.google.cloud.functions.v1.CloudFunctionsServiceClient.ListLocationsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.cloud.location.ListLocationsRequest;
31 import com.google.cloud.location.ListLocationsResponse;
32 import com.google.cloud.location.Location;
33 import com.google.common.collect.Lists;
34 import com.google.iam.v1.AuditConfig;
35 import com.google.iam.v1.Binding;
36 import com.google.iam.v1.GetIamPolicyRequest;
37 import com.google.iam.v1.GetPolicyOptions;
38 import com.google.iam.v1.Policy;
39 import com.google.iam.v1.SetIamPolicyRequest;
40 import com.google.iam.v1.TestIamPermissionsRequest;
41 import com.google.iam.v1.TestIamPermissionsResponse;
42 import com.google.longrunning.Operation;
43 import com.google.protobuf.AbstractMessage;
44 import com.google.protobuf.Any;
45 import com.google.protobuf.ByteString;
46 import com.google.protobuf.Duration;
47 import com.google.protobuf.Empty;
48 import com.google.protobuf.FieldMask;
49 import com.google.protobuf.Timestamp;
50 import io.grpc.StatusRuntimeException;
51 import java.io.IOException;
52 import java.util.ArrayList;
53 import java.util.Arrays;
54 import java.util.HashMap;
55 import java.util.List;
56 import java.util.UUID;
57 import java.util.concurrent.ExecutionException;
58 import javax.annotation.Generated;
59 import org.junit.After;
60 import org.junit.AfterClass;
61 import org.junit.Assert;
62 import org.junit.Before;
63 import org.junit.BeforeClass;
64 import org.junit.Test;
65 
66 @Generated("by gapic-generator-java")
67 public class CloudFunctionsServiceClientTest {
68   private static MockCloudFunctionsService mockCloudFunctionsService;
69   private static MockIAMPolicy mockIAMPolicy;
70   private static MockLocations mockLocations;
71   private static MockServiceHelper mockServiceHelper;
72   private LocalChannelProvider channelProvider;
73   private CloudFunctionsServiceClient client;
74 
75   @BeforeClass
startStaticServer()76   public static void startStaticServer() {
77     mockCloudFunctionsService = new MockCloudFunctionsService();
78     mockLocations = new MockLocations();
79     mockIAMPolicy = new MockIAMPolicy();
80     mockServiceHelper =
81         new MockServiceHelper(
82             UUID.randomUUID().toString(),
83             Arrays.<MockGrpcService>asList(
84                 mockCloudFunctionsService, mockLocations, mockIAMPolicy));
85     mockServiceHelper.start();
86   }
87 
88   @AfterClass
stopServer()89   public static void stopServer() {
90     mockServiceHelper.stop();
91   }
92 
93   @Before
setUp()94   public void setUp() throws IOException {
95     mockServiceHelper.reset();
96     channelProvider = mockServiceHelper.createChannelProvider();
97     CloudFunctionsServiceSettings settings =
98         CloudFunctionsServiceSettings.newBuilder()
99             .setTransportChannelProvider(channelProvider)
100             .setCredentialsProvider(NoCredentialsProvider.create())
101             .build();
102     client = CloudFunctionsServiceClient.create(settings);
103   }
104 
105   @After
tearDown()106   public void tearDown() throws Exception {
107     client.close();
108   }
109 
110   @Test
listFunctionsTest()111   public void listFunctionsTest() throws Exception {
112     CloudFunction responsesElement = CloudFunction.newBuilder().build();
113     ListFunctionsResponse expectedResponse =
114         ListFunctionsResponse.newBuilder()
115             .setNextPageToken("")
116             .addAllFunctions(Arrays.asList(responsesElement))
117             .build();
118     mockCloudFunctionsService.addResponse(expectedResponse);
119 
120     ListFunctionsRequest request =
121         ListFunctionsRequest.newBuilder()
122             .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
123             .setPageSize(883849137)
124             .setPageToken("pageToken873572522")
125             .build();
126 
127     ListFunctionsPagedResponse pagedListResponse = client.listFunctions(request);
128 
129     List<CloudFunction> resources = Lists.newArrayList(pagedListResponse.iterateAll());
130 
131     Assert.assertEquals(1, resources.size());
132     Assert.assertEquals(expectedResponse.getFunctionsList().get(0), resources.get(0));
133 
134     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
135     Assert.assertEquals(1, actualRequests.size());
136     ListFunctionsRequest actualRequest = ((ListFunctionsRequest) actualRequests.get(0));
137 
138     Assert.assertEquals(request.getParent(), actualRequest.getParent());
139     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
140     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
141     Assert.assertTrue(
142         channelProvider.isHeaderSent(
143             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
144             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
145   }
146 
147   @Test
listFunctionsExceptionTest()148   public void listFunctionsExceptionTest() throws Exception {
149     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
150     mockCloudFunctionsService.addException(exception);
151 
152     try {
153       ListFunctionsRequest request =
154           ListFunctionsRequest.newBuilder()
155               .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
156               .setPageSize(883849137)
157               .setPageToken("pageToken873572522")
158               .build();
159       client.listFunctions(request);
160       Assert.fail("No exception raised");
161     } catch (InvalidArgumentException e) {
162       // Expected exception.
163     }
164   }
165 
166   @Test
getFunctionTest()167   public void getFunctionTest() throws Exception {
168     CloudFunction expectedResponse =
169         CloudFunction.newBuilder()
170             .setName(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
171             .setDescription("description-1724546052")
172             .setStatus(CloudFunctionStatus.forNumber(0))
173             .setEntryPoint("entryPoint-1979329474")
174             .setRuntime("runtime1550962648")
175             .setTimeout(Duration.newBuilder().build())
176             .setAvailableMemoryMb(1964533661)
177             .setServiceAccountEmail("serviceAccountEmail1825953988")
178             .setUpdateTime(Timestamp.newBuilder().build())
179             .setVersionId(-670497310)
180             .putAllLabels(new HashMap<String, String>())
181             .putAllEnvironmentVariables(new HashMap<String, String>())
182             .putAllBuildEnvironmentVariables(new HashMap<String, String>())
183             .setNetwork("network1843485230")
184             .setMaxInstances(-330682013)
185             .setMinInstances(1491624145)
186             .setVpcConnector("vpcConnector2101559652")
187             .setKmsKeyName(
188                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
189                     .toString())
190             .setBuildWorkerPool("buildWorkerPool1011442120")
191             .setBuildId("buildId230943785")
192             .setBuildName("buildName-1401172455")
193             .addAllSecretEnvironmentVariables(new ArrayList<SecretEnvVar>())
194             .addAllSecretVolumes(new ArrayList<SecretVolume>())
195             .setSourceToken("sourceToken-94946658")
196             .setDockerRepository("dockerRepository1588395402")
197             .build();
198     mockCloudFunctionsService.addResponse(expectedResponse);
199 
200     CloudFunctionName name = CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
201 
202     CloudFunction actualResponse = client.getFunction(name);
203     Assert.assertEquals(expectedResponse, actualResponse);
204 
205     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
206     Assert.assertEquals(1, actualRequests.size());
207     GetFunctionRequest actualRequest = ((GetFunctionRequest) actualRequests.get(0));
208 
209     Assert.assertEquals(name.toString(), actualRequest.getName());
210     Assert.assertTrue(
211         channelProvider.isHeaderSent(
212             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
213             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
214   }
215 
216   @Test
getFunctionExceptionTest()217   public void getFunctionExceptionTest() throws Exception {
218     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
219     mockCloudFunctionsService.addException(exception);
220 
221     try {
222       CloudFunctionName name = CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
223       client.getFunction(name);
224       Assert.fail("No exception raised");
225     } catch (InvalidArgumentException e) {
226       // Expected exception.
227     }
228   }
229 
230   @Test
getFunctionTest2()231   public void getFunctionTest2() throws Exception {
232     CloudFunction expectedResponse =
233         CloudFunction.newBuilder()
234             .setName(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
235             .setDescription("description-1724546052")
236             .setStatus(CloudFunctionStatus.forNumber(0))
237             .setEntryPoint("entryPoint-1979329474")
238             .setRuntime("runtime1550962648")
239             .setTimeout(Duration.newBuilder().build())
240             .setAvailableMemoryMb(1964533661)
241             .setServiceAccountEmail("serviceAccountEmail1825953988")
242             .setUpdateTime(Timestamp.newBuilder().build())
243             .setVersionId(-670497310)
244             .putAllLabels(new HashMap<String, String>())
245             .putAllEnvironmentVariables(new HashMap<String, String>())
246             .putAllBuildEnvironmentVariables(new HashMap<String, String>())
247             .setNetwork("network1843485230")
248             .setMaxInstances(-330682013)
249             .setMinInstances(1491624145)
250             .setVpcConnector("vpcConnector2101559652")
251             .setKmsKeyName(
252                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
253                     .toString())
254             .setBuildWorkerPool("buildWorkerPool1011442120")
255             .setBuildId("buildId230943785")
256             .setBuildName("buildName-1401172455")
257             .addAllSecretEnvironmentVariables(new ArrayList<SecretEnvVar>())
258             .addAllSecretVolumes(new ArrayList<SecretVolume>())
259             .setSourceToken("sourceToken-94946658")
260             .setDockerRepository("dockerRepository1588395402")
261             .build();
262     mockCloudFunctionsService.addResponse(expectedResponse);
263 
264     String name = "name3373707";
265 
266     CloudFunction actualResponse = client.getFunction(name);
267     Assert.assertEquals(expectedResponse, actualResponse);
268 
269     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
270     Assert.assertEquals(1, actualRequests.size());
271     GetFunctionRequest actualRequest = ((GetFunctionRequest) actualRequests.get(0));
272 
273     Assert.assertEquals(name, actualRequest.getName());
274     Assert.assertTrue(
275         channelProvider.isHeaderSent(
276             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
277             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
278   }
279 
280   @Test
getFunctionExceptionTest2()281   public void getFunctionExceptionTest2() throws Exception {
282     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
283     mockCloudFunctionsService.addException(exception);
284 
285     try {
286       String name = "name3373707";
287       client.getFunction(name);
288       Assert.fail("No exception raised");
289     } catch (InvalidArgumentException e) {
290       // Expected exception.
291     }
292   }
293 
294   @Test
createFunctionTest()295   public void createFunctionTest() throws Exception {
296     CloudFunction expectedResponse =
297         CloudFunction.newBuilder()
298             .setName(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
299             .setDescription("description-1724546052")
300             .setStatus(CloudFunctionStatus.forNumber(0))
301             .setEntryPoint("entryPoint-1979329474")
302             .setRuntime("runtime1550962648")
303             .setTimeout(Duration.newBuilder().build())
304             .setAvailableMemoryMb(1964533661)
305             .setServiceAccountEmail("serviceAccountEmail1825953988")
306             .setUpdateTime(Timestamp.newBuilder().build())
307             .setVersionId(-670497310)
308             .putAllLabels(new HashMap<String, String>())
309             .putAllEnvironmentVariables(new HashMap<String, String>())
310             .putAllBuildEnvironmentVariables(new HashMap<String, String>())
311             .setNetwork("network1843485230")
312             .setMaxInstances(-330682013)
313             .setMinInstances(1491624145)
314             .setVpcConnector("vpcConnector2101559652")
315             .setKmsKeyName(
316                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
317                     .toString())
318             .setBuildWorkerPool("buildWorkerPool1011442120")
319             .setBuildId("buildId230943785")
320             .setBuildName("buildName-1401172455")
321             .addAllSecretEnvironmentVariables(new ArrayList<SecretEnvVar>())
322             .addAllSecretVolumes(new ArrayList<SecretVolume>())
323             .setSourceToken("sourceToken-94946658")
324             .setDockerRepository("dockerRepository1588395402")
325             .build();
326     Operation resultOperation =
327         Operation.newBuilder()
328             .setName("createFunctionTest")
329             .setDone(true)
330             .setResponse(Any.pack(expectedResponse))
331             .build();
332     mockCloudFunctionsService.addResponse(resultOperation);
333 
334     LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
335     CloudFunction function = CloudFunction.newBuilder().build();
336 
337     CloudFunction actualResponse = client.createFunctionAsync(location, function).get();
338     Assert.assertEquals(expectedResponse, actualResponse);
339 
340     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
341     Assert.assertEquals(1, actualRequests.size());
342     CreateFunctionRequest actualRequest = ((CreateFunctionRequest) actualRequests.get(0));
343 
344     Assert.assertEquals(location.toString(), actualRequest.getLocation());
345     Assert.assertEquals(function, actualRequest.getFunction());
346     Assert.assertTrue(
347         channelProvider.isHeaderSent(
348             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
349             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
350   }
351 
352   @Test
createFunctionExceptionTest()353   public void createFunctionExceptionTest() throws Exception {
354     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
355     mockCloudFunctionsService.addException(exception);
356 
357     try {
358       LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
359       CloudFunction function = CloudFunction.newBuilder().build();
360       client.createFunctionAsync(location, function).get();
361       Assert.fail("No exception raised");
362     } catch (ExecutionException e) {
363       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
364       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
365       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
366     }
367   }
368 
369   @Test
createFunctionTest2()370   public void createFunctionTest2() throws Exception {
371     CloudFunction expectedResponse =
372         CloudFunction.newBuilder()
373             .setName(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
374             .setDescription("description-1724546052")
375             .setStatus(CloudFunctionStatus.forNumber(0))
376             .setEntryPoint("entryPoint-1979329474")
377             .setRuntime("runtime1550962648")
378             .setTimeout(Duration.newBuilder().build())
379             .setAvailableMemoryMb(1964533661)
380             .setServiceAccountEmail("serviceAccountEmail1825953988")
381             .setUpdateTime(Timestamp.newBuilder().build())
382             .setVersionId(-670497310)
383             .putAllLabels(new HashMap<String, String>())
384             .putAllEnvironmentVariables(new HashMap<String, String>())
385             .putAllBuildEnvironmentVariables(new HashMap<String, String>())
386             .setNetwork("network1843485230")
387             .setMaxInstances(-330682013)
388             .setMinInstances(1491624145)
389             .setVpcConnector("vpcConnector2101559652")
390             .setKmsKeyName(
391                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
392                     .toString())
393             .setBuildWorkerPool("buildWorkerPool1011442120")
394             .setBuildId("buildId230943785")
395             .setBuildName("buildName-1401172455")
396             .addAllSecretEnvironmentVariables(new ArrayList<SecretEnvVar>())
397             .addAllSecretVolumes(new ArrayList<SecretVolume>())
398             .setSourceToken("sourceToken-94946658")
399             .setDockerRepository("dockerRepository1588395402")
400             .build();
401     Operation resultOperation =
402         Operation.newBuilder()
403             .setName("createFunctionTest")
404             .setDone(true)
405             .setResponse(Any.pack(expectedResponse))
406             .build();
407     mockCloudFunctionsService.addResponse(resultOperation);
408 
409     String location = "location1901043637";
410     CloudFunction function = CloudFunction.newBuilder().build();
411 
412     CloudFunction actualResponse = client.createFunctionAsync(location, function).get();
413     Assert.assertEquals(expectedResponse, actualResponse);
414 
415     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
416     Assert.assertEquals(1, actualRequests.size());
417     CreateFunctionRequest actualRequest = ((CreateFunctionRequest) actualRequests.get(0));
418 
419     Assert.assertEquals(location, actualRequest.getLocation());
420     Assert.assertEquals(function, actualRequest.getFunction());
421     Assert.assertTrue(
422         channelProvider.isHeaderSent(
423             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
424             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
425   }
426 
427   @Test
createFunctionExceptionTest2()428   public void createFunctionExceptionTest2() throws Exception {
429     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
430     mockCloudFunctionsService.addException(exception);
431 
432     try {
433       String location = "location1901043637";
434       CloudFunction function = CloudFunction.newBuilder().build();
435       client.createFunctionAsync(location, function).get();
436       Assert.fail("No exception raised");
437     } catch (ExecutionException e) {
438       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
439       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
440       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
441     }
442   }
443 
444   @Test
updateFunctionTest()445   public void updateFunctionTest() throws Exception {
446     CloudFunction expectedResponse =
447         CloudFunction.newBuilder()
448             .setName(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
449             .setDescription("description-1724546052")
450             .setStatus(CloudFunctionStatus.forNumber(0))
451             .setEntryPoint("entryPoint-1979329474")
452             .setRuntime("runtime1550962648")
453             .setTimeout(Duration.newBuilder().build())
454             .setAvailableMemoryMb(1964533661)
455             .setServiceAccountEmail("serviceAccountEmail1825953988")
456             .setUpdateTime(Timestamp.newBuilder().build())
457             .setVersionId(-670497310)
458             .putAllLabels(new HashMap<String, String>())
459             .putAllEnvironmentVariables(new HashMap<String, String>())
460             .putAllBuildEnvironmentVariables(new HashMap<String, String>())
461             .setNetwork("network1843485230")
462             .setMaxInstances(-330682013)
463             .setMinInstances(1491624145)
464             .setVpcConnector("vpcConnector2101559652")
465             .setKmsKeyName(
466                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
467                     .toString())
468             .setBuildWorkerPool("buildWorkerPool1011442120")
469             .setBuildId("buildId230943785")
470             .setBuildName("buildName-1401172455")
471             .addAllSecretEnvironmentVariables(new ArrayList<SecretEnvVar>())
472             .addAllSecretVolumes(new ArrayList<SecretVolume>())
473             .setSourceToken("sourceToken-94946658")
474             .setDockerRepository("dockerRepository1588395402")
475             .build();
476     Operation resultOperation =
477         Operation.newBuilder()
478             .setName("updateFunctionTest")
479             .setDone(true)
480             .setResponse(Any.pack(expectedResponse))
481             .build();
482     mockCloudFunctionsService.addResponse(resultOperation);
483 
484     CloudFunction function = CloudFunction.newBuilder().build();
485 
486     CloudFunction actualResponse = client.updateFunctionAsync(function).get();
487     Assert.assertEquals(expectedResponse, actualResponse);
488 
489     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
490     Assert.assertEquals(1, actualRequests.size());
491     UpdateFunctionRequest actualRequest = ((UpdateFunctionRequest) actualRequests.get(0));
492 
493     Assert.assertEquals(function, actualRequest.getFunction());
494     Assert.assertTrue(
495         channelProvider.isHeaderSent(
496             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
497             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
498   }
499 
500   @Test
updateFunctionExceptionTest()501   public void updateFunctionExceptionTest() throws Exception {
502     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
503     mockCloudFunctionsService.addException(exception);
504 
505     try {
506       CloudFunction function = CloudFunction.newBuilder().build();
507       client.updateFunctionAsync(function).get();
508       Assert.fail("No exception raised");
509     } catch (ExecutionException e) {
510       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
511       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
512       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
513     }
514   }
515 
516   @Test
deleteFunctionTest()517   public void deleteFunctionTest() throws Exception {
518     Empty expectedResponse = Empty.newBuilder().build();
519     Operation resultOperation =
520         Operation.newBuilder()
521             .setName("deleteFunctionTest")
522             .setDone(true)
523             .setResponse(Any.pack(expectedResponse))
524             .build();
525     mockCloudFunctionsService.addResponse(resultOperation);
526 
527     CloudFunctionName name = CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
528 
529     client.deleteFunctionAsync(name).get();
530 
531     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
532     Assert.assertEquals(1, actualRequests.size());
533     DeleteFunctionRequest actualRequest = ((DeleteFunctionRequest) actualRequests.get(0));
534 
535     Assert.assertEquals(name.toString(), actualRequest.getName());
536     Assert.assertTrue(
537         channelProvider.isHeaderSent(
538             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
539             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
540   }
541 
542   @Test
deleteFunctionExceptionTest()543   public void deleteFunctionExceptionTest() throws Exception {
544     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
545     mockCloudFunctionsService.addException(exception);
546 
547     try {
548       CloudFunctionName name = CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
549       client.deleteFunctionAsync(name).get();
550       Assert.fail("No exception raised");
551     } catch (ExecutionException e) {
552       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
553       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
554       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
555     }
556   }
557 
558   @Test
deleteFunctionTest2()559   public void deleteFunctionTest2() throws Exception {
560     Empty expectedResponse = Empty.newBuilder().build();
561     Operation resultOperation =
562         Operation.newBuilder()
563             .setName("deleteFunctionTest")
564             .setDone(true)
565             .setResponse(Any.pack(expectedResponse))
566             .build();
567     mockCloudFunctionsService.addResponse(resultOperation);
568 
569     String name = "name3373707";
570 
571     client.deleteFunctionAsync(name).get();
572 
573     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
574     Assert.assertEquals(1, actualRequests.size());
575     DeleteFunctionRequest actualRequest = ((DeleteFunctionRequest) actualRequests.get(0));
576 
577     Assert.assertEquals(name, actualRequest.getName());
578     Assert.assertTrue(
579         channelProvider.isHeaderSent(
580             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
581             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
582   }
583 
584   @Test
deleteFunctionExceptionTest2()585   public void deleteFunctionExceptionTest2() throws Exception {
586     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
587     mockCloudFunctionsService.addException(exception);
588 
589     try {
590       String name = "name3373707";
591       client.deleteFunctionAsync(name).get();
592       Assert.fail("No exception raised");
593     } catch (ExecutionException e) {
594       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
595       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
596       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
597     }
598   }
599 
600   @Test
callFunctionTest()601   public void callFunctionTest() throws Exception {
602     CallFunctionResponse expectedResponse =
603         CallFunctionResponse.newBuilder()
604             .setExecutionId("executionId-454906285")
605             .setResult("result-934426595")
606             .setError("error96784904")
607             .build();
608     mockCloudFunctionsService.addResponse(expectedResponse);
609 
610     CloudFunctionName name = CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
611     String data = "data3076010";
612 
613     CallFunctionResponse actualResponse = client.callFunction(name, data);
614     Assert.assertEquals(expectedResponse, actualResponse);
615 
616     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
617     Assert.assertEquals(1, actualRequests.size());
618     CallFunctionRequest actualRequest = ((CallFunctionRequest) actualRequests.get(0));
619 
620     Assert.assertEquals(name.toString(), actualRequest.getName());
621     Assert.assertEquals(data, actualRequest.getData());
622     Assert.assertTrue(
623         channelProvider.isHeaderSent(
624             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
625             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
626   }
627 
628   @Test
callFunctionExceptionTest()629   public void callFunctionExceptionTest() throws Exception {
630     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
631     mockCloudFunctionsService.addException(exception);
632 
633     try {
634       CloudFunctionName name = CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
635       String data = "data3076010";
636       client.callFunction(name, data);
637       Assert.fail("No exception raised");
638     } catch (InvalidArgumentException e) {
639       // Expected exception.
640     }
641   }
642 
643   @Test
callFunctionTest2()644   public void callFunctionTest2() throws Exception {
645     CallFunctionResponse expectedResponse =
646         CallFunctionResponse.newBuilder()
647             .setExecutionId("executionId-454906285")
648             .setResult("result-934426595")
649             .setError("error96784904")
650             .build();
651     mockCloudFunctionsService.addResponse(expectedResponse);
652 
653     String name = "name3373707";
654     String data = "data3076010";
655 
656     CallFunctionResponse actualResponse = client.callFunction(name, data);
657     Assert.assertEquals(expectedResponse, actualResponse);
658 
659     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
660     Assert.assertEquals(1, actualRequests.size());
661     CallFunctionRequest actualRequest = ((CallFunctionRequest) actualRequests.get(0));
662 
663     Assert.assertEquals(name, actualRequest.getName());
664     Assert.assertEquals(data, actualRequest.getData());
665     Assert.assertTrue(
666         channelProvider.isHeaderSent(
667             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
668             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
669   }
670 
671   @Test
callFunctionExceptionTest2()672   public void callFunctionExceptionTest2() throws Exception {
673     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
674     mockCloudFunctionsService.addException(exception);
675 
676     try {
677       String name = "name3373707";
678       String data = "data3076010";
679       client.callFunction(name, data);
680       Assert.fail("No exception raised");
681     } catch (InvalidArgumentException e) {
682       // Expected exception.
683     }
684   }
685 
686   @Test
generateUploadUrlTest()687   public void generateUploadUrlTest() throws Exception {
688     GenerateUploadUrlResponse expectedResponse =
689         GenerateUploadUrlResponse.newBuilder().setUploadUrl("uploadUrl1239085998").build();
690     mockCloudFunctionsService.addResponse(expectedResponse);
691 
692     GenerateUploadUrlRequest request =
693         GenerateUploadUrlRequest.newBuilder()
694             .setParent("parent-995424086")
695             .setKmsKeyName(
696                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
697                     .toString())
698             .build();
699 
700     GenerateUploadUrlResponse actualResponse = client.generateUploadUrl(request);
701     Assert.assertEquals(expectedResponse, actualResponse);
702 
703     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
704     Assert.assertEquals(1, actualRequests.size());
705     GenerateUploadUrlRequest actualRequest = ((GenerateUploadUrlRequest) actualRequests.get(0));
706 
707     Assert.assertEquals(request.getParent(), actualRequest.getParent());
708     Assert.assertEquals(request.getKmsKeyName(), actualRequest.getKmsKeyName());
709     Assert.assertTrue(
710         channelProvider.isHeaderSent(
711             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
712             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
713   }
714 
715   @Test
generateUploadUrlExceptionTest()716   public void generateUploadUrlExceptionTest() throws Exception {
717     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
718     mockCloudFunctionsService.addException(exception);
719 
720     try {
721       GenerateUploadUrlRequest request =
722           GenerateUploadUrlRequest.newBuilder()
723               .setParent("parent-995424086")
724               .setKmsKeyName(
725                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
726                       .toString())
727               .build();
728       client.generateUploadUrl(request);
729       Assert.fail("No exception raised");
730     } catch (InvalidArgumentException e) {
731       // Expected exception.
732     }
733   }
734 
735   @Test
generateDownloadUrlTest()736   public void generateDownloadUrlTest() throws Exception {
737     GenerateDownloadUrlResponse expectedResponse =
738         GenerateDownloadUrlResponse.newBuilder().setDownloadUrl("downloadUrl-1211148345").build();
739     mockCloudFunctionsService.addResponse(expectedResponse);
740 
741     GenerateDownloadUrlRequest request =
742         GenerateDownloadUrlRequest.newBuilder()
743             .setName("name3373707")
744             .setVersionId(-670497310)
745             .build();
746 
747     GenerateDownloadUrlResponse actualResponse = client.generateDownloadUrl(request);
748     Assert.assertEquals(expectedResponse, actualResponse);
749 
750     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
751     Assert.assertEquals(1, actualRequests.size());
752     GenerateDownloadUrlRequest actualRequest = ((GenerateDownloadUrlRequest) actualRequests.get(0));
753 
754     Assert.assertEquals(request.getName(), actualRequest.getName());
755     Assert.assertEquals(request.getVersionId(), actualRequest.getVersionId());
756     Assert.assertTrue(
757         channelProvider.isHeaderSent(
758             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
759             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
760   }
761 
762   @Test
generateDownloadUrlExceptionTest()763   public void generateDownloadUrlExceptionTest() throws Exception {
764     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
765     mockCloudFunctionsService.addException(exception);
766 
767     try {
768       GenerateDownloadUrlRequest request =
769           GenerateDownloadUrlRequest.newBuilder()
770               .setName("name3373707")
771               .setVersionId(-670497310)
772               .build();
773       client.generateDownloadUrl(request);
774       Assert.fail("No exception raised");
775     } catch (InvalidArgumentException e) {
776       // Expected exception.
777     }
778   }
779 
780   @Test
setIamPolicyTest()781   public void setIamPolicyTest() throws Exception {
782     Policy expectedResponse =
783         Policy.newBuilder()
784             .setVersion(351608024)
785             .addAllBindings(new ArrayList<Binding>())
786             .addAllAuditConfigs(new ArrayList<AuditConfig>())
787             .setEtag(ByteString.EMPTY)
788             .build();
789     mockCloudFunctionsService.addResponse(expectedResponse);
790 
791     SetIamPolicyRequest request =
792         SetIamPolicyRequest.newBuilder()
793             .setResource(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
794             .setPolicy(Policy.newBuilder().build())
795             .setUpdateMask(FieldMask.newBuilder().build())
796             .build();
797 
798     Policy actualResponse = client.setIamPolicy(request);
799     Assert.assertEquals(expectedResponse, actualResponse);
800 
801     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
802     Assert.assertEquals(1, actualRequests.size());
803     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
804 
805     Assert.assertEquals(request.getResource(), actualRequest.getResource());
806     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
807     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
808     Assert.assertTrue(
809         channelProvider.isHeaderSent(
810             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
811             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
812   }
813 
814   @Test
setIamPolicyExceptionTest()815   public void setIamPolicyExceptionTest() throws Exception {
816     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
817     mockCloudFunctionsService.addException(exception);
818 
819     try {
820       SetIamPolicyRequest request =
821           SetIamPolicyRequest.newBuilder()
822               .setResource(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
823               .setPolicy(Policy.newBuilder().build())
824               .setUpdateMask(FieldMask.newBuilder().build())
825               .build();
826       client.setIamPolicy(request);
827       Assert.fail("No exception raised");
828     } catch (InvalidArgumentException e) {
829       // Expected exception.
830     }
831   }
832 
833   @Test
getIamPolicyTest()834   public void getIamPolicyTest() throws Exception {
835     Policy expectedResponse =
836         Policy.newBuilder()
837             .setVersion(351608024)
838             .addAllBindings(new ArrayList<Binding>())
839             .addAllAuditConfigs(new ArrayList<AuditConfig>())
840             .setEtag(ByteString.EMPTY)
841             .build();
842     mockCloudFunctionsService.addResponse(expectedResponse);
843 
844     GetIamPolicyRequest request =
845         GetIamPolicyRequest.newBuilder()
846             .setResource(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
847             .setOptions(GetPolicyOptions.newBuilder().build())
848             .build();
849 
850     Policy actualResponse = client.getIamPolicy(request);
851     Assert.assertEquals(expectedResponse, actualResponse);
852 
853     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
854     Assert.assertEquals(1, actualRequests.size());
855     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
856 
857     Assert.assertEquals(request.getResource(), actualRequest.getResource());
858     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
859     Assert.assertTrue(
860         channelProvider.isHeaderSent(
861             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
862             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
863   }
864 
865   @Test
getIamPolicyExceptionTest()866   public void getIamPolicyExceptionTest() throws Exception {
867     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
868     mockCloudFunctionsService.addException(exception);
869 
870     try {
871       GetIamPolicyRequest request =
872           GetIamPolicyRequest.newBuilder()
873               .setResource(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
874               .setOptions(GetPolicyOptions.newBuilder().build())
875               .build();
876       client.getIamPolicy(request);
877       Assert.fail("No exception raised");
878     } catch (InvalidArgumentException e) {
879       // Expected exception.
880     }
881   }
882 
883   @Test
testIamPermissionsTest()884   public void testIamPermissionsTest() throws Exception {
885     TestIamPermissionsResponse expectedResponse =
886         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
887     mockCloudFunctionsService.addResponse(expectedResponse);
888 
889     TestIamPermissionsRequest request =
890         TestIamPermissionsRequest.newBuilder()
891             .setResource(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
892             .addAllPermissions(new ArrayList<String>())
893             .build();
894 
895     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
896     Assert.assertEquals(expectedResponse, actualResponse);
897 
898     List<AbstractMessage> actualRequests = mockCloudFunctionsService.getRequests();
899     Assert.assertEquals(1, actualRequests.size());
900     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
901 
902     Assert.assertEquals(request.getResource(), actualRequest.getResource());
903     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
904     Assert.assertTrue(
905         channelProvider.isHeaderSent(
906             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
907             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
908   }
909 
910   @Test
testIamPermissionsExceptionTest()911   public void testIamPermissionsExceptionTest() throws Exception {
912     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
913     mockCloudFunctionsService.addException(exception);
914 
915     try {
916       TestIamPermissionsRequest request =
917           TestIamPermissionsRequest.newBuilder()
918               .setResource(CloudFunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
919               .addAllPermissions(new ArrayList<String>())
920               .build();
921       client.testIamPermissions(request);
922       Assert.fail("No exception raised");
923     } catch (InvalidArgumentException e) {
924       // Expected exception.
925     }
926   }
927 
928   @Test
listLocationsTest()929   public void listLocationsTest() throws Exception {
930     Location responsesElement = Location.newBuilder().build();
931     ListLocationsResponse expectedResponse =
932         ListLocationsResponse.newBuilder()
933             .setNextPageToken("")
934             .addAllLocations(Arrays.asList(responsesElement))
935             .build();
936     mockLocations.addResponse(expectedResponse);
937 
938     ListLocationsRequest request =
939         ListLocationsRequest.newBuilder()
940             .setName("name3373707")
941             .setFilter("filter-1274492040")
942             .setPageSize(883849137)
943             .setPageToken("pageToken873572522")
944             .build();
945 
946     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
947 
948     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
949 
950     Assert.assertEquals(1, resources.size());
951     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
952 
953     List<AbstractMessage> actualRequests = mockLocations.getRequests();
954     Assert.assertEquals(1, actualRequests.size());
955     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
956 
957     Assert.assertEquals(request.getName(), actualRequest.getName());
958     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
959     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
960     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
961     Assert.assertTrue(
962         channelProvider.isHeaderSent(
963             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
964             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
965   }
966 
967   @Test
listLocationsExceptionTest()968   public void listLocationsExceptionTest() throws Exception {
969     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
970     mockLocations.addException(exception);
971 
972     try {
973       ListLocationsRequest request =
974           ListLocationsRequest.newBuilder()
975               .setName("name3373707")
976               .setFilter("filter-1274492040")
977               .setPageSize(883849137)
978               .setPageToken("pageToken873572522")
979               .build();
980       client.listLocations(request);
981       Assert.fail("No exception raised");
982     } catch (InvalidArgumentException e) {
983       // Expected exception.
984     }
985   }
986 }
987