• 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.notebooks.v1;
18 
19 import static com.google.cloud.notebooks.v1.ManagedNotebookServiceClient.ListLocationsPagedResponse;
20 import static com.google.cloud.notebooks.v1.ManagedNotebookServiceClient.ListRuntimesPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.gax.rpc.StatusCode;
30 import com.google.cloud.location.GetLocationRequest;
31 import com.google.cloud.location.ListLocationsRequest;
32 import com.google.cloud.location.ListLocationsResponse;
33 import com.google.cloud.location.Location;
34 import com.google.common.collect.Lists;
35 import com.google.iam.v1.AuditConfig;
36 import com.google.iam.v1.Binding;
37 import com.google.iam.v1.GetIamPolicyRequest;
38 import com.google.iam.v1.GetPolicyOptions;
39 import com.google.iam.v1.Policy;
40 import com.google.iam.v1.SetIamPolicyRequest;
41 import com.google.iam.v1.TestIamPermissionsRequest;
42 import com.google.iam.v1.TestIamPermissionsResponse;
43 import com.google.longrunning.Operation;
44 import com.google.protobuf.AbstractMessage;
45 import com.google.protobuf.Any;
46 import com.google.protobuf.ByteString;
47 import com.google.protobuf.Empty;
48 import com.google.protobuf.FieldMask;
49 import com.google.protobuf.Timestamp;
50 import io.grpc.StatusRuntimeException;
51 import java.io.IOException;
52 import java.util.ArrayList;
53 import java.util.Arrays;
54 import java.util.HashMap;
55 import java.util.List;
56 import java.util.UUID;
57 import java.util.concurrent.ExecutionException;
58 import javax.annotation.Generated;
59 import org.junit.After;
60 import org.junit.AfterClass;
61 import org.junit.Assert;
62 import org.junit.Before;
63 import org.junit.BeforeClass;
64 import org.junit.Test;
65 
66 @Generated("by gapic-generator-java")
67 public class ManagedNotebookServiceClientTest {
68   private static MockIAMPolicy mockIAMPolicy;
69   private static MockLocations mockLocations;
70   private static MockManagedNotebookService mockManagedNotebookService;
71   private static MockServiceHelper mockServiceHelper;
72   private LocalChannelProvider channelProvider;
73   private ManagedNotebookServiceClient client;
74 
75   @BeforeClass
startStaticServer()76   public static void startStaticServer() {
77     mockManagedNotebookService = new MockManagedNotebookService();
78     mockLocations = new MockLocations();
79     mockIAMPolicy = new MockIAMPolicy();
80     mockServiceHelper =
81         new MockServiceHelper(
82             UUID.randomUUID().toString(),
83             Arrays.<MockGrpcService>asList(
84                 mockManagedNotebookService, mockLocations, mockIAMPolicy));
85     mockServiceHelper.start();
86   }
87 
88   @AfterClass
stopServer()89   public static void stopServer() {
90     mockServiceHelper.stop();
91   }
92 
93   @Before
setUp()94   public void setUp() throws IOException {
95     mockServiceHelper.reset();
96     channelProvider = mockServiceHelper.createChannelProvider();
97     ManagedNotebookServiceSettings settings =
98         ManagedNotebookServiceSettings.newBuilder()
99             .setTransportChannelProvider(channelProvider)
100             .setCredentialsProvider(NoCredentialsProvider.create())
101             .build();
102     client = ManagedNotebookServiceClient.create(settings);
103   }
104 
105   @After
tearDown()106   public void tearDown() throws Exception {
107     client.close();
108   }
109 
110   @Test
listRuntimesTest()111   public void listRuntimesTest() throws Exception {
112     Runtime responsesElement = Runtime.newBuilder().build();
113     ListRuntimesResponse expectedResponse =
114         ListRuntimesResponse.newBuilder()
115             .setNextPageToken("")
116             .addAllRuntimes(Arrays.asList(responsesElement))
117             .build();
118     mockManagedNotebookService.addResponse(expectedResponse);
119 
120     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
121 
122     ListRuntimesPagedResponse pagedListResponse = client.listRuntimes(parent);
123 
124     List<Runtime> resources = Lists.newArrayList(pagedListResponse.iterateAll());
125 
126     Assert.assertEquals(1, resources.size());
127     Assert.assertEquals(expectedResponse.getRuntimesList().get(0), resources.get(0));
128 
129     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
130     Assert.assertEquals(1, actualRequests.size());
131     ListRuntimesRequest actualRequest = ((ListRuntimesRequest) actualRequests.get(0));
132 
133     Assert.assertEquals(parent.toString(), actualRequest.getParent());
134     Assert.assertTrue(
135         channelProvider.isHeaderSent(
136             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
137             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
138   }
139 
140   @Test
listRuntimesExceptionTest()141   public void listRuntimesExceptionTest() throws Exception {
142     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
143     mockManagedNotebookService.addException(exception);
144 
145     try {
146       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
147       client.listRuntimes(parent);
148       Assert.fail("No exception raised");
149     } catch (InvalidArgumentException e) {
150       // Expected exception.
151     }
152   }
153 
154   @Test
listRuntimesTest2()155   public void listRuntimesTest2() throws Exception {
156     Runtime responsesElement = Runtime.newBuilder().build();
157     ListRuntimesResponse expectedResponse =
158         ListRuntimesResponse.newBuilder()
159             .setNextPageToken("")
160             .addAllRuntimes(Arrays.asList(responsesElement))
161             .build();
162     mockManagedNotebookService.addResponse(expectedResponse);
163 
164     String parent = "parent-995424086";
165 
166     ListRuntimesPagedResponse pagedListResponse = client.listRuntimes(parent);
167 
168     List<Runtime> resources = Lists.newArrayList(pagedListResponse.iterateAll());
169 
170     Assert.assertEquals(1, resources.size());
171     Assert.assertEquals(expectedResponse.getRuntimesList().get(0), resources.get(0));
172 
173     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
174     Assert.assertEquals(1, actualRequests.size());
175     ListRuntimesRequest actualRequest = ((ListRuntimesRequest) actualRequests.get(0));
176 
177     Assert.assertEquals(parent, actualRequest.getParent());
178     Assert.assertTrue(
179         channelProvider.isHeaderSent(
180             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
181             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
182   }
183 
184   @Test
listRuntimesExceptionTest2()185   public void listRuntimesExceptionTest2() throws Exception {
186     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
187     mockManagedNotebookService.addException(exception);
188 
189     try {
190       String parent = "parent-995424086";
191       client.listRuntimes(parent);
192       Assert.fail("No exception raised");
193     } catch (InvalidArgumentException e) {
194       // Expected exception.
195     }
196   }
197 
198   @Test
getRuntimeTest()199   public void getRuntimeTest() throws Exception {
200     Runtime expectedResponse =
201         Runtime.newBuilder()
202             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
203             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
204             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
205             .setMetrics(RuntimeMetrics.newBuilder().build())
206             .setCreateTime(Timestamp.newBuilder().build())
207             .setUpdateTime(Timestamp.newBuilder().build())
208             .build();
209     mockManagedNotebookService.addResponse(expectedResponse);
210 
211     RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
212 
213     Runtime actualResponse = client.getRuntime(name);
214     Assert.assertEquals(expectedResponse, actualResponse);
215 
216     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
217     Assert.assertEquals(1, actualRequests.size());
218     GetRuntimeRequest actualRequest = ((GetRuntimeRequest) actualRequests.get(0));
219 
220     Assert.assertEquals(name.toString(), actualRequest.getName());
221     Assert.assertTrue(
222         channelProvider.isHeaderSent(
223             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
224             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
225   }
226 
227   @Test
getRuntimeExceptionTest()228   public void getRuntimeExceptionTest() throws Exception {
229     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
230     mockManagedNotebookService.addException(exception);
231 
232     try {
233       RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
234       client.getRuntime(name);
235       Assert.fail("No exception raised");
236     } catch (InvalidArgumentException e) {
237       // Expected exception.
238     }
239   }
240 
241   @Test
getRuntimeTest2()242   public void getRuntimeTest2() throws Exception {
243     Runtime expectedResponse =
244         Runtime.newBuilder()
245             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
246             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
247             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
248             .setMetrics(RuntimeMetrics.newBuilder().build())
249             .setCreateTime(Timestamp.newBuilder().build())
250             .setUpdateTime(Timestamp.newBuilder().build())
251             .build();
252     mockManagedNotebookService.addResponse(expectedResponse);
253 
254     String name = "name3373707";
255 
256     Runtime actualResponse = client.getRuntime(name);
257     Assert.assertEquals(expectedResponse, actualResponse);
258 
259     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
260     Assert.assertEquals(1, actualRequests.size());
261     GetRuntimeRequest actualRequest = ((GetRuntimeRequest) actualRequests.get(0));
262 
263     Assert.assertEquals(name, actualRequest.getName());
264     Assert.assertTrue(
265         channelProvider.isHeaderSent(
266             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
267             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
268   }
269 
270   @Test
getRuntimeExceptionTest2()271   public void getRuntimeExceptionTest2() throws Exception {
272     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
273     mockManagedNotebookService.addException(exception);
274 
275     try {
276       String name = "name3373707";
277       client.getRuntime(name);
278       Assert.fail("No exception raised");
279     } catch (InvalidArgumentException e) {
280       // Expected exception.
281     }
282   }
283 
284   @Test
createRuntimeTest()285   public void createRuntimeTest() throws Exception {
286     Runtime expectedResponse =
287         Runtime.newBuilder()
288             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
289             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
290             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
291             .setMetrics(RuntimeMetrics.newBuilder().build())
292             .setCreateTime(Timestamp.newBuilder().build())
293             .setUpdateTime(Timestamp.newBuilder().build())
294             .build();
295     Operation resultOperation =
296         Operation.newBuilder()
297             .setName("createRuntimeTest")
298             .setDone(true)
299             .setResponse(Any.pack(expectedResponse))
300             .build();
301     mockManagedNotebookService.addResponse(resultOperation);
302 
303     RuntimeName parent = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
304     String runtimeId = "runtimeId121455379";
305     Runtime runtime = Runtime.newBuilder().build();
306 
307     Runtime actualResponse = client.createRuntimeAsync(parent, runtimeId, runtime).get();
308     Assert.assertEquals(expectedResponse, actualResponse);
309 
310     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
311     Assert.assertEquals(1, actualRequests.size());
312     CreateRuntimeRequest actualRequest = ((CreateRuntimeRequest) actualRequests.get(0));
313 
314     Assert.assertEquals(parent.toString(), actualRequest.getParent());
315     Assert.assertEquals(runtimeId, actualRequest.getRuntimeId());
316     Assert.assertEquals(runtime, actualRequest.getRuntime());
317     Assert.assertTrue(
318         channelProvider.isHeaderSent(
319             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
320             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
321   }
322 
323   @Test
createRuntimeExceptionTest()324   public void createRuntimeExceptionTest() throws Exception {
325     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
326     mockManagedNotebookService.addException(exception);
327 
328     try {
329       RuntimeName parent = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
330       String runtimeId = "runtimeId121455379";
331       Runtime runtime = Runtime.newBuilder().build();
332       client.createRuntimeAsync(parent, runtimeId, runtime).get();
333       Assert.fail("No exception raised");
334     } catch (ExecutionException e) {
335       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
336       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
337       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
338     }
339   }
340 
341   @Test
createRuntimeTest2()342   public void createRuntimeTest2() throws Exception {
343     Runtime expectedResponse =
344         Runtime.newBuilder()
345             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
346             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
347             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
348             .setMetrics(RuntimeMetrics.newBuilder().build())
349             .setCreateTime(Timestamp.newBuilder().build())
350             .setUpdateTime(Timestamp.newBuilder().build())
351             .build();
352     Operation resultOperation =
353         Operation.newBuilder()
354             .setName("createRuntimeTest")
355             .setDone(true)
356             .setResponse(Any.pack(expectedResponse))
357             .build();
358     mockManagedNotebookService.addResponse(resultOperation);
359 
360     String parent = "parent-995424086";
361     String runtimeId = "runtimeId121455379";
362     Runtime runtime = Runtime.newBuilder().build();
363 
364     Runtime actualResponse = client.createRuntimeAsync(parent, runtimeId, runtime).get();
365     Assert.assertEquals(expectedResponse, actualResponse);
366 
367     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
368     Assert.assertEquals(1, actualRequests.size());
369     CreateRuntimeRequest actualRequest = ((CreateRuntimeRequest) actualRequests.get(0));
370 
371     Assert.assertEquals(parent, actualRequest.getParent());
372     Assert.assertEquals(runtimeId, actualRequest.getRuntimeId());
373     Assert.assertEquals(runtime, actualRequest.getRuntime());
374     Assert.assertTrue(
375         channelProvider.isHeaderSent(
376             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
377             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
378   }
379 
380   @Test
createRuntimeExceptionTest2()381   public void createRuntimeExceptionTest2() throws Exception {
382     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
383     mockManagedNotebookService.addException(exception);
384 
385     try {
386       String parent = "parent-995424086";
387       String runtimeId = "runtimeId121455379";
388       Runtime runtime = Runtime.newBuilder().build();
389       client.createRuntimeAsync(parent, runtimeId, runtime).get();
390       Assert.fail("No exception raised");
391     } catch (ExecutionException e) {
392       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
393       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
394       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
395     }
396   }
397 
398   @Test
updateRuntimeTest()399   public void updateRuntimeTest() throws Exception {
400     Runtime expectedResponse =
401         Runtime.newBuilder()
402             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
403             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
404             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
405             .setMetrics(RuntimeMetrics.newBuilder().build())
406             .setCreateTime(Timestamp.newBuilder().build())
407             .setUpdateTime(Timestamp.newBuilder().build())
408             .build();
409     Operation resultOperation =
410         Operation.newBuilder()
411             .setName("updateRuntimeTest")
412             .setDone(true)
413             .setResponse(Any.pack(expectedResponse))
414             .build();
415     mockManagedNotebookService.addResponse(resultOperation);
416 
417     Runtime runtime = Runtime.newBuilder().build();
418     FieldMask updateMask = FieldMask.newBuilder().build();
419 
420     Runtime actualResponse = client.updateRuntimeAsync(runtime, updateMask).get();
421     Assert.assertEquals(expectedResponse, actualResponse);
422 
423     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
424     Assert.assertEquals(1, actualRequests.size());
425     UpdateRuntimeRequest actualRequest = ((UpdateRuntimeRequest) actualRequests.get(0));
426 
427     Assert.assertEquals(runtime, actualRequest.getRuntime());
428     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
429     Assert.assertTrue(
430         channelProvider.isHeaderSent(
431             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
432             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
433   }
434 
435   @Test
updateRuntimeExceptionTest()436   public void updateRuntimeExceptionTest() throws Exception {
437     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
438     mockManagedNotebookService.addException(exception);
439 
440     try {
441       Runtime runtime = Runtime.newBuilder().build();
442       FieldMask updateMask = FieldMask.newBuilder().build();
443       client.updateRuntimeAsync(runtime, updateMask).get();
444       Assert.fail("No exception raised");
445     } catch (ExecutionException e) {
446       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
447       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
448       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
449     }
450   }
451 
452   @Test
deleteRuntimeTest()453   public void deleteRuntimeTest() throws Exception {
454     Empty expectedResponse = Empty.newBuilder().build();
455     Operation resultOperation =
456         Operation.newBuilder()
457             .setName("deleteRuntimeTest")
458             .setDone(true)
459             .setResponse(Any.pack(expectedResponse))
460             .build();
461     mockManagedNotebookService.addResponse(resultOperation);
462 
463     RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
464 
465     client.deleteRuntimeAsync(name).get();
466 
467     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
468     Assert.assertEquals(1, actualRequests.size());
469     DeleteRuntimeRequest actualRequest = ((DeleteRuntimeRequest) actualRequests.get(0));
470 
471     Assert.assertEquals(name.toString(), actualRequest.getName());
472     Assert.assertTrue(
473         channelProvider.isHeaderSent(
474             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
475             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
476   }
477 
478   @Test
deleteRuntimeExceptionTest()479   public void deleteRuntimeExceptionTest() throws Exception {
480     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
481     mockManagedNotebookService.addException(exception);
482 
483     try {
484       RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
485       client.deleteRuntimeAsync(name).get();
486       Assert.fail("No exception raised");
487     } catch (ExecutionException e) {
488       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
489       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
490       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
491     }
492   }
493 
494   @Test
deleteRuntimeTest2()495   public void deleteRuntimeTest2() throws Exception {
496     Empty expectedResponse = Empty.newBuilder().build();
497     Operation resultOperation =
498         Operation.newBuilder()
499             .setName("deleteRuntimeTest")
500             .setDone(true)
501             .setResponse(Any.pack(expectedResponse))
502             .build();
503     mockManagedNotebookService.addResponse(resultOperation);
504 
505     String name = "name3373707";
506 
507     client.deleteRuntimeAsync(name).get();
508 
509     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
510     Assert.assertEquals(1, actualRequests.size());
511     DeleteRuntimeRequest actualRequest = ((DeleteRuntimeRequest) actualRequests.get(0));
512 
513     Assert.assertEquals(name, actualRequest.getName());
514     Assert.assertTrue(
515         channelProvider.isHeaderSent(
516             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
517             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
518   }
519 
520   @Test
deleteRuntimeExceptionTest2()521   public void deleteRuntimeExceptionTest2() throws Exception {
522     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
523     mockManagedNotebookService.addException(exception);
524 
525     try {
526       String name = "name3373707";
527       client.deleteRuntimeAsync(name).get();
528       Assert.fail("No exception raised");
529     } catch (ExecutionException e) {
530       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
531       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
532       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
533     }
534   }
535 
536   @Test
startRuntimeTest()537   public void startRuntimeTest() throws Exception {
538     Runtime expectedResponse =
539         Runtime.newBuilder()
540             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
541             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
542             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
543             .setMetrics(RuntimeMetrics.newBuilder().build())
544             .setCreateTime(Timestamp.newBuilder().build())
545             .setUpdateTime(Timestamp.newBuilder().build())
546             .build();
547     Operation resultOperation =
548         Operation.newBuilder()
549             .setName("startRuntimeTest")
550             .setDone(true)
551             .setResponse(Any.pack(expectedResponse))
552             .build();
553     mockManagedNotebookService.addResponse(resultOperation);
554 
555     String name = "name3373707";
556 
557     Runtime actualResponse = client.startRuntimeAsync(name).get();
558     Assert.assertEquals(expectedResponse, actualResponse);
559 
560     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
561     Assert.assertEquals(1, actualRequests.size());
562     StartRuntimeRequest actualRequest = ((StartRuntimeRequest) actualRequests.get(0));
563 
564     Assert.assertEquals(name, actualRequest.getName());
565     Assert.assertTrue(
566         channelProvider.isHeaderSent(
567             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
568             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
569   }
570 
571   @Test
startRuntimeExceptionTest()572   public void startRuntimeExceptionTest() throws Exception {
573     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
574     mockManagedNotebookService.addException(exception);
575 
576     try {
577       String name = "name3373707";
578       client.startRuntimeAsync(name).get();
579       Assert.fail("No exception raised");
580     } catch (ExecutionException e) {
581       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
582       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
583       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
584     }
585   }
586 
587   @Test
stopRuntimeTest()588   public void stopRuntimeTest() throws Exception {
589     Runtime expectedResponse =
590         Runtime.newBuilder()
591             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
592             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
593             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
594             .setMetrics(RuntimeMetrics.newBuilder().build())
595             .setCreateTime(Timestamp.newBuilder().build())
596             .setUpdateTime(Timestamp.newBuilder().build())
597             .build();
598     Operation resultOperation =
599         Operation.newBuilder()
600             .setName("stopRuntimeTest")
601             .setDone(true)
602             .setResponse(Any.pack(expectedResponse))
603             .build();
604     mockManagedNotebookService.addResponse(resultOperation);
605 
606     String name = "name3373707";
607 
608     Runtime actualResponse = client.stopRuntimeAsync(name).get();
609     Assert.assertEquals(expectedResponse, actualResponse);
610 
611     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
612     Assert.assertEquals(1, actualRequests.size());
613     StopRuntimeRequest actualRequest = ((StopRuntimeRequest) actualRequests.get(0));
614 
615     Assert.assertEquals(name, actualRequest.getName());
616     Assert.assertTrue(
617         channelProvider.isHeaderSent(
618             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
619             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
620   }
621 
622   @Test
stopRuntimeExceptionTest()623   public void stopRuntimeExceptionTest() throws Exception {
624     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
625     mockManagedNotebookService.addException(exception);
626 
627     try {
628       String name = "name3373707";
629       client.stopRuntimeAsync(name).get();
630       Assert.fail("No exception raised");
631     } catch (ExecutionException e) {
632       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
633       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
634       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
635     }
636   }
637 
638   @Test
switchRuntimeTest()639   public void switchRuntimeTest() throws Exception {
640     Runtime expectedResponse =
641         Runtime.newBuilder()
642             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
643             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
644             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
645             .setMetrics(RuntimeMetrics.newBuilder().build())
646             .setCreateTime(Timestamp.newBuilder().build())
647             .setUpdateTime(Timestamp.newBuilder().build())
648             .build();
649     Operation resultOperation =
650         Operation.newBuilder()
651             .setName("switchRuntimeTest")
652             .setDone(true)
653             .setResponse(Any.pack(expectedResponse))
654             .build();
655     mockManagedNotebookService.addResponse(resultOperation);
656 
657     String name = "name3373707";
658 
659     Runtime actualResponse = client.switchRuntimeAsync(name).get();
660     Assert.assertEquals(expectedResponse, actualResponse);
661 
662     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
663     Assert.assertEquals(1, actualRequests.size());
664     SwitchRuntimeRequest actualRequest = ((SwitchRuntimeRequest) actualRequests.get(0));
665 
666     Assert.assertEquals(name, actualRequest.getName());
667     Assert.assertTrue(
668         channelProvider.isHeaderSent(
669             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
670             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
671   }
672 
673   @Test
switchRuntimeExceptionTest()674   public void switchRuntimeExceptionTest() throws Exception {
675     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
676     mockManagedNotebookService.addException(exception);
677 
678     try {
679       String name = "name3373707";
680       client.switchRuntimeAsync(name).get();
681       Assert.fail("No exception raised");
682     } catch (ExecutionException e) {
683       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
684       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
685       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
686     }
687   }
688 
689   @Test
resetRuntimeTest()690   public void resetRuntimeTest() throws Exception {
691     Runtime expectedResponse =
692         Runtime.newBuilder()
693             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
694             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
695             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
696             .setMetrics(RuntimeMetrics.newBuilder().build())
697             .setCreateTime(Timestamp.newBuilder().build())
698             .setUpdateTime(Timestamp.newBuilder().build())
699             .build();
700     Operation resultOperation =
701         Operation.newBuilder()
702             .setName("resetRuntimeTest")
703             .setDone(true)
704             .setResponse(Any.pack(expectedResponse))
705             .build();
706     mockManagedNotebookService.addResponse(resultOperation);
707 
708     String name = "name3373707";
709 
710     Runtime actualResponse = client.resetRuntimeAsync(name).get();
711     Assert.assertEquals(expectedResponse, actualResponse);
712 
713     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
714     Assert.assertEquals(1, actualRequests.size());
715     ResetRuntimeRequest actualRequest = ((ResetRuntimeRequest) actualRequests.get(0));
716 
717     Assert.assertEquals(name, actualRequest.getName());
718     Assert.assertTrue(
719         channelProvider.isHeaderSent(
720             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
721             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
722   }
723 
724   @Test
resetRuntimeExceptionTest()725   public void resetRuntimeExceptionTest() throws Exception {
726     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
727     mockManagedNotebookService.addException(exception);
728 
729     try {
730       String name = "name3373707";
731       client.resetRuntimeAsync(name).get();
732       Assert.fail("No exception raised");
733     } catch (ExecutionException e) {
734       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
735       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
736       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
737     }
738   }
739 
740   @Test
upgradeRuntimeTest()741   public void upgradeRuntimeTest() throws Exception {
742     Runtime expectedResponse =
743         Runtime.newBuilder()
744             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
745             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
746             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
747             .setMetrics(RuntimeMetrics.newBuilder().build())
748             .setCreateTime(Timestamp.newBuilder().build())
749             .setUpdateTime(Timestamp.newBuilder().build())
750             .build();
751     Operation resultOperation =
752         Operation.newBuilder()
753             .setName("upgradeRuntimeTest")
754             .setDone(true)
755             .setResponse(Any.pack(expectedResponse))
756             .build();
757     mockManagedNotebookService.addResponse(resultOperation);
758 
759     String name = "name3373707";
760 
761     Runtime actualResponse = client.upgradeRuntimeAsync(name).get();
762     Assert.assertEquals(expectedResponse, actualResponse);
763 
764     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
765     Assert.assertEquals(1, actualRequests.size());
766     UpgradeRuntimeRequest actualRequest = ((UpgradeRuntimeRequest) actualRequests.get(0));
767 
768     Assert.assertEquals(name, actualRequest.getName());
769     Assert.assertTrue(
770         channelProvider.isHeaderSent(
771             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
772             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
773   }
774 
775   @Test
upgradeRuntimeExceptionTest()776   public void upgradeRuntimeExceptionTest() throws Exception {
777     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
778     mockManagedNotebookService.addException(exception);
779 
780     try {
781       String name = "name3373707";
782       client.upgradeRuntimeAsync(name).get();
783       Assert.fail("No exception raised");
784     } catch (ExecutionException e) {
785       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
786       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
787       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
788     }
789   }
790 
791   @Test
reportRuntimeEventTest()792   public void reportRuntimeEventTest() throws Exception {
793     Runtime expectedResponse =
794         Runtime.newBuilder()
795             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
796             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
797             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
798             .setMetrics(RuntimeMetrics.newBuilder().build())
799             .setCreateTime(Timestamp.newBuilder().build())
800             .setUpdateTime(Timestamp.newBuilder().build())
801             .build();
802     Operation resultOperation =
803         Operation.newBuilder()
804             .setName("reportRuntimeEventTest")
805             .setDone(true)
806             .setResponse(Any.pack(expectedResponse))
807             .build();
808     mockManagedNotebookService.addResponse(resultOperation);
809 
810     RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
811 
812     Runtime actualResponse = client.reportRuntimeEventAsync(name).get();
813     Assert.assertEquals(expectedResponse, actualResponse);
814 
815     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
816     Assert.assertEquals(1, actualRequests.size());
817     ReportRuntimeEventRequest actualRequest = ((ReportRuntimeEventRequest) actualRequests.get(0));
818 
819     Assert.assertEquals(name.toString(), actualRequest.getName());
820     Assert.assertTrue(
821         channelProvider.isHeaderSent(
822             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
823             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
824   }
825 
826   @Test
reportRuntimeEventExceptionTest()827   public void reportRuntimeEventExceptionTest() throws Exception {
828     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
829     mockManagedNotebookService.addException(exception);
830 
831     try {
832       RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
833       client.reportRuntimeEventAsync(name).get();
834       Assert.fail("No exception raised");
835     } catch (ExecutionException e) {
836       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
837       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
838       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
839     }
840   }
841 
842   @Test
reportRuntimeEventTest2()843   public void reportRuntimeEventTest2() throws Exception {
844     Runtime expectedResponse =
845         Runtime.newBuilder()
846             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
847             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
848             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
849             .setMetrics(RuntimeMetrics.newBuilder().build())
850             .setCreateTime(Timestamp.newBuilder().build())
851             .setUpdateTime(Timestamp.newBuilder().build())
852             .build();
853     Operation resultOperation =
854         Operation.newBuilder()
855             .setName("reportRuntimeEventTest")
856             .setDone(true)
857             .setResponse(Any.pack(expectedResponse))
858             .build();
859     mockManagedNotebookService.addResponse(resultOperation);
860 
861     String name = "name3373707";
862 
863     Runtime actualResponse = client.reportRuntimeEventAsync(name).get();
864     Assert.assertEquals(expectedResponse, actualResponse);
865 
866     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
867     Assert.assertEquals(1, actualRequests.size());
868     ReportRuntimeEventRequest actualRequest = ((ReportRuntimeEventRequest) actualRequests.get(0));
869 
870     Assert.assertEquals(name, actualRequest.getName());
871     Assert.assertTrue(
872         channelProvider.isHeaderSent(
873             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
874             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
875   }
876 
877   @Test
reportRuntimeEventExceptionTest2()878   public void reportRuntimeEventExceptionTest2() throws Exception {
879     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
880     mockManagedNotebookService.addException(exception);
881 
882     try {
883       String name = "name3373707";
884       client.reportRuntimeEventAsync(name).get();
885       Assert.fail("No exception raised");
886     } catch (ExecutionException e) {
887       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
888       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
889       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
890     }
891   }
892 
893   @Test
refreshRuntimeTokenInternalTest()894   public void refreshRuntimeTokenInternalTest() throws Exception {
895     RefreshRuntimeTokenInternalResponse expectedResponse =
896         RefreshRuntimeTokenInternalResponse.newBuilder()
897             .setAccessToken("accessToken-1042689291")
898             .setExpireTime(Timestamp.newBuilder().build())
899             .build();
900     mockManagedNotebookService.addResponse(expectedResponse);
901 
902     RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
903     String vmId = "vmId3622450";
904 
905     RefreshRuntimeTokenInternalResponse actualResponse =
906         client.refreshRuntimeTokenInternal(name, vmId);
907     Assert.assertEquals(expectedResponse, actualResponse);
908 
909     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
910     Assert.assertEquals(1, actualRequests.size());
911     RefreshRuntimeTokenInternalRequest actualRequest =
912         ((RefreshRuntimeTokenInternalRequest) actualRequests.get(0));
913 
914     Assert.assertEquals(name.toString(), actualRequest.getName());
915     Assert.assertEquals(vmId, actualRequest.getVmId());
916     Assert.assertTrue(
917         channelProvider.isHeaderSent(
918             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
919             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
920   }
921 
922   @Test
refreshRuntimeTokenInternalExceptionTest()923   public void refreshRuntimeTokenInternalExceptionTest() throws Exception {
924     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
925     mockManagedNotebookService.addException(exception);
926 
927     try {
928       RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
929       String vmId = "vmId3622450";
930       client.refreshRuntimeTokenInternal(name, vmId);
931       Assert.fail("No exception raised");
932     } catch (InvalidArgumentException e) {
933       // Expected exception.
934     }
935   }
936 
937   @Test
refreshRuntimeTokenInternalTest2()938   public void refreshRuntimeTokenInternalTest2() throws Exception {
939     RefreshRuntimeTokenInternalResponse expectedResponse =
940         RefreshRuntimeTokenInternalResponse.newBuilder()
941             .setAccessToken("accessToken-1042689291")
942             .setExpireTime(Timestamp.newBuilder().build())
943             .build();
944     mockManagedNotebookService.addResponse(expectedResponse);
945 
946     String name = "name3373707";
947     String vmId = "vmId3622450";
948 
949     RefreshRuntimeTokenInternalResponse actualResponse =
950         client.refreshRuntimeTokenInternal(name, vmId);
951     Assert.assertEquals(expectedResponse, actualResponse);
952 
953     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
954     Assert.assertEquals(1, actualRequests.size());
955     RefreshRuntimeTokenInternalRequest actualRequest =
956         ((RefreshRuntimeTokenInternalRequest) actualRequests.get(0));
957 
958     Assert.assertEquals(name, actualRequest.getName());
959     Assert.assertEquals(vmId, actualRequest.getVmId());
960     Assert.assertTrue(
961         channelProvider.isHeaderSent(
962             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
963             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
964   }
965 
966   @Test
refreshRuntimeTokenInternalExceptionTest2()967   public void refreshRuntimeTokenInternalExceptionTest2() throws Exception {
968     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
969     mockManagedNotebookService.addException(exception);
970 
971     try {
972       String name = "name3373707";
973       String vmId = "vmId3622450";
974       client.refreshRuntimeTokenInternal(name, vmId);
975       Assert.fail("No exception raised");
976     } catch (InvalidArgumentException e) {
977       // Expected exception.
978     }
979   }
980 
981   @Test
diagnoseRuntimeTest()982   public void diagnoseRuntimeTest() throws Exception {
983     Runtime expectedResponse =
984         Runtime.newBuilder()
985             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
986             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
987             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
988             .setMetrics(RuntimeMetrics.newBuilder().build())
989             .setCreateTime(Timestamp.newBuilder().build())
990             .setUpdateTime(Timestamp.newBuilder().build())
991             .build();
992     Operation resultOperation =
993         Operation.newBuilder()
994             .setName("diagnoseRuntimeTest")
995             .setDone(true)
996             .setResponse(Any.pack(expectedResponse))
997             .build();
998     mockManagedNotebookService.addResponse(resultOperation);
999 
1000     RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
1001     DiagnosticConfig diagnosticConfig = DiagnosticConfig.newBuilder().build();
1002 
1003     Runtime actualResponse = client.diagnoseRuntimeAsync(name, diagnosticConfig).get();
1004     Assert.assertEquals(expectedResponse, actualResponse);
1005 
1006     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
1007     Assert.assertEquals(1, actualRequests.size());
1008     DiagnoseRuntimeRequest actualRequest = ((DiagnoseRuntimeRequest) actualRequests.get(0));
1009 
1010     Assert.assertEquals(name.toString(), actualRequest.getName());
1011     Assert.assertEquals(diagnosticConfig, actualRequest.getDiagnosticConfig());
1012     Assert.assertTrue(
1013         channelProvider.isHeaderSent(
1014             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1015             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1016   }
1017 
1018   @Test
diagnoseRuntimeExceptionTest()1019   public void diagnoseRuntimeExceptionTest() throws Exception {
1020     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1021     mockManagedNotebookService.addException(exception);
1022 
1023     try {
1024       RuntimeName name = RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]");
1025       DiagnosticConfig diagnosticConfig = DiagnosticConfig.newBuilder().build();
1026       client.diagnoseRuntimeAsync(name, diagnosticConfig).get();
1027       Assert.fail("No exception raised");
1028     } catch (ExecutionException e) {
1029       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1030       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1031       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1032     }
1033   }
1034 
1035   @Test
diagnoseRuntimeTest2()1036   public void diagnoseRuntimeTest2() throws Exception {
1037     Runtime expectedResponse =
1038         Runtime.newBuilder()
1039             .setName(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
1040             .setAccessConfig(RuntimeAccessConfig.newBuilder().build())
1041             .setSoftwareConfig(RuntimeSoftwareConfig.newBuilder().build())
1042             .setMetrics(RuntimeMetrics.newBuilder().build())
1043             .setCreateTime(Timestamp.newBuilder().build())
1044             .setUpdateTime(Timestamp.newBuilder().build())
1045             .build();
1046     Operation resultOperation =
1047         Operation.newBuilder()
1048             .setName("diagnoseRuntimeTest")
1049             .setDone(true)
1050             .setResponse(Any.pack(expectedResponse))
1051             .build();
1052     mockManagedNotebookService.addResponse(resultOperation);
1053 
1054     String name = "name3373707";
1055     DiagnosticConfig diagnosticConfig = DiagnosticConfig.newBuilder().build();
1056 
1057     Runtime actualResponse = client.diagnoseRuntimeAsync(name, diagnosticConfig).get();
1058     Assert.assertEquals(expectedResponse, actualResponse);
1059 
1060     List<AbstractMessage> actualRequests = mockManagedNotebookService.getRequests();
1061     Assert.assertEquals(1, actualRequests.size());
1062     DiagnoseRuntimeRequest actualRequest = ((DiagnoseRuntimeRequest) actualRequests.get(0));
1063 
1064     Assert.assertEquals(name, actualRequest.getName());
1065     Assert.assertEquals(diagnosticConfig, actualRequest.getDiagnosticConfig());
1066     Assert.assertTrue(
1067         channelProvider.isHeaderSent(
1068             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1069             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1070   }
1071 
1072   @Test
diagnoseRuntimeExceptionTest2()1073   public void diagnoseRuntimeExceptionTest2() throws Exception {
1074     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1075     mockManagedNotebookService.addException(exception);
1076 
1077     try {
1078       String name = "name3373707";
1079       DiagnosticConfig diagnosticConfig = DiagnosticConfig.newBuilder().build();
1080       client.diagnoseRuntimeAsync(name, diagnosticConfig).get();
1081       Assert.fail("No exception raised");
1082     } catch (ExecutionException e) {
1083       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1084       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1085       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1086     }
1087   }
1088 
1089   @Test
listLocationsTest()1090   public void listLocationsTest() throws Exception {
1091     Location responsesElement = Location.newBuilder().build();
1092     ListLocationsResponse expectedResponse =
1093         ListLocationsResponse.newBuilder()
1094             .setNextPageToken("")
1095             .addAllLocations(Arrays.asList(responsesElement))
1096             .build();
1097     mockLocations.addResponse(expectedResponse);
1098 
1099     ListLocationsRequest request =
1100         ListLocationsRequest.newBuilder()
1101             .setName("name3373707")
1102             .setFilter("filter-1274492040")
1103             .setPageSize(883849137)
1104             .setPageToken("pageToken873572522")
1105             .build();
1106 
1107     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1108 
1109     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1110 
1111     Assert.assertEquals(1, resources.size());
1112     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1113 
1114     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1115     Assert.assertEquals(1, actualRequests.size());
1116     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1117 
1118     Assert.assertEquals(request.getName(), actualRequest.getName());
1119     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1120     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1121     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1122     Assert.assertTrue(
1123         channelProvider.isHeaderSent(
1124             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1125             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1126   }
1127 
1128   @Test
listLocationsExceptionTest()1129   public void listLocationsExceptionTest() throws Exception {
1130     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1131     mockLocations.addException(exception);
1132 
1133     try {
1134       ListLocationsRequest request =
1135           ListLocationsRequest.newBuilder()
1136               .setName("name3373707")
1137               .setFilter("filter-1274492040")
1138               .setPageSize(883849137)
1139               .setPageToken("pageToken873572522")
1140               .build();
1141       client.listLocations(request);
1142       Assert.fail("No exception raised");
1143     } catch (InvalidArgumentException e) {
1144       // Expected exception.
1145     }
1146   }
1147 
1148   @Test
getLocationTest()1149   public void getLocationTest() throws Exception {
1150     Location expectedResponse =
1151         Location.newBuilder()
1152             .setName("name3373707")
1153             .setLocationId("locationId1541836720")
1154             .setDisplayName("displayName1714148973")
1155             .putAllLabels(new HashMap<String, String>())
1156             .setMetadata(Any.newBuilder().build())
1157             .build();
1158     mockLocations.addResponse(expectedResponse);
1159 
1160     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1161 
1162     Location actualResponse = client.getLocation(request);
1163     Assert.assertEquals(expectedResponse, actualResponse);
1164 
1165     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1166     Assert.assertEquals(1, actualRequests.size());
1167     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1168 
1169     Assert.assertEquals(request.getName(), actualRequest.getName());
1170     Assert.assertTrue(
1171         channelProvider.isHeaderSent(
1172             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1173             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1174   }
1175 
1176   @Test
getLocationExceptionTest()1177   public void getLocationExceptionTest() throws Exception {
1178     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1179     mockLocations.addException(exception);
1180 
1181     try {
1182       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1183       client.getLocation(request);
1184       Assert.fail("No exception raised");
1185     } catch (InvalidArgumentException e) {
1186       // Expected exception.
1187     }
1188   }
1189 
1190   @Test
setIamPolicyTest()1191   public void setIamPolicyTest() throws Exception {
1192     Policy expectedResponse =
1193         Policy.newBuilder()
1194             .setVersion(351608024)
1195             .addAllBindings(new ArrayList<Binding>())
1196             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1197             .setEtag(ByteString.EMPTY)
1198             .build();
1199     mockIAMPolicy.addResponse(expectedResponse);
1200 
1201     SetIamPolicyRequest request =
1202         SetIamPolicyRequest.newBuilder()
1203             .setResource(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
1204             .setPolicy(Policy.newBuilder().build())
1205             .setUpdateMask(FieldMask.newBuilder().build())
1206             .build();
1207 
1208     Policy actualResponse = client.setIamPolicy(request);
1209     Assert.assertEquals(expectedResponse, actualResponse);
1210 
1211     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1212     Assert.assertEquals(1, actualRequests.size());
1213     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1214 
1215     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1216     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
1217     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
1218     Assert.assertTrue(
1219         channelProvider.isHeaderSent(
1220             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1221             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1222   }
1223 
1224   @Test
setIamPolicyExceptionTest()1225   public void setIamPolicyExceptionTest() throws Exception {
1226     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1227     mockIAMPolicy.addException(exception);
1228 
1229     try {
1230       SetIamPolicyRequest request =
1231           SetIamPolicyRequest.newBuilder()
1232               .setResource(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
1233               .setPolicy(Policy.newBuilder().build())
1234               .setUpdateMask(FieldMask.newBuilder().build())
1235               .build();
1236       client.setIamPolicy(request);
1237       Assert.fail("No exception raised");
1238     } catch (InvalidArgumentException e) {
1239       // Expected exception.
1240     }
1241   }
1242 
1243   @Test
getIamPolicyTest()1244   public void getIamPolicyTest() throws Exception {
1245     Policy expectedResponse =
1246         Policy.newBuilder()
1247             .setVersion(351608024)
1248             .addAllBindings(new ArrayList<Binding>())
1249             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1250             .setEtag(ByteString.EMPTY)
1251             .build();
1252     mockIAMPolicy.addResponse(expectedResponse);
1253 
1254     GetIamPolicyRequest request =
1255         GetIamPolicyRequest.newBuilder()
1256             .setResource(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
1257             .setOptions(GetPolicyOptions.newBuilder().build())
1258             .build();
1259 
1260     Policy actualResponse = client.getIamPolicy(request);
1261     Assert.assertEquals(expectedResponse, actualResponse);
1262 
1263     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1264     Assert.assertEquals(1, actualRequests.size());
1265     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
1266 
1267     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1268     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
1269     Assert.assertTrue(
1270         channelProvider.isHeaderSent(
1271             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1272             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1273   }
1274 
1275   @Test
getIamPolicyExceptionTest()1276   public void getIamPolicyExceptionTest() throws Exception {
1277     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1278     mockIAMPolicy.addException(exception);
1279 
1280     try {
1281       GetIamPolicyRequest request =
1282           GetIamPolicyRequest.newBuilder()
1283               .setResource(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
1284               .setOptions(GetPolicyOptions.newBuilder().build())
1285               .build();
1286       client.getIamPolicy(request);
1287       Assert.fail("No exception raised");
1288     } catch (InvalidArgumentException e) {
1289       // Expected exception.
1290     }
1291   }
1292 
1293   @Test
testIamPermissionsTest()1294   public void testIamPermissionsTest() throws Exception {
1295     TestIamPermissionsResponse expectedResponse =
1296         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1297     mockIAMPolicy.addResponse(expectedResponse);
1298 
1299     TestIamPermissionsRequest request =
1300         TestIamPermissionsRequest.newBuilder()
1301             .setResource(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
1302             .addAllPermissions(new ArrayList<String>())
1303             .build();
1304 
1305     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1306     Assert.assertEquals(expectedResponse, actualResponse);
1307 
1308     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1309     Assert.assertEquals(1, actualRequests.size());
1310     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
1311 
1312     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1313     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
1314     Assert.assertTrue(
1315         channelProvider.isHeaderSent(
1316             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1317             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1318   }
1319 
1320   @Test
testIamPermissionsExceptionTest()1321   public void testIamPermissionsExceptionTest() throws Exception {
1322     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1323     mockIAMPolicy.addException(exception);
1324 
1325     try {
1326       TestIamPermissionsRequest request =
1327           TestIamPermissionsRequest.newBuilder()
1328               .setResource(RuntimeName.of("[PROJECT]", "[LOCATION]", "[RUNTIME]").toString())
1329               .addAllPermissions(new ArrayList<String>())
1330               .build();
1331       client.testIamPermissions(request);
1332       Assert.fail("No exception raised");
1333     } catch (InvalidArgumentException e) {
1334       // Expected exception.
1335     }
1336   }
1337 }
1338