• 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.MetricServiceClient.ListMetricDescriptorsPagedResponse;
20 import static com.google.cloud.monitoring.v3.MetricServiceClient.ListMonitoredResourceDescriptorsPagedResponse;
21 import static com.google.cloud.monitoring.v3.MetricServiceClient.ListTimeSeriesPagedResponse;
22 
23 import com.google.api.LabelDescriptor;
24 import com.google.api.LaunchStage;
25 import com.google.api.MetricDescriptor;
26 import com.google.api.MonitoredResourceDescriptor;
27 import com.google.api.gax.core.NoCredentialsProvider;
28 import com.google.api.gax.grpc.GaxGrpcProperties;
29 import com.google.api.gax.grpc.testing.LocalChannelProvider;
30 import com.google.api.gax.grpc.testing.MockGrpcService;
31 import com.google.api.gax.grpc.testing.MockServiceHelper;
32 import com.google.api.gax.rpc.ApiClientHeaderProvider;
33 import com.google.api.gax.rpc.InvalidArgumentException;
34 import com.google.common.collect.Lists;
35 import com.google.monitoring.v3.CreateMetricDescriptorRequest;
36 import com.google.monitoring.v3.CreateTimeSeriesRequest;
37 import com.google.monitoring.v3.DeleteMetricDescriptorRequest;
38 import com.google.monitoring.v3.FolderName;
39 import com.google.monitoring.v3.GetMetricDescriptorRequest;
40 import com.google.monitoring.v3.GetMonitoredResourceDescriptorRequest;
41 import com.google.monitoring.v3.ListMetricDescriptorsRequest;
42 import com.google.monitoring.v3.ListMetricDescriptorsResponse;
43 import com.google.monitoring.v3.ListMonitoredResourceDescriptorsRequest;
44 import com.google.monitoring.v3.ListMonitoredResourceDescriptorsResponse;
45 import com.google.monitoring.v3.ListTimeSeriesRequest;
46 import com.google.monitoring.v3.ListTimeSeriesResponse;
47 import com.google.monitoring.v3.MetricDescriptorName;
48 import com.google.monitoring.v3.MonitoredResourceDescriptorName;
49 import com.google.monitoring.v3.OrganizationName;
50 import com.google.monitoring.v3.ProjectName;
51 import com.google.monitoring.v3.TimeInterval;
52 import com.google.monitoring.v3.TimeSeries;
53 import com.google.protobuf.AbstractMessage;
54 import com.google.protobuf.Empty;
55 import io.grpc.StatusRuntimeException;
56 import java.io.IOException;
57 import java.util.ArrayList;
58 import java.util.Arrays;
59 import java.util.List;
60 import java.util.UUID;
61 import javax.annotation.Generated;
62 import org.junit.After;
63 import org.junit.AfterClass;
64 import org.junit.Assert;
65 import org.junit.Before;
66 import org.junit.BeforeClass;
67 import org.junit.Test;
68 
69 @Generated("by gapic-generator-java")
70 public class MetricServiceClientTest {
71   private static MockMetricService mockMetricService;
72   private static MockServiceHelper mockServiceHelper;
73   private LocalChannelProvider channelProvider;
74   private MetricServiceClient client;
75 
76   @BeforeClass
startStaticServer()77   public static void startStaticServer() {
78     mockMetricService = new MockMetricService();
79     mockServiceHelper =
80         new MockServiceHelper(
81             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockMetricService));
82     mockServiceHelper.start();
83   }
84 
85   @AfterClass
stopServer()86   public static void stopServer() {
87     mockServiceHelper.stop();
88   }
89 
90   @Before
setUp()91   public void setUp() throws IOException {
92     mockServiceHelper.reset();
93     channelProvider = mockServiceHelper.createChannelProvider();
94     MetricServiceSettings settings =
95         MetricServiceSettings.newBuilder()
96             .setTransportChannelProvider(channelProvider)
97             .setCredentialsProvider(NoCredentialsProvider.create())
98             .build();
99     client = MetricServiceClient.create(settings);
100   }
101 
102   @After
tearDown()103   public void tearDown() throws Exception {
104     client.close();
105   }
106 
107   @Test
listMonitoredResourceDescriptorsTest()108   public void listMonitoredResourceDescriptorsTest() throws Exception {
109     MonitoredResourceDescriptor responsesElement = MonitoredResourceDescriptor.newBuilder().build();
110     ListMonitoredResourceDescriptorsResponse expectedResponse =
111         ListMonitoredResourceDescriptorsResponse.newBuilder()
112             .setNextPageToken("")
113             .addAllResourceDescriptors(Arrays.asList(responsesElement))
114             .build();
115     mockMetricService.addResponse(expectedResponse);
116 
117     FolderName name = FolderName.of("[FOLDER]");
118 
119     ListMonitoredResourceDescriptorsPagedResponse pagedListResponse =
120         client.listMonitoredResourceDescriptors(name);
121 
122     List<MonitoredResourceDescriptor> resources =
123         Lists.newArrayList(pagedListResponse.iterateAll());
124 
125     Assert.assertEquals(1, resources.size());
126     Assert.assertEquals(expectedResponse.getResourceDescriptorsList().get(0), resources.get(0));
127 
128     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
129     Assert.assertEquals(1, actualRequests.size());
130     ListMonitoredResourceDescriptorsRequest actualRequest =
131         ((ListMonitoredResourceDescriptorsRequest) actualRequests.get(0));
132 
133     Assert.assertEquals(name.toString(), actualRequest.getName());
134     Assert.assertTrue(
135         channelProvider.isHeaderSent(
136             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
137             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
138   }
139 
140   @Test
listMonitoredResourceDescriptorsExceptionTest()141   public void listMonitoredResourceDescriptorsExceptionTest() throws Exception {
142     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
143     mockMetricService.addException(exception);
144 
145     try {
146       FolderName name = FolderName.of("[FOLDER]");
147       client.listMonitoredResourceDescriptors(name);
148       Assert.fail("No exception raised");
149     } catch (InvalidArgumentException e) {
150       // Expected exception.
151     }
152   }
153 
154   @Test
listMonitoredResourceDescriptorsTest2()155   public void listMonitoredResourceDescriptorsTest2() throws Exception {
156     MonitoredResourceDescriptor responsesElement = MonitoredResourceDescriptor.newBuilder().build();
157     ListMonitoredResourceDescriptorsResponse expectedResponse =
158         ListMonitoredResourceDescriptorsResponse.newBuilder()
159             .setNextPageToken("")
160             .addAllResourceDescriptors(Arrays.asList(responsesElement))
161             .build();
162     mockMetricService.addResponse(expectedResponse);
163 
164     OrganizationName name = OrganizationName.of("[ORGANIZATION]");
165 
166     ListMonitoredResourceDescriptorsPagedResponse pagedListResponse =
167         client.listMonitoredResourceDescriptors(name);
168 
169     List<MonitoredResourceDescriptor> resources =
170         Lists.newArrayList(pagedListResponse.iterateAll());
171 
172     Assert.assertEquals(1, resources.size());
173     Assert.assertEquals(expectedResponse.getResourceDescriptorsList().get(0), resources.get(0));
174 
175     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
176     Assert.assertEquals(1, actualRequests.size());
177     ListMonitoredResourceDescriptorsRequest actualRequest =
178         ((ListMonitoredResourceDescriptorsRequest) actualRequests.get(0));
179 
180     Assert.assertEquals(name.toString(), actualRequest.getName());
181     Assert.assertTrue(
182         channelProvider.isHeaderSent(
183             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
184             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
185   }
186 
187   @Test
listMonitoredResourceDescriptorsExceptionTest2()188   public void listMonitoredResourceDescriptorsExceptionTest2() throws Exception {
189     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
190     mockMetricService.addException(exception);
191 
192     try {
193       OrganizationName name = OrganizationName.of("[ORGANIZATION]");
194       client.listMonitoredResourceDescriptors(name);
195       Assert.fail("No exception raised");
196     } catch (InvalidArgumentException e) {
197       // Expected exception.
198     }
199   }
200 
201   @Test
listMonitoredResourceDescriptorsTest3()202   public void listMonitoredResourceDescriptorsTest3() throws Exception {
203     MonitoredResourceDescriptor responsesElement = MonitoredResourceDescriptor.newBuilder().build();
204     ListMonitoredResourceDescriptorsResponse expectedResponse =
205         ListMonitoredResourceDescriptorsResponse.newBuilder()
206             .setNextPageToken("")
207             .addAllResourceDescriptors(Arrays.asList(responsesElement))
208             .build();
209     mockMetricService.addResponse(expectedResponse);
210 
211     ProjectName name = ProjectName.of("[PROJECT]");
212 
213     ListMonitoredResourceDescriptorsPagedResponse pagedListResponse =
214         client.listMonitoredResourceDescriptors(name);
215 
216     List<MonitoredResourceDescriptor> resources =
217         Lists.newArrayList(pagedListResponse.iterateAll());
218 
219     Assert.assertEquals(1, resources.size());
220     Assert.assertEquals(expectedResponse.getResourceDescriptorsList().get(0), resources.get(0));
221 
222     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
223     Assert.assertEquals(1, actualRequests.size());
224     ListMonitoredResourceDescriptorsRequest actualRequest =
225         ((ListMonitoredResourceDescriptorsRequest) actualRequests.get(0));
226 
227     Assert.assertEquals(name.toString(), actualRequest.getName());
228     Assert.assertTrue(
229         channelProvider.isHeaderSent(
230             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
231             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
232   }
233 
234   @Test
listMonitoredResourceDescriptorsExceptionTest3()235   public void listMonitoredResourceDescriptorsExceptionTest3() throws Exception {
236     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
237     mockMetricService.addException(exception);
238 
239     try {
240       ProjectName name = ProjectName.of("[PROJECT]");
241       client.listMonitoredResourceDescriptors(name);
242       Assert.fail("No exception raised");
243     } catch (InvalidArgumentException e) {
244       // Expected exception.
245     }
246   }
247 
248   @Test
listMonitoredResourceDescriptorsTest4()249   public void listMonitoredResourceDescriptorsTest4() throws Exception {
250     MonitoredResourceDescriptor responsesElement = MonitoredResourceDescriptor.newBuilder().build();
251     ListMonitoredResourceDescriptorsResponse expectedResponse =
252         ListMonitoredResourceDescriptorsResponse.newBuilder()
253             .setNextPageToken("")
254             .addAllResourceDescriptors(Arrays.asList(responsesElement))
255             .build();
256     mockMetricService.addResponse(expectedResponse);
257 
258     String name = "name3373707";
259 
260     ListMonitoredResourceDescriptorsPagedResponse pagedListResponse =
261         client.listMonitoredResourceDescriptors(name);
262 
263     List<MonitoredResourceDescriptor> resources =
264         Lists.newArrayList(pagedListResponse.iterateAll());
265 
266     Assert.assertEquals(1, resources.size());
267     Assert.assertEquals(expectedResponse.getResourceDescriptorsList().get(0), resources.get(0));
268 
269     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
270     Assert.assertEquals(1, actualRequests.size());
271     ListMonitoredResourceDescriptorsRequest actualRequest =
272         ((ListMonitoredResourceDescriptorsRequest) actualRequests.get(0));
273 
274     Assert.assertEquals(name, actualRequest.getName());
275     Assert.assertTrue(
276         channelProvider.isHeaderSent(
277             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
278             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
279   }
280 
281   @Test
listMonitoredResourceDescriptorsExceptionTest4()282   public void listMonitoredResourceDescriptorsExceptionTest4() throws Exception {
283     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
284     mockMetricService.addException(exception);
285 
286     try {
287       String name = "name3373707";
288       client.listMonitoredResourceDescriptors(name);
289       Assert.fail("No exception raised");
290     } catch (InvalidArgumentException e) {
291       // Expected exception.
292     }
293   }
294 
295   @Test
getMonitoredResourceDescriptorTest()296   public void getMonitoredResourceDescriptorTest() throws Exception {
297     MonitoredResourceDescriptor expectedResponse =
298         MonitoredResourceDescriptor.newBuilder()
299             .setName("name3373707")
300             .setType("type3575610")
301             .setDisplayName("displayName1714148973")
302             .setDescription("description-1724546052")
303             .addAllLabels(new ArrayList<LabelDescriptor>())
304             .setLaunchStage(LaunchStage.forNumber(0))
305             .build();
306     mockMetricService.addResponse(expectedResponse);
307 
308     MonitoredResourceDescriptorName name =
309         MonitoredResourceDescriptorName.ofProjectMonitoredResourceDescriptorName(
310             "[PROJECT]", "[MONITORED_RESOURCE_DESCRIPTOR]");
311 
312     MonitoredResourceDescriptor actualResponse = client.getMonitoredResourceDescriptor(name);
313     Assert.assertEquals(expectedResponse, actualResponse);
314 
315     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
316     Assert.assertEquals(1, actualRequests.size());
317     GetMonitoredResourceDescriptorRequest actualRequest =
318         ((GetMonitoredResourceDescriptorRequest) actualRequests.get(0));
319 
320     Assert.assertEquals(name.toString(), actualRequest.getName());
321     Assert.assertTrue(
322         channelProvider.isHeaderSent(
323             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
324             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
325   }
326 
327   @Test
getMonitoredResourceDescriptorExceptionTest()328   public void getMonitoredResourceDescriptorExceptionTest() throws Exception {
329     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
330     mockMetricService.addException(exception);
331 
332     try {
333       MonitoredResourceDescriptorName name =
334           MonitoredResourceDescriptorName.ofProjectMonitoredResourceDescriptorName(
335               "[PROJECT]", "[MONITORED_RESOURCE_DESCRIPTOR]");
336       client.getMonitoredResourceDescriptor(name);
337       Assert.fail("No exception raised");
338     } catch (InvalidArgumentException e) {
339       // Expected exception.
340     }
341   }
342 
343   @Test
getMonitoredResourceDescriptorTest2()344   public void getMonitoredResourceDescriptorTest2() throws Exception {
345     MonitoredResourceDescriptor expectedResponse =
346         MonitoredResourceDescriptor.newBuilder()
347             .setName("name3373707")
348             .setType("type3575610")
349             .setDisplayName("displayName1714148973")
350             .setDescription("description-1724546052")
351             .addAllLabels(new ArrayList<LabelDescriptor>())
352             .setLaunchStage(LaunchStage.forNumber(0))
353             .build();
354     mockMetricService.addResponse(expectedResponse);
355 
356     String name = "name3373707";
357 
358     MonitoredResourceDescriptor actualResponse = client.getMonitoredResourceDescriptor(name);
359     Assert.assertEquals(expectedResponse, actualResponse);
360 
361     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
362     Assert.assertEquals(1, actualRequests.size());
363     GetMonitoredResourceDescriptorRequest actualRequest =
364         ((GetMonitoredResourceDescriptorRequest) actualRequests.get(0));
365 
366     Assert.assertEquals(name, actualRequest.getName());
367     Assert.assertTrue(
368         channelProvider.isHeaderSent(
369             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
370             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
371   }
372 
373   @Test
getMonitoredResourceDescriptorExceptionTest2()374   public void getMonitoredResourceDescriptorExceptionTest2() throws Exception {
375     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
376     mockMetricService.addException(exception);
377 
378     try {
379       String name = "name3373707";
380       client.getMonitoredResourceDescriptor(name);
381       Assert.fail("No exception raised");
382     } catch (InvalidArgumentException e) {
383       // Expected exception.
384     }
385   }
386 
387   @Test
listMetricDescriptorsTest()388   public void listMetricDescriptorsTest() throws Exception {
389     MetricDescriptor responsesElement = MetricDescriptor.newBuilder().build();
390     ListMetricDescriptorsResponse expectedResponse =
391         ListMetricDescriptorsResponse.newBuilder()
392             .setNextPageToken("")
393             .addAllMetricDescriptors(Arrays.asList(responsesElement))
394             .build();
395     mockMetricService.addResponse(expectedResponse);
396 
397     FolderName name = FolderName.of("[FOLDER]");
398 
399     ListMetricDescriptorsPagedResponse pagedListResponse = client.listMetricDescriptors(name);
400 
401     List<MetricDescriptor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
402 
403     Assert.assertEquals(1, resources.size());
404     Assert.assertEquals(expectedResponse.getMetricDescriptorsList().get(0), resources.get(0));
405 
406     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
407     Assert.assertEquals(1, actualRequests.size());
408     ListMetricDescriptorsRequest actualRequest =
409         ((ListMetricDescriptorsRequest) actualRequests.get(0));
410 
411     Assert.assertEquals(name.toString(), actualRequest.getName());
412     Assert.assertTrue(
413         channelProvider.isHeaderSent(
414             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
415             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
416   }
417 
418   @Test
listMetricDescriptorsExceptionTest()419   public void listMetricDescriptorsExceptionTest() throws Exception {
420     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
421     mockMetricService.addException(exception);
422 
423     try {
424       FolderName name = FolderName.of("[FOLDER]");
425       client.listMetricDescriptors(name);
426       Assert.fail("No exception raised");
427     } catch (InvalidArgumentException e) {
428       // Expected exception.
429     }
430   }
431 
432   @Test
listMetricDescriptorsTest2()433   public void listMetricDescriptorsTest2() throws Exception {
434     MetricDescriptor responsesElement = MetricDescriptor.newBuilder().build();
435     ListMetricDescriptorsResponse expectedResponse =
436         ListMetricDescriptorsResponse.newBuilder()
437             .setNextPageToken("")
438             .addAllMetricDescriptors(Arrays.asList(responsesElement))
439             .build();
440     mockMetricService.addResponse(expectedResponse);
441 
442     OrganizationName name = OrganizationName.of("[ORGANIZATION]");
443 
444     ListMetricDescriptorsPagedResponse pagedListResponse = client.listMetricDescriptors(name);
445 
446     List<MetricDescriptor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
447 
448     Assert.assertEquals(1, resources.size());
449     Assert.assertEquals(expectedResponse.getMetricDescriptorsList().get(0), resources.get(0));
450 
451     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
452     Assert.assertEquals(1, actualRequests.size());
453     ListMetricDescriptorsRequest actualRequest =
454         ((ListMetricDescriptorsRequest) actualRequests.get(0));
455 
456     Assert.assertEquals(name.toString(), actualRequest.getName());
457     Assert.assertTrue(
458         channelProvider.isHeaderSent(
459             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
460             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
461   }
462 
463   @Test
listMetricDescriptorsExceptionTest2()464   public void listMetricDescriptorsExceptionTest2() throws Exception {
465     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
466     mockMetricService.addException(exception);
467 
468     try {
469       OrganizationName name = OrganizationName.of("[ORGANIZATION]");
470       client.listMetricDescriptors(name);
471       Assert.fail("No exception raised");
472     } catch (InvalidArgumentException e) {
473       // Expected exception.
474     }
475   }
476 
477   @Test
listMetricDescriptorsTest3()478   public void listMetricDescriptorsTest3() throws Exception {
479     MetricDescriptor responsesElement = MetricDescriptor.newBuilder().build();
480     ListMetricDescriptorsResponse expectedResponse =
481         ListMetricDescriptorsResponse.newBuilder()
482             .setNextPageToken("")
483             .addAllMetricDescriptors(Arrays.asList(responsesElement))
484             .build();
485     mockMetricService.addResponse(expectedResponse);
486 
487     ProjectName name = ProjectName.of("[PROJECT]");
488 
489     ListMetricDescriptorsPagedResponse pagedListResponse = client.listMetricDescriptors(name);
490 
491     List<MetricDescriptor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
492 
493     Assert.assertEquals(1, resources.size());
494     Assert.assertEquals(expectedResponse.getMetricDescriptorsList().get(0), resources.get(0));
495 
496     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
497     Assert.assertEquals(1, actualRequests.size());
498     ListMetricDescriptorsRequest actualRequest =
499         ((ListMetricDescriptorsRequest) actualRequests.get(0));
500 
501     Assert.assertEquals(name.toString(), actualRequest.getName());
502     Assert.assertTrue(
503         channelProvider.isHeaderSent(
504             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
505             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
506   }
507 
508   @Test
listMetricDescriptorsExceptionTest3()509   public void listMetricDescriptorsExceptionTest3() throws Exception {
510     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
511     mockMetricService.addException(exception);
512 
513     try {
514       ProjectName name = ProjectName.of("[PROJECT]");
515       client.listMetricDescriptors(name);
516       Assert.fail("No exception raised");
517     } catch (InvalidArgumentException e) {
518       // Expected exception.
519     }
520   }
521 
522   @Test
listMetricDescriptorsTest4()523   public void listMetricDescriptorsTest4() throws Exception {
524     MetricDescriptor responsesElement = MetricDescriptor.newBuilder().build();
525     ListMetricDescriptorsResponse expectedResponse =
526         ListMetricDescriptorsResponse.newBuilder()
527             .setNextPageToken("")
528             .addAllMetricDescriptors(Arrays.asList(responsesElement))
529             .build();
530     mockMetricService.addResponse(expectedResponse);
531 
532     String name = "name3373707";
533 
534     ListMetricDescriptorsPagedResponse pagedListResponse = client.listMetricDescriptors(name);
535 
536     List<MetricDescriptor> resources = Lists.newArrayList(pagedListResponse.iterateAll());
537 
538     Assert.assertEquals(1, resources.size());
539     Assert.assertEquals(expectedResponse.getMetricDescriptorsList().get(0), resources.get(0));
540 
541     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
542     Assert.assertEquals(1, actualRequests.size());
543     ListMetricDescriptorsRequest actualRequest =
544         ((ListMetricDescriptorsRequest) actualRequests.get(0));
545 
546     Assert.assertEquals(name, actualRequest.getName());
547     Assert.assertTrue(
548         channelProvider.isHeaderSent(
549             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
550             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
551   }
552 
553   @Test
listMetricDescriptorsExceptionTest4()554   public void listMetricDescriptorsExceptionTest4() throws Exception {
555     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
556     mockMetricService.addException(exception);
557 
558     try {
559       String name = "name3373707";
560       client.listMetricDescriptors(name);
561       Assert.fail("No exception raised");
562     } catch (InvalidArgumentException e) {
563       // Expected exception.
564     }
565   }
566 
567   @Test
getMetricDescriptorTest()568   public void getMetricDescriptorTest() throws Exception {
569     MetricDescriptor expectedResponse =
570         MetricDescriptor.newBuilder()
571             .setName("name3373707")
572             .setType("type3575610")
573             .addAllLabels(new ArrayList<LabelDescriptor>())
574             .setUnit("unit3594628")
575             .setDescription("description-1724546052")
576             .setDisplayName("displayName1714148973")
577             .setMetadata(MetricDescriptor.MetricDescriptorMetadata.newBuilder().build())
578             .setLaunchStage(LaunchStage.forNumber(0))
579             .addAllMonitoredResourceTypes(new ArrayList<String>())
580             .build();
581     mockMetricService.addResponse(expectedResponse);
582 
583     MetricDescriptorName name =
584         MetricDescriptorName.ofProjectMetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]");
585 
586     MetricDescriptor actualResponse = client.getMetricDescriptor(name);
587     Assert.assertEquals(expectedResponse, actualResponse);
588 
589     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
590     Assert.assertEquals(1, actualRequests.size());
591     GetMetricDescriptorRequest actualRequest = ((GetMetricDescriptorRequest) actualRequests.get(0));
592 
593     Assert.assertEquals(name.toString(), actualRequest.getName());
594     Assert.assertTrue(
595         channelProvider.isHeaderSent(
596             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
597             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
598   }
599 
600   @Test
getMetricDescriptorExceptionTest()601   public void getMetricDescriptorExceptionTest() throws Exception {
602     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
603     mockMetricService.addException(exception);
604 
605     try {
606       MetricDescriptorName name =
607           MetricDescriptorName.ofProjectMetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]");
608       client.getMetricDescriptor(name);
609       Assert.fail("No exception raised");
610     } catch (InvalidArgumentException e) {
611       // Expected exception.
612     }
613   }
614 
615   @Test
getMetricDescriptorTest2()616   public void getMetricDescriptorTest2() throws Exception {
617     MetricDescriptor expectedResponse =
618         MetricDescriptor.newBuilder()
619             .setName("name3373707")
620             .setType("type3575610")
621             .addAllLabels(new ArrayList<LabelDescriptor>())
622             .setUnit("unit3594628")
623             .setDescription("description-1724546052")
624             .setDisplayName("displayName1714148973")
625             .setMetadata(MetricDescriptor.MetricDescriptorMetadata.newBuilder().build())
626             .setLaunchStage(LaunchStage.forNumber(0))
627             .addAllMonitoredResourceTypes(new ArrayList<String>())
628             .build();
629     mockMetricService.addResponse(expectedResponse);
630 
631     String name = "name3373707";
632 
633     MetricDescriptor actualResponse = client.getMetricDescriptor(name);
634     Assert.assertEquals(expectedResponse, actualResponse);
635 
636     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
637     Assert.assertEquals(1, actualRequests.size());
638     GetMetricDescriptorRequest actualRequest = ((GetMetricDescriptorRequest) actualRequests.get(0));
639 
640     Assert.assertEquals(name, actualRequest.getName());
641     Assert.assertTrue(
642         channelProvider.isHeaderSent(
643             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
644             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
645   }
646 
647   @Test
getMetricDescriptorExceptionTest2()648   public void getMetricDescriptorExceptionTest2() throws Exception {
649     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
650     mockMetricService.addException(exception);
651 
652     try {
653       String name = "name3373707";
654       client.getMetricDescriptor(name);
655       Assert.fail("No exception raised");
656     } catch (InvalidArgumentException e) {
657       // Expected exception.
658     }
659   }
660 
661   @Test
createMetricDescriptorTest()662   public void createMetricDescriptorTest() throws Exception {
663     MetricDescriptor expectedResponse =
664         MetricDescriptor.newBuilder()
665             .setName("name3373707")
666             .setType("type3575610")
667             .addAllLabels(new ArrayList<LabelDescriptor>())
668             .setUnit("unit3594628")
669             .setDescription("description-1724546052")
670             .setDisplayName("displayName1714148973")
671             .setMetadata(MetricDescriptor.MetricDescriptorMetadata.newBuilder().build())
672             .setLaunchStage(LaunchStage.forNumber(0))
673             .addAllMonitoredResourceTypes(new ArrayList<String>())
674             .build();
675     mockMetricService.addResponse(expectedResponse);
676 
677     FolderName name = FolderName.of("[FOLDER]");
678     MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
679 
680     MetricDescriptor actualResponse = client.createMetricDescriptor(name, metricDescriptor);
681     Assert.assertEquals(expectedResponse, actualResponse);
682 
683     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
684     Assert.assertEquals(1, actualRequests.size());
685     CreateMetricDescriptorRequest actualRequest =
686         ((CreateMetricDescriptorRequest) actualRequests.get(0));
687 
688     Assert.assertEquals(name.toString(), actualRequest.getName());
689     Assert.assertEquals(metricDescriptor, actualRequest.getMetricDescriptor());
690     Assert.assertTrue(
691         channelProvider.isHeaderSent(
692             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
693             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
694   }
695 
696   @Test
createMetricDescriptorExceptionTest()697   public void createMetricDescriptorExceptionTest() throws Exception {
698     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
699     mockMetricService.addException(exception);
700 
701     try {
702       FolderName name = FolderName.of("[FOLDER]");
703       MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
704       client.createMetricDescriptor(name, metricDescriptor);
705       Assert.fail("No exception raised");
706     } catch (InvalidArgumentException e) {
707       // Expected exception.
708     }
709   }
710 
711   @Test
createMetricDescriptorTest2()712   public void createMetricDescriptorTest2() throws Exception {
713     MetricDescriptor expectedResponse =
714         MetricDescriptor.newBuilder()
715             .setName("name3373707")
716             .setType("type3575610")
717             .addAllLabels(new ArrayList<LabelDescriptor>())
718             .setUnit("unit3594628")
719             .setDescription("description-1724546052")
720             .setDisplayName("displayName1714148973")
721             .setMetadata(MetricDescriptor.MetricDescriptorMetadata.newBuilder().build())
722             .setLaunchStage(LaunchStage.forNumber(0))
723             .addAllMonitoredResourceTypes(new ArrayList<String>())
724             .build();
725     mockMetricService.addResponse(expectedResponse);
726 
727     OrganizationName name = OrganizationName.of("[ORGANIZATION]");
728     MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
729 
730     MetricDescriptor actualResponse = client.createMetricDescriptor(name, metricDescriptor);
731     Assert.assertEquals(expectedResponse, actualResponse);
732 
733     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
734     Assert.assertEquals(1, actualRequests.size());
735     CreateMetricDescriptorRequest actualRequest =
736         ((CreateMetricDescriptorRequest) actualRequests.get(0));
737 
738     Assert.assertEquals(name.toString(), actualRequest.getName());
739     Assert.assertEquals(metricDescriptor, actualRequest.getMetricDescriptor());
740     Assert.assertTrue(
741         channelProvider.isHeaderSent(
742             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
743             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
744   }
745 
746   @Test
createMetricDescriptorExceptionTest2()747   public void createMetricDescriptorExceptionTest2() throws Exception {
748     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
749     mockMetricService.addException(exception);
750 
751     try {
752       OrganizationName name = OrganizationName.of("[ORGANIZATION]");
753       MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
754       client.createMetricDescriptor(name, metricDescriptor);
755       Assert.fail("No exception raised");
756     } catch (InvalidArgumentException e) {
757       // Expected exception.
758     }
759   }
760 
761   @Test
createMetricDescriptorTest3()762   public void createMetricDescriptorTest3() throws Exception {
763     MetricDescriptor expectedResponse =
764         MetricDescriptor.newBuilder()
765             .setName("name3373707")
766             .setType("type3575610")
767             .addAllLabels(new ArrayList<LabelDescriptor>())
768             .setUnit("unit3594628")
769             .setDescription("description-1724546052")
770             .setDisplayName("displayName1714148973")
771             .setMetadata(MetricDescriptor.MetricDescriptorMetadata.newBuilder().build())
772             .setLaunchStage(LaunchStage.forNumber(0))
773             .addAllMonitoredResourceTypes(new ArrayList<String>())
774             .build();
775     mockMetricService.addResponse(expectedResponse);
776 
777     ProjectName name = ProjectName.of("[PROJECT]");
778     MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
779 
780     MetricDescriptor actualResponse = client.createMetricDescriptor(name, metricDescriptor);
781     Assert.assertEquals(expectedResponse, actualResponse);
782 
783     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
784     Assert.assertEquals(1, actualRequests.size());
785     CreateMetricDescriptorRequest actualRequest =
786         ((CreateMetricDescriptorRequest) actualRequests.get(0));
787 
788     Assert.assertEquals(name.toString(), actualRequest.getName());
789     Assert.assertEquals(metricDescriptor, actualRequest.getMetricDescriptor());
790     Assert.assertTrue(
791         channelProvider.isHeaderSent(
792             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
793             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
794   }
795 
796   @Test
createMetricDescriptorExceptionTest3()797   public void createMetricDescriptorExceptionTest3() throws Exception {
798     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
799     mockMetricService.addException(exception);
800 
801     try {
802       ProjectName name = ProjectName.of("[PROJECT]");
803       MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
804       client.createMetricDescriptor(name, metricDescriptor);
805       Assert.fail("No exception raised");
806     } catch (InvalidArgumentException e) {
807       // Expected exception.
808     }
809   }
810 
811   @Test
createMetricDescriptorTest4()812   public void createMetricDescriptorTest4() throws Exception {
813     MetricDescriptor expectedResponse =
814         MetricDescriptor.newBuilder()
815             .setName("name3373707")
816             .setType("type3575610")
817             .addAllLabels(new ArrayList<LabelDescriptor>())
818             .setUnit("unit3594628")
819             .setDescription("description-1724546052")
820             .setDisplayName("displayName1714148973")
821             .setMetadata(MetricDescriptor.MetricDescriptorMetadata.newBuilder().build())
822             .setLaunchStage(LaunchStage.forNumber(0))
823             .addAllMonitoredResourceTypes(new ArrayList<String>())
824             .build();
825     mockMetricService.addResponse(expectedResponse);
826 
827     String name = "name3373707";
828     MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
829 
830     MetricDescriptor actualResponse = client.createMetricDescriptor(name, metricDescriptor);
831     Assert.assertEquals(expectedResponse, actualResponse);
832 
833     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
834     Assert.assertEquals(1, actualRequests.size());
835     CreateMetricDescriptorRequest actualRequest =
836         ((CreateMetricDescriptorRequest) actualRequests.get(0));
837 
838     Assert.assertEquals(name, actualRequest.getName());
839     Assert.assertEquals(metricDescriptor, actualRequest.getMetricDescriptor());
840     Assert.assertTrue(
841         channelProvider.isHeaderSent(
842             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
843             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
844   }
845 
846   @Test
createMetricDescriptorExceptionTest4()847   public void createMetricDescriptorExceptionTest4() throws Exception {
848     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
849     mockMetricService.addException(exception);
850 
851     try {
852       String name = "name3373707";
853       MetricDescriptor metricDescriptor = MetricDescriptor.newBuilder().build();
854       client.createMetricDescriptor(name, metricDescriptor);
855       Assert.fail("No exception raised");
856     } catch (InvalidArgumentException e) {
857       // Expected exception.
858     }
859   }
860 
861   @Test
deleteMetricDescriptorTest()862   public void deleteMetricDescriptorTest() throws Exception {
863     Empty expectedResponse = Empty.newBuilder().build();
864     mockMetricService.addResponse(expectedResponse);
865 
866     MetricDescriptorName name =
867         MetricDescriptorName.ofProjectMetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]");
868 
869     client.deleteMetricDescriptor(name);
870 
871     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
872     Assert.assertEquals(1, actualRequests.size());
873     DeleteMetricDescriptorRequest actualRequest =
874         ((DeleteMetricDescriptorRequest) actualRequests.get(0));
875 
876     Assert.assertEquals(name.toString(), actualRequest.getName());
877     Assert.assertTrue(
878         channelProvider.isHeaderSent(
879             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
880             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
881   }
882 
883   @Test
deleteMetricDescriptorExceptionTest()884   public void deleteMetricDescriptorExceptionTest() throws Exception {
885     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
886     mockMetricService.addException(exception);
887 
888     try {
889       MetricDescriptorName name =
890           MetricDescriptorName.ofProjectMetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]");
891       client.deleteMetricDescriptor(name);
892       Assert.fail("No exception raised");
893     } catch (InvalidArgumentException e) {
894       // Expected exception.
895     }
896   }
897 
898   @Test
deleteMetricDescriptorTest2()899   public void deleteMetricDescriptorTest2() throws Exception {
900     Empty expectedResponse = Empty.newBuilder().build();
901     mockMetricService.addResponse(expectedResponse);
902 
903     String name = "name3373707";
904 
905     client.deleteMetricDescriptor(name);
906 
907     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
908     Assert.assertEquals(1, actualRequests.size());
909     DeleteMetricDescriptorRequest actualRequest =
910         ((DeleteMetricDescriptorRequest) actualRequests.get(0));
911 
912     Assert.assertEquals(name, actualRequest.getName());
913     Assert.assertTrue(
914         channelProvider.isHeaderSent(
915             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
916             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
917   }
918 
919   @Test
deleteMetricDescriptorExceptionTest2()920   public void deleteMetricDescriptorExceptionTest2() throws Exception {
921     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
922     mockMetricService.addException(exception);
923 
924     try {
925       String name = "name3373707";
926       client.deleteMetricDescriptor(name);
927       Assert.fail("No exception raised");
928     } catch (InvalidArgumentException e) {
929       // Expected exception.
930     }
931   }
932 
933   @Test
listTimeSeriesTest()934   public void listTimeSeriesTest() throws Exception {
935     TimeSeries responsesElement = TimeSeries.newBuilder().build();
936     ListTimeSeriesResponse expectedResponse =
937         ListTimeSeriesResponse.newBuilder()
938             .setNextPageToken("")
939             .addAllTimeSeries(Arrays.asList(responsesElement))
940             .build();
941     mockMetricService.addResponse(expectedResponse);
942 
943     FolderName name = FolderName.of("[FOLDER]");
944     String filter = "filter-1274492040";
945     TimeInterval interval = TimeInterval.newBuilder().build();
946     ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
947 
948     ListTimeSeriesPagedResponse pagedListResponse =
949         client.listTimeSeries(name, filter, interval, view);
950 
951     List<TimeSeries> resources = Lists.newArrayList(pagedListResponse.iterateAll());
952 
953     Assert.assertEquals(1, resources.size());
954     Assert.assertEquals(expectedResponse.getTimeSeriesList().get(0), resources.get(0));
955 
956     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
957     Assert.assertEquals(1, actualRequests.size());
958     ListTimeSeriesRequest actualRequest = ((ListTimeSeriesRequest) actualRequests.get(0));
959 
960     Assert.assertEquals(name.toString(), actualRequest.getName());
961     Assert.assertEquals(filter, actualRequest.getFilter());
962     Assert.assertEquals(interval, actualRequest.getInterval());
963     Assert.assertEquals(view, actualRequest.getView());
964     Assert.assertTrue(
965         channelProvider.isHeaderSent(
966             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
967             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
968   }
969 
970   @Test
listTimeSeriesExceptionTest()971   public void listTimeSeriesExceptionTest() throws Exception {
972     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
973     mockMetricService.addException(exception);
974 
975     try {
976       FolderName name = FolderName.of("[FOLDER]");
977       String filter = "filter-1274492040";
978       TimeInterval interval = TimeInterval.newBuilder().build();
979       ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
980       client.listTimeSeries(name, filter, interval, view);
981       Assert.fail("No exception raised");
982     } catch (InvalidArgumentException e) {
983       // Expected exception.
984     }
985   }
986 
987   @Test
listTimeSeriesTest2()988   public void listTimeSeriesTest2() throws Exception {
989     TimeSeries responsesElement = TimeSeries.newBuilder().build();
990     ListTimeSeriesResponse expectedResponse =
991         ListTimeSeriesResponse.newBuilder()
992             .setNextPageToken("")
993             .addAllTimeSeries(Arrays.asList(responsesElement))
994             .build();
995     mockMetricService.addResponse(expectedResponse);
996 
997     OrganizationName name = OrganizationName.of("[ORGANIZATION]");
998     String filter = "filter-1274492040";
999     TimeInterval interval = TimeInterval.newBuilder().build();
1000     ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
1001 
1002     ListTimeSeriesPagedResponse pagedListResponse =
1003         client.listTimeSeries(name, filter, interval, view);
1004 
1005     List<TimeSeries> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1006 
1007     Assert.assertEquals(1, resources.size());
1008     Assert.assertEquals(expectedResponse.getTimeSeriesList().get(0), resources.get(0));
1009 
1010     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
1011     Assert.assertEquals(1, actualRequests.size());
1012     ListTimeSeriesRequest actualRequest = ((ListTimeSeriesRequest) actualRequests.get(0));
1013 
1014     Assert.assertEquals(name.toString(), actualRequest.getName());
1015     Assert.assertEquals(filter, actualRequest.getFilter());
1016     Assert.assertEquals(interval, actualRequest.getInterval());
1017     Assert.assertEquals(view, actualRequest.getView());
1018     Assert.assertTrue(
1019         channelProvider.isHeaderSent(
1020             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1021             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1022   }
1023 
1024   @Test
listTimeSeriesExceptionTest2()1025   public void listTimeSeriesExceptionTest2() throws Exception {
1026     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1027     mockMetricService.addException(exception);
1028 
1029     try {
1030       OrganizationName name = OrganizationName.of("[ORGANIZATION]");
1031       String filter = "filter-1274492040";
1032       TimeInterval interval = TimeInterval.newBuilder().build();
1033       ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
1034       client.listTimeSeries(name, filter, interval, view);
1035       Assert.fail("No exception raised");
1036     } catch (InvalidArgumentException e) {
1037       // Expected exception.
1038     }
1039   }
1040 
1041   @Test
listTimeSeriesTest3()1042   public void listTimeSeriesTest3() throws Exception {
1043     TimeSeries responsesElement = TimeSeries.newBuilder().build();
1044     ListTimeSeriesResponse expectedResponse =
1045         ListTimeSeriesResponse.newBuilder()
1046             .setNextPageToken("")
1047             .addAllTimeSeries(Arrays.asList(responsesElement))
1048             .build();
1049     mockMetricService.addResponse(expectedResponse);
1050 
1051     ProjectName name = ProjectName.of("[PROJECT]");
1052     String filter = "filter-1274492040";
1053     TimeInterval interval = TimeInterval.newBuilder().build();
1054     ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
1055 
1056     ListTimeSeriesPagedResponse pagedListResponse =
1057         client.listTimeSeries(name, filter, interval, view);
1058 
1059     List<TimeSeries> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1060 
1061     Assert.assertEquals(1, resources.size());
1062     Assert.assertEquals(expectedResponse.getTimeSeriesList().get(0), resources.get(0));
1063 
1064     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
1065     Assert.assertEquals(1, actualRequests.size());
1066     ListTimeSeriesRequest actualRequest = ((ListTimeSeriesRequest) actualRequests.get(0));
1067 
1068     Assert.assertEquals(name.toString(), actualRequest.getName());
1069     Assert.assertEquals(filter, actualRequest.getFilter());
1070     Assert.assertEquals(interval, actualRequest.getInterval());
1071     Assert.assertEquals(view, actualRequest.getView());
1072     Assert.assertTrue(
1073         channelProvider.isHeaderSent(
1074             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1075             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1076   }
1077 
1078   @Test
listTimeSeriesExceptionTest3()1079   public void listTimeSeriesExceptionTest3() throws Exception {
1080     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1081     mockMetricService.addException(exception);
1082 
1083     try {
1084       ProjectName name = ProjectName.of("[PROJECT]");
1085       String filter = "filter-1274492040";
1086       TimeInterval interval = TimeInterval.newBuilder().build();
1087       ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
1088       client.listTimeSeries(name, filter, interval, view);
1089       Assert.fail("No exception raised");
1090     } catch (InvalidArgumentException e) {
1091       // Expected exception.
1092     }
1093   }
1094 
1095   @Test
listTimeSeriesTest4()1096   public void listTimeSeriesTest4() throws Exception {
1097     TimeSeries responsesElement = TimeSeries.newBuilder().build();
1098     ListTimeSeriesResponse expectedResponse =
1099         ListTimeSeriesResponse.newBuilder()
1100             .setNextPageToken("")
1101             .addAllTimeSeries(Arrays.asList(responsesElement))
1102             .build();
1103     mockMetricService.addResponse(expectedResponse);
1104 
1105     String name = "name3373707";
1106     String filter = "filter-1274492040";
1107     TimeInterval interval = TimeInterval.newBuilder().build();
1108     ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
1109 
1110     ListTimeSeriesPagedResponse pagedListResponse =
1111         client.listTimeSeries(name, filter, interval, view);
1112 
1113     List<TimeSeries> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1114 
1115     Assert.assertEquals(1, resources.size());
1116     Assert.assertEquals(expectedResponse.getTimeSeriesList().get(0), resources.get(0));
1117 
1118     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
1119     Assert.assertEquals(1, actualRequests.size());
1120     ListTimeSeriesRequest actualRequest = ((ListTimeSeriesRequest) actualRequests.get(0));
1121 
1122     Assert.assertEquals(name, actualRequest.getName());
1123     Assert.assertEquals(filter, actualRequest.getFilter());
1124     Assert.assertEquals(interval, actualRequest.getInterval());
1125     Assert.assertEquals(view, actualRequest.getView());
1126     Assert.assertTrue(
1127         channelProvider.isHeaderSent(
1128             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1129             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1130   }
1131 
1132   @Test
listTimeSeriesExceptionTest4()1133   public void listTimeSeriesExceptionTest4() throws Exception {
1134     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1135     mockMetricService.addException(exception);
1136 
1137     try {
1138       String name = "name3373707";
1139       String filter = "filter-1274492040";
1140       TimeInterval interval = TimeInterval.newBuilder().build();
1141       ListTimeSeriesRequest.TimeSeriesView view = ListTimeSeriesRequest.TimeSeriesView.forNumber(0);
1142       client.listTimeSeries(name, filter, interval, view);
1143       Assert.fail("No exception raised");
1144     } catch (InvalidArgumentException e) {
1145       // Expected exception.
1146     }
1147   }
1148 
1149   @Test
createTimeSeriesTest()1150   public void createTimeSeriesTest() throws Exception {
1151     Empty expectedResponse = Empty.newBuilder().build();
1152     mockMetricService.addResponse(expectedResponse);
1153 
1154     ProjectName name = ProjectName.of("[PROJECT]");
1155     List<TimeSeries> timeSeries = new ArrayList<>();
1156 
1157     client.createTimeSeries(name, timeSeries);
1158 
1159     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
1160     Assert.assertEquals(1, actualRequests.size());
1161     CreateTimeSeriesRequest actualRequest = ((CreateTimeSeriesRequest) actualRequests.get(0));
1162 
1163     Assert.assertEquals(name.toString(), actualRequest.getName());
1164     Assert.assertEquals(timeSeries, actualRequest.getTimeSeriesList());
1165     Assert.assertTrue(
1166         channelProvider.isHeaderSent(
1167             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1168             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1169   }
1170 
1171   @Test
createTimeSeriesExceptionTest()1172   public void createTimeSeriesExceptionTest() throws Exception {
1173     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1174     mockMetricService.addException(exception);
1175 
1176     try {
1177       ProjectName name = ProjectName.of("[PROJECT]");
1178       List<TimeSeries> timeSeries = new ArrayList<>();
1179       client.createTimeSeries(name, timeSeries);
1180       Assert.fail("No exception raised");
1181     } catch (InvalidArgumentException e) {
1182       // Expected exception.
1183     }
1184   }
1185 
1186   @Test
createTimeSeriesTest2()1187   public void createTimeSeriesTest2() throws Exception {
1188     Empty expectedResponse = Empty.newBuilder().build();
1189     mockMetricService.addResponse(expectedResponse);
1190 
1191     String name = "name3373707";
1192     List<TimeSeries> timeSeries = new ArrayList<>();
1193 
1194     client.createTimeSeries(name, timeSeries);
1195 
1196     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
1197     Assert.assertEquals(1, actualRequests.size());
1198     CreateTimeSeriesRequest actualRequest = ((CreateTimeSeriesRequest) actualRequests.get(0));
1199 
1200     Assert.assertEquals(name, actualRequest.getName());
1201     Assert.assertEquals(timeSeries, actualRequest.getTimeSeriesList());
1202     Assert.assertTrue(
1203         channelProvider.isHeaderSent(
1204             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1205             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1206   }
1207 
1208   @Test
createTimeSeriesExceptionTest2()1209   public void createTimeSeriesExceptionTest2() throws Exception {
1210     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1211     mockMetricService.addException(exception);
1212 
1213     try {
1214       String name = "name3373707";
1215       List<TimeSeries> timeSeries = new ArrayList<>();
1216       client.createTimeSeries(name, timeSeries);
1217       Assert.fail("No exception raised");
1218     } catch (InvalidArgumentException e) {
1219       // Expected exception.
1220     }
1221   }
1222 
1223   @Test
createServiceTimeSeriesTest()1224   public void createServiceTimeSeriesTest() throws Exception {
1225     Empty expectedResponse = Empty.newBuilder().build();
1226     mockMetricService.addResponse(expectedResponse);
1227 
1228     ProjectName name = ProjectName.of("[PROJECT]");
1229     List<TimeSeries> timeSeries = new ArrayList<>();
1230 
1231     client.createServiceTimeSeries(name, timeSeries);
1232 
1233     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
1234     Assert.assertEquals(1, actualRequests.size());
1235     CreateTimeSeriesRequest actualRequest = ((CreateTimeSeriesRequest) actualRequests.get(0));
1236 
1237     Assert.assertEquals(name.toString(), actualRequest.getName());
1238     Assert.assertEquals(timeSeries, actualRequest.getTimeSeriesList());
1239     Assert.assertTrue(
1240         channelProvider.isHeaderSent(
1241             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1242             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1243   }
1244 
1245   @Test
createServiceTimeSeriesExceptionTest()1246   public void createServiceTimeSeriesExceptionTest() throws Exception {
1247     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1248     mockMetricService.addException(exception);
1249 
1250     try {
1251       ProjectName name = ProjectName.of("[PROJECT]");
1252       List<TimeSeries> timeSeries = new ArrayList<>();
1253       client.createServiceTimeSeries(name, timeSeries);
1254       Assert.fail("No exception raised");
1255     } catch (InvalidArgumentException e) {
1256       // Expected exception.
1257     }
1258   }
1259 
1260   @Test
createServiceTimeSeriesTest2()1261   public void createServiceTimeSeriesTest2() throws Exception {
1262     Empty expectedResponse = Empty.newBuilder().build();
1263     mockMetricService.addResponse(expectedResponse);
1264 
1265     String name = "name3373707";
1266     List<TimeSeries> timeSeries = new ArrayList<>();
1267 
1268     client.createServiceTimeSeries(name, timeSeries);
1269 
1270     List<AbstractMessage> actualRequests = mockMetricService.getRequests();
1271     Assert.assertEquals(1, actualRequests.size());
1272     CreateTimeSeriesRequest actualRequest = ((CreateTimeSeriesRequest) actualRequests.get(0));
1273 
1274     Assert.assertEquals(name, actualRequest.getName());
1275     Assert.assertEquals(timeSeries, actualRequest.getTimeSeriesList());
1276     Assert.assertTrue(
1277         channelProvider.isHeaderSent(
1278             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1279             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1280   }
1281 
1282   @Test
createServiceTimeSeriesExceptionTest2()1283   public void createServiceTimeSeriesExceptionTest2() throws Exception {
1284     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1285     mockMetricService.addException(exception);
1286 
1287     try {
1288       String name = "name3373707";
1289       List<TimeSeries> timeSeries = new ArrayList<>();
1290       client.createServiceTimeSeries(name, timeSeries);
1291       Assert.fail("No exception raised");
1292     } catch (InvalidArgumentException e) {
1293       // Expected exception.
1294     }
1295   }
1296 }
1297