• 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.retail.v2beta;
18 
19 import static com.google.cloud.retail.v2beta.ModelServiceClient.ListModelsPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.grpc.GaxGrpcProperties;
23 import com.google.api.gax.grpc.testing.LocalChannelProvider;
24 import com.google.api.gax.grpc.testing.MockGrpcService;
25 import com.google.api.gax.grpc.testing.MockServiceHelper;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.common.collect.Lists;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Any;
33 import com.google.protobuf.Empty;
34 import com.google.protobuf.FieldMask;
35 import com.google.protobuf.Timestamp;
36 import io.grpc.StatusRuntimeException;
37 import java.io.IOException;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.List;
41 import java.util.UUID;
42 import java.util.concurrent.ExecutionException;
43 import javax.annotation.Generated;
44 import org.junit.After;
45 import org.junit.AfterClass;
46 import org.junit.Assert;
47 import org.junit.Before;
48 import org.junit.BeforeClass;
49 import org.junit.Test;
50 
51 @Generated("by gapic-generator-java")
52 public class ModelServiceClientTest {
53   private static MockModelService mockModelService;
54   private static MockServiceHelper mockServiceHelper;
55   private LocalChannelProvider channelProvider;
56   private ModelServiceClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() {
60     mockModelService = new MockModelService();
61     mockServiceHelper =
62         new MockServiceHelper(
63             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockModelService));
64     mockServiceHelper.start();
65   }
66 
67   @AfterClass
stopServer()68   public static void stopServer() {
69     mockServiceHelper.stop();
70   }
71 
72   @Before
setUp()73   public void setUp() throws IOException {
74     mockServiceHelper.reset();
75     channelProvider = mockServiceHelper.createChannelProvider();
76     ModelServiceSettings settings =
77         ModelServiceSettings.newBuilder()
78             .setTransportChannelProvider(channelProvider)
79             .setCredentialsProvider(NoCredentialsProvider.create())
80             .build();
81     client = ModelServiceClient.create(settings);
82   }
83 
84   @After
tearDown()85   public void tearDown() throws Exception {
86     client.close();
87   }
88 
89   @Test
createModelTest()90   public void createModelTest() throws Exception {
91     Model expectedResponse =
92         Model.newBuilder()
93             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
94             .setDisplayName("displayName1714148973")
95             .setCreateTime(Timestamp.newBuilder().build())
96             .setUpdateTime(Timestamp.newBuilder().build())
97             .setType("type3575610")
98             .setOptimizationObjective("optimizationObjective-1014459828")
99             .setLastTuneTime(Timestamp.newBuilder().build())
100             .setTuningOperation("tuningOperation-1269747150")
101             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
102             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
103             .build();
104     Operation resultOperation =
105         Operation.newBuilder()
106             .setName("createModelTest")
107             .setDone(true)
108             .setResponse(Any.pack(expectedResponse))
109             .build();
110     mockModelService.addResponse(resultOperation);
111 
112     CatalogName parent = CatalogName.of("[PROJECT]", "[LOCATION]", "[CATALOG]");
113     Model model = Model.newBuilder().build();
114 
115     Model actualResponse = client.createModelAsync(parent, model).get();
116     Assert.assertEquals(expectedResponse, actualResponse);
117 
118     List<AbstractMessage> actualRequests = mockModelService.getRequests();
119     Assert.assertEquals(1, actualRequests.size());
120     CreateModelRequest actualRequest = ((CreateModelRequest) actualRequests.get(0));
121 
122     Assert.assertEquals(parent.toString(), actualRequest.getParent());
123     Assert.assertEquals(model, actualRequest.getModel());
124     Assert.assertTrue(
125         channelProvider.isHeaderSent(
126             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
127             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
128   }
129 
130   @Test
createModelExceptionTest()131   public void createModelExceptionTest() throws Exception {
132     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
133     mockModelService.addException(exception);
134 
135     try {
136       CatalogName parent = CatalogName.of("[PROJECT]", "[LOCATION]", "[CATALOG]");
137       Model model = Model.newBuilder().build();
138       client.createModelAsync(parent, model).get();
139       Assert.fail("No exception raised");
140     } catch (ExecutionException e) {
141       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
142       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
143       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
144     }
145   }
146 
147   @Test
createModelTest2()148   public void createModelTest2() throws Exception {
149     Model expectedResponse =
150         Model.newBuilder()
151             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
152             .setDisplayName("displayName1714148973")
153             .setCreateTime(Timestamp.newBuilder().build())
154             .setUpdateTime(Timestamp.newBuilder().build())
155             .setType("type3575610")
156             .setOptimizationObjective("optimizationObjective-1014459828")
157             .setLastTuneTime(Timestamp.newBuilder().build())
158             .setTuningOperation("tuningOperation-1269747150")
159             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
160             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
161             .build();
162     Operation resultOperation =
163         Operation.newBuilder()
164             .setName("createModelTest")
165             .setDone(true)
166             .setResponse(Any.pack(expectedResponse))
167             .build();
168     mockModelService.addResponse(resultOperation);
169 
170     String parent = "parent-995424086";
171     Model model = Model.newBuilder().build();
172 
173     Model actualResponse = client.createModelAsync(parent, model).get();
174     Assert.assertEquals(expectedResponse, actualResponse);
175 
176     List<AbstractMessage> actualRequests = mockModelService.getRequests();
177     Assert.assertEquals(1, actualRequests.size());
178     CreateModelRequest actualRequest = ((CreateModelRequest) actualRequests.get(0));
179 
180     Assert.assertEquals(parent, actualRequest.getParent());
181     Assert.assertEquals(model, actualRequest.getModel());
182     Assert.assertTrue(
183         channelProvider.isHeaderSent(
184             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
185             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
186   }
187 
188   @Test
createModelExceptionTest2()189   public void createModelExceptionTest2() throws Exception {
190     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
191     mockModelService.addException(exception);
192 
193     try {
194       String parent = "parent-995424086";
195       Model model = Model.newBuilder().build();
196       client.createModelAsync(parent, model).get();
197       Assert.fail("No exception raised");
198     } catch (ExecutionException e) {
199       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
200       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
201       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
202     }
203   }
204 
205   @Test
getModelTest()206   public void getModelTest() throws Exception {
207     Model expectedResponse =
208         Model.newBuilder()
209             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
210             .setDisplayName("displayName1714148973")
211             .setCreateTime(Timestamp.newBuilder().build())
212             .setUpdateTime(Timestamp.newBuilder().build())
213             .setType("type3575610")
214             .setOptimizationObjective("optimizationObjective-1014459828")
215             .setLastTuneTime(Timestamp.newBuilder().build())
216             .setTuningOperation("tuningOperation-1269747150")
217             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
218             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
219             .build();
220     mockModelService.addResponse(expectedResponse);
221 
222     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
223 
224     Model actualResponse = client.getModel(name);
225     Assert.assertEquals(expectedResponse, actualResponse);
226 
227     List<AbstractMessage> actualRequests = mockModelService.getRequests();
228     Assert.assertEquals(1, actualRequests.size());
229     GetModelRequest actualRequest = ((GetModelRequest) actualRequests.get(0));
230 
231     Assert.assertEquals(name.toString(), actualRequest.getName());
232     Assert.assertTrue(
233         channelProvider.isHeaderSent(
234             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
235             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
236   }
237 
238   @Test
getModelExceptionTest()239   public void getModelExceptionTest() throws Exception {
240     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
241     mockModelService.addException(exception);
242 
243     try {
244       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
245       client.getModel(name);
246       Assert.fail("No exception raised");
247     } catch (InvalidArgumentException e) {
248       // Expected exception.
249     }
250   }
251 
252   @Test
getModelTest2()253   public void getModelTest2() throws Exception {
254     Model expectedResponse =
255         Model.newBuilder()
256             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
257             .setDisplayName("displayName1714148973")
258             .setCreateTime(Timestamp.newBuilder().build())
259             .setUpdateTime(Timestamp.newBuilder().build())
260             .setType("type3575610")
261             .setOptimizationObjective("optimizationObjective-1014459828")
262             .setLastTuneTime(Timestamp.newBuilder().build())
263             .setTuningOperation("tuningOperation-1269747150")
264             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
265             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
266             .build();
267     mockModelService.addResponse(expectedResponse);
268 
269     String name = "name3373707";
270 
271     Model actualResponse = client.getModel(name);
272     Assert.assertEquals(expectedResponse, actualResponse);
273 
274     List<AbstractMessage> actualRequests = mockModelService.getRequests();
275     Assert.assertEquals(1, actualRequests.size());
276     GetModelRequest actualRequest = ((GetModelRequest) actualRequests.get(0));
277 
278     Assert.assertEquals(name, actualRequest.getName());
279     Assert.assertTrue(
280         channelProvider.isHeaderSent(
281             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
282             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
283   }
284 
285   @Test
getModelExceptionTest2()286   public void getModelExceptionTest2() throws Exception {
287     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
288     mockModelService.addException(exception);
289 
290     try {
291       String name = "name3373707";
292       client.getModel(name);
293       Assert.fail("No exception raised");
294     } catch (InvalidArgumentException e) {
295       // Expected exception.
296     }
297   }
298 
299   @Test
pauseModelTest()300   public void pauseModelTest() throws Exception {
301     Model expectedResponse =
302         Model.newBuilder()
303             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
304             .setDisplayName("displayName1714148973")
305             .setCreateTime(Timestamp.newBuilder().build())
306             .setUpdateTime(Timestamp.newBuilder().build())
307             .setType("type3575610")
308             .setOptimizationObjective("optimizationObjective-1014459828")
309             .setLastTuneTime(Timestamp.newBuilder().build())
310             .setTuningOperation("tuningOperation-1269747150")
311             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
312             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
313             .build();
314     mockModelService.addResponse(expectedResponse);
315 
316     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
317 
318     Model actualResponse = client.pauseModel(name);
319     Assert.assertEquals(expectedResponse, actualResponse);
320 
321     List<AbstractMessage> actualRequests = mockModelService.getRequests();
322     Assert.assertEquals(1, actualRequests.size());
323     PauseModelRequest actualRequest = ((PauseModelRequest) actualRequests.get(0));
324 
325     Assert.assertEquals(name.toString(), actualRequest.getName());
326     Assert.assertTrue(
327         channelProvider.isHeaderSent(
328             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
329             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
330   }
331 
332   @Test
pauseModelExceptionTest()333   public void pauseModelExceptionTest() throws Exception {
334     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
335     mockModelService.addException(exception);
336 
337     try {
338       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
339       client.pauseModel(name);
340       Assert.fail("No exception raised");
341     } catch (InvalidArgumentException e) {
342       // Expected exception.
343     }
344   }
345 
346   @Test
pauseModelTest2()347   public void pauseModelTest2() throws Exception {
348     Model expectedResponse =
349         Model.newBuilder()
350             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
351             .setDisplayName("displayName1714148973")
352             .setCreateTime(Timestamp.newBuilder().build())
353             .setUpdateTime(Timestamp.newBuilder().build())
354             .setType("type3575610")
355             .setOptimizationObjective("optimizationObjective-1014459828")
356             .setLastTuneTime(Timestamp.newBuilder().build())
357             .setTuningOperation("tuningOperation-1269747150")
358             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
359             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
360             .build();
361     mockModelService.addResponse(expectedResponse);
362 
363     String name = "name3373707";
364 
365     Model actualResponse = client.pauseModel(name);
366     Assert.assertEquals(expectedResponse, actualResponse);
367 
368     List<AbstractMessage> actualRequests = mockModelService.getRequests();
369     Assert.assertEquals(1, actualRequests.size());
370     PauseModelRequest actualRequest = ((PauseModelRequest) actualRequests.get(0));
371 
372     Assert.assertEquals(name, actualRequest.getName());
373     Assert.assertTrue(
374         channelProvider.isHeaderSent(
375             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
376             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
377   }
378 
379   @Test
pauseModelExceptionTest2()380   public void pauseModelExceptionTest2() throws Exception {
381     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
382     mockModelService.addException(exception);
383 
384     try {
385       String name = "name3373707";
386       client.pauseModel(name);
387       Assert.fail("No exception raised");
388     } catch (InvalidArgumentException e) {
389       // Expected exception.
390     }
391   }
392 
393   @Test
resumeModelTest()394   public void resumeModelTest() throws Exception {
395     Model expectedResponse =
396         Model.newBuilder()
397             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
398             .setDisplayName("displayName1714148973")
399             .setCreateTime(Timestamp.newBuilder().build())
400             .setUpdateTime(Timestamp.newBuilder().build())
401             .setType("type3575610")
402             .setOptimizationObjective("optimizationObjective-1014459828")
403             .setLastTuneTime(Timestamp.newBuilder().build())
404             .setTuningOperation("tuningOperation-1269747150")
405             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
406             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
407             .build();
408     mockModelService.addResponse(expectedResponse);
409 
410     String name = "name3373707";
411 
412     Model actualResponse = client.resumeModel(name);
413     Assert.assertEquals(expectedResponse, actualResponse);
414 
415     List<AbstractMessage> actualRequests = mockModelService.getRequests();
416     Assert.assertEquals(1, actualRequests.size());
417     ResumeModelRequest actualRequest = ((ResumeModelRequest) actualRequests.get(0));
418 
419     Assert.assertEquals(name, actualRequest.getName());
420     Assert.assertTrue(
421         channelProvider.isHeaderSent(
422             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
423             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
424   }
425 
426   @Test
resumeModelExceptionTest()427   public void resumeModelExceptionTest() throws Exception {
428     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
429     mockModelService.addException(exception);
430 
431     try {
432       String name = "name3373707";
433       client.resumeModel(name);
434       Assert.fail("No exception raised");
435     } catch (InvalidArgumentException e) {
436       // Expected exception.
437     }
438   }
439 
440   @Test
deleteModelTest()441   public void deleteModelTest() throws Exception {
442     Empty expectedResponse = Empty.newBuilder().build();
443     mockModelService.addResponse(expectedResponse);
444 
445     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
446 
447     client.deleteModel(name);
448 
449     List<AbstractMessage> actualRequests = mockModelService.getRequests();
450     Assert.assertEquals(1, actualRequests.size());
451     DeleteModelRequest actualRequest = ((DeleteModelRequest) actualRequests.get(0));
452 
453     Assert.assertEquals(name.toString(), actualRequest.getName());
454     Assert.assertTrue(
455         channelProvider.isHeaderSent(
456             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
457             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
458   }
459 
460   @Test
deleteModelExceptionTest()461   public void deleteModelExceptionTest() throws Exception {
462     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
463     mockModelService.addException(exception);
464 
465     try {
466       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
467       client.deleteModel(name);
468       Assert.fail("No exception raised");
469     } catch (InvalidArgumentException e) {
470       // Expected exception.
471     }
472   }
473 
474   @Test
deleteModelTest2()475   public void deleteModelTest2() throws Exception {
476     Empty expectedResponse = Empty.newBuilder().build();
477     mockModelService.addResponse(expectedResponse);
478 
479     String name = "name3373707";
480 
481     client.deleteModel(name);
482 
483     List<AbstractMessage> actualRequests = mockModelService.getRequests();
484     Assert.assertEquals(1, actualRequests.size());
485     DeleteModelRequest actualRequest = ((DeleteModelRequest) actualRequests.get(0));
486 
487     Assert.assertEquals(name, actualRequest.getName());
488     Assert.assertTrue(
489         channelProvider.isHeaderSent(
490             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
491             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
492   }
493 
494   @Test
deleteModelExceptionTest2()495   public void deleteModelExceptionTest2() throws Exception {
496     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
497     mockModelService.addException(exception);
498 
499     try {
500       String name = "name3373707";
501       client.deleteModel(name);
502       Assert.fail("No exception raised");
503     } catch (InvalidArgumentException e) {
504       // Expected exception.
505     }
506   }
507 
508   @Test
listModelsTest()509   public void listModelsTest() throws Exception {
510     Model responsesElement = Model.newBuilder().build();
511     ListModelsResponse expectedResponse =
512         ListModelsResponse.newBuilder()
513             .setNextPageToken("")
514             .addAllModels(Arrays.asList(responsesElement))
515             .build();
516     mockModelService.addResponse(expectedResponse);
517 
518     CatalogName parent = CatalogName.of("[PROJECT]", "[LOCATION]", "[CATALOG]");
519 
520     ListModelsPagedResponse pagedListResponse = client.listModels(parent);
521 
522     List<Model> resources = Lists.newArrayList(pagedListResponse.iterateAll());
523 
524     Assert.assertEquals(1, resources.size());
525     Assert.assertEquals(expectedResponse.getModelsList().get(0), resources.get(0));
526 
527     List<AbstractMessage> actualRequests = mockModelService.getRequests();
528     Assert.assertEquals(1, actualRequests.size());
529     ListModelsRequest actualRequest = ((ListModelsRequest) actualRequests.get(0));
530 
531     Assert.assertEquals(parent.toString(), actualRequest.getParent());
532     Assert.assertTrue(
533         channelProvider.isHeaderSent(
534             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
535             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
536   }
537 
538   @Test
listModelsExceptionTest()539   public void listModelsExceptionTest() throws Exception {
540     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
541     mockModelService.addException(exception);
542 
543     try {
544       CatalogName parent = CatalogName.of("[PROJECT]", "[LOCATION]", "[CATALOG]");
545       client.listModels(parent);
546       Assert.fail("No exception raised");
547     } catch (InvalidArgumentException e) {
548       // Expected exception.
549     }
550   }
551 
552   @Test
listModelsTest2()553   public void listModelsTest2() throws Exception {
554     Model responsesElement = Model.newBuilder().build();
555     ListModelsResponse expectedResponse =
556         ListModelsResponse.newBuilder()
557             .setNextPageToken("")
558             .addAllModels(Arrays.asList(responsesElement))
559             .build();
560     mockModelService.addResponse(expectedResponse);
561 
562     String parent = "parent-995424086";
563 
564     ListModelsPagedResponse pagedListResponse = client.listModels(parent);
565 
566     List<Model> resources = Lists.newArrayList(pagedListResponse.iterateAll());
567 
568     Assert.assertEquals(1, resources.size());
569     Assert.assertEquals(expectedResponse.getModelsList().get(0), resources.get(0));
570 
571     List<AbstractMessage> actualRequests = mockModelService.getRequests();
572     Assert.assertEquals(1, actualRequests.size());
573     ListModelsRequest actualRequest = ((ListModelsRequest) actualRequests.get(0));
574 
575     Assert.assertEquals(parent, actualRequest.getParent());
576     Assert.assertTrue(
577         channelProvider.isHeaderSent(
578             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
579             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
580   }
581 
582   @Test
listModelsExceptionTest2()583   public void listModelsExceptionTest2() throws Exception {
584     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
585     mockModelService.addException(exception);
586 
587     try {
588       String parent = "parent-995424086";
589       client.listModels(parent);
590       Assert.fail("No exception raised");
591     } catch (InvalidArgumentException e) {
592       // Expected exception.
593     }
594   }
595 
596   @Test
updateModelTest()597   public void updateModelTest() throws Exception {
598     Model expectedResponse =
599         Model.newBuilder()
600             .setName(ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]").toString())
601             .setDisplayName("displayName1714148973")
602             .setCreateTime(Timestamp.newBuilder().build())
603             .setUpdateTime(Timestamp.newBuilder().build())
604             .setType("type3575610")
605             .setOptimizationObjective("optimizationObjective-1014459828")
606             .setLastTuneTime(Timestamp.newBuilder().build())
607             .setTuningOperation("tuningOperation-1269747150")
608             .setFilteringOption(RecommendationsFilteringOption.forNumber(0))
609             .addAllServingConfigLists(new ArrayList<Model.ServingConfigList>())
610             .build();
611     mockModelService.addResponse(expectedResponse);
612 
613     Model model = Model.newBuilder().build();
614     FieldMask updateMask = FieldMask.newBuilder().build();
615 
616     Model actualResponse = client.updateModel(model, updateMask);
617     Assert.assertEquals(expectedResponse, actualResponse);
618 
619     List<AbstractMessage> actualRequests = mockModelService.getRequests();
620     Assert.assertEquals(1, actualRequests.size());
621     UpdateModelRequest actualRequest = ((UpdateModelRequest) actualRequests.get(0));
622 
623     Assert.assertEquals(model, actualRequest.getModel());
624     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
625     Assert.assertTrue(
626         channelProvider.isHeaderSent(
627             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
628             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
629   }
630 
631   @Test
updateModelExceptionTest()632   public void updateModelExceptionTest() throws Exception {
633     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
634     mockModelService.addException(exception);
635 
636     try {
637       Model model = Model.newBuilder().build();
638       FieldMask updateMask = FieldMask.newBuilder().build();
639       client.updateModel(model, updateMask);
640       Assert.fail("No exception raised");
641     } catch (InvalidArgumentException e) {
642       // Expected exception.
643     }
644   }
645 
646   @Test
tuneModelTest()647   public void tuneModelTest() throws Exception {
648     TuneModelResponse expectedResponse = TuneModelResponse.newBuilder().build();
649     Operation resultOperation =
650         Operation.newBuilder()
651             .setName("tuneModelTest")
652             .setDone(true)
653             .setResponse(Any.pack(expectedResponse))
654             .build();
655     mockModelService.addResponse(resultOperation);
656 
657     ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
658 
659     TuneModelResponse actualResponse = client.tuneModelAsync(name).get();
660     Assert.assertEquals(expectedResponse, actualResponse);
661 
662     List<AbstractMessage> actualRequests = mockModelService.getRequests();
663     Assert.assertEquals(1, actualRequests.size());
664     TuneModelRequest actualRequest = ((TuneModelRequest) actualRequests.get(0));
665 
666     Assert.assertEquals(name.toString(), actualRequest.getName());
667     Assert.assertTrue(
668         channelProvider.isHeaderSent(
669             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
670             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
671   }
672 
673   @Test
tuneModelExceptionTest()674   public void tuneModelExceptionTest() throws Exception {
675     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
676     mockModelService.addException(exception);
677 
678     try {
679       ModelName name = ModelName.of("[PROJECT]", "[LOCATION]", "[CATALOG]", "[MODEL]");
680       client.tuneModelAsync(name).get();
681       Assert.fail("No exception raised");
682     } catch (ExecutionException e) {
683       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
684       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
685       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
686     }
687   }
688 
689   @Test
tuneModelTest2()690   public void tuneModelTest2() throws Exception {
691     TuneModelResponse expectedResponse = TuneModelResponse.newBuilder().build();
692     Operation resultOperation =
693         Operation.newBuilder()
694             .setName("tuneModelTest")
695             .setDone(true)
696             .setResponse(Any.pack(expectedResponse))
697             .build();
698     mockModelService.addResponse(resultOperation);
699 
700     String name = "name3373707";
701 
702     TuneModelResponse actualResponse = client.tuneModelAsync(name).get();
703     Assert.assertEquals(expectedResponse, actualResponse);
704 
705     List<AbstractMessage> actualRequests = mockModelService.getRequests();
706     Assert.assertEquals(1, actualRequests.size());
707     TuneModelRequest actualRequest = ((TuneModelRequest) actualRequests.get(0));
708 
709     Assert.assertEquals(name, actualRequest.getName());
710     Assert.assertTrue(
711         channelProvider.isHeaderSent(
712             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
713             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
714   }
715 
716   @Test
tuneModelExceptionTest2()717   public void tuneModelExceptionTest2() throws Exception {
718     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
719     mockModelService.addException(exception);
720 
721     try {
722       String name = "name3373707";
723       client.tuneModelAsync(name).get();
724       Assert.fail("No exception raised");
725     } catch (ExecutionException e) {
726       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
727       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
728       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
729     }
730   }
731 }
732