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