• 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.ConversationDatasetsClient.ListConversationDatasetsPagedResponse;
20 import static com.google.cloud.dialogflow.v2.ConversationDatasetsClient.ListLocationsPagedResponse;
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.dialogflow.v2.stub.HttpJsonConversationDatasetsStub;
32 import com.google.cloud.location.GetLocationRequest;
33 import com.google.cloud.location.ListLocationsRequest;
34 import com.google.cloud.location.ListLocationsResponse;
35 import com.google.cloud.location.Location;
36 import com.google.common.collect.Lists;
37 import com.google.longrunning.Operation;
38 import com.google.protobuf.Any;
39 import com.google.protobuf.Empty;
40 import com.google.protobuf.Timestamp;
41 import java.io.IOException;
42 import java.util.Arrays;
43 import java.util.HashMap;
44 import java.util.List;
45 import java.util.concurrent.ExecutionException;
46 import javax.annotation.Generated;
47 import org.junit.After;
48 import org.junit.AfterClass;
49 import org.junit.Assert;
50 import org.junit.Before;
51 import org.junit.BeforeClass;
52 import org.junit.Test;
53 
54 @Generated("by gapic-generator-java")
55 public class ConversationDatasetsClientHttpJsonTest {
56   private static MockHttpService mockService;
57   private static ConversationDatasetsClient client;
58 
59   @BeforeClass
startStaticServer()60   public static void startStaticServer() throws IOException {
61     mockService =
62         new MockHttpService(
63             HttpJsonConversationDatasetsStub.getMethodDescriptors(),
64             ConversationDatasetsSettings.getDefaultEndpoint());
65     ConversationDatasetsSettings settings =
66         ConversationDatasetsSettings.newHttpJsonBuilder()
67             .setTransportChannelProvider(
68                 ConversationDatasetsSettings.defaultHttpJsonTransportProviderBuilder()
69                     .setHttpTransport(mockService)
70                     .build())
71             .setCredentialsProvider(NoCredentialsProvider.create())
72             .build();
73     client = ConversationDatasetsClient.create(settings);
74   }
75 
76   @AfterClass
stopServer()77   public static void stopServer() {
78     client.close();
79   }
80 
81   @Before
setUp()82   public void setUp() {}
83 
84   @After
tearDown()85   public void tearDown() throws Exception {
86     mockService.reset();
87   }
88 
89   @Test
createConversationDatasetTest()90   public void createConversationDatasetTest() throws Exception {
91     ConversationDataset expectedResponse =
92         ConversationDataset.newBuilder()
93             .setName(
94                 ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]")
95                     .toString())
96             .setDisplayName("displayName1714148973")
97             .setDescription("description-1724546052")
98             .setCreateTime(Timestamp.newBuilder().build())
99             .setInputConfig(InputConfig.newBuilder().build())
100             .setConversationInfo(ConversationInfo.newBuilder().build())
101             .setConversationCount(1994187347)
102             .build();
103     Operation resultOperation =
104         Operation.newBuilder()
105             .setName("createConversationDatasetTest")
106             .setDone(true)
107             .setResponse(Any.pack(expectedResponse))
108             .build();
109     mockService.addResponse(resultOperation);
110 
111     String parent = "projects/project-5833/locations/location-5833";
112     ConversationDataset conversationDataset = ConversationDataset.newBuilder().build();
113 
114     ConversationDataset actualResponse =
115         client.createConversationDatasetAsync(parent, conversationDataset).get();
116     Assert.assertEquals(expectedResponse, actualResponse);
117 
118     List<String> actualRequests = mockService.getRequestPaths();
119     Assert.assertEquals(1, actualRequests.size());
120 
121     String apiClientHeaderKey =
122         mockService
123             .getRequestHeaders()
124             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
125             .iterator()
126             .next();
127     Assert.assertTrue(
128         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
129             .matcher(apiClientHeaderKey)
130             .matches());
131   }
132 
133   @Test
createConversationDatasetExceptionTest()134   public void createConversationDatasetExceptionTest() throws Exception {
135     ApiException exception =
136         ApiExceptionFactory.createException(
137             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
138     mockService.addException(exception);
139 
140     try {
141       String parent = "projects/project-5833/locations/location-5833";
142       ConversationDataset conversationDataset = ConversationDataset.newBuilder().build();
143       client.createConversationDatasetAsync(parent, conversationDataset).get();
144       Assert.fail("No exception raised");
145     } catch (ExecutionException e) {
146     }
147   }
148 
149   @Test
getConversationDatasetTest()150   public void getConversationDatasetTest() throws Exception {
151     ConversationDataset expectedResponse =
152         ConversationDataset.newBuilder()
153             .setName(
154                 ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]")
155                     .toString())
156             .setDisplayName("displayName1714148973")
157             .setDescription("description-1724546052")
158             .setCreateTime(Timestamp.newBuilder().build())
159             .setInputConfig(InputConfig.newBuilder().build())
160             .setConversationInfo(ConversationInfo.newBuilder().build())
161             .setConversationCount(1994187347)
162             .build();
163     mockService.addResponse(expectedResponse);
164 
165     ConversationDatasetName name =
166         ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]");
167 
168     ConversationDataset actualResponse = client.getConversationDataset(name);
169     Assert.assertEquals(expectedResponse, actualResponse);
170 
171     List<String> actualRequests = mockService.getRequestPaths();
172     Assert.assertEquals(1, actualRequests.size());
173 
174     String apiClientHeaderKey =
175         mockService
176             .getRequestHeaders()
177             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
178             .iterator()
179             .next();
180     Assert.assertTrue(
181         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
182             .matcher(apiClientHeaderKey)
183             .matches());
184   }
185 
186   @Test
getConversationDatasetExceptionTest()187   public void getConversationDatasetExceptionTest() throws Exception {
188     ApiException exception =
189         ApiExceptionFactory.createException(
190             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
191     mockService.addException(exception);
192 
193     try {
194       ConversationDatasetName name =
195           ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]");
196       client.getConversationDataset(name);
197       Assert.fail("No exception raised");
198     } catch (InvalidArgumentException e) {
199       // Expected exception.
200     }
201   }
202 
203   @Test
getConversationDatasetTest2()204   public void getConversationDatasetTest2() throws Exception {
205     ConversationDataset expectedResponse =
206         ConversationDataset.newBuilder()
207             .setName(
208                 ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]")
209                     .toString())
210             .setDisplayName("displayName1714148973")
211             .setDescription("description-1724546052")
212             .setCreateTime(Timestamp.newBuilder().build())
213             .setInputConfig(InputConfig.newBuilder().build())
214             .setConversationInfo(ConversationInfo.newBuilder().build())
215             .setConversationCount(1994187347)
216             .build();
217     mockService.addResponse(expectedResponse);
218 
219     String name = "projects/project-9960/conversationDatasets/conversationDataset-9960";
220 
221     ConversationDataset actualResponse = client.getConversationDataset(name);
222     Assert.assertEquals(expectedResponse, actualResponse);
223 
224     List<String> actualRequests = mockService.getRequestPaths();
225     Assert.assertEquals(1, actualRequests.size());
226 
227     String apiClientHeaderKey =
228         mockService
229             .getRequestHeaders()
230             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
231             .iterator()
232             .next();
233     Assert.assertTrue(
234         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
235             .matcher(apiClientHeaderKey)
236             .matches());
237   }
238 
239   @Test
getConversationDatasetExceptionTest2()240   public void getConversationDatasetExceptionTest2() throws Exception {
241     ApiException exception =
242         ApiExceptionFactory.createException(
243             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
244     mockService.addException(exception);
245 
246     try {
247       String name = "projects/project-9960/conversationDatasets/conversationDataset-9960";
248       client.getConversationDataset(name);
249       Assert.fail("No exception raised");
250     } catch (InvalidArgumentException e) {
251       // Expected exception.
252     }
253   }
254 
255   @Test
listConversationDatasetsTest()256   public void listConversationDatasetsTest() throws Exception {
257     ConversationDataset responsesElement = ConversationDataset.newBuilder().build();
258     ListConversationDatasetsResponse expectedResponse =
259         ListConversationDatasetsResponse.newBuilder()
260             .setNextPageToken("")
261             .addAllConversationDatasets(Arrays.asList(responsesElement))
262             .build();
263     mockService.addResponse(expectedResponse);
264 
265     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
266 
267     ListConversationDatasetsPagedResponse pagedListResponse =
268         client.listConversationDatasets(parent);
269 
270     List<ConversationDataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
271 
272     Assert.assertEquals(1, resources.size());
273     Assert.assertEquals(expectedResponse.getConversationDatasetsList().get(0), resources.get(0));
274 
275     List<String> actualRequests = mockService.getRequestPaths();
276     Assert.assertEquals(1, actualRequests.size());
277 
278     String apiClientHeaderKey =
279         mockService
280             .getRequestHeaders()
281             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
282             .iterator()
283             .next();
284     Assert.assertTrue(
285         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
286             .matcher(apiClientHeaderKey)
287             .matches());
288   }
289 
290   @Test
listConversationDatasetsExceptionTest()291   public void listConversationDatasetsExceptionTest() throws Exception {
292     ApiException exception =
293         ApiExceptionFactory.createException(
294             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
295     mockService.addException(exception);
296 
297     try {
298       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
299       client.listConversationDatasets(parent);
300       Assert.fail("No exception raised");
301     } catch (InvalidArgumentException e) {
302       // Expected exception.
303     }
304   }
305 
306   @Test
listConversationDatasetsTest2()307   public void listConversationDatasetsTest2() throws Exception {
308     ConversationDataset responsesElement = ConversationDataset.newBuilder().build();
309     ListConversationDatasetsResponse expectedResponse =
310         ListConversationDatasetsResponse.newBuilder()
311             .setNextPageToken("")
312             .addAllConversationDatasets(Arrays.asList(responsesElement))
313             .build();
314     mockService.addResponse(expectedResponse);
315 
316     String parent = "projects/project-2353";
317 
318     ListConversationDatasetsPagedResponse pagedListResponse =
319         client.listConversationDatasets(parent);
320 
321     List<ConversationDataset> resources = Lists.newArrayList(pagedListResponse.iterateAll());
322 
323     Assert.assertEquals(1, resources.size());
324     Assert.assertEquals(expectedResponse.getConversationDatasetsList().get(0), resources.get(0));
325 
326     List<String> actualRequests = mockService.getRequestPaths();
327     Assert.assertEquals(1, actualRequests.size());
328 
329     String apiClientHeaderKey =
330         mockService
331             .getRequestHeaders()
332             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
333             .iterator()
334             .next();
335     Assert.assertTrue(
336         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
337             .matcher(apiClientHeaderKey)
338             .matches());
339   }
340 
341   @Test
listConversationDatasetsExceptionTest2()342   public void listConversationDatasetsExceptionTest2() throws Exception {
343     ApiException exception =
344         ApiExceptionFactory.createException(
345             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
346     mockService.addException(exception);
347 
348     try {
349       String parent = "projects/project-2353";
350       client.listConversationDatasets(parent);
351       Assert.fail("No exception raised");
352     } catch (InvalidArgumentException e) {
353       // Expected exception.
354     }
355   }
356 
357   @Test
deleteConversationDatasetTest()358   public void deleteConversationDatasetTest() throws Exception {
359     Empty expectedResponse = Empty.newBuilder().build();
360     Operation resultOperation =
361         Operation.newBuilder()
362             .setName("deleteConversationDatasetTest")
363             .setDone(true)
364             .setResponse(Any.pack(expectedResponse))
365             .build();
366     mockService.addResponse(resultOperation);
367 
368     ConversationDatasetName name =
369         ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]");
370 
371     client.deleteConversationDatasetAsync(name).get();
372 
373     List<String> actualRequests = mockService.getRequestPaths();
374     Assert.assertEquals(1, actualRequests.size());
375 
376     String apiClientHeaderKey =
377         mockService
378             .getRequestHeaders()
379             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
380             .iterator()
381             .next();
382     Assert.assertTrue(
383         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
384             .matcher(apiClientHeaderKey)
385             .matches());
386   }
387 
388   @Test
deleteConversationDatasetExceptionTest()389   public void deleteConversationDatasetExceptionTest() throws Exception {
390     ApiException exception =
391         ApiExceptionFactory.createException(
392             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
393     mockService.addException(exception);
394 
395     try {
396       ConversationDatasetName name =
397           ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]");
398       client.deleteConversationDatasetAsync(name).get();
399       Assert.fail("No exception raised");
400     } catch (ExecutionException e) {
401     }
402   }
403 
404   @Test
deleteConversationDatasetTest2()405   public void deleteConversationDatasetTest2() throws Exception {
406     Empty expectedResponse = Empty.newBuilder().build();
407     Operation resultOperation =
408         Operation.newBuilder()
409             .setName("deleteConversationDatasetTest")
410             .setDone(true)
411             .setResponse(Any.pack(expectedResponse))
412             .build();
413     mockService.addResponse(resultOperation);
414 
415     String name =
416         "projects/project-658/locations/location-658/conversationDatasets/conversationDataset-658";
417 
418     client.deleteConversationDatasetAsync(name).get();
419 
420     List<String> actualRequests = mockService.getRequestPaths();
421     Assert.assertEquals(1, actualRequests.size());
422 
423     String apiClientHeaderKey =
424         mockService
425             .getRequestHeaders()
426             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
427             .iterator()
428             .next();
429     Assert.assertTrue(
430         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
431             .matcher(apiClientHeaderKey)
432             .matches());
433   }
434 
435   @Test
deleteConversationDatasetExceptionTest2()436   public void deleteConversationDatasetExceptionTest2() throws Exception {
437     ApiException exception =
438         ApiExceptionFactory.createException(
439             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
440     mockService.addException(exception);
441 
442     try {
443       String name =
444           "projects/project-658/locations/location-658/conversationDatasets/conversationDataset-658";
445       client.deleteConversationDatasetAsync(name).get();
446       Assert.fail("No exception raised");
447     } catch (ExecutionException e) {
448     }
449   }
450 
451   @Test
importConversationDataTest()452   public void importConversationDataTest() throws Exception {
453     ImportConversationDataOperationResponse expectedResponse =
454         ImportConversationDataOperationResponse.newBuilder()
455             .setConversationDataset(
456                 ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]")
457                     .toString())
458             .setImportCount(-1721296907)
459             .build();
460     Operation resultOperation =
461         Operation.newBuilder()
462             .setName("importConversationDataTest")
463             .setDone(true)
464             .setResponse(Any.pack(expectedResponse))
465             .build();
466     mockService.addResponse(resultOperation);
467 
468     ImportConversationDataRequest request =
469         ImportConversationDataRequest.newBuilder()
470             .setName(
471                 ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]")
472                     .toString())
473             .setInputConfig(InputConfig.newBuilder().build())
474             .build();
475 
476     ImportConversationDataOperationResponse actualResponse =
477         client.importConversationDataAsync(request).get();
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
importConversationDataExceptionTest()496   public void importConversationDataExceptionTest() 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       ImportConversationDataRequest request =
504           ImportConversationDataRequest.newBuilder()
505               .setName(
506                   ConversationDatasetName.of("[PROJECT]", "[LOCATION]", "[CONVERSATION_DATASET]")
507                       .toString())
508               .setInputConfig(InputConfig.newBuilder().build())
509               .build();
510       client.importConversationDataAsync(request).get();
511       Assert.fail("No exception raised");
512     } catch (ExecutionException e) {
513     }
514   }
515 
516   @Test
listLocationsTest()517   public void listLocationsTest() throws Exception {
518     Location responsesElement = Location.newBuilder().build();
519     ListLocationsResponse expectedResponse =
520         ListLocationsResponse.newBuilder()
521             .setNextPageToken("")
522             .addAllLocations(Arrays.asList(responsesElement))
523             .build();
524     mockService.addResponse(expectedResponse);
525 
526     ListLocationsRequest request =
527         ListLocationsRequest.newBuilder()
528             .setName("projects/project-3664")
529             .setFilter("filter-1274492040")
530             .setPageSize(883849137)
531             .setPageToken("pageToken873572522")
532             .build();
533 
534     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
535 
536     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
537 
538     Assert.assertEquals(1, resources.size());
539     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
540 
541     List<String> actualRequests = mockService.getRequestPaths();
542     Assert.assertEquals(1, actualRequests.size());
543 
544     String apiClientHeaderKey =
545         mockService
546             .getRequestHeaders()
547             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
548             .iterator()
549             .next();
550     Assert.assertTrue(
551         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
552             .matcher(apiClientHeaderKey)
553             .matches());
554   }
555 
556   @Test
listLocationsExceptionTest()557   public void listLocationsExceptionTest() throws Exception {
558     ApiException exception =
559         ApiExceptionFactory.createException(
560             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
561     mockService.addException(exception);
562 
563     try {
564       ListLocationsRequest request =
565           ListLocationsRequest.newBuilder()
566               .setName("projects/project-3664")
567               .setFilter("filter-1274492040")
568               .setPageSize(883849137)
569               .setPageToken("pageToken873572522")
570               .build();
571       client.listLocations(request);
572       Assert.fail("No exception raised");
573     } catch (InvalidArgumentException e) {
574       // Expected exception.
575     }
576   }
577 
578   @Test
getLocationTest()579   public void getLocationTest() throws Exception {
580     Location expectedResponse =
581         Location.newBuilder()
582             .setName("name3373707")
583             .setLocationId("locationId1541836720")
584             .setDisplayName("displayName1714148973")
585             .putAllLabels(new HashMap<String, String>())
586             .setMetadata(Any.newBuilder().build())
587             .build();
588     mockService.addResponse(expectedResponse);
589 
590     GetLocationRequest request =
591         GetLocationRequest.newBuilder()
592             .setName("projects/project-9062/locations/location-9062")
593             .build();
594 
595     Location actualResponse = client.getLocation(request);
596     Assert.assertEquals(expectedResponse, actualResponse);
597 
598     List<String> actualRequests = mockService.getRequestPaths();
599     Assert.assertEquals(1, actualRequests.size());
600 
601     String apiClientHeaderKey =
602         mockService
603             .getRequestHeaders()
604             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
605             .iterator()
606             .next();
607     Assert.assertTrue(
608         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
609             .matcher(apiClientHeaderKey)
610             .matches());
611   }
612 
613   @Test
getLocationExceptionTest()614   public void getLocationExceptionTest() throws Exception {
615     ApiException exception =
616         ApiExceptionFactory.createException(
617             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
618     mockService.addException(exception);
619 
620     try {
621       GetLocationRequest request =
622           GetLocationRequest.newBuilder()
623               .setName("projects/project-9062/locations/location-9062")
624               .build();
625       client.getLocation(request);
626       Assert.fail("No exception raised");
627     } catch (InvalidArgumentException e) {
628       // Expected exception.
629     }
630   }
631 }
632