• 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.recommender.v1beta1;
18 
19 import static com.google.cloud.recommender.v1beta1.RecommenderClient.ListInsightsPagedResponse;
20 import static com.google.cloud.recommender.v1beta1.RecommenderClient.ListRecommendationsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
24 import com.google.api.gax.httpjson.testing.MockHttpService;
25 import com.google.api.gax.rpc.ApiClientHeaderProvider;
26 import com.google.api.gax.rpc.ApiException;
27 import com.google.api.gax.rpc.ApiExceptionFactory;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.api.gax.rpc.testing.FakeStatusCode;
31 import com.google.cloud.recommender.v1beta1.stub.HttpJsonRecommenderStub;
32 import com.google.common.collect.Lists;
33 import com.google.protobuf.Duration;
34 import com.google.protobuf.FieldMask;
35 import com.google.protobuf.Struct;
36 import com.google.protobuf.Timestamp;
37 import java.io.IOException;
38 import java.util.ArrayList;
39 import java.util.Arrays;
40 import java.util.HashMap;
41 import java.util.List;
42 import java.util.Map;
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 RecommenderClientHttpJsonTest {
53   private static MockHttpService mockService;
54   private static RecommenderClient client;
55 
56   @BeforeClass
startStaticServer()57   public static void startStaticServer() throws IOException {
58     mockService =
59         new MockHttpService(
60             HttpJsonRecommenderStub.getMethodDescriptors(),
61             RecommenderSettings.getDefaultEndpoint());
62     RecommenderSettings settings =
63         RecommenderSettings.newHttpJsonBuilder()
64             .setTransportChannelProvider(
65                 RecommenderSettings.defaultHttpJsonTransportProviderBuilder()
66                     .setHttpTransport(mockService)
67                     .build())
68             .setCredentialsProvider(NoCredentialsProvider.create())
69             .build();
70     client = RecommenderClient.create(settings);
71   }
72 
73   @AfterClass
stopServer()74   public static void stopServer() {
75     client.close();
76   }
77 
78   @Before
setUp()79   public void setUp() {}
80 
81   @After
tearDown()82   public void tearDown() throws Exception {
83     mockService.reset();
84   }
85 
86   @Test
listInsightsTest()87   public void listInsightsTest() throws Exception {
88     Insight responsesElement = Insight.newBuilder().build();
89     ListInsightsResponse expectedResponse =
90         ListInsightsResponse.newBuilder()
91             .setNextPageToken("")
92             .addAllInsights(Arrays.asList(responsesElement))
93             .build();
94     mockService.addResponse(expectedResponse);
95 
96     InsightTypeName parent =
97         InsightTypeName.ofProjectLocationInsightTypeName(
98             "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]");
99 
100     ListInsightsPagedResponse pagedListResponse = client.listInsights(parent);
101 
102     List<Insight> resources = Lists.newArrayList(pagedListResponse.iterateAll());
103 
104     Assert.assertEquals(1, resources.size());
105     Assert.assertEquals(expectedResponse.getInsightsList().get(0), resources.get(0));
106 
107     List<String> actualRequests = mockService.getRequestPaths();
108     Assert.assertEquals(1, actualRequests.size());
109 
110     String apiClientHeaderKey =
111         mockService
112             .getRequestHeaders()
113             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
114             .iterator()
115             .next();
116     Assert.assertTrue(
117         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
118             .matcher(apiClientHeaderKey)
119             .matches());
120   }
121 
122   @Test
listInsightsExceptionTest()123   public void listInsightsExceptionTest() throws Exception {
124     ApiException exception =
125         ApiExceptionFactory.createException(
126             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
127     mockService.addException(exception);
128 
129     try {
130       InsightTypeName parent =
131           InsightTypeName.ofProjectLocationInsightTypeName(
132               "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]");
133       client.listInsights(parent);
134       Assert.fail("No exception raised");
135     } catch (InvalidArgumentException e) {
136       // Expected exception.
137     }
138   }
139 
140   @Test
listInsightsTest2()141   public void listInsightsTest2() throws Exception {
142     Insight responsesElement = Insight.newBuilder().build();
143     ListInsightsResponse expectedResponse =
144         ListInsightsResponse.newBuilder()
145             .setNextPageToken("")
146             .addAllInsights(Arrays.asList(responsesElement))
147             .build();
148     mockService.addResponse(expectedResponse);
149 
150     String parent = "projects/project-8290/locations/location-8290/insightTypes/insightType-8290";
151 
152     ListInsightsPagedResponse pagedListResponse = client.listInsights(parent);
153 
154     List<Insight> resources = Lists.newArrayList(pagedListResponse.iterateAll());
155 
156     Assert.assertEquals(1, resources.size());
157     Assert.assertEquals(expectedResponse.getInsightsList().get(0), resources.get(0));
158 
159     List<String> actualRequests = mockService.getRequestPaths();
160     Assert.assertEquals(1, actualRequests.size());
161 
162     String apiClientHeaderKey =
163         mockService
164             .getRequestHeaders()
165             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
166             .iterator()
167             .next();
168     Assert.assertTrue(
169         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
170             .matcher(apiClientHeaderKey)
171             .matches());
172   }
173 
174   @Test
listInsightsExceptionTest2()175   public void listInsightsExceptionTest2() throws Exception {
176     ApiException exception =
177         ApiExceptionFactory.createException(
178             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
179     mockService.addException(exception);
180 
181     try {
182       String parent = "projects/project-8290/locations/location-8290/insightTypes/insightType-8290";
183       client.listInsights(parent);
184       Assert.fail("No exception raised");
185     } catch (InvalidArgumentException e) {
186       // Expected exception.
187     }
188   }
189 
190   @Test
getInsightTest()191   public void getInsightTest() throws Exception {
192     Insight expectedResponse =
193         Insight.newBuilder()
194             .setName(
195                 InsightName.ofProjectLocationInsightTypeInsightName(
196                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]")
197                     .toString())
198             .setDescription("description-1724546052")
199             .addAllTargetResources(new ArrayList<String>())
200             .setInsightSubtype("insightSubtype841535170")
201             .setContent(Struct.newBuilder().build())
202             .setLastRefreshTime(Timestamp.newBuilder().build())
203             .setObservationPeriod(Duration.newBuilder().build())
204             .setStateInfo(InsightStateInfo.newBuilder().build())
205             .setEtag("etag3123477")
206             .addAllAssociatedRecommendations(new ArrayList<Insight.RecommendationReference>())
207             .build();
208     mockService.addResponse(expectedResponse);
209 
210     InsightName name =
211         InsightName.ofProjectLocationInsightTypeInsightName(
212             "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]");
213 
214     Insight actualResponse = client.getInsight(name);
215     Assert.assertEquals(expectedResponse, actualResponse);
216 
217     List<String> actualRequests = mockService.getRequestPaths();
218     Assert.assertEquals(1, actualRequests.size());
219 
220     String apiClientHeaderKey =
221         mockService
222             .getRequestHeaders()
223             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
224             .iterator()
225             .next();
226     Assert.assertTrue(
227         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
228             .matcher(apiClientHeaderKey)
229             .matches());
230   }
231 
232   @Test
getInsightExceptionTest()233   public void getInsightExceptionTest() throws Exception {
234     ApiException exception =
235         ApiExceptionFactory.createException(
236             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
237     mockService.addException(exception);
238 
239     try {
240       InsightName name =
241           InsightName.ofProjectLocationInsightTypeInsightName(
242               "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]");
243       client.getInsight(name);
244       Assert.fail("No exception raised");
245     } catch (InvalidArgumentException e) {
246       // Expected exception.
247     }
248   }
249 
250   @Test
getInsightTest2()251   public void getInsightTest2() throws Exception {
252     Insight expectedResponse =
253         Insight.newBuilder()
254             .setName(
255                 InsightName.ofProjectLocationInsightTypeInsightName(
256                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]")
257                     .toString())
258             .setDescription("description-1724546052")
259             .addAllTargetResources(new ArrayList<String>())
260             .setInsightSubtype("insightSubtype841535170")
261             .setContent(Struct.newBuilder().build())
262             .setLastRefreshTime(Timestamp.newBuilder().build())
263             .setObservationPeriod(Duration.newBuilder().build())
264             .setStateInfo(InsightStateInfo.newBuilder().build())
265             .setEtag("etag3123477")
266             .addAllAssociatedRecommendations(new ArrayList<Insight.RecommendationReference>())
267             .build();
268     mockService.addResponse(expectedResponse);
269 
270     String name =
271         "projects/project-3636/locations/location-3636/insightTypes/insightType-3636/insights/insight-3636";
272 
273     Insight actualResponse = client.getInsight(name);
274     Assert.assertEquals(expectedResponse, actualResponse);
275 
276     List<String> actualRequests = mockService.getRequestPaths();
277     Assert.assertEquals(1, actualRequests.size());
278 
279     String apiClientHeaderKey =
280         mockService
281             .getRequestHeaders()
282             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
283             .iterator()
284             .next();
285     Assert.assertTrue(
286         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
287             .matcher(apiClientHeaderKey)
288             .matches());
289   }
290 
291   @Test
getInsightExceptionTest2()292   public void getInsightExceptionTest2() throws Exception {
293     ApiException exception =
294         ApiExceptionFactory.createException(
295             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
296     mockService.addException(exception);
297 
298     try {
299       String name =
300           "projects/project-3636/locations/location-3636/insightTypes/insightType-3636/insights/insight-3636";
301       client.getInsight(name);
302       Assert.fail("No exception raised");
303     } catch (InvalidArgumentException e) {
304       // Expected exception.
305     }
306   }
307 
308   @Test
markInsightAcceptedTest()309   public void markInsightAcceptedTest() throws Exception {
310     Insight expectedResponse =
311         Insight.newBuilder()
312             .setName(
313                 InsightName.ofProjectLocationInsightTypeInsightName(
314                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]")
315                     .toString())
316             .setDescription("description-1724546052")
317             .addAllTargetResources(new ArrayList<String>())
318             .setInsightSubtype("insightSubtype841535170")
319             .setContent(Struct.newBuilder().build())
320             .setLastRefreshTime(Timestamp.newBuilder().build())
321             .setObservationPeriod(Duration.newBuilder().build())
322             .setStateInfo(InsightStateInfo.newBuilder().build())
323             .setEtag("etag3123477")
324             .addAllAssociatedRecommendations(new ArrayList<Insight.RecommendationReference>())
325             .build();
326     mockService.addResponse(expectedResponse);
327 
328     InsightName name =
329         InsightName.ofProjectLocationInsightTypeInsightName(
330             "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]");
331     Map<String, String> stateMetadata = new HashMap<>();
332     String etag = "etag3123477";
333 
334     Insight actualResponse = client.markInsightAccepted(name, stateMetadata, etag);
335     Assert.assertEquals(expectedResponse, actualResponse);
336 
337     List<String> actualRequests = mockService.getRequestPaths();
338     Assert.assertEquals(1, actualRequests.size());
339 
340     String apiClientHeaderKey =
341         mockService
342             .getRequestHeaders()
343             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
344             .iterator()
345             .next();
346     Assert.assertTrue(
347         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
348             .matcher(apiClientHeaderKey)
349             .matches());
350   }
351 
352   @Test
markInsightAcceptedExceptionTest()353   public void markInsightAcceptedExceptionTest() throws Exception {
354     ApiException exception =
355         ApiExceptionFactory.createException(
356             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
357     mockService.addException(exception);
358 
359     try {
360       InsightName name =
361           InsightName.ofProjectLocationInsightTypeInsightName(
362               "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]");
363       Map<String, String> stateMetadata = new HashMap<>();
364       String etag = "etag3123477";
365       client.markInsightAccepted(name, stateMetadata, etag);
366       Assert.fail("No exception raised");
367     } catch (InvalidArgumentException e) {
368       // Expected exception.
369     }
370   }
371 
372   @Test
markInsightAcceptedTest2()373   public void markInsightAcceptedTest2() throws Exception {
374     Insight expectedResponse =
375         Insight.newBuilder()
376             .setName(
377                 InsightName.ofProjectLocationInsightTypeInsightName(
378                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]", "[INSIGHT]")
379                     .toString())
380             .setDescription("description-1724546052")
381             .addAllTargetResources(new ArrayList<String>())
382             .setInsightSubtype("insightSubtype841535170")
383             .setContent(Struct.newBuilder().build())
384             .setLastRefreshTime(Timestamp.newBuilder().build())
385             .setObservationPeriod(Duration.newBuilder().build())
386             .setStateInfo(InsightStateInfo.newBuilder().build())
387             .setEtag("etag3123477")
388             .addAllAssociatedRecommendations(new ArrayList<Insight.RecommendationReference>())
389             .build();
390     mockService.addResponse(expectedResponse);
391 
392     String name =
393         "projects/project-3636/locations/location-3636/insightTypes/insightType-3636/insights/insight-3636";
394     Map<String, String> stateMetadata = new HashMap<>();
395     String etag = "etag3123477";
396 
397     Insight actualResponse = client.markInsightAccepted(name, stateMetadata, etag);
398     Assert.assertEquals(expectedResponse, actualResponse);
399 
400     List<String> actualRequests = mockService.getRequestPaths();
401     Assert.assertEquals(1, actualRequests.size());
402 
403     String apiClientHeaderKey =
404         mockService
405             .getRequestHeaders()
406             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
407             .iterator()
408             .next();
409     Assert.assertTrue(
410         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
411             .matcher(apiClientHeaderKey)
412             .matches());
413   }
414 
415   @Test
markInsightAcceptedExceptionTest2()416   public void markInsightAcceptedExceptionTest2() throws Exception {
417     ApiException exception =
418         ApiExceptionFactory.createException(
419             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
420     mockService.addException(exception);
421 
422     try {
423       String name =
424           "projects/project-3636/locations/location-3636/insightTypes/insightType-3636/insights/insight-3636";
425       Map<String, String> stateMetadata = new HashMap<>();
426       String etag = "etag3123477";
427       client.markInsightAccepted(name, stateMetadata, etag);
428       Assert.fail("No exception raised");
429     } catch (InvalidArgumentException e) {
430       // Expected exception.
431     }
432   }
433 
434   @Test
listRecommendationsTest()435   public void listRecommendationsTest() throws Exception {
436     Recommendation responsesElement = Recommendation.newBuilder().build();
437     ListRecommendationsResponse expectedResponse =
438         ListRecommendationsResponse.newBuilder()
439             .setNextPageToken("")
440             .addAllRecommendations(Arrays.asList(responsesElement))
441             .build();
442     mockService.addResponse(expectedResponse);
443 
444     RecommenderName parent =
445         RecommenderName.ofProjectLocationRecommenderName(
446             "[PROJECT]", "[LOCATION]", "[RECOMMENDER]");
447     String filter = "filter-1274492040";
448 
449     ListRecommendationsPagedResponse pagedListResponse = client.listRecommendations(parent, filter);
450 
451     List<Recommendation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
452 
453     Assert.assertEquals(1, resources.size());
454     Assert.assertEquals(expectedResponse.getRecommendationsList().get(0), resources.get(0));
455 
456     List<String> actualRequests = mockService.getRequestPaths();
457     Assert.assertEquals(1, actualRequests.size());
458 
459     String apiClientHeaderKey =
460         mockService
461             .getRequestHeaders()
462             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
463             .iterator()
464             .next();
465     Assert.assertTrue(
466         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
467             .matcher(apiClientHeaderKey)
468             .matches());
469   }
470 
471   @Test
listRecommendationsExceptionTest()472   public void listRecommendationsExceptionTest() throws Exception {
473     ApiException exception =
474         ApiExceptionFactory.createException(
475             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
476     mockService.addException(exception);
477 
478     try {
479       RecommenderName parent =
480           RecommenderName.ofProjectLocationRecommenderName(
481               "[PROJECT]", "[LOCATION]", "[RECOMMENDER]");
482       String filter = "filter-1274492040";
483       client.listRecommendations(parent, filter);
484       Assert.fail("No exception raised");
485     } catch (InvalidArgumentException e) {
486       // Expected exception.
487     }
488   }
489 
490   @Test
listRecommendationsTest2()491   public void listRecommendationsTest2() throws Exception {
492     Recommendation responsesElement = Recommendation.newBuilder().build();
493     ListRecommendationsResponse expectedResponse =
494         ListRecommendationsResponse.newBuilder()
495             .setNextPageToken("")
496             .addAllRecommendations(Arrays.asList(responsesElement))
497             .build();
498     mockService.addResponse(expectedResponse);
499 
500     String parent = "projects/project-6437/locations/location-6437/recommenders/recommender-6437";
501     String filter = "filter-1274492040";
502 
503     ListRecommendationsPagedResponse pagedListResponse = client.listRecommendations(parent, filter);
504 
505     List<Recommendation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
506 
507     Assert.assertEquals(1, resources.size());
508     Assert.assertEquals(expectedResponse.getRecommendationsList().get(0), resources.get(0));
509 
510     List<String> actualRequests = mockService.getRequestPaths();
511     Assert.assertEquals(1, actualRequests.size());
512 
513     String apiClientHeaderKey =
514         mockService
515             .getRequestHeaders()
516             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
517             .iterator()
518             .next();
519     Assert.assertTrue(
520         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
521             .matcher(apiClientHeaderKey)
522             .matches());
523   }
524 
525   @Test
listRecommendationsExceptionTest2()526   public void listRecommendationsExceptionTest2() throws Exception {
527     ApiException exception =
528         ApiExceptionFactory.createException(
529             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
530     mockService.addException(exception);
531 
532     try {
533       String parent = "projects/project-6437/locations/location-6437/recommenders/recommender-6437";
534       String filter = "filter-1274492040";
535       client.listRecommendations(parent, filter);
536       Assert.fail("No exception raised");
537     } catch (InvalidArgumentException e) {
538       // Expected exception.
539     }
540   }
541 
542   @Test
getRecommendationTest()543   public void getRecommendationTest() throws Exception {
544     Recommendation expectedResponse =
545         Recommendation.newBuilder()
546             .setName(
547                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
548                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
549                     .toString())
550             .setDescription("description-1724546052")
551             .setRecommenderSubtype("recommenderSubtype1811451601")
552             .setLastRefreshTime(Timestamp.newBuilder().build())
553             .setPrimaryImpact(Impact.newBuilder().build())
554             .addAllAdditionalImpact(new ArrayList<Impact>())
555             .setContent(RecommendationContent.newBuilder().build())
556             .setStateInfo(RecommendationStateInfo.newBuilder().build())
557             .setEtag("etag3123477")
558             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
559             .setXorGroupId("xorGroupId-2095769825")
560             .build();
561     mockService.addResponse(expectedResponse);
562 
563     RecommendationName name =
564         RecommendationName.ofProjectLocationRecommenderRecommendationName(
565             "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
566 
567     Recommendation actualResponse = client.getRecommendation(name);
568     Assert.assertEquals(expectedResponse, actualResponse);
569 
570     List<String> actualRequests = mockService.getRequestPaths();
571     Assert.assertEquals(1, actualRequests.size());
572 
573     String apiClientHeaderKey =
574         mockService
575             .getRequestHeaders()
576             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
577             .iterator()
578             .next();
579     Assert.assertTrue(
580         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
581             .matcher(apiClientHeaderKey)
582             .matches());
583   }
584 
585   @Test
getRecommendationExceptionTest()586   public void getRecommendationExceptionTest() throws Exception {
587     ApiException exception =
588         ApiExceptionFactory.createException(
589             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
590     mockService.addException(exception);
591 
592     try {
593       RecommendationName name =
594           RecommendationName.ofProjectLocationRecommenderRecommendationName(
595               "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
596       client.getRecommendation(name);
597       Assert.fail("No exception raised");
598     } catch (InvalidArgumentException e) {
599       // Expected exception.
600     }
601   }
602 
603   @Test
getRecommendationTest2()604   public void getRecommendationTest2() throws Exception {
605     Recommendation expectedResponse =
606         Recommendation.newBuilder()
607             .setName(
608                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
609                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
610                     .toString())
611             .setDescription("description-1724546052")
612             .setRecommenderSubtype("recommenderSubtype1811451601")
613             .setLastRefreshTime(Timestamp.newBuilder().build())
614             .setPrimaryImpact(Impact.newBuilder().build())
615             .addAllAdditionalImpact(new ArrayList<Impact>())
616             .setContent(RecommendationContent.newBuilder().build())
617             .setStateInfo(RecommendationStateInfo.newBuilder().build())
618             .setEtag("etag3123477")
619             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
620             .setXorGroupId("xorGroupId-2095769825")
621             .build();
622     mockService.addResponse(expectedResponse);
623 
624     String name =
625         "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
626 
627     Recommendation actualResponse = client.getRecommendation(name);
628     Assert.assertEquals(expectedResponse, actualResponse);
629 
630     List<String> actualRequests = mockService.getRequestPaths();
631     Assert.assertEquals(1, actualRequests.size());
632 
633     String apiClientHeaderKey =
634         mockService
635             .getRequestHeaders()
636             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
637             .iterator()
638             .next();
639     Assert.assertTrue(
640         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
641             .matcher(apiClientHeaderKey)
642             .matches());
643   }
644 
645   @Test
getRecommendationExceptionTest2()646   public void getRecommendationExceptionTest2() throws Exception {
647     ApiException exception =
648         ApiExceptionFactory.createException(
649             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
650     mockService.addException(exception);
651 
652     try {
653       String name =
654           "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
655       client.getRecommendation(name);
656       Assert.fail("No exception raised");
657     } catch (InvalidArgumentException e) {
658       // Expected exception.
659     }
660   }
661 
662   @Test
markRecommendationClaimedTest()663   public void markRecommendationClaimedTest() throws Exception {
664     Recommendation expectedResponse =
665         Recommendation.newBuilder()
666             .setName(
667                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
668                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
669                     .toString())
670             .setDescription("description-1724546052")
671             .setRecommenderSubtype("recommenderSubtype1811451601")
672             .setLastRefreshTime(Timestamp.newBuilder().build())
673             .setPrimaryImpact(Impact.newBuilder().build())
674             .addAllAdditionalImpact(new ArrayList<Impact>())
675             .setContent(RecommendationContent.newBuilder().build())
676             .setStateInfo(RecommendationStateInfo.newBuilder().build())
677             .setEtag("etag3123477")
678             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
679             .setXorGroupId("xorGroupId-2095769825")
680             .build();
681     mockService.addResponse(expectedResponse);
682 
683     RecommendationName name =
684         RecommendationName.ofProjectLocationRecommenderRecommendationName(
685             "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
686     Map<String, String> stateMetadata = new HashMap<>();
687     String etag = "etag3123477";
688 
689     Recommendation actualResponse = client.markRecommendationClaimed(name, stateMetadata, etag);
690     Assert.assertEquals(expectedResponse, actualResponse);
691 
692     List<String> actualRequests = mockService.getRequestPaths();
693     Assert.assertEquals(1, actualRequests.size());
694 
695     String apiClientHeaderKey =
696         mockService
697             .getRequestHeaders()
698             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
699             .iterator()
700             .next();
701     Assert.assertTrue(
702         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
703             .matcher(apiClientHeaderKey)
704             .matches());
705   }
706 
707   @Test
markRecommendationClaimedExceptionTest()708   public void markRecommendationClaimedExceptionTest() throws Exception {
709     ApiException exception =
710         ApiExceptionFactory.createException(
711             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
712     mockService.addException(exception);
713 
714     try {
715       RecommendationName name =
716           RecommendationName.ofProjectLocationRecommenderRecommendationName(
717               "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
718       Map<String, String> stateMetadata = new HashMap<>();
719       String etag = "etag3123477";
720       client.markRecommendationClaimed(name, stateMetadata, etag);
721       Assert.fail("No exception raised");
722     } catch (InvalidArgumentException e) {
723       // Expected exception.
724     }
725   }
726 
727   @Test
markRecommendationClaimedTest2()728   public void markRecommendationClaimedTest2() throws Exception {
729     Recommendation expectedResponse =
730         Recommendation.newBuilder()
731             .setName(
732                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
733                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
734                     .toString())
735             .setDescription("description-1724546052")
736             .setRecommenderSubtype("recommenderSubtype1811451601")
737             .setLastRefreshTime(Timestamp.newBuilder().build())
738             .setPrimaryImpact(Impact.newBuilder().build())
739             .addAllAdditionalImpact(new ArrayList<Impact>())
740             .setContent(RecommendationContent.newBuilder().build())
741             .setStateInfo(RecommendationStateInfo.newBuilder().build())
742             .setEtag("etag3123477")
743             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
744             .setXorGroupId("xorGroupId-2095769825")
745             .build();
746     mockService.addResponse(expectedResponse);
747 
748     String name =
749         "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
750     Map<String, String> stateMetadata = new HashMap<>();
751     String etag = "etag3123477";
752 
753     Recommendation actualResponse = client.markRecommendationClaimed(name, stateMetadata, etag);
754     Assert.assertEquals(expectedResponse, actualResponse);
755 
756     List<String> actualRequests = mockService.getRequestPaths();
757     Assert.assertEquals(1, actualRequests.size());
758 
759     String apiClientHeaderKey =
760         mockService
761             .getRequestHeaders()
762             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
763             .iterator()
764             .next();
765     Assert.assertTrue(
766         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
767             .matcher(apiClientHeaderKey)
768             .matches());
769   }
770 
771   @Test
markRecommendationClaimedExceptionTest2()772   public void markRecommendationClaimedExceptionTest2() throws Exception {
773     ApiException exception =
774         ApiExceptionFactory.createException(
775             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
776     mockService.addException(exception);
777 
778     try {
779       String name =
780           "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
781       Map<String, String> stateMetadata = new HashMap<>();
782       String etag = "etag3123477";
783       client.markRecommendationClaimed(name, stateMetadata, etag);
784       Assert.fail("No exception raised");
785     } catch (InvalidArgumentException e) {
786       // Expected exception.
787     }
788   }
789 
790   @Test
markRecommendationSucceededTest()791   public void markRecommendationSucceededTest() throws Exception {
792     Recommendation expectedResponse =
793         Recommendation.newBuilder()
794             .setName(
795                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
796                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
797                     .toString())
798             .setDescription("description-1724546052")
799             .setRecommenderSubtype("recommenderSubtype1811451601")
800             .setLastRefreshTime(Timestamp.newBuilder().build())
801             .setPrimaryImpact(Impact.newBuilder().build())
802             .addAllAdditionalImpact(new ArrayList<Impact>())
803             .setContent(RecommendationContent.newBuilder().build())
804             .setStateInfo(RecommendationStateInfo.newBuilder().build())
805             .setEtag("etag3123477")
806             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
807             .setXorGroupId("xorGroupId-2095769825")
808             .build();
809     mockService.addResponse(expectedResponse);
810 
811     RecommendationName name =
812         RecommendationName.ofProjectLocationRecommenderRecommendationName(
813             "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
814     Map<String, String> stateMetadata = new HashMap<>();
815     String etag = "etag3123477";
816 
817     Recommendation actualResponse = client.markRecommendationSucceeded(name, stateMetadata, etag);
818     Assert.assertEquals(expectedResponse, actualResponse);
819 
820     List<String> actualRequests = mockService.getRequestPaths();
821     Assert.assertEquals(1, actualRequests.size());
822 
823     String apiClientHeaderKey =
824         mockService
825             .getRequestHeaders()
826             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
827             .iterator()
828             .next();
829     Assert.assertTrue(
830         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
831             .matcher(apiClientHeaderKey)
832             .matches());
833   }
834 
835   @Test
markRecommendationSucceededExceptionTest()836   public void markRecommendationSucceededExceptionTest() throws Exception {
837     ApiException exception =
838         ApiExceptionFactory.createException(
839             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
840     mockService.addException(exception);
841 
842     try {
843       RecommendationName name =
844           RecommendationName.ofProjectLocationRecommenderRecommendationName(
845               "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
846       Map<String, String> stateMetadata = new HashMap<>();
847       String etag = "etag3123477";
848       client.markRecommendationSucceeded(name, stateMetadata, etag);
849       Assert.fail("No exception raised");
850     } catch (InvalidArgumentException e) {
851       // Expected exception.
852     }
853   }
854 
855   @Test
markRecommendationSucceededTest2()856   public void markRecommendationSucceededTest2() throws Exception {
857     Recommendation expectedResponse =
858         Recommendation.newBuilder()
859             .setName(
860                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
861                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
862                     .toString())
863             .setDescription("description-1724546052")
864             .setRecommenderSubtype("recommenderSubtype1811451601")
865             .setLastRefreshTime(Timestamp.newBuilder().build())
866             .setPrimaryImpact(Impact.newBuilder().build())
867             .addAllAdditionalImpact(new ArrayList<Impact>())
868             .setContent(RecommendationContent.newBuilder().build())
869             .setStateInfo(RecommendationStateInfo.newBuilder().build())
870             .setEtag("etag3123477")
871             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
872             .setXorGroupId("xorGroupId-2095769825")
873             .build();
874     mockService.addResponse(expectedResponse);
875 
876     String name =
877         "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
878     Map<String, String> stateMetadata = new HashMap<>();
879     String etag = "etag3123477";
880 
881     Recommendation actualResponse = client.markRecommendationSucceeded(name, stateMetadata, etag);
882     Assert.assertEquals(expectedResponse, actualResponse);
883 
884     List<String> actualRequests = mockService.getRequestPaths();
885     Assert.assertEquals(1, actualRequests.size());
886 
887     String apiClientHeaderKey =
888         mockService
889             .getRequestHeaders()
890             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
891             .iterator()
892             .next();
893     Assert.assertTrue(
894         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
895             .matcher(apiClientHeaderKey)
896             .matches());
897   }
898 
899   @Test
markRecommendationSucceededExceptionTest2()900   public void markRecommendationSucceededExceptionTest2() throws Exception {
901     ApiException exception =
902         ApiExceptionFactory.createException(
903             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
904     mockService.addException(exception);
905 
906     try {
907       String name =
908           "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
909       Map<String, String> stateMetadata = new HashMap<>();
910       String etag = "etag3123477";
911       client.markRecommendationSucceeded(name, stateMetadata, etag);
912       Assert.fail("No exception raised");
913     } catch (InvalidArgumentException e) {
914       // Expected exception.
915     }
916   }
917 
918   @Test
markRecommendationFailedTest()919   public void markRecommendationFailedTest() throws Exception {
920     Recommendation expectedResponse =
921         Recommendation.newBuilder()
922             .setName(
923                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
924                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
925                     .toString())
926             .setDescription("description-1724546052")
927             .setRecommenderSubtype("recommenderSubtype1811451601")
928             .setLastRefreshTime(Timestamp.newBuilder().build())
929             .setPrimaryImpact(Impact.newBuilder().build())
930             .addAllAdditionalImpact(new ArrayList<Impact>())
931             .setContent(RecommendationContent.newBuilder().build())
932             .setStateInfo(RecommendationStateInfo.newBuilder().build())
933             .setEtag("etag3123477")
934             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
935             .setXorGroupId("xorGroupId-2095769825")
936             .build();
937     mockService.addResponse(expectedResponse);
938 
939     RecommendationName name =
940         RecommendationName.ofProjectLocationRecommenderRecommendationName(
941             "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
942     Map<String, String> stateMetadata = new HashMap<>();
943     String etag = "etag3123477";
944 
945     Recommendation actualResponse = client.markRecommendationFailed(name, stateMetadata, etag);
946     Assert.assertEquals(expectedResponse, actualResponse);
947 
948     List<String> actualRequests = mockService.getRequestPaths();
949     Assert.assertEquals(1, actualRequests.size());
950 
951     String apiClientHeaderKey =
952         mockService
953             .getRequestHeaders()
954             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
955             .iterator()
956             .next();
957     Assert.assertTrue(
958         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
959             .matcher(apiClientHeaderKey)
960             .matches());
961   }
962 
963   @Test
markRecommendationFailedExceptionTest()964   public void markRecommendationFailedExceptionTest() throws Exception {
965     ApiException exception =
966         ApiExceptionFactory.createException(
967             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
968     mockService.addException(exception);
969 
970     try {
971       RecommendationName name =
972           RecommendationName.ofProjectLocationRecommenderRecommendationName(
973               "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]");
974       Map<String, String> stateMetadata = new HashMap<>();
975       String etag = "etag3123477";
976       client.markRecommendationFailed(name, stateMetadata, etag);
977       Assert.fail("No exception raised");
978     } catch (InvalidArgumentException e) {
979       // Expected exception.
980     }
981   }
982 
983   @Test
markRecommendationFailedTest2()984   public void markRecommendationFailedTest2() throws Exception {
985     Recommendation expectedResponse =
986         Recommendation.newBuilder()
987             .setName(
988                 RecommendationName.ofProjectLocationRecommenderRecommendationName(
989                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]", "[RECOMMENDATION]")
990                     .toString())
991             .setDescription("description-1724546052")
992             .setRecommenderSubtype("recommenderSubtype1811451601")
993             .setLastRefreshTime(Timestamp.newBuilder().build())
994             .setPrimaryImpact(Impact.newBuilder().build())
995             .addAllAdditionalImpact(new ArrayList<Impact>())
996             .setContent(RecommendationContent.newBuilder().build())
997             .setStateInfo(RecommendationStateInfo.newBuilder().build())
998             .setEtag("etag3123477")
999             .addAllAssociatedInsights(new ArrayList<Recommendation.InsightReference>())
1000             .setXorGroupId("xorGroupId-2095769825")
1001             .build();
1002     mockService.addResponse(expectedResponse);
1003 
1004     String name =
1005         "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
1006     Map<String, String> stateMetadata = new HashMap<>();
1007     String etag = "etag3123477";
1008 
1009     Recommendation actualResponse = client.markRecommendationFailed(name, stateMetadata, etag);
1010     Assert.assertEquals(expectedResponse, actualResponse);
1011 
1012     List<String> actualRequests = mockService.getRequestPaths();
1013     Assert.assertEquals(1, actualRequests.size());
1014 
1015     String apiClientHeaderKey =
1016         mockService
1017             .getRequestHeaders()
1018             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1019             .iterator()
1020             .next();
1021     Assert.assertTrue(
1022         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1023             .matcher(apiClientHeaderKey)
1024             .matches());
1025   }
1026 
1027   @Test
markRecommendationFailedExceptionTest2()1028   public void markRecommendationFailedExceptionTest2() throws Exception {
1029     ApiException exception =
1030         ApiExceptionFactory.createException(
1031             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1032     mockService.addException(exception);
1033 
1034     try {
1035       String name =
1036           "projects/project-9152/locations/location-9152/recommenders/recommender-9152/recommendations/recommendation-9152";
1037       Map<String, String> stateMetadata = new HashMap<>();
1038       String etag = "etag3123477";
1039       client.markRecommendationFailed(name, stateMetadata, etag);
1040       Assert.fail("No exception raised");
1041     } catch (InvalidArgumentException e) {
1042       // Expected exception.
1043     }
1044   }
1045 
1046   @Test
getRecommenderConfigTest()1047   public void getRecommenderConfigTest() throws Exception {
1048     RecommenderConfig expectedResponse =
1049         RecommenderConfig.newBuilder()
1050             .setName(
1051                 RecommenderConfigName.ofProjectLocationRecommenderName(
1052                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]")
1053                     .toString())
1054             .setRecommenderGenerationConfig(RecommenderGenerationConfig.newBuilder().build())
1055             .setEtag("etag3123477")
1056             .setUpdateTime(Timestamp.newBuilder().build())
1057             .setRevisionId("revisionId-1507445162")
1058             .putAllAnnotations(new HashMap<String, String>())
1059             .setDisplayName("displayName1714148973")
1060             .build();
1061     mockService.addResponse(expectedResponse);
1062 
1063     RecommenderConfigName name =
1064         RecommenderConfigName.ofProjectLocationRecommenderName(
1065             "[PROJECT]", "[LOCATION]", "[RECOMMENDER]");
1066 
1067     RecommenderConfig actualResponse = client.getRecommenderConfig(name);
1068     Assert.assertEquals(expectedResponse, actualResponse);
1069 
1070     List<String> actualRequests = mockService.getRequestPaths();
1071     Assert.assertEquals(1, actualRequests.size());
1072 
1073     String apiClientHeaderKey =
1074         mockService
1075             .getRequestHeaders()
1076             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1077             .iterator()
1078             .next();
1079     Assert.assertTrue(
1080         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1081             .matcher(apiClientHeaderKey)
1082             .matches());
1083   }
1084 
1085   @Test
getRecommenderConfigExceptionTest()1086   public void getRecommenderConfigExceptionTest() throws Exception {
1087     ApiException exception =
1088         ApiExceptionFactory.createException(
1089             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1090     mockService.addException(exception);
1091 
1092     try {
1093       RecommenderConfigName name =
1094           RecommenderConfigName.ofProjectLocationRecommenderName(
1095               "[PROJECT]", "[LOCATION]", "[RECOMMENDER]");
1096       client.getRecommenderConfig(name);
1097       Assert.fail("No exception raised");
1098     } catch (InvalidArgumentException e) {
1099       // Expected exception.
1100     }
1101   }
1102 
1103   @Test
getRecommenderConfigTest2()1104   public void getRecommenderConfigTest2() throws Exception {
1105     RecommenderConfig expectedResponse =
1106         RecommenderConfig.newBuilder()
1107             .setName(
1108                 RecommenderConfigName.ofProjectLocationRecommenderName(
1109                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]")
1110                     .toString())
1111             .setRecommenderGenerationConfig(RecommenderGenerationConfig.newBuilder().build())
1112             .setEtag("etag3123477")
1113             .setUpdateTime(Timestamp.newBuilder().build())
1114             .setRevisionId("revisionId-1507445162")
1115             .putAllAnnotations(new HashMap<String, String>())
1116             .setDisplayName("displayName1714148973")
1117             .build();
1118     mockService.addResponse(expectedResponse);
1119 
1120     String name =
1121         "projects/project-3367/locations/location-3367/recommenders/recommender-3367/config";
1122 
1123     RecommenderConfig actualResponse = client.getRecommenderConfig(name);
1124     Assert.assertEquals(expectedResponse, actualResponse);
1125 
1126     List<String> actualRequests = mockService.getRequestPaths();
1127     Assert.assertEquals(1, actualRequests.size());
1128 
1129     String apiClientHeaderKey =
1130         mockService
1131             .getRequestHeaders()
1132             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1133             .iterator()
1134             .next();
1135     Assert.assertTrue(
1136         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1137             .matcher(apiClientHeaderKey)
1138             .matches());
1139   }
1140 
1141   @Test
getRecommenderConfigExceptionTest2()1142   public void getRecommenderConfigExceptionTest2() throws Exception {
1143     ApiException exception =
1144         ApiExceptionFactory.createException(
1145             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1146     mockService.addException(exception);
1147 
1148     try {
1149       String name =
1150           "projects/project-3367/locations/location-3367/recommenders/recommender-3367/config";
1151       client.getRecommenderConfig(name);
1152       Assert.fail("No exception raised");
1153     } catch (InvalidArgumentException e) {
1154       // Expected exception.
1155     }
1156   }
1157 
1158   @Test
updateRecommenderConfigTest()1159   public void updateRecommenderConfigTest() throws Exception {
1160     RecommenderConfig expectedResponse =
1161         RecommenderConfig.newBuilder()
1162             .setName(
1163                 RecommenderConfigName.ofProjectLocationRecommenderName(
1164                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]")
1165                     .toString())
1166             .setRecommenderGenerationConfig(RecommenderGenerationConfig.newBuilder().build())
1167             .setEtag("etag3123477")
1168             .setUpdateTime(Timestamp.newBuilder().build())
1169             .setRevisionId("revisionId-1507445162")
1170             .putAllAnnotations(new HashMap<String, String>())
1171             .setDisplayName("displayName1714148973")
1172             .build();
1173     mockService.addResponse(expectedResponse);
1174 
1175     RecommenderConfig recommenderConfig =
1176         RecommenderConfig.newBuilder()
1177             .setName(
1178                 RecommenderConfigName.ofProjectLocationRecommenderName(
1179                         "[PROJECT]", "[LOCATION]", "[RECOMMENDER]")
1180                     .toString())
1181             .setRecommenderGenerationConfig(RecommenderGenerationConfig.newBuilder().build())
1182             .setEtag("etag3123477")
1183             .setUpdateTime(Timestamp.newBuilder().build())
1184             .setRevisionId("revisionId-1507445162")
1185             .putAllAnnotations(new HashMap<String, String>())
1186             .setDisplayName("displayName1714148973")
1187             .build();
1188     FieldMask updateMask = FieldMask.newBuilder().build();
1189 
1190     RecommenderConfig actualResponse =
1191         client.updateRecommenderConfig(recommenderConfig, updateMask);
1192     Assert.assertEquals(expectedResponse, actualResponse);
1193 
1194     List<String> actualRequests = mockService.getRequestPaths();
1195     Assert.assertEquals(1, actualRequests.size());
1196 
1197     String apiClientHeaderKey =
1198         mockService
1199             .getRequestHeaders()
1200             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1201             .iterator()
1202             .next();
1203     Assert.assertTrue(
1204         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1205             .matcher(apiClientHeaderKey)
1206             .matches());
1207   }
1208 
1209   @Test
updateRecommenderConfigExceptionTest()1210   public void updateRecommenderConfigExceptionTest() throws Exception {
1211     ApiException exception =
1212         ApiExceptionFactory.createException(
1213             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1214     mockService.addException(exception);
1215 
1216     try {
1217       RecommenderConfig recommenderConfig =
1218           RecommenderConfig.newBuilder()
1219               .setName(
1220                   RecommenderConfigName.ofProjectLocationRecommenderName(
1221                           "[PROJECT]", "[LOCATION]", "[RECOMMENDER]")
1222                       .toString())
1223               .setRecommenderGenerationConfig(RecommenderGenerationConfig.newBuilder().build())
1224               .setEtag("etag3123477")
1225               .setUpdateTime(Timestamp.newBuilder().build())
1226               .setRevisionId("revisionId-1507445162")
1227               .putAllAnnotations(new HashMap<String, String>())
1228               .setDisplayName("displayName1714148973")
1229               .build();
1230       FieldMask updateMask = FieldMask.newBuilder().build();
1231       client.updateRecommenderConfig(recommenderConfig, updateMask);
1232       Assert.fail("No exception raised");
1233     } catch (InvalidArgumentException e) {
1234       // Expected exception.
1235     }
1236   }
1237 
1238   @Test
getInsightTypeConfigTest()1239   public void getInsightTypeConfigTest() throws Exception {
1240     InsightTypeConfig expectedResponse =
1241         InsightTypeConfig.newBuilder()
1242             .setName(
1243                 InsightTypeConfigName.ofProjectLocationInsightTypeName(
1244                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]")
1245                     .toString())
1246             .setInsightTypeGenerationConfig(InsightTypeGenerationConfig.newBuilder().build())
1247             .setEtag("etag3123477")
1248             .setUpdateTime(Timestamp.newBuilder().build())
1249             .setRevisionId("revisionId-1507445162")
1250             .putAllAnnotations(new HashMap<String, String>())
1251             .setDisplayName("displayName1714148973")
1252             .build();
1253     mockService.addResponse(expectedResponse);
1254 
1255     InsightTypeConfigName name =
1256         InsightTypeConfigName.ofProjectLocationInsightTypeName(
1257             "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]");
1258 
1259     InsightTypeConfig actualResponse = client.getInsightTypeConfig(name);
1260     Assert.assertEquals(expectedResponse, actualResponse);
1261 
1262     List<String> actualRequests = mockService.getRequestPaths();
1263     Assert.assertEquals(1, actualRequests.size());
1264 
1265     String apiClientHeaderKey =
1266         mockService
1267             .getRequestHeaders()
1268             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1269             .iterator()
1270             .next();
1271     Assert.assertTrue(
1272         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1273             .matcher(apiClientHeaderKey)
1274             .matches());
1275   }
1276 
1277   @Test
getInsightTypeConfigExceptionTest()1278   public void getInsightTypeConfigExceptionTest() throws Exception {
1279     ApiException exception =
1280         ApiExceptionFactory.createException(
1281             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1282     mockService.addException(exception);
1283 
1284     try {
1285       InsightTypeConfigName name =
1286           InsightTypeConfigName.ofProjectLocationInsightTypeName(
1287               "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]");
1288       client.getInsightTypeConfig(name);
1289       Assert.fail("No exception raised");
1290     } catch (InvalidArgumentException e) {
1291       // Expected exception.
1292     }
1293   }
1294 
1295   @Test
getInsightTypeConfigTest2()1296   public void getInsightTypeConfigTest2() throws Exception {
1297     InsightTypeConfig expectedResponse =
1298         InsightTypeConfig.newBuilder()
1299             .setName(
1300                 InsightTypeConfigName.ofProjectLocationInsightTypeName(
1301                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]")
1302                     .toString())
1303             .setInsightTypeGenerationConfig(InsightTypeGenerationConfig.newBuilder().build())
1304             .setEtag("etag3123477")
1305             .setUpdateTime(Timestamp.newBuilder().build())
1306             .setRevisionId("revisionId-1507445162")
1307             .putAllAnnotations(new HashMap<String, String>())
1308             .setDisplayName("displayName1714148973")
1309             .build();
1310     mockService.addResponse(expectedResponse);
1311 
1312     String name =
1313         "projects/project-5840/locations/location-5840/insightTypes/insightType-5840/config";
1314 
1315     InsightTypeConfig actualResponse = client.getInsightTypeConfig(name);
1316     Assert.assertEquals(expectedResponse, actualResponse);
1317 
1318     List<String> actualRequests = mockService.getRequestPaths();
1319     Assert.assertEquals(1, actualRequests.size());
1320 
1321     String apiClientHeaderKey =
1322         mockService
1323             .getRequestHeaders()
1324             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1325             .iterator()
1326             .next();
1327     Assert.assertTrue(
1328         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1329             .matcher(apiClientHeaderKey)
1330             .matches());
1331   }
1332 
1333   @Test
getInsightTypeConfigExceptionTest2()1334   public void getInsightTypeConfigExceptionTest2() throws Exception {
1335     ApiException exception =
1336         ApiExceptionFactory.createException(
1337             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1338     mockService.addException(exception);
1339 
1340     try {
1341       String name =
1342           "projects/project-5840/locations/location-5840/insightTypes/insightType-5840/config";
1343       client.getInsightTypeConfig(name);
1344       Assert.fail("No exception raised");
1345     } catch (InvalidArgumentException e) {
1346       // Expected exception.
1347     }
1348   }
1349 
1350   @Test
updateInsightTypeConfigTest()1351   public void updateInsightTypeConfigTest() throws Exception {
1352     InsightTypeConfig expectedResponse =
1353         InsightTypeConfig.newBuilder()
1354             .setName(
1355                 InsightTypeConfigName.ofProjectLocationInsightTypeName(
1356                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]")
1357                     .toString())
1358             .setInsightTypeGenerationConfig(InsightTypeGenerationConfig.newBuilder().build())
1359             .setEtag("etag3123477")
1360             .setUpdateTime(Timestamp.newBuilder().build())
1361             .setRevisionId("revisionId-1507445162")
1362             .putAllAnnotations(new HashMap<String, String>())
1363             .setDisplayName("displayName1714148973")
1364             .build();
1365     mockService.addResponse(expectedResponse);
1366 
1367     InsightTypeConfig insightTypeConfig =
1368         InsightTypeConfig.newBuilder()
1369             .setName(
1370                 InsightTypeConfigName.ofProjectLocationInsightTypeName(
1371                         "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]")
1372                     .toString())
1373             .setInsightTypeGenerationConfig(InsightTypeGenerationConfig.newBuilder().build())
1374             .setEtag("etag3123477")
1375             .setUpdateTime(Timestamp.newBuilder().build())
1376             .setRevisionId("revisionId-1507445162")
1377             .putAllAnnotations(new HashMap<String, String>())
1378             .setDisplayName("displayName1714148973")
1379             .build();
1380     FieldMask updateMask = FieldMask.newBuilder().build();
1381 
1382     InsightTypeConfig actualResponse =
1383         client.updateInsightTypeConfig(insightTypeConfig, updateMask);
1384     Assert.assertEquals(expectedResponse, actualResponse);
1385 
1386     List<String> actualRequests = mockService.getRequestPaths();
1387     Assert.assertEquals(1, actualRequests.size());
1388 
1389     String apiClientHeaderKey =
1390         mockService
1391             .getRequestHeaders()
1392             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1393             .iterator()
1394             .next();
1395     Assert.assertTrue(
1396         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1397             .matcher(apiClientHeaderKey)
1398             .matches());
1399   }
1400 
1401   @Test
updateInsightTypeConfigExceptionTest()1402   public void updateInsightTypeConfigExceptionTest() throws Exception {
1403     ApiException exception =
1404         ApiExceptionFactory.createException(
1405             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1406     mockService.addException(exception);
1407 
1408     try {
1409       InsightTypeConfig insightTypeConfig =
1410           InsightTypeConfig.newBuilder()
1411               .setName(
1412                   InsightTypeConfigName.ofProjectLocationInsightTypeName(
1413                           "[PROJECT]", "[LOCATION]", "[INSIGHT_TYPE]")
1414                       .toString())
1415               .setInsightTypeGenerationConfig(InsightTypeGenerationConfig.newBuilder().build())
1416               .setEtag("etag3123477")
1417               .setUpdateTime(Timestamp.newBuilder().build())
1418               .setRevisionId("revisionId-1507445162")
1419               .putAllAnnotations(new HashMap<String, String>())
1420               .setDisplayName("displayName1714148973")
1421               .build();
1422       FieldMask updateMask = FieldMask.newBuilder().build();
1423       client.updateInsightTypeConfig(insightTypeConfig, updateMask);
1424       Assert.fail("No exception raised");
1425     } catch (InvalidArgumentException e) {
1426       // Expected exception.
1427     }
1428   }
1429 }
1430