• 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.cx.v3;
18 
19 import static com.google.cloud.dialogflow.cx.v3.VersionsClient.ListLocationsPagedResponse;
20 import static com.google.cloud.dialogflow.cx.v3.VersionsClient.ListVersionsPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.cloud.location.GetLocationRequest;
31 import com.google.cloud.location.ListLocationsRequest;
32 import com.google.cloud.location.ListLocationsResponse;
33 import com.google.cloud.location.Location;
34 import com.google.common.collect.Lists;
35 import com.google.longrunning.Operation;
36 import com.google.protobuf.AbstractMessage;
37 import com.google.protobuf.Any;
38 import com.google.protobuf.Empty;
39 import com.google.protobuf.FieldMask;
40 import com.google.protobuf.Timestamp;
41 import io.grpc.StatusRuntimeException;
42 import java.io.IOException;
43 import java.util.Arrays;
44 import java.util.HashMap;
45 import java.util.List;
46 import java.util.UUID;
47 import java.util.concurrent.ExecutionException;
48 import javax.annotation.Generated;
49 import org.junit.After;
50 import org.junit.AfterClass;
51 import org.junit.Assert;
52 import org.junit.Before;
53 import org.junit.BeforeClass;
54 import org.junit.Test;
55 
56 @Generated("by gapic-generator-java")
57 public class VersionsClientTest {
58   private static MockLocations mockLocations;
59   private static MockServiceHelper mockServiceHelper;
60   private static MockVersions mockVersions;
61   private LocalChannelProvider channelProvider;
62   private VersionsClient client;
63 
64   @BeforeClass
startStaticServer()65   public static void startStaticServer() {
66     mockVersions = new MockVersions();
67     mockLocations = new MockLocations();
68     mockServiceHelper =
69         new MockServiceHelper(
70             UUID.randomUUID().toString(),
71             Arrays.<MockGrpcService>asList(mockVersions, mockLocations));
72     mockServiceHelper.start();
73   }
74 
75   @AfterClass
stopServer()76   public static void stopServer() {
77     mockServiceHelper.stop();
78   }
79 
80   @Before
setUp()81   public void setUp() throws IOException {
82     mockServiceHelper.reset();
83     channelProvider = mockServiceHelper.createChannelProvider();
84     VersionsSettings settings =
85         VersionsSettings.newBuilder()
86             .setTransportChannelProvider(channelProvider)
87             .setCredentialsProvider(NoCredentialsProvider.create())
88             .build();
89     client = VersionsClient.create(settings);
90   }
91 
92   @After
tearDown()93   public void tearDown() throws Exception {
94     client.close();
95   }
96 
97   @Test
listVersionsTest()98   public void listVersionsTest() throws Exception {
99     Version responsesElement = Version.newBuilder().build();
100     ListVersionsResponse expectedResponse =
101         ListVersionsResponse.newBuilder()
102             .setNextPageToken("")
103             .addAllVersions(Arrays.asList(responsesElement))
104             .build();
105     mockVersions.addResponse(expectedResponse);
106 
107     FlowName parent = FlowName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]");
108 
109     ListVersionsPagedResponse pagedListResponse = client.listVersions(parent);
110 
111     List<Version> resources = Lists.newArrayList(pagedListResponse.iterateAll());
112 
113     Assert.assertEquals(1, resources.size());
114     Assert.assertEquals(expectedResponse.getVersionsList().get(0), resources.get(0));
115 
116     List<AbstractMessage> actualRequests = mockVersions.getRequests();
117     Assert.assertEquals(1, actualRequests.size());
118     ListVersionsRequest actualRequest = ((ListVersionsRequest) actualRequests.get(0));
119 
120     Assert.assertEquals(parent.toString(), actualRequest.getParent());
121     Assert.assertTrue(
122         channelProvider.isHeaderSent(
123             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
124             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
125   }
126 
127   @Test
listVersionsExceptionTest()128   public void listVersionsExceptionTest() throws Exception {
129     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
130     mockVersions.addException(exception);
131 
132     try {
133       FlowName parent = FlowName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]");
134       client.listVersions(parent);
135       Assert.fail("No exception raised");
136     } catch (InvalidArgumentException e) {
137       // Expected exception.
138     }
139   }
140 
141   @Test
listVersionsTest2()142   public void listVersionsTest2() throws Exception {
143     Version responsesElement = Version.newBuilder().build();
144     ListVersionsResponse expectedResponse =
145         ListVersionsResponse.newBuilder()
146             .setNextPageToken("")
147             .addAllVersions(Arrays.asList(responsesElement))
148             .build();
149     mockVersions.addResponse(expectedResponse);
150 
151     String parent = "parent-995424086";
152 
153     ListVersionsPagedResponse pagedListResponse = client.listVersions(parent);
154 
155     List<Version> resources = Lists.newArrayList(pagedListResponse.iterateAll());
156 
157     Assert.assertEquals(1, resources.size());
158     Assert.assertEquals(expectedResponse.getVersionsList().get(0), resources.get(0));
159 
160     List<AbstractMessage> actualRequests = mockVersions.getRequests();
161     Assert.assertEquals(1, actualRequests.size());
162     ListVersionsRequest actualRequest = ((ListVersionsRequest) actualRequests.get(0));
163 
164     Assert.assertEquals(parent, actualRequest.getParent());
165     Assert.assertTrue(
166         channelProvider.isHeaderSent(
167             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
168             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
169   }
170 
171   @Test
listVersionsExceptionTest2()172   public void listVersionsExceptionTest2() throws Exception {
173     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
174     mockVersions.addException(exception);
175 
176     try {
177       String parent = "parent-995424086";
178       client.listVersions(parent);
179       Assert.fail("No exception raised");
180     } catch (InvalidArgumentException e) {
181       // Expected exception.
182     }
183   }
184 
185   @Test
getVersionTest()186   public void getVersionTest() throws Exception {
187     Version expectedResponse =
188         Version.newBuilder()
189             .setName(
190                 VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]")
191                     .toString())
192             .setDisplayName("displayName1714148973")
193             .setDescription("description-1724546052")
194             .setNluSettings(NluSettings.newBuilder().build())
195             .setCreateTime(Timestamp.newBuilder().build())
196             .build();
197     mockVersions.addResponse(expectedResponse);
198 
199     VersionName name = VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
200 
201     Version actualResponse = client.getVersion(name);
202     Assert.assertEquals(expectedResponse, actualResponse);
203 
204     List<AbstractMessage> actualRequests = mockVersions.getRequests();
205     Assert.assertEquals(1, actualRequests.size());
206     GetVersionRequest actualRequest = ((GetVersionRequest) actualRequests.get(0));
207 
208     Assert.assertEquals(name.toString(), actualRequest.getName());
209     Assert.assertTrue(
210         channelProvider.isHeaderSent(
211             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
212             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
213   }
214 
215   @Test
getVersionExceptionTest()216   public void getVersionExceptionTest() throws Exception {
217     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
218     mockVersions.addException(exception);
219 
220     try {
221       VersionName name =
222           VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
223       client.getVersion(name);
224       Assert.fail("No exception raised");
225     } catch (InvalidArgumentException e) {
226       // Expected exception.
227     }
228   }
229 
230   @Test
getVersionTest2()231   public void getVersionTest2() throws Exception {
232     Version expectedResponse =
233         Version.newBuilder()
234             .setName(
235                 VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]")
236                     .toString())
237             .setDisplayName("displayName1714148973")
238             .setDescription("description-1724546052")
239             .setNluSettings(NluSettings.newBuilder().build())
240             .setCreateTime(Timestamp.newBuilder().build())
241             .build();
242     mockVersions.addResponse(expectedResponse);
243 
244     String name = "name3373707";
245 
246     Version actualResponse = client.getVersion(name);
247     Assert.assertEquals(expectedResponse, actualResponse);
248 
249     List<AbstractMessage> actualRequests = mockVersions.getRequests();
250     Assert.assertEquals(1, actualRequests.size());
251     GetVersionRequest actualRequest = ((GetVersionRequest) actualRequests.get(0));
252 
253     Assert.assertEquals(name, actualRequest.getName());
254     Assert.assertTrue(
255         channelProvider.isHeaderSent(
256             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
257             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
258   }
259 
260   @Test
getVersionExceptionTest2()261   public void getVersionExceptionTest2() throws Exception {
262     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
263     mockVersions.addException(exception);
264 
265     try {
266       String name = "name3373707";
267       client.getVersion(name);
268       Assert.fail("No exception raised");
269     } catch (InvalidArgumentException e) {
270       // Expected exception.
271     }
272   }
273 
274   @Test
createVersionTest()275   public void createVersionTest() throws Exception {
276     Version expectedResponse =
277         Version.newBuilder()
278             .setName(
279                 VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]")
280                     .toString())
281             .setDisplayName("displayName1714148973")
282             .setDescription("description-1724546052")
283             .setNluSettings(NluSettings.newBuilder().build())
284             .setCreateTime(Timestamp.newBuilder().build())
285             .build();
286     Operation resultOperation =
287         Operation.newBuilder()
288             .setName("createVersionTest")
289             .setDone(true)
290             .setResponse(Any.pack(expectedResponse))
291             .build();
292     mockVersions.addResponse(resultOperation);
293 
294     FlowName parent = FlowName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]");
295     Version version = Version.newBuilder().build();
296 
297     Version actualResponse = client.createVersionAsync(parent, version).get();
298     Assert.assertEquals(expectedResponse, actualResponse);
299 
300     List<AbstractMessage> actualRequests = mockVersions.getRequests();
301     Assert.assertEquals(1, actualRequests.size());
302     CreateVersionRequest actualRequest = ((CreateVersionRequest) actualRequests.get(0));
303 
304     Assert.assertEquals(parent.toString(), actualRequest.getParent());
305     Assert.assertEquals(version, actualRequest.getVersion());
306     Assert.assertTrue(
307         channelProvider.isHeaderSent(
308             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
309             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
310   }
311 
312   @Test
createVersionExceptionTest()313   public void createVersionExceptionTest() throws Exception {
314     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
315     mockVersions.addException(exception);
316 
317     try {
318       FlowName parent = FlowName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]");
319       Version version = Version.newBuilder().build();
320       client.createVersionAsync(parent, version).get();
321       Assert.fail("No exception raised");
322     } catch (ExecutionException e) {
323       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
324       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
325       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
326     }
327   }
328 
329   @Test
createVersionTest2()330   public void createVersionTest2() throws Exception {
331     Version expectedResponse =
332         Version.newBuilder()
333             .setName(
334                 VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]")
335                     .toString())
336             .setDisplayName("displayName1714148973")
337             .setDescription("description-1724546052")
338             .setNluSettings(NluSettings.newBuilder().build())
339             .setCreateTime(Timestamp.newBuilder().build())
340             .build();
341     Operation resultOperation =
342         Operation.newBuilder()
343             .setName("createVersionTest")
344             .setDone(true)
345             .setResponse(Any.pack(expectedResponse))
346             .build();
347     mockVersions.addResponse(resultOperation);
348 
349     String parent = "parent-995424086";
350     Version version = Version.newBuilder().build();
351 
352     Version actualResponse = client.createVersionAsync(parent, version).get();
353     Assert.assertEquals(expectedResponse, actualResponse);
354 
355     List<AbstractMessage> actualRequests = mockVersions.getRequests();
356     Assert.assertEquals(1, actualRequests.size());
357     CreateVersionRequest actualRequest = ((CreateVersionRequest) actualRequests.get(0));
358 
359     Assert.assertEquals(parent, actualRequest.getParent());
360     Assert.assertEquals(version, actualRequest.getVersion());
361     Assert.assertTrue(
362         channelProvider.isHeaderSent(
363             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
364             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
365   }
366 
367   @Test
createVersionExceptionTest2()368   public void createVersionExceptionTest2() throws Exception {
369     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
370     mockVersions.addException(exception);
371 
372     try {
373       String parent = "parent-995424086";
374       Version version = Version.newBuilder().build();
375       client.createVersionAsync(parent, version).get();
376       Assert.fail("No exception raised");
377     } catch (ExecutionException e) {
378       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
379       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
380       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
381     }
382   }
383 
384   @Test
updateVersionTest()385   public void updateVersionTest() throws Exception {
386     Version expectedResponse =
387         Version.newBuilder()
388             .setName(
389                 VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]")
390                     .toString())
391             .setDisplayName("displayName1714148973")
392             .setDescription("description-1724546052")
393             .setNluSettings(NluSettings.newBuilder().build())
394             .setCreateTime(Timestamp.newBuilder().build())
395             .build();
396     mockVersions.addResponse(expectedResponse);
397 
398     Version version = Version.newBuilder().build();
399     FieldMask updateMask = FieldMask.newBuilder().build();
400 
401     Version actualResponse = client.updateVersion(version, updateMask);
402     Assert.assertEquals(expectedResponse, actualResponse);
403 
404     List<AbstractMessage> actualRequests = mockVersions.getRequests();
405     Assert.assertEquals(1, actualRequests.size());
406     UpdateVersionRequest actualRequest = ((UpdateVersionRequest) actualRequests.get(0));
407 
408     Assert.assertEquals(version, actualRequest.getVersion());
409     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
410     Assert.assertTrue(
411         channelProvider.isHeaderSent(
412             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
413             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
414   }
415 
416   @Test
updateVersionExceptionTest()417   public void updateVersionExceptionTest() throws Exception {
418     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
419     mockVersions.addException(exception);
420 
421     try {
422       Version version = Version.newBuilder().build();
423       FieldMask updateMask = FieldMask.newBuilder().build();
424       client.updateVersion(version, updateMask);
425       Assert.fail("No exception raised");
426     } catch (InvalidArgumentException e) {
427       // Expected exception.
428     }
429   }
430 
431   @Test
deleteVersionTest()432   public void deleteVersionTest() throws Exception {
433     Empty expectedResponse = Empty.newBuilder().build();
434     mockVersions.addResponse(expectedResponse);
435 
436     VersionName name = VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
437 
438     client.deleteVersion(name);
439 
440     List<AbstractMessage> actualRequests = mockVersions.getRequests();
441     Assert.assertEquals(1, actualRequests.size());
442     DeleteVersionRequest actualRequest = ((DeleteVersionRequest) actualRequests.get(0));
443 
444     Assert.assertEquals(name.toString(), actualRequest.getName());
445     Assert.assertTrue(
446         channelProvider.isHeaderSent(
447             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
448             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
449   }
450 
451   @Test
deleteVersionExceptionTest()452   public void deleteVersionExceptionTest() throws Exception {
453     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
454     mockVersions.addException(exception);
455 
456     try {
457       VersionName name =
458           VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
459       client.deleteVersion(name);
460       Assert.fail("No exception raised");
461     } catch (InvalidArgumentException e) {
462       // Expected exception.
463     }
464   }
465 
466   @Test
deleteVersionTest2()467   public void deleteVersionTest2() throws Exception {
468     Empty expectedResponse = Empty.newBuilder().build();
469     mockVersions.addResponse(expectedResponse);
470 
471     String name = "name3373707";
472 
473     client.deleteVersion(name);
474 
475     List<AbstractMessage> actualRequests = mockVersions.getRequests();
476     Assert.assertEquals(1, actualRequests.size());
477     DeleteVersionRequest actualRequest = ((DeleteVersionRequest) actualRequests.get(0));
478 
479     Assert.assertEquals(name, actualRequest.getName());
480     Assert.assertTrue(
481         channelProvider.isHeaderSent(
482             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
483             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
484   }
485 
486   @Test
deleteVersionExceptionTest2()487   public void deleteVersionExceptionTest2() throws Exception {
488     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
489     mockVersions.addException(exception);
490 
491     try {
492       String name = "name3373707";
493       client.deleteVersion(name);
494       Assert.fail("No exception raised");
495     } catch (InvalidArgumentException e) {
496       // Expected exception.
497     }
498   }
499 
500   @Test
loadVersionTest()501   public void loadVersionTest() throws Exception {
502     Empty expectedResponse = Empty.newBuilder().build();
503     Operation resultOperation =
504         Operation.newBuilder()
505             .setName("loadVersionTest")
506             .setDone(true)
507             .setResponse(Any.pack(expectedResponse))
508             .build();
509     mockVersions.addResponse(resultOperation);
510 
511     VersionName name = VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
512 
513     client.loadVersionAsync(name).get();
514 
515     List<AbstractMessage> actualRequests = mockVersions.getRequests();
516     Assert.assertEquals(1, actualRequests.size());
517     LoadVersionRequest actualRequest = ((LoadVersionRequest) actualRequests.get(0));
518 
519     Assert.assertEquals(name.toString(), actualRequest.getName());
520     Assert.assertTrue(
521         channelProvider.isHeaderSent(
522             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
523             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
524   }
525 
526   @Test
loadVersionExceptionTest()527   public void loadVersionExceptionTest() throws Exception {
528     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
529     mockVersions.addException(exception);
530 
531     try {
532       VersionName name =
533           VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
534       client.loadVersionAsync(name).get();
535       Assert.fail("No exception raised");
536     } catch (ExecutionException e) {
537       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
538       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
539       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
540     }
541   }
542 
543   @Test
loadVersionTest2()544   public void loadVersionTest2() throws Exception {
545     Empty expectedResponse = Empty.newBuilder().build();
546     Operation resultOperation =
547         Operation.newBuilder()
548             .setName("loadVersionTest")
549             .setDone(true)
550             .setResponse(Any.pack(expectedResponse))
551             .build();
552     mockVersions.addResponse(resultOperation);
553 
554     String name = "name3373707";
555 
556     client.loadVersionAsync(name).get();
557 
558     List<AbstractMessage> actualRequests = mockVersions.getRequests();
559     Assert.assertEquals(1, actualRequests.size());
560     LoadVersionRequest actualRequest = ((LoadVersionRequest) actualRequests.get(0));
561 
562     Assert.assertEquals(name, actualRequest.getName());
563     Assert.assertTrue(
564         channelProvider.isHeaderSent(
565             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
566             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
567   }
568 
569   @Test
loadVersionExceptionTest2()570   public void loadVersionExceptionTest2() throws Exception {
571     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
572     mockVersions.addException(exception);
573 
574     try {
575       String name = "name3373707";
576       client.loadVersionAsync(name).get();
577       Assert.fail("No exception raised");
578     } catch (ExecutionException e) {
579       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
580       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
581       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
582     }
583   }
584 
585   @Test
compareVersionsTest()586   public void compareVersionsTest() throws Exception {
587     CompareVersionsResponse expectedResponse =
588         CompareVersionsResponse.newBuilder()
589             .setBaseVersionContentJson("baseVersionContentJson-856795718")
590             .setTargetVersionContentJson("targetVersionContentJson813797498")
591             .setCompareTime(Timestamp.newBuilder().build())
592             .build();
593     mockVersions.addResponse(expectedResponse);
594 
595     VersionName baseVersion =
596         VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
597 
598     CompareVersionsResponse actualResponse = client.compareVersions(baseVersion);
599     Assert.assertEquals(expectedResponse, actualResponse);
600 
601     List<AbstractMessage> actualRequests = mockVersions.getRequests();
602     Assert.assertEquals(1, actualRequests.size());
603     CompareVersionsRequest actualRequest = ((CompareVersionsRequest) actualRequests.get(0));
604 
605     Assert.assertEquals(baseVersion.toString(), actualRequest.getBaseVersion());
606     Assert.assertTrue(
607         channelProvider.isHeaderSent(
608             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
609             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
610   }
611 
612   @Test
compareVersionsExceptionTest()613   public void compareVersionsExceptionTest() throws Exception {
614     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
615     mockVersions.addException(exception);
616 
617     try {
618       VersionName baseVersion =
619           VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]");
620       client.compareVersions(baseVersion);
621       Assert.fail("No exception raised");
622     } catch (InvalidArgumentException e) {
623       // Expected exception.
624     }
625   }
626 
627   @Test
compareVersionsTest2()628   public void compareVersionsTest2() throws Exception {
629     CompareVersionsResponse expectedResponse =
630         CompareVersionsResponse.newBuilder()
631             .setBaseVersionContentJson("baseVersionContentJson-856795718")
632             .setTargetVersionContentJson("targetVersionContentJson813797498")
633             .setCompareTime(Timestamp.newBuilder().build())
634             .build();
635     mockVersions.addResponse(expectedResponse);
636 
637     String baseVersion = "baseVersion-1641901881";
638 
639     CompareVersionsResponse actualResponse = client.compareVersions(baseVersion);
640     Assert.assertEquals(expectedResponse, actualResponse);
641 
642     List<AbstractMessage> actualRequests = mockVersions.getRequests();
643     Assert.assertEquals(1, actualRequests.size());
644     CompareVersionsRequest actualRequest = ((CompareVersionsRequest) actualRequests.get(0));
645 
646     Assert.assertEquals(baseVersion, actualRequest.getBaseVersion());
647     Assert.assertTrue(
648         channelProvider.isHeaderSent(
649             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
650             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
651   }
652 
653   @Test
compareVersionsExceptionTest2()654   public void compareVersionsExceptionTest2() throws Exception {
655     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
656     mockVersions.addException(exception);
657 
658     try {
659       String baseVersion = "baseVersion-1641901881";
660       client.compareVersions(baseVersion);
661       Assert.fail("No exception raised");
662     } catch (InvalidArgumentException e) {
663       // Expected exception.
664     }
665   }
666 
667   @Test
listLocationsTest()668   public void listLocationsTest() throws Exception {
669     Location responsesElement = Location.newBuilder().build();
670     ListLocationsResponse expectedResponse =
671         ListLocationsResponse.newBuilder()
672             .setNextPageToken("")
673             .addAllLocations(Arrays.asList(responsesElement))
674             .build();
675     mockLocations.addResponse(expectedResponse);
676 
677     ListLocationsRequest request =
678         ListLocationsRequest.newBuilder()
679             .setName("name3373707")
680             .setFilter("filter-1274492040")
681             .setPageSize(883849137)
682             .setPageToken("pageToken873572522")
683             .build();
684 
685     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
686 
687     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
688 
689     Assert.assertEquals(1, resources.size());
690     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
691 
692     List<AbstractMessage> actualRequests = mockLocations.getRequests();
693     Assert.assertEquals(1, actualRequests.size());
694     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
695 
696     Assert.assertEquals(request.getName(), actualRequest.getName());
697     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
698     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
699     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
700     Assert.assertTrue(
701         channelProvider.isHeaderSent(
702             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
703             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
704   }
705 
706   @Test
listLocationsExceptionTest()707   public void listLocationsExceptionTest() throws Exception {
708     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
709     mockLocations.addException(exception);
710 
711     try {
712       ListLocationsRequest request =
713           ListLocationsRequest.newBuilder()
714               .setName("name3373707")
715               .setFilter("filter-1274492040")
716               .setPageSize(883849137)
717               .setPageToken("pageToken873572522")
718               .build();
719       client.listLocations(request);
720       Assert.fail("No exception raised");
721     } catch (InvalidArgumentException e) {
722       // Expected exception.
723     }
724   }
725 
726   @Test
getLocationTest()727   public void getLocationTest() throws Exception {
728     Location expectedResponse =
729         Location.newBuilder()
730             .setName("name3373707")
731             .setLocationId("locationId1541836720")
732             .setDisplayName("displayName1714148973")
733             .putAllLabels(new HashMap<String, String>())
734             .setMetadata(Any.newBuilder().build())
735             .build();
736     mockLocations.addResponse(expectedResponse);
737 
738     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
739 
740     Location actualResponse = client.getLocation(request);
741     Assert.assertEquals(expectedResponse, actualResponse);
742 
743     List<AbstractMessage> actualRequests = mockLocations.getRequests();
744     Assert.assertEquals(1, actualRequests.size());
745     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
746 
747     Assert.assertEquals(request.getName(), actualRequest.getName());
748     Assert.assertTrue(
749         channelProvider.isHeaderSent(
750             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
751             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
752   }
753 
754   @Test
getLocationExceptionTest()755   public void getLocationExceptionTest() throws Exception {
756     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
757     mockLocations.addException(exception);
758 
759     try {
760       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
761       client.getLocation(request);
762       Assert.fail("No exception raised");
763     } catch (InvalidArgumentException e) {
764       // Expected exception.
765     }
766   }
767 }
768