• 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.v1beta1;
18 
19 import static com.google.cloud.aiplatform.v1beta1.MetadataServiceClient.ListArtifactsPagedResponse;
20 import static com.google.cloud.aiplatform.v1beta1.MetadataServiceClient.ListContextsPagedResponse;
21 import static com.google.cloud.aiplatform.v1beta1.MetadataServiceClient.ListExecutionsPagedResponse;
22 import static com.google.cloud.aiplatform.v1beta1.MetadataServiceClient.ListLocationsPagedResponse;
23 import static com.google.cloud.aiplatform.v1beta1.MetadataServiceClient.ListMetadataSchemasPagedResponse;
24 import static com.google.cloud.aiplatform.v1beta1.MetadataServiceClient.ListMetadataStoresPagedResponse;
25 
26 import com.google.api.gax.core.NoCredentialsProvider;
27 import com.google.api.gax.grpc.GaxGrpcProperties;
28 import com.google.api.gax.grpc.testing.LocalChannelProvider;
29 import com.google.api.gax.grpc.testing.MockGrpcService;
30 import com.google.api.gax.grpc.testing.MockServiceHelper;
31 import com.google.api.gax.rpc.ApiClientHeaderProvider;
32 import com.google.api.gax.rpc.InvalidArgumentException;
33 import com.google.api.gax.rpc.StatusCode;
34 import com.google.cloud.location.GetLocationRequest;
35 import com.google.cloud.location.ListLocationsRequest;
36 import com.google.cloud.location.ListLocationsResponse;
37 import com.google.cloud.location.Location;
38 import com.google.common.collect.Lists;
39 import com.google.iam.v1.AuditConfig;
40 import com.google.iam.v1.Binding;
41 import com.google.iam.v1.GetIamPolicyRequest;
42 import com.google.iam.v1.GetPolicyOptions;
43 import com.google.iam.v1.Policy;
44 import com.google.iam.v1.SetIamPolicyRequest;
45 import com.google.iam.v1.TestIamPermissionsRequest;
46 import com.google.iam.v1.TestIamPermissionsResponse;
47 import com.google.longrunning.Operation;
48 import com.google.protobuf.AbstractMessage;
49 import com.google.protobuf.Any;
50 import com.google.protobuf.ByteString;
51 import com.google.protobuf.Empty;
52 import com.google.protobuf.FieldMask;
53 import com.google.protobuf.Struct;
54 import com.google.protobuf.Timestamp;
55 import io.grpc.StatusRuntimeException;
56 import java.io.IOException;
57 import java.util.ArrayList;
58 import java.util.Arrays;
59 import java.util.HashMap;
60 import java.util.List;
61 import java.util.UUID;
62 import java.util.concurrent.ExecutionException;
63 import javax.annotation.Generated;
64 import org.junit.After;
65 import org.junit.AfterClass;
66 import org.junit.Assert;
67 import org.junit.Before;
68 import org.junit.BeforeClass;
69 import org.junit.Test;
70 
71 @Generated("by gapic-generator-java")
72 public class MetadataServiceClientTest {
73   private static MockIAMPolicy mockIAMPolicy;
74   private static MockLocations mockLocations;
75   private static MockMetadataService mockMetadataService;
76   private static MockServiceHelper mockServiceHelper;
77   private LocalChannelProvider channelProvider;
78   private MetadataServiceClient client;
79 
80   @BeforeClass
startStaticServer()81   public static void startStaticServer() {
82     mockMetadataService = new MockMetadataService();
83     mockLocations = new MockLocations();
84     mockIAMPolicy = new MockIAMPolicy();
85     mockServiceHelper =
86         new MockServiceHelper(
87             UUID.randomUUID().toString(),
88             Arrays.<MockGrpcService>asList(mockMetadataService, mockLocations, mockIAMPolicy));
89     mockServiceHelper.start();
90   }
91 
92   @AfterClass
stopServer()93   public static void stopServer() {
94     mockServiceHelper.stop();
95   }
96 
97   @Before
setUp()98   public void setUp() throws IOException {
99     mockServiceHelper.reset();
100     channelProvider = mockServiceHelper.createChannelProvider();
101     MetadataServiceSettings settings =
102         MetadataServiceSettings.newBuilder()
103             .setTransportChannelProvider(channelProvider)
104             .setCredentialsProvider(NoCredentialsProvider.create())
105             .build();
106     client = MetadataServiceClient.create(settings);
107   }
108 
109   @After
tearDown()110   public void tearDown() throws Exception {
111     client.close();
112   }
113 
114   @Test
createMetadataStoreTest()115   public void createMetadataStoreTest() throws Exception {
116     MetadataStore expectedResponse =
117         MetadataStore.newBuilder()
118             .setName(MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]").toString())
119             .setCreateTime(Timestamp.newBuilder().build())
120             .setUpdateTime(Timestamp.newBuilder().build())
121             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
122             .setDescription("description-1724546052")
123             .setState(MetadataStore.MetadataStoreState.newBuilder().build())
124             .build();
125     Operation resultOperation =
126         Operation.newBuilder()
127             .setName("createMetadataStoreTest")
128             .setDone(true)
129             .setResponse(Any.pack(expectedResponse))
130             .build();
131     mockMetadataService.addResponse(resultOperation);
132 
133     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
134     MetadataStore metadataStore = MetadataStore.newBuilder().build();
135     String metadataStoreId = "metadataStoreId-1811789907";
136 
137     MetadataStore actualResponse =
138         client.createMetadataStoreAsync(parent, metadataStore, metadataStoreId).get();
139     Assert.assertEquals(expectedResponse, actualResponse);
140 
141     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
142     Assert.assertEquals(1, actualRequests.size());
143     CreateMetadataStoreRequest actualRequest = ((CreateMetadataStoreRequest) actualRequests.get(0));
144 
145     Assert.assertEquals(parent.toString(), actualRequest.getParent());
146     Assert.assertEquals(metadataStore, actualRequest.getMetadataStore());
147     Assert.assertEquals(metadataStoreId, actualRequest.getMetadataStoreId());
148     Assert.assertTrue(
149         channelProvider.isHeaderSent(
150             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
151             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
152   }
153 
154   @Test
createMetadataStoreExceptionTest()155   public void createMetadataStoreExceptionTest() throws Exception {
156     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
157     mockMetadataService.addException(exception);
158 
159     try {
160       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
161       MetadataStore metadataStore = MetadataStore.newBuilder().build();
162       String metadataStoreId = "metadataStoreId-1811789907";
163       client.createMetadataStoreAsync(parent, metadataStore, metadataStoreId).get();
164       Assert.fail("No exception raised");
165     } catch (ExecutionException e) {
166       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
167       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
168       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
169     }
170   }
171 
172   @Test
createMetadataStoreTest2()173   public void createMetadataStoreTest2() throws Exception {
174     MetadataStore expectedResponse =
175         MetadataStore.newBuilder()
176             .setName(MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]").toString())
177             .setCreateTime(Timestamp.newBuilder().build())
178             .setUpdateTime(Timestamp.newBuilder().build())
179             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
180             .setDescription("description-1724546052")
181             .setState(MetadataStore.MetadataStoreState.newBuilder().build())
182             .build();
183     Operation resultOperation =
184         Operation.newBuilder()
185             .setName("createMetadataStoreTest")
186             .setDone(true)
187             .setResponse(Any.pack(expectedResponse))
188             .build();
189     mockMetadataService.addResponse(resultOperation);
190 
191     String parent = "parent-995424086";
192     MetadataStore metadataStore = MetadataStore.newBuilder().build();
193     String metadataStoreId = "metadataStoreId-1811789907";
194 
195     MetadataStore actualResponse =
196         client.createMetadataStoreAsync(parent, metadataStore, metadataStoreId).get();
197     Assert.assertEquals(expectedResponse, actualResponse);
198 
199     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
200     Assert.assertEquals(1, actualRequests.size());
201     CreateMetadataStoreRequest actualRequest = ((CreateMetadataStoreRequest) actualRequests.get(0));
202 
203     Assert.assertEquals(parent, actualRequest.getParent());
204     Assert.assertEquals(metadataStore, actualRequest.getMetadataStore());
205     Assert.assertEquals(metadataStoreId, actualRequest.getMetadataStoreId());
206     Assert.assertTrue(
207         channelProvider.isHeaderSent(
208             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
209             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
210   }
211 
212   @Test
createMetadataStoreExceptionTest2()213   public void createMetadataStoreExceptionTest2() throws Exception {
214     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
215     mockMetadataService.addException(exception);
216 
217     try {
218       String parent = "parent-995424086";
219       MetadataStore metadataStore = MetadataStore.newBuilder().build();
220       String metadataStoreId = "metadataStoreId-1811789907";
221       client.createMetadataStoreAsync(parent, metadataStore, metadataStoreId).get();
222       Assert.fail("No exception raised");
223     } catch (ExecutionException e) {
224       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
225       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
226       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
227     }
228   }
229 
230   @Test
getMetadataStoreTest()231   public void getMetadataStoreTest() throws Exception {
232     MetadataStore expectedResponse =
233         MetadataStore.newBuilder()
234             .setName(MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]").toString())
235             .setCreateTime(Timestamp.newBuilder().build())
236             .setUpdateTime(Timestamp.newBuilder().build())
237             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
238             .setDescription("description-1724546052")
239             .setState(MetadataStore.MetadataStoreState.newBuilder().build())
240             .build();
241     mockMetadataService.addResponse(expectedResponse);
242 
243     MetadataStoreName name = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
244 
245     MetadataStore actualResponse = client.getMetadataStore(name);
246     Assert.assertEquals(expectedResponse, actualResponse);
247 
248     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
249     Assert.assertEquals(1, actualRequests.size());
250     GetMetadataStoreRequest actualRequest = ((GetMetadataStoreRequest) actualRequests.get(0));
251 
252     Assert.assertEquals(name.toString(), actualRequest.getName());
253     Assert.assertTrue(
254         channelProvider.isHeaderSent(
255             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
256             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
257   }
258 
259   @Test
getMetadataStoreExceptionTest()260   public void getMetadataStoreExceptionTest() throws Exception {
261     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
262     mockMetadataService.addException(exception);
263 
264     try {
265       MetadataStoreName name = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
266       client.getMetadataStore(name);
267       Assert.fail("No exception raised");
268     } catch (InvalidArgumentException e) {
269       // Expected exception.
270     }
271   }
272 
273   @Test
getMetadataStoreTest2()274   public void getMetadataStoreTest2() throws Exception {
275     MetadataStore expectedResponse =
276         MetadataStore.newBuilder()
277             .setName(MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]").toString())
278             .setCreateTime(Timestamp.newBuilder().build())
279             .setUpdateTime(Timestamp.newBuilder().build())
280             .setEncryptionSpec(EncryptionSpec.newBuilder().build())
281             .setDescription("description-1724546052")
282             .setState(MetadataStore.MetadataStoreState.newBuilder().build())
283             .build();
284     mockMetadataService.addResponse(expectedResponse);
285 
286     String name = "name3373707";
287 
288     MetadataStore actualResponse = client.getMetadataStore(name);
289     Assert.assertEquals(expectedResponse, actualResponse);
290 
291     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
292     Assert.assertEquals(1, actualRequests.size());
293     GetMetadataStoreRequest actualRequest = ((GetMetadataStoreRequest) actualRequests.get(0));
294 
295     Assert.assertEquals(name, actualRequest.getName());
296     Assert.assertTrue(
297         channelProvider.isHeaderSent(
298             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
299             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
300   }
301 
302   @Test
getMetadataStoreExceptionTest2()303   public void getMetadataStoreExceptionTest2() throws Exception {
304     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
305     mockMetadataService.addException(exception);
306 
307     try {
308       String name = "name3373707";
309       client.getMetadataStore(name);
310       Assert.fail("No exception raised");
311     } catch (InvalidArgumentException e) {
312       // Expected exception.
313     }
314   }
315 
316   @Test
listMetadataStoresTest()317   public void listMetadataStoresTest() throws Exception {
318     MetadataStore responsesElement = MetadataStore.newBuilder().build();
319     ListMetadataStoresResponse expectedResponse =
320         ListMetadataStoresResponse.newBuilder()
321             .setNextPageToken("")
322             .addAllMetadataStores(Arrays.asList(responsesElement))
323             .build();
324     mockMetadataService.addResponse(expectedResponse);
325 
326     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
327 
328     ListMetadataStoresPagedResponse pagedListResponse = client.listMetadataStores(parent);
329 
330     List<MetadataStore> resources = Lists.newArrayList(pagedListResponse.iterateAll());
331 
332     Assert.assertEquals(1, resources.size());
333     Assert.assertEquals(expectedResponse.getMetadataStoresList().get(0), resources.get(0));
334 
335     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
336     Assert.assertEquals(1, actualRequests.size());
337     ListMetadataStoresRequest actualRequest = ((ListMetadataStoresRequest) actualRequests.get(0));
338 
339     Assert.assertEquals(parent.toString(), actualRequest.getParent());
340     Assert.assertTrue(
341         channelProvider.isHeaderSent(
342             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
343             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
344   }
345 
346   @Test
listMetadataStoresExceptionTest()347   public void listMetadataStoresExceptionTest() throws Exception {
348     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
349     mockMetadataService.addException(exception);
350 
351     try {
352       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
353       client.listMetadataStores(parent);
354       Assert.fail("No exception raised");
355     } catch (InvalidArgumentException e) {
356       // Expected exception.
357     }
358   }
359 
360   @Test
listMetadataStoresTest2()361   public void listMetadataStoresTest2() throws Exception {
362     MetadataStore responsesElement = MetadataStore.newBuilder().build();
363     ListMetadataStoresResponse expectedResponse =
364         ListMetadataStoresResponse.newBuilder()
365             .setNextPageToken("")
366             .addAllMetadataStores(Arrays.asList(responsesElement))
367             .build();
368     mockMetadataService.addResponse(expectedResponse);
369 
370     String parent = "parent-995424086";
371 
372     ListMetadataStoresPagedResponse pagedListResponse = client.listMetadataStores(parent);
373 
374     List<MetadataStore> resources = Lists.newArrayList(pagedListResponse.iterateAll());
375 
376     Assert.assertEquals(1, resources.size());
377     Assert.assertEquals(expectedResponse.getMetadataStoresList().get(0), resources.get(0));
378 
379     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
380     Assert.assertEquals(1, actualRequests.size());
381     ListMetadataStoresRequest actualRequest = ((ListMetadataStoresRequest) actualRequests.get(0));
382 
383     Assert.assertEquals(parent, actualRequest.getParent());
384     Assert.assertTrue(
385         channelProvider.isHeaderSent(
386             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
387             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
388   }
389 
390   @Test
listMetadataStoresExceptionTest2()391   public void listMetadataStoresExceptionTest2() throws Exception {
392     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
393     mockMetadataService.addException(exception);
394 
395     try {
396       String parent = "parent-995424086";
397       client.listMetadataStores(parent);
398       Assert.fail("No exception raised");
399     } catch (InvalidArgumentException e) {
400       // Expected exception.
401     }
402   }
403 
404   @Test
deleteMetadataStoreTest()405   public void deleteMetadataStoreTest() throws Exception {
406     Empty expectedResponse = Empty.newBuilder().build();
407     Operation resultOperation =
408         Operation.newBuilder()
409             .setName("deleteMetadataStoreTest")
410             .setDone(true)
411             .setResponse(Any.pack(expectedResponse))
412             .build();
413     mockMetadataService.addResponse(resultOperation);
414 
415     MetadataStoreName name = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
416 
417     client.deleteMetadataStoreAsync(name).get();
418 
419     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
420     Assert.assertEquals(1, actualRequests.size());
421     DeleteMetadataStoreRequest actualRequest = ((DeleteMetadataStoreRequest) actualRequests.get(0));
422 
423     Assert.assertEquals(name.toString(), actualRequest.getName());
424     Assert.assertTrue(
425         channelProvider.isHeaderSent(
426             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
427             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
428   }
429 
430   @Test
deleteMetadataStoreExceptionTest()431   public void deleteMetadataStoreExceptionTest() throws Exception {
432     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
433     mockMetadataService.addException(exception);
434 
435     try {
436       MetadataStoreName name = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
437       client.deleteMetadataStoreAsync(name).get();
438       Assert.fail("No exception raised");
439     } catch (ExecutionException e) {
440       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
441       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
442       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
443     }
444   }
445 
446   @Test
deleteMetadataStoreTest2()447   public void deleteMetadataStoreTest2() throws Exception {
448     Empty expectedResponse = Empty.newBuilder().build();
449     Operation resultOperation =
450         Operation.newBuilder()
451             .setName("deleteMetadataStoreTest")
452             .setDone(true)
453             .setResponse(Any.pack(expectedResponse))
454             .build();
455     mockMetadataService.addResponse(resultOperation);
456 
457     String name = "name3373707";
458 
459     client.deleteMetadataStoreAsync(name).get();
460 
461     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
462     Assert.assertEquals(1, actualRequests.size());
463     DeleteMetadataStoreRequest actualRequest = ((DeleteMetadataStoreRequest) actualRequests.get(0));
464 
465     Assert.assertEquals(name, actualRequest.getName());
466     Assert.assertTrue(
467         channelProvider.isHeaderSent(
468             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
469             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
470   }
471 
472   @Test
deleteMetadataStoreExceptionTest2()473   public void deleteMetadataStoreExceptionTest2() throws Exception {
474     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
475     mockMetadataService.addException(exception);
476 
477     try {
478       String name = "name3373707";
479       client.deleteMetadataStoreAsync(name).get();
480       Assert.fail("No exception raised");
481     } catch (ExecutionException e) {
482       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
483       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
484       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
485     }
486   }
487 
488   @Test
createArtifactTest()489   public void createArtifactTest() throws Exception {
490     Artifact expectedResponse =
491         Artifact.newBuilder()
492             .setName(
493                 ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]")
494                     .toString())
495             .setDisplayName("displayName1714148973")
496             .setUri("uri116076")
497             .setEtag("etag3123477")
498             .putAllLabels(new HashMap<String, String>())
499             .setCreateTime(Timestamp.newBuilder().build())
500             .setUpdateTime(Timestamp.newBuilder().build())
501             .setSchemaTitle("schemaTitle-1020962505")
502             .setSchemaVersion("schemaVersion-233564169")
503             .setMetadata(Struct.newBuilder().build())
504             .setDescription("description-1724546052")
505             .build();
506     mockMetadataService.addResponse(expectedResponse);
507 
508     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
509     Artifact artifact = Artifact.newBuilder().build();
510     String artifactId = "artifactId240640653";
511 
512     Artifact actualResponse = client.createArtifact(parent, artifact, artifactId);
513     Assert.assertEquals(expectedResponse, actualResponse);
514 
515     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
516     Assert.assertEquals(1, actualRequests.size());
517     CreateArtifactRequest actualRequest = ((CreateArtifactRequest) actualRequests.get(0));
518 
519     Assert.assertEquals(parent.toString(), actualRequest.getParent());
520     Assert.assertEquals(artifact, actualRequest.getArtifact());
521     Assert.assertEquals(artifactId, actualRequest.getArtifactId());
522     Assert.assertTrue(
523         channelProvider.isHeaderSent(
524             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
525             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
526   }
527 
528   @Test
createArtifactExceptionTest()529   public void createArtifactExceptionTest() throws Exception {
530     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
531     mockMetadataService.addException(exception);
532 
533     try {
534       MetadataStoreName parent =
535           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
536       Artifact artifact = Artifact.newBuilder().build();
537       String artifactId = "artifactId240640653";
538       client.createArtifact(parent, artifact, artifactId);
539       Assert.fail("No exception raised");
540     } catch (InvalidArgumentException e) {
541       // Expected exception.
542     }
543   }
544 
545   @Test
createArtifactTest2()546   public void createArtifactTest2() throws Exception {
547     Artifact expectedResponse =
548         Artifact.newBuilder()
549             .setName(
550                 ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]")
551                     .toString())
552             .setDisplayName("displayName1714148973")
553             .setUri("uri116076")
554             .setEtag("etag3123477")
555             .putAllLabels(new HashMap<String, String>())
556             .setCreateTime(Timestamp.newBuilder().build())
557             .setUpdateTime(Timestamp.newBuilder().build())
558             .setSchemaTitle("schemaTitle-1020962505")
559             .setSchemaVersion("schemaVersion-233564169")
560             .setMetadata(Struct.newBuilder().build())
561             .setDescription("description-1724546052")
562             .build();
563     mockMetadataService.addResponse(expectedResponse);
564 
565     String parent = "parent-995424086";
566     Artifact artifact = Artifact.newBuilder().build();
567     String artifactId = "artifactId240640653";
568 
569     Artifact actualResponse = client.createArtifact(parent, artifact, artifactId);
570     Assert.assertEquals(expectedResponse, actualResponse);
571 
572     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
573     Assert.assertEquals(1, actualRequests.size());
574     CreateArtifactRequest actualRequest = ((CreateArtifactRequest) actualRequests.get(0));
575 
576     Assert.assertEquals(parent, actualRequest.getParent());
577     Assert.assertEquals(artifact, actualRequest.getArtifact());
578     Assert.assertEquals(artifactId, actualRequest.getArtifactId());
579     Assert.assertTrue(
580         channelProvider.isHeaderSent(
581             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
582             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
583   }
584 
585   @Test
createArtifactExceptionTest2()586   public void createArtifactExceptionTest2() throws Exception {
587     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
588     mockMetadataService.addException(exception);
589 
590     try {
591       String parent = "parent-995424086";
592       Artifact artifact = Artifact.newBuilder().build();
593       String artifactId = "artifactId240640653";
594       client.createArtifact(parent, artifact, artifactId);
595       Assert.fail("No exception raised");
596     } catch (InvalidArgumentException e) {
597       // Expected exception.
598     }
599   }
600 
601   @Test
getArtifactTest()602   public void getArtifactTest() throws Exception {
603     Artifact expectedResponse =
604         Artifact.newBuilder()
605             .setName(
606                 ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]")
607                     .toString())
608             .setDisplayName("displayName1714148973")
609             .setUri("uri116076")
610             .setEtag("etag3123477")
611             .putAllLabels(new HashMap<String, String>())
612             .setCreateTime(Timestamp.newBuilder().build())
613             .setUpdateTime(Timestamp.newBuilder().build())
614             .setSchemaTitle("schemaTitle-1020962505")
615             .setSchemaVersion("schemaVersion-233564169")
616             .setMetadata(Struct.newBuilder().build())
617             .setDescription("description-1724546052")
618             .build();
619     mockMetadataService.addResponse(expectedResponse);
620 
621     ArtifactName name =
622         ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
623 
624     Artifact actualResponse = client.getArtifact(name);
625     Assert.assertEquals(expectedResponse, actualResponse);
626 
627     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
628     Assert.assertEquals(1, actualRequests.size());
629     GetArtifactRequest actualRequest = ((GetArtifactRequest) actualRequests.get(0));
630 
631     Assert.assertEquals(name.toString(), actualRequest.getName());
632     Assert.assertTrue(
633         channelProvider.isHeaderSent(
634             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
635             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
636   }
637 
638   @Test
getArtifactExceptionTest()639   public void getArtifactExceptionTest() throws Exception {
640     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
641     mockMetadataService.addException(exception);
642 
643     try {
644       ArtifactName name =
645           ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
646       client.getArtifact(name);
647       Assert.fail("No exception raised");
648     } catch (InvalidArgumentException e) {
649       // Expected exception.
650     }
651   }
652 
653   @Test
getArtifactTest2()654   public void getArtifactTest2() throws Exception {
655     Artifact expectedResponse =
656         Artifact.newBuilder()
657             .setName(
658                 ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]")
659                     .toString())
660             .setDisplayName("displayName1714148973")
661             .setUri("uri116076")
662             .setEtag("etag3123477")
663             .putAllLabels(new HashMap<String, String>())
664             .setCreateTime(Timestamp.newBuilder().build())
665             .setUpdateTime(Timestamp.newBuilder().build())
666             .setSchemaTitle("schemaTitle-1020962505")
667             .setSchemaVersion("schemaVersion-233564169")
668             .setMetadata(Struct.newBuilder().build())
669             .setDescription("description-1724546052")
670             .build();
671     mockMetadataService.addResponse(expectedResponse);
672 
673     String name = "name3373707";
674 
675     Artifact actualResponse = client.getArtifact(name);
676     Assert.assertEquals(expectedResponse, actualResponse);
677 
678     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
679     Assert.assertEquals(1, actualRequests.size());
680     GetArtifactRequest actualRequest = ((GetArtifactRequest) actualRequests.get(0));
681 
682     Assert.assertEquals(name, actualRequest.getName());
683     Assert.assertTrue(
684         channelProvider.isHeaderSent(
685             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
686             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
687   }
688 
689   @Test
getArtifactExceptionTest2()690   public void getArtifactExceptionTest2() throws Exception {
691     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
692     mockMetadataService.addException(exception);
693 
694     try {
695       String name = "name3373707";
696       client.getArtifact(name);
697       Assert.fail("No exception raised");
698     } catch (InvalidArgumentException e) {
699       // Expected exception.
700     }
701   }
702 
703   @Test
listArtifactsTest()704   public void listArtifactsTest() throws Exception {
705     Artifact responsesElement = Artifact.newBuilder().build();
706     ListArtifactsResponse expectedResponse =
707         ListArtifactsResponse.newBuilder()
708             .setNextPageToken("")
709             .addAllArtifacts(Arrays.asList(responsesElement))
710             .build();
711     mockMetadataService.addResponse(expectedResponse);
712 
713     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
714 
715     ListArtifactsPagedResponse pagedListResponse = client.listArtifacts(parent);
716 
717     List<Artifact> resources = Lists.newArrayList(pagedListResponse.iterateAll());
718 
719     Assert.assertEquals(1, resources.size());
720     Assert.assertEquals(expectedResponse.getArtifactsList().get(0), resources.get(0));
721 
722     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
723     Assert.assertEquals(1, actualRequests.size());
724     ListArtifactsRequest actualRequest = ((ListArtifactsRequest) actualRequests.get(0));
725 
726     Assert.assertEquals(parent.toString(), actualRequest.getParent());
727     Assert.assertTrue(
728         channelProvider.isHeaderSent(
729             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
730             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
731   }
732 
733   @Test
listArtifactsExceptionTest()734   public void listArtifactsExceptionTest() throws Exception {
735     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
736     mockMetadataService.addException(exception);
737 
738     try {
739       MetadataStoreName parent =
740           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
741       client.listArtifacts(parent);
742       Assert.fail("No exception raised");
743     } catch (InvalidArgumentException e) {
744       // Expected exception.
745     }
746   }
747 
748   @Test
listArtifactsTest2()749   public void listArtifactsTest2() throws Exception {
750     Artifact responsesElement = Artifact.newBuilder().build();
751     ListArtifactsResponse expectedResponse =
752         ListArtifactsResponse.newBuilder()
753             .setNextPageToken("")
754             .addAllArtifacts(Arrays.asList(responsesElement))
755             .build();
756     mockMetadataService.addResponse(expectedResponse);
757 
758     String parent = "parent-995424086";
759 
760     ListArtifactsPagedResponse pagedListResponse = client.listArtifacts(parent);
761 
762     List<Artifact> resources = Lists.newArrayList(pagedListResponse.iterateAll());
763 
764     Assert.assertEquals(1, resources.size());
765     Assert.assertEquals(expectedResponse.getArtifactsList().get(0), resources.get(0));
766 
767     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
768     Assert.assertEquals(1, actualRequests.size());
769     ListArtifactsRequest actualRequest = ((ListArtifactsRequest) actualRequests.get(0));
770 
771     Assert.assertEquals(parent, actualRequest.getParent());
772     Assert.assertTrue(
773         channelProvider.isHeaderSent(
774             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
775             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
776   }
777 
778   @Test
listArtifactsExceptionTest2()779   public void listArtifactsExceptionTest2() throws Exception {
780     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
781     mockMetadataService.addException(exception);
782 
783     try {
784       String parent = "parent-995424086";
785       client.listArtifacts(parent);
786       Assert.fail("No exception raised");
787     } catch (InvalidArgumentException e) {
788       // Expected exception.
789     }
790   }
791 
792   @Test
updateArtifactTest()793   public void updateArtifactTest() throws Exception {
794     Artifact expectedResponse =
795         Artifact.newBuilder()
796             .setName(
797                 ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]")
798                     .toString())
799             .setDisplayName("displayName1714148973")
800             .setUri("uri116076")
801             .setEtag("etag3123477")
802             .putAllLabels(new HashMap<String, String>())
803             .setCreateTime(Timestamp.newBuilder().build())
804             .setUpdateTime(Timestamp.newBuilder().build())
805             .setSchemaTitle("schemaTitle-1020962505")
806             .setSchemaVersion("schemaVersion-233564169")
807             .setMetadata(Struct.newBuilder().build())
808             .setDescription("description-1724546052")
809             .build();
810     mockMetadataService.addResponse(expectedResponse);
811 
812     Artifact artifact = Artifact.newBuilder().build();
813     FieldMask updateMask = FieldMask.newBuilder().build();
814 
815     Artifact actualResponse = client.updateArtifact(artifact, updateMask);
816     Assert.assertEquals(expectedResponse, actualResponse);
817 
818     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
819     Assert.assertEquals(1, actualRequests.size());
820     UpdateArtifactRequest actualRequest = ((UpdateArtifactRequest) actualRequests.get(0));
821 
822     Assert.assertEquals(artifact, actualRequest.getArtifact());
823     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
824     Assert.assertTrue(
825         channelProvider.isHeaderSent(
826             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
827             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
828   }
829 
830   @Test
updateArtifactExceptionTest()831   public void updateArtifactExceptionTest() throws Exception {
832     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
833     mockMetadataService.addException(exception);
834 
835     try {
836       Artifact artifact = Artifact.newBuilder().build();
837       FieldMask updateMask = FieldMask.newBuilder().build();
838       client.updateArtifact(artifact, updateMask);
839       Assert.fail("No exception raised");
840     } catch (InvalidArgumentException e) {
841       // Expected exception.
842     }
843   }
844 
845   @Test
deleteArtifactTest()846   public void deleteArtifactTest() throws Exception {
847     Empty expectedResponse = Empty.newBuilder().build();
848     Operation resultOperation =
849         Operation.newBuilder()
850             .setName("deleteArtifactTest")
851             .setDone(true)
852             .setResponse(Any.pack(expectedResponse))
853             .build();
854     mockMetadataService.addResponse(resultOperation);
855 
856     ArtifactName name =
857         ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
858 
859     client.deleteArtifactAsync(name).get();
860 
861     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
862     Assert.assertEquals(1, actualRequests.size());
863     DeleteArtifactRequest actualRequest = ((DeleteArtifactRequest) actualRequests.get(0));
864 
865     Assert.assertEquals(name.toString(), actualRequest.getName());
866     Assert.assertTrue(
867         channelProvider.isHeaderSent(
868             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
869             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
870   }
871 
872   @Test
deleteArtifactExceptionTest()873   public void deleteArtifactExceptionTest() throws Exception {
874     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
875     mockMetadataService.addException(exception);
876 
877     try {
878       ArtifactName name =
879           ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
880       client.deleteArtifactAsync(name).get();
881       Assert.fail("No exception raised");
882     } catch (ExecutionException e) {
883       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
884       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
885       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
886     }
887   }
888 
889   @Test
deleteArtifactTest2()890   public void deleteArtifactTest2() throws Exception {
891     Empty expectedResponse = Empty.newBuilder().build();
892     Operation resultOperation =
893         Operation.newBuilder()
894             .setName("deleteArtifactTest")
895             .setDone(true)
896             .setResponse(Any.pack(expectedResponse))
897             .build();
898     mockMetadataService.addResponse(resultOperation);
899 
900     String name = "name3373707";
901 
902     client.deleteArtifactAsync(name).get();
903 
904     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
905     Assert.assertEquals(1, actualRequests.size());
906     DeleteArtifactRequest actualRequest = ((DeleteArtifactRequest) actualRequests.get(0));
907 
908     Assert.assertEquals(name, actualRequest.getName());
909     Assert.assertTrue(
910         channelProvider.isHeaderSent(
911             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
912             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
913   }
914 
915   @Test
deleteArtifactExceptionTest2()916   public void deleteArtifactExceptionTest2() throws Exception {
917     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
918     mockMetadataService.addException(exception);
919 
920     try {
921       String name = "name3373707";
922       client.deleteArtifactAsync(name).get();
923       Assert.fail("No exception raised");
924     } catch (ExecutionException e) {
925       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
926       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
927       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
928     }
929   }
930 
931   @Test
purgeArtifactsTest()932   public void purgeArtifactsTest() throws Exception {
933     PurgeArtifactsResponse expectedResponse =
934         PurgeArtifactsResponse.newBuilder()
935             .setPurgeCount(575305851)
936             .addAllPurgeSample(new ArrayList<String>())
937             .build();
938     Operation resultOperation =
939         Operation.newBuilder()
940             .setName("purgeArtifactsTest")
941             .setDone(true)
942             .setResponse(Any.pack(expectedResponse))
943             .build();
944     mockMetadataService.addResponse(resultOperation);
945 
946     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
947 
948     PurgeArtifactsResponse actualResponse = client.purgeArtifactsAsync(parent).get();
949     Assert.assertEquals(expectedResponse, actualResponse);
950 
951     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
952     Assert.assertEquals(1, actualRequests.size());
953     PurgeArtifactsRequest actualRequest = ((PurgeArtifactsRequest) actualRequests.get(0));
954 
955     Assert.assertEquals(parent.toString(), actualRequest.getParent());
956     Assert.assertTrue(
957         channelProvider.isHeaderSent(
958             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
959             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
960   }
961 
962   @Test
purgeArtifactsExceptionTest()963   public void purgeArtifactsExceptionTest() throws Exception {
964     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
965     mockMetadataService.addException(exception);
966 
967     try {
968       MetadataStoreName parent =
969           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
970       client.purgeArtifactsAsync(parent).get();
971       Assert.fail("No exception raised");
972     } catch (ExecutionException e) {
973       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
974       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
975       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
976     }
977   }
978 
979   @Test
purgeArtifactsTest2()980   public void purgeArtifactsTest2() throws Exception {
981     PurgeArtifactsResponse expectedResponse =
982         PurgeArtifactsResponse.newBuilder()
983             .setPurgeCount(575305851)
984             .addAllPurgeSample(new ArrayList<String>())
985             .build();
986     Operation resultOperation =
987         Operation.newBuilder()
988             .setName("purgeArtifactsTest")
989             .setDone(true)
990             .setResponse(Any.pack(expectedResponse))
991             .build();
992     mockMetadataService.addResponse(resultOperation);
993 
994     String parent = "parent-995424086";
995 
996     PurgeArtifactsResponse actualResponse = client.purgeArtifactsAsync(parent).get();
997     Assert.assertEquals(expectedResponse, actualResponse);
998 
999     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1000     Assert.assertEquals(1, actualRequests.size());
1001     PurgeArtifactsRequest actualRequest = ((PurgeArtifactsRequest) actualRequests.get(0));
1002 
1003     Assert.assertEquals(parent, actualRequest.getParent());
1004     Assert.assertTrue(
1005         channelProvider.isHeaderSent(
1006             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1007             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1008   }
1009 
1010   @Test
purgeArtifactsExceptionTest2()1011   public void purgeArtifactsExceptionTest2() throws Exception {
1012     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1013     mockMetadataService.addException(exception);
1014 
1015     try {
1016       String parent = "parent-995424086";
1017       client.purgeArtifactsAsync(parent).get();
1018       Assert.fail("No exception raised");
1019     } catch (ExecutionException e) {
1020       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1021       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1022       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1023     }
1024   }
1025 
1026   @Test
createContextTest()1027   public void createContextTest() throws Exception {
1028     Context expectedResponse =
1029         Context.newBuilder()
1030             .setName(
1031                 ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]")
1032                     .toString())
1033             .setDisplayName("displayName1714148973")
1034             .setEtag("etag3123477")
1035             .putAllLabels(new HashMap<String, String>())
1036             .setCreateTime(Timestamp.newBuilder().build())
1037             .setUpdateTime(Timestamp.newBuilder().build())
1038             .addAllParentContexts(new ArrayList<String>())
1039             .setSchemaTitle("schemaTitle-1020962505")
1040             .setSchemaVersion("schemaVersion-233564169")
1041             .setMetadata(Struct.newBuilder().build())
1042             .setDescription("description-1724546052")
1043             .build();
1044     mockMetadataService.addResponse(expectedResponse);
1045 
1046     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1047     Context context = Context.newBuilder().build();
1048     String contextId = "contextId-406810838";
1049 
1050     Context actualResponse = client.createContext(parent, context, contextId);
1051     Assert.assertEquals(expectedResponse, actualResponse);
1052 
1053     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1054     Assert.assertEquals(1, actualRequests.size());
1055     CreateContextRequest actualRequest = ((CreateContextRequest) actualRequests.get(0));
1056 
1057     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1058     Assert.assertEquals(context, actualRequest.getContext());
1059     Assert.assertEquals(contextId, actualRequest.getContextId());
1060     Assert.assertTrue(
1061         channelProvider.isHeaderSent(
1062             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1063             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1064   }
1065 
1066   @Test
createContextExceptionTest()1067   public void createContextExceptionTest() throws Exception {
1068     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1069     mockMetadataService.addException(exception);
1070 
1071     try {
1072       MetadataStoreName parent =
1073           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1074       Context context = Context.newBuilder().build();
1075       String contextId = "contextId-406810838";
1076       client.createContext(parent, context, contextId);
1077       Assert.fail("No exception raised");
1078     } catch (InvalidArgumentException e) {
1079       // Expected exception.
1080     }
1081   }
1082 
1083   @Test
createContextTest2()1084   public void createContextTest2() throws Exception {
1085     Context expectedResponse =
1086         Context.newBuilder()
1087             .setName(
1088                 ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]")
1089                     .toString())
1090             .setDisplayName("displayName1714148973")
1091             .setEtag("etag3123477")
1092             .putAllLabels(new HashMap<String, String>())
1093             .setCreateTime(Timestamp.newBuilder().build())
1094             .setUpdateTime(Timestamp.newBuilder().build())
1095             .addAllParentContexts(new ArrayList<String>())
1096             .setSchemaTitle("schemaTitle-1020962505")
1097             .setSchemaVersion("schemaVersion-233564169")
1098             .setMetadata(Struct.newBuilder().build())
1099             .setDescription("description-1724546052")
1100             .build();
1101     mockMetadataService.addResponse(expectedResponse);
1102 
1103     String parent = "parent-995424086";
1104     Context context = Context.newBuilder().build();
1105     String contextId = "contextId-406810838";
1106 
1107     Context actualResponse = client.createContext(parent, context, contextId);
1108     Assert.assertEquals(expectedResponse, actualResponse);
1109 
1110     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1111     Assert.assertEquals(1, actualRequests.size());
1112     CreateContextRequest actualRequest = ((CreateContextRequest) actualRequests.get(0));
1113 
1114     Assert.assertEquals(parent, actualRequest.getParent());
1115     Assert.assertEquals(context, actualRequest.getContext());
1116     Assert.assertEquals(contextId, actualRequest.getContextId());
1117     Assert.assertTrue(
1118         channelProvider.isHeaderSent(
1119             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1120             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1121   }
1122 
1123   @Test
createContextExceptionTest2()1124   public void createContextExceptionTest2() throws Exception {
1125     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1126     mockMetadataService.addException(exception);
1127 
1128     try {
1129       String parent = "parent-995424086";
1130       Context context = Context.newBuilder().build();
1131       String contextId = "contextId-406810838";
1132       client.createContext(parent, context, contextId);
1133       Assert.fail("No exception raised");
1134     } catch (InvalidArgumentException e) {
1135       // Expected exception.
1136     }
1137   }
1138 
1139   @Test
getContextTest()1140   public void getContextTest() throws Exception {
1141     Context expectedResponse =
1142         Context.newBuilder()
1143             .setName(
1144                 ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]")
1145                     .toString())
1146             .setDisplayName("displayName1714148973")
1147             .setEtag("etag3123477")
1148             .putAllLabels(new HashMap<String, String>())
1149             .setCreateTime(Timestamp.newBuilder().build())
1150             .setUpdateTime(Timestamp.newBuilder().build())
1151             .addAllParentContexts(new ArrayList<String>())
1152             .setSchemaTitle("schemaTitle-1020962505")
1153             .setSchemaVersion("schemaVersion-233564169")
1154             .setMetadata(Struct.newBuilder().build())
1155             .setDescription("description-1724546052")
1156             .build();
1157     mockMetadataService.addResponse(expectedResponse);
1158 
1159     ContextName name = ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1160 
1161     Context actualResponse = client.getContext(name);
1162     Assert.assertEquals(expectedResponse, actualResponse);
1163 
1164     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1165     Assert.assertEquals(1, actualRequests.size());
1166     GetContextRequest actualRequest = ((GetContextRequest) actualRequests.get(0));
1167 
1168     Assert.assertEquals(name.toString(), actualRequest.getName());
1169     Assert.assertTrue(
1170         channelProvider.isHeaderSent(
1171             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1172             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1173   }
1174 
1175   @Test
getContextExceptionTest()1176   public void getContextExceptionTest() throws Exception {
1177     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1178     mockMetadataService.addException(exception);
1179 
1180     try {
1181       ContextName name = ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1182       client.getContext(name);
1183       Assert.fail("No exception raised");
1184     } catch (InvalidArgumentException e) {
1185       // Expected exception.
1186     }
1187   }
1188 
1189   @Test
getContextTest2()1190   public void getContextTest2() throws Exception {
1191     Context expectedResponse =
1192         Context.newBuilder()
1193             .setName(
1194                 ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]")
1195                     .toString())
1196             .setDisplayName("displayName1714148973")
1197             .setEtag("etag3123477")
1198             .putAllLabels(new HashMap<String, String>())
1199             .setCreateTime(Timestamp.newBuilder().build())
1200             .setUpdateTime(Timestamp.newBuilder().build())
1201             .addAllParentContexts(new ArrayList<String>())
1202             .setSchemaTitle("schemaTitle-1020962505")
1203             .setSchemaVersion("schemaVersion-233564169")
1204             .setMetadata(Struct.newBuilder().build())
1205             .setDescription("description-1724546052")
1206             .build();
1207     mockMetadataService.addResponse(expectedResponse);
1208 
1209     String name = "name3373707";
1210 
1211     Context actualResponse = client.getContext(name);
1212     Assert.assertEquals(expectedResponse, actualResponse);
1213 
1214     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1215     Assert.assertEquals(1, actualRequests.size());
1216     GetContextRequest actualRequest = ((GetContextRequest) actualRequests.get(0));
1217 
1218     Assert.assertEquals(name, actualRequest.getName());
1219     Assert.assertTrue(
1220         channelProvider.isHeaderSent(
1221             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1222             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1223   }
1224 
1225   @Test
getContextExceptionTest2()1226   public void getContextExceptionTest2() throws Exception {
1227     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1228     mockMetadataService.addException(exception);
1229 
1230     try {
1231       String name = "name3373707";
1232       client.getContext(name);
1233       Assert.fail("No exception raised");
1234     } catch (InvalidArgumentException e) {
1235       // Expected exception.
1236     }
1237   }
1238 
1239   @Test
listContextsTest()1240   public void listContextsTest() throws Exception {
1241     Context responsesElement = Context.newBuilder().build();
1242     ListContextsResponse expectedResponse =
1243         ListContextsResponse.newBuilder()
1244             .setNextPageToken("")
1245             .addAllContexts(Arrays.asList(responsesElement))
1246             .build();
1247     mockMetadataService.addResponse(expectedResponse);
1248 
1249     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1250 
1251     ListContextsPagedResponse pagedListResponse = client.listContexts(parent);
1252 
1253     List<Context> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1254 
1255     Assert.assertEquals(1, resources.size());
1256     Assert.assertEquals(expectedResponse.getContextsList().get(0), resources.get(0));
1257 
1258     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1259     Assert.assertEquals(1, actualRequests.size());
1260     ListContextsRequest actualRequest = ((ListContextsRequest) actualRequests.get(0));
1261 
1262     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1263     Assert.assertTrue(
1264         channelProvider.isHeaderSent(
1265             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1266             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1267   }
1268 
1269   @Test
listContextsExceptionTest()1270   public void listContextsExceptionTest() throws Exception {
1271     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1272     mockMetadataService.addException(exception);
1273 
1274     try {
1275       MetadataStoreName parent =
1276           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1277       client.listContexts(parent);
1278       Assert.fail("No exception raised");
1279     } catch (InvalidArgumentException e) {
1280       // Expected exception.
1281     }
1282   }
1283 
1284   @Test
listContextsTest2()1285   public void listContextsTest2() throws Exception {
1286     Context responsesElement = Context.newBuilder().build();
1287     ListContextsResponse expectedResponse =
1288         ListContextsResponse.newBuilder()
1289             .setNextPageToken("")
1290             .addAllContexts(Arrays.asList(responsesElement))
1291             .build();
1292     mockMetadataService.addResponse(expectedResponse);
1293 
1294     String parent = "parent-995424086";
1295 
1296     ListContextsPagedResponse pagedListResponse = client.listContexts(parent);
1297 
1298     List<Context> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1299 
1300     Assert.assertEquals(1, resources.size());
1301     Assert.assertEquals(expectedResponse.getContextsList().get(0), resources.get(0));
1302 
1303     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1304     Assert.assertEquals(1, actualRequests.size());
1305     ListContextsRequest actualRequest = ((ListContextsRequest) actualRequests.get(0));
1306 
1307     Assert.assertEquals(parent, actualRequest.getParent());
1308     Assert.assertTrue(
1309         channelProvider.isHeaderSent(
1310             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1311             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1312   }
1313 
1314   @Test
listContextsExceptionTest2()1315   public void listContextsExceptionTest2() throws Exception {
1316     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1317     mockMetadataService.addException(exception);
1318 
1319     try {
1320       String parent = "parent-995424086";
1321       client.listContexts(parent);
1322       Assert.fail("No exception raised");
1323     } catch (InvalidArgumentException e) {
1324       // Expected exception.
1325     }
1326   }
1327 
1328   @Test
updateContextTest()1329   public void updateContextTest() throws Exception {
1330     Context expectedResponse =
1331         Context.newBuilder()
1332             .setName(
1333                 ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]")
1334                     .toString())
1335             .setDisplayName("displayName1714148973")
1336             .setEtag("etag3123477")
1337             .putAllLabels(new HashMap<String, String>())
1338             .setCreateTime(Timestamp.newBuilder().build())
1339             .setUpdateTime(Timestamp.newBuilder().build())
1340             .addAllParentContexts(new ArrayList<String>())
1341             .setSchemaTitle("schemaTitle-1020962505")
1342             .setSchemaVersion("schemaVersion-233564169")
1343             .setMetadata(Struct.newBuilder().build())
1344             .setDescription("description-1724546052")
1345             .build();
1346     mockMetadataService.addResponse(expectedResponse);
1347 
1348     Context context = Context.newBuilder().build();
1349     FieldMask updateMask = FieldMask.newBuilder().build();
1350 
1351     Context actualResponse = client.updateContext(context, updateMask);
1352     Assert.assertEquals(expectedResponse, actualResponse);
1353 
1354     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1355     Assert.assertEquals(1, actualRequests.size());
1356     UpdateContextRequest actualRequest = ((UpdateContextRequest) actualRequests.get(0));
1357 
1358     Assert.assertEquals(context, actualRequest.getContext());
1359     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1360     Assert.assertTrue(
1361         channelProvider.isHeaderSent(
1362             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1363             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1364   }
1365 
1366   @Test
updateContextExceptionTest()1367   public void updateContextExceptionTest() throws Exception {
1368     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1369     mockMetadataService.addException(exception);
1370 
1371     try {
1372       Context context = Context.newBuilder().build();
1373       FieldMask updateMask = FieldMask.newBuilder().build();
1374       client.updateContext(context, updateMask);
1375       Assert.fail("No exception raised");
1376     } catch (InvalidArgumentException e) {
1377       // Expected exception.
1378     }
1379   }
1380 
1381   @Test
deleteContextTest()1382   public void deleteContextTest() throws Exception {
1383     Empty expectedResponse = Empty.newBuilder().build();
1384     Operation resultOperation =
1385         Operation.newBuilder()
1386             .setName("deleteContextTest")
1387             .setDone(true)
1388             .setResponse(Any.pack(expectedResponse))
1389             .build();
1390     mockMetadataService.addResponse(resultOperation);
1391 
1392     ContextName name = ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1393 
1394     client.deleteContextAsync(name).get();
1395 
1396     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1397     Assert.assertEquals(1, actualRequests.size());
1398     DeleteContextRequest actualRequest = ((DeleteContextRequest) actualRequests.get(0));
1399 
1400     Assert.assertEquals(name.toString(), actualRequest.getName());
1401     Assert.assertTrue(
1402         channelProvider.isHeaderSent(
1403             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1404             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1405   }
1406 
1407   @Test
deleteContextExceptionTest()1408   public void deleteContextExceptionTest() throws Exception {
1409     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1410     mockMetadataService.addException(exception);
1411 
1412     try {
1413       ContextName name = ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1414       client.deleteContextAsync(name).get();
1415       Assert.fail("No exception raised");
1416     } catch (ExecutionException e) {
1417       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1418       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1419       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1420     }
1421   }
1422 
1423   @Test
deleteContextTest2()1424   public void deleteContextTest2() throws Exception {
1425     Empty expectedResponse = Empty.newBuilder().build();
1426     Operation resultOperation =
1427         Operation.newBuilder()
1428             .setName("deleteContextTest")
1429             .setDone(true)
1430             .setResponse(Any.pack(expectedResponse))
1431             .build();
1432     mockMetadataService.addResponse(resultOperation);
1433 
1434     String name = "name3373707";
1435 
1436     client.deleteContextAsync(name).get();
1437 
1438     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1439     Assert.assertEquals(1, actualRequests.size());
1440     DeleteContextRequest actualRequest = ((DeleteContextRequest) actualRequests.get(0));
1441 
1442     Assert.assertEquals(name, actualRequest.getName());
1443     Assert.assertTrue(
1444         channelProvider.isHeaderSent(
1445             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1446             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1447   }
1448 
1449   @Test
deleteContextExceptionTest2()1450   public void deleteContextExceptionTest2() throws Exception {
1451     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1452     mockMetadataService.addException(exception);
1453 
1454     try {
1455       String name = "name3373707";
1456       client.deleteContextAsync(name).get();
1457       Assert.fail("No exception raised");
1458     } catch (ExecutionException e) {
1459       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1460       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1461       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1462     }
1463   }
1464 
1465   @Test
purgeContextsTest()1466   public void purgeContextsTest() throws Exception {
1467     PurgeContextsResponse expectedResponse =
1468         PurgeContextsResponse.newBuilder()
1469             .setPurgeCount(575305851)
1470             .addAllPurgeSample(new ArrayList<String>())
1471             .build();
1472     Operation resultOperation =
1473         Operation.newBuilder()
1474             .setName("purgeContextsTest")
1475             .setDone(true)
1476             .setResponse(Any.pack(expectedResponse))
1477             .build();
1478     mockMetadataService.addResponse(resultOperation);
1479 
1480     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1481 
1482     PurgeContextsResponse actualResponse = client.purgeContextsAsync(parent).get();
1483     Assert.assertEquals(expectedResponse, actualResponse);
1484 
1485     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1486     Assert.assertEquals(1, actualRequests.size());
1487     PurgeContextsRequest actualRequest = ((PurgeContextsRequest) actualRequests.get(0));
1488 
1489     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1490     Assert.assertTrue(
1491         channelProvider.isHeaderSent(
1492             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1493             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1494   }
1495 
1496   @Test
purgeContextsExceptionTest()1497   public void purgeContextsExceptionTest() throws Exception {
1498     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1499     mockMetadataService.addException(exception);
1500 
1501     try {
1502       MetadataStoreName parent =
1503           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1504       client.purgeContextsAsync(parent).get();
1505       Assert.fail("No exception raised");
1506     } catch (ExecutionException e) {
1507       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1508       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1509       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1510     }
1511   }
1512 
1513   @Test
purgeContextsTest2()1514   public void purgeContextsTest2() throws Exception {
1515     PurgeContextsResponse expectedResponse =
1516         PurgeContextsResponse.newBuilder()
1517             .setPurgeCount(575305851)
1518             .addAllPurgeSample(new ArrayList<String>())
1519             .build();
1520     Operation resultOperation =
1521         Operation.newBuilder()
1522             .setName("purgeContextsTest")
1523             .setDone(true)
1524             .setResponse(Any.pack(expectedResponse))
1525             .build();
1526     mockMetadataService.addResponse(resultOperation);
1527 
1528     String parent = "parent-995424086";
1529 
1530     PurgeContextsResponse actualResponse = client.purgeContextsAsync(parent).get();
1531     Assert.assertEquals(expectedResponse, actualResponse);
1532 
1533     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1534     Assert.assertEquals(1, actualRequests.size());
1535     PurgeContextsRequest actualRequest = ((PurgeContextsRequest) actualRequests.get(0));
1536 
1537     Assert.assertEquals(parent, actualRequest.getParent());
1538     Assert.assertTrue(
1539         channelProvider.isHeaderSent(
1540             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1541             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1542   }
1543 
1544   @Test
purgeContextsExceptionTest2()1545   public void purgeContextsExceptionTest2() throws Exception {
1546     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1547     mockMetadataService.addException(exception);
1548 
1549     try {
1550       String parent = "parent-995424086";
1551       client.purgeContextsAsync(parent).get();
1552       Assert.fail("No exception raised");
1553     } catch (ExecutionException e) {
1554       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1555       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1556       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1557     }
1558   }
1559 
1560   @Test
addContextArtifactsAndExecutionsTest()1561   public void addContextArtifactsAndExecutionsTest() throws Exception {
1562     AddContextArtifactsAndExecutionsResponse expectedResponse =
1563         AddContextArtifactsAndExecutionsResponse.newBuilder().build();
1564     mockMetadataService.addResponse(expectedResponse);
1565 
1566     ContextName context =
1567         ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1568     List<String> artifacts = new ArrayList<>();
1569     List<String> executions = new ArrayList<>();
1570 
1571     AddContextArtifactsAndExecutionsResponse actualResponse =
1572         client.addContextArtifactsAndExecutions(context, artifacts, executions);
1573     Assert.assertEquals(expectedResponse, actualResponse);
1574 
1575     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1576     Assert.assertEquals(1, actualRequests.size());
1577     AddContextArtifactsAndExecutionsRequest actualRequest =
1578         ((AddContextArtifactsAndExecutionsRequest) actualRequests.get(0));
1579 
1580     Assert.assertEquals(context.toString(), actualRequest.getContext());
1581     Assert.assertEquals(artifacts, actualRequest.getArtifactsList());
1582     Assert.assertEquals(executions, actualRequest.getExecutionsList());
1583     Assert.assertTrue(
1584         channelProvider.isHeaderSent(
1585             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1586             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1587   }
1588 
1589   @Test
addContextArtifactsAndExecutionsExceptionTest()1590   public void addContextArtifactsAndExecutionsExceptionTest() throws Exception {
1591     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1592     mockMetadataService.addException(exception);
1593 
1594     try {
1595       ContextName context =
1596           ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1597       List<String> artifacts = new ArrayList<>();
1598       List<String> executions = new ArrayList<>();
1599       client.addContextArtifactsAndExecutions(context, artifacts, executions);
1600       Assert.fail("No exception raised");
1601     } catch (InvalidArgumentException e) {
1602       // Expected exception.
1603     }
1604   }
1605 
1606   @Test
addContextArtifactsAndExecutionsTest2()1607   public void addContextArtifactsAndExecutionsTest2() throws Exception {
1608     AddContextArtifactsAndExecutionsResponse expectedResponse =
1609         AddContextArtifactsAndExecutionsResponse.newBuilder().build();
1610     mockMetadataService.addResponse(expectedResponse);
1611 
1612     String context = "context951530927";
1613     List<String> artifacts = new ArrayList<>();
1614     List<String> executions = new ArrayList<>();
1615 
1616     AddContextArtifactsAndExecutionsResponse actualResponse =
1617         client.addContextArtifactsAndExecutions(context, artifacts, executions);
1618     Assert.assertEquals(expectedResponse, actualResponse);
1619 
1620     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1621     Assert.assertEquals(1, actualRequests.size());
1622     AddContextArtifactsAndExecutionsRequest actualRequest =
1623         ((AddContextArtifactsAndExecutionsRequest) actualRequests.get(0));
1624 
1625     Assert.assertEquals(context, actualRequest.getContext());
1626     Assert.assertEquals(artifacts, actualRequest.getArtifactsList());
1627     Assert.assertEquals(executions, actualRequest.getExecutionsList());
1628     Assert.assertTrue(
1629         channelProvider.isHeaderSent(
1630             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1631             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1632   }
1633 
1634   @Test
addContextArtifactsAndExecutionsExceptionTest2()1635   public void addContextArtifactsAndExecutionsExceptionTest2() throws Exception {
1636     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1637     mockMetadataService.addException(exception);
1638 
1639     try {
1640       String context = "context951530927";
1641       List<String> artifacts = new ArrayList<>();
1642       List<String> executions = new ArrayList<>();
1643       client.addContextArtifactsAndExecutions(context, artifacts, executions);
1644       Assert.fail("No exception raised");
1645     } catch (InvalidArgumentException e) {
1646       // Expected exception.
1647     }
1648   }
1649 
1650   @Test
addContextChildrenTest()1651   public void addContextChildrenTest() throws Exception {
1652     AddContextChildrenResponse expectedResponse = AddContextChildrenResponse.newBuilder().build();
1653     mockMetadataService.addResponse(expectedResponse);
1654 
1655     ContextName context =
1656         ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1657     List<String> childContexts = new ArrayList<>();
1658 
1659     AddContextChildrenResponse actualResponse = client.addContextChildren(context, childContexts);
1660     Assert.assertEquals(expectedResponse, actualResponse);
1661 
1662     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1663     Assert.assertEquals(1, actualRequests.size());
1664     AddContextChildrenRequest actualRequest = ((AddContextChildrenRequest) actualRequests.get(0));
1665 
1666     Assert.assertEquals(context.toString(), actualRequest.getContext());
1667     Assert.assertEquals(childContexts, actualRequest.getChildContextsList());
1668     Assert.assertTrue(
1669         channelProvider.isHeaderSent(
1670             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1671             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1672   }
1673 
1674   @Test
addContextChildrenExceptionTest()1675   public void addContextChildrenExceptionTest() throws Exception {
1676     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1677     mockMetadataService.addException(exception);
1678 
1679     try {
1680       ContextName context =
1681           ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1682       List<String> childContexts = new ArrayList<>();
1683       client.addContextChildren(context, childContexts);
1684       Assert.fail("No exception raised");
1685     } catch (InvalidArgumentException e) {
1686       // Expected exception.
1687     }
1688   }
1689 
1690   @Test
addContextChildrenTest2()1691   public void addContextChildrenTest2() throws Exception {
1692     AddContextChildrenResponse expectedResponse = AddContextChildrenResponse.newBuilder().build();
1693     mockMetadataService.addResponse(expectedResponse);
1694 
1695     String context = "context951530927";
1696     List<String> childContexts = new ArrayList<>();
1697 
1698     AddContextChildrenResponse actualResponse = client.addContextChildren(context, childContexts);
1699     Assert.assertEquals(expectedResponse, actualResponse);
1700 
1701     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1702     Assert.assertEquals(1, actualRequests.size());
1703     AddContextChildrenRequest actualRequest = ((AddContextChildrenRequest) actualRequests.get(0));
1704 
1705     Assert.assertEquals(context, actualRequest.getContext());
1706     Assert.assertEquals(childContexts, actualRequest.getChildContextsList());
1707     Assert.assertTrue(
1708         channelProvider.isHeaderSent(
1709             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1710             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1711   }
1712 
1713   @Test
addContextChildrenExceptionTest2()1714   public void addContextChildrenExceptionTest2() throws Exception {
1715     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1716     mockMetadataService.addException(exception);
1717 
1718     try {
1719       String context = "context951530927";
1720       List<String> childContexts = new ArrayList<>();
1721       client.addContextChildren(context, childContexts);
1722       Assert.fail("No exception raised");
1723     } catch (InvalidArgumentException e) {
1724       // Expected exception.
1725     }
1726   }
1727 
1728   @Test
removeContextChildrenTest()1729   public void removeContextChildrenTest() throws Exception {
1730     RemoveContextChildrenResponse expectedResponse =
1731         RemoveContextChildrenResponse.newBuilder().build();
1732     mockMetadataService.addResponse(expectedResponse);
1733 
1734     ContextName context =
1735         ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1736     List<String> childContexts = new ArrayList<>();
1737 
1738     RemoveContextChildrenResponse actualResponse =
1739         client.removeContextChildren(context, childContexts);
1740     Assert.assertEquals(expectedResponse, actualResponse);
1741 
1742     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1743     Assert.assertEquals(1, actualRequests.size());
1744     RemoveContextChildrenRequest actualRequest =
1745         ((RemoveContextChildrenRequest) actualRequests.get(0));
1746 
1747     Assert.assertEquals(context.toString(), actualRequest.getContext());
1748     Assert.assertEquals(childContexts, actualRequest.getChildContextsList());
1749     Assert.assertTrue(
1750         channelProvider.isHeaderSent(
1751             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1752             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1753   }
1754 
1755   @Test
removeContextChildrenExceptionTest()1756   public void removeContextChildrenExceptionTest() throws Exception {
1757     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1758     mockMetadataService.addException(exception);
1759 
1760     try {
1761       ContextName context =
1762           ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1763       List<String> childContexts = new ArrayList<>();
1764       client.removeContextChildren(context, childContexts);
1765       Assert.fail("No exception raised");
1766     } catch (InvalidArgumentException e) {
1767       // Expected exception.
1768     }
1769   }
1770 
1771   @Test
removeContextChildrenTest2()1772   public void removeContextChildrenTest2() throws Exception {
1773     RemoveContextChildrenResponse expectedResponse =
1774         RemoveContextChildrenResponse.newBuilder().build();
1775     mockMetadataService.addResponse(expectedResponse);
1776 
1777     String context = "context951530927";
1778     List<String> childContexts = new ArrayList<>();
1779 
1780     RemoveContextChildrenResponse actualResponse =
1781         client.removeContextChildren(context, childContexts);
1782     Assert.assertEquals(expectedResponse, actualResponse);
1783 
1784     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1785     Assert.assertEquals(1, actualRequests.size());
1786     RemoveContextChildrenRequest actualRequest =
1787         ((RemoveContextChildrenRequest) actualRequests.get(0));
1788 
1789     Assert.assertEquals(context, actualRequest.getContext());
1790     Assert.assertEquals(childContexts, actualRequest.getChildContextsList());
1791     Assert.assertTrue(
1792         channelProvider.isHeaderSent(
1793             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1794             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1795   }
1796 
1797   @Test
removeContextChildrenExceptionTest2()1798   public void removeContextChildrenExceptionTest2() throws Exception {
1799     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1800     mockMetadataService.addException(exception);
1801 
1802     try {
1803       String context = "context951530927";
1804       List<String> childContexts = new ArrayList<>();
1805       client.removeContextChildren(context, childContexts);
1806       Assert.fail("No exception raised");
1807     } catch (InvalidArgumentException e) {
1808       // Expected exception.
1809     }
1810   }
1811 
1812   @Test
queryContextLineageSubgraphTest()1813   public void queryContextLineageSubgraphTest() throws Exception {
1814     LineageSubgraph expectedResponse =
1815         LineageSubgraph.newBuilder()
1816             .addAllArtifacts(new ArrayList<Artifact>())
1817             .addAllExecutions(new ArrayList<Execution>())
1818             .addAllEvents(new ArrayList<Event>())
1819             .build();
1820     mockMetadataService.addResponse(expectedResponse);
1821 
1822     ContextName context =
1823         ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1824 
1825     LineageSubgraph actualResponse = client.queryContextLineageSubgraph(context);
1826     Assert.assertEquals(expectedResponse, actualResponse);
1827 
1828     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1829     Assert.assertEquals(1, actualRequests.size());
1830     QueryContextLineageSubgraphRequest actualRequest =
1831         ((QueryContextLineageSubgraphRequest) actualRequests.get(0));
1832 
1833     Assert.assertEquals(context.toString(), actualRequest.getContext());
1834     Assert.assertTrue(
1835         channelProvider.isHeaderSent(
1836             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1837             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1838   }
1839 
1840   @Test
queryContextLineageSubgraphExceptionTest()1841   public void queryContextLineageSubgraphExceptionTest() throws Exception {
1842     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1843     mockMetadataService.addException(exception);
1844 
1845     try {
1846       ContextName context =
1847           ContextName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[CONTEXT]");
1848       client.queryContextLineageSubgraph(context);
1849       Assert.fail("No exception raised");
1850     } catch (InvalidArgumentException e) {
1851       // Expected exception.
1852     }
1853   }
1854 
1855   @Test
queryContextLineageSubgraphTest2()1856   public void queryContextLineageSubgraphTest2() throws Exception {
1857     LineageSubgraph expectedResponse =
1858         LineageSubgraph.newBuilder()
1859             .addAllArtifacts(new ArrayList<Artifact>())
1860             .addAllExecutions(new ArrayList<Execution>())
1861             .addAllEvents(new ArrayList<Event>())
1862             .build();
1863     mockMetadataService.addResponse(expectedResponse);
1864 
1865     String context = "context951530927";
1866 
1867     LineageSubgraph actualResponse = client.queryContextLineageSubgraph(context);
1868     Assert.assertEquals(expectedResponse, actualResponse);
1869 
1870     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1871     Assert.assertEquals(1, actualRequests.size());
1872     QueryContextLineageSubgraphRequest actualRequest =
1873         ((QueryContextLineageSubgraphRequest) actualRequests.get(0));
1874 
1875     Assert.assertEquals(context, actualRequest.getContext());
1876     Assert.assertTrue(
1877         channelProvider.isHeaderSent(
1878             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1879             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1880   }
1881 
1882   @Test
queryContextLineageSubgraphExceptionTest2()1883   public void queryContextLineageSubgraphExceptionTest2() throws Exception {
1884     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1885     mockMetadataService.addException(exception);
1886 
1887     try {
1888       String context = "context951530927";
1889       client.queryContextLineageSubgraph(context);
1890       Assert.fail("No exception raised");
1891     } catch (InvalidArgumentException e) {
1892       // Expected exception.
1893     }
1894   }
1895 
1896   @Test
createExecutionTest()1897   public void createExecutionTest() throws Exception {
1898     Execution expectedResponse =
1899         Execution.newBuilder()
1900             .setName(
1901                 ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]")
1902                     .toString())
1903             .setDisplayName("displayName1714148973")
1904             .setEtag("etag3123477")
1905             .putAllLabels(new HashMap<String, String>())
1906             .setCreateTime(Timestamp.newBuilder().build())
1907             .setUpdateTime(Timestamp.newBuilder().build())
1908             .setSchemaTitle("schemaTitle-1020962505")
1909             .setSchemaVersion("schemaVersion-233564169")
1910             .setMetadata(Struct.newBuilder().build())
1911             .setDescription("description-1724546052")
1912             .build();
1913     mockMetadataService.addResponse(expectedResponse);
1914 
1915     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1916     Execution execution = Execution.newBuilder().build();
1917     String executionId = "executionId-454906285";
1918 
1919     Execution actualResponse = client.createExecution(parent, execution, executionId);
1920     Assert.assertEquals(expectedResponse, actualResponse);
1921 
1922     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1923     Assert.assertEquals(1, actualRequests.size());
1924     CreateExecutionRequest actualRequest = ((CreateExecutionRequest) actualRequests.get(0));
1925 
1926     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1927     Assert.assertEquals(execution, actualRequest.getExecution());
1928     Assert.assertEquals(executionId, actualRequest.getExecutionId());
1929     Assert.assertTrue(
1930         channelProvider.isHeaderSent(
1931             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1932             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1933   }
1934 
1935   @Test
createExecutionExceptionTest()1936   public void createExecutionExceptionTest() throws Exception {
1937     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1938     mockMetadataService.addException(exception);
1939 
1940     try {
1941       MetadataStoreName parent =
1942           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
1943       Execution execution = Execution.newBuilder().build();
1944       String executionId = "executionId-454906285";
1945       client.createExecution(parent, execution, executionId);
1946       Assert.fail("No exception raised");
1947     } catch (InvalidArgumentException e) {
1948       // Expected exception.
1949     }
1950   }
1951 
1952   @Test
createExecutionTest2()1953   public void createExecutionTest2() throws Exception {
1954     Execution expectedResponse =
1955         Execution.newBuilder()
1956             .setName(
1957                 ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]")
1958                     .toString())
1959             .setDisplayName("displayName1714148973")
1960             .setEtag("etag3123477")
1961             .putAllLabels(new HashMap<String, String>())
1962             .setCreateTime(Timestamp.newBuilder().build())
1963             .setUpdateTime(Timestamp.newBuilder().build())
1964             .setSchemaTitle("schemaTitle-1020962505")
1965             .setSchemaVersion("schemaVersion-233564169")
1966             .setMetadata(Struct.newBuilder().build())
1967             .setDescription("description-1724546052")
1968             .build();
1969     mockMetadataService.addResponse(expectedResponse);
1970 
1971     String parent = "parent-995424086";
1972     Execution execution = Execution.newBuilder().build();
1973     String executionId = "executionId-454906285";
1974 
1975     Execution actualResponse = client.createExecution(parent, execution, executionId);
1976     Assert.assertEquals(expectedResponse, actualResponse);
1977 
1978     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
1979     Assert.assertEquals(1, actualRequests.size());
1980     CreateExecutionRequest actualRequest = ((CreateExecutionRequest) actualRequests.get(0));
1981 
1982     Assert.assertEquals(parent, actualRequest.getParent());
1983     Assert.assertEquals(execution, actualRequest.getExecution());
1984     Assert.assertEquals(executionId, actualRequest.getExecutionId());
1985     Assert.assertTrue(
1986         channelProvider.isHeaderSent(
1987             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1988             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1989   }
1990 
1991   @Test
createExecutionExceptionTest2()1992   public void createExecutionExceptionTest2() throws Exception {
1993     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1994     mockMetadataService.addException(exception);
1995 
1996     try {
1997       String parent = "parent-995424086";
1998       Execution execution = Execution.newBuilder().build();
1999       String executionId = "executionId-454906285";
2000       client.createExecution(parent, execution, executionId);
2001       Assert.fail("No exception raised");
2002     } catch (InvalidArgumentException e) {
2003       // Expected exception.
2004     }
2005   }
2006 
2007   @Test
getExecutionTest()2008   public void getExecutionTest() throws Exception {
2009     Execution expectedResponse =
2010         Execution.newBuilder()
2011             .setName(
2012                 ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]")
2013                     .toString())
2014             .setDisplayName("displayName1714148973")
2015             .setEtag("etag3123477")
2016             .putAllLabels(new HashMap<String, String>())
2017             .setCreateTime(Timestamp.newBuilder().build())
2018             .setUpdateTime(Timestamp.newBuilder().build())
2019             .setSchemaTitle("schemaTitle-1020962505")
2020             .setSchemaVersion("schemaVersion-233564169")
2021             .setMetadata(Struct.newBuilder().build())
2022             .setDescription("description-1724546052")
2023             .build();
2024     mockMetadataService.addResponse(expectedResponse);
2025 
2026     ExecutionName name =
2027         ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2028 
2029     Execution actualResponse = client.getExecution(name);
2030     Assert.assertEquals(expectedResponse, actualResponse);
2031 
2032     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2033     Assert.assertEquals(1, actualRequests.size());
2034     GetExecutionRequest actualRequest = ((GetExecutionRequest) actualRequests.get(0));
2035 
2036     Assert.assertEquals(name.toString(), actualRequest.getName());
2037     Assert.assertTrue(
2038         channelProvider.isHeaderSent(
2039             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2040             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2041   }
2042 
2043   @Test
getExecutionExceptionTest()2044   public void getExecutionExceptionTest() throws Exception {
2045     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2046     mockMetadataService.addException(exception);
2047 
2048     try {
2049       ExecutionName name =
2050           ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2051       client.getExecution(name);
2052       Assert.fail("No exception raised");
2053     } catch (InvalidArgumentException e) {
2054       // Expected exception.
2055     }
2056   }
2057 
2058   @Test
getExecutionTest2()2059   public void getExecutionTest2() throws Exception {
2060     Execution expectedResponse =
2061         Execution.newBuilder()
2062             .setName(
2063                 ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]")
2064                     .toString())
2065             .setDisplayName("displayName1714148973")
2066             .setEtag("etag3123477")
2067             .putAllLabels(new HashMap<String, String>())
2068             .setCreateTime(Timestamp.newBuilder().build())
2069             .setUpdateTime(Timestamp.newBuilder().build())
2070             .setSchemaTitle("schemaTitle-1020962505")
2071             .setSchemaVersion("schemaVersion-233564169")
2072             .setMetadata(Struct.newBuilder().build())
2073             .setDescription("description-1724546052")
2074             .build();
2075     mockMetadataService.addResponse(expectedResponse);
2076 
2077     String name = "name3373707";
2078 
2079     Execution actualResponse = client.getExecution(name);
2080     Assert.assertEquals(expectedResponse, actualResponse);
2081 
2082     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2083     Assert.assertEquals(1, actualRequests.size());
2084     GetExecutionRequest actualRequest = ((GetExecutionRequest) actualRequests.get(0));
2085 
2086     Assert.assertEquals(name, actualRequest.getName());
2087     Assert.assertTrue(
2088         channelProvider.isHeaderSent(
2089             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2090             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2091   }
2092 
2093   @Test
getExecutionExceptionTest2()2094   public void getExecutionExceptionTest2() throws Exception {
2095     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2096     mockMetadataService.addException(exception);
2097 
2098     try {
2099       String name = "name3373707";
2100       client.getExecution(name);
2101       Assert.fail("No exception raised");
2102     } catch (InvalidArgumentException e) {
2103       // Expected exception.
2104     }
2105   }
2106 
2107   @Test
listExecutionsTest()2108   public void listExecutionsTest() throws Exception {
2109     Execution responsesElement = Execution.newBuilder().build();
2110     ListExecutionsResponse expectedResponse =
2111         ListExecutionsResponse.newBuilder()
2112             .setNextPageToken("")
2113             .addAllExecutions(Arrays.asList(responsesElement))
2114             .build();
2115     mockMetadataService.addResponse(expectedResponse);
2116 
2117     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2118 
2119     ListExecutionsPagedResponse pagedListResponse = client.listExecutions(parent);
2120 
2121     List<Execution> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2122 
2123     Assert.assertEquals(1, resources.size());
2124     Assert.assertEquals(expectedResponse.getExecutionsList().get(0), resources.get(0));
2125 
2126     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2127     Assert.assertEquals(1, actualRequests.size());
2128     ListExecutionsRequest actualRequest = ((ListExecutionsRequest) actualRequests.get(0));
2129 
2130     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2131     Assert.assertTrue(
2132         channelProvider.isHeaderSent(
2133             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2134             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2135   }
2136 
2137   @Test
listExecutionsExceptionTest()2138   public void listExecutionsExceptionTest() throws Exception {
2139     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2140     mockMetadataService.addException(exception);
2141 
2142     try {
2143       MetadataStoreName parent =
2144           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2145       client.listExecutions(parent);
2146       Assert.fail("No exception raised");
2147     } catch (InvalidArgumentException e) {
2148       // Expected exception.
2149     }
2150   }
2151 
2152   @Test
listExecutionsTest2()2153   public void listExecutionsTest2() throws Exception {
2154     Execution responsesElement = Execution.newBuilder().build();
2155     ListExecutionsResponse expectedResponse =
2156         ListExecutionsResponse.newBuilder()
2157             .setNextPageToken("")
2158             .addAllExecutions(Arrays.asList(responsesElement))
2159             .build();
2160     mockMetadataService.addResponse(expectedResponse);
2161 
2162     String parent = "parent-995424086";
2163 
2164     ListExecutionsPagedResponse pagedListResponse = client.listExecutions(parent);
2165 
2166     List<Execution> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2167 
2168     Assert.assertEquals(1, resources.size());
2169     Assert.assertEquals(expectedResponse.getExecutionsList().get(0), resources.get(0));
2170 
2171     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2172     Assert.assertEquals(1, actualRequests.size());
2173     ListExecutionsRequest actualRequest = ((ListExecutionsRequest) actualRequests.get(0));
2174 
2175     Assert.assertEquals(parent, actualRequest.getParent());
2176     Assert.assertTrue(
2177         channelProvider.isHeaderSent(
2178             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2179             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2180   }
2181 
2182   @Test
listExecutionsExceptionTest2()2183   public void listExecutionsExceptionTest2() throws Exception {
2184     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2185     mockMetadataService.addException(exception);
2186 
2187     try {
2188       String parent = "parent-995424086";
2189       client.listExecutions(parent);
2190       Assert.fail("No exception raised");
2191     } catch (InvalidArgumentException e) {
2192       // Expected exception.
2193     }
2194   }
2195 
2196   @Test
updateExecutionTest()2197   public void updateExecutionTest() throws Exception {
2198     Execution expectedResponse =
2199         Execution.newBuilder()
2200             .setName(
2201                 ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]")
2202                     .toString())
2203             .setDisplayName("displayName1714148973")
2204             .setEtag("etag3123477")
2205             .putAllLabels(new HashMap<String, String>())
2206             .setCreateTime(Timestamp.newBuilder().build())
2207             .setUpdateTime(Timestamp.newBuilder().build())
2208             .setSchemaTitle("schemaTitle-1020962505")
2209             .setSchemaVersion("schemaVersion-233564169")
2210             .setMetadata(Struct.newBuilder().build())
2211             .setDescription("description-1724546052")
2212             .build();
2213     mockMetadataService.addResponse(expectedResponse);
2214 
2215     Execution execution = Execution.newBuilder().build();
2216     FieldMask updateMask = FieldMask.newBuilder().build();
2217 
2218     Execution actualResponse = client.updateExecution(execution, updateMask);
2219     Assert.assertEquals(expectedResponse, actualResponse);
2220 
2221     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2222     Assert.assertEquals(1, actualRequests.size());
2223     UpdateExecutionRequest actualRequest = ((UpdateExecutionRequest) actualRequests.get(0));
2224 
2225     Assert.assertEquals(execution, actualRequest.getExecution());
2226     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
2227     Assert.assertTrue(
2228         channelProvider.isHeaderSent(
2229             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2230             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2231   }
2232 
2233   @Test
updateExecutionExceptionTest()2234   public void updateExecutionExceptionTest() throws Exception {
2235     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2236     mockMetadataService.addException(exception);
2237 
2238     try {
2239       Execution execution = Execution.newBuilder().build();
2240       FieldMask updateMask = FieldMask.newBuilder().build();
2241       client.updateExecution(execution, updateMask);
2242       Assert.fail("No exception raised");
2243     } catch (InvalidArgumentException e) {
2244       // Expected exception.
2245     }
2246   }
2247 
2248   @Test
deleteExecutionTest()2249   public void deleteExecutionTest() throws Exception {
2250     Empty expectedResponse = Empty.newBuilder().build();
2251     Operation resultOperation =
2252         Operation.newBuilder()
2253             .setName("deleteExecutionTest")
2254             .setDone(true)
2255             .setResponse(Any.pack(expectedResponse))
2256             .build();
2257     mockMetadataService.addResponse(resultOperation);
2258 
2259     ExecutionName name =
2260         ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2261 
2262     client.deleteExecutionAsync(name).get();
2263 
2264     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2265     Assert.assertEquals(1, actualRequests.size());
2266     DeleteExecutionRequest actualRequest = ((DeleteExecutionRequest) actualRequests.get(0));
2267 
2268     Assert.assertEquals(name.toString(), actualRequest.getName());
2269     Assert.assertTrue(
2270         channelProvider.isHeaderSent(
2271             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2272             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2273   }
2274 
2275   @Test
deleteExecutionExceptionTest()2276   public void deleteExecutionExceptionTest() throws Exception {
2277     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2278     mockMetadataService.addException(exception);
2279 
2280     try {
2281       ExecutionName name =
2282           ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2283       client.deleteExecutionAsync(name).get();
2284       Assert.fail("No exception raised");
2285     } catch (ExecutionException e) {
2286       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2287       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2288       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2289     }
2290   }
2291 
2292   @Test
deleteExecutionTest2()2293   public void deleteExecutionTest2() throws Exception {
2294     Empty expectedResponse = Empty.newBuilder().build();
2295     Operation resultOperation =
2296         Operation.newBuilder()
2297             .setName("deleteExecutionTest")
2298             .setDone(true)
2299             .setResponse(Any.pack(expectedResponse))
2300             .build();
2301     mockMetadataService.addResponse(resultOperation);
2302 
2303     String name = "name3373707";
2304 
2305     client.deleteExecutionAsync(name).get();
2306 
2307     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2308     Assert.assertEquals(1, actualRequests.size());
2309     DeleteExecutionRequest actualRequest = ((DeleteExecutionRequest) actualRequests.get(0));
2310 
2311     Assert.assertEquals(name, actualRequest.getName());
2312     Assert.assertTrue(
2313         channelProvider.isHeaderSent(
2314             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2315             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2316   }
2317 
2318   @Test
deleteExecutionExceptionTest2()2319   public void deleteExecutionExceptionTest2() throws Exception {
2320     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2321     mockMetadataService.addException(exception);
2322 
2323     try {
2324       String name = "name3373707";
2325       client.deleteExecutionAsync(name).get();
2326       Assert.fail("No exception raised");
2327     } catch (ExecutionException e) {
2328       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2329       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2330       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2331     }
2332   }
2333 
2334   @Test
purgeExecutionsTest()2335   public void purgeExecutionsTest() throws Exception {
2336     PurgeExecutionsResponse expectedResponse =
2337         PurgeExecutionsResponse.newBuilder()
2338             .setPurgeCount(575305851)
2339             .addAllPurgeSample(new ArrayList<String>())
2340             .build();
2341     Operation resultOperation =
2342         Operation.newBuilder()
2343             .setName("purgeExecutionsTest")
2344             .setDone(true)
2345             .setResponse(Any.pack(expectedResponse))
2346             .build();
2347     mockMetadataService.addResponse(resultOperation);
2348 
2349     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2350 
2351     PurgeExecutionsResponse actualResponse = client.purgeExecutionsAsync(parent).get();
2352     Assert.assertEquals(expectedResponse, actualResponse);
2353 
2354     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2355     Assert.assertEquals(1, actualRequests.size());
2356     PurgeExecutionsRequest actualRequest = ((PurgeExecutionsRequest) actualRequests.get(0));
2357 
2358     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2359     Assert.assertTrue(
2360         channelProvider.isHeaderSent(
2361             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2362             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2363   }
2364 
2365   @Test
purgeExecutionsExceptionTest()2366   public void purgeExecutionsExceptionTest() throws Exception {
2367     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2368     mockMetadataService.addException(exception);
2369 
2370     try {
2371       MetadataStoreName parent =
2372           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2373       client.purgeExecutionsAsync(parent).get();
2374       Assert.fail("No exception raised");
2375     } catch (ExecutionException e) {
2376       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2377       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2378       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2379     }
2380   }
2381 
2382   @Test
purgeExecutionsTest2()2383   public void purgeExecutionsTest2() throws Exception {
2384     PurgeExecutionsResponse expectedResponse =
2385         PurgeExecutionsResponse.newBuilder()
2386             .setPurgeCount(575305851)
2387             .addAllPurgeSample(new ArrayList<String>())
2388             .build();
2389     Operation resultOperation =
2390         Operation.newBuilder()
2391             .setName("purgeExecutionsTest")
2392             .setDone(true)
2393             .setResponse(Any.pack(expectedResponse))
2394             .build();
2395     mockMetadataService.addResponse(resultOperation);
2396 
2397     String parent = "parent-995424086";
2398 
2399     PurgeExecutionsResponse actualResponse = client.purgeExecutionsAsync(parent).get();
2400     Assert.assertEquals(expectedResponse, actualResponse);
2401 
2402     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2403     Assert.assertEquals(1, actualRequests.size());
2404     PurgeExecutionsRequest actualRequest = ((PurgeExecutionsRequest) actualRequests.get(0));
2405 
2406     Assert.assertEquals(parent, actualRequest.getParent());
2407     Assert.assertTrue(
2408         channelProvider.isHeaderSent(
2409             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2410             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2411   }
2412 
2413   @Test
purgeExecutionsExceptionTest2()2414   public void purgeExecutionsExceptionTest2() throws Exception {
2415     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2416     mockMetadataService.addException(exception);
2417 
2418     try {
2419       String parent = "parent-995424086";
2420       client.purgeExecutionsAsync(parent).get();
2421       Assert.fail("No exception raised");
2422     } catch (ExecutionException e) {
2423       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
2424       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
2425       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
2426     }
2427   }
2428 
2429   @Test
addExecutionEventsTest()2430   public void addExecutionEventsTest() throws Exception {
2431     AddExecutionEventsResponse expectedResponse = AddExecutionEventsResponse.newBuilder().build();
2432     mockMetadataService.addResponse(expectedResponse);
2433 
2434     ExecutionName execution =
2435         ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2436     List<Event> events = new ArrayList<>();
2437 
2438     AddExecutionEventsResponse actualResponse = client.addExecutionEvents(execution, events);
2439     Assert.assertEquals(expectedResponse, actualResponse);
2440 
2441     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2442     Assert.assertEquals(1, actualRequests.size());
2443     AddExecutionEventsRequest actualRequest = ((AddExecutionEventsRequest) actualRequests.get(0));
2444 
2445     Assert.assertEquals(execution.toString(), actualRequest.getExecution());
2446     Assert.assertEquals(events, actualRequest.getEventsList());
2447     Assert.assertTrue(
2448         channelProvider.isHeaderSent(
2449             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2450             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2451   }
2452 
2453   @Test
addExecutionEventsExceptionTest()2454   public void addExecutionEventsExceptionTest() throws Exception {
2455     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2456     mockMetadataService.addException(exception);
2457 
2458     try {
2459       ExecutionName execution =
2460           ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2461       List<Event> events = new ArrayList<>();
2462       client.addExecutionEvents(execution, events);
2463       Assert.fail("No exception raised");
2464     } catch (InvalidArgumentException e) {
2465       // Expected exception.
2466     }
2467   }
2468 
2469   @Test
addExecutionEventsTest2()2470   public void addExecutionEventsTest2() throws Exception {
2471     AddExecutionEventsResponse expectedResponse = AddExecutionEventsResponse.newBuilder().build();
2472     mockMetadataService.addResponse(expectedResponse);
2473 
2474     String execution = "execution-1090974952";
2475     List<Event> events = new ArrayList<>();
2476 
2477     AddExecutionEventsResponse actualResponse = client.addExecutionEvents(execution, events);
2478     Assert.assertEquals(expectedResponse, actualResponse);
2479 
2480     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2481     Assert.assertEquals(1, actualRequests.size());
2482     AddExecutionEventsRequest actualRequest = ((AddExecutionEventsRequest) actualRequests.get(0));
2483 
2484     Assert.assertEquals(execution, actualRequest.getExecution());
2485     Assert.assertEquals(events, actualRequest.getEventsList());
2486     Assert.assertTrue(
2487         channelProvider.isHeaderSent(
2488             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2489             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2490   }
2491 
2492   @Test
addExecutionEventsExceptionTest2()2493   public void addExecutionEventsExceptionTest2() throws Exception {
2494     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2495     mockMetadataService.addException(exception);
2496 
2497     try {
2498       String execution = "execution-1090974952";
2499       List<Event> events = new ArrayList<>();
2500       client.addExecutionEvents(execution, events);
2501       Assert.fail("No exception raised");
2502     } catch (InvalidArgumentException e) {
2503       // Expected exception.
2504     }
2505   }
2506 
2507   @Test
queryExecutionInputsAndOutputsTest()2508   public void queryExecutionInputsAndOutputsTest() throws Exception {
2509     LineageSubgraph expectedResponse =
2510         LineageSubgraph.newBuilder()
2511             .addAllArtifacts(new ArrayList<Artifact>())
2512             .addAllExecutions(new ArrayList<Execution>())
2513             .addAllEvents(new ArrayList<Event>())
2514             .build();
2515     mockMetadataService.addResponse(expectedResponse);
2516 
2517     ExecutionName execution =
2518         ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2519 
2520     LineageSubgraph actualResponse = client.queryExecutionInputsAndOutputs(execution);
2521     Assert.assertEquals(expectedResponse, actualResponse);
2522 
2523     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2524     Assert.assertEquals(1, actualRequests.size());
2525     QueryExecutionInputsAndOutputsRequest actualRequest =
2526         ((QueryExecutionInputsAndOutputsRequest) actualRequests.get(0));
2527 
2528     Assert.assertEquals(execution.toString(), actualRequest.getExecution());
2529     Assert.assertTrue(
2530         channelProvider.isHeaderSent(
2531             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2532             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2533   }
2534 
2535   @Test
queryExecutionInputsAndOutputsExceptionTest()2536   public void queryExecutionInputsAndOutputsExceptionTest() throws Exception {
2537     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2538     mockMetadataService.addException(exception);
2539 
2540     try {
2541       ExecutionName execution =
2542           ExecutionName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[EXECUTION]");
2543       client.queryExecutionInputsAndOutputs(execution);
2544       Assert.fail("No exception raised");
2545     } catch (InvalidArgumentException e) {
2546       // Expected exception.
2547     }
2548   }
2549 
2550   @Test
queryExecutionInputsAndOutputsTest2()2551   public void queryExecutionInputsAndOutputsTest2() throws Exception {
2552     LineageSubgraph expectedResponse =
2553         LineageSubgraph.newBuilder()
2554             .addAllArtifacts(new ArrayList<Artifact>())
2555             .addAllExecutions(new ArrayList<Execution>())
2556             .addAllEvents(new ArrayList<Event>())
2557             .build();
2558     mockMetadataService.addResponse(expectedResponse);
2559 
2560     String execution = "execution-1090974952";
2561 
2562     LineageSubgraph actualResponse = client.queryExecutionInputsAndOutputs(execution);
2563     Assert.assertEquals(expectedResponse, actualResponse);
2564 
2565     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2566     Assert.assertEquals(1, actualRequests.size());
2567     QueryExecutionInputsAndOutputsRequest actualRequest =
2568         ((QueryExecutionInputsAndOutputsRequest) actualRequests.get(0));
2569 
2570     Assert.assertEquals(execution, actualRequest.getExecution());
2571     Assert.assertTrue(
2572         channelProvider.isHeaderSent(
2573             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2574             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2575   }
2576 
2577   @Test
queryExecutionInputsAndOutputsExceptionTest2()2578   public void queryExecutionInputsAndOutputsExceptionTest2() throws Exception {
2579     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2580     mockMetadataService.addException(exception);
2581 
2582     try {
2583       String execution = "execution-1090974952";
2584       client.queryExecutionInputsAndOutputs(execution);
2585       Assert.fail("No exception raised");
2586     } catch (InvalidArgumentException e) {
2587       // Expected exception.
2588     }
2589   }
2590 
2591   @Test
createMetadataSchemaTest()2592   public void createMetadataSchemaTest() throws Exception {
2593     MetadataSchema expectedResponse =
2594         MetadataSchema.newBuilder()
2595             .setName(
2596                 MetadataSchemaName.of(
2597                         "[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]")
2598                     .toString())
2599             .setSchemaVersion("schemaVersion-233564169")
2600             .setSchema("schema-907987551")
2601             .setCreateTime(Timestamp.newBuilder().build())
2602             .setDescription("description-1724546052")
2603             .build();
2604     mockMetadataService.addResponse(expectedResponse);
2605 
2606     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2607     MetadataSchema metadataSchema = MetadataSchema.newBuilder().build();
2608     String metadataSchemaId = "metadataSchemaId1549245163";
2609 
2610     MetadataSchema actualResponse =
2611         client.createMetadataSchema(parent, metadataSchema, metadataSchemaId);
2612     Assert.assertEquals(expectedResponse, actualResponse);
2613 
2614     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2615     Assert.assertEquals(1, actualRequests.size());
2616     CreateMetadataSchemaRequest actualRequest =
2617         ((CreateMetadataSchemaRequest) actualRequests.get(0));
2618 
2619     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2620     Assert.assertEquals(metadataSchema, actualRequest.getMetadataSchema());
2621     Assert.assertEquals(metadataSchemaId, actualRequest.getMetadataSchemaId());
2622     Assert.assertTrue(
2623         channelProvider.isHeaderSent(
2624             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2625             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2626   }
2627 
2628   @Test
createMetadataSchemaExceptionTest()2629   public void createMetadataSchemaExceptionTest() throws Exception {
2630     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2631     mockMetadataService.addException(exception);
2632 
2633     try {
2634       MetadataStoreName parent =
2635           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2636       MetadataSchema metadataSchema = MetadataSchema.newBuilder().build();
2637       String metadataSchemaId = "metadataSchemaId1549245163";
2638       client.createMetadataSchema(parent, metadataSchema, metadataSchemaId);
2639       Assert.fail("No exception raised");
2640     } catch (InvalidArgumentException e) {
2641       // Expected exception.
2642     }
2643   }
2644 
2645   @Test
createMetadataSchemaTest2()2646   public void createMetadataSchemaTest2() throws Exception {
2647     MetadataSchema expectedResponse =
2648         MetadataSchema.newBuilder()
2649             .setName(
2650                 MetadataSchemaName.of(
2651                         "[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]")
2652                     .toString())
2653             .setSchemaVersion("schemaVersion-233564169")
2654             .setSchema("schema-907987551")
2655             .setCreateTime(Timestamp.newBuilder().build())
2656             .setDescription("description-1724546052")
2657             .build();
2658     mockMetadataService.addResponse(expectedResponse);
2659 
2660     String parent = "parent-995424086";
2661     MetadataSchema metadataSchema = MetadataSchema.newBuilder().build();
2662     String metadataSchemaId = "metadataSchemaId1549245163";
2663 
2664     MetadataSchema actualResponse =
2665         client.createMetadataSchema(parent, metadataSchema, metadataSchemaId);
2666     Assert.assertEquals(expectedResponse, actualResponse);
2667 
2668     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2669     Assert.assertEquals(1, actualRequests.size());
2670     CreateMetadataSchemaRequest actualRequest =
2671         ((CreateMetadataSchemaRequest) actualRequests.get(0));
2672 
2673     Assert.assertEquals(parent, actualRequest.getParent());
2674     Assert.assertEquals(metadataSchema, actualRequest.getMetadataSchema());
2675     Assert.assertEquals(metadataSchemaId, actualRequest.getMetadataSchemaId());
2676     Assert.assertTrue(
2677         channelProvider.isHeaderSent(
2678             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2679             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2680   }
2681 
2682   @Test
createMetadataSchemaExceptionTest2()2683   public void createMetadataSchemaExceptionTest2() throws Exception {
2684     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2685     mockMetadataService.addException(exception);
2686 
2687     try {
2688       String parent = "parent-995424086";
2689       MetadataSchema metadataSchema = MetadataSchema.newBuilder().build();
2690       String metadataSchemaId = "metadataSchemaId1549245163";
2691       client.createMetadataSchema(parent, metadataSchema, metadataSchemaId);
2692       Assert.fail("No exception raised");
2693     } catch (InvalidArgumentException e) {
2694       // Expected exception.
2695     }
2696   }
2697 
2698   @Test
getMetadataSchemaTest()2699   public void getMetadataSchemaTest() throws Exception {
2700     MetadataSchema expectedResponse =
2701         MetadataSchema.newBuilder()
2702             .setName(
2703                 MetadataSchemaName.of(
2704                         "[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]")
2705                     .toString())
2706             .setSchemaVersion("schemaVersion-233564169")
2707             .setSchema("schema-907987551")
2708             .setCreateTime(Timestamp.newBuilder().build())
2709             .setDescription("description-1724546052")
2710             .build();
2711     mockMetadataService.addResponse(expectedResponse);
2712 
2713     MetadataSchemaName name =
2714         MetadataSchemaName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]");
2715 
2716     MetadataSchema actualResponse = client.getMetadataSchema(name);
2717     Assert.assertEquals(expectedResponse, actualResponse);
2718 
2719     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2720     Assert.assertEquals(1, actualRequests.size());
2721     GetMetadataSchemaRequest actualRequest = ((GetMetadataSchemaRequest) actualRequests.get(0));
2722 
2723     Assert.assertEquals(name.toString(), actualRequest.getName());
2724     Assert.assertTrue(
2725         channelProvider.isHeaderSent(
2726             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2727             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2728   }
2729 
2730   @Test
getMetadataSchemaExceptionTest()2731   public void getMetadataSchemaExceptionTest() throws Exception {
2732     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2733     mockMetadataService.addException(exception);
2734 
2735     try {
2736       MetadataSchemaName name =
2737           MetadataSchemaName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]");
2738       client.getMetadataSchema(name);
2739       Assert.fail("No exception raised");
2740     } catch (InvalidArgumentException e) {
2741       // Expected exception.
2742     }
2743   }
2744 
2745   @Test
getMetadataSchemaTest2()2746   public void getMetadataSchemaTest2() throws Exception {
2747     MetadataSchema expectedResponse =
2748         MetadataSchema.newBuilder()
2749             .setName(
2750                 MetadataSchemaName.of(
2751                         "[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[METADATA_SCHEMA]")
2752                     .toString())
2753             .setSchemaVersion("schemaVersion-233564169")
2754             .setSchema("schema-907987551")
2755             .setCreateTime(Timestamp.newBuilder().build())
2756             .setDescription("description-1724546052")
2757             .build();
2758     mockMetadataService.addResponse(expectedResponse);
2759 
2760     String name = "name3373707";
2761 
2762     MetadataSchema actualResponse = client.getMetadataSchema(name);
2763     Assert.assertEquals(expectedResponse, actualResponse);
2764 
2765     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2766     Assert.assertEquals(1, actualRequests.size());
2767     GetMetadataSchemaRequest actualRequest = ((GetMetadataSchemaRequest) actualRequests.get(0));
2768 
2769     Assert.assertEquals(name, actualRequest.getName());
2770     Assert.assertTrue(
2771         channelProvider.isHeaderSent(
2772             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2773             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2774   }
2775 
2776   @Test
getMetadataSchemaExceptionTest2()2777   public void getMetadataSchemaExceptionTest2() throws Exception {
2778     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2779     mockMetadataService.addException(exception);
2780 
2781     try {
2782       String name = "name3373707";
2783       client.getMetadataSchema(name);
2784       Assert.fail("No exception raised");
2785     } catch (InvalidArgumentException e) {
2786       // Expected exception.
2787     }
2788   }
2789 
2790   @Test
listMetadataSchemasTest()2791   public void listMetadataSchemasTest() throws Exception {
2792     MetadataSchema responsesElement = MetadataSchema.newBuilder().build();
2793     ListMetadataSchemasResponse expectedResponse =
2794         ListMetadataSchemasResponse.newBuilder()
2795             .setNextPageToken("")
2796             .addAllMetadataSchemas(Arrays.asList(responsesElement))
2797             .build();
2798     mockMetadataService.addResponse(expectedResponse);
2799 
2800     MetadataStoreName parent = MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2801 
2802     ListMetadataSchemasPagedResponse pagedListResponse = client.listMetadataSchemas(parent);
2803 
2804     List<MetadataSchema> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2805 
2806     Assert.assertEquals(1, resources.size());
2807     Assert.assertEquals(expectedResponse.getMetadataSchemasList().get(0), resources.get(0));
2808 
2809     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2810     Assert.assertEquals(1, actualRequests.size());
2811     ListMetadataSchemasRequest actualRequest = ((ListMetadataSchemasRequest) actualRequests.get(0));
2812 
2813     Assert.assertEquals(parent.toString(), actualRequest.getParent());
2814     Assert.assertTrue(
2815         channelProvider.isHeaderSent(
2816             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2817             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2818   }
2819 
2820   @Test
listMetadataSchemasExceptionTest()2821   public void listMetadataSchemasExceptionTest() throws Exception {
2822     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2823     mockMetadataService.addException(exception);
2824 
2825     try {
2826       MetadataStoreName parent =
2827           MetadataStoreName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]");
2828       client.listMetadataSchemas(parent);
2829       Assert.fail("No exception raised");
2830     } catch (InvalidArgumentException e) {
2831       // Expected exception.
2832     }
2833   }
2834 
2835   @Test
listMetadataSchemasTest2()2836   public void listMetadataSchemasTest2() throws Exception {
2837     MetadataSchema responsesElement = MetadataSchema.newBuilder().build();
2838     ListMetadataSchemasResponse expectedResponse =
2839         ListMetadataSchemasResponse.newBuilder()
2840             .setNextPageToken("")
2841             .addAllMetadataSchemas(Arrays.asList(responsesElement))
2842             .build();
2843     mockMetadataService.addResponse(expectedResponse);
2844 
2845     String parent = "parent-995424086";
2846 
2847     ListMetadataSchemasPagedResponse pagedListResponse = client.listMetadataSchemas(parent);
2848 
2849     List<MetadataSchema> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2850 
2851     Assert.assertEquals(1, resources.size());
2852     Assert.assertEquals(expectedResponse.getMetadataSchemasList().get(0), resources.get(0));
2853 
2854     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2855     Assert.assertEquals(1, actualRequests.size());
2856     ListMetadataSchemasRequest actualRequest = ((ListMetadataSchemasRequest) actualRequests.get(0));
2857 
2858     Assert.assertEquals(parent, actualRequest.getParent());
2859     Assert.assertTrue(
2860         channelProvider.isHeaderSent(
2861             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2862             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2863   }
2864 
2865   @Test
listMetadataSchemasExceptionTest2()2866   public void listMetadataSchemasExceptionTest2() throws Exception {
2867     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2868     mockMetadataService.addException(exception);
2869 
2870     try {
2871       String parent = "parent-995424086";
2872       client.listMetadataSchemas(parent);
2873       Assert.fail("No exception raised");
2874     } catch (InvalidArgumentException e) {
2875       // Expected exception.
2876     }
2877   }
2878 
2879   @Test
queryArtifactLineageSubgraphTest()2880   public void queryArtifactLineageSubgraphTest() throws Exception {
2881     LineageSubgraph expectedResponse =
2882         LineageSubgraph.newBuilder()
2883             .addAllArtifacts(new ArrayList<Artifact>())
2884             .addAllExecutions(new ArrayList<Execution>())
2885             .addAllEvents(new ArrayList<Event>())
2886             .build();
2887     mockMetadataService.addResponse(expectedResponse);
2888 
2889     ArtifactName artifact =
2890         ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
2891 
2892     LineageSubgraph actualResponse = client.queryArtifactLineageSubgraph(artifact);
2893     Assert.assertEquals(expectedResponse, actualResponse);
2894 
2895     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2896     Assert.assertEquals(1, actualRequests.size());
2897     QueryArtifactLineageSubgraphRequest actualRequest =
2898         ((QueryArtifactLineageSubgraphRequest) actualRequests.get(0));
2899 
2900     Assert.assertEquals(artifact.toString(), actualRequest.getArtifact());
2901     Assert.assertTrue(
2902         channelProvider.isHeaderSent(
2903             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2904             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2905   }
2906 
2907   @Test
queryArtifactLineageSubgraphExceptionTest()2908   public void queryArtifactLineageSubgraphExceptionTest() throws Exception {
2909     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2910     mockMetadataService.addException(exception);
2911 
2912     try {
2913       ArtifactName artifact =
2914           ArtifactName.of("[PROJECT]", "[LOCATION]", "[METADATA_STORE]", "[ARTIFACT]");
2915       client.queryArtifactLineageSubgraph(artifact);
2916       Assert.fail("No exception raised");
2917     } catch (InvalidArgumentException e) {
2918       // Expected exception.
2919     }
2920   }
2921 
2922   @Test
queryArtifactLineageSubgraphTest2()2923   public void queryArtifactLineageSubgraphTest2() throws Exception {
2924     LineageSubgraph expectedResponse =
2925         LineageSubgraph.newBuilder()
2926             .addAllArtifacts(new ArrayList<Artifact>())
2927             .addAllExecutions(new ArrayList<Execution>())
2928             .addAllEvents(new ArrayList<Event>())
2929             .build();
2930     mockMetadataService.addResponse(expectedResponse);
2931 
2932     String artifact = "artifact-1228798510";
2933 
2934     LineageSubgraph actualResponse = client.queryArtifactLineageSubgraph(artifact);
2935     Assert.assertEquals(expectedResponse, actualResponse);
2936 
2937     List<AbstractMessage> actualRequests = mockMetadataService.getRequests();
2938     Assert.assertEquals(1, actualRequests.size());
2939     QueryArtifactLineageSubgraphRequest actualRequest =
2940         ((QueryArtifactLineageSubgraphRequest) actualRequests.get(0));
2941 
2942     Assert.assertEquals(artifact, actualRequest.getArtifact());
2943     Assert.assertTrue(
2944         channelProvider.isHeaderSent(
2945             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2946             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
2947   }
2948 
2949   @Test
queryArtifactLineageSubgraphExceptionTest2()2950   public void queryArtifactLineageSubgraphExceptionTest2() throws Exception {
2951     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
2952     mockMetadataService.addException(exception);
2953 
2954     try {
2955       String artifact = "artifact-1228798510";
2956       client.queryArtifactLineageSubgraph(artifact);
2957       Assert.fail("No exception raised");
2958     } catch (InvalidArgumentException e) {
2959       // Expected exception.
2960     }
2961   }
2962 
2963   @Test
listLocationsTest()2964   public void listLocationsTest() throws Exception {
2965     Location responsesElement = Location.newBuilder().build();
2966     ListLocationsResponse expectedResponse =
2967         ListLocationsResponse.newBuilder()
2968             .setNextPageToken("")
2969             .addAllLocations(Arrays.asList(responsesElement))
2970             .build();
2971     mockLocations.addResponse(expectedResponse);
2972 
2973     ListLocationsRequest request =
2974         ListLocationsRequest.newBuilder()
2975             .setName("name3373707")
2976             .setFilter("filter-1274492040")
2977             .setPageSize(883849137)
2978             .setPageToken("pageToken873572522")
2979             .build();
2980 
2981     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
2982 
2983     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
2984 
2985     Assert.assertEquals(1, resources.size());
2986     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
2987 
2988     List<AbstractMessage> actualRequests = mockLocations.getRequests();
2989     Assert.assertEquals(1, actualRequests.size());
2990     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
2991 
2992     Assert.assertEquals(request.getName(), actualRequest.getName());
2993     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
2994     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
2995     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
2996     Assert.assertTrue(
2997         channelProvider.isHeaderSent(
2998             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
2999             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3000   }
3001 
3002   @Test
listLocationsExceptionTest()3003   public void listLocationsExceptionTest() throws Exception {
3004     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3005     mockLocations.addException(exception);
3006 
3007     try {
3008       ListLocationsRequest request =
3009           ListLocationsRequest.newBuilder()
3010               .setName("name3373707")
3011               .setFilter("filter-1274492040")
3012               .setPageSize(883849137)
3013               .setPageToken("pageToken873572522")
3014               .build();
3015       client.listLocations(request);
3016       Assert.fail("No exception raised");
3017     } catch (InvalidArgumentException e) {
3018       // Expected exception.
3019     }
3020   }
3021 
3022   @Test
getLocationTest()3023   public void getLocationTest() throws Exception {
3024     Location expectedResponse =
3025         Location.newBuilder()
3026             .setName("name3373707")
3027             .setLocationId("locationId1541836720")
3028             .setDisplayName("displayName1714148973")
3029             .putAllLabels(new HashMap<String, String>())
3030             .setMetadata(Any.newBuilder().build())
3031             .build();
3032     mockLocations.addResponse(expectedResponse);
3033 
3034     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
3035 
3036     Location actualResponse = client.getLocation(request);
3037     Assert.assertEquals(expectedResponse, actualResponse);
3038 
3039     List<AbstractMessage> actualRequests = mockLocations.getRequests();
3040     Assert.assertEquals(1, actualRequests.size());
3041     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
3042 
3043     Assert.assertEquals(request.getName(), actualRequest.getName());
3044     Assert.assertTrue(
3045         channelProvider.isHeaderSent(
3046             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3047             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3048   }
3049 
3050   @Test
getLocationExceptionTest()3051   public void getLocationExceptionTest() throws Exception {
3052     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3053     mockLocations.addException(exception);
3054 
3055     try {
3056       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
3057       client.getLocation(request);
3058       Assert.fail("No exception raised");
3059     } catch (InvalidArgumentException e) {
3060       // Expected exception.
3061     }
3062   }
3063 
3064   @Test
setIamPolicyTest()3065   public void setIamPolicyTest() throws Exception {
3066     Policy expectedResponse =
3067         Policy.newBuilder()
3068             .setVersion(351608024)
3069             .addAllBindings(new ArrayList<Binding>())
3070             .addAllAuditConfigs(new ArrayList<AuditConfig>())
3071             .setEtag(ByteString.EMPTY)
3072             .build();
3073     mockIAMPolicy.addResponse(expectedResponse);
3074 
3075     SetIamPolicyRequest request =
3076         SetIamPolicyRequest.newBuilder()
3077             .setResource(
3078                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
3079                     .toString())
3080             .setPolicy(Policy.newBuilder().build())
3081             .setUpdateMask(FieldMask.newBuilder().build())
3082             .build();
3083 
3084     Policy actualResponse = client.setIamPolicy(request);
3085     Assert.assertEquals(expectedResponse, actualResponse);
3086 
3087     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
3088     Assert.assertEquals(1, actualRequests.size());
3089     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
3090 
3091     Assert.assertEquals(request.getResource(), actualRequest.getResource());
3092     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
3093     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
3094     Assert.assertTrue(
3095         channelProvider.isHeaderSent(
3096             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3097             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3098   }
3099 
3100   @Test
setIamPolicyExceptionTest()3101   public void setIamPolicyExceptionTest() throws Exception {
3102     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3103     mockIAMPolicy.addException(exception);
3104 
3105     try {
3106       SetIamPolicyRequest request =
3107           SetIamPolicyRequest.newBuilder()
3108               .setResource(
3109                   EndpointName.ofProjectLocationEndpointName(
3110                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
3111                       .toString())
3112               .setPolicy(Policy.newBuilder().build())
3113               .setUpdateMask(FieldMask.newBuilder().build())
3114               .build();
3115       client.setIamPolicy(request);
3116       Assert.fail("No exception raised");
3117     } catch (InvalidArgumentException e) {
3118       // Expected exception.
3119     }
3120   }
3121 
3122   @Test
getIamPolicyTest()3123   public void getIamPolicyTest() throws Exception {
3124     Policy expectedResponse =
3125         Policy.newBuilder()
3126             .setVersion(351608024)
3127             .addAllBindings(new ArrayList<Binding>())
3128             .addAllAuditConfigs(new ArrayList<AuditConfig>())
3129             .setEtag(ByteString.EMPTY)
3130             .build();
3131     mockIAMPolicy.addResponse(expectedResponse);
3132 
3133     GetIamPolicyRequest request =
3134         GetIamPolicyRequest.newBuilder()
3135             .setResource(
3136                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
3137                     .toString())
3138             .setOptions(GetPolicyOptions.newBuilder().build())
3139             .build();
3140 
3141     Policy actualResponse = client.getIamPolicy(request);
3142     Assert.assertEquals(expectedResponse, actualResponse);
3143 
3144     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
3145     Assert.assertEquals(1, actualRequests.size());
3146     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
3147 
3148     Assert.assertEquals(request.getResource(), actualRequest.getResource());
3149     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
3150     Assert.assertTrue(
3151         channelProvider.isHeaderSent(
3152             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3153             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3154   }
3155 
3156   @Test
getIamPolicyExceptionTest()3157   public void getIamPolicyExceptionTest() throws Exception {
3158     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3159     mockIAMPolicy.addException(exception);
3160 
3161     try {
3162       GetIamPolicyRequest request =
3163           GetIamPolicyRequest.newBuilder()
3164               .setResource(
3165                   EndpointName.ofProjectLocationEndpointName(
3166                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
3167                       .toString())
3168               .setOptions(GetPolicyOptions.newBuilder().build())
3169               .build();
3170       client.getIamPolicy(request);
3171       Assert.fail("No exception raised");
3172     } catch (InvalidArgumentException e) {
3173       // Expected exception.
3174     }
3175   }
3176 
3177   @Test
testIamPermissionsTest()3178   public void testIamPermissionsTest() throws Exception {
3179     TestIamPermissionsResponse expectedResponse =
3180         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
3181     mockIAMPolicy.addResponse(expectedResponse);
3182 
3183     TestIamPermissionsRequest request =
3184         TestIamPermissionsRequest.newBuilder()
3185             .setResource(
3186                 EndpointName.ofProjectLocationEndpointName("[PROJECT]", "[LOCATION]", "[ENDPOINT]")
3187                     .toString())
3188             .addAllPermissions(new ArrayList<String>())
3189             .build();
3190 
3191     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
3192     Assert.assertEquals(expectedResponse, actualResponse);
3193 
3194     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
3195     Assert.assertEquals(1, actualRequests.size());
3196     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
3197 
3198     Assert.assertEquals(request.getResource(), actualRequest.getResource());
3199     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
3200     Assert.assertTrue(
3201         channelProvider.isHeaderSent(
3202             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
3203             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
3204   }
3205 
3206   @Test
testIamPermissionsExceptionTest()3207   public void testIamPermissionsExceptionTest() throws Exception {
3208     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
3209     mockIAMPolicy.addException(exception);
3210 
3211     try {
3212       TestIamPermissionsRequest request =
3213           TestIamPermissionsRequest.newBuilder()
3214               .setResource(
3215                   EndpointName.ofProjectLocationEndpointName(
3216                           "[PROJECT]", "[LOCATION]", "[ENDPOINT]")
3217                       .toString())
3218               .addAllPermissions(new ArrayList<String>())
3219               .build();
3220       client.testIamPermissions(request);
3221       Assert.fail("No exception raised");
3222     } catch (InvalidArgumentException e) {
3223       // Expected exception.
3224     }
3225   }
3226 }
3227