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