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