• 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.v2;
18 
19 import static com.google.cloud.functions.v2.FunctionServiceClient.ListFunctionsPagedResponse;
20 import static com.google.cloud.functions.v2.FunctionServiceClient.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.v2.stub.HttpJsonFunctionServiceStub;
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.Empty;
48 import com.google.protobuf.FieldMask;
49 import com.google.protobuf.Timestamp;
50 import java.io.IOException;
51 import java.util.ArrayList;
52 import java.util.Arrays;
53 import java.util.HashMap;
54 import java.util.List;
55 import java.util.concurrent.ExecutionException;
56 import javax.annotation.Generated;
57 import org.junit.After;
58 import org.junit.AfterClass;
59 import org.junit.Assert;
60 import org.junit.Before;
61 import org.junit.BeforeClass;
62 import org.junit.Test;
63 
64 @Generated("by gapic-generator-java")
65 public class FunctionServiceClientHttpJsonTest {
66   private static MockHttpService mockService;
67   private static FunctionServiceClient client;
68 
69   @BeforeClass
startStaticServer()70   public static void startStaticServer() throws IOException {
71     mockService =
72         new MockHttpService(
73             HttpJsonFunctionServiceStub.getMethodDescriptors(),
74             FunctionServiceSettings.getDefaultEndpoint());
75     FunctionServiceSettings settings =
76         FunctionServiceSettings.newHttpJsonBuilder()
77             .setTransportChannelProvider(
78                 FunctionServiceSettings.defaultHttpJsonTransportProviderBuilder()
79                     .setHttpTransport(mockService)
80                     .build())
81             .setCredentialsProvider(NoCredentialsProvider.create())
82             .build();
83     client = FunctionServiceClient.create(settings);
84   }
85 
86   @AfterClass
stopServer()87   public static void stopServer() {
88     client.close();
89   }
90 
91   @Before
setUp()92   public void setUp() {}
93 
94   @After
tearDown()95   public void tearDown() throws Exception {
96     mockService.reset();
97   }
98 
99   @Test
getFunctionTest()100   public void getFunctionTest() throws Exception {
101     Function expectedResponse =
102         Function.newBuilder()
103             .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
104             .setEnvironment(Environment.forNumber(0))
105             .setDescription("description-1724546052")
106             .setBuildConfig(BuildConfig.newBuilder().build())
107             .setServiceConfig(ServiceConfig.newBuilder().build())
108             .setEventTrigger(EventTrigger.newBuilder().build())
109             .setUpdateTime(Timestamp.newBuilder().build())
110             .putAllLabels(new HashMap<String, String>())
111             .addAllStateMessages(new ArrayList<StateMessage>())
112             .setKmsKeyName(
113                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
114                     .toString())
115             .setUrl("url116079")
116             .build();
117     mockService.addResponse(expectedResponse);
118 
119     FunctionName name = FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
120 
121     Function actualResponse = client.getFunction(name);
122     Assert.assertEquals(expectedResponse, actualResponse);
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
getFunctionExceptionTest()140   public void getFunctionExceptionTest() 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       FunctionName name = FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
148       client.getFunction(name);
149       Assert.fail("No exception raised");
150     } catch (InvalidArgumentException e) {
151       // Expected exception.
152     }
153   }
154 
155   @Test
getFunctionTest2()156   public void getFunctionTest2() throws Exception {
157     Function expectedResponse =
158         Function.newBuilder()
159             .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
160             .setEnvironment(Environment.forNumber(0))
161             .setDescription("description-1724546052")
162             .setBuildConfig(BuildConfig.newBuilder().build())
163             .setServiceConfig(ServiceConfig.newBuilder().build())
164             .setEventTrigger(EventTrigger.newBuilder().build())
165             .setUpdateTime(Timestamp.newBuilder().build())
166             .putAllLabels(new HashMap<String, String>())
167             .addAllStateMessages(new ArrayList<StateMessage>())
168             .setKmsKeyName(
169                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
170                     .toString())
171             .setUrl("url116079")
172             .build();
173     mockService.addResponse(expectedResponse);
174 
175     String name = "projects/project-129/locations/location-129/functions/function-129";
176 
177     Function actualResponse = client.getFunction(name);
178     Assert.assertEquals(expectedResponse, actualResponse);
179 
180     List<String> actualRequests = mockService.getRequestPaths();
181     Assert.assertEquals(1, actualRequests.size());
182 
183     String apiClientHeaderKey =
184         mockService
185             .getRequestHeaders()
186             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
187             .iterator()
188             .next();
189     Assert.assertTrue(
190         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
191             .matcher(apiClientHeaderKey)
192             .matches());
193   }
194 
195   @Test
getFunctionExceptionTest2()196   public void getFunctionExceptionTest2() throws Exception {
197     ApiException exception =
198         ApiExceptionFactory.createException(
199             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
200     mockService.addException(exception);
201 
202     try {
203       String name = "projects/project-129/locations/location-129/functions/function-129";
204       client.getFunction(name);
205       Assert.fail("No exception raised");
206     } catch (InvalidArgumentException e) {
207       // Expected exception.
208     }
209   }
210 
211   @Test
listFunctionsTest()212   public void listFunctionsTest() throws Exception {
213     Function responsesElement = Function.newBuilder().build();
214     ListFunctionsResponse expectedResponse =
215         ListFunctionsResponse.newBuilder()
216             .setNextPageToken("")
217             .addAllFunctions(Arrays.asList(responsesElement))
218             .build();
219     mockService.addResponse(expectedResponse);
220 
221     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
222 
223     ListFunctionsPagedResponse pagedListResponse = client.listFunctions(parent);
224 
225     List<Function> resources = Lists.newArrayList(pagedListResponse.iterateAll());
226 
227     Assert.assertEquals(1, resources.size());
228     Assert.assertEquals(expectedResponse.getFunctionsList().get(0), resources.get(0));
229 
230     List<String> actualRequests = mockService.getRequestPaths();
231     Assert.assertEquals(1, actualRequests.size());
232 
233     String apiClientHeaderKey =
234         mockService
235             .getRequestHeaders()
236             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
237             .iterator()
238             .next();
239     Assert.assertTrue(
240         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
241             .matcher(apiClientHeaderKey)
242             .matches());
243   }
244 
245   @Test
listFunctionsExceptionTest()246   public void listFunctionsExceptionTest() throws Exception {
247     ApiException exception =
248         ApiExceptionFactory.createException(
249             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
250     mockService.addException(exception);
251 
252     try {
253       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
254       client.listFunctions(parent);
255       Assert.fail("No exception raised");
256     } catch (InvalidArgumentException e) {
257       // Expected exception.
258     }
259   }
260 
261   @Test
listFunctionsTest2()262   public void listFunctionsTest2() throws Exception {
263     Function responsesElement = Function.newBuilder().build();
264     ListFunctionsResponse expectedResponse =
265         ListFunctionsResponse.newBuilder()
266             .setNextPageToken("")
267             .addAllFunctions(Arrays.asList(responsesElement))
268             .build();
269     mockService.addResponse(expectedResponse);
270 
271     String parent = "projects/project-5833/locations/location-5833";
272 
273     ListFunctionsPagedResponse pagedListResponse = client.listFunctions(parent);
274 
275     List<Function> resources = Lists.newArrayList(pagedListResponse.iterateAll());
276 
277     Assert.assertEquals(1, resources.size());
278     Assert.assertEquals(expectedResponse.getFunctionsList().get(0), resources.get(0));
279 
280     List<String> actualRequests = mockService.getRequestPaths();
281     Assert.assertEquals(1, actualRequests.size());
282 
283     String apiClientHeaderKey =
284         mockService
285             .getRequestHeaders()
286             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
287             .iterator()
288             .next();
289     Assert.assertTrue(
290         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
291             .matcher(apiClientHeaderKey)
292             .matches());
293   }
294 
295   @Test
listFunctionsExceptionTest2()296   public void listFunctionsExceptionTest2() throws Exception {
297     ApiException exception =
298         ApiExceptionFactory.createException(
299             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
300     mockService.addException(exception);
301 
302     try {
303       String parent = "projects/project-5833/locations/location-5833";
304       client.listFunctions(parent);
305       Assert.fail("No exception raised");
306     } catch (InvalidArgumentException e) {
307       // Expected exception.
308     }
309   }
310 
311   @Test
createFunctionTest()312   public void createFunctionTest() throws Exception {
313     Function expectedResponse =
314         Function.newBuilder()
315             .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
316             .setEnvironment(Environment.forNumber(0))
317             .setDescription("description-1724546052")
318             .setBuildConfig(BuildConfig.newBuilder().build())
319             .setServiceConfig(ServiceConfig.newBuilder().build())
320             .setEventTrigger(EventTrigger.newBuilder().build())
321             .setUpdateTime(Timestamp.newBuilder().build())
322             .putAllLabels(new HashMap<String, String>())
323             .addAllStateMessages(new ArrayList<StateMessage>())
324             .setKmsKeyName(
325                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
326                     .toString())
327             .setUrl("url116079")
328             .build();
329     Operation resultOperation =
330         Operation.newBuilder()
331             .setName("createFunctionTest")
332             .setDone(true)
333             .setResponse(Any.pack(expectedResponse))
334             .build();
335     mockService.addResponse(resultOperation);
336 
337     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
338     Function function = Function.newBuilder().build();
339     String functionId = "functionId-62789869";
340 
341     Function actualResponse = client.createFunctionAsync(parent, function, functionId).get();
342     Assert.assertEquals(expectedResponse, actualResponse);
343 
344     List<String> actualRequests = mockService.getRequestPaths();
345     Assert.assertEquals(1, actualRequests.size());
346 
347     String apiClientHeaderKey =
348         mockService
349             .getRequestHeaders()
350             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
351             .iterator()
352             .next();
353     Assert.assertTrue(
354         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
355             .matcher(apiClientHeaderKey)
356             .matches());
357   }
358 
359   @Test
createFunctionExceptionTest()360   public void createFunctionExceptionTest() throws Exception {
361     ApiException exception =
362         ApiExceptionFactory.createException(
363             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
364     mockService.addException(exception);
365 
366     try {
367       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
368       Function function = Function.newBuilder().build();
369       String functionId = "functionId-62789869";
370       client.createFunctionAsync(parent, function, functionId).get();
371       Assert.fail("No exception raised");
372     } catch (ExecutionException e) {
373     }
374   }
375 
376   @Test
createFunctionTest2()377   public void createFunctionTest2() throws Exception {
378     Function expectedResponse =
379         Function.newBuilder()
380             .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
381             .setEnvironment(Environment.forNumber(0))
382             .setDescription("description-1724546052")
383             .setBuildConfig(BuildConfig.newBuilder().build())
384             .setServiceConfig(ServiceConfig.newBuilder().build())
385             .setEventTrigger(EventTrigger.newBuilder().build())
386             .setUpdateTime(Timestamp.newBuilder().build())
387             .putAllLabels(new HashMap<String, String>())
388             .addAllStateMessages(new ArrayList<StateMessage>())
389             .setKmsKeyName(
390                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
391                     .toString())
392             .setUrl("url116079")
393             .build();
394     Operation resultOperation =
395         Operation.newBuilder()
396             .setName("createFunctionTest")
397             .setDone(true)
398             .setResponse(Any.pack(expectedResponse))
399             .build();
400     mockService.addResponse(resultOperation);
401 
402     String parent = "projects/project-5833/locations/location-5833";
403     Function function = Function.newBuilder().build();
404     String functionId = "functionId-62789869";
405 
406     Function actualResponse = client.createFunctionAsync(parent, function, functionId).get();
407     Assert.assertEquals(expectedResponse, actualResponse);
408 
409     List<String> actualRequests = mockService.getRequestPaths();
410     Assert.assertEquals(1, actualRequests.size());
411 
412     String apiClientHeaderKey =
413         mockService
414             .getRequestHeaders()
415             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
416             .iterator()
417             .next();
418     Assert.assertTrue(
419         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
420             .matcher(apiClientHeaderKey)
421             .matches());
422   }
423 
424   @Test
createFunctionExceptionTest2()425   public void createFunctionExceptionTest2() throws Exception {
426     ApiException exception =
427         ApiExceptionFactory.createException(
428             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
429     mockService.addException(exception);
430 
431     try {
432       String parent = "projects/project-5833/locations/location-5833";
433       Function function = Function.newBuilder().build();
434       String functionId = "functionId-62789869";
435       client.createFunctionAsync(parent, function, functionId).get();
436       Assert.fail("No exception raised");
437     } catch (ExecutionException e) {
438     }
439   }
440 
441   @Test
updateFunctionTest()442   public void updateFunctionTest() throws Exception {
443     Function expectedResponse =
444         Function.newBuilder()
445             .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
446             .setEnvironment(Environment.forNumber(0))
447             .setDescription("description-1724546052")
448             .setBuildConfig(BuildConfig.newBuilder().build())
449             .setServiceConfig(ServiceConfig.newBuilder().build())
450             .setEventTrigger(EventTrigger.newBuilder().build())
451             .setUpdateTime(Timestamp.newBuilder().build())
452             .putAllLabels(new HashMap<String, String>())
453             .addAllStateMessages(new ArrayList<StateMessage>())
454             .setKmsKeyName(
455                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
456                     .toString())
457             .setUrl("url116079")
458             .build();
459     Operation resultOperation =
460         Operation.newBuilder()
461             .setName("updateFunctionTest")
462             .setDone(true)
463             .setResponse(Any.pack(expectedResponse))
464             .build();
465     mockService.addResponse(resultOperation);
466 
467     Function function =
468         Function.newBuilder()
469             .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
470             .setEnvironment(Environment.forNumber(0))
471             .setDescription("description-1724546052")
472             .setBuildConfig(BuildConfig.newBuilder().build())
473             .setServiceConfig(ServiceConfig.newBuilder().build())
474             .setEventTrigger(EventTrigger.newBuilder().build())
475             .setUpdateTime(Timestamp.newBuilder().build())
476             .putAllLabels(new HashMap<String, String>())
477             .addAllStateMessages(new ArrayList<StateMessage>())
478             .setKmsKeyName(
479                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
480                     .toString())
481             .setUrl("url116079")
482             .build();
483     FieldMask updateMask = FieldMask.newBuilder().build();
484 
485     Function actualResponse = client.updateFunctionAsync(function, updateMask).get();
486     Assert.assertEquals(expectedResponse, actualResponse);
487 
488     List<String> actualRequests = mockService.getRequestPaths();
489     Assert.assertEquals(1, actualRequests.size());
490 
491     String apiClientHeaderKey =
492         mockService
493             .getRequestHeaders()
494             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
495             .iterator()
496             .next();
497     Assert.assertTrue(
498         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
499             .matcher(apiClientHeaderKey)
500             .matches());
501   }
502 
503   @Test
updateFunctionExceptionTest()504   public void updateFunctionExceptionTest() throws Exception {
505     ApiException exception =
506         ApiExceptionFactory.createException(
507             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
508     mockService.addException(exception);
509 
510     try {
511       Function function =
512           Function.newBuilder()
513               .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
514               .setEnvironment(Environment.forNumber(0))
515               .setDescription("description-1724546052")
516               .setBuildConfig(BuildConfig.newBuilder().build())
517               .setServiceConfig(ServiceConfig.newBuilder().build())
518               .setEventTrigger(EventTrigger.newBuilder().build())
519               .setUpdateTime(Timestamp.newBuilder().build())
520               .putAllLabels(new HashMap<String, String>())
521               .addAllStateMessages(new ArrayList<StateMessage>())
522               .setKmsKeyName(
523                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
524                       .toString())
525               .setUrl("url116079")
526               .build();
527       FieldMask updateMask = FieldMask.newBuilder().build();
528       client.updateFunctionAsync(function, updateMask).get();
529       Assert.fail("No exception raised");
530     } catch (ExecutionException e) {
531     }
532   }
533 
534   @Test
deleteFunctionTest()535   public void deleteFunctionTest() throws Exception {
536     Empty expectedResponse = Empty.newBuilder().build();
537     Operation resultOperation =
538         Operation.newBuilder()
539             .setName("deleteFunctionTest")
540             .setDone(true)
541             .setResponse(Any.pack(expectedResponse))
542             .build();
543     mockService.addResponse(resultOperation);
544 
545     FunctionName name = FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
546 
547     client.deleteFunctionAsync(name).get();
548 
549     List<String> actualRequests = mockService.getRequestPaths();
550     Assert.assertEquals(1, actualRequests.size());
551 
552     String apiClientHeaderKey =
553         mockService
554             .getRequestHeaders()
555             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
556             .iterator()
557             .next();
558     Assert.assertTrue(
559         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
560             .matcher(apiClientHeaderKey)
561             .matches());
562   }
563 
564   @Test
deleteFunctionExceptionTest()565   public void deleteFunctionExceptionTest() throws Exception {
566     ApiException exception =
567         ApiExceptionFactory.createException(
568             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
569     mockService.addException(exception);
570 
571     try {
572       FunctionName name = FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]");
573       client.deleteFunctionAsync(name).get();
574       Assert.fail("No exception raised");
575     } catch (ExecutionException e) {
576     }
577   }
578 
579   @Test
deleteFunctionTest2()580   public void deleteFunctionTest2() throws Exception {
581     Empty expectedResponse = Empty.newBuilder().build();
582     Operation resultOperation =
583         Operation.newBuilder()
584             .setName("deleteFunctionTest")
585             .setDone(true)
586             .setResponse(Any.pack(expectedResponse))
587             .build();
588     mockService.addResponse(resultOperation);
589 
590     String name = "projects/project-129/locations/location-129/functions/function-129";
591 
592     client.deleteFunctionAsync(name).get();
593 
594     List<String> actualRequests = mockService.getRequestPaths();
595     Assert.assertEquals(1, actualRequests.size());
596 
597     String apiClientHeaderKey =
598         mockService
599             .getRequestHeaders()
600             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
601             .iterator()
602             .next();
603     Assert.assertTrue(
604         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
605             .matcher(apiClientHeaderKey)
606             .matches());
607   }
608 
609   @Test
deleteFunctionExceptionTest2()610   public void deleteFunctionExceptionTest2() throws Exception {
611     ApiException exception =
612         ApiExceptionFactory.createException(
613             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
614     mockService.addException(exception);
615 
616     try {
617       String name = "projects/project-129/locations/location-129/functions/function-129";
618       client.deleteFunctionAsync(name).get();
619       Assert.fail("No exception raised");
620     } catch (ExecutionException e) {
621     }
622   }
623 
624   @Test
generateUploadUrlTest()625   public void generateUploadUrlTest() throws Exception {
626     GenerateUploadUrlResponse expectedResponse =
627         GenerateUploadUrlResponse.newBuilder()
628             .setUploadUrl("uploadUrl1239085998")
629             .setStorageSource(StorageSource.newBuilder().build())
630             .build();
631     mockService.addResponse(expectedResponse);
632 
633     GenerateUploadUrlRequest request =
634         GenerateUploadUrlRequest.newBuilder()
635             .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
636             .setKmsKeyName(
637                 CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
638                     .toString())
639             .build();
640 
641     GenerateUploadUrlResponse actualResponse = client.generateUploadUrl(request);
642     Assert.assertEquals(expectedResponse, actualResponse);
643 
644     List<String> actualRequests = mockService.getRequestPaths();
645     Assert.assertEquals(1, actualRequests.size());
646 
647     String apiClientHeaderKey =
648         mockService
649             .getRequestHeaders()
650             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
651             .iterator()
652             .next();
653     Assert.assertTrue(
654         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
655             .matcher(apiClientHeaderKey)
656             .matches());
657   }
658 
659   @Test
generateUploadUrlExceptionTest()660   public void generateUploadUrlExceptionTest() throws Exception {
661     ApiException exception =
662         ApiExceptionFactory.createException(
663             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
664     mockService.addException(exception);
665 
666     try {
667       GenerateUploadUrlRequest request =
668           GenerateUploadUrlRequest.newBuilder()
669               .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
670               .setKmsKeyName(
671                   CryptoKeyName.of("[PROJECT]", "[LOCATION]", "[KEY_RING]", "[CRYPTO_KEY]")
672                       .toString())
673               .build();
674       client.generateUploadUrl(request);
675       Assert.fail("No exception raised");
676     } catch (InvalidArgumentException e) {
677       // Expected exception.
678     }
679   }
680 
681   @Test
generateDownloadUrlTest()682   public void generateDownloadUrlTest() throws Exception {
683     GenerateDownloadUrlResponse expectedResponse =
684         GenerateDownloadUrlResponse.newBuilder().setDownloadUrl("downloadUrl-1211148345").build();
685     mockService.addResponse(expectedResponse);
686 
687     GenerateDownloadUrlRequest request =
688         GenerateDownloadUrlRequest.newBuilder()
689             .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
690             .build();
691 
692     GenerateDownloadUrlResponse actualResponse = client.generateDownloadUrl(request);
693     Assert.assertEquals(expectedResponse, actualResponse);
694 
695     List<String> actualRequests = mockService.getRequestPaths();
696     Assert.assertEquals(1, actualRequests.size());
697 
698     String apiClientHeaderKey =
699         mockService
700             .getRequestHeaders()
701             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
702             .iterator()
703             .next();
704     Assert.assertTrue(
705         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
706             .matcher(apiClientHeaderKey)
707             .matches());
708   }
709 
710   @Test
generateDownloadUrlExceptionTest()711   public void generateDownloadUrlExceptionTest() throws Exception {
712     ApiException exception =
713         ApiExceptionFactory.createException(
714             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
715     mockService.addException(exception);
716 
717     try {
718       GenerateDownloadUrlRequest request =
719           GenerateDownloadUrlRequest.newBuilder()
720               .setName(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
721               .build();
722       client.generateDownloadUrl(request);
723       Assert.fail("No exception raised");
724     } catch (InvalidArgumentException e) {
725       // Expected exception.
726     }
727   }
728 
729   @Test
listRuntimesTest()730   public void listRuntimesTest() throws Exception {
731     ListRuntimesResponse expectedResponse =
732         ListRuntimesResponse.newBuilder()
733             .addAllRuntimes(new ArrayList<ListRuntimesResponse.Runtime>())
734             .build();
735     mockService.addResponse(expectedResponse);
736 
737     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
738 
739     ListRuntimesResponse actualResponse = client.listRuntimes(parent);
740     Assert.assertEquals(expectedResponse, actualResponse);
741 
742     List<String> actualRequests = mockService.getRequestPaths();
743     Assert.assertEquals(1, actualRequests.size());
744 
745     String apiClientHeaderKey =
746         mockService
747             .getRequestHeaders()
748             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
749             .iterator()
750             .next();
751     Assert.assertTrue(
752         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
753             .matcher(apiClientHeaderKey)
754             .matches());
755   }
756 
757   @Test
listRuntimesExceptionTest()758   public void listRuntimesExceptionTest() throws Exception {
759     ApiException exception =
760         ApiExceptionFactory.createException(
761             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
762     mockService.addException(exception);
763 
764     try {
765       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
766       client.listRuntimes(parent);
767       Assert.fail("No exception raised");
768     } catch (InvalidArgumentException e) {
769       // Expected exception.
770     }
771   }
772 
773   @Test
listRuntimesTest2()774   public void listRuntimesTest2() throws Exception {
775     ListRuntimesResponse expectedResponse =
776         ListRuntimesResponse.newBuilder()
777             .addAllRuntimes(new ArrayList<ListRuntimesResponse.Runtime>())
778             .build();
779     mockService.addResponse(expectedResponse);
780 
781     String parent = "projects/project-5833/locations/location-5833";
782 
783     ListRuntimesResponse actualResponse = client.listRuntimes(parent);
784     Assert.assertEquals(expectedResponse, actualResponse);
785 
786     List<String> actualRequests = mockService.getRequestPaths();
787     Assert.assertEquals(1, actualRequests.size());
788 
789     String apiClientHeaderKey =
790         mockService
791             .getRequestHeaders()
792             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
793             .iterator()
794             .next();
795     Assert.assertTrue(
796         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
797             .matcher(apiClientHeaderKey)
798             .matches());
799   }
800 
801   @Test
listRuntimesExceptionTest2()802   public void listRuntimesExceptionTest2() throws Exception {
803     ApiException exception =
804         ApiExceptionFactory.createException(
805             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
806     mockService.addException(exception);
807 
808     try {
809       String parent = "projects/project-5833/locations/location-5833";
810       client.listRuntimes(parent);
811       Assert.fail("No exception raised");
812     } catch (InvalidArgumentException e) {
813       // Expected exception.
814     }
815   }
816 
817   @Test
listLocationsTest()818   public void listLocationsTest() throws Exception {
819     Location responsesElement = Location.newBuilder().build();
820     ListLocationsResponse expectedResponse =
821         ListLocationsResponse.newBuilder()
822             .setNextPageToken("")
823             .addAllLocations(Arrays.asList(responsesElement))
824             .build();
825     mockService.addResponse(expectedResponse);
826 
827     ListLocationsRequest request =
828         ListLocationsRequest.newBuilder()
829             .setName("projects/project-3664")
830             .setFilter("filter-1274492040")
831             .setPageSize(883849137)
832             .setPageToken("pageToken873572522")
833             .build();
834 
835     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
836 
837     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
838 
839     Assert.assertEquals(1, resources.size());
840     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
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
listLocationsExceptionTest()858   public void listLocationsExceptionTest() 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       ListLocationsRequest request =
866           ListLocationsRequest.newBuilder()
867               .setName("projects/project-3664")
868               .setFilter("filter-1274492040")
869               .setPageSize(883849137)
870               .setPageToken("pageToken873572522")
871               .build();
872       client.listLocations(request);
873       Assert.fail("No exception raised");
874     } catch (InvalidArgumentException e) {
875       // Expected exception.
876     }
877   }
878 
879   @Test
setIamPolicyTest()880   public void setIamPolicyTest() throws Exception {
881     Policy expectedResponse =
882         Policy.newBuilder()
883             .setVersion(351608024)
884             .addAllBindings(new ArrayList<Binding>())
885             .addAllAuditConfigs(new ArrayList<AuditConfig>())
886             .setEtag(ByteString.EMPTY)
887             .build();
888     mockService.addResponse(expectedResponse);
889 
890     SetIamPolicyRequest request =
891         SetIamPolicyRequest.newBuilder()
892             .setResource(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
893             .setPolicy(Policy.newBuilder().build())
894             .setUpdateMask(FieldMask.newBuilder().build())
895             .build();
896 
897     Policy actualResponse = client.setIamPolicy(request);
898     Assert.assertEquals(expectedResponse, actualResponse);
899 
900     List<String> actualRequests = mockService.getRequestPaths();
901     Assert.assertEquals(1, actualRequests.size());
902 
903     String apiClientHeaderKey =
904         mockService
905             .getRequestHeaders()
906             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
907             .iterator()
908             .next();
909     Assert.assertTrue(
910         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
911             .matcher(apiClientHeaderKey)
912             .matches());
913   }
914 
915   @Test
setIamPolicyExceptionTest()916   public void setIamPolicyExceptionTest() throws Exception {
917     ApiException exception =
918         ApiExceptionFactory.createException(
919             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
920     mockService.addException(exception);
921 
922     try {
923       SetIamPolicyRequest request =
924           SetIamPolicyRequest.newBuilder()
925               .setResource(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
926               .setPolicy(Policy.newBuilder().build())
927               .setUpdateMask(FieldMask.newBuilder().build())
928               .build();
929       client.setIamPolicy(request);
930       Assert.fail("No exception raised");
931     } catch (InvalidArgumentException e) {
932       // Expected exception.
933     }
934   }
935 
936   @Test
getIamPolicyTest()937   public void getIamPolicyTest() throws Exception {
938     Policy expectedResponse =
939         Policy.newBuilder()
940             .setVersion(351608024)
941             .addAllBindings(new ArrayList<Binding>())
942             .addAllAuditConfigs(new ArrayList<AuditConfig>())
943             .setEtag(ByteString.EMPTY)
944             .build();
945     mockService.addResponse(expectedResponse);
946 
947     GetIamPolicyRequest request =
948         GetIamPolicyRequest.newBuilder()
949             .setResource(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
950             .setOptions(GetPolicyOptions.newBuilder().build())
951             .build();
952 
953     Policy actualResponse = client.getIamPolicy(request);
954     Assert.assertEquals(expectedResponse, actualResponse);
955 
956     List<String> actualRequests = mockService.getRequestPaths();
957     Assert.assertEquals(1, actualRequests.size());
958 
959     String apiClientHeaderKey =
960         mockService
961             .getRequestHeaders()
962             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
963             .iterator()
964             .next();
965     Assert.assertTrue(
966         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
967             .matcher(apiClientHeaderKey)
968             .matches());
969   }
970 
971   @Test
getIamPolicyExceptionTest()972   public void getIamPolicyExceptionTest() throws Exception {
973     ApiException exception =
974         ApiExceptionFactory.createException(
975             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
976     mockService.addException(exception);
977 
978     try {
979       GetIamPolicyRequest request =
980           GetIamPolicyRequest.newBuilder()
981               .setResource(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
982               .setOptions(GetPolicyOptions.newBuilder().build())
983               .build();
984       client.getIamPolicy(request);
985       Assert.fail("No exception raised");
986     } catch (InvalidArgumentException e) {
987       // Expected exception.
988     }
989   }
990 
991   @Test
testIamPermissionsTest()992   public void testIamPermissionsTest() throws Exception {
993     TestIamPermissionsResponse expectedResponse =
994         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
995     mockService.addResponse(expectedResponse);
996 
997     TestIamPermissionsRequest request =
998         TestIamPermissionsRequest.newBuilder()
999             .setResource(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
1000             .addAllPermissions(new ArrayList<String>())
1001             .build();
1002 
1003     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1004     Assert.assertEquals(expectedResponse, actualResponse);
1005 
1006     List<String> actualRequests = mockService.getRequestPaths();
1007     Assert.assertEquals(1, actualRequests.size());
1008 
1009     String apiClientHeaderKey =
1010         mockService
1011             .getRequestHeaders()
1012             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1013             .iterator()
1014             .next();
1015     Assert.assertTrue(
1016         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1017             .matcher(apiClientHeaderKey)
1018             .matches());
1019   }
1020 
1021   @Test
testIamPermissionsExceptionTest()1022   public void testIamPermissionsExceptionTest() throws Exception {
1023     ApiException exception =
1024         ApiExceptionFactory.createException(
1025             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1026     mockService.addException(exception);
1027 
1028     try {
1029       TestIamPermissionsRequest request =
1030           TestIamPermissionsRequest.newBuilder()
1031               .setResource(FunctionName.of("[PROJECT]", "[LOCATION]", "[FUNCTION]").toString())
1032               .addAllPermissions(new ArrayList<String>())
1033               .build();
1034       client.testIamPermissions(request);
1035       Assert.fail("No exception raised");
1036     } catch (InvalidArgumentException e) {
1037       // Expected exception.
1038     }
1039   }
1040 }
1041