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