• 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.dataproc.v1;
18 
19 import static com.google.cloud.dataproc.v1.ClusterControllerClient.ListClustersPagedResponse;
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.api.gax.rpc.StatusCode;
29 import com.google.common.collect.Lists;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Any;
33 import com.google.protobuf.Empty;
34 import com.google.protobuf.FieldMask;
35 import io.grpc.StatusRuntimeException;
36 import java.io.IOException;
37 import java.util.ArrayList;
38 import java.util.Arrays;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.UUID;
42 import java.util.concurrent.ExecutionException;
43 import javax.annotation.Generated;
44 import org.junit.After;
45 import org.junit.AfterClass;
46 import org.junit.Assert;
47 import org.junit.Before;
48 import org.junit.BeforeClass;
49 import org.junit.Test;
50 
51 @Generated("by gapic-generator-java")
52 public class ClusterControllerClientTest {
53   private static MockClusterController mockClusterController;
54   private static MockServiceHelper mockServiceHelper;
55   private LocalChannelProvider channelProvider;
56   private ClusterControllerClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() {
60     mockClusterController = new MockClusterController();
61     mockServiceHelper =
62         new MockServiceHelper(
63             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockClusterController));
64     mockServiceHelper.start();
65   }
66 
67   @AfterClass
stopServer()68   public static void stopServer() {
69     mockServiceHelper.stop();
70   }
71 
72   @Before
setUp()73   public void setUp() throws IOException {
74     mockServiceHelper.reset();
75     channelProvider = mockServiceHelper.createChannelProvider();
76     ClusterControllerSettings settings =
77         ClusterControllerSettings.newBuilder()
78             .setTransportChannelProvider(channelProvider)
79             .setCredentialsProvider(NoCredentialsProvider.create())
80             .build();
81     client = ClusterControllerClient.create(settings);
82   }
83 
84   @After
tearDown()85   public void tearDown() throws Exception {
86     client.close();
87   }
88 
89   @Test
createClusterTest()90   public void createClusterTest() throws Exception {
91     Cluster expectedResponse =
92         Cluster.newBuilder()
93             .setProjectId("projectId-894832108")
94             .setClusterName("clusterName-1141738587")
95             .setConfig(ClusterConfig.newBuilder().build())
96             .setVirtualClusterConfig(VirtualClusterConfig.newBuilder().build())
97             .putAllLabels(new HashMap<String, String>())
98             .setStatus(ClusterStatus.newBuilder().build())
99             .addAllStatusHistory(new ArrayList<ClusterStatus>())
100             .setClusterUuid("clusterUuid-1141510955")
101             .setMetrics(ClusterMetrics.newBuilder().build())
102             .build();
103     Operation resultOperation =
104         Operation.newBuilder()
105             .setName("createClusterTest")
106             .setDone(true)
107             .setResponse(Any.pack(expectedResponse))
108             .build();
109     mockClusterController.addResponse(resultOperation);
110 
111     String projectId = "projectId-894832108";
112     String region = "region-934795532";
113     Cluster cluster = Cluster.newBuilder().build();
114 
115     Cluster actualResponse = client.createClusterAsync(projectId, region, cluster).get();
116     Assert.assertEquals(expectedResponse, actualResponse);
117 
118     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
119     Assert.assertEquals(1, actualRequests.size());
120     CreateClusterRequest actualRequest = ((CreateClusterRequest) actualRequests.get(0));
121 
122     Assert.assertEquals(projectId, actualRequest.getProjectId());
123     Assert.assertEquals(region, actualRequest.getRegion());
124     Assert.assertEquals(cluster, actualRequest.getCluster());
125     Assert.assertTrue(
126         channelProvider.isHeaderSent(
127             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
128             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
129   }
130 
131   @Test
createClusterExceptionTest()132   public void createClusterExceptionTest() throws Exception {
133     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
134     mockClusterController.addException(exception);
135 
136     try {
137       String projectId = "projectId-894832108";
138       String region = "region-934795532";
139       Cluster cluster = Cluster.newBuilder().build();
140       client.createClusterAsync(projectId, region, cluster).get();
141       Assert.fail("No exception raised");
142     } catch (ExecutionException e) {
143       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
144       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
145       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
146     }
147   }
148 
149   @Test
updateClusterTest()150   public void updateClusterTest() throws Exception {
151     Cluster expectedResponse =
152         Cluster.newBuilder()
153             .setProjectId("projectId-894832108")
154             .setClusterName("clusterName-1141738587")
155             .setConfig(ClusterConfig.newBuilder().build())
156             .setVirtualClusterConfig(VirtualClusterConfig.newBuilder().build())
157             .putAllLabels(new HashMap<String, String>())
158             .setStatus(ClusterStatus.newBuilder().build())
159             .addAllStatusHistory(new ArrayList<ClusterStatus>())
160             .setClusterUuid("clusterUuid-1141510955")
161             .setMetrics(ClusterMetrics.newBuilder().build())
162             .build();
163     Operation resultOperation =
164         Operation.newBuilder()
165             .setName("updateClusterTest")
166             .setDone(true)
167             .setResponse(Any.pack(expectedResponse))
168             .build();
169     mockClusterController.addResponse(resultOperation);
170 
171     String projectId = "projectId-894832108";
172     String region = "region-934795532";
173     String clusterName = "clusterName-1141738587";
174     Cluster cluster = Cluster.newBuilder().build();
175     FieldMask updateMask = FieldMask.newBuilder().build();
176 
177     Cluster actualResponse =
178         client.updateClusterAsync(projectId, region, clusterName, cluster, updateMask).get();
179     Assert.assertEquals(expectedResponse, actualResponse);
180 
181     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
182     Assert.assertEquals(1, actualRequests.size());
183     UpdateClusterRequest actualRequest = ((UpdateClusterRequest) actualRequests.get(0));
184 
185     Assert.assertEquals(projectId, actualRequest.getProjectId());
186     Assert.assertEquals(region, actualRequest.getRegion());
187     Assert.assertEquals(clusterName, actualRequest.getClusterName());
188     Assert.assertEquals(cluster, actualRequest.getCluster());
189     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
190     Assert.assertTrue(
191         channelProvider.isHeaderSent(
192             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
193             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
194   }
195 
196   @Test
updateClusterExceptionTest()197   public void updateClusterExceptionTest() throws Exception {
198     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
199     mockClusterController.addException(exception);
200 
201     try {
202       String projectId = "projectId-894832108";
203       String region = "region-934795532";
204       String clusterName = "clusterName-1141738587";
205       Cluster cluster = Cluster.newBuilder().build();
206       FieldMask updateMask = FieldMask.newBuilder().build();
207       client.updateClusterAsync(projectId, region, clusterName, cluster, updateMask).get();
208       Assert.fail("No exception raised");
209     } catch (ExecutionException e) {
210       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
211       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
212       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
213     }
214   }
215 
216   @Test
stopClusterTest()217   public void stopClusterTest() throws Exception {
218     Cluster expectedResponse =
219         Cluster.newBuilder()
220             .setProjectId("projectId-894832108")
221             .setClusterName("clusterName-1141738587")
222             .setConfig(ClusterConfig.newBuilder().build())
223             .setVirtualClusterConfig(VirtualClusterConfig.newBuilder().build())
224             .putAllLabels(new HashMap<String, String>())
225             .setStatus(ClusterStatus.newBuilder().build())
226             .addAllStatusHistory(new ArrayList<ClusterStatus>())
227             .setClusterUuid("clusterUuid-1141510955")
228             .setMetrics(ClusterMetrics.newBuilder().build())
229             .build();
230     Operation resultOperation =
231         Operation.newBuilder()
232             .setName("stopClusterTest")
233             .setDone(true)
234             .setResponse(Any.pack(expectedResponse))
235             .build();
236     mockClusterController.addResponse(resultOperation);
237 
238     StopClusterRequest request =
239         StopClusterRequest.newBuilder()
240             .setProjectId("projectId-894832108")
241             .setRegion("region-934795532")
242             .setClusterName("clusterName-1141738587")
243             .setClusterUuid("clusterUuid-1141510955")
244             .setRequestId("requestId693933066")
245             .build();
246 
247     Cluster actualResponse = client.stopClusterAsync(request).get();
248     Assert.assertEquals(expectedResponse, actualResponse);
249 
250     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
251     Assert.assertEquals(1, actualRequests.size());
252     StopClusterRequest actualRequest = ((StopClusterRequest) actualRequests.get(0));
253 
254     Assert.assertEquals(request.getProjectId(), actualRequest.getProjectId());
255     Assert.assertEquals(request.getRegion(), actualRequest.getRegion());
256     Assert.assertEquals(request.getClusterName(), actualRequest.getClusterName());
257     Assert.assertEquals(request.getClusterUuid(), actualRequest.getClusterUuid());
258     Assert.assertEquals(request.getRequestId(), actualRequest.getRequestId());
259     Assert.assertTrue(
260         channelProvider.isHeaderSent(
261             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
262             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
263   }
264 
265   @Test
stopClusterExceptionTest()266   public void stopClusterExceptionTest() throws Exception {
267     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
268     mockClusterController.addException(exception);
269 
270     try {
271       StopClusterRequest request =
272           StopClusterRequest.newBuilder()
273               .setProjectId("projectId-894832108")
274               .setRegion("region-934795532")
275               .setClusterName("clusterName-1141738587")
276               .setClusterUuid("clusterUuid-1141510955")
277               .setRequestId("requestId693933066")
278               .build();
279       client.stopClusterAsync(request).get();
280       Assert.fail("No exception raised");
281     } catch (ExecutionException e) {
282       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
283       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
284       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
285     }
286   }
287 
288   @Test
startClusterTest()289   public void startClusterTest() throws Exception {
290     Cluster expectedResponse =
291         Cluster.newBuilder()
292             .setProjectId("projectId-894832108")
293             .setClusterName("clusterName-1141738587")
294             .setConfig(ClusterConfig.newBuilder().build())
295             .setVirtualClusterConfig(VirtualClusterConfig.newBuilder().build())
296             .putAllLabels(new HashMap<String, String>())
297             .setStatus(ClusterStatus.newBuilder().build())
298             .addAllStatusHistory(new ArrayList<ClusterStatus>())
299             .setClusterUuid("clusterUuid-1141510955")
300             .setMetrics(ClusterMetrics.newBuilder().build())
301             .build();
302     Operation resultOperation =
303         Operation.newBuilder()
304             .setName("startClusterTest")
305             .setDone(true)
306             .setResponse(Any.pack(expectedResponse))
307             .build();
308     mockClusterController.addResponse(resultOperation);
309 
310     StartClusterRequest request =
311         StartClusterRequest.newBuilder()
312             .setProjectId("projectId-894832108")
313             .setRegion("region-934795532")
314             .setClusterName("clusterName-1141738587")
315             .setClusterUuid("clusterUuid-1141510955")
316             .setRequestId("requestId693933066")
317             .build();
318 
319     Cluster actualResponse = client.startClusterAsync(request).get();
320     Assert.assertEquals(expectedResponse, actualResponse);
321 
322     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
323     Assert.assertEquals(1, actualRequests.size());
324     StartClusterRequest actualRequest = ((StartClusterRequest) actualRequests.get(0));
325 
326     Assert.assertEquals(request.getProjectId(), actualRequest.getProjectId());
327     Assert.assertEquals(request.getRegion(), actualRequest.getRegion());
328     Assert.assertEquals(request.getClusterName(), actualRequest.getClusterName());
329     Assert.assertEquals(request.getClusterUuid(), actualRequest.getClusterUuid());
330     Assert.assertEquals(request.getRequestId(), actualRequest.getRequestId());
331     Assert.assertTrue(
332         channelProvider.isHeaderSent(
333             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
334             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
335   }
336 
337   @Test
startClusterExceptionTest()338   public void startClusterExceptionTest() throws Exception {
339     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
340     mockClusterController.addException(exception);
341 
342     try {
343       StartClusterRequest request =
344           StartClusterRequest.newBuilder()
345               .setProjectId("projectId-894832108")
346               .setRegion("region-934795532")
347               .setClusterName("clusterName-1141738587")
348               .setClusterUuid("clusterUuid-1141510955")
349               .setRequestId("requestId693933066")
350               .build();
351       client.startClusterAsync(request).get();
352       Assert.fail("No exception raised");
353     } catch (ExecutionException e) {
354       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
355       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
356       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
357     }
358   }
359 
360   @Test
deleteClusterTest()361   public void deleteClusterTest() throws Exception {
362     Empty expectedResponse = Empty.newBuilder().build();
363     Operation resultOperation =
364         Operation.newBuilder()
365             .setName("deleteClusterTest")
366             .setDone(true)
367             .setResponse(Any.pack(expectedResponse))
368             .build();
369     mockClusterController.addResponse(resultOperation);
370 
371     String projectId = "projectId-894832108";
372     String region = "region-934795532";
373     String clusterName = "clusterName-1141738587";
374 
375     client.deleteClusterAsync(projectId, region, clusterName).get();
376 
377     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
378     Assert.assertEquals(1, actualRequests.size());
379     DeleteClusterRequest actualRequest = ((DeleteClusterRequest) actualRequests.get(0));
380 
381     Assert.assertEquals(projectId, actualRequest.getProjectId());
382     Assert.assertEquals(region, actualRequest.getRegion());
383     Assert.assertEquals(clusterName, actualRequest.getClusterName());
384     Assert.assertTrue(
385         channelProvider.isHeaderSent(
386             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
387             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
388   }
389 
390   @Test
deleteClusterExceptionTest()391   public void deleteClusterExceptionTest() throws Exception {
392     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
393     mockClusterController.addException(exception);
394 
395     try {
396       String projectId = "projectId-894832108";
397       String region = "region-934795532";
398       String clusterName = "clusterName-1141738587";
399       client.deleteClusterAsync(projectId, region, clusterName).get();
400       Assert.fail("No exception raised");
401     } catch (ExecutionException e) {
402       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
403       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
404       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
405     }
406   }
407 
408   @Test
getClusterTest()409   public void getClusterTest() throws Exception {
410     Cluster expectedResponse =
411         Cluster.newBuilder()
412             .setProjectId("projectId-894832108")
413             .setClusterName("clusterName-1141738587")
414             .setConfig(ClusterConfig.newBuilder().build())
415             .setVirtualClusterConfig(VirtualClusterConfig.newBuilder().build())
416             .putAllLabels(new HashMap<String, String>())
417             .setStatus(ClusterStatus.newBuilder().build())
418             .addAllStatusHistory(new ArrayList<ClusterStatus>())
419             .setClusterUuid("clusterUuid-1141510955")
420             .setMetrics(ClusterMetrics.newBuilder().build())
421             .build();
422     mockClusterController.addResponse(expectedResponse);
423 
424     String projectId = "projectId-894832108";
425     String region = "region-934795532";
426     String clusterName = "clusterName-1141738587";
427 
428     Cluster actualResponse = client.getCluster(projectId, region, clusterName);
429     Assert.assertEquals(expectedResponse, actualResponse);
430 
431     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
432     Assert.assertEquals(1, actualRequests.size());
433     GetClusterRequest actualRequest = ((GetClusterRequest) actualRequests.get(0));
434 
435     Assert.assertEquals(projectId, actualRequest.getProjectId());
436     Assert.assertEquals(region, actualRequest.getRegion());
437     Assert.assertEquals(clusterName, actualRequest.getClusterName());
438     Assert.assertTrue(
439         channelProvider.isHeaderSent(
440             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
441             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
442   }
443 
444   @Test
getClusterExceptionTest()445   public void getClusterExceptionTest() throws Exception {
446     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
447     mockClusterController.addException(exception);
448 
449     try {
450       String projectId = "projectId-894832108";
451       String region = "region-934795532";
452       String clusterName = "clusterName-1141738587";
453       client.getCluster(projectId, region, clusterName);
454       Assert.fail("No exception raised");
455     } catch (InvalidArgumentException e) {
456       // Expected exception.
457     }
458   }
459 
460   @Test
listClustersTest()461   public void listClustersTest() throws Exception {
462     Cluster responsesElement = Cluster.newBuilder().build();
463     ListClustersResponse expectedResponse =
464         ListClustersResponse.newBuilder()
465             .setNextPageToken("")
466             .addAllClusters(Arrays.asList(responsesElement))
467             .build();
468     mockClusterController.addResponse(expectedResponse);
469 
470     String projectId = "projectId-894832108";
471     String region = "region-934795532";
472 
473     ListClustersPagedResponse pagedListResponse = client.listClusters(projectId, region);
474 
475     List<Cluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
476 
477     Assert.assertEquals(1, resources.size());
478     Assert.assertEquals(expectedResponse.getClustersList().get(0), resources.get(0));
479 
480     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
481     Assert.assertEquals(1, actualRequests.size());
482     ListClustersRequest actualRequest = ((ListClustersRequest) actualRequests.get(0));
483 
484     Assert.assertEquals(projectId, actualRequest.getProjectId());
485     Assert.assertEquals(region, actualRequest.getRegion());
486     Assert.assertTrue(
487         channelProvider.isHeaderSent(
488             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
489             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
490   }
491 
492   @Test
listClustersExceptionTest()493   public void listClustersExceptionTest() throws Exception {
494     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
495     mockClusterController.addException(exception);
496 
497     try {
498       String projectId = "projectId-894832108";
499       String region = "region-934795532";
500       client.listClusters(projectId, region);
501       Assert.fail("No exception raised");
502     } catch (InvalidArgumentException e) {
503       // Expected exception.
504     }
505   }
506 
507   @Test
listClustersTest2()508   public void listClustersTest2() throws Exception {
509     Cluster responsesElement = Cluster.newBuilder().build();
510     ListClustersResponse expectedResponse =
511         ListClustersResponse.newBuilder()
512             .setNextPageToken("")
513             .addAllClusters(Arrays.asList(responsesElement))
514             .build();
515     mockClusterController.addResponse(expectedResponse);
516 
517     String projectId = "projectId-894832108";
518     String region = "region-934795532";
519     String filter = "filter-1274492040";
520 
521     ListClustersPagedResponse pagedListResponse = client.listClusters(projectId, region, filter);
522 
523     List<Cluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
524 
525     Assert.assertEquals(1, resources.size());
526     Assert.assertEquals(expectedResponse.getClustersList().get(0), resources.get(0));
527 
528     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
529     Assert.assertEquals(1, actualRequests.size());
530     ListClustersRequest actualRequest = ((ListClustersRequest) actualRequests.get(0));
531 
532     Assert.assertEquals(projectId, actualRequest.getProjectId());
533     Assert.assertEquals(region, actualRequest.getRegion());
534     Assert.assertEquals(filter, actualRequest.getFilter());
535     Assert.assertTrue(
536         channelProvider.isHeaderSent(
537             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
538             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
539   }
540 
541   @Test
listClustersExceptionTest2()542   public void listClustersExceptionTest2() throws Exception {
543     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
544     mockClusterController.addException(exception);
545 
546     try {
547       String projectId = "projectId-894832108";
548       String region = "region-934795532";
549       String filter = "filter-1274492040";
550       client.listClusters(projectId, region, filter);
551       Assert.fail("No exception raised");
552     } catch (InvalidArgumentException e) {
553       // Expected exception.
554     }
555   }
556 
557   @Test
diagnoseClusterTest()558   public void diagnoseClusterTest() throws Exception {
559     DiagnoseClusterResults expectedResponse =
560         DiagnoseClusterResults.newBuilder().setOutputUri("outputUri-2119300949").build();
561     Operation resultOperation =
562         Operation.newBuilder()
563             .setName("diagnoseClusterTest")
564             .setDone(true)
565             .setResponse(Any.pack(expectedResponse))
566             .build();
567     mockClusterController.addResponse(resultOperation);
568 
569     String projectId = "projectId-894832108";
570     String region = "region-934795532";
571     String clusterName = "clusterName-1141738587";
572 
573     DiagnoseClusterResults actualResponse =
574         client.diagnoseClusterAsync(projectId, region, clusterName).get();
575     Assert.assertEquals(expectedResponse, actualResponse);
576 
577     List<AbstractMessage> actualRequests = mockClusterController.getRequests();
578     Assert.assertEquals(1, actualRequests.size());
579     DiagnoseClusterRequest actualRequest = ((DiagnoseClusterRequest) actualRequests.get(0));
580 
581     Assert.assertEquals(projectId, actualRequest.getProjectId());
582     Assert.assertEquals(region, actualRequest.getRegion());
583     Assert.assertEquals(clusterName, actualRequest.getClusterName());
584     Assert.assertTrue(
585         channelProvider.isHeaderSent(
586             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
587             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
588   }
589 
590   @Test
diagnoseClusterExceptionTest()591   public void diagnoseClusterExceptionTest() throws Exception {
592     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
593     mockClusterController.addException(exception);
594 
595     try {
596       String projectId = "projectId-894832108";
597       String region = "region-934795532";
598       String clusterName = "clusterName-1141738587";
599       client.diagnoseClusterAsync(projectId, region, clusterName).get();
600       Assert.fail("No exception raised");
601     } catch (ExecutionException e) {
602       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
603       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
604       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
605     }
606   }
607 }
608