• 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.aiplatform.v1;
18 
19 import static com.google.cloud.aiplatform.v1.EndpointServiceClient.ListEndpointsPagedResponse;
20 import static com.google.cloud.aiplatform.v1.EndpointServiceClient.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.GetLocationRequest;
31 import com.google.cloud.location.ListLocationsRequest;
32 import com.google.cloud.location.ListLocationsResponse;
33 import com.google.cloud.location.Location;
34 import com.google.common.collect.Lists;
35 import com.google.iam.v1.AuditConfig;
36 import com.google.iam.v1.Binding;
37 import com.google.iam.v1.GetIamPolicyRequest;
38 import com.google.iam.v1.GetPolicyOptions;
39 import com.google.iam.v1.Policy;
40 import com.google.iam.v1.SetIamPolicyRequest;
41 import com.google.iam.v1.TestIamPermissionsRequest;
42 import com.google.iam.v1.TestIamPermissionsResponse;
43 import com.google.longrunning.Operation;
44 import com.google.protobuf.AbstractMessage;
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 io.grpc.StatusRuntimeException;
51 import java.io.IOException;
52 import java.util.ArrayList;
53 import java.util.Arrays;
54 import java.util.HashMap;
55 import java.util.List;
56 import java.util.Map;
57 import java.util.UUID;
58 import java.util.concurrent.ExecutionException;
59 import javax.annotation.Generated;
60 import org.junit.After;
61 import org.junit.AfterClass;
62 import org.junit.Assert;
63 import org.junit.Before;
64 import org.junit.BeforeClass;
65 import org.junit.Test;
66 
67 @Generated("by gapic-generator-java")
68 public class EndpointServiceClientTest {
69   private static MockEndpointService mockEndpointService;
70   private static MockIAMPolicy mockIAMPolicy;
71   private static MockLocations mockLocations;
72   private static MockServiceHelper mockServiceHelper;
73   private LocalChannelProvider channelProvider;
74   private EndpointServiceClient client;
75 
76   @BeforeClass
startStaticServer()77   public static void startStaticServer() {
78     mockEndpointService = new MockEndpointService();
79     mockLocations = new MockLocations();
80     mockIAMPolicy = new MockIAMPolicy();
81     mockServiceHelper =
82         new MockServiceHelper(
83             UUID.randomUUID().toString(),
84             Arrays.<MockGrpcService>asList(mockEndpointService, mockLocations, mockIAMPolicy));
85     mockServiceHelper.start();
86   }
87 
88   @AfterClass
stopServer()89   public static void stopServer() {
90     mockServiceHelper.stop();
91   }
92 
93   @Before
setUp()94   public void setUp() throws IOException {
95     mockServiceHelper.reset();
96     channelProvider = mockServiceHelper.createChannelProvider();
97     EndpointServiceSettings settings =
98         EndpointServiceSettings.newBuilder()
99             .setTransportChannelProvider(channelProvider)
100             .setCredentialsProvider(NoCredentialsProvider.create())
101             .build();
102     client = EndpointServiceClient.create(settings);
103   }
104 
105   @After
tearDown()106   public void tearDown() throws Exception {
107     client.close();
108   }
109 
110   @Test
createEndpointTest()111   public void createEndpointTest() throws Exception {
112     Endpoint expectedResponse =
113         Endpoint.newBuilder()
114             .setName(
115                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
116                     .toString())
117             .setDisplayName("displayName1714148973")
118             .setDescription("description-1724546052")
119             .addAllDeployedModels(new ArrayList<DeployedModel>())
120             .putAllTrafficSplit(new HashMap<String, Integer>())
121             .setEtag("etag3123477")
122             .putAllLabels(new HashMap<String, String>())
123             .setCreateTime(Timestamp.newBuilder().build())
124             .setUpdateTime(Timestamp.newBuilder().build())
125             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
126             .setNetwork("network1843485230")
127             .setEnablePrivateServiceConnect(true)
128             .setModelDeploymentMonitoringJob(
129                 ModelDeploymentMonitoringJobName.of(
130                         "[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]")
131                     .toString())
132             .setPredictRequestResponseLoggingConfig(
133                 PredictRequestResponseLoggingConfig.newBuilder().build())
134             .build();
135     Operation resultOperation =
136         Operation.newBuilder()
137             .setName("createEndpointTest")
138             .setDone(true)
139             .setResponse(Any.pack(expectedResponse))
140             .build();
141     mockEndpointService.addResponse(resultOperation);
142 
143     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
144     Endpoint endpoint = Endpoint.newBuilder().build();
145 
146     Endpoint actualResponse = client.createEndpointAsync(parent, endpoint).get();
147     Assert.assertEquals(expectedResponse, actualResponse);
148 
149     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
150     Assert.assertEquals(1, actualRequests.size());
151     CreateEndpointRequest actualRequest = ((CreateEndpointRequest) actualRequests.get(0));
152 
153     Assert.assertEquals(parent.toString(), actualRequest.getParent());
154     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
155     Assert.assertTrue(
156         channelProvider.isHeaderSent(
157             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
158             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
159   }
160 
161   @Test
createEndpointExceptionTest()162   public void createEndpointExceptionTest() throws Exception {
163     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
164     mockEndpointService.addException(exception);
165 
166     try {
167       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
168       Endpoint endpoint = Endpoint.newBuilder().build();
169       client.createEndpointAsync(parent, endpoint).get();
170       Assert.fail("No exception raised");
171     } catch (ExecutionException e) {
172       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
173       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
174       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
175     }
176   }
177 
178   @Test
createEndpointTest2()179   public void createEndpointTest2() throws Exception {
180     Endpoint expectedResponse =
181         Endpoint.newBuilder()
182             .setName(
183                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
184                     .toString())
185             .setDisplayName("displayName1714148973")
186             .setDescription("description-1724546052")
187             .addAllDeployedModels(new ArrayList<DeployedModel>())
188             .putAllTrafficSplit(new HashMap<String, Integer>())
189             .setEtag("etag3123477")
190             .putAllLabels(new HashMap<String, String>())
191             .setCreateTime(Timestamp.newBuilder().build())
192             .setUpdateTime(Timestamp.newBuilder().build())
193             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
194             .setNetwork("network1843485230")
195             .setEnablePrivateServiceConnect(true)
196             .setModelDeploymentMonitoringJob(
197                 ModelDeploymentMonitoringJobName.of(
198                         "[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]")
199                     .toString())
200             .setPredictRequestResponseLoggingConfig(
201                 PredictRequestResponseLoggingConfig.newBuilder().build())
202             .build();
203     Operation resultOperation =
204         Operation.newBuilder()
205             .setName("createEndpointTest")
206             .setDone(true)
207             .setResponse(Any.pack(expectedResponse))
208             .build();
209     mockEndpointService.addResponse(resultOperation);
210 
211     String parent = "parent-995424086";
212     Endpoint endpoint = Endpoint.newBuilder().build();
213 
214     Endpoint actualResponse = client.createEndpointAsync(parent, endpoint).get();
215     Assert.assertEquals(expectedResponse, actualResponse);
216 
217     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
218     Assert.assertEquals(1, actualRequests.size());
219     CreateEndpointRequest actualRequest = ((CreateEndpointRequest) actualRequests.get(0));
220 
221     Assert.assertEquals(parent, actualRequest.getParent());
222     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
223     Assert.assertTrue(
224         channelProvider.isHeaderSent(
225             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
226             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
227   }
228 
229   @Test
createEndpointExceptionTest2()230   public void createEndpointExceptionTest2() throws Exception {
231     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
232     mockEndpointService.addException(exception);
233 
234     try {
235       String parent = "parent-995424086";
236       Endpoint endpoint = Endpoint.newBuilder().build();
237       client.createEndpointAsync(parent, endpoint).get();
238       Assert.fail("No exception raised");
239     } catch (ExecutionException e) {
240       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
241       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
242       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
243     }
244   }
245 
246   @Test
createEndpointTest3()247   public void createEndpointTest3() throws Exception {
248     Endpoint expectedResponse =
249         Endpoint.newBuilder()
250             .setName(
251                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
252                     .toString())
253             .setDisplayName("displayName1714148973")
254             .setDescription("description-1724546052")
255             .addAllDeployedModels(new ArrayList<DeployedModel>())
256             .putAllTrafficSplit(new HashMap<String, Integer>())
257             .setEtag("etag3123477")
258             .putAllLabels(new HashMap<String, String>())
259             .setCreateTime(Timestamp.newBuilder().build())
260             .setUpdateTime(Timestamp.newBuilder().build())
261             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
262             .setNetwork("network1843485230")
263             .setEnablePrivateServiceConnect(true)
264             .setModelDeploymentMonitoringJob(
265                 ModelDeploymentMonitoringJobName.of(
266                         "[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]")
267                     .toString())
268             .setPredictRequestResponseLoggingConfig(
269                 PredictRequestResponseLoggingConfig.newBuilder().build())
270             .build();
271     Operation resultOperation =
272         Operation.newBuilder()
273             .setName("createEndpointTest")
274             .setDone(true)
275             .setResponse(Any.pack(expectedResponse))
276             .build();
277     mockEndpointService.addResponse(resultOperation);
278 
279     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
280     Endpoint endpoint = Endpoint.newBuilder().build();
281     String endpointId = "endpointId-1837754992";
282 
283     Endpoint actualResponse = client.createEndpointAsync(parent, endpoint, endpointId).get();
284     Assert.assertEquals(expectedResponse, actualResponse);
285 
286     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
287     Assert.assertEquals(1, actualRequests.size());
288     CreateEndpointRequest actualRequest = ((CreateEndpointRequest) actualRequests.get(0));
289 
290     Assert.assertEquals(parent.toString(), actualRequest.getParent());
291     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
292     Assert.assertEquals(endpointId, actualRequest.getEndpointId());
293     Assert.assertTrue(
294         channelProvider.isHeaderSent(
295             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
296             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
297   }
298 
299   @Test
createEndpointExceptionTest3()300   public void createEndpointExceptionTest3() throws Exception {
301     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
302     mockEndpointService.addException(exception);
303 
304     try {
305       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
306       Endpoint endpoint = Endpoint.newBuilder().build();
307       String endpointId = "endpointId-1837754992";
308       client.createEndpointAsync(parent, endpoint, endpointId).get();
309       Assert.fail("No exception raised");
310     } catch (ExecutionException e) {
311       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
312       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
313       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
314     }
315   }
316 
317   @Test
createEndpointTest4()318   public void createEndpointTest4() throws Exception {
319     Endpoint expectedResponse =
320         Endpoint.newBuilder()
321             .setName(
322                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
323                     .toString())
324             .setDisplayName("displayName1714148973")
325             .setDescription("description-1724546052")
326             .addAllDeployedModels(new ArrayList<DeployedModel>())
327             .putAllTrafficSplit(new HashMap<String, Integer>())
328             .setEtag("etag3123477")
329             .putAllLabels(new HashMap<String, String>())
330             .setCreateTime(Timestamp.newBuilder().build())
331             .setUpdateTime(Timestamp.newBuilder().build())
332             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
333             .setNetwork("network1843485230")
334             .setEnablePrivateServiceConnect(true)
335             .setModelDeploymentMonitoringJob(
336                 ModelDeploymentMonitoringJobName.of(
337                         "[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]")
338                     .toString())
339             .setPredictRequestResponseLoggingConfig(
340                 PredictRequestResponseLoggingConfig.newBuilder().build())
341             .build();
342     Operation resultOperation =
343         Operation.newBuilder()
344             .setName("createEndpointTest")
345             .setDone(true)
346             .setResponse(Any.pack(expectedResponse))
347             .build();
348     mockEndpointService.addResponse(resultOperation);
349 
350     String parent = "parent-995424086";
351     Endpoint endpoint = Endpoint.newBuilder().build();
352     String endpointId = "endpointId-1837754992";
353 
354     Endpoint actualResponse = client.createEndpointAsync(parent, endpoint, endpointId).get();
355     Assert.assertEquals(expectedResponse, actualResponse);
356 
357     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
358     Assert.assertEquals(1, actualRequests.size());
359     CreateEndpointRequest actualRequest = ((CreateEndpointRequest) actualRequests.get(0));
360 
361     Assert.assertEquals(parent, actualRequest.getParent());
362     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
363     Assert.assertEquals(endpointId, actualRequest.getEndpointId());
364     Assert.assertTrue(
365         channelProvider.isHeaderSent(
366             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
367             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
368   }
369 
370   @Test
createEndpointExceptionTest4()371   public void createEndpointExceptionTest4() throws Exception {
372     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
373     mockEndpointService.addException(exception);
374 
375     try {
376       String parent = "parent-995424086";
377       Endpoint endpoint = Endpoint.newBuilder().build();
378       String endpointId = "endpointId-1837754992";
379       client.createEndpointAsync(parent, endpoint, endpointId).get();
380       Assert.fail("No exception raised");
381     } catch (ExecutionException e) {
382       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
383       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
384       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
385     }
386   }
387 
388   @Test
getEndpointTest()389   public void getEndpointTest() throws Exception {
390     Endpoint expectedResponse =
391         Endpoint.newBuilder()
392             .setName(
393                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
394                     .toString())
395             .setDisplayName("displayName1714148973")
396             .setDescription("description-1724546052")
397             .addAllDeployedModels(new ArrayList<DeployedModel>())
398             .putAllTrafficSplit(new HashMap<String, Integer>())
399             .setEtag("etag3123477")
400             .putAllLabels(new HashMap<String, String>())
401             .setCreateTime(Timestamp.newBuilder().build())
402             .setUpdateTime(Timestamp.newBuilder().build())
403             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
404             .setNetwork("network1843485230")
405             .setEnablePrivateServiceConnect(true)
406             .setModelDeploymentMonitoringJob(
407                 ModelDeploymentMonitoringJobName.of(
408                         "[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]")
409                     .toString())
410             .setPredictRequestResponseLoggingConfig(
411                 PredictRequestResponseLoggingConfig.newBuilder().build())
412             .build();
413     mockEndpointService.addResponse(expectedResponse);
414 
415     EndpointName name =
416         EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
417 
418     Endpoint actualResponse = client.getEndpoint(name);
419     Assert.assertEquals(expectedResponse, actualResponse);
420 
421     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
422     Assert.assertEquals(1, actualRequests.size());
423     GetEndpointRequest actualRequest = ((GetEndpointRequest) actualRequests.get(0));
424 
425     Assert.assertEquals(name.toString(), actualRequest.getName());
426     Assert.assertTrue(
427         channelProvider.isHeaderSent(
428             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
429             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
430   }
431 
432   @Test
getEndpointExceptionTest()433   public void getEndpointExceptionTest() throws Exception {
434     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
435     mockEndpointService.addException(exception);
436 
437     try {
438       EndpointName name =
439           EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
440       client.getEndpoint(name);
441       Assert.fail("No exception raised");
442     } catch (InvalidArgumentException e) {
443       // Expected exception.
444     }
445   }
446 
447   @Test
getEndpointTest2()448   public void getEndpointTest2() throws Exception {
449     Endpoint expectedResponse =
450         Endpoint.newBuilder()
451             .setName(
452                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
453                     .toString())
454             .setDisplayName("displayName1714148973")
455             .setDescription("description-1724546052")
456             .addAllDeployedModels(new ArrayList<DeployedModel>())
457             .putAllTrafficSplit(new HashMap<String, Integer>())
458             .setEtag("etag3123477")
459             .putAllLabels(new HashMap<String, String>())
460             .setCreateTime(Timestamp.newBuilder().build())
461             .setUpdateTime(Timestamp.newBuilder().build())
462             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
463             .setNetwork("network1843485230")
464             .setEnablePrivateServiceConnect(true)
465             .setModelDeploymentMonitoringJob(
466                 ModelDeploymentMonitoringJobName.of(
467                         "[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]")
468                     .toString())
469             .setPredictRequestResponseLoggingConfig(
470                 PredictRequestResponseLoggingConfig.newBuilder().build())
471             .build();
472     mockEndpointService.addResponse(expectedResponse);
473 
474     String name = "name3373707";
475 
476     Endpoint actualResponse = client.getEndpoint(name);
477     Assert.assertEquals(expectedResponse, actualResponse);
478 
479     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
480     Assert.assertEquals(1, actualRequests.size());
481     GetEndpointRequest actualRequest = ((GetEndpointRequest) actualRequests.get(0));
482 
483     Assert.assertEquals(name, actualRequest.getName());
484     Assert.assertTrue(
485         channelProvider.isHeaderSent(
486             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
487             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
488   }
489 
490   @Test
getEndpointExceptionTest2()491   public void getEndpointExceptionTest2() throws Exception {
492     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
493     mockEndpointService.addException(exception);
494 
495     try {
496       String name = "name3373707";
497       client.getEndpoint(name);
498       Assert.fail("No exception raised");
499     } catch (InvalidArgumentException e) {
500       // Expected exception.
501     }
502   }
503 
504   @Test
listEndpointsTest()505   public void listEndpointsTest() throws Exception {
506     Endpoint responsesElement = Endpoint.newBuilder().build();
507     ListEndpointsResponse expectedResponse =
508         ListEndpointsResponse.newBuilder()
509             .setNextPageToken("")
510             .addAllEndpoints(Arrays.asList(responsesElement))
511             .build();
512     mockEndpointService.addResponse(expectedResponse);
513 
514     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
515 
516     ListEndpointsPagedResponse pagedListResponse = client.listEndpoints(parent);
517 
518     List<Endpoint> resources = Lists.newArrayList(pagedListResponse.iterateAll());
519 
520     Assert.assertEquals(1, resources.size());
521     Assert.assertEquals(expectedResponse.getEndpointsList().get(0), resources.get(0));
522 
523     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
524     Assert.assertEquals(1, actualRequests.size());
525     ListEndpointsRequest actualRequest = ((ListEndpointsRequest) actualRequests.get(0));
526 
527     Assert.assertEquals(parent.toString(), actualRequest.getParent());
528     Assert.assertTrue(
529         channelProvider.isHeaderSent(
530             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
531             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
532   }
533 
534   @Test
listEndpointsExceptionTest()535   public void listEndpointsExceptionTest() throws Exception {
536     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
537     mockEndpointService.addException(exception);
538 
539     try {
540       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
541       client.listEndpoints(parent);
542       Assert.fail("No exception raised");
543     } catch (InvalidArgumentException e) {
544       // Expected exception.
545     }
546   }
547 
548   @Test
listEndpointsTest2()549   public void listEndpointsTest2() throws Exception {
550     Endpoint responsesElement = Endpoint.newBuilder().build();
551     ListEndpointsResponse expectedResponse =
552         ListEndpointsResponse.newBuilder()
553             .setNextPageToken("")
554             .addAllEndpoints(Arrays.asList(responsesElement))
555             .build();
556     mockEndpointService.addResponse(expectedResponse);
557 
558     String parent = "parent-995424086";
559 
560     ListEndpointsPagedResponse pagedListResponse = client.listEndpoints(parent);
561 
562     List<Endpoint> resources = Lists.newArrayList(pagedListResponse.iterateAll());
563 
564     Assert.assertEquals(1, resources.size());
565     Assert.assertEquals(expectedResponse.getEndpointsList().get(0), resources.get(0));
566 
567     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
568     Assert.assertEquals(1, actualRequests.size());
569     ListEndpointsRequest actualRequest = ((ListEndpointsRequest) actualRequests.get(0));
570 
571     Assert.assertEquals(parent, actualRequest.getParent());
572     Assert.assertTrue(
573         channelProvider.isHeaderSent(
574             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
575             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
576   }
577 
578   @Test
listEndpointsExceptionTest2()579   public void listEndpointsExceptionTest2() throws Exception {
580     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
581     mockEndpointService.addException(exception);
582 
583     try {
584       String parent = "parent-995424086";
585       client.listEndpoints(parent);
586       Assert.fail("No exception raised");
587     } catch (InvalidArgumentException e) {
588       // Expected exception.
589     }
590   }
591 
592   @Test
updateEndpointTest()593   public void updateEndpointTest() throws Exception {
594     Endpoint expectedResponse =
595         Endpoint.newBuilder()
596             .setName(
597                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
598                     .toString())
599             .setDisplayName("displayName1714148973")
600             .setDescription("description-1724546052")
601             .addAllDeployedModels(new ArrayList<DeployedModel>())
602             .putAllTrafficSplit(new HashMap<String, Integer>())
603             .setEtag("etag3123477")
604             .putAllLabels(new HashMap<String, String>())
605             .setCreateTime(Timestamp.newBuilder().build())
606             .setUpdateTime(Timestamp.newBuilder().build())
607             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
608             .setNetwork("network1843485230")
609             .setEnablePrivateServiceConnect(true)
610             .setModelDeploymentMonitoringJob(
611                 ModelDeploymentMonitoringJobName.of(
612                         "[PROJECT]", "[LOCATION]", "[MODEL_DEPLOYMENT_MONITORING_JOB]")
613                     .toString())
614             .setPredictRequestResponseLoggingConfig(
615                 PredictRequestResponseLoggingConfig.newBuilder().build())
616             .build();
617     mockEndpointService.addResponse(expectedResponse);
618 
619     Endpoint endpoint = Endpoint.newBuilder().build();
620     FieldMask updateMask = FieldMask.newBuilder().build();
621 
622     Endpoint actualResponse = client.updateEndpoint(endpoint, updateMask);
623     Assert.assertEquals(expectedResponse, actualResponse);
624 
625     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
626     Assert.assertEquals(1, actualRequests.size());
627     UpdateEndpointRequest actualRequest = ((UpdateEndpointRequest) actualRequests.get(0));
628 
629     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
630     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
631     Assert.assertTrue(
632         channelProvider.isHeaderSent(
633             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
634             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
635   }
636 
637   @Test
updateEndpointExceptionTest()638   public void updateEndpointExceptionTest() throws Exception {
639     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
640     mockEndpointService.addException(exception);
641 
642     try {
643       Endpoint endpoint = Endpoint.newBuilder().build();
644       FieldMask updateMask = FieldMask.newBuilder().build();
645       client.updateEndpoint(endpoint, updateMask);
646       Assert.fail("No exception raised");
647     } catch (InvalidArgumentException e) {
648       // Expected exception.
649     }
650   }
651 
652   @Test
deleteEndpointTest()653   public void deleteEndpointTest() throws Exception {
654     Empty expectedResponse = Empty.newBuilder().build();
655     Operation resultOperation =
656         Operation.newBuilder()
657             .setName("deleteEndpointTest")
658             .setDone(true)
659             .setResponse(Any.pack(expectedResponse))
660             .build();
661     mockEndpointService.addResponse(resultOperation);
662 
663     EndpointName name =
664         EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
665 
666     client.deleteEndpointAsync(name).get();
667 
668     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
669     Assert.assertEquals(1, actualRequests.size());
670     DeleteEndpointRequest actualRequest = ((DeleteEndpointRequest) actualRequests.get(0));
671 
672     Assert.assertEquals(name.toString(), actualRequest.getName());
673     Assert.assertTrue(
674         channelProvider.isHeaderSent(
675             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
676             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
677   }
678 
679   @Test
deleteEndpointExceptionTest()680   public void deleteEndpointExceptionTest() throws Exception {
681     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
682     mockEndpointService.addException(exception);
683 
684     try {
685       EndpointName name =
686           EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
687       client.deleteEndpointAsync(name).get();
688       Assert.fail("No exception raised");
689     } catch (ExecutionException e) {
690       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
691       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
692       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
693     }
694   }
695 
696   @Test
deleteEndpointTest2()697   public void deleteEndpointTest2() throws Exception {
698     Empty expectedResponse = Empty.newBuilder().build();
699     Operation resultOperation =
700         Operation.newBuilder()
701             .setName("deleteEndpointTest")
702             .setDone(true)
703             .setResponse(Any.pack(expectedResponse))
704             .build();
705     mockEndpointService.addResponse(resultOperation);
706 
707     String name = "name3373707";
708 
709     client.deleteEndpointAsync(name).get();
710 
711     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
712     Assert.assertEquals(1, actualRequests.size());
713     DeleteEndpointRequest actualRequest = ((DeleteEndpointRequest) actualRequests.get(0));
714 
715     Assert.assertEquals(name, actualRequest.getName());
716     Assert.assertTrue(
717         channelProvider.isHeaderSent(
718             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
719             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
720   }
721 
722   @Test
deleteEndpointExceptionTest2()723   public void deleteEndpointExceptionTest2() throws Exception {
724     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
725     mockEndpointService.addException(exception);
726 
727     try {
728       String name = "name3373707";
729       client.deleteEndpointAsync(name).get();
730       Assert.fail("No exception raised");
731     } catch (ExecutionException e) {
732       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
733       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
734       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
735     }
736   }
737 
738   @Test
deployModelTest()739   public void deployModelTest() throws Exception {
740     DeployModelResponse expectedResponse =
741         DeployModelResponse.newBuilder()
742             .setDeployedModel(DeployedModel.newBuilder().build())
743             .build();
744     Operation resultOperation =
745         Operation.newBuilder()
746             .setName("deployModelTest")
747             .setDone(true)
748             .setResponse(Any.pack(expectedResponse))
749             .build();
750     mockEndpointService.addResponse(resultOperation);
751 
752     EndpointName endpoint =
753         EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
754     DeployedModel deployedModel = DeployedModel.newBuilder().build();
755     Map<String, Integer> trafficSplit = new HashMap<>();
756 
757     DeployModelResponse actualResponse =
758         client.deployModelAsync(endpoint, deployedModel, trafficSplit).get();
759     Assert.assertEquals(expectedResponse, actualResponse);
760 
761     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
762     Assert.assertEquals(1, actualRequests.size());
763     DeployModelRequest actualRequest = ((DeployModelRequest) actualRequests.get(0));
764 
765     Assert.assertEquals(endpoint.toString(), actualRequest.getEndpoint());
766     Assert.assertEquals(deployedModel, actualRequest.getDeployedModel());
767     Assert.assertEquals(trafficSplit, actualRequest.getTrafficSplitMap());
768     Assert.assertTrue(
769         channelProvider.isHeaderSent(
770             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
771             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
772   }
773 
774   @Test
deployModelExceptionTest()775   public void deployModelExceptionTest() throws Exception {
776     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
777     mockEndpointService.addException(exception);
778 
779     try {
780       EndpointName endpoint =
781           EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
782       DeployedModel deployedModel = DeployedModel.newBuilder().build();
783       Map<String, Integer> trafficSplit = new HashMap<>();
784       client.deployModelAsync(endpoint, deployedModel, trafficSplit).get();
785       Assert.fail("No exception raised");
786     } catch (ExecutionException e) {
787       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
788       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
789       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
790     }
791   }
792 
793   @Test
deployModelTest2()794   public void deployModelTest2() throws Exception {
795     DeployModelResponse expectedResponse =
796         DeployModelResponse.newBuilder()
797             .setDeployedModel(DeployedModel.newBuilder().build())
798             .build();
799     Operation resultOperation =
800         Operation.newBuilder()
801             .setName("deployModelTest")
802             .setDone(true)
803             .setResponse(Any.pack(expectedResponse))
804             .build();
805     mockEndpointService.addResponse(resultOperation);
806 
807     String endpoint = "endpoint1741102485";
808     DeployedModel deployedModel = DeployedModel.newBuilder().build();
809     Map<String, Integer> trafficSplit = new HashMap<>();
810 
811     DeployModelResponse actualResponse =
812         client.deployModelAsync(endpoint, deployedModel, trafficSplit).get();
813     Assert.assertEquals(expectedResponse, actualResponse);
814 
815     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
816     Assert.assertEquals(1, actualRequests.size());
817     DeployModelRequest actualRequest = ((DeployModelRequest) actualRequests.get(0));
818 
819     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
820     Assert.assertEquals(deployedModel, actualRequest.getDeployedModel());
821     Assert.assertEquals(trafficSplit, actualRequest.getTrafficSplitMap());
822     Assert.assertTrue(
823         channelProvider.isHeaderSent(
824             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
825             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
826   }
827 
828   @Test
deployModelExceptionTest2()829   public void deployModelExceptionTest2() throws Exception {
830     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
831     mockEndpointService.addException(exception);
832 
833     try {
834       String endpoint = "endpoint1741102485";
835       DeployedModel deployedModel = DeployedModel.newBuilder().build();
836       Map<String, Integer> trafficSplit = new HashMap<>();
837       client.deployModelAsync(endpoint, deployedModel, trafficSplit).get();
838       Assert.fail("No exception raised");
839     } catch (ExecutionException e) {
840       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
841       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
842       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
843     }
844   }
845 
846   @Test
undeployModelTest()847   public void undeployModelTest() throws Exception {
848     UndeployModelResponse expectedResponse = UndeployModelResponse.newBuilder().build();
849     Operation resultOperation =
850         Operation.newBuilder()
851             .setName("undeployModelTest")
852             .setDone(true)
853             .setResponse(Any.pack(expectedResponse))
854             .build();
855     mockEndpointService.addResponse(resultOperation);
856 
857     EndpointName endpoint =
858         EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
859     String deployedModelId = "deployedModelId-1817547906";
860     Map<String, Integer> trafficSplit = new HashMap<>();
861 
862     UndeployModelResponse actualResponse =
863         client.undeployModelAsync(endpoint, deployedModelId, trafficSplit).get();
864     Assert.assertEquals(expectedResponse, actualResponse);
865 
866     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
867     Assert.assertEquals(1, actualRequests.size());
868     UndeployModelRequest actualRequest = ((UndeployModelRequest) actualRequests.get(0));
869 
870     Assert.assertEquals(endpoint.toString(), actualRequest.getEndpoint());
871     Assert.assertEquals(deployedModelId, actualRequest.getDeployedModelId());
872     Assert.assertEquals(trafficSplit, actualRequest.getTrafficSplitMap());
873     Assert.assertTrue(
874         channelProvider.isHeaderSent(
875             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
876             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
877   }
878 
879   @Test
undeployModelExceptionTest()880   public void undeployModelExceptionTest() throws Exception {
881     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
882     mockEndpointService.addException(exception);
883 
884     try {
885       EndpointName endpoint =
886           EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
887       String deployedModelId = "deployedModelId-1817547906";
888       Map<String, Integer> trafficSplit = new HashMap<>();
889       client.undeployModelAsync(endpoint, deployedModelId, trafficSplit).get();
890       Assert.fail("No exception raised");
891     } catch (ExecutionException e) {
892       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
893       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
894       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
895     }
896   }
897 
898   @Test
undeployModelTest2()899   public void undeployModelTest2() throws Exception {
900     UndeployModelResponse expectedResponse = UndeployModelResponse.newBuilder().build();
901     Operation resultOperation =
902         Operation.newBuilder()
903             .setName("undeployModelTest")
904             .setDone(true)
905             .setResponse(Any.pack(expectedResponse))
906             .build();
907     mockEndpointService.addResponse(resultOperation);
908 
909     String endpoint = "endpoint1741102485";
910     String deployedModelId = "deployedModelId-1817547906";
911     Map<String, Integer> trafficSplit = new HashMap<>();
912 
913     UndeployModelResponse actualResponse =
914         client.undeployModelAsync(endpoint, deployedModelId, trafficSplit).get();
915     Assert.assertEquals(expectedResponse, actualResponse);
916 
917     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
918     Assert.assertEquals(1, actualRequests.size());
919     UndeployModelRequest actualRequest = ((UndeployModelRequest) actualRequests.get(0));
920 
921     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
922     Assert.assertEquals(deployedModelId, actualRequest.getDeployedModelId());
923     Assert.assertEquals(trafficSplit, actualRequest.getTrafficSplitMap());
924     Assert.assertTrue(
925         channelProvider.isHeaderSent(
926             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
927             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
928   }
929 
930   @Test
undeployModelExceptionTest2()931   public void undeployModelExceptionTest2() throws Exception {
932     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
933     mockEndpointService.addException(exception);
934 
935     try {
936       String endpoint = "endpoint1741102485";
937       String deployedModelId = "deployedModelId-1817547906";
938       Map<String, Integer> trafficSplit = new HashMap<>();
939       client.undeployModelAsync(endpoint, deployedModelId, trafficSplit).get();
940       Assert.fail("No exception raised");
941     } catch (ExecutionException e) {
942       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
943       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
944       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
945     }
946   }
947 
948   @Test
mutateDeployedModelTest()949   public void mutateDeployedModelTest() throws Exception {
950     MutateDeployedModelResponse expectedResponse =
951         MutateDeployedModelResponse.newBuilder()
952             .setDeployedModel(DeployedModel.newBuilder().build())
953             .build();
954     Operation resultOperation =
955         Operation.newBuilder()
956             .setName("mutateDeployedModelTest")
957             .setDone(true)
958             .setResponse(Any.pack(expectedResponse))
959             .build();
960     mockEndpointService.addResponse(resultOperation);
961 
962     EndpointName endpoint =
963         EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
964     DeployedModel deployedModel = DeployedModel.newBuilder().build();
965     FieldMask updateMask = FieldMask.newBuilder().build();
966 
967     MutateDeployedModelResponse actualResponse =
968         client.mutateDeployedModelAsync(endpoint, deployedModel, updateMask).get();
969     Assert.assertEquals(expectedResponse, actualResponse);
970 
971     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
972     Assert.assertEquals(1, actualRequests.size());
973     MutateDeployedModelRequest actualRequest = ((MutateDeployedModelRequest) actualRequests.get(0));
974 
975     Assert.assertEquals(endpoint.toString(), actualRequest.getEndpoint());
976     Assert.assertEquals(deployedModel, actualRequest.getDeployedModel());
977     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
978     Assert.assertTrue(
979         channelProvider.isHeaderSent(
980             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
981             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
982   }
983 
984   @Test
mutateDeployedModelExceptionTest()985   public void mutateDeployedModelExceptionTest() throws Exception {
986     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
987     mockEndpointService.addException(exception);
988 
989     try {
990       EndpointName endpoint =
991           EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]");
992       DeployedModel deployedModel = DeployedModel.newBuilder().build();
993       FieldMask updateMask = FieldMask.newBuilder().build();
994       client.mutateDeployedModelAsync(endpoint, deployedModel, updateMask).get();
995       Assert.fail("No exception raised");
996     } catch (ExecutionException e) {
997       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
998       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
999       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1000     }
1001   }
1002 
1003   @Test
mutateDeployedModelTest2()1004   public void mutateDeployedModelTest2() throws Exception {
1005     MutateDeployedModelResponse expectedResponse =
1006         MutateDeployedModelResponse.newBuilder()
1007             .setDeployedModel(DeployedModel.newBuilder().build())
1008             .build();
1009     Operation resultOperation =
1010         Operation.newBuilder()
1011             .setName("mutateDeployedModelTest")
1012             .setDone(true)
1013             .setResponse(Any.pack(expectedResponse))
1014             .build();
1015     mockEndpointService.addResponse(resultOperation);
1016 
1017     String endpoint = "endpoint1741102485";
1018     DeployedModel deployedModel = DeployedModel.newBuilder().build();
1019     FieldMask updateMask = FieldMask.newBuilder().build();
1020 
1021     MutateDeployedModelResponse actualResponse =
1022         client.mutateDeployedModelAsync(endpoint, deployedModel, updateMask).get();
1023     Assert.assertEquals(expectedResponse, actualResponse);
1024 
1025     List<AbstractMessage> actualRequests = mockEndpointService.getRequests();
1026     Assert.assertEquals(1, actualRequests.size());
1027     MutateDeployedModelRequest actualRequest = ((MutateDeployedModelRequest) actualRequests.get(0));
1028 
1029     Assert.assertEquals(endpoint, actualRequest.getEndpoint());
1030     Assert.assertEquals(deployedModel, actualRequest.getDeployedModel());
1031     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1032     Assert.assertTrue(
1033         channelProvider.isHeaderSent(
1034             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1035             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1036   }
1037 
1038   @Test
mutateDeployedModelExceptionTest2()1039   public void mutateDeployedModelExceptionTest2() throws Exception {
1040     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1041     mockEndpointService.addException(exception);
1042 
1043     try {
1044       String endpoint = "endpoint1741102485";
1045       DeployedModel deployedModel = DeployedModel.newBuilder().build();
1046       FieldMask updateMask = FieldMask.newBuilder().build();
1047       client.mutateDeployedModelAsync(endpoint, deployedModel, updateMask).get();
1048       Assert.fail("No exception raised");
1049     } catch (ExecutionException e) {
1050       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1051       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1052       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1053     }
1054   }
1055 
1056   @Test
listLocationsTest()1057   public void listLocationsTest() throws Exception {
1058     Location responsesElement = Location.newBuilder().build();
1059     ListLocationsResponse expectedResponse =
1060         ListLocationsResponse.newBuilder()
1061             .setNextPageToken("")
1062             .addAllLocations(Arrays.asList(responsesElement))
1063             .build();
1064     mockLocations.addResponse(expectedResponse);
1065 
1066     ListLocationsRequest request =
1067         ListLocationsRequest.newBuilder()
1068             .setName("name3373707")
1069             .setFilter("filter-1274492040")
1070             .setPageSize(883849137)
1071             .setPageToken("pageToken873572522")
1072             .build();
1073 
1074     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1075 
1076     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1077 
1078     Assert.assertEquals(1, resources.size());
1079     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1080 
1081     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1082     Assert.assertEquals(1, actualRequests.size());
1083     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1084 
1085     Assert.assertEquals(request.getName(), actualRequest.getName());
1086     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1087     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1088     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1089     Assert.assertTrue(
1090         channelProvider.isHeaderSent(
1091             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1092             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1093   }
1094 
1095   @Test
listLocationsExceptionTest()1096   public void listLocationsExceptionTest() throws Exception {
1097     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1098     mockLocations.addException(exception);
1099 
1100     try {
1101       ListLocationsRequest request =
1102           ListLocationsRequest.newBuilder()
1103               .setName("name3373707")
1104               .setFilter("filter-1274492040")
1105               .setPageSize(883849137)
1106               .setPageToken("pageToken873572522")
1107               .build();
1108       client.listLocations(request);
1109       Assert.fail("No exception raised");
1110     } catch (InvalidArgumentException e) {
1111       // Expected exception.
1112     }
1113   }
1114 
1115   @Test
getLocationTest()1116   public void getLocationTest() throws Exception {
1117     Location expectedResponse =
1118         Location.newBuilder()
1119             .setName("name3373707")
1120             .setLocationId("locationId1541836720")
1121             .setDisplayName("displayName1714148973")
1122             .putAllLabels(new HashMap<String, String>())
1123             .setMetadata(Any.newBuilder().build())
1124             .build();
1125     mockLocations.addResponse(expectedResponse);
1126 
1127     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1128 
1129     Location actualResponse = client.getLocation(request);
1130     Assert.assertEquals(expectedResponse, actualResponse);
1131 
1132     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1133     Assert.assertEquals(1, actualRequests.size());
1134     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1135 
1136     Assert.assertEquals(request.getName(), actualRequest.getName());
1137     Assert.assertTrue(
1138         channelProvider.isHeaderSent(
1139             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1140             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1141   }
1142 
1143   @Test
getLocationExceptionTest()1144   public void getLocationExceptionTest() throws Exception {
1145     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1146     mockLocations.addException(exception);
1147 
1148     try {
1149       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1150       client.getLocation(request);
1151       Assert.fail("No exception raised");
1152     } catch (InvalidArgumentException e) {
1153       // Expected exception.
1154     }
1155   }
1156 
1157   @Test
setIamPolicyTest()1158   public void setIamPolicyTest() throws Exception {
1159     Policy expectedResponse =
1160         Policy.newBuilder()
1161             .setVersion(351608024)
1162             .addAllBindings(new ArrayList<Binding>())
1163             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1164             .setEtag(ByteString.EMPTY)
1165             .build();
1166     mockIAMPolicy.addResponse(expectedResponse);
1167 
1168     SetIamPolicyRequest request =
1169         SetIamPolicyRequest.newBuilder()
1170             .setResource(
1171                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1172                     .toString())
1173             .setPolicy(Policy.newBuilder().build())
1174             .setUpdateMask(FieldMask.newBuilder().build())
1175             .build();
1176 
1177     Policy actualResponse = client.setIamPolicy(request);
1178     Assert.assertEquals(expectedResponse, actualResponse);
1179 
1180     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1181     Assert.assertEquals(1, actualRequests.size());
1182     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1183 
1184     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1185     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
1186     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
1187     Assert.assertTrue(
1188         channelProvider.isHeaderSent(
1189             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1190             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1191   }
1192 
1193   @Test
setIamPolicyExceptionTest()1194   public void setIamPolicyExceptionTest() throws Exception {
1195     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1196     mockIAMPolicy.addException(exception);
1197 
1198     try {
1199       SetIamPolicyRequest request =
1200           SetIamPolicyRequest.newBuilder()
1201               .setResource(
1202                   EndpointName.ofProjectLocationEndpointName(
1203                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1204                       .toString())
1205               .setPolicy(Policy.newBuilder().build())
1206               .setUpdateMask(FieldMask.newBuilder().build())
1207               .build();
1208       client.setIamPolicy(request);
1209       Assert.fail("No exception raised");
1210     } catch (InvalidArgumentException e) {
1211       // Expected exception.
1212     }
1213   }
1214 
1215   @Test
getIamPolicyTest()1216   public void getIamPolicyTest() throws Exception {
1217     Policy expectedResponse =
1218         Policy.newBuilder()
1219             .setVersion(351608024)
1220             .addAllBindings(new ArrayList<Binding>())
1221             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1222             .setEtag(ByteString.EMPTY)
1223             .build();
1224     mockIAMPolicy.addResponse(expectedResponse);
1225 
1226     GetIamPolicyRequest request =
1227         GetIamPolicyRequest.newBuilder()
1228             .setResource(
1229                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1230                     .toString())
1231             .setOptions(GetPolicyOptions.newBuilder().build())
1232             .build();
1233 
1234     Policy actualResponse = client.getIamPolicy(request);
1235     Assert.assertEquals(expectedResponse, actualResponse);
1236 
1237     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1238     Assert.assertEquals(1, actualRequests.size());
1239     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
1240 
1241     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1242     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
1243     Assert.assertTrue(
1244         channelProvider.isHeaderSent(
1245             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1246             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1247   }
1248 
1249   @Test
getIamPolicyExceptionTest()1250   public void getIamPolicyExceptionTest() throws Exception {
1251     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1252     mockIAMPolicy.addException(exception);
1253 
1254     try {
1255       GetIamPolicyRequest request =
1256           GetIamPolicyRequest.newBuilder()
1257               .setResource(
1258                   EndpointName.ofProjectLocationEndpointName(
1259                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1260                       .toString())
1261               .setOptions(GetPolicyOptions.newBuilder().build())
1262               .build();
1263       client.getIamPolicy(request);
1264       Assert.fail("No exception raised");
1265     } catch (InvalidArgumentException e) {
1266       // Expected exception.
1267     }
1268   }
1269 
1270   @Test
testIamPermissionsTest()1271   public void testIamPermissionsTest() throws Exception {
1272     TestIamPermissionsResponse expectedResponse =
1273         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1274     mockIAMPolicy.addResponse(expectedResponse);
1275 
1276     TestIamPermissionsRequest request =
1277         TestIamPermissionsRequest.newBuilder()
1278             .setResource(
1279                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1280                     .toString())
1281             .addAllPermissions(new ArrayList<String>())
1282             .build();
1283 
1284     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1285     Assert.assertEquals(expectedResponse, actualResponse);
1286 
1287     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1288     Assert.assertEquals(1, actualRequests.size());
1289     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
1290 
1291     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1292     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
1293     Assert.assertTrue(
1294         channelProvider.isHeaderSent(
1295             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1296             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1297   }
1298 
1299   @Test
testIamPermissionsExceptionTest()1300   public void testIamPermissionsExceptionTest() throws Exception {
1301     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1302     mockIAMPolicy.addException(exception);
1303 
1304     try {
1305       TestIamPermissionsRequest request =
1306           TestIamPermissionsRequest.newBuilder()
1307               .setResource(
1308                   EndpointName.ofProjectLocationEndpointName(
1309                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
1310                       .toString())
1311               .addAllPermissions(new ArrayList<String>())
1312               .build();
1313       client.testIamPermissions(request);
1314       Assert.fail("No exception raised");
1315     } catch (InvalidArgumentException e) {
1316       // Expected exception.
1317     }
1318   }
1319 }
1320