• 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.monitoring.v3;
18 
19 import static com.google.cloud.monitoring.v3.GroupServiceClient.ListGroupMembersPagedResponse;
20 import static com.google.cloud.monitoring.v3.GroupServiceClient.ListGroupsPagedResponse;
21 
22 import com.google.api.MonitoredResource;
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.grpc.GaxGrpcProperties;
25 import com.google.api.gax.grpc.testing.LocalChannelProvider;
26 import com.google.api.gax.grpc.testing.MockGrpcService;
27 import com.google.api.gax.grpc.testing.MockServiceHelper;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.common.collect.Lists;
31 import com.google.monitoring.v3.CreateGroupRequest;
32 import com.google.monitoring.v3.DeleteGroupRequest;
33 import com.google.monitoring.v3.FolderName;
34 import com.google.monitoring.v3.GetGroupRequest;
35 import com.google.monitoring.v3.Group;
36 import com.google.monitoring.v3.GroupName;
37 import com.google.monitoring.v3.ListGroupMembersRequest;
38 import com.google.monitoring.v3.ListGroupMembersResponse;
39 import com.google.monitoring.v3.ListGroupsRequest;
40 import com.google.monitoring.v3.ListGroupsResponse;
41 import com.google.monitoring.v3.OrganizationName;
42 import com.google.monitoring.v3.ProjectName;
43 import com.google.monitoring.v3.UpdateGroupRequest;
44 import com.google.protobuf.AbstractMessage;
45 import com.google.protobuf.Empty;
46 import io.grpc.StatusRuntimeException;
47 import java.io.IOException;
48 import java.util.Arrays;
49 import java.util.List;
50 import java.util.UUID;
51 import javax.annotation.Generated;
52 import org.junit.After;
53 import org.junit.AfterClass;
54 import org.junit.Assert;
55 import org.junit.Before;
56 import org.junit.BeforeClass;
57 import org.junit.Test;
58 
59 @Generated("by gapic-generator-java")
60 public class GroupServiceClientTest {
61   private static MockGroupService mockGroupService;
62   private static MockServiceHelper mockServiceHelper;
63   private LocalChannelProvider channelProvider;
64   private GroupServiceClient client;
65 
66   @BeforeClass
startStaticServer()67   public static void startStaticServer() {
68     mockGroupService = new MockGroupService();
69     mockServiceHelper =
70         new MockServiceHelper(
71             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockGroupService));
72     mockServiceHelper.start();
73   }
74 
75   @AfterClass
stopServer()76   public static void stopServer() {
77     mockServiceHelper.stop();
78   }
79 
80   @Before
setUp()81   public void setUp() throws IOException {
82     mockServiceHelper.reset();
83     channelProvider = mockServiceHelper.createChannelProvider();
84     GroupServiceSettings settings =
85         GroupServiceSettings.newBuilder()
86             .setTransportChannelProvider(channelProvider)
87             .setCredentialsProvider(NoCredentialsProvider.create())
88             .build();
89     client = GroupServiceClient.create(settings);
90   }
91 
92   @After
tearDown()93   public void tearDown() throws Exception {
94     client.close();
95   }
96 
97   @Test
listGroupsTest()98   public void listGroupsTest() throws Exception {
99     Group responsesElement = Group.newBuilder().build();
100     ListGroupsResponse expectedResponse =
101         ListGroupsResponse.newBuilder()
102             .setNextPageToken("")
103             .addAllGroup(Arrays.asList(responsesElement))
104             .build();
105     mockGroupService.addResponse(expectedResponse);
106 
107     FolderName name = FolderName.of("[FOLDER]");
108 
109     ListGroupsPagedResponse pagedListResponse = client.listGroups(name);
110 
111     List<Group> resources = Lists.newArrayList(pagedListResponse.iterateAll());
112 
113     Assert.assertEquals(1, resources.size());
114     Assert.assertEquals(expectedResponse.getGroupList().get(0), resources.get(0));
115 
116     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
117     Assert.assertEquals(1, actualRequests.size());
118     ListGroupsRequest actualRequest = ((ListGroupsRequest) actualRequests.get(0));
119 
120     Assert.assertEquals(name.toString(), actualRequest.getName());
121     Assert.assertTrue(
122         channelProvider.isHeaderSent(
123             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
124             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
125   }
126 
127   @Test
listGroupsExceptionTest()128   public void listGroupsExceptionTest() throws Exception {
129     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
130     mockGroupService.addException(exception);
131 
132     try {
133       FolderName name = FolderName.of("[FOLDER]");
134       client.listGroups(name);
135       Assert.fail("No exception raised");
136     } catch (InvalidArgumentException e) {
137       // Expected exception.
138     }
139   }
140 
141   @Test
listGroupsTest2()142   public void listGroupsTest2() throws Exception {
143     Group responsesElement = Group.newBuilder().build();
144     ListGroupsResponse expectedResponse =
145         ListGroupsResponse.newBuilder()
146             .setNextPageToken("")
147             .addAllGroup(Arrays.asList(responsesElement))
148             .build();
149     mockGroupService.addResponse(expectedResponse);
150 
151     OrganizationName name = OrganizationName.of("[ORGANIZATION]");
152 
153     ListGroupsPagedResponse pagedListResponse = client.listGroups(name);
154 
155     List<Group> resources = Lists.newArrayList(pagedListResponse.iterateAll());
156 
157     Assert.assertEquals(1, resources.size());
158     Assert.assertEquals(expectedResponse.getGroupList().get(0), resources.get(0));
159 
160     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
161     Assert.assertEquals(1, actualRequests.size());
162     ListGroupsRequest actualRequest = ((ListGroupsRequest) actualRequests.get(0));
163 
164     Assert.assertEquals(name.toString(), actualRequest.getName());
165     Assert.assertTrue(
166         channelProvider.isHeaderSent(
167             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
168             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
169   }
170 
171   @Test
listGroupsExceptionTest2()172   public void listGroupsExceptionTest2() throws Exception {
173     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
174     mockGroupService.addException(exception);
175 
176     try {
177       OrganizationName name = OrganizationName.of("[ORGANIZATION]");
178       client.listGroups(name);
179       Assert.fail("No exception raised");
180     } catch (InvalidArgumentException e) {
181       // Expected exception.
182     }
183   }
184 
185   @Test
listGroupsTest3()186   public void listGroupsTest3() throws Exception {
187     Group responsesElement = Group.newBuilder().build();
188     ListGroupsResponse expectedResponse =
189         ListGroupsResponse.newBuilder()
190             .setNextPageToken("")
191             .addAllGroup(Arrays.asList(responsesElement))
192             .build();
193     mockGroupService.addResponse(expectedResponse);
194 
195     ProjectName name = ProjectName.of("[PROJECT]");
196 
197     ListGroupsPagedResponse pagedListResponse = client.listGroups(name);
198 
199     List<Group> resources = Lists.newArrayList(pagedListResponse.iterateAll());
200 
201     Assert.assertEquals(1, resources.size());
202     Assert.assertEquals(expectedResponse.getGroupList().get(0), resources.get(0));
203 
204     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
205     Assert.assertEquals(1, actualRequests.size());
206     ListGroupsRequest actualRequest = ((ListGroupsRequest) actualRequests.get(0));
207 
208     Assert.assertEquals(name.toString(), actualRequest.getName());
209     Assert.assertTrue(
210         channelProvider.isHeaderSent(
211             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
212             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
213   }
214 
215   @Test
listGroupsExceptionTest3()216   public void listGroupsExceptionTest3() throws Exception {
217     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
218     mockGroupService.addException(exception);
219 
220     try {
221       ProjectName name = ProjectName.of("[PROJECT]");
222       client.listGroups(name);
223       Assert.fail("No exception raised");
224     } catch (InvalidArgumentException e) {
225       // Expected exception.
226     }
227   }
228 
229   @Test
listGroupsTest4()230   public void listGroupsTest4() throws Exception {
231     Group responsesElement = Group.newBuilder().build();
232     ListGroupsResponse expectedResponse =
233         ListGroupsResponse.newBuilder()
234             .setNextPageToken("")
235             .addAllGroup(Arrays.asList(responsesElement))
236             .build();
237     mockGroupService.addResponse(expectedResponse);
238 
239     String name = "name3373707";
240 
241     ListGroupsPagedResponse pagedListResponse = client.listGroups(name);
242 
243     List<Group> resources = Lists.newArrayList(pagedListResponse.iterateAll());
244 
245     Assert.assertEquals(1, resources.size());
246     Assert.assertEquals(expectedResponse.getGroupList().get(0), resources.get(0));
247 
248     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
249     Assert.assertEquals(1, actualRequests.size());
250     ListGroupsRequest actualRequest = ((ListGroupsRequest) actualRequests.get(0));
251 
252     Assert.assertEquals(name, actualRequest.getName());
253     Assert.assertTrue(
254         channelProvider.isHeaderSent(
255             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
256             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
257   }
258 
259   @Test
listGroupsExceptionTest4()260   public void listGroupsExceptionTest4() throws Exception {
261     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
262     mockGroupService.addException(exception);
263 
264     try {
265       String name = "name3373707";
266       client.listGroups(name);
267       Assert.fail("No exception raised");
268     } catch (InvalidArgumentException e) {
269       // Expected exception.
270     }
271   }
272 
273   @Test
getGroupTest()274   public void getGroupTest() throws Exception {
275     Group expectedResponse =
276         Group.newBuilder()
277             .setName(GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]").toString())
278             .setDisplayName("displayName1714148973")
279             .setParentName("parentName-244870571")
280             .setFilter("filter-1274492040")
281             .setIsCluster(true)
282             .build();
283     mockGroupService.addResponse(expectedResponse);
284 
285     GroupName name = GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]");
286 
287     Group actualResponse = client.getGroup(name);
288     Assert.assertEquals(expectedResponse, actualResponse);
289 
290     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
291     Assert.assertEquals(1, actualRequests.size());
292     GetGroupRequest actualRequest = ((GetGroupRequest) actualRequests.get(0));
293 
294     Assert.assertEquals(name.toString(), actualRequest.getName());
295     Assert.assertTrue(
296         channelProvider.isHeaderSent(
297             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
298             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
299   }
300 
301   @Test
getGroupExceptionTest()302   public void getGroupExceptionTest() throws Exception {
303     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
304     mockGroupService.addException(exception);
305 
306     try {
307       GroupName name = GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]");
308       client.getGroup(name);
309       Assert.fail("No exception raised");
310     } catch (InvalidArgumentException e) {
311       // Expected exception.
312     }
313   }
314 
315   @Test
getGroupTest2()316   public void getGroupTest2() throws Exception {
317     Group expectedResponse =
318         Group.newBuilder()
319             .setName(GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]").toString())
320             .setDisplayName("displayName1714148973")
321             .setParentName("parentName-244870571")
322             .setFilter("filter-1274492040")
323             .setIsCluster(true)
324             .build();
325     mockGroupService.addResponse(expectedResponse);
326 
327     String name = "name3373707";
328 
329     Group actualResponse = client.getGroup(name);
330     Assert.assertEquals(expectedResponse, actualResponse);
331 
332     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
333     Assert.assertEquals(1, actualRequests.size());
334     GetGroupRequest actualRequest = ((GetGroupRequest) actualRequests.get(0));
335 
336     Assert.assertEquals(name, actualRequest.getName());
337     Assert.assertTrue(
338         channelProvider.isHeaderSent(
339             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
340             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
341   }
342 
343   @Test
getGroupExceptionTest2()344   public void getGroupExceptionTest2() throws Exception {
345     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
346     mockGroupService.addException(exception);
347 
348     try {
349       String name = "name3373707";
350       client.getGroup(name);
351       Assert.fail("No exception raised");
352     } catch (InvalidArgumentException e) {
353       // Expected exception.
354     }
355   }
356 
357   @Test
createGroupTest()358   public void createGroupTest() throws Exception {
359     Group expectedResponse =
360         Group.newBuilder()
361             .setName(GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]").toString())
362             .setDisplayName("displayName1714148973")
363             .setParentName("parentName-244870571")
364             .setFilter("filter-1274492040")
365             .setIsCluster(true)
366             .build();
367     mockGroupService.addResponse(expectedResponse);
368 
369     FolderName name = FolderName.of("[FOLDER]");
370     Group group = Group.newBuilder().build();
371 
372     Group actualResponse = client.createGroup(name, group);
373     Assert.assertEquals(expectedResponse, actualResponse);
374 
375     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
376     Assert.assertEquals(1, actualRequests.size());
377     CreateGroupRequest actualRequest = ((CreateGroupRequest) actualRequests.get(0));
378 
379     Assert.assertEquals(name.toString(), actualRequest.getName());
380     Assert.assertEquals(group, actualRequest.getGroup());
381     Assert.assertTrue(
382         channelProvider.isHeaderSent(
383             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
384             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
385   }
386 
387   @Test
createGroupExceptionTest()388   public void createGroupExceptionTest() throws Exception {
389     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
390     mockGroupService.addException(exception);
391 
392     try {
393       FolderName name = FolderName.of("[FOLDER]");
394       Group group = Group.newBuilder().build();
395       client.createGroup(name, group);
396       Assert.fail("No exception raised");
397     } catch (InvalidArgumentException e) {
398       // Expected exception.
399     }
400   }
401 
402   @Test
createGroupTest2()403   public void createGroupTest2() throws Exception {
404     Group expectedResponse =
405         Group.newBuilder()
406             .setName(GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]").toString())
407             .setDisplayName("displayName1714148973")
408             .setParentName("parentName-244870571")
409             .setFilter("filter-1274492040")
410             .setIsCluster(true)
411             .build();
412     mockGroupService.addResponse(expectedResponse);
413 
414     OrganizationName name = OrganizationName.of("[ORGANIZATION]");
415     Group group = Group.newBuilder().build();
416 
417     Group actualResponse = client.createGroup(name, group);
418     Assert.assertEquals(expectedResponse, actualResponse);
419 
420     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
421     Assert.assertEquals(1, actualRequests.size());
422     CreateGroupRequest actualRequest = ((CreateGroupRequest) actualRequests.get(0));
423 
424     Assert.assertEquals(name.toString(), actualRequest.getName());
425     Assert.assertEquals(group, actualRequest.getGroup());
426     Assert.assertTrue(
427         channelProvider.isHeaderSent(
428             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
429             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
430   }
431 
432   @Test
createGroupExceptionTest2()433   public void createGroupExceptionTest2() throws Exception {
434     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
435     mockGroupService.addException(exception);
436 
437     try {
438       OrganizationName name = OrganizationName.of("[ORGANIZATION]");
439       Group group = Group.newBuilder().build();
440       client.createGroup(name, group);
441       Assert.fail("No exception raised");
442     } catch (InvalidArgumentException e) {
443       // Expected exception.
444     }
445   }
446 
447   @Test
createGroupTest3()448   public void createGroupTest3() throws Exception {
449     Group expectedResponse =
450         Group.newBuilder()
451             .setName(GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]").toString())
452             .setDisplayName("displayName1714148973")
453             .setParentName("parentName-244870571")
454             .setFilter("filter-1274492040")
455             .setIsCluster(true)
456             .build();
457     mockGroupService.addResponse(expectedResponse);
458 
459     ProjectName name = ProjectName.of("[PROJECT]");
460     Group group = Group.newBuilder().build();
461 
462     Group actualResponse = client.createGroup(name, group);
463     Assert.assertEquals(expectedResponse, actualResponse);
464 
465     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
466     Assert.assertEquals(1, actualRequests.size());
467     CreateGroupRequest actualRequest = ((CreateGroupRequest) actualRequests.get(0));
468 
469     Assert.assertEquals(name.toString(), actualRequest.getName());
470     Assert.assertEquals(group, actualRequest.getGroup());
471     Assert.assertTrue(
472         channelProvider.isHeaderSent(
473             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
474             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
475   }
476 
477   @Test
createGroupExceptionTest3()478   public void createGroupExceptionTest3() throws Exception {
479     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
480     mockGroupService.addException(exception);
481 
482     try {
483       ProjectName name = ProjectName.of("[PROJECT]");
484       Group group = Group.newBuilder().build();
485       client.createGroup(name, group);
486       Assert.fail("No exception raised");
487     } catch (InvalidArgumentException e) {
488       // Expected exception.
489     }
490   }
491 
492   @Test
createGroupTest4()493   public void createGroupTest4() throws Exception {
494     Group expectedResponse =
495         Group.newBuilder()
496             .setName(GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]").toString())
497             .setDisplayName("displayName1714148973")
498             .setParentName("parentName-244870571")
499             .setFilter("filter-1274492040")
500             .setIsCluster(true)
501             .build();
502     mockGroupService.addResponse(expectedResponse);
503 
504     String name = "name3373707";
505     Group group = Group.newBuilder().build();
506 
507     Group actualResponse = client.createGroup(name, group);
508     Assert.assertEquals(expectedResponse, actualResponse);
509 
510     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
511     Assert.assertEquals(1, actualRequests.size());
512     CreateGroupRequest actualRequest = ((CreateGroupRequest) actualRequests.get(0));
513 
514     Assert.assertEquals(name, actualRequest.getName());
515     Assert.assertEquals(group, actualRequest.getGroup());
516     Assert.assertTrue(
517         channelProvider.isHeaderSent(
518             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
519             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
520   }
521 
522   @Test
createGroupExceptionTest4()523   public void createGroupExceptionTest4() throws Exception {
524     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
525     mockGroupService.addException(exception);
526 
527     try {
528       String name = "name3373707";
529       Group group = Group.newBuilder().build();
530       client.createGroup(name, group);
531       Assert.fail("No exception raised");
532     } catch (InvalidArgumentException e) {
533       // Expected exception.
534     }
535   }
536 
537   @Test
updateGroupTest()538   public void updateGroupTest() throws Exception {
539     Group expectedResponse =
540         Group.newBuilder()
541             .setName(GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]").toString())
542             .setDisplayName("displayName1714148973")
543             .setParentName("parentName-244870571")
544             .setFilter("filter-1274492040")
545             .setIsCluster(true)
546             .build();
547     mockGroupService.addResponse(expectedResponse);
548 
549     Group group = Group.newBuilder().build();
550 
551     Group actualResponse = client.updateGroup(group);
552     Assert.assertEquals(expectedResponse, actualResponse);
553 
554     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
555     Assert.assertEquals(1, actualRequests.size());
556     UpdateGroupRequest actualRequest = ((UpdateGroupRequest) actualRequests.get(0));
557 
558     Assert.assertEquals(group, actualRequest.getGroup());
559     Assert.assertTrue(
560         channelProvider.isHeaderSent(
561             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
562             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
563   }
564 
565   @Test
updateGroupExceptionTest()566   public void updateGroupExceptionTest() throws Exception {
567     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
568     mockGroupService.addException(exception);
569 
570     try {
571       Group group = Group.newBuilder().build();
572       client.updateGroup(group);
573       Assert.fail("No exception raised");
574     } catch (InvalidArgumentException e) {
575       // Expected exception.
576     }
577   }
578 
579   @Test
deleteGroupTest()580   public void deleteGroupTest() throws Exception {
581     Empty expectedResponse = Empty.newBuilder().build();
582     mockGroupService.addResponse(expectedResponse);
583 
584     GroupName name = GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]");
585 
586     client.deleteGroup(name);
587 
588     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
589     Assert.assertEquals(1, actualRequests.size());
590     DeleteGroupRequest actualRequest = ((DeleteGroupRequest) actualRequests.get(0));
591 
592     Assert.assertEquals(name.toString(), actualRequest.getName());
593     Assert.assertTrue(
594         channelProvider.isHeaderSent(
595             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
596             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
597   }
598 
599   @Test
deleteGroupExceptionTest()600   public void deleteGroupExceptionTest() throws Exception {
601     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
602     mockGroupService.addException(exception);
603 
604     try {
605       GroupName name = GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]");
606       client.deleteGroup(name);
607       Assert.fail("No exception raised");
608     } catch (InvalidArgumentException e) {
609       // Expected exception.
610     }
611   }
612 
613   @Test
deleteGroupTest2()614   public void deleteGroupTest2() throws Exception {
615     Empty expectedResponse = Empty.newBuilder().build();
616     mockGroupService.addResponse(expectedResponse);
617 
618     String name = "name3373707";
619 
620     client.deleteGroup(name);
621 
622     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
623     Assert.assertEquals(1, actualRequests.size());
624     DeleteGroupRequest actualRequest = ((DeleteGroupRequest) actualRequests.get(0));
625 
626     Assert.assertEquals(name, actualRequest.getName());
627     Assert.assertTrue(
628         channelProvider.isHeaderSent(
629             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
630             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
631   }
632 
633   @Test
deleteGroupExceptionTest2()634   public void deleteGroupExceptionTest2() throws Exception {
635     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
636     mockGroupService.addException(exception);
637 
638     try {
639       String name = "name3373707";
640       client.deleteGroup(name);
641       Assert.fail("No exception raised");
642     } catch (InvalidArgumentException e) {
643       // Expected exception.
644     }
645   }
646 
647   @Test
listGroupMembersTest()648   public void listGroupMembersTest() throws Exception {
649     MonitoredResource responsesElement = MonitoredResource.newBuilder().build();
650     ListGroupMembersResponse expectedResponse =
651         ListGroupMembersResponse.newBuilder()
652             .setNextPageToken("")
653             .addAllMembers(Arrays.asList(responsesElement))
654             .build();
655     mockGroupService.addResponse(expectedResponse);
656 
657     GroupName name = GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]");
658 
659     ListGroupMembersPagedResponse pagedListResponse = client.listGroupMembers(name);
660 
661     List<MonitoredResource> resources = Lists.newArrayList(pagedListResponse.iterateAll());
662 
663     Assert.assertEquals(1, resources.size());
664     Assert.assertEquals(expectedResponse.getMembersList().get(0), resources.get(0));
665 
666     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
667     Assert.assertEquals(1, actualRequests.size());
668     ListGroupMembersRequest actualRequest = ((ListGroupMembersRequest) actualRequests.get(0));
669 
670     Assert.assertEquals(name.toString(), actualRequest.getName());
671     Assert.assertTrue(
672         channelProvider.isHeaderSent(
673             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
674             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
675   }
676 
677   @Test
listGroupMembersExceptionTest()678   public void listGroupMembersExceptionTest() throws Exception {
679     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
680     mockGroupService.addException(exception);
681 
682     try {
683       GroupName name = GroupName.ofProjectGroupName("[PROJECT]", "[GROUP]");
684       client.listGroupMembers(name);
685       Assert.fail("No exception raised");
686     } catch (InvalidArgumentException e) {
687       // Expected exception.
688     }
689   }
690 
691   @Test
listGroupMembersTest2()692   public void listGroupMembersTest2() throws Exception {
693     MonitoredResource responsesElement = MonitoredResource.newBuilder().build();
694     ListGroupMembersResponse expectedResponse =
695         ListGroupMembersResponse.newBuilder()
696             .setNextPageToken("")
697             .addAllMembers(Arrays.asList(responsesElement))
698             .build();
699     mockGroupService.addResponse(expectedResponse);
700 
701     String name = "name3373707";
702 
703     ListGroupMembersPagedResponse pagedListResponse = client.listGroupMembers(name);
704 
705     List<MonitoredResource> resources = Lists.newArrayList(pagedListResponse.iterateAll());
706 
707     Assert.assertEquals(1, resources.size());
708     Assert.assertEquals(expectedResponse.getMembersList().get(0), resources.get(0));
709 
710     List<AbstractMessage> actualRequests = mockGroupService.getRequests();
711     Assert.assertEquals(1, actualRequests.size());
712     ListGroupMembersRequest actualRequest = ((ListGroupMembersRequest) actualRequests.get(0));
713 
714     Assert.assertEquals(name, actualRequest.getName());
715     Assert.assertTrue(
716         channelProvider.isHeaderSent(
717             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
718             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
719   }
720 
721   @Test
listGroupMembersExceptionTest2()722   public void listGroupMembersExceptionTest2() throws Exception {
723     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
724     mockGroupService.addException(exception);
725 
726     try {
727       String name = "name3373707";
728       client.listGroupMembers(name);
729       Assert.fail("No exception raised");
730     } catch (InvalidArgumentException e) {
731       // Expected exception.
732     }
733   }
734 }
735