• 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.example.library.v1;
18 
19 import static com.google.cloud.example.library.v1.LibraryServiceClient.ListBooksPagedResponse;
20 import static com.google.cloud.example.library.v1.LibraryServiceClient.ListShelvesPagedResponse;
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.example.library.v1.stub.HttpJsonLibraryServiceStub;
32 import com.google.common.collect.Lists;
33 import com.google.example.library.v1.Book;
34 import com.google.example.library.v1.BookName;
35 import com.google.example.library.v1.ListBooksResponse;
36 import com.google.example.library.v1.ListShelvesRequest;
37 import com.google.example.library.v1.ListShelvesResponse;
38 import com.google.example.library.v1.Shelf;
39 import com.google.example.library.v1.ShelfName;
40 import com.google.protobuf.Empty;
41 import com.google.protobuf.FieldMask;
42 import java.io.IOException;
43 import java.util.Arrays;
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 LibraryServiceClientHttpJsonTest {
55   private static MockHttpService mockService;
56   private static LibraryServiceClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() throws IOException {
60     mockService =
61         new MockHttpService(
62             HttpJsonLibraryServiceStub.getMethodDescriptors(),
63             LibraryServiceSettings.getDefaultEndpoint());
64     LibraryServiceSettings settings =
65         LibraryServiceSettings.newHttpJsonBuilder()
66             .setTransportChannelProvider(
67                 LibraryServiceSettings.defaultHttpJsonTransportProviderBuilder()
68                     .setHttpTransport(mockService)
69                     .build())
70             .setCredentialsProvider(NoCredentialsProvider.create())
71             .build();
72     client = LibraryServiceClient.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
createShelfTest()89   public void createShelfTest() throws Exception {
90     Shelf expectedResponse =
91         Shelf.newBuilder()
92             .setName(ShelfName.of("[SHELF_ID]").toString())
93             .setTheme("theme110327241")
94             .build();
95     mockService.addResponse(expectedResponse);
96 
97     Shelf shelf = Shelf.newBuilder().build();
98 
99     Shelf actualResponse = client.createShelf(shelf);
100     Assert.assertEquals(expectedResponse, actualResponse);
101 
102     List<String> actualRequests = mockService.getRequestPaths();
103     Assert.assertEquals(1, actualRequests.size());
104 
105     String apiClientHeaderKey =
106         mockService
107             .getRequestHeaders()
108             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
109             .iterator()
110             .next();
111     Assert.assertTrue(
112         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
113             .matcher(apiClientHeaderKey)
114             .matches());
115   }
116 
117   @Test
createShelfExceptionTest()118   public void createShelfExceptionTest() throws Exception {
119     ApiException exception =
120         ApiExceptionFactory.createException(
121             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
122     mockService.addException(exception);
123 
124     try {
125       Shelf shelf = Shelf.newBuilder().build();
126       client.createShelf(shelf);
127       Assert.fail("No exception raised");
128     } catch (InvalidArgumentException e) {
129       // Expected exception.
130     }
131   }
132 
133   @Test
getShelfTest()134   public void getShelfTest() throws Exception {
135     Shelf expectedResponse =
136         Shelf.newBuilder()
137             .setName(ShelfName.of("[SHELF_ID]").toString())
138             .setTheme("theme110327241")
139             .build();
140     mockService.addResponse(expectedResponse);
141 
142     ShelfName name = ShelfName.of("[SHELF_ID]");
143 
144     Shelf actualResponse = client.getShelf(name);
145     Assert.assertEquals(expectedResponse, actualResponse);
146 
147     List<String> actualRequests = mockService.getRequestPaths();
148     Assert.assertEquals(1, actualRequests.size());
149 
150     String apiClientHeaderKey =
151         mockService
152             .getRequestHeaders()
153             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
154             .iterator()
155             .next();
156     Assert.assertTrue(
157         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
158             .matcher(apiClientHeaderKey)
159             .matches());
160   }
161 
162   @Test
getShelfExceptionTest()163   public void getShelfExceptionTest() throws Exception {
164     ApiException exception =
165         ApiExceptionFactory.createException(
166             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
167     mockService.addException(exception);
168 
169     try {
170       ShelfName name = ShelfName.of("[SHELF_ID]");
171       client.getShelf(name);
172       Assert.fail("No exception raised");
173     } catch (InvalidArgumentException e) {
174       // Expected exception.
175     }
176   }
177 
178   @Test
getShelfTest2()179   public void getShelfTest2() throws Exception {
180     Shelf expectedResponse =
181         Shelf.newBuilder()
182             .setName(ShelfName.of("[SHELF_ID]").toString())
183             .setTheme("theme110327241")
184             .build();
185     mockService.addResponse(expectedResponse);
186 
187     String name = "shelves/shelve-6552";
188 
189     Shelf actualResponse = client.getShelf(name);
190     Assert.assertEquals(expectedResponse, actualResponse);
191 
192     List<String> actualRequests = mockService.getRequestPaths();
193     Assert.assertEquals(1, actualRequests.size());
194 
195     String apiClientHeaderKey =
196         mockService
197             .getRequestHeaders()
198             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
199             .iterator()
200             .next();
201     Assert.assertTrue(
202         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
203             .matcher(apiClientHeaderKey)
204             .matches());
205   }
206 
207   @Test
getShelfExceptionTest2()208   public void getShelfExceptionTest2() throws Exception {
209     ApiException exception =
210         ApiExceptionFactory.createException(
211             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
212     mockService.addException(exception);
213 
214     try {
215       String name = "shelves/shelve-6552";
216       client.getShelf(name);
217       Assert.fail("No exception raised");
218     } catch (InvalidArgumentException e) {
219       // Expected exception.
220     }
221   }
222 
223   @Test
listShelvesTest()224   public void listShelvesTest() throws Exception {
225     Shelf responsesElement = Shelf.newBuilder().build();
226     ListShelvesResponse expectedResponse =
227         ListShelvesResponse.newBuilder()
228             .setNextPageToken("")
229             .addAllShelves(Arrays.asList(responsesElement))
230             .build();
231     mockService.addResponse(expectedResponse);
232 
233     ListShelvesRequest request =
234         ListShelvesRequest.newBuilder()
235             .setPageSize(883849137)
236             .setPageToken("pageToken873572522")
237             .build();
238 
239     ListShelvesPagedResponse pagedListResponse = client.listShelves(request);
240 
241     List<Shelf> resources = Lists.newArrayList(pagedListResponse.iterateAll());
242 
243     Assert.assertEquals(1, resources.size());
244     Assert.assertEquals(expectedResponse.getShelvesList().get(0), resources.get(0));
245 
246     List<String> actualRequests = mockService.getRequestPaths();
247     Assert.assertEquals(1, actualRequests.size());
248 
249     String apiClientHeaderKey =
250         mockService
251             .getRequestHeaders()
252             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
253             .iterator()
254             .next();
255     Assert.assertTrue(
256         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
257             .matcher(apiClientHeaderKey)
258             .matches());
259   }
260 
261   @Test
listShelvesExceptionTest()262   public void listShelvesExceptionTest() throws Exception {
263     ApiException exception =
264         ApiExceptionFactory.createException(
265             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
266     mockService.addException(exception);
267 
268     try {
269       ListShelvesRequest request =
270           ListShelvesRequest.newBuilder()
271               .setPageSize(883849137)
272               .setPageToken("pageToken873572522")
273               .build();
274       client.listShelves(request);
275       Assert.fail("No exception raised");
276     } catch (InvalidArgumentException e) {
277       // Expected exception.
278     }
279   }
280 
281   @Test
deleteShelfTest()282   public void deleteShelfTest() throws Exception {
283     Empty expectedResponse = Empty.newBuilder().build();
284     mockService.addResponse(expectedResponse);
285 
286     ShelfName name = ShelfName.of("[SHELF_ID]");
287 
288     client.deleteShelf(name);
289 
290     List<String> actualRequests = mockService.getRequestPaths();
291     Assert.assertEquals(1, actualRequests.size());
292 
293     String apiClientHeaderKey =
294         mockService
295             .getRequestHeaders()
296             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
297             .iterator()
298             .next();
299     Assert.assertTrue(
300         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
301             .matcher(apiClientHeaderKey)
302             .matches());
303   }
304 
305   @Test
deleteShelfExceptionTest()306   public void deleteShelfExceptionTest() throws Exception {
307     ApiException exception =
308         ApiExceptionFactory.createException(
309             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
310     mockService.addException(exception);
311 
312     try {
313       ShelfName name = ShelfName.of("[SHELF_ID]");
314       client.deleteShelf(name);
315       Assert.fail("No exception raised");
316     } catch (InvalidArgumentException e) {
317       // Expected exception.
318     }
319   }
320 
321   @Test
deleteShelfTest2()322   public void deleteShelfTest2() throws Exception {
323     Empty expectedResponse = Empty.newBuilder().build();
324     mockService.addResponse(expectedResponse);
325 
326     String name = "shelves/shelve-6552";
327 
328     client.deleteShelf(name);
329 
330     List<String> actualRequests = mockService.getRequestPaths();
331     Assert.assertEquals(1, actualRequests.size());
332 
333     String apiClientHeaderKey =
334         mockService
335             .getRequestHeaders()
336             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
337             .iterator()
338             .next();
339     Assert.assertTrue(
340         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
341             .matcher(apiClientHeaderKey)
342             .matches());
343   }
344 
345   @Test
deleteShelfExceptionTest2()346   public void deleteShelfExceptionTest2() throws Exception {
347     ApiException exception =
348         ApiExceptionFactory.createException(
349             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
350     mockService.addException(exception);
351 
352     try {
353       String name = "shelves/shelve-6552";
354       client.deleteShelf(name);
355       Assert.fail("No exception raised");
356     } catch (InvalidArgumentException e) {
357       // Expected exception.
358     }
359   }
360 
361   @Test
mergeShelvesTest()362   public void mergeShelvesTest() throws Exception {
363     Shelf expectedResponse =
364         Shelf.newBuilder()
365             .setName(ShelfName.of("[SHELF_ID]").toString())
366             .setTheme("theme110327241")
367             .build();
368     mockService.addResponse(expectedResponse);
369 
370     ShelfName name = ShelfName.of("[SHELF_ID]");
371     ShelfName otherShelf = ShelfName.of("[SHELF_ID]");
372 
373     Shelf actualResponse = client.mergeShelves(name, otherShelf);
374     Assert.assertEquals(expectedResponse, actualResponse);
375 
376     List<String> actualRequests = mockService.getRequestPaths();
377     Assert.assertEquals(1, actualRequests.size());
378 
379     String apiClientHeaderKey =
380         mockService
381             .getRequestHeaders()
382             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
383             .iterator()
384             .next();
385     Assert.assertTrue(
386         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
387             .matcher(apiClientHeaderKey)
388             .matches());
389   }
390 
391   @Test
mergeShelvesExceptionTest()392   public void mergeShelvesExceptionTest() throws Exception {
393     ApiException exception =
394         ApiExceptionFactory.createException(
395             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
396     mockService.addException(exception);
397 
398     try {
399       ShelfName name = ShelfName.of("[SHELF_ID]");
400       ShelfName otherShelf = ShelfName.of("[SHELF_ID]");
401       client.mergeShelves(name, otherShelf);
402       Assert.fail("No exception raised");
403     } catch (InvalidArgumentException e) {
404       // Expected exception.
405     }
406   }
407 
408   @Test
mergeShelvesTest2()409   public void mergeShelvesTest2() throws Exception {
410     Shelf expectedResponse =
411         Shelf.newBuilder()
412             .setName(ShelfName.of("[SHELF_ID]").toString())
413             .setTheme("theme110327241")
414             .build();
415     mockService.addResponse(expectedResponse);
416 
417     ShelfName name = ShelfName.of("[SHELF_ID]");
418     String otherShelf = "otherShelf-193668870";
419 
420     Shelf actualResponse = client.mergeShelves(name, otherShelf);
421     Assert.assertEquals(expectedResponse, actualResponse);
422 
423     List<String> actualRequests = mockService.getRequestPaths();
424     Assert.assertEquals(1, actualRequests.size());
425 
426     String apiClientHeaderKey =
427         mockService
428             .getRequestHeaders()
429             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
430             .iterator()
431             .next();
432     Assert.assertTrue(
433         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
434             .matcher(apiClientHeaderKey)
435             .matches());
436   }
437 
438   @Test
mergeShelvesExceptionTest2()439   public void mergeShelvesExceptionTest2() throws Exception {
440     ApiException exception =
441         ApiExceptionFactory.createException(
442             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
443     mockService.addException(exception);
444 
445     try {
446       ShelfName name = ShelfName.of("[SHELF_ID]");
447       String otherShelf = "otherShelf-193668870";
448       client.mergeShelves(name, otherShelf);
449       Assert.fail("No exception raised");
450     } catch (InvalidArgumentException e) {
451       // Expected exception.
452     }
453   }
454 
455   @Test
mergeShelvesTest3()456   public void mergeShelvesTest3() throws Exception {
457     Shelf expectedResponse =
458         Shelf.newBuilder()
459             .setName(ShelfName.of("[SHELF_ID]").toString())
460             .setTheme("theme110327241")
461             .build();
462     mockService.addResponse(expectedResponse);
463 
464     String name = "shelves/shelve-6552";
465     ShelfName otherShelf = ShelfName.of("[SHELF_ID]");
466 
467     Shelf actualResponse = client.mergeShelves(name, otherShelf);
468     Assert.assertEquals(expectedResponse, actualResponse);
469 
470     List<String> actualRequests = mockService.getRequestPaths();
471     Assert.assertEquals(1, actualRequests.size());
472 
473     String apiClientHeaderKey =
474         mockService
475             .getRequestHeaders()
476             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
477             .iterator()
478             .next();
479     Assert.assertTrue(
480         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
481             .matcher(apiClientHeaderKey)
482             .matches());
483   }
484 
485   @Test
mergeShelvesExceptionTest3()486   public void mergeShelvesExceptionTest3() throws Exception {
487     ApiException exception =
488         ApiExceptionFactory.createException(
489             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
490     mockService.addException(exception);
491 
492     try {
493       String name = "shelves/shelve-6552";
494       ShelfName otherShelf = ShelfName.of("[SHELF_ID]");
495       client.mergeShelves(name, otherShelf);
496       Assert.fail("No exception raised");
497     } catch (InvalidArgumentException e) {
498       // Expected exception.
499     }
500   }
501 
502   @Test
mergeShelvesTest4()503   public void mergeShelvesTest4() throws Exception {
504     Shelf expectedResponse =
505         Shelf.newBuilder()
506             .setName(ShelfName.of("[SHELF_ID]").toString())
507             .setTheme("theme110327241")
508             .build();
509     mockService.addResponse(expectedResponse);
510 
511     String name = "shelves/shelve-6552";
512     String otherShelf = "otherShelf-193668870";
513 
514     Shelf actualResponse = client.mergeShelves(name, otherShelf);
515     Assert.assertEquals(expectedResponse, actualResponse);
516 
517     List<String> actualRequests = mockService.getRequestPaths();
518     Assert.assertEquals(1, actualRequests.size());
519 
520     String apiClientHeaderKey =
521         mockService
522             .getRequestHeaders()
523             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
524             .iterator()
525             .next();
526     Assert.assertTrue(
527         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
528             .matcher(apiClientHeaderKey)
529             .matches());
530   }
531 
532   @Test
mergeShelvesExceptionTest4()533   public void mergeShelvesExceptionTest4() throws Exception {
534     ApiException exception =
535         ApiExceptionFactory.createException(
536             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
537     mockService.addException(exception);
538 
539     try {
540       String name = "shelves/shelve-6552";
541       String otherShelf = "otherShelf-193668870";
542       client.mergeShelves(name, otherShelf);
543       Assert.fail("No exception raised");
544     } catch (InvalidArgumentException e) {
545       // Expected exception.
546     }
547   }
548 
549   @Test
createBookTest()550   public void createBookTest() throws Exception {
551     Book expectedResponse =
552         Book.newBuilder()
553             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
554             .setAuthor("author-1406328437")
555             .setTitle("title110371416")
556             .setRead(true)
557             .build();
558     mockService.addResponse(expectedResponse);
559 
560     ShelfName parent = ShelfName.of("[SHELF_ID]");
561     Book book = Book.newBuilder().build();
562 
563     Book actualResponse = client.createBook(parent, book);
564     Assert.assertEquals(expectedResponse, actualResponse);
565 
566     List<String> actualRequests = mockService.getRequestPaths();
567     Assert.assertEquals(1, actualRequests.size());
568 
569     String apiClientHeaderKey =
570         mockService
571             .getRequestHeaders()
572             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
573             .iterator()
574             .next();
575     Assert.assertTrue(
576         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
577             .matcher(apiClientHeaderKey)
578             .matches());
579   }
580 
581   @Test
createBookExceptionTest()582   public void createBookExceptionTest() throws Exception {
583     ApiException exception =
584         ApiExceptionFactory.createException(
585             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
586     mockService.addException(exception);
587 
588     try {
589       ShelfName parent = ShelfName.of("[SHELF_ID]");
590       Book book = Book.newBuilder().build();
591       client.createBook(parent, book);
592       Assert.fail("No exception raised");
593     } catch (InvalidArgumentException e) {
594       // Expected exception.
595     }
596   }
597 
598   @Test
createBookTest2()599   public void createBookTest2() throws Exception {
600     Book expectedResponse =
601         Book.newBuilder()
602             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
603             .setAuthor("author-1406328437")
604             .setTitle("title110371416")
605             .setRead(true)
606             .build();
607     mockService.addResponse(expectedResponse);
608 
609     String parent = "shelves/shelve-4649";
610     Book book = Book.newBuilder().build();
611 
612     Book actualResponse = client.createBook(parent, book);
613     Assert.assertEquals(expectedResponse, actualResponse);
614 
615     List<String> actualRequests = mockService.getRequestPaths();
616     Assert.assertEquals(1, actualRequests.size());
617 
618     String apiClientHeaderKey =
619         mockService
620             .getRequestHeaders()
621             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
622             .iterator()
623             .next();
624     Assert.assertTrue(
625         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
626             .matcher(apiClientHeaderKey)
627             .matches());
628   }
629 
630   @Test
createBookExceptionTest2()631   public void createBookExceptionTest2() throws Exception {
632     ApiException exception =
633         ApiExceptionFactory.createException(
634             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
635     mockService.addException(exception);
636 
637     try {
638       String parent = "shelves/shelve-4649";
639       Book book = Book.newBuilder().build();
640       client.createBook(parent, book);
641       Assert.fail("No exception raised");
642     } catch (InvalidArgumentException e) {
643       // Expected exception.
644     }
645   }
646 
647   @Test
getBookTest()648   public void getBookTest() throws Exception {
649     Book expectedResponse =
650         Book.newBuilder()
651             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
652             .setAuthor("author-1406328437")
653             .setTitle("title110371416")
654             .setRead(true)
655             .build();
656     mockService.addResponse(expectedResponse);
657 
658     BookName name = BookName.of("[SHELF]", "[BOOK]");
659 
660     Book actualResponse = client.getBook(name);
661     Assert.assertEquals(expectedResponse, actualResponse);
662 
663     List<String> actualRequests = mockService.getRequestPaths();
664     Assert.assertEquals(1, actualRequests.size());
665 
666     String apiClientHeaderKey =
667         mockService
668             .getRequestHeaders()
669             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
670             .iterator()
671             .next();
672     Assert.assertTrue(
673         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
674             .matcher(apiClientHeaderKey)
675             .matches());
676   }
677 
678   @Test
getBookExceptionTest()679   public void getBookExceptionTest() throws Exception {
680     ApiException exception =
681         ApiExceptionFactory.createException(
682             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
683     mockService.addException(exception);
684 
685     try {
686       BookName name = BookName.of("[SHELF]", "[BOOK]");
687       client.getBook(name);
688       Assert.fail("No exception raised");
689     } catch (InvalidArgumentException e) {
690       // Expected exception.
691     }
692   }
693 
694   @Test
getBookTest2()695   public void getBookTest2() throws Exception {
696     Book expectedResponse =
697         Book.newBuilder()
698             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
699             .setAuthor("author-1406328437")
700             .setTitle("title110371416")
701             .setRead(true)
702             .build();
703     mockService.addResponse(expectedResponse);
704 
705     String name = "shelves/shelve-382/books/book-382";
706 
707     Book actualResponse = client.getBook(name);
708     Assert.assertEquals(expectedResponse, actualResponse);
709 
710     List<String> actualRequests = mockService.getRequestPaths();
711     Assert.assertEquals(1, actualRequests.size());
712 
713     String apiClientHeaderKey =
714         mockService
715             .getRequestHeaders()
716             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
717             .iterator()
718             .next();
719     Assert.assertTrue(
720         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
721             .matcher(apiClientHeaderKey)
722             .matches());
723   }
724 
725   @Test
getBookExceptionTest2()726   public void getBookExceptionTest2() throws Exception {
727     ApiException exception =
728         ApiExceptionFactory.createException(
729             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
730     mockService.addException(exception);
731 
732     try {
733       String name = "shelves/shelve-382/books/book-382";
734       client.getBook(name);
735       Assert.fail("No exception raised");
736     } catch (InvalidArgumentException e) {
737       // Expected exception.
738     }
739   }
740 
741   @Test
listBooksTest()742   public void listBooksTest() throws Exception {
743     Book responsesElement = Book.newBuilder().build();
744     ListBooksResponse expectedResponse =
745         ListBooksResponse.newBuilder()
746             .setNextPageToken("")
747             .addAllBooks(Arrays.asList(responsesElement))
748             .build();
749     mockService.addResponse(expectedResponse);
750 
751     ShelfName parent = ShelfName.of("[SHELF_ID]");
752 
753     ListBooksPagedResponse pagedListResponse = client.listBooks(parent);
754 
755     List<Book> resources = Lists.newArrayList(pagedListResponse.iterateAll());
756 
757     Assert.assertEquals(1, resources.size());
758     Assert.assertEquals(expectedResponse.getBooksList().get(0), resources.get(0));
759 
760     List<String> actualRequests = mockService.getRequestPaths();
761     Assert.assertEquals(1, actualRequests.size());
762 
763     String apiClientHeaderKey =
764         mockService
765             .getRequestHeaders()
766             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
767             .iterator()
768             .next();
769     Assert.assertTrue(
770         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
771             .matcher(apiClientHeaderKey)
772             .matches());
773   }
774 
775   @Test
listBooksExceptionTest()776   public void listBooksExceptionTest() throws Exception {
777     ApiException exception =
778         ApiExceptionFactory.createException(
779             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
780     mockService.addException(exception);
781 
782     try {
783       ShelfName parent = ShelfName.of("[SHELF_ID]");
784       client.listBooks(parent);
785       Assert.fail("No exception raised");
786     } catch (InvalidArgumentException e) {
787       // Expected exception.
788     }
789   }
790 
791   @Test
listBooksTest2()792   public void listBooksTest2() throws Exception {
793     Book responsesElement = Book.newBuilder().build();
794     ListBooksResponse expectedResponse =
795         ListBooksResponse.newBuilder()
796             .setNextPageToken("")
797             .addAllBooks(Arrays.asList(responsesElement))
798             .build();
799     mockService.addResponse(expectedResponse);
800 
801     String parent = "shelves/shelve-4649";
802 
803     ListBooksPagedResponse pagedListResponse = client.listBooks(parent);
804 
805     List<Book> resources = Lists.newArrayList(pagedListResponse.iterateAll());
806 
807     Assert.assertEquals(1, resources.size());
808     Assert.assertEquals(expectedResponse.getBooksList().get(0), resources.get(0));
809 
810     List<String> actualRequests = mockService.getRequestPaths();
811     Assert.assertEquals(1, actualRequests.size());
812 
813     String apiClientHeaderKey =
814         mockService
815             .getRequestHeaders()
816             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
817             .iterator()
818             .next();
819     Assert.assertTrue(
820         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
821             .matcher(apiClientHeaderKey)
822             .matches());
823   }
824 
825   @Test
listBooksExceptionTest2()826   public void listBooksExceptionTest2() throws Exception {
827     ApiException exception =
828         ApiExceptionFactory.createException(
829             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
830     mockService.addException(exception);
831 
832     try {
833       String parent = "shelves/shelve-4649";
834       client.listBooks(parent);
835       Assert.fail("No exception raised");
836     } catch (InvalidArgumentException e) {
837       // Expected exception.
838     }
839   }
840 
841   @Test
deleteBookTest()842   public void deleteBookTest() throws Exception {
843     Empty expectedResponse = Empty.newBuilder().build();
844     mockService.addResponse(expectedResponse);
845 
846     BookName name = BookName.of("[SHELF]", "[BOOK]");
847 
848     client.deleteBook(name);
849 
850     List<String> actualRequests = mockService.getRequestPaths();
851     Assert.assertEquals(1, actualRequests.size());
852 
853     String apiClientHeaderKey =
854         mockService
855             .getRequestHeaders()
856             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
857             .iterator()
858             .next();
859     Assert.assertTrue(
860         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
861             .matcher(apiClientHeaderKey)
862             .matches());
863   }
864 
865   @Test
deleteBookExceptionTest()866   public void deleteBookExceptionTest() throws Exception {
867     ApiException exception =
868         ApiExceptionFactory.createException(
869             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
870     mockService.addException(exception);
871 
872     try {
873       BookName name = BookName.of("[SHELF]", "[BOOK]");
874       client.deleteBook(name);
875       Assert.fail("No exception raised");
876     } catch (InvalidArgumentException e) {
877       // Expected exception.
878     }
879   }
880 
881   @Test
deleteBookTest2()882   public void deleteBookTest2() throws Exception {
883     Empty expectedResponse = Empty.newBuilder().build();
884     mockService.addResponse(expectedResponse);
885 
886     String name = "shelves/shelve-382/books/book-382";
887 
888     client.deleteBook(name);
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
deleteBookExceptionTest2()906   public void deleteBookExceptionTest2() 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 name = "shelves/shelve-382/books/book-382";
914       client.deleteBook(name);
915       Assert.fail("No exception raised");
916     } catch (InvalidArgumentException e) {
917       // Expected exception.
918     }
919   }
920 
921   @Test
updateBookTest()922   public void updateBookTest() throws Exception {
923     Book expectedResponse =
924         Book.newBuilder()
925             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
926             .setAuthor("author-1406328437")
927             .setTitle("title110371416")
928             .setRead(true)
929             .build();
930     mockService.addResponse(expectedResponse);
931 
932     Book book =
933         Book.newBuilder()
934             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
935             .setAuthor("author-1406328437")
936             .setTitle("title110371416")
937             .setRead(true)
938             .build();
939     FieldMask updateMask = FieldMask.newBuilder().build();
940 
941     Book actualResponse = client.updateBook(book, updateMask);
942     Assert.assertEquals(expectedResponse, actualResponse);
943 
944     List<String> actualRequests = mockService.getRequestPaths();
945     Assert.assertEquals(1, actualRequests.size());
946 
947     String apiClientHeaderKey =
948         mockService
949             .getRequestHeaders()
950             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
951             .iterator()
952             .next();
953     Assert.assertTrue(
954         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
955             .matcher(apiClientHeaderKey)
956             .matches());
957   }
958 
959   @Test
updateBookExceptionTest()960   public void updateBookExceptionTest() throws Exception {
961     ApiException exception =
962         ApiExceptionFactory.createException(
963             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
964     mockService.addException(exception);
965 
966     try {
967       Book book =
968           Book.newBuilder()
969               .setName(BookName.of("[SHELF]", "[BOOK]").toString())
970               .setAuthor("author-1406328437")
971               .setTitle("title110371416")
972               .setRead(true)
973               .build();
974       FieldMask updateMask = FieldMask.newBuilder().build();
975       client.updateBook(book, updateMask);
976       Assert.fail("No exception raised");
977     } catch (InvalidArgumentException e) {
978       // Expected exception.
979     }
980   }
981 
982   @Test
moveBookTest()983   public void moveBookTest() throws Exception {
984     Book expectedResponse =
985         Book.newBuilder()
986             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
987             .setAuthor("author-1406328437")
988             .setTitle("title110371416")
989             .setRead(true)
990             .build();
991     mockService.addResponse(expectedResponse);
992 
993     BookName name = BookName.of("[SHELF]", "[BOOK]");
994     ShelfName otherShelfName = ShelfName.of("[SHELF_ID]");
995 
996     Book actualResponse = client.moveBook(name, otherShelfName);
997     Assert.assertEquals(expectedResponse, actualResponse);
998 
999     List<String> actualRequests = mockService.getRequestPaths();
1000     Assert.assertEquals(1, actualRequests.size());
1001 
1002     String apiClientHeaderKey =
1003         mockService
1004             .getRequestHeaders()
1005             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1006             .iterator()
1007             .next();
1008     Assert.assertTrue(
1009         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1010             .matcher(apiClientHeaderKey)
1011             .matches());
1012   }
1013 
1014   @Test
moveBookExceptionTest()1015   public void moveBookExceptionTest() throws Exception {
1016     ApiException exception =
1017         ApiExceptionFactory.createException(
1018             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1019     mockService.addException(exception);
1020 
1021     try {
1022       BookName name = BookName.of("[SHELF]", "[BOOK]");
1023       ShelfName otherShelfName = ShelfName.of("[SHELF_ID]");
1024       client.moveBook(name, otherShelfName);
1025       Assert.fail("No exception raised");
1026     } catch (InvalidArgumentException e) {
1027       // Expected exception.
1028     }
1029   }
1030 
1031   @Test
moveBookTest2()1032   public void moveBookTest2() throws Exception {
1033     Book expectedResponse =
1034         Book.newBuilder()
1035             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
1036             .setAuthor("author-1406328437")
1037             .setTitle("title110371416")
1038             .setRead(true)
1039             .build();
1040     mockService.addResponse(expectedResponse);
1041 
1042     BookName name = BookName.of("[SHELF]", "[BOOK]");
1043     String otherShelfName = "otherShelfName-1942963547";
1044 
1045     Book actualResponse = client.moveBook(name, otherShelfName);
1046     Assert.assertEquals(expectedResponse, actualResponse);
1047 
1048     List<String> actualRequests = mockService.getRequestPaths();
1049     Assert.assertEquals(1, actualRequests.size());
1050 
1051     String apiClientHeaderKey =
1052         mockService
1053             .getRequestHeaders()
1054             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1055             .iterator()
1056             .next();
1057     Assert.assertTrue(
1058         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1059             .matcher(apiClientHeaderKey)
1060             .matches());
1061   }
1062 
1063   @Test
moveBookExceptionTest2()1064   public void moveBookExceptionTest2() throws Exception {
1065     ApiException exception =
1066         ApiExceptionFactory.createException(
1067             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1068     mockService.addException(exception);
1069 
1070     try {
1071       BookName name = BookName.of("[SHELF]", "[BOOK]");
1072       String otherShelfName = "otherShelfName-1942963547";
1073       client.moveBook(name, otherShelfName);
1074       Assert.fail("No exception raised");
1075     } catch (InvalidArgumentException e) {
1076       // Expected exception.
1077     }
1078   }
1079 
1080   @Test
moveBookTest3()1081   public void moveBookTest3() throws Exception {
1082     Book expectedResponse =
1083         Book.newBuilder()
1084             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
1085             .setAuthor("author-1406328437")
1086             .setTitle("title110371416")
1087             .setRead(true)
1088             .build();
1089     mockService.addResponse(expectedResponse);
1090 
1091     String name = "shelves/shelve-382/books/book-382";
1092     ShelfName otherShelfName = ShelfName.of("[SHELF_ID]");
1093 
1094     Book actualResponse = client.moveBook(name, otherShelfName);
1095     Assert.assertEquals(expectedResponse, actualResponse);
1096 
1097     List<String> actualRequests = mockService.getRequestPaths();
1098     Assert.assertEquals(1, actualRequests.size());
1099 
1100     String apiClientHeaderKey =
1101         mockService
1102             .getRequestHeaders()
1103             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1104             .iterator()
1105             .next();
1106     Assert.assertTrue(
1107         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1108             .matcher(apiClientHeaderKey)
1109             .matches());
1110   }
1111 
1112   @Test
moveBookExceptionTest3()1113   public void moveBookExceptionTest3() throws Exception {
1114     ApiException exception =
1115         ApiExceptionFactory.createException(
1116             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1117     mockService.addException(exception);
1118 
1119     try {
1120       String name = "shelves/shelve-382/books/book-382";
1121       ShelfName otherShelfName = ShelfName.of("[SHELF_ID]");
1122       client.moveBook(name, otherShelfName);
1123       Assert.fail("No exception raised");
1124     } catch (InvalidArgumentException e) {
1125       // Expected exception.
1126     }
1127   }
1128 
1129   @Test
moveBookTest4()1130   public void moveBookTest4() throws Exception {
1131     Book expectedResponse =
1132         Book.newBuilder()
1133             .setName(BookName.of("[SHELF]", "[BOOK]").toString())
1134             .setAuthor("author-1406328437")
1135             .setTitle("title110371416")
1136             .setRead(true)
1137             .build();
1138     mockService.addResponse(expectedResponse);
1139 
1140     String name = "shelves/shelve-382/books/book-382";
1141     String otherShelfName = "otherShelfName-1942963547";
1142 
1143     Book actualResponse = client.moveBook(name, otherShelfName);
1144     Assert.assertEquals(expectedResponse, actualResponse);
1145 
1146     List<String> actualRequests = mockService.getRequestPaths();
1147     Assert.assertEquals(1, actualRequests.size());
1148 
1149     String apiClientHeaderKey =
1150         mockService
1151             .getRequestHeaders()
1152             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1153             .iterator()
1154             .next();
1155     Assert.assertTrue(
1156         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1157             .matcher(apiClientHeaderKey)
1158             .matches());
1159   }
1160 
1161   @Test
moveBookExceptionTest4()1162   public void moveBookExceptionTest4() throws Exception {
1163     ApiException exception =
1164         ApiExceptionFactory.createException(
1165             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1166     mockService.addException(exception);
1167 
1168     try {
1169       String name = "shelves/shelve-382/books/book-382";
1170       String otherShelfName = "otherShelfName-1942963547";
1171       client.moveBook(name, otherShelfName);
1172       Assert.fail("No exception raised");
1173     } catch (InvalidArgumentException e) {
1174       // Expected exception.
1175     }
1176   }
1177 }
1178