• 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.dialogflow.v2;
18 
19 import static com.google.cloud.dialogflow.v2.ConversationsClient.ListConversationsPagedResponse;
20 import static com.google.cloud.dialogflow.v2.ConversationsClient.ListLocationsPagedResponse;
21 import static com.google.cloud.dialogflow.v2.ConversationsClient.ListMessagesPagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
25 import com.google.api.gax.httpjson.testing.MockHttpService;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.ApiException;
28 import com.google.api.gax.rpc.ApiExceptionFactory;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.api.gax.rpc.testing.FakeStatusCode;
32 import com.google.cloud.dialogflow.v2.stub.HttpJsonConversationsStub;
33 import com.google.cloud.location.GetLocationRequest;
34 import com.google.cloud.location.ListLocationsRequest;
35 import com.google.cloud.location.ListLocationsResponse;
36 import com.google.cloud.location.Location;
37 import com.google.common.collect.Lists;
38 import com.google.protobuf.Any;
39 import com.google.protobuf.Timestamp;
40 import java.io.IOException;
41 import java.util.ArrayList;
42 import java.util.Arrays;
43 import java.util.HashMap;
44 import java.util.List;
45 import javax.annotation.Generated;
46 import org.junit.After;
47 import org.junit.AfterClass;
48 import org.junit.Assert;
49 import org.junit.Before;
50 import org.junit.BeforeClass;
51 import org.junit.Test;
52 
53 @Generated("by gapic-generator-java")
54 public class ConversationsClientHttpJsonTest {
55   private static MockHttpService mockService;
56   private static ConversationsClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() throws IOException {
60     mockService =
61         new MockHttpService(
62             HttpJsonConversationsStub.getMethodDescriptors(),
63             ConversationsSettings.getDefaultEndpoint());
64     ConversationsSettings settings =
65         ConversationsSettings.newHttpJsonBuilder()
66             .setTransportChannelProvider(
67                 ConversationsSettings.defaultHttpJsonTransportProviderBuilder()
68                     .setHttpTransport(mockService)
69                     .build())
70             .setCredentialsProvider(NoCredentialsProvider.create())
71             .build();
72     client = ConversationsClient.create(settings);
73   }
74 
75   @AfterClass
stopServer()76   public static void stopServer() {
77     client.close();
78   }
79 
80   @Before
setUp()81   public void setUp() {}
82 
83   @After
tearDown()84   public void tearDown() throws Exception {
85     mockService.reset();
86   }
87 
88   @Test
createConversationTest()89   public void createConversationTest() throws Exception {
90     Conversation expectedResponse =
91         Conversation.newBuilder()
92             .setName(
93                 ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]")
94                     .toString())
95             .setConversationProfile(
96                 ConversationProfileName.ofProjectConversationProfileName(
97                         "[PROJECT]", "[CONVERSATION_PROFILE]")
98                     .toString())
99             .setPhoneNumber(ConversationPhoneNumber.newBuilder().build())
100             .setStartTime(Timestamp.newBuilder().build())
101             .setEndTime(Timestamp.newBuilder().build())
102             .build();
103     mockService.addResponse(expectedResponse);
104 
105     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
106     Conversation conversation = Conversation.newBuilder().build();
107 
108     Conversation actualResponse = client.createConversation(parent, conversation);
109     Assert.assertEquals(expectedResponse, actualResponse);
110 
111     List<String> actualRequests = mockService.getRequestPaths();
112     Assert.assertEquals(1, actualRequests.size());
113 
114     String apiClientHeaderKey =
115         mockService
116             .getRequestHeaders()
117             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
118             .iterator()
119             .next();
120     Assert.assertTrue(
121         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
122             .matcher(apiClientHeaderKey)
123             .matches());
124   }
125 
126   @Test
createConversationExceptionTest()127   public void createConversationExceptionTest() throws Exception {
128     ApiException exception =
129         ApiExceptionFactory.createException(
130             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
131     mockService.addException(exception);
132 
133     try {
134       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
135       Conversation conversation = Conversation.newBuilder().build();
136       client.createConversation(parent, conversation);
137       Assert.fail("No exception raised");
138     } catch (InvalidArgumentException e) {
139       // Expected exception.
140     }
141   }
142 
143   @Test
createConversationTest2()144   public void createConversationTest2() throws Exception {
145     Conversation expectedResponse =
146         Conversation.newBuilder()
147             .setName(
148                 ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]")
149                     .toString())
150             .setConversationProfile(
151                 ConversationProfileName.ofProjectConversationProfileName(
152                         "[PROJECT]", "[CONVERSATION_PROFILE]")
153                     .toString())
154             .setPhoneNumber(ConversationPhoneNumber.newBuilder().build())
155             .setStartTime(Timestamp.newBuilder().build())
156             .setEndTime(Timestamp.newBuilder().build())
157             .build();
158     mockService.addResponse(expectedResponse);
159 
160     ProjectName parent = ProjectName.of("[PROJECT]");
161     Conversation conversation = Conversation.newBuilder().build();
162 
163     Conversation actualResponse = client.createConversation(parent, conversation);
164     Assert.assertEquals(expectedResponse, actualResponse);
165 
166     List<String> actualRequests = mockService.getRequestPaths();
167     Assert.assertEquals(1, actualRequests.size());
168 
169     String apiClientHeaderKey =
170         mockService
171             .getRequestHeaders()
172             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
173             .iterator()
174             .next();
175     Assert.assertTrue(
176         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
177             .matcher(apiClientHeaderKey)
178             .matches());
179   }
180 
181   @Test
createConversationExceptionTest2()182   public void createConversationExceptionTest2() throws Exception {
183     ApiException exception =
184         ApiExceptionFactory.createException(
185             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
186     mockService.addException(exception);
187 
188     try {
189       ProjectName parent = ProjectName.of("[PROJECT]");
190       Conversation conversation = Conversation.newBuilder().build();
191       client.createConversation(parent, conversation);
192       Assert.fail("No exception raised");
193     } catch (InvalidArgumentException e) {
194       // Expected exception.
195     }
196   }
197 
198   @Test
createConversationTest3()199   public void createConversationTest3() throws Exception {
200     Conversation expectedResponse =
201         Conversation.newBuilder()
202             .setName(
203                 ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]")
204                     .toString())
205             .setConversationProfile(
206                 ConversationProfileName.ofProjectConversationProfileName(
207                         "[PROJECT]", "[CONVERSATION_PROFILE]")
208                     .toString())
209             .setPhoneNumber(ConversationPhoneNumber.newBuilder().build())
210             .setStartTime(Timestamp.newBuilder().build())
211             .setEndTime(Timestamp.newBuilder().build())
212             .build();
213     mockService.addResponse(expectedResponse);
214 
215     String parent = "projects/project-2353";
216     Conversation conversation = Conversation.newBuilder().build();
217 
218     Conversation actualResponse = client.createConversation(parent, conversation);
219     Assert.assertEquals(expectedResponse, actualResponse);
220 
221     List<String> actualRequests = mockService.getRequestPaths();
222     Assert.assertEquals(1, actualRequests.size());
223 
224     String apiClientHeaderKey =
225         mockService
226             .getRequestHeaders()
227             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
228             .iterator()
229             .next();
230     Assert.assertTrue(
231         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
232             .matcher(apiClientHeaderKey)
233             .matches());
234   }
235 
236   @Test
createConversationExceptionTest3()237   public void createConversationExceptionTest3() throws Exception {
238     ApiException exception =
239         ApiExceptionFactory.createException(
240             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
241     mockService.addException(exception);
242 
243     try {
244       String parent = "projects/project-2353";
245       Conversation conversation = Conversation.newBuilder().build();
246       client.createConversation(parent, conversation);
247       Assert.fail("No exception raised");
248     } catch (InvalidArgumentException e) {
249       // Expected exception.
250     }
251   }
252 
253   @Test
listConversationsTest()254   public void listConversationsTest() throws Exception {
255     Conversation responsesElement = Conversation.newBuilder().build();
256     ListConversationsResponse expectedResponse =
257         ListConversationsResponse.newBuilder()
258             .setNextPageToken("")
259             .addAllConversations(Arrays.asList(responsesElement))
260             .build();
261     mockService.addResponse(expectedResponse);
262 
263     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
264 
265     ListConversationsPagedResponse pagedListResponse = client.listConversations(parent);
266 
267     List<Conversation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
268 
269     Assert.assertEquals(1, resources.size());
270     Assert.assertEquals(expectedResponse.getConversationsList().get(0), resources.get(0));
271 
272     List<String> actualRequests = mockService.getRequestPaths();
273     Assert.assertEquals(1, actualRequests.size());
274 
275     String apiClientHeaderKey =
276         mockService
277             .getRequestHeaders()
278             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
279             .iterator()
280             .next();
281     Assert.assertTrue(
282         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
283             .matcher(apiClientHeaderKey)
284             .matches());
285   }
286 
287   @Test
listConversationsExceptionTest()288   public void listConversationsExceptionTest() throws Exception {
289     ApiException exception =
290         ApiExceptionFactory.createException(
291             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
292     mockService.addException(exception);
293 
294     try {
295       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
296       client.listConversations(parent);
297       Assert.fail("No exception raised");
298     } catch (InvalidArgumentException e) {
299       // Expected exception.
300     }
301   }
302 
303   @Test
listConversationsTest2()304   public void listConversationsTest2() throws Exception {
305     Conversation responsesElement = Conversation.newBuilder().build();
306     ListConversationsResponse expectedResponse =
307         ListConversationsResponse.newBuilder()
308             .setNextPageToken("")
309             .addAllConversations(Arrays.asList(responsesElement))
310             .build();
311     mockService.addResponse(expectedResponse);
312 
313     ProjectName parent = ProjectName.of("[PROJECT]");
314 
315     ListConversationsPagedResponse pagedListResponse = client.listConversations(parent);
316 
317     List<Conversation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
318 
319     Assert.assertEquals(1, resources.size());
320     Assert.assertEquals(expectedResponse.getConversationsList().get(0), resources.get(0));
321 
322     List<String> actualRequests = mockService.getRequestPaths();
323     Assert.assertEquals(1, actualRequests.size());
324 
325     String apiClientHeaderKey =
326         mockService
327             .getRequestHeaders()
328             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
329             .iterator()
330             .next();
331     Assert.assertTrue(
332         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
333             .matcher(apiClientHeaderKey)
334             .matches());
335   }
336 
337   @Test
listConversationsExceptionTest2()338   public void listConversationsExceptionTest2() throws Exception {
339     ApiException exception =
340         ApiExceptionFactory.createException(
341             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
342     mockService.addException(exception);
343 
344     try {
345       ProjectName parent = ProjectName.of("[PROJECT]");
346       client.listConversations(parent);
347       Assert.fail("No exception raised");
348     } catch (InvalidArgumentException e) {
349       // Expected exception.
350     }
351   }
352 
353   @Test
listConversationsTest3()354   public void listConversationsTest3() throws Exception {
355     Conversation responsesElement = Conversation.newBuilder().build();
356     ListConversationsResponse expectedResponse =
357         ListConversationsResponse.newBuilder()
358             .setNextPageToken("")
359             .addAllConversations(Arrays.asList(responsesElement))
360             .build();
361     mockService.addResponse(expectedResponse);
362 
363     String parent = "projects/project-2353";
364 
365     ListConversationsPagedResponse pagedListResponse = client.listConversations(parent);
366 
367     List<Conversation> resources = Lists.newArrayList(pagedListResponse.iterateAll());
368 
369     Assert.assertEquals(1, resources.size());
370     Assert.assertEquals(expectedResponse.getConversationsList().get(0), resources.get(0));
371 
372     List<String> actualRequests = mockService.getRequestPaths();
373     Assert.assertEquals(1, actualRequests.size());
374 
375     String apiClientHeaderKey =
376         mockService
377             .getRequestHeaders()
378             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
379             .iterator()
380             .next();
381     Assert.assertTrue(
382         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
383             .matcher(apiClientHeaderKey)
384             .matches());
385   }
386 
387   @Test
listConversationsExceptionTest3()388   public void listConversationsExceptionTest3() throws Exception {
389     ApiException exception =
390         ApiExceptionFactory.createException(
391             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
392     mockService.addException(exception);
393 
394     try {
395       String parent = "projects/project-2353";
396       client.listConversations(parent);
397       Assert.fail("No exception raised");
398     } catch (InvalidArgumentException e) {
399       // Expected exception.
400     }
401   }
402 
403   @Test
getConversationTest()404   public void getConversationTest() throws Exception {
405     Conversation expectedResponse =
406         Conversation.newBuilder()
407             .setName(
408                 ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]")
409                     .toString())
410             .setConversationProfile(
411                 ConversationProfileName.ofProjectConversationProfileName(
412                         "[PROJECT]", "[CONVERSATION_PROFILE]")
413                     .toString())
414             .setPhoneNumber(ConversationPhoneNumber.newBuilder().build())
415             .setStartTime(Timestamp.newBuilder().build())
416             .setEndTime(Timestamp.newBuilder().build())
417             .build();
418     mockService.addResponse(expectedResponse);
419 
420     ConversationName name =
421         ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
422 
423     Conversation actualResponse = client.getConversation(name);
424     Assert.assertEquals(expectedResponse, actualResponse);
425 
426     List<String> actualRequests = mockService.getRequestPaths();
427     Assert.assertEquals(1, actualRequests.size());
428 
429     String apiClientHeaderKey =
430         mockService
431             .getRequestHeaders()
432             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
433             .iterator()
434             .next();
435     Assert.assertTrue(
436         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
437             .matcher(apiClientHeaderKey)
438             .matches());
439   }
440 
441   @Test
getConversationExceptionTest()442   public void getConversationExceptionTest() throws Exception {
443     ApiException exception =
444         ApiExceptionFactory.createException(
445             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
446     mockService.addException(exception);
447 
448     try {
449       ConversationName name =
450           ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
451       client.getConversation(name);
452       Assert.fail("No exception raised");
453     } catch (InvalidArgumentException e) {
454       // Expected exception.
455     }
456   }
457 
458   @Test
getConversationTest2()459   public void getConversationTest2() throws Exception {
460     Conversation expectedResponse =
461         Conversation.newBuilder()
462             .setName(
463                 ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]")
464                     .toString())
465             .setConversationProfile(
466                 ConversationProfileName.ofProjectConversationProfileName(
467                         "[PROJECT]", "[CONVERSATION_PROFILE]")
468                     .toString())
469             .setPhoneNumber(ConversationPhoneNumber.newBuilder().build())
470             .setStartTime(Timestamp.newBuilder().build())
471             .setEndTime(Timestamp.newBuilder().build())
472             .build();
473     mockService.addResponse(expectedResponse);
474 
475     String name = "projects/project-3460/conversations/conversation-3460";
476 
477     Conversation actualResponse = client.getConversation(name);
478     Assert.assertEquals(expectedResponse, actualResponse);
479 
480     List<String> actualRequests = mockService.getRequestPaths();
481     Assert.assertEquals(1, actualRequests.size());
482 
483     String apiClientHeaderKey =
484         mockService
485             .getRequestHeaders()
486             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
487             .iterator()
488             .next();
489     Assert.assertTrue(
490         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
491             .matcher(apiClientHeaderKey)
492             .matches());
493   }
494 
495   @Test
getConversationExceptionTest2()496   public void getConversationExceptionTest2() throws Exception {
497     ApiException exception =
498         ApiExceptionFactory.createException(
499             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
500     mockService.addException(exception);
501 
502     try {
503       String name = "projects/project-3460/conversations/conversation-3460";
504       client.getConversation(name);
505       Assert.fail("No exception raised");
506     } catch (InvalidArgumentException e) {
507       // Expected exception.
508     }
509   }
510 
511   @Test
completeConversationTest()512   public void completeConversationTest() throws Exception {
513     Conversation expectedResponse =
514         Conversation.newBuilder()
515             .setName(
516                 ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]")
517                     .toString())
518             .setConversationProfile(
519                 ConversationProfileName.ofProjectConversationProfileName(
520                         "[PROJECT]", "[CONVERSATION_PROFILE]")
521                     .toString())
522             .setPhoneNumber(ConversationPhoneNumber.newBuilder().build())
523             .setStartTime(Timestamp.newBuilder().build())
524             .setEndTime(Timestamp.newBuilder().build())
525             .build();
526     mockService.addResponse(expectedResponse);
527 
528     ConversationName name =
529         ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
530 
531     Conversation actualResponse = client.completeConversation(name);
532     Assert.assertEquals(expectedResponse, actualResponse);
533 
534     List<String> actualRequests = mockService.getRequestPaths();
535     Assert.assertEquals(1, actualRequests.size());
536 
537     String apiClientHeaderKey =
538         mockService
539             .getRequestHeaders()
540             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
541             .iterator()
542             .next();
543     Assert.assertTrue(
544         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
545             .matcher(apiClientHeaderKey)
546             .matches());
547   }
548 
549   @Test
completeConversationExceptionTest()550   public void completeConversationExceptionTest() throws Exception {
551     ApiException exception =
552         ApiExceptionFactory.createException(
553             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
554     mockService.addException(exception);
555 
556     try {
557       ConversationName name =
558           ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
559       client.completeConversation(name);
560       Assert.fail("No exception raised");
561     } catch (InvalidArgumentException e) {
562       // Expected exception.
563     }
564   }
565 
566   @Test
completeConversationTest2()567   public void completeConversationTest2() throws Exception {
568     Conversation expectedResponse =
569         Conversation.newBuilder()
570             .setName(
571                 ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]")
572                     .toString())
573             .setConversationProfile(
574                 ConversationProfileName.ofProjectConversationProfileName(
575                         "[PROJECT]", "[CONVERSATION_PROFILE]")
576                     .toString())
577             .setPhoneNumber(ConversationPhoneNumber.newBuilder().build())
578             .setStartTime(Timestamp.newBuilder().build())
579             .setEndTime(Timestamp.newBuilder().build())
580             .build();
581     mockService.addResponse(expectedResponse);
582 
583     String name = "projects/project-3460/conversations/conversation-3460";
584 
585     Conversation actualResponse = client.completeConversation(name);
586     Assert.assertEquals(expectedResponse, actualResponse);
587 
588     List<String> actualRequests = mockService.getRequestPaths();
589     Assert.assertEquals(1, actualRequests.size());
590 
591     String apiClientHeaderKey =
592         mockService
593             .getRequestHeaders()
594             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
595             .iterator()
596             .next();
597     Assert.assertTrue(
598         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
599             .matcher(apiClientHeaderKey)
600             .matches());
601   }
602 
603   @Test
completeConversationExceptionTest2()604   public void completeConversationExceptionTest2() throws Exception {
605     ApiException exception =
606         ApiExceptionFactory.createException(
607             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
608     mockService.addException(exception);
609 
610     try {
611       String name = "projects/project-3460/conversations/conversation-3460";
612       client.completeConversation(name);
613       Assert.fail("No exception raised");
614     } catch (InvalidArgumentException e) {
615       // Expected exception.
616     }
617   }
618 
619   @Test
listMessagesTest()620   public void listMessagesTest() throws Exception {
621     Message responsesElement = Message.newBuilder().build();
622     ListMessagesResponse expectedResponse =
623         ListMessagesResponse.newBuilder()
624             .setNextPageToken("")
625             .addAllMessages(Arrays.asList(responsesElement))
626             .build();
627     mockService.addResponse(expectedResponse);
628 
629     ConversationName parent =
630         ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
631 
632     ListMessagesPagedResponse pagedListResponse = client.listMessages(parent);
633 
634     List<Message> resources = Lists.newArrayList(pagedListResponse.iterateAll());
635 
636     Assert.assertEquals(1, resources.size());
637     Assert.assertEquals(expectedResponse.getMessagesList().get(0), resources.get(0));
638 
639     List<String> actualRequests = mockService.getRequestPaths();
640     Assert.assertEquals(1, actualRequests.size());
641 
642     String apiClientHeaderKey =
643         mockService
644             .getRequestHeaders()
645             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
646             .iterator()
647             .next();
648     Assert.assertTrue(
649         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
650             .matcher(apiClientHeaderKey)
651             .matches());
652   }
653 
654   @Test
listMessagesExceptionTest()655   public void listMessagesExceptionTest() throws Exception {
656     ApiException exception =
657         ApiExceptionFactory.createException(
658             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
659     mockService.addException(exception);
660 
661     try {
662       ConversationName parent =
663           ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
664       client.listMessages(parent);
665       Assert.fail("No exception raised");
666     } catch (InvalidArgumentException e) {
667       // Expected exception.
668     }
669   }
670 
671   @Test
listMessagesTest2()672   public void listMessagesTest2() throws Exception {
673     Message responsesElement = Message.newBuilder().build();
674     ListMessagesResponse expectedResponse =
675         ListMessagesResponse.newBuilder()
676             .setNextPageToken("")
677             .addAllMessages(Arrays.asList(responsesElement))
678             .build();
679     mockService.addResponse(expectedResponse);
680 
681     String parent = "projects/project-4379/conversations/conversation-4379";
682 
683     ListMessagesPagedResponse pagedListResponse = client.listMessages(parent);
684 
685     List<Message> resources = Lists.newArrayList(pagedListResponse.iterateAll());
686 
687     Assert.assertEquals(1, resources.size());
688     Assert.assertEquals(expectedResponse.getMessagesList().get(0), resources.get(0));
689 
690     List<String> actualRequests = mockService.getRequestPaths();
691     Assert.assertEquals(1, actualRequests.size());
692 
693     String apiClientHeaderKey =
694         mockService
695             .getRequestHeaders()
696             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
697             .iterator()
698             .next();
699     Assert.assertTrue(
700         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
701             .matcher(apiClientHeaderKey)
702             .matches());
703   }
704 
705   @Test
listMessagesExceptionTest2()706   public void listMessagesExceptionTest2() throws Exception {
707     ApiException exception =
708         ApiExceptionFactory.createException(
709             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
710     mockService.addException(exception);
711 
712     try {
713       String parent = "projects/project-4379/conversations/conversation-4379";
714       client.listMessages(parent);
715       Assert.fail("No exception raised");
716     } catch (InvalidArgumentException e) {
717       // Expected exception.
718     }
719   }
720 
721   @Test
suggestConversationSummaryTest()722   public void suggestConversationSummaryTest() throws Exception {
723     SuggestConversationSummaryResponse expectedResponse =
724         SuggestConversationSummaryResponse.newBuilder()
725             .setSummary(SuggestConversationSummaryResponse.Summary.newBuilder().build())
726             .setLatestMessage(
727                 MessageName.ofProjectConversationMessageName(
728                         "[PROJECT]", "[CONVERSATION]", "[MESSAGE]")
729                     .toString())
730             .setContextSize(1116903569)
731             .build();
732     mockService.addResponse(expectedResponse);
733 
734     ConversationName conversation =
735         ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
736 
737     SuggestConversationSummaryResponse actualResponse =
738         client.suggestConversationSummary(conversation);
739     Assert.assertEquals(expectedResponse, actualResponse);
740 
741     List<String> actualRequests = mockService.getRequestPaths();
742     Assert.assertEquals(1, actualRequests.size());
743 
744     String apiClientHeaderKey =
745         mockService
746             .getRequestHeaders()
747             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
748             .iterator()
749             .next();
750     Assert.assertTrue(
751         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
752             .matcher(apiClientHeaderKey)
753             .matches());
754   }
755 
756   @Test
suggestConversationSummaryExceptionTest()757   public void suggestConversationSummaryExceptionTest() throws Exception {
758     ApiException exception =
759         ApiExceptionFactory.createException(
760             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
761     mockService.addException(exception);
762 
763     try {
764       ConversationName conversation =
765           ConversationName.ofProjectConversationName("[PROJECT]", "[CONVERSATION]");
766       client.suggestConversationSummary(conversation);
767       Assert.fail("No exception raised");
768     } catch (InvalidArgumentException e) {
769       // Expected exception.
770     }
771   }
772 
773   @Test
suggestConversationSummaryTest2()774   public void suggestConversationSummaryTest2() throws Exception {
775     SuggestConversationSummaryResponse expectedResponse =
776         SuggestConversationSummaryResponse.newBuilder()
777             .setSummary(SuggestConversationSummaryResponse.Summary.newBuilder().build())
778             .setLatestMessage(
779                 MessageName.ofProjectConversationMessageName(
780                         "[PROJECT]", "[CONVERSATION]", "[MESSAGE]")
781                     .toString())
782             .setContextSize(1116903569)
783             .build();
784     mockService.addResponse(expectedResponse);
785 
786     String conversation = "projects/project-5228/conversations/conversation-5228";
787 
788     SuggestConversationSummaryResponse actualResponse =
789         client.suggestConversationSummary(conversation);
790     Assert.assertEquals(expectedResponse, actualResponse);
791 
792     List<String> actualRequests = mockService.getRequestPaths();
793     Assert.assertEquals(1, actualRequests.size());
794 
795     String apiClientHeaderKey =
796         mockService
797             .getRequestHeaders()
798             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
799             .iterator()
800             .next();
801     Assert.assertTrue(
802         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
803             .matcher(apiClientHeaderKey)
804             .matches());
805   }
806 
807   @Test
suggestConversationSummaryExceptionTest2()808   public void suggestConversationSummaryExceptionTest2() throws Exception {
809     ApiException exception =
810         ApiExceptionFactory.createException(
811             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
812     mockService.addException(exception);
813 
814     try {
815       String conversation = "projects/project-5228/conversations/conversation-5228";
816       client.suggestConversationSummary(conversation);
817       Assert.fail("No exception raised");
818     } catch (InvalidArgumentException e) {
819       // Expected exception.
820     }
821   }
822 
823   @Test
generateStatelessSummaryTest()824   public void generateStatelessSummaryTest() throws Exception {
825     GenerateStatelessSummaryResponse expectedResponse =
826         GenerateStatelessSummaryResponse.newBuilder()
827             .setSummary(GenerateStatelessSummaryResponse.Summary.newBuilder().build())
828             .setLatestMessage(
829                 MessageName.ofProjectConversationMessageName(
830                         "[PROJECT]", "[CONVERSATION]", "[MESSAGE]")
831                     .toString())
832             .setContextSize(1116903569)
833             .build();
834     mockService.addResponse(expectedResponse);
835 
836     GenerateStatelessSummaryRequest request =
837         GenerateStatelessSummaryRequest.newBuilder()
838             .setStatelessConversation(
839                 GenerateStatelessSummaryRequest.MinimalConversation.newBuilder()
840                     .addAllMessages(new ArrayList<Message>())
841                     .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
842                     .build())
843             .setConversationProfile(ConversationProfile.newBuilder().build())
844             .setLatestMessage(
845                 MessageName.ofProjectConversationMessageName(
846                         "[PROJECT]", "[CONVERSATION]", "[MESSAGE]")
847                     .toString())
848             .setMaxContextSize(-1134084212)
849             .build();
850 
851     GenerateStatelessSummaryResponse actualResponse = client.generateStatelessSummary(request);
852     Assert.assertEquals(expectedResponse, actualResponse);
853 
854     List<String> actualRequests = mockService.getRequestPaths();
855     Assert.assertEquals(1, actualRequests.size());
856 
857     String apiClientHeaderKey =
858         mockService
859             .getRequestHeaders()
860             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
861             .iterator()
862             .next();
863     Assert.assertTrue(
864         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
865             .matcher(apiClientHeaderKey)
866             .matches());
867   }
868 
869   @Test
generateStatelessSummaryExceptionTest()870   public void generateStatelessSummaryExceptionTest() throws Exception {
871     ApiException exception =
872         ApiExceptionFactory.createException(
873             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
874     mockService.addException(exception);
875 
876     try {
877       GenerateStatelessSummaryRequest request =
878           GenerateStatelessSummaryRequest.newBuilder()
879               .setStatelessConversation(
880                   GenerateStatelessSummaryRequest.MinimalConversation.newBuilder()
881                       .addAllMessages(new ArrayList<Message>())
882                       .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
883                       .build())
884               .setConversationProfile(ConversationProfile.newBuilder().build())
885               .setLatestMessage(
886                   MessageName.ofProjectConversationMessageName(
887                           "[PROJECT]", "[CONVERSATION]", "[MESSAGE]")
888                       .toString())
889               .setMaxContextSize(-1134084212)
890               .build();
891       client.generateStatelessSummary(request);
892       Assert.fail("No exception raised");
893     } catch (InvalidArgumentException e) {
894       // Expected exception.
895     }
896   }
897 
898   @Test
listLocationsTest()899   public void listLocationsTest() throws Exception {
900     Location responsesElement = Location.newBuilder().build();
901     ListLocationsResponse expectedResponse =
902         ListLocationsResponse.newBuilder()
903             .setNextPageToken("")
904             .addAllLocations(Arrays.asList(responsesElement))
905             .build();
906     mockService.addResponse(expectedResponse);
907 
908     ListLocationsRequest request =
909         ListLocationsRequest.newBuilder()
910             .setName("projects/project-3664")
911             .setFilter("filter-1274492040")
912             .setPageSize(883849137)
913             .setPageToken("pageToken873572522")
914             .build();
915 
916     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
917 
918     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
919 
920     Assert.assertEquals(1, resources.size());
921     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
922 
923     List<String> actualRequests = mockService.getRequestPaths();
924     Assert.assertEquals(1, actualRequests.size());
925 
926     String apiClientHeaderKey =
927         mockService
928             .getRequestHeaders()
929             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
930             .iterator()
931             .next();
932     Assert.assertTrue(
933         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
934             .matcher(apiClientHeaderKey)
935             .matches());
936   }
937 
938   @Test
listLocationsExceptionTest()939   public void listLocationsExceptionTest() throws Exception {
940     ApiException exception =
941         ApiExceptionFactory.createException(
942             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
943     mockService.addException(exception);
944 
945     try {
946       ListLocationsRequest request =
947           ListLocationsRequest.newBuilder()
948               .setName("projects/project-3664")
949               .setFilter("filter-1274492040")
950               .setPageSize(883849137)
951               .setPageToken("pageToken873572522")
952               .build();
953       client.listLocations(request);
954       Assert.fail("No exception raised");
955     } catch (InvalidArgumentException e) {
956       // Expected exception.
957     }
958   }
959 
960   @Test
getLocationTest()961   public void getLocationTest() throws Exception {
962     Location expectedResponse =
963         Location.newBuilder()
964             .setName("name3373707")
965             .setLocationId("locationId1541836720")
966             .setDisplayName("displayName1714148973")
967             .putAllLabels(new HashMap<String, String>())
968             .setMetadata(Any.newBuilder().build())
969             .build();
970     mockService.addResponse(expectedResponse);
971 
972     GetLocationRequest request =
973         GetLocationRequest.newBuilder()
974             .setName("projects/project-9062/locations/location-9062")
975             .build();
976 
977     Location actualResponse = client.getLocation(request);
978     Assert.assertEquals(expectedResponse, actualResponse);
979 
980     List<String> actualRequests = mockService.getRequestPaths();
981     Assert.assertEquals(1, actualRequests.size());
982 
983     String apiClientHeaderKey =
984         mockService
985             .getRequestHeaders()
986             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
987             .iterator()
988             .next();
989     Assert.assertTrue(
990         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
991             .matcher(apiClientHeaderKey)
992             .matches());
993   }
994 
995   @Test
getLocationExceptionTest()996   public void getLocationExceptionTest() throws Exception {
997     ApiException exception =
998         ApiExceptionFactory.createException(
999             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1000     mockService.addException(exception);
1001 
1002     try {
1003       GetLocationRequest request =
1004           GetLocationRequest.newBuilder()
1005               .setName("projects/project-9062/locations/location-9062")
1006               .build();
1007       client.getLocation(request);
1008       Assert.fail("No exception raised");
1009     } catch (InvalidArgumentException e) {
1010       // Expected exception.
1011     }
1012   }
1013 }
1014