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