• 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.SessionEntityTypesClient.ListLocationsPagedResponse;
20 import static com.google.cloud.dialogflow.v2.SessionEntityTypesClient.ListSessionEntityTypesPagedResponse;
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.HttpJsonSessionEntityTypesStub;
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.protobuf.Any;
38 import com.google.protobuf.Empty;
39 import com.google.protobuf.FieldMask;
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 SessionEntityTypesClientHttpJsonTest {
55   private static MockHttpService mockService;
56   private static SessionEntityTypesClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() throws IOException {
60     mockService =
61         new MockHttpService(
62             HttpJsonSessionEntityTypesStub.getMethodDescriptors(),
63             SessionEntityTypesSettings.getDefaultEndpoint());
64     SessionEntityTypesSettings settings =
65         SessionEntityTypesSettings.newHttpJsonBuilder()
66             .setTransportChannelProvider(
67                 SessionEntityTypesSettings.defaultHttpJsonTransportProviderBuilder()
68                     .setHttpTransport(mockService)
69                     .build())
70             .setCredentialsProvider(NoCredentialsProvider.create())
71             .build();
72     client = SessionEntityTypesClient.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
listSessionEntityTypesTest()89   public void listSessionEntityTypesTest() throws Exception {
90     SessionEntityType responsesElement = SessionEntityType.newBuilder().build();
91     ListSessionEntityTypesResponse expectedResponse =
92         ListSessionEntityTypesResponse.newBuilder()
93             .setNextPageToken("")
94             .addAllSessionEntityTypes(Arrays.asList(responsesElement))
95             .build();
96     mockService.addResponse(expectedResponse);
97 
98     SessionName parent = SessionName.ofProjectSessionName("[PROJECT]", "[SESSION]");
99 
100     ListSessionEntityTypesPagedResponse pagedListResponse = client.listSessionEntityTypes(parent);
101 
102     List<SessionEntityType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
103 
104     Assert.assertEquals(1, resources.size());
105     Assert.assertEquals(expectedResponse.getSessionEntityTypesList().get(0), resources.get(0));
106 
107     List<String> actualRequests = mockService.getRequestPaths();
108     Assert.assertEquals(1, actualRequests.size());
109 
110     String apiClientHeaderKey =
111         mockService
112             .getRequestHeaders()
113             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
114             .iterator()
115             .next();
116     Assert.assertTrue(
117         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
118             .matcher(apiClientHeaderKey)
119             .matches());
120   }
121 
122   @Test
listSessionEntityTypesExceptionTest()123   public void listSessionEntityTypesExceptionTest() throws Exception {
124     ApiException exception =
125         ApiExceptionFactory.createException(
126             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
127     mockService.addException(exception);
128 
129     try {
130       SessionName parent = SessionName.ofProjectSessionName("[PROJECT]", "[SESSION]");
131       client.listSessionEntityTypes(parent);
132       Assert.fail("No exception raised");
133     } catch (InvalidArgumentException e) {
134       // Expected exception.
135     }
136   }
137 
138   @Test
listSessionEntityTypesTest2()139   public void listSessionEntityTypesTest2() throws Exception {
140     SessionEntityType responsesElement = SessionEntityType.newBuilder().build();
141     ListSessionEntityTypesResponse expectedResponse =
142         ListSessionEntityTypesResponse.newBuilder()
143             .setNextPageToken("")
144             .addAllSessionEntityTypes(Arrays.asList(responsesElement))
145             .build();
146     mockService.addResponse(expectedResponse);
147 
148     String parent = "projects/project-6494/agent/sessions/session-6494";
149 
150     ListSessionEntityTypesPagedResponse pagedListResponse = client.listSessionEntityTypes(parent);
151 
152     List<SessionEntityType> resources = Lists.newArrayList(pagedListResponse.iterateAll());
153 
154     Assert.assertEquals(1, resources.size());
155     Assert.assertEquals(expectedResponse.getSessionEntityTypesList().get(0), resources.get(0));
156 
157     List<String> actualRequests = mockService.getRequestPaths();
158     Assert.assertEquals(1, actualRequests.size());
159 
160     String apiClientHeaderKey =
161         mockService
162             .getRequestHeaders()
163             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
164             .iterator()
165             .next();
166     Assert.assertTrue(
167         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
168             .matcher(apiClientHeaderKey)
169             .matches());
170   }
171 
172   @Test
listSessionEntityTypesExceptionTest2()173   public void listSessionEntityTypesExceptionTest2() throws Exception {
174     ApiException exception =
175         ApiExceptionFactory.createException(
176             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
177     mockService.addException(exception);
178 
179     try {
180       String parent = "projects/project-6494/agent/sessions/session-6494";
181       client.listSessionEntityTypes(parent);
182       Assert.fail("No exception raised");
183     } catch (InvalidArgumentException e) {
184       // Expected exception.
185     }
186   }
187 
188   @Test
getSessionEntityTypeTest()189   public void getSessionEntityTypeTest() throws Exception {
190     SessionEntityType expectedResponse =
191         SessionEntityType.newBuilder()
192             .setName(
193                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
194                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
195                     .toString())
196             .addAllEntities(new ArrayList<EntityType.Entity>())
197             .build();
198     mockService.addResponse(expectedResponse);
199 
200     SessionEntityTypeName name =
201         SessionEntityTypeName.ofProjectSessionEntityTypeName(
202             "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]");
203 
204     SessionEntityType actualResponse = client.getSessionEntityType(name);
205     Assert.assertEquals(expectedResponse, actualResponse);
206 
207     List<String> actualRequests = mockService.getRequestPaths();
208     Assert.assertEquals(1, actualRequests.size());
209 
210     String apiClientHeaderKey =
211         mockService
212             .getRequestHeaders()
213             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
214             .iterator()
215             .next();
216     Assert.assertTrue(
217         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
218             .matcher(apiClientHeaderKey)
219             .matches());
220   }
221 
222   @Test
getSessionEntityTypeExceptionTest()223   public void getSessionEntityTypeExceptionTest() throws Exception {
224     ApiException exception =
225         ApiExceptionFactory.createException(
226             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
227     mockService.addException(exception);
228 
229     try {
230       SessionEntityTypeName name =
231           SessionEntityTypeName.ofProjectSessionEntityTypeName(
232               "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]");
233       client.getSessionEntityType(name);
234       Assert.fail("No exception raised");
235     } catch (InvalidArgumentException e) {
236       // Expected exception.
237     }
238   }
239 
240   @Test
getSessionEntityTypeTest2()241   public void getSessionEntityTypeTest2() throws Exception {
242     SessionEntityType expectedResponse =
243         SessionEntityType.newBuilder()
244             .setName(
245                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
246                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
247                     .toString())
248             .addAllEntities(new ArrayList<EntityType.Entity>())
249             .build();
250     mockService.addResponse(expectedResponse);
251 
252     String name = "projects/project-957/agent/sessions/session-957/entityTypes/entityType-957";
253 
254     SessionEntityType actualResponse = client.getSessionEntityType(name);
255     Assert.assertEquals(expectedResponse, actualResponse);
256 
257     List<String> actualRequests = mockService.getRequestPaths();
258     Assert.assertEquals(1, actualRequests.size());
259 
260     String apiClientHeaderKey =
261         mockService
262             .getRequestHeaders()
263             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
264             .iterator()
265             .next();
266     Assert.assertTrue(
267         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
268             .matcher(apiClientHeaderKey)
269             .matches());
270   }
271 
272   @Test
getSessionEntityTypeExceptionTest2()273   public void getSessionEntityTypeExceptionTest2() throws Exception {
274     ApiException exception =
275         ApiExceptionFactory.createException(
276             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
277     mockService.addException(exception);
278 
279     try {
280       String name = "projects/project-957/agent/sessions/session-957/entityTypes/entityType-957";
281       client.getSessionEntityType(name);
282       Assert.fail("No exception raised");
283     } catch (InvalidArgumentException e) {
284       // Expected exception.
285     }
286   }
287 
288   @Test
createSessionEntityTypeTest()289   public void createSessionEntityTypeTest() throws Exception {
290     SessionEntityType expectedResponse =
291         SessionEntityType.newBuilder()
292             .setName(
293                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
294                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
295                     .toString())
296             .addAllEntities(new ArrayList<EntityType.Entity>())
297             .build();
298     mockService.addResponse(expectedResponse);
299 
300     SessionName parent = SessionName.ofProjectSessionName("[PROJECT]", "[SESSION]");
301     SessionEntityType sessionEntityType = SessionEntityType.newBuilder().build();
302 
303     SessionEntityType actualResponse = client.createSessionEntityType(parent, sessionEntityType);
304     Assert.assertEquals(expectedResponse, actualResponse);
305 
306     List<String> actualRequests = mockService.getRequestPaths();
307     Assert.assertEquals(1, actualRequests.size());
308 
309     String apiClientHeaderKey =
310         mockService
311             .getRequestHeaders()
312             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
313             .iterator()
314             .next();
315     Assert.assertTrue(
316         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
317             .matcher(apiClientHeaderKey)
318             .matches());
319   }
320 
321   @Test
createSessionEntityTypeExceptionTest()322   public void createSessionEntityTypeExceptionTest() throws Exception {
323     ApiException exception =
324         ApiExceptionFactory.createException(
325             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
326     mockService.addException(exception);
327 
328     try {
329       SessionName parent = SessionName.ofProjectSessionName("[PROJECT]", "[SESSION]");
330       SessionEntityType sessionEntityType = SessionEntityType.newBuilder().build();
331       client.createSessionEntityType(parent, sessionEntityType);
332       Assert.fail("No exception raised");
333     } catch (InvalidArgumentException e) {
334       // Expected exception.
335     }
336   }
337 
338   @Test
createSessionEntityTypeTest2()339   public void createSessionEntityTypeTest2() throws Exception {
340     SessionEntityType expectedResponse =
341         SessionEntityType.newBuilder()
342             .setName(
343                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
344                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
345                     .toString())
346             .addAllEntities(new ArrayList<EntityType.Entity>())
347             .build();
348     mockService.addResponse(expectedResponse);
349 
350     String parent = "projects/project-6494/agent/sessions/session-6494";
351     SessionEntityType sessionEntityType = SessionEntityType.newBuilder().build();
352 
353     SessionEntityType actualResponse = client.createSessionEntityType(parent, sessionEntityType);
354     Assert.assertEquals(expectedResponse, actualResponse);
355 
356     List<String> actualRequests = mockService.getRequestPaths();
357     Assert.assertEquals(1, actualRequests.size());
358 
359     String apiClientHeaderKey =
360         mockService
361             .getRequestHeaders()
362             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
363             .iterator()
364             .next();
365     Assert.assertTrue(
366         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
367             .matcher(apiClientHeaderKey)
368             .matches());
369   }
370 
371   @Test
createSessionEntityTypeExceptionTest2()372   public void createSessionEntityTypeExceptionTest2() throws Exception {
373     ApiException exception =
374         ApiExceptionFactory.createException(
375             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
376     mockService.addException(exception);
377 
378     try {
379       String parent = "projects/project-6494/agent/sessions/session-6494";
380       SessionEntityType sessionEntityType = SessionEntityType.newBuilder().build();
381       client.createSessionEntityType(parent, sessionEntityType);
382       Assert.fail("No exception raised");
383     } catch (InvalidArgumentException e) {
384       // Expected exception.
385     }
386   }
387 
388   @Test
updateSessionEntityTypeTest()389   public void updateSessionEntityTypeTest() throws Exception {
390     SessionEntityType expectedResponse =
391         SessionEntityType.newBuilder()
392             .setName(
393                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
394                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
395                     .toString())
396             .addAllEntities(new ArrayList<EntityType.Entity>())
397             .build();
398     mockService.addResponse(expectedResponse);
399 
400     SessionEntityType sessionEntityType =
401         SessionEntityType.newBuilder()
402             .setName(
403                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
404                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
405                     .toString())
406             .addAllEntities(new ArrayList<EntityType.Entity>())
407             .build();
408 
409     SessionEntityType actualResponse = client.updateSessionEntityType(sessionEntityType);
410     Assert.assertEquals(expectedResponse, actualResponse);
411 
412     List<String> actualRequests = mockService.getRequestPaths();
413     Assert.assertEquals(1, actualRequests.size());
414 
415     String apiClientHeaderKey =
416         mockService
417             .getRequestHeaders()
418             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
419             .iterator()
420             .next();
421     Assert.assertTrue(
422         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
423             .matcher(apiClientHeaderKey)
424             .matches());
425   }
426 
427   @Test
updateSessionEntityTypeExceptionTest()428   public void updateSessionEntityTypeExceptionTest() throws Exception {
429     ApiException exception =
430         ApiExceptionFactory.createException(
431             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
432     mockService.addException(exception);
433 
434     try {
435       SessionEntityType sessionEntityType =
436           SessionEntityType.newBuilder()
437               .setName(
438                   SessionEntityTypeName.ofProjectSessionEntityTypeName(
439                           "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
440                       .toString())
441               .addAllEntities(new ArrayList<EntityType.Entity>())
442               .build();
443       client.updateSessionEntityType(sessionEntityType);
444       Assert.fail("No exception raised");
445     } catch (InvalidArgumentException e) {
446       // Expected exception.
447     }
448   }
449 
450   @Test
updateSessionEntityTypeTest2()451   public void updateSessionEntityTypeTest2() throws Exception {
452     SessionEntityType expectedResponse =
453         SessionEntityType.newBuilder()
454             .setName(
455                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
456                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
457                     .toString())
458             .addAllEntities(new ArrayList<EntityType.Entity>())
459             .build();
460     mockService.addResponse(expectedResponse);
461 
462     SessionEntityType sessionEntityType =
463         SessionEntityType.newBuilder()
464             .setName(
465                 SessionEntityTypeName.ofProjectSessionEntityTypeName(
466                         "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
467                     .toString())
468             .addAllEntities(new ArrayList<EntityType.Entity>())
469             .build();
470     FieldMask updateMask = FieldMask.newBuilder().build();
471 
472     SessionEntityType actualResponse =
473         client.updateSessionEntityType(sessionEntityType, updateMask);
474     Assert.assertEquals(expectedResponse, actualResponse);
475 
476     List<String> actualRequests = mockService.getRequestPaths();
477     Assert.assertEquals(1, actualRequests.size());
478 
479     String apiClientHeaderKey =
480         mockService
481             .getRequestHeaders()
482             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
483             .iterator()
484             .next();
485     Assert.assertTrue(
486         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
487             .matcher(apiClientHeaderKey)
488             .matches());
489   }
490 
491   @Test
updateSessionEntityTypeExceptionTest2()492   public void updateSessionEntityTypeExceptionTest2() throws Exception {
493     ApiException exception =
494         ApiExceptionFactory.createException(
495             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
496     mockService.addException(exception);
497 
498     try {
499       SessionEntityType sessionEntityType =
500           SessionEntityType.newBuilder()
501               .setName(
502                   SessionEntityTypeName.ofProjectSessionEntityTypeName(
503                           "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]")
504                       .toString())
505               .addAllEntities(new ArrayList<EntityType.Entity>())
506               .build();
507       FieldMask updateMask = FieldMask.newBuilder().build();
508       client.updateSessionEntityType(sessionEntityType, updateMask);
509       Assert.fail("No exception raised");
510     } catch (InvalidArgumentException e) {
511       // Expected exception.
512     }
513   }
514 
515   @Test
deleteSessionEntityTypeTest()516   public void deleteSessionEntityTypeTest() throws Exception {
517     Empty expectedResponse = Empty.newBuilder().build();
518     mockService.addResponse(expectedResponse);
519 
520     SessionEntityTypeName name =
521         SessionEntityTypeName.ofProjectSessionEntityTypeName(
522             "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]");
523 
524     client.deleteSessionEntityType(name);
525 
526     List<String> actualRequests = mockService.getRequestPaths();
527     Assert.assertEquals(1, actualRequests.size());
528 
529     String apiClientHeaderKey =
530         mockService
531             .getRequestHeaders()
532             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
533             .iterator()
534             .next();
535     Assert.assertTrue(
536         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
537             .matcher(apiClientHeaderKey)
538             .matches());
539   }
540 
541   @Test
deleteSessionEntityTypeExceptionTest()542   public void deleteSessionEntityTypeExceptionTest() throws Exception {
543     ApiException exception =
544         ApiExceptionFactory.createException(
545             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
546     mockService.addException(exception);
547 
548     try {
549       SessionEntityTypeName name =
550           SessionEntityTypeName.ofProjectSessionEntityTypeName(
551               "[PROJECT]", "[SESSION]", "[ENTITY_TYPE]");
552       client.deleteSessionEntityType(name);
553       Assert.fail("No exception raised");
554     } catch (InvalidArgumentException e) {
555       // Expected exception.
556     }
557   }
558 
559   @Test
deleteSessionEntityTypeTest2()560   public void deleteSessionEntityTypeTest2() throws Exception {
561     Empty expectedResponse = Empty.newBuilder().build();
562     mockService.addResponse(expectedResponse);
563 
564     String name = "projects/project-957/agent/sessions/session-957/entityTypes/entityType-957";
565 
566     client.deleteSessionEntityType(name);
567 
568     List<String> actualRequests = mockService.getRequestPaths();
569     Assert.assertEquals(1, actualRequests.size());
570 
571     String apiClientHeaderKey =
572         mockService
573             .getRequestHeaders()
574             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
575             .iterator()
576             .next();
577     Assert.assertTrue(
578         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
579             .matcher(apiClientHeaderKey)
580             .matches());
581   }
582 
583   @Test
deleteSessionEntityTypeExceptionTest2()584   public void deleteSessionEntityTypeExceptionTest2() throws Exception {
585     ApiException exception =
586         ApiExceptionFactory.createException(
587             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
588     mockService.addException(exception);
589 
590     try {
591       String name = "projects/project-957/agent/sessions/session-957/entityTypes/entityType-957";
592       client.deleteSessionEntityType(name);
593       Assert.fail("No exception raised");
594     } catch (InvalidArgumentException e) {
595       // Expected exception.
596     }
597   }
598 
599   @Test
listLocationsTest()600   public void listLocationsTest() throws Exception {
601     Location responsesElement = Location.newBuilder().build();
602     ListLocationsResponse expectedResponse =
603         ListLocationsResponse.newBuilder()
604             .setNextPageToken("")
605             .addAllLocations(Arrays.asList(responsesElement))
606             .build();
607     mockService.addResponse(expectedResponse);
608 
609     ListLocationsRequest request =
610         ListLocationsRequest.newBuilder()
611             .setName("projects/project-3664")
612             .setFilter("filter-1274492040")
613             .setPageSize(883849137)
614             .setPageToken("pageToken873572522")
615             .build();
616 
617     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
618 
619     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
620 
621     Assert.assertEquals(1, resources.size());
622     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
623 
624     List<String> actualRequests = mockService.getRequestPaths();
625     Assert.assertEquals(1, actualRequests.size());
626 
627     String apiClientHeaderKey =
628         mockService
629             .getRequestHeaders()
630             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
631             .iterator()
632             .next();
633     Assert.assertTrue(
634         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
635             .matcher(apiClientHeaderKey)
636             .matches());
637   }
638 
639   @Test
listLocationsExceptionTest()640   public void listLocationsExceptionTest() throws Exception {
641     ApiException exception =
642         ApiExceptionFactory.createException(
643             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
644     mockService.addException(exception);
645 
646     try {
647       ListLocationsRequest request =
648           ListLocationsRequest.newBuilder()
649               .setName("projects/project-3664")
650               .setFilter("filter-1274492040")
651               .setPageSize(883849137)
652               .setPageToken("pageToken873572522")
653               .build();
654       client.listLocations(request);
655       Assert.fail("No exception raised");
656     } catch (InvalidArgumentException e) {
657       // Expected exception.
658     }
659   }
660 
661   @Test
getLocationTest()662   public void getLocationTest() throws Exception {
663     Location expectedResponse =
664         Location.newBuilder()
665             .setName("name3373707")
666             .setLocationId("locationId1541836720")
667             .setDisplayName("displayName1714148973")
668             .putAllLabels(new HashMap<String, String>())
669             .setMetadata(Any.newBuilder().build())
670             .build();
671     mockService.addResponse(expectedResponse);
672 
673     GetLocationRequest request =
674         GetLocationRequest.newBuilder()
675             .setName("projects/project-9062/locations/location-9062")
676             .build();
677 
678     Location actualResponse = client.getLocation(request);
679     Assert.assertEquals(expectedResponse, actualResponse);
680 
681     List<String> actualRequests = mockService.getRequestPaths();
682     Assert.assertEquals(1, actualRequests.size());
683 
684     String apiClientHeaderKey =
685         mockService
686             .getRequestHeaders()
687             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
688             .iterator()
689             .next();
690     Assert.assertTrue(
691         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
692             .matcher(apiClientHeaderKey)
693             .matches());
694   }
695 
696   @Test
getLocationExceptionTest()697   public void getLocationExceptionTest() throws Exception {
698     ApiException exception =
699         ApiExceptionFactory.createException(
700             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
701     mockService.addException(exception);
702 
703     try {
704       GetLocationRequest request =
705           GetLocationRequest.newBuilder()
706               .setName("projects/project-9062/locations/location-9062")
707               .build();
708       client.getLocation(request);
709       Assert.fail("No exception raised");
710     } catch (InvalidArgumentException e) {
711       // Expected exception.
712     }
713   }
714 }
715