• 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.showcase.v1beta1;
18 
19 import static com.google.showcase.v1beta1.MessagingClient.ListBlurbsPagedResponse;
20 import static com.google.showcase.v1beta1.MessagingClient.ListLocationsPagedResponse;
21 import static com.google.showcase.v1beta1.MessagingClient.ListRoomsPagedResponse;
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.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.ByteString;
40 import com.google.protobuf.Empty;
41 import com.google.protobuf.FieldMask;
42 import com.google.protobuf.Timestamp;
43 import com.google.showcase.v1beta1.stub.HttpJsonMessagingStub;
44 import java.io.IOException;
45 import java.util.ArrayList;
46 import java.util.Arrays;
47 import java.util.HashMap;
48 import java.util.List;
49 import java.util.concurrent.ExecutionException;
50 import javax.annotation.Generated;
51 import org.junit.After;
52 import org.junit.AfterClass;
53 import org.junit.Assert;
54 import org.junit.Before;
55 import org.junit.BeforeClass;
56 import org.junit.Test;
57 
58 @Generated("by gapic-generator-java")
59 public class MessagingClientHttpJsonTest {
60   private static MockHttpService mockService;
61   private static MessagingClient client;
62 
63   @BeforeClass
startStaticServer()64   public static void startStaticServer() throws IOException {
65     mockService =
66         new MockHttpService(
67             HttpJsonMessagingStub.getMethodDescriptors(), MessagingSettings.getDefaultEndpoint());
68     MessagingSettings settings =
69         MessagingSettings.newHttpJsonBuilder()
70             .setTransportChannelProvider(
71                 MessagingSettings.defaultHttpJsonTransportProviderBuilder()
72                     .setHttpTransport(mockService)
73                     .build())
74             .setCredentialsProvider(NoCredentialsProvider.create())
75             .build();
76     client = MessagingClient.create(settings);
77   }
78 
79   @AfterClass
stopServer()80   public static void stopServer() {
81     client.close();
82   }
83 
84   @Before
setUp()85   public void setUp() {}
86 
87   @After
tearDown()88   public void tearDown() throws Exception {
89     mockService.reset();
90   }
91 
92   @Test
createRoomTest()93   public void createRoomTest() throws Exception {
94     Room expectedResponse =
95         Room.newBuilder()
96             .setName(RoomName.of("[ROOM]").toString())
97             .setDisplayName("displayName1714148973")
98             .setDescription("description-1724546052")
99             .setCreateTime(Timestamp.newBuilder().build())
100             .setUpdateTime(Timestamp.newBuilder().build())
101             .build();
102     mockService.addResponse(expectedResponse);
103 
104     String displayName = "displayName1714148973";
105     String description = "description-1724546052";
106 
107     Room actualResponse = client.createRoom(displayName, description);
108     Assert.assertEquals(expectedResponse, actualResponse);
109 
110     List<String> actualRequests = mockService.getRequestPaths();
111     Assert.assertEquals(1, actualRequests.size());
112 
113     String apiClientHeaderKey =
114         mockService
115             .getRequestHeaders()
116             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
117             .iterator()
118             .next();
119     Assert.assertTrue(
120         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
121             .matcher(apiClientHeaderKey)
122             .matches());
123   }
124 
125   @Test
createRoomExceptionTest()126   public void createRoomExceptionTest() throws Exception {
127     ApiException exception =
128         ApiExceptionFactory.createException(
129             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
130     mockService.addException(exception);
131 
132     try {
133       String displayName = "displayName1714148973";
134       String description = "description-1724546052";
135       client.createRoom(displayName, description);
136       Assert.fail("No exception raised");
137     } catch (InvalidArgumentException e) {
138       // Expected exception.
139     }
140   }
141 
142   @Test
getRoomTest()143   public void getRoomTest() throws Exception {
144     Room expectedResponse =
145         Room.newBuilder()
146             .setName(RoomName.of("[ROOM]").toString())
147             .setDisplayName("displayName1714148973")
148             .setDescription("description-1724546052")
149             .setCreateTime(Timestamp.newBuilder().build())
150             .setUpdateTime(Timestamp.newBuilder().build())
151             .build();
152     mockService.addResponse(expectedResponse);
153 
154     RoomName name = RoomName.of("[ROOM]");
155 
156     Room actualResponse = client.getRoom(name);
157     Assert.assertEquals(expectedResponse, actualResponse);
158 
159     List<String> actualRequests = mockService.getRequestPaths();
160     Assert.assertEquals(1, actualRequests.size());
161 
162     String apiClientHeaderKey =
163         mockService
164             .getRequestHeaders()
165             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
166             .iterator()
167             .next();
168     Assert.assertTrue(
169         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
170             .matcher(apiClientHeaderKey)
171             .matches());
172   }
173 
174   @Test
getRoomExceptionTest()175   public void getRoomExceptionTest() throws Exception {
176     ApiException exception =
177         ApiExceptionFactory.createException(
178             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
179     mockService.addException(exception);
180 
181     try {
182       RoomName name = RoomName.of("[ROOM]");
183       client.getRoom(name);
184       Assert.fail("No exception raised");
185     } catch (InvalidArgumentException e) {
186       // Expected exception.
187     }
188   }
189 
190   @Test
getRoomTest2()191   public void getRoomTest2() throws Exception {
192     Room expectedResponse =
193         Room.newBuilder()
194             .setName(RoomName.of("[ROOM]").toString())
195             .setDisplayName("displayName1714148973")
196             .setDescription("description-1724546052")
197             .setCreateTime(Timestamp.newBuilder().build())
198             .setUpdateTime(Timestamp.newBuilder().build())
199             .build();
200     mockService.addResponse(expectedResponse);
201 
202     String name = "rooms/room-472";
203 
204     Room actualResponse = client.getRoom(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
getRoomExceptionTest2()223   public void getRoomExceptionTest2() 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       String name = "rooms/room-472";
231       client.getRoom(name);
232       Assert.fail("No exception raised");
233     } catch (InvalidArgumentException e) {
234       // Expected exception.
235     }
236   }
237 
238   @Test
updateRoomTest()239   public void updateRoomTest() throws Exception {
240     Room expectedResponse =
241         Room.newBuilder()
242             .setName(RoomName.of("[ROOM]").toString())
243             .setDisplayName("displayName1714148973")
244             .setDescription("description-1724546052")
245             .setCreateTime(Timestamp.newBuilder().build())
246             .setUpdateTime(Timestamp.newBuilder().build())
247             .build();
248     mockService.addResponse(expectedResponse);
249 
250     UpdateRoomRequest request =
251         UpdateRoomRequest.newBuilder()
252             .setRoom(
253                 Room.newBuilder()
254                     .setName(RoomName.of("[ROOM]").toString())
255                     .setDisplayName("displayName1714148973")
256                     .setDescription("description-1724546052")
257                     .setCreateTime(Timestamp.newBuilder().build())
258                     .setUpdateTime(Timestamp.newBuilder().build())
259                     .build())
260             .setUpdateMask(FieldMask.newBuilder().build())
261             .build();
262 
263     Room actualResponse = client.updateRoom(request);
264     Assert.assertEquals(expectedResponse, actualResponse);
265 
266     List<String> actualRequests = mockService.getRequestPaths();
267     Assert.assertEquals(1, actualRequests.size());
268 
269     String apiClientHeaderKey =
270         mockService
271             .getRequestHeaders()
272             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
273             .iterator()
274             .next();
275     Assert.assertTrue(
276         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
277             .matcher(apiClientHeaderKey)
278             .matches());
279   }
280 
281   @Test
updateRoomExceptionTest()282   public void updateRoomExceptionTest() throws Exception {
283     ApiException exception =
284         ApiExceptionFactory.createException(
285             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
286     mockService.addException(exception);
287 
288     try {
289       UpdateRoomRequest request =
290           UpdateRoomRequest.newBuilder()
291               .setRoom(
292                   Room.newBuilder()
293                       .setName(RoomName.of("[ROOM]").toString())
294                       .setDisplayName("displayName1714148973")
295                       .setDescription("description-1724546052")
296                       .setCreateTime(Timestamp.newBuilder().build())
297                       .setUpdateTime(Timestamp.newBuilder().build())
298                       .build())
299               .setUpdateMask(FieldMask.newBuilder().build())
300               .build();
301       client.updateRoom(request);
302       Assert.fail("No exception raised");
303     } catch (InvalidArgumentException e) {
304       // Expected exception.
305     }
306   }
307 
308   @Test
deleteRoomTest()309   public void deleteRoomTest() throws Exception {
310     Empty expectedResponse = Empty.newBuilder().build();
311     mockService.addResponse(expectedResponse);
312 
313     RoomName name = RoomName.of("[ROOM]");
314 
315     client.deleteRoom(name);
316 
317     List<String> actualRequests = mockService.getRequestPaths();
318     Assert.assertEquals(1, actualRequests.size());
319 
320     String apiClientHeaderKey =
321         mockService
322             .getRequestHeaders()
323             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
324             .iterator()
325             .next();
326     Assert.assertTrue(
327         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
328             .matcher(apiClientHeaderKey)
329             .matches());
330   }
331 
332   @Test
deleteRoomExceptionTest()333   public void deleteRoomExceptionTest() throws Exception {
334     ApiException exception =
335         ApiExceptionFactory.createException(
336             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
337     mockService.addException(exception);
338 
339     try {
340       RoomName name = RoomName.of("[ROOM]");
341       client.deleteRoom(name);
342       Assert.fail("No exception raised");
343     } catch (InvalidArgumentException e) {
344       // Expected exception.
345     }
346   }
347 
348   @Test
deleteRoomTest2()349   public void deleteRoomTest2() throws Exception {
350     Empty expectedResponse = Empty.newBuilder().build();
351     mockService.addResponse(expectedResponse);
352 
353     String name = "rooms/room-472";
354 
355     client.deleteRoom(name);
356 
357     List<String> actualRequests = mockService.getRequestPaths();
358     Assert.assertEquals(1, actualRequests.size());
359 
360     String apiClientHeaderKey =
361         mockService
362             .getRequestHeaders()
363             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
364             .iterator()
365             .next();
366     Assert.assertTrue(
367         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
368             .matcher(apiClientHeaderKey)
369             .matches());
370   }
371 
372   @Test
deleteRoomExceptionTest2()373   public void deleteRoomExceptionTest2() throws Exception {
374     ApiException exception =
375         ApiExceptionFactory.createException(
376             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
377     mockService.addException(exception);
378 
379     try {
380       String name = "rooms/room-472";
381       client.deleteRoom(name);
382       Assert.fail("No exception raised");
383     } catch (InvalidArgumentException e) {
384       // Expected exception.
385     }
386   }
387 
388   @Test
listRoomsTest()389   public void listRoomsTest() throws Exception {
390     Room responsesElement = Room.newBuilder().build();
391     ListRoomsResponse expectedResponse =
392         ListRoomsResponse.newBuilder()
393             .setNextPageToken("")
394             .addAllRooms(Arrays.asList(responsesElement))
395             .build();
396     mockService.addResponse(expectedResponse);
397 
398     ListRoomsRequest request =
399         ListRoomsRequest.newBuilder()
400             .setPageSize(883849137)
401             .setPageToken("pageToken873572522")
402             .build();
403 
404     ListRoomsPagedResponse pagedListResponse = client.listRooms(request);
405 
406     List<Room> resources = Lists.newArrayList(pagedListResponse.iterateAll());
407 
408     Assert.assertEquals(1, resources.size());
409     Assert.assertEquals(expectedResponse.getRoomsList().get(0), resources.get(0));
410 
411     List<String> actualRequests = mockService.getRequestPaths();
412     Assert.assertEquals(1, actualRequests.size());
413 
414     String apiClientHeaderKey =
415         mockService
416             .getRequestHeaders()
417             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
418             .iterator()
419             .next();
420     Assert.assertTrue(
421         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
422             .matcher(apiClientHeaderKey)
423             .matches());
424   }
425 
426   @Test
listRoomsExceptionTest()427   public void listRoomsExceptionTest() throws Exception {
428     ApiException exception =
429         ApiExceptionFactory.createException(
430             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
431     mockService.addException(exception);
432 
433     try {
434       ListRoomsRequest request =
435           ListRoomsRequest.newBuilder()
436               .setPageSize(883849137)
437               .setPageToken("pageToken873572522")
438               .build();
439       client.listRooms(request);
440       Assert.fail("No exception raised");
441     } catch (InvalidArgumentException e) {
442       // Expected exception.
443     }
444   }
445 
446   @Test
createBlurbTest()447   public void createBlurbTest() throws Exception {
448     Blurb expectedResponse =
449         Blurb.newBuilder()
450             .setName(
451                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
452                     .toString())
453             .setUser(UserName.of("[USER]").toString())
454             .setCreateTime(Timestamp.newBuilder().build())
455             .setUpdateTime(Timestamp.newBuilder().build())
456             .build();
457     mockService.addResponse(expectedResponse);
458 
459     ProfileName parent = ProfileName.of("[USER]");
460     UserName user = UserName.of("[USER]");
461     ByteString image = ByteString.EMPTY;
462 
463     Blurb actualResponse = client.createBlurb(parent, user, image);
464     Assert.assertEquals(expectedResponse, actualResponse);
465 
466     List<String> actualRequests = mockService.getRequestPaths();
467     Assert.assertEquals(1, actualRequests.size());
468 
469     String apiClientHeaderKey =
470         mockService
471             .getRequestHeaders()
472             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
473             .iterator()
474             .next();
475     Assert.assertTrue(
476         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
477             .matcher(apiClientHeaderKey)
478             .matches());
479   }
480 
481   @Test
createBlurbExceptionTest()482   public void createBlurbExceptionTest() throws Exception {
483     ApiException exception =
484         ApiExceptionFactory.createException(
485             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
486     mockService.addException(exception);
487 
488     try {
489       ProfileName parent = ProfileName.of("[USER]");
490       UserName user = UserName.of("[USER]");
491       ByteString image = ByteString.EMPTY;
492       client.createBlurb(parent, user, image);
493       Assert.fail("No exception raised");
494     } catch (InvalidArgumentException e) {
495       // Expected exception.
496     }
497   }
498 
499   @Test
createBlurbTest2()500   public void createBlurbTest2() throws Exception {
501     Blurb expectedResponse =
502         Blurb.newBuilder()
503             .setName(
504                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
505                     .toString())
506             .setUser(UserName.of("[USER]").toString())
507             .setCreateTime(Timestamp.newBuilder().build())
508             .setUpdateTime(Timestamp.newBuilder().build())
509             .build();
510     mockService.addResponse(expectedResponse);
511 
512     ProfileName parent = ProfileName.of("[USER]");
513     UserName user = UserName.of("[USER]");
514     String text = "text3556653";
515 
516     Blurb actualResponse = client.createBlurb(parent, user, text);
517     Assert.assertEquals(expectedResponse, actualResponse);
518 
519     List<String> actualRequests = mockService.getRequestPaths();
520     Assert.assertEquals(1, actualRequests.size());
521 
522     String apiClientHeaderKey =
523         mockService
524             .getRequestHeaders()
525             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
526             .iterator()
527             .next();
528     Assert.assertTrue(
529         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
530             .matcher(apiClientHeaderKey)
531             .matches());
532   }
533 
534   @Test
createBlurbExceptionTest2()535   public void createBlurbExceptionTest2() throws Exception {
536     ApiException exception =
537         ApiExceptionFactory.createException(
538             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
539     mockService.addException(exception);
540 
541     try {
542       ProfileName parent = ProfileName.of("[USER]");
543       UserName user = UserName.of("[USER]");
544       String text = "text3556653";
545       client.createBlurb(parent, user, text);
546       Assert.fail("No exception raised");
547     } catch (InvalidArgumentException e) {
548       // Expected exception.
549     }
550   }
551 
552   @Test
createBlurbTest3()553   public void createBlurbTest3() throws Exception {
554     Blurb expectedResponse =
555         Blurb.newBuilder()
556             .setName(
557                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
558                     .toString())
559             .setUser(UserName.of("[USER]").toString())
560             .setCreateTime(Timestamp.newBuilder().build())
561             .setUpdateTime(Timestamp.newBuilder().build())
562             .build();
563     mockService.addResponse(expectedResponse);
564 
565     ProfileName parent = ProfileName.of("[USER]");
566     String user = "user3599307";
567     ByteString image = ByteString.EMPTY;
568 
569     Blurb actualResponse = client.createBlurb(parent, user, image);
570     Assert.assertEquals(expectedResponse, actualResponse);
571 
572     List<String> actualRequests = mockService.getRequestPaths();
573     Assert.assertEquals(1, actualRequests.size());
574 
575     String apiClientHeaderKey =
576         mockService
577             .getRequestHeaders()
578             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
579             .iterator()
580             .next();
581     Assert.assertTrue(
582         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
583             .matcher(apiClientHeaderKey)
584             .matches());
585   }
586 
587   @Test
createBlurbExceptionTest3()588   public void createBlurbExceptionTest3() throws Exception {
589     ApiException exception =
590         ApiExceptionFactory.createException(
591             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
592     mockService.addException(exception);
593 
594     try {
595       ProfileName parent = ProfileName.of("[USER]");
596       String user = "user3599307";
597       ByteString image = ByteString.EMPTY;
598       client.createBlurb(parent, user, image);
599       Assert.fail("No exception raised");
600     } catch (InvalidArgumentException e) {
601       // Expected exception.
602     }
603   }
604 
605   @Test
createBlurbTest4()606   public void createBlurbTest4() throws Exception {
607     Blurb expectedResponse =
608         Blurb.newBuilder()
609             .setName(
610                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
611                     .toString())
612             .setUser(UserName.of("[USER]").toString())
613             .setCreateTime(Timestamp.newBuilder().build())
614             .setUpdateTime(Timestamp.newBuilder().build())
615             .build();
616     mockService.addResponse(expectedResponse);
617 
618     ProfileName parent = ProfileName.of("[USER]");
619     String user = "user3599307";
620     String text = "text3556653";
621 
622     Blurb actualResponse = client.createBlurb(parent, user, text);
623     Assert.assertEquals(expectedResponse, actualResponse);
624 
625     List<String> actualRequests = mockService.getRequestPaths();
626     Assert.assertEquals(1, actualRequests.size());
627 
628     String apiClientHeaderKey =
629         mockService
630             .getRequestHeaders()
631             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
632             .iterator()
633             .next();
634     Assert.assertTrue(
635         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
636             .matcher(apiClientHeaderKey)
637             .matches());
638   }
639 
640   @Test
createBlurbExceptionTest4()641   public void createBlurbExceptionTest4() throws Exception {
642     ApiException exception =
643         ApiExceptionFactory.createException(
644             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
645     mockService.addException(exception);
646 
647     try {
648       ProfileName parent = ProfileName.of("[USER]");
649       String user = "user3599307";
650       String text = "text3556653";
651       client.createBlurb(parent, user, text);
652       Assert.fail("No exception raised");
653     } catch (InvalidArgumentException e) {
654       // Expected exception.
655     }
656   }
657 
658   @Test
createBlurbTest5()659   public void createBlurbTest5() throws Exception {
660     Blurb expectedResponse =
661         Blurb.newBuilder()
662             .setName(
663                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
664                     .toString())
665             .setUser(UserName.of("[USER]").toString())
666             .setCreateTime(Timestamp.newBuilder().build())
667             .setUpdateTime(Timestamp.newBuilder().build())
668             .build();
669     mockService.addResponse(expectedResponse);
670 
671     RoomName parent = RoomName.of("[ROOM]");
672     UserName user = UserName.of("[USER]");
673     ByteString image = ByteString.EMPTY;
674 
675     Blurb actualResponse = client.createBlurb(parent, user, image);
676     Assert.assertEquals(expectedResponse, actualResponse);
677 
678     List<String> actualRequests = mockService.getRequestPaths();
679     Assert.assertEquals(1, actualRequests.size());
680 
681     String apiClientHeaderKey =
682         mockService
683             .getRequestHeaders()
684             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
685             .iterator()
686             .next();
687     Assert.assertTrue(
688         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
689             .matcher(apiClientHeaderKey)
690             .matches());
691   }
692 
693   @Test
createBlurbExceptionTest5()694   public void createBlurbExceptionTest5() throws Exception {
695     ApiException exception =
696         ApiExceptionFactory.createException(
697             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
698     mockService.addException(exception);
699 
700     try {
701       RoomName parent = RoomName.of("[ROOM]");
702       UserName user = UserName.of("[USER]");
703       ByteString image = ByteString.EMPTY;
704       client.createBlurb(parent, user, image);
705       Assert.fail("No exception raised");
706     } catch (InvalidArgumentException e) {
707       // Expected exception.
708     }
709   }
710 
711   @Test
createBlurbTest6()712   public void createBlurbTest6() throws Exception {
713     Blurb expectedResponse =
714         Blurb.newBuilder()
715             .setName(
716                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
717                     .toString())
718             .setUser(UserName.of("[USER]").toString())
719             .setCreateTime(Timestamp.newBuilder().build())
720             .setUpdateTime(Timestamp.newBuilder().build())
721             .build();
722     mockService.addResponse(expectedResponse);
723 
724     RoomName parent = RoomName.of("[ROOM]");
725     UserName user = UserName.of("[USER]");
726     String text = "text3556653";
727 
728     Blurb actualResponse = client.createBlurb(parent, user, text);
729     Assert.assertEquals(expectedResponse, actualResponse);
730 
731     List<String> actualRequests = mockService.getRequestPaths();
732     Assert.assertEquals(1, actualRequests.size());
733 
734     String apiClientHeaderKey =
735         mockService
736             .getRequestHeaders()
737             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
738             .iterator()
739             .next();
740     Assert.assertTrue(
741         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
742             .matcher(apiClientHeaderKey)
743             .matches());
744   }
745 
746   @Test
createBlurbExceptionTest6()747   public void createBlurbExceptionTest6() throws Exception {
748     ApiException exception =
749         ApiExceptionFactory.createException(
750             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
751     mockService.addException(exception);
752 
753     try {
754       RoomName parent = RoomName.of("[ROOM]");
755       UserName user = UserName.of("[USER]");
756       String text = "text3556653";
757       client.createBlurb(parent, user, text);
758       Assert.fail("No exception raised");
759     } catch (InvalidArgumentException e) {
760       // Expected exception.
761     }
762   }
763 
764   @Test
createBlurbTest7()765   public void createBlurbTest7() throws Exception {
766     Blurb expectedResponse =
767         Blurb.newBuilder()
768             .setName(
769                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
770                     .toString())
771             .setUser(UserName.of("[USER]").toString())
772             .setCreateTime(Timestamp.newBuilder().build())
773             .setUpdateTime(Timestamp.newBuilder().build())
774             .build();
775     mockService.addResponse(expectedResponse);
776 
777     RoomName parent = RoomName.of("[ROOM]");
778     String user = "user3599307";
779     ByteString image = ByteString.EMPTY;
780 
781     Blurb actualResponse = client.createBlurb(parent, user, image);
782     Assert.assertEquals(expectedResponse, actualResponse);
783 
784     List<String> actualRequests = mockService.getRequestPaths();
785     Assert.assertEquals(1, actualRequests.size());
786 
787     String apiClientHeaderKey =
788         mockService
789             .getRequestHeaders()
790             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
791             .iterator()
792             .next();
793     Assert.assertTrue(
794         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
795             .matcher(apiClientHeaderKey)
796             .matches());
797   }
798 
799   @Test
createBlurbExceptionTest7()800   public void createBlurbExceptionTest7() throws Exception {
801     ApiException exception =
802         ApiExceptionFactory.createException(
803             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
804     mockService.addException(exception);
805 
806     try {
807       RoomName parent = RoomName.of("[ROOM]");
808       String user = "user3599307";
809       ByteString image = ByteString.EMPTY;
810       client.createBlurb(parent, user, image);
811       Assert.fail("No exception raised");
812     } catch (InvalidArgumentException e) {
813       // Expected exception.
814     }
815   }
816 
817   @Test
createBlurbTest8()818   public void createBlurbTest8() throws Exception {
819     Blurb expectedResponse =
820         Blurb.newBuilder()
821             .setName(
822                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
823                     .toString())
824             .setUser(UserName.of("[USER]").toString())
825             .setCreateTime(Timestamp.newBuilder().build())
826             .setUpdateTime(Timestamp.newBuilder().build())
827             .build();
828     mockService.addResponse(expectedResponse);
829 
830     RoomName parent = RoomName.of("[ROOM]");
831     String user = "user3599307";
832     String text = "text3556653";
833 
834     Blurb actualResponse = client.createBlurb(parent, user, text);
835     Assert.assertEquals(expectedResponse, actualResponse);
836 
837     List<String> actualRequests = mockService.getRequestPaths();
838     Assert.assertEquals(1, actualRequests.size());
839 
840     String apiClientHeaderKey =
841         mockService
842             .getRequestHeaders()
843             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
844             .iterator()
845             .next();
846     Assert.assertTrue(
847         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
848             .matcher(apiClientHeaderKey)
849             .matches());
850   }
851 
852   @Test
createBlurbExceptionTest8()853   public void createBlurbExceptionTest8() throws Exception {
854     ApiException exception =
855         ApiExceptionFactory.createException(
856             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
857     mockService.addException(exception);
858 
859     try {
860       RoomName parent = RoomName.of("[ROOM]");
861       String user = "user3599307";
862       String text = "text3556653";
863       client.createBlurb(parent, user, text);
864       Assert.fail("No exception raised");
865     } catch (InvalidArgumentException e) {
866       // Expected exception.
867     }
868   }
869 
870   @Test
createBlurbTest9()871   public void createBlurbTest9() throws Exception {
872     Blurb expectedResponse =
873         Blurb.newBuilder()
874             .setName(
875                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
876                     .toString())
877             .setUser(UserName.of("[USER]").toString())
878             .setCreateTime(Timestamp.newBuilder().build())
879             .setUpdateTime(Timestamp.newBuilder().build())
880             .build();
881     mockService.addResponse(expectedResponse);
882 
883     String parent = "rooms/room-4889";
884     UserName user = UserName.of("[USER]");
885     ByteString image = ByteString.EMPTY;
886 
887     Blurb actualResponse = client.createBlurb(parent, user, image);
888     Assert.assertEquals(expectedResponse, actualResponse);
889 
890     List<String> actualRequests = mockService.getRequestPaths();
891     Assert.assertEquals(1, actualRequests.size());
892 
893     String apiClientHeaderKey =
894         mockService
895             .getRequestHeaders()
896             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
897             .iterator()
898             .next();
899     Assert.assertTrue(
900         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
901             .matcher(apiClientHeaderKey)
902             .matches());
903   }
904 
905   @Test
createBlurbExceptionTest9()906   public void createBlurbExceptionTest9() throws Exception {
907     ApiException exception =
908         ApiExceptionFactory.createException(
909             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
910     mockService.addException(exception);
911 
912     try {
913       String parent = "rooms/room-4889";
914       UserName user = UserName.of("[USER]");
915       ByteString image = ByteString.EMPTY;
916       client.createBlurb(parent, user, image);
917       Assert.fail("No exception raised");
918     } catch (InvalidArgumentException e) {
919       // Expected exception.
920     }
921   }
922 
923   @Test
createBlurbTest10()924   public void createBlurbTest10() throws Exception {
925     Blurb expectedResponse =
926         Blurb.newBuilder()
927             .setName(
928                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
929                     .toString())
930             .setUser(UserName.of("[USER]").toString())
931             .setCreateTime(Timestamp.newBuilder().build())
932             .setUpdateTime(Timestamp.newBuilder().build())
933             .build();
934     mockService.addResponse(expectedResponse);
935 
936     String parent = "rooms/room-4889";
937     UserName user = UserName.of("[USER]");
938     String text = "text3556653";
939 
940     Blurb actualResponse = client.createBlurb(parent, user, text);
941     Assert.assertEquals(expectedResponse, actualResponse);
942 
943     List<String> actualRequests = mockService.getRequestPaths();
944     Assert.assertEquals(1, actualRequests.size());
945 
946     String apiClientHeaderKey =
947         mockService
948             .getRequestHeaders()
949             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
950             .iterator()
951             .next();
952     Assert.assertTrue(
953         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
954             .matcher(apiClientHeaderKey)
955             .matches());
956   }
957 
958   @Test
createBlurbExceptionTest10()959   public void createBlurbExceptionTest10() throws Exception {
960     ApiException exception =
961         ApiExceptionFactory.createException(
962             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
963     mockService.addException(exception);
964 
965     try {
966       String parent = "rooms/room-4889";
967       UserName user = UserName.of("[USER]");
968       String text = "text3556653";
969       client.createBlurb(parent, user, text);
970       Assert.fail("No exception raised");
971     } catch (InvalidArgumentException e) {
972       // Expected exception.
973     }
974   }
975 
976   @Test
createBlurbTest11()977   public void createBlurbTest11() throws Exception {
978     Blurb expectedResponse =
979         Blurb.newBuilder()
980             .setName(
981                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
982                     .toString())
983             .setUser(UserName.of("[USER]").toString())
984             .setCreateTime(Timestamp.newBuilder().build())
985             .setUpdateTime(Timestamp.newBuilder().build())
986             .build();
987     mockService.addResponse(expectedResponse);
988 
989     String parent = "rooms/room-4889";
990     String user = "user3599307";
991     ByteString image = ByteString.EMPTY;
992 
993     Blurb actualResponse = client.createBlurb(parent, user, image);
994     Assert.assertEquals(expectedResponse, actualResponse);
995 
996     List<String> actualRequests = mockService.getRequestPaths();
997     Assert.assertEquals(1, actualRequests.size());
998 
999     String apiClientHeaderKey =
1000         mockService
1001             .getRequestHeaders()
1002             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1003             .iterator()
1004             .next();
1005     Assert.assertTrue(
1006         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1007             .matcher(apiClientHeaderKey)
1008             .matches());
1009   }
1010 
1011   @Test
createBlurbExceptionTest11()1012   public void createBlurbExceptionTest11() throws Exception {
1013     ApiException exception =
1014         ApiExceptionFactory.createException(
1015             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1016     mockService.addException(exception);
1017 
1018     try {
1019       String parent = "rooms/room-4889";
1020       String user = "user3599307";
1021       ByteString image = ByteString.EMPTY;
1022       client.createBlurb(parent, user, image);
1023       Assert.fail("No exception raised");
1024     } catch (InvalidArgumentException e) {
1025       // Expected exception.
1026     }
1027   }
1028 
1029   @Test
createBlurbTest12()1030   public void createBlurbTest12() throws Exception {
1031     Blurb expectedResponse =
1032         Blurb.newBuilder()
1033             .setName(
1034                 BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
1035                     .toString())
1036             .setUser(UserName.of("[USER]").toString())
1037             .setCreateTime(Timestamp.newBuilder().build())
1038             .setUpdateTime(Timestamp.newBuilder().build())
1039             .build();
1040     mockService.addResponse(expectedResponse);
1041 
1042     String parent = "rooms/room-4889";
1043     String user = "user3599307";
1044     String text = "text3556653";
1045 
1046     Blurb actualResponse = client.createBlurb(parent, user, text);
1047     Assert.assertEquals(expectedResponse, actualResponse);
1048 
1049     List<String> actualRequests = mockService.getRequestPaths();
1050     Assert.assertEquals(1, actualRequests.size());
1051 
1052     String apiClientHeaderKey =
1053         mockService
1054             .getRequestHeaders()
1055             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1056             .iterator()
1057             .next();
1058     Assert.assertTrue(
1059         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1060             .matcher(apiClientHeaderKey)
1061             .matches());
1062   }
1063 
1064   @Test
createBlurbExceptionTest12()1065   public void createBlurbExceptionTest12() throws Exception {
1066     ApiException exception =
1067         ApiExceptionFactory.createException(
1068             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1069     mockService.addException(exception);
1070 
1071     try {
1072       String parent = "rooms/room-4889";
1073       String user = "user3599307";
1074       String text = "text3556653";
1075       client.createBlurb(parent, user, text);
1076       Assert.fail("No exception raised");
1077     } catch (InvalidArgumentException e) {
1078       // Expected exception.
1079     }
1080   }
1081 
1082   @Test
getBlurbTest()1083   public void getBlurbTest() throws Exception {
1084     Blurb expectedResponse =
1085         Blurb.newBuilder()
1086             .setName(BlurbName.ofRoomBlurbName("[ROOM]", "[BLURB]").toString())
1087             .setUser(UserName.of("[USER]").toString())
1088             .setCreateTime(Timestamp.newBuilder().build())
1089             .setUpdateTime(Timestamp.newBuilder().build())
1090             .build();
1091     mockService.addResponse(expectedResponse);
1092 
1093     BlurbName name = BlurbName.ofRoomBlurbName("[ROOM]", "[BLURB]");
1094 
1095     Blurb actualResponse = client.getBlurb(name);
1096     Assert.assertEquals(expectedResponse, actualResponse);
1097 
1098     List<String> actualRequests = mockService.getRequestPaths();
1099     Assert.assertEquals(1, actualRequests.size());
1100 
1101     String apiClientHeaderKey =
1102         mockService
1103             .getRequestHeaders()
1104             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1105             .iterator()
1106             .next();
1107     Assert.assertTrue(
1108         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1109             .matcher(apiClientHeaderKey)
1110             .matches());
1111   }
1112 
1113   @Test
getBlurbExceptionTest()1114   public void getBlurbExceptionTest() throws Exception {
1115     ApiException exception =
1116         ApiExceptionFactory.createException(
1117             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1118     mockService.addException(exception);
1119 
1120     try {
1121       BlurbName name = BlurbName.ofRoomBlurbName("[ROOM]", "[BLURB]");
1122       client.getBlurb(name);
1123       Assert.fail("No exception raised");
1124     } catch (InvalidArgumentException e) {
1125       // Expected exception.
1126     }
1127   }
1128 
1129   @Test
getBlurbTest2()1130   public void getBlurbTest2() throws Exception {
1131     Blurb expectedResponse =
1132         Blurb.newBuilder()
1133             .setName(BlurbName.ofRoomBlurbName("[ROOM]", "[BLURB]").toString())
1134             .setUser(UserName.of("[USER]").toString())
1135             .setCreateTime(Timestamp.newBuilder().build())
1136             .setUpdateTime(Timestamp.newBuilder().build())
1137             .build();
1138     mockService.addResponse(expectedResponse);
1139 
1140     String name = "rooms/room-9094/blurbs/blurb-9094";
1141 
1142     Blurb actualResponse = client.getBlurb(name);
1143     Assert.assertEquals(expectedResponse, actualResponse);
1144 
1145     List<String> actualRequests = mockService.getRequestPaths();
1146     Assert.assertEquals(1, actualRequests.size());
1147 
1148     String apiClientHeaderKey =
1149         mockService
1150             .getRequestHeaders()
1151             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1152             .iterator()
1153             .next();
1154     Assert.assertTrue(
1155         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1156             .matcher(apiClientHeaderKey)
1157             .matches());
1158   }
1159 
1160   @Test
getBlurbExceptionTest2()1161   public void getBlurbExceptionTest2() throws Exception {
1162     ApiException exception =
1163         ApiExceptionFactory.createException(
1164             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1165     mockService.addException(exception);
1166 
1167     try {
1168       String name = "rooms/room-9094/blurbs/blurb-9094";
1169       client.getBlurb(name);
1170       Assert.fail("No exception raised");
1171     } catch (InvalidArgumentException e) {
1172       // Expected exception.
1173     }
1174   }
1175 
1176   @Test
updateBlurbTest()1177   public void updateBlurbTest() throws Exception {
1178     Blurb expectedResponse =
1179         Blurb.newBuilder()
1180             .setName(BlurbName.ofRoomBlurbName("[ROOM]", "[BLURB]").toString())
1181             .setUser(UserName.of("[USER]").toString())
1182             .setCreateTime(Timestamp.newBuilder().build())
1183             .setUpdateTime(Timestamp.newBuilder().build())
1184             .build();
1185     mockService.addResponse(expectedResponse);
1186 
1187     UpdateBlurbRequest request =
1188         UpdateBlurbRequest.newBuilder()
1189             .setBlurb(
1190                 Blurb.newBuilder()
1191                     .setName(
1192                         BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
1193                             .toString())
1194                     .setUser(UserName.of("[USER]").toString())
1195                     .setCreateTime(Timestamp.newBuilder().build())
1196                     .setUpdateTime(Timestamp.newBuilder().build())
1197                     .build())
1198             .setUpdateMask(FieldMask.newBuilder().build())
1199             .build();
1200 
1201     Blurb actualResponse = client.updateBlurb(request);
1202     Assert.assertEquals(expectedResponse, actualResponse);
1203 
1204     List<String> actualRequests = mockService.getRequestPaths();
1205     Assert.assertEquals(1, actualRequests.size());
1206 
1207     String apiClientHeaderKey =
1208         mockService
1209             .getRequestHeaders()
1210             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1211             .iterator()
1212             .next();
1213     Assert.assertTrue(
1214         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1215             .matcher(apiClientHeaderKey)
1216             .matches());
1217   }
1218 
1219   @Test
updateBlurbExceptionTest()1220   public void updateBlurbExceptionTest() throws Exception {
1221     ApiException exception =
1222         ApiExceptionFactory.createException(
1223             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1224     mockService.addException(exception);
1225 
1226     try {
1227       UpdateBlurbRequest request =
1228           UpdateBlurbRequest.newBuilder()
1229               .setBlurb(
1230                   Blurb.newBuilder()
1231                       .setName(
1232                           BlurbName.ofUserLegacyUserBlurbName("[USER]", "[LEGACY_USER]", "[BLURB]")
1233                               .toString())
1234                       .setUser(UserName.of("[USER]").toString())
1235                       .setCreateTime(Timestamp.newBuilder().build())
1236                       .setUpdateTime(Timestamp.newBuilder().build())
1237                       .build())
1238               .setUpdateMask(FieldMask.newBuilder().build())
1239               .build();
1240       client.updateBlurb(request);
1241       Assert.fail("No exception raised");
1242     } catch (InvalidArgumentException e) {
1243       // Expected exception.
1244     }
1245   }
1246 
1247   @Test
deleteBlurbTest()1248   public void deleteBlurbTest() throws Exception {
1249     Empty expectedResponse = Empty.newBuilder().build();
1250     mockService.addResponse(expectedResponse);
1251 
1252     BlurbName name = BlurbName.ofRoomBlurbName("[ROOM]", "[BLURB]");
1253 
1254     client.deleteBlurb(name);
1255 
1256     List<String> actualRequests = mockService.getRequestPaths();
1257     Assert.assertEquals(1, actualRequests.size());
1258 
1259     String apiClientHeaderKey =
1260         mockService
1261             .getRequestHeaders()
1262             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1263             .iterator()
1264             .next();
1265     Assert.assertTrue(
1266         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1267             .matcher(apiClientHeaderKey)
1268             .matches());
1269   }
1270 
1271   @Test
deleteBlurbExceptionTest()1272   public void deleteBlurbExceptionTest() throws Exception {
1273     ApiException exception =
1274         ApiExceptionFactory.createException(
1275             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1276     mockService.addException(exception);
1277 
1278     try {
1279       BlurbName name = BlurbName.ofRoomBlurbName("[ROOM]", "[BLURB]");
1280       client.deleteBlurb(name);
1281       Assert.fail("No exception raised");
1282     } catch (InvalidArgumentException e) {
1283       // Expected exception.
1284     }
1285   }
1286 
1287   @Test
deleteBlurbTest2()1288   public void deleteBlurbTest2() throws Exception {
1289     Empty expectedResponse = Empty.newBuilder().build();
1290     mockService.addResponse(expectedResponse);
1291 
1292     String name = "rooms/room-9094/blurbs/blurb-9094";
1293 
1294     client.deleteBlurb(name);
1295 
1296     List<String> actualRequests = mockService.getRequestPaths();
1297     Assert.assertEquals(1, actualRequests.size());
1298 
1299     String apiClientHeaderKey =
1300         mockService
1301             .getRequestHeaders()
1302             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1303             .iterator()
1304             .next();
1305     Assert.assertTrue(
1306         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1307             .matcher(apiClientHeaderKey)
1308             .matches());
1309   }
1310 
1311   @Test
deleteBlurbExceptionTest2()1312   public void deleteBlurbExceptionTest2() throws Exception {
1313     ApiException exception =
1314         ApiExceptionFactory.createException(
1315             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1316     mockService.addException(exception);
1317 
1318     try {
1319       String name = "rooms/room-9094/blurbs/blurb-9094";
1320       client.deleteBlurb(name);
1321       Assert.fail("No exception raised");
1322     } catch (InvalidArgumentException e) {
1323       // Expected exception.
1324     }
1325   }
1326 
1327   @Test
listBlurbsTest()1328   public void listBlurbsTest() throws Exception {
1329     Blurb responsesElement = Blurb.newBuilder().build();
1330     ListBlurbsResponse expectedResponse =
1331         ListBlurbsResponse.newBuilder()
1332             .setNextPageToken("")
1333             .addAllBlurbs(Arrays.asList(responsesElement))
1334             .build();
1335     mockService.addResponse(expectedResponse);
1336 
1337     ProfileName parent = ProfileName.of("[USER]");
1338 
1339     ListBlurbsPagedResponse pagedListResponse = client.listBlurbs(parent);
1340 
1341     List<Blurb> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1342 
1343     Assert.assertEquals(1, resources.size());
1344     Assert.assertEquals(expectedResponse.getBlurbsList().get(0), resources.get(0));
1345 
1346     List<String> actualRequests = mockService.getRequestPaths();
1347     Assert.assertEquals(1, actualRequests.size());
1348 
1349     String apiClientHeaderKey =
1350         mockService
1351             .getRequestHeaders()
1352             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1353             .iterator()
1354             .next();
1355     Assert.assertTrue(
1356         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1357             .matcher(apiClientHeaderKey)
1358             .matches());
1359   }
1360 
1361   @Test
listBlurbsExceptionTest()1362   public void listBlurbsExceptionTest() throws Exception {
1363     ApiException exception =
1364         ApiExceptionFactory.createException(
1365             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1366     mockService.addException(exception);
1367 
1368     try {
1369       ProfileName parent = ProfileName.of("[USER]");
1370       client.listBlurbs(parent);
1371       Assert.fail("No exception raised");
1372     } catch (InvalidArgumentException e) {
1373       // Expected exception.
1374     }
1375   }
1376 
1377   @Test
listBlurbsTest2()1378   public void listBlurbsTest2() throws Exception {
1379     Blurb responsesElement = Blurb.newBuilder().build();
1380     ListBlurbsResponse expectedResponse =
1381         ListBlurbsResponse.newBuilder()
1382             .setNextPageToken("")
1383             .addAllBlurbs(Arrays.asList(responsesElement))
1384             .build();
1385     mockService.addResponse(expectedResponse);
1386 
1387     RoomName parent = RoomName.of("[ROOM]");
1388 
1389     ListBlurbsPagedResponse pagedListResponse = client.listBlurbs(parent);
1390 
1391     List<Blurb> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1392 
1393     Assert.assertEquals(1, resources.size());
1394     Assert.assertEquals(expectedResponse.getBlurbsList().get(0), resources.get(0));
1395 
1396     List<String> actualRequests = mockService.getRequestPaths();
1397     Assert.assertEquals(1, actualRequests.size());
1398 
1399     String apiClientHeaderKey =
1400         mockService
1401             .getRequestHeaders()
1402             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1403             .iterator()
1404             .next();
1405     Assert.assertTrue(
1406         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1407             .matcher(apiClientHeaderKey)
1408             .matches());
1409   }
1410 
1411   @Test
listBlurbsExceptionTest2()1412   public void listBlurbsExceptionTest2() throws Exception {
1413     ApiException exception =
1414         ApiExceptionFactory.createException(
1415             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1416     mockService.addException(exception);
1417 
1418     try {
1419       RoomName parent = RoomName.of("[ROOM]");
1420       client.listBlurbs(parent);
1421       Assert.fail("No exception raised");
1422     } catch (InvalidArgumentException e) {
1423       // Expected exception.
1424     }
1425   }
1426 
1427   @Test
listBlurbsTest3()1428   public void listBlurbsTest3() throws Exception {
1429     Blurb responsesElement = Blurb.newBuilder().build();
1430     ListBlurbsResponse expectedResponse =
1431         ListBlurbsResponse.newBuilder()
1432             .setNextPageToken("")
1433             .addAllBlurbs(Arrays.asList(responsesElement))
1434             .build();
1435     mockService.addResponse(expectedResponse);
1436 
1437     String parent = "rooms/room-4889";
1438 
1439     ListBlurbsPagedResponse pagedListResponse = client.listBlurbs(parent);
1440 
1441     List<Blurb> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1442 
1443     Assert.assertEquals(1, resources.size());
1444     Assert.assertEquals(expectedResponse.getBlurbsList().get(0), resources.get(0));
1445 
1446     List<String> actualRequests = mockService.getRequestPaths();
1447     Assert.assertEquals(1, actualRequests.size());
1448 
1449     String apiClientHeaderKey =
1450         mockService
1451             .getRequestHeaders()
1452             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1453             .iterator()
1454             .next();
1455     Assert.assertTrue(
1456         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1457             .matcher(apiClientHeaderKey)
1458             .matches());
1459   }
1460 
1461   @Test
listBlurbsExceptionTest3()1462   public void listBlurbsExceptionTest3() throws Exception {
1463     ApiException exception =
1464         ApiExceptionFactory.createException(
1465             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1466     mockService.addException(exception);
1467 
1468     try {
1469       String parent = "rooms/room-4889";
1470       client.listBlurbs(parent);
1471       Assert.fail("No exception raised");
1472     } catch (InvalidArgumentException e) {
1473       // Expected exception.
1474     }
1475   }
1476 
1477   @Test
searchBlurbsTest()1478   public void searchBlurbsTest() throws Exception {
1479     SearchBlurbsResponse expectedResponse =
1480         SearchBlurbsResponse.newBuilder()
1481             .addAllBlurbs(new ArrayList<Blurb>())
1482             .setNextPageToken("nextPageToken-1386094857")
1483             .build();
1484     Operation resultOperation =
1485         Operation.newBuilder()
1486             .setName("searchBlurbsTest")
1487             .setDone(true)
1488             .setResponse(Any.pack(expectedResponse))
1489             .build();
1490     mockService.addResponse(resultOperation);
1491 
1492     ProfileName parent = ProfileName.of("[USER]");
1493     String query = "query107944136";
1494 
1495     SearchBlurbsResponse actualResponse = client.searchBlurbsAsync(parent, query).get();
1496     Assert.assertEquals(expectedResponse, actualResponse);
1497 
1498     List<String> actualRequests = mockService.getRequestPaths();
1499     Assert.assertEquals(1, actualRequests.size());
1500 
1501     String apiClientHeaderKey =
1502         mockService
1503             .getRequestHeaders()
1504             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1505             .iterator()
1506             .next();
1507     Assert.assertTrue(
1508         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1509             .matcher(apiClientHeaderKey)
1510             .matches());
1511   }
1512 
1513   @Test
searchBlurbsExceptionTest()1514   public void searchBlurbsExceptionTest() throws Exception {
1515     ApiException exception =
1516         ApiExceptionFactory.createException(
1517             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1518     mockService.addException(exception);
1519 
1520     try {
1521       ProfileName parent = ProfileName.of("[USER]");
1522       String query = "query107944136";
1523       client.searchBlurbsAsync(parent, query).get();
1524       Assert.fail("No exception raised");
1525     } catch (ExecutionException e) {
1526     }
1527   }
1528 
1529   @Test
searchBlurbsTest2()1530   public void searchBlurbsTest2() throws Exception {
1531     SearchBlurbsResponse expectedResponse =
1532         SearchBlurbsResponse.newBuilder()
1533             .addAllBlurbs(new ArrayList<Blurb>())
1534             .setNextPageToken("nextPageToken-1386094857")
1535             .build();
1536     Operation resultOperation =
1537         Operation.newBuilder()
1538             .setName("searchBlurbsTest")
1539             .setDone(true)
1540             .setResponse(Any.pack(expectedResponse))
1541             .build();
1542     mockService.addResponse(resultOperation);
1543 
1544     RoomName parent = RoomName.of("[ROOM]");
1545     String query = "query107944136";
1546 
1547     SearchBlurbsResponse actualResponse = client.searchBlurbsAsync(parent, query).get();
1548     Assert.assertEquals(expectedResponse, actualResponse);
1549 
1550     List<String> actualRequests = mockService.getRequestPaths();
1551     Assert.assertEquals(1, actualRequests.size());
1552 
1553     String apiClientHeaderKey =
1554         mockService
1555             .getRequestHeaders()
1556             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1557             .iterator()
1558             .next();
1559     Assert.assertTrue(
1560         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1561             .matcher(apiClientHeaderKey)
1562             .matches());
1563   }
1564 
1565   @Test
searchBlurbsExceptionTest2()1566   public void searchBlurbsExceptionTest2() throws Exception {
1567     ApiException exception =
1568         ApiExceptionFactory.createException(
1569             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1570     mockService.addException(exception);
1571 
1572     try {
1573       RoomName parent = RoomName.of("[ROOM]");
1574       String query = "query107944136";
1575       client.searchBlurbsAsync(parent, query).get();
1576       Assert.fail("No exception raised");
1577     } catch (ExecutionException e) {
1578     }
1579   }
1580 
1581   @Test
searchBlurbsTest3()1582   public void searchBlurbsTest3() throws Exception {
1583     SearchBlurbsResponse expectedResponse =
1584         SearchBlurbsResponse.newBuilder()
1585             .addAllBlurbs(new ArrayList<Blurb>())
1586             .setNextPageToken("nextPageToken-1386094857")
1587             .build();
1588     Operation resultOperation =
1589         Operation.newBuilder()
1590             .setName("searchBlurbsTest")
1591             .setDone(true)
1592             .setResponse(Any.pack(expectedResponse))
1593             .build();
1594     mockService.addResponse(resultOperation);
1595 
1596     String parent = "rooms/room-4889";
1597     String query = "query107944136";
1598 
1599     SearchBlurbsResponse actualResponse = client.searchBlurbsAsync(parent, query).get();
1600     Assert.assertEquals(expectedResponse, actualResponse);
1601 
1602     List<String> actualRequests = mockService.getRequestPaths();
1603     Assert.assertEquals(1, actualRequests.size());
1604 
1605     String apiClientHeaderKey =
1606         mockService
1607             .getRequestHeaders()
1608             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1609             .iterator()
1610             .next();
1611     Assert.assertTrue(
1612         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1613             .matcher(apiClientHeaderKey)
1614             .matches());
1615   }
1616 
1617   @Test
searchBlurbsExceptionTest3()1618   public void searchBlurbsExceptionTest3() throws Exception {
1619     ApiException exception =
1620         ApiExceptionFactory.createException(
1621             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1622     mockService.addException(exception);
1623 
1624     try {
1625       String parent = "rooms/room-4889";
1626       String query = "query107944136";
1627       client.searchBlurbsAsync(parent, query).get();
1628       Assert.fail("No exception raised");
1629     } catch (ExecutionException e) {
1630     }
1631   }
1632 
1633   @Test
streamBlurbsTest()1634   public void streamBlurbsTest() throws Exception {}
1635 
1636   @Test
streamBlurbsExceptionTest()1637   public void streamBlurbsExceptionTest() throws Exception {
1638     ApiException exception =
1639         ApiExceptionFactory.createException(
1640             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1641     mockService.addException(exception);
1642   }
1643 
1644   @Test
sendBlurbsUnsupportedMethodTest()1645   public void sendBlurbsUnsupportedMethodTest() throws Exception {
1646     // The sendBlurbs() method is not supported in REST transport.
1647     // This empty test is generated for technical reasons.
1648   }
1649 
1650   @Test
connectUnsupportedMethodTest()1651   public void connectUnsupportedMethodTest() throws Exception {
1652     // The connect() method is not supported in REST transport.
1653     // This empty test is generated for technical reasons.
1654   }
1655 
1656   @Test
listLocationsTest()1657   public void listLocationsTest() throws Exception {
1658     Location responsesElement = Location.newBuilder().build();
1659     ListLocationsResponse expectedResponse =
1660         ListLocationsResponse.newBuilder()
1661             .setNextPageToken("")
1662             .addAllLocations(Arrays.asList(responsesElement))
1663             .build();
1664     mockService.addResponse(expectedResponse);
1665 
1666     ListLocationsRequest request =
1667         ListLocationsRequest.newBuilder()
1668             .setName("projects/project-3664")
1669             .setFilter("filter-1274492040")
1670             .setPageSize(883849137)
1671             .setPageToken("pageToken873572522")
1672             .build();
1673 
1674     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1675 
1676     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1677 
1678     Assert.assertEquals(1, resources.size());
1679     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1680 
1681     List<String> actualRequests = mockService.getRequestPaths();
1682     Assert.assertEquals(1, actualRequests.size());
1683 
1684     String apiClientHeaderKey =
1685         mockService
1686             .getRequestHeaders()
1687             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1688             .iterator()
1689             .next();
1690     Assert.assertTrue(
1691         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1692             .matcher(apiClientHeaderKey)
1693             .matches());
1694   }
1695 
1696   @Test
listLocationsExceptionTest()1697   public void listLocationsExceptionTest() throws Exception {
1698     ApiException exception =
1699         ApiExceptionFactory.createException(
1700             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1701     mockService.addException(exception);
1702 
1703     try {
1704       ListLocationsRequest request =
1705           ListLocationsRequest.newBuilder()
1706               .setName("projects/project-3664")
1707               .setFilter("filter-1274492040")
1708               .setPageSize(883849137)
1709               .setPageToken("pageToken873572522")
1710               .build();
1711       client.listLocations(request);
1712       Assert.fail("No exception raised");
1713     } catch (InvalidArgumentException e) {
1714       // Expected exception.
1715     }
1716   }
1717 
1718   @Test
getLocationTest()1719   public void getLocationTest() throws Exception {
1720     Location expectedResponse =
1721         Location.newBuilder()
1722             .setName("name3373707")
1723             .setLocationId("locationId1541836720")
1724             .setDisplayName("displayName1714148973")
1725             .putAllLabels(new HashMap<String, String>())
1726             .setMetadata(Any.newBuilder().build())
1727             .build();
1728     mockService.addResponse(expectedResponse);
1729 
1730     GetLocationRequest request =
1731         GetLocationRequest.newBuilder()
1732             .setName("projects/project-9062/locations/location-9062")
1733             .build();
1734 
1735     Location actualResponse = client.getLocation(request);
1736     Assert.assertEquals(expectedResponse, actualResponse);
1737 
1738     List<String> actualRequests = mockService.getRequestPaths();
1739     Assert.assertEquals(1, actualRequests.size());
1740 
1741     String apiClientHeaderKey =
1742         mockService
1743             .getRequestHeaders()
1744             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1745             .iterator()
1746             .next();
1747     Assert.assertTrue(
1748         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1749             .matcher(apiClientHeaderKey)
1750             .matches());
1751   }
1752 
1753   @Test
getLocationExceptionTest()1754   public void getLocationExceptionTest() throws Exception {
1755     ApiException exception =
1756         ApiExceptionFactory.createException(
1757             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1758     mockService.addException(exception);
1759 
1760     try {
1761       GetLocationRequest request =
1762           GetLocationRequest.newBuilder()
1763               .setName("projects/project-9062/locations/location-9062")
1764               .build();
1765       client.getLocation(request);
1766       Assert.fail("No exception raised");
1767     } catch (InvalidArgumentException e) {
1768       // Expected exception.
1769     }
1770   }
1771 }
1772