• 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.v1beta1;
18 
19 import static com.google.cloud.notebooks.v1beta1.NotebookServiceClient.ListEnvironmentsPagedResponse;
20 import static com.google.cloud.notebooks.v1beta1.NotebookServiceClient.ListInstancesPagedResponse;
21 import static com.google.cloud.notebooks.v1beta1.NotebookServiceClient.ListLocationsPagedResponse;
22 
23 import com.google.api.gax.core.NoCredentialsProvider;
24 import com.google.api.gax.grpc.GaxGrpcProperties;
25 import com.google.api.gax.grpc.testing.LocalChannelProvider;
26 import com.google.api.gax.grpc.testing.MockGrpcService;
27 import com.google.api.gax.grpc.testing.MockServiceHelper;
28 import com.google.api.gax.rpc.ApiClientHeaderProvider;
29 import com.google.api.gax.rpc.InvalidArgumentException;
30 import com.google.api.gax.rpc.StatusCode;
31 import com.google.cloud.location.GetLocationRequest;
32 import com.google.cloud.location.ListLocationsRequest;
33 import com.google.cloud.location.ListLocationsResponse;
34 import com.google.cloud.location.Location;
35 import com.google.common.collect.Lists;
36 import com.google.iam.v1.AuditConfig;
37 import com.google.iam.v1.Binding;
38 import com.google.iam.v1.GetIamPolicyRequest;
39 import com.google.iam.v1.GetPolicyOptions;
40 import com.google.iam.v1.Policy;
41 import com.google.iam.v1.SetIamPolicyRequest;
42 import com.google.iam.v1.TestIamPermissionsRequest;
43 import com.google.iam.v1.TestIamPermissionsResponse;
44 import com.google.longrunning.Operation;
45 import com.google.protobuf.AbstractMessage;
46 import com.google.protobuf.Any;
47 import com.google.protobuf.ByteString;
48 import com.google.protobuf.Empty;
49 import com.google.protobuf.FieldMask;
50 import com.google.protobuf.Timestamp;
51 import io.grpc.StatusRuntimeException;
52 import java.io.IOException;
53 import java.util.ArrayList;
54 import java.util.Arrays;
55 import java.util.HashMap;
56 import java.util.List;
57 import java.util.UUID;
58 import java.util.concurrent.ExecutionException;
59 import javax.annotation.Generated;
60 import org.junit.After;
61 import org.junit.AfterClass;
62 import org.junit.Assert;
63 import org.junit.Before;
64 import org.junit.BeforeClass;
65 import org.junit.Test;
66 
67 @Generated("by gapic-generator-java")
68 public class NotebookServiceClientTest {
69   private static MockIAMPolicy mockIAMPolicy;
70   private static MockLocations mockLocations;
71   private static MockNotebookService mockNotebookService;
72   private static MockServiceHelper mockServiceHelper;
73   private LocalChannelProvider channelProvider;
74   private NotebookServiceClient client;
75 
76   @BeforeClass
startStaticServer()77   public static void startStaticServer() {
78     mockNotebookService = new MockNotebookService();
79     mockLocations = new MockLocations();
80     mockIAMPolicy = new MockIAMPolicy();
81     mockServiceHelper =
82         new MockServiceHelper(
83             UUID.randomUUID().toString(),
84             Arrays.<MockGrpcService>asList(mockNotebookService, 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     NotebookServiceSettings settings =
98         NotebookServiceSettings.newBuilder()
99             .setTransportChannelProvider(channelProvider)
100             .setCredentialsProvider(NoCredentialsProvider.create())
101             .build();
102     client = NotebookServiceClient.create(settings);
103   }
104 
105   @After
tearDown()106   public void tearDown() throws Exception {
107     client.close();
108   }
109 
110   @Test
listInstancesTest()111   public void listInstancesTest() throws Exception {
112     Instance responsesElement = Instance.newBuilder().build();
113     ListInstancesResponse expectedResponse =
114         ListInstancesResponse.newBuilder()
115             .setNextPageToken("")
116             .addAllInstances(Arrays.asList(responsesElement))
117             .build();
118     mockNotebookService.addResponse(expectedResponse);
119 
120     ListInstancesRequest request =
121         ListInstancesRequest.newBuilder()
122             .setParent("parent-995424086")
123             .setPageSize(883849137)
124             .setPageToken("pageToken873572522")
125             .build();
126 
127     ListInstancesPagedResponse pagedListResponse = client.listInstances(request);
128 
129     List<Instance> resources = Lists.newArrayList(pagedListResponse.iterateAll());
130 
131     Assert.assertEquals(1, resources.size());
132     Assert.assertEquals(expectedResponse.getInstancesList().get(0), resources.get(0));
133 
134     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
135     Assert.assertEquals(1, actualRequests.size());
136     ListInstancesRequest actualRequest = ((ListInstancesRequest) actualRequests.get(0));
137 
138     Assert.assertEquals(request.getParent(), actualRequest.getParent());
139     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
140     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
141     Assert.assertTrue(
142         channelProvider.isHeaderSent(
143             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
144             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
145   }
146 
147   @Test
listInstancesExceptionTest()148   public void listInstancesExceptionTest() throws Exception {
149     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
150     mockNotebookService.addException(exception);
151 
152     try {
153       ListInstancesRequest request =
154           ListInstancesRequest.newBuilder()
155               .setParent("parent-995424086")
156               .setPageSize(883849137)
157               .setPageToken("pageToken873572522")
158               .build();
159       client.listInstances(request);
160       Assert.fail("No exception raised");
161     } catch (InvalidArgumentException e) {
162       // Expected exception.
163     }
164   }
165 
166   @Test
getInstanceTest()167   public void getInstanceTest() throws Exception {
168     Instance expectedResponse =
169         Instance.newBuilder()
170             .setName("name3373707")
171             .setPostStartupScript("postStartupScript870779112")
172             .setProxyUri("proxyUri-985185250")
173             .addAllInstanceOwners(new ArrayList<String>())
174             .setServiceAccount("serviceAccount1079137720")
175             .setMachineType("machineType-218117087")
176             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
177             .setInstallGpuDriver(true)
178             .setCustomGpuDriverPath("customGpuDriverPath509224520")
179             .setBootDiskSizeGb(1398920548)
180             .setDataDiskSizeGb(-1668379732)
181             .setNoRemoveDataDisk(true)
182             .setKmsKey("kmsKey-1127483058")
183             .setNoPublicIp(true)
184             .setNoProxyAccess(true)
185             .setNetwork("network1843485230")
186             .setSubnet("subnet-891534499")
187             .putAllLabels(new HashMap<String, String>())
188             .putAllMetadata(new HashMap<String, String>())
189             .setReservationAffinity(ReservationAffinity.newBuilder().build())
190             .setCanIpForward(true)
191             .setCreateTime(Timestamp.newBuilder().build())
192             .setUpdateTime(Timestamp.newBuilder().build())
193             .build();
194     mockNotebookService.addResponse(expectedResponse);
195 
196     GetInstanceRequest request = GetInstanceRequest.newBuilder().setName("name3373707").build();
197 
198     Instance actualResponse = client.getInstance(request);
199     Assert.assertEquals(expectedResponse, actualResponse);
200 
201     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
202     Assert.assertEquals(1, actualRequests.size());
203     GetInstanceRequest actualRequest = ((GetInstanceRequest) actualRequests.get(0));
204 
205     Assert.assertEquals(request.getName(), actualRequest.getName());
206     Assert.assertTrue(
207         channelProvider.isHeaderSent(
208             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
209             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
210   }
211 
212   @Test
getInstanceExceptionTest()213   public void getInstanceExceptionTest() throws Exception {
214     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
215     mockNotebookService.addException(exception);
216 
217     try {
218       GetInstanceRequest request = GetInstanceRequest.newBuilder().setName("name3373707").build();
219       client.getInstance(request);
220       Assert.fail("No exception raised");
221     } catch (InvalidArgumentException e) {
222       // Expected exception.
223     }
224   }
225 
226   @Test
createInstanceTest()227   public void createInstanceTest() throws Exception {
228     Instance expectedResponse =
229         Instance.newBuilder()
230             .setName("name3373707")
231             .setPostStartupScript("postStartupScript870779112")
232             .setProxyUri("proxyUri-985185250")
233             .addAllInstanceOwners(new ArrayList<String>())
234             .setServiceAccount("serviceAccount1079137720")
235             .setMachineType("machineType-218117087")
236             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
237             .setInstallGpuDriver(true)
238             .setCustomGpuDriverPath("customGpuDriverPath509224520")
239             .setBootDiskSizeGb(1398920548)
240             .setDataDiskSizeGb(-1668379732)
241             .setNoRemoveDataDisk(true)
242             .setKmsKey("kmsKey-1127483058")
243             .setNoPublicIp(true)
244             .setNoProxyAccess(true)
245             .setNetwork("network1843485230")
246             .setSubnet("subnet-891534499")
247             .putAllLabels(new HashMap<String, String>())
248             .putAllMetadata(new HashMap<String, String>())
249             .setReservationAffinity(ReservationAffinity.newBuilder().build())
250             .setCanIpForward(true)
251             .setCreateTime(Timestamp.newBuilder().build())
252             .setUpdateTime(Timestamp.newBuilder().build())
253             .build();
254     Operation resultOperation =
255         Operation.newBuilder()
256             .setName("createInstanceTest")
257             .setDone(true)
258             .setResponse(Any.pack(expectedResponse))
259             .build();
260     mockNotebookService.addResponse(resultOperation);
261 
262     CreateInstanceRequest request =
263         CreateInstanceRequest.newBuilder()
264             .setParent("parent-995424086")
265             .setInstanceId("instanceId902024336")
266             .setInstance(Instance.newBuilder().build())
267             .build();
268 
269     Instance actualResponse = client.createInstanceAsync(request).get();
270     Assert.assertEquals(expectedResponse, actualResponse);
271 
272     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
273     Assert.assertEquals(1, actualRequests.size());
274     CreateInstanceRequest actualRequest = ((CreateInstanceRequest) actualRequests.get(0));
275 
276     Assert.assertEquals(request.getParent(), actualRequest.getParent());
277     Assert.assertEquals(request.getInstanceId(), actualRequest.getInstanceId());
278     Assert.assertEquals(request.getInstance(), actualRequest.getInstance());
279     Assert.assertTrue(
280         channelProvider.isHeaderSent(
281             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
282             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
283   }
284 
285   @Test
createInstanceExceptionTest()286   public void createInstanceExceptionTest() throws Exception {
287     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
288     mockNotebookService.addException(exception);
289 
290     try {
291       CreateInstanceRequest request =
292           CreateInstanceRequest.newBuilder()
293               .setParent("parent-995424086")
294               .setInstanceId("instanceId902024336")
295               .setInstance(Instance.newBuilder().build())
296               .build();
297       client.createInstanceAsync(request).get();
298       Assert.fail("No exception raised");
299     } catch (ExecutionException e) {
300       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
301       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
302       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
303     }
304   }
305 
306   @Test
registerInstanceTest()307   public void registerInstanceTest() throws Exception {
308     Instance expectedResponse =
309         Instance.newBuilder()
310             .setName("name3373707")
311             .setPostStartupScript("postStartupScript870779112")
312             .setProxyUri("proxyUri-985185250")
313             .addAllInstanceOwners(new ArrayList<String>())
314             .setServiceAccount("serviceAccount1079137720")
315             .setMachineType("machineType-218117087")
316             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
317             .setInstallGpuDriver(true)
318             .setCustomGpuDriverPath("customGpuDriverPath509224520")
319             .setBootDiskSizeGb(1398920548)
320             .setDataDiskSizeGb(-1668379732)
321             .setNoRemoveDataDisk(true)
322             .setKmsKey("kmsKey-1127483058")
323             .setNoPublicIp(true)
324             .setNoProxyAccess(true)
325             .setNetwork("network1843485230")
326             .setSubnet("subnet-891534499")
327             .putAllLabels(new HashMap<String, String>())
328             .putAllMetadata(new HashMap<String, String>())
329             .setReservationAffinity(ReservationAffinity.newBuilder().build())
330             .setCanIpForward(true)
331             .setCreateTime(Timestamp.newBuilder().build())
332             .setUpdateTime(Timestamp.newBuilder().build())
333             .build();
334     Operation resultOperation =
335         Operation.newBuilder()
336             .setName("registerInstanceTest")
337             .setDone(true)
338             .setResponse(Any.pack(expectedResponse))
339             .build();
340     mockNotebookService.addResponse(resultOperation);
341 
342     RegisterInstanceRequest request =
343         RegisterInstanceRequest.newBuilder()
344             .setParent("parent-995424086")
345             .setInstanceId("instanceId902024336")
346             .build();
347 
348     Instance actualResponse = client.registerInstanceAsync(request).get();
349     Assert.assertEquals(expectedResponse, actualResponse);
350 
351     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
352     Assert.assertEquals(1, actualRequests.size());
353     RegisterInstanceRequest actualRequest = ((RegisterInstanceRequest) actualRequests.get(0));
354 
355     Assert.assertEquals(request.getParent(), actualRequest.getParent());
356     Assert.assertEquals(request.getInstanceId(), actualRequest.getInstanceId());
357     Assert.assertTrue(
358         channelProvider.isHeaderSent(
359             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
360             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
361   }
362 
363   @Test
registerInstanceExceptionTest()364   public void registerInstanceExceptionTest() throws Exception {
365     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
366     mockNotebookService.addException(exception);
367 
368     try {
369       RegisterInstanceRequest request =
370           RegisterInstanceRequest.newBuilder()
371               .setParent("parent-995424086")
372               .setInstanceId("instanceId902024336")
373               .build();
374       client.registerInstanceAsync(request).get();
375       Assert.fail("No exception raised");
376     } catch (ExecutionException e) {
377       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
378       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
379       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
380     }
381   }
382 
383   @Test
setInstanceAcceleratorTest()384   public void setInstanceAcceleratorTest() throws Exception {
385     Instance expectedResponse =
386         Instance.newBuilder()
387             .setName("name3373707")
388             .setPostStartupScript("postStartupScript870779112")
389             .setProxyUri("proxyUri-985185250")
390             .addAllInstanceOwners(new ArrayList<String>())
391             .setServiceAccount("serviceAccount1079137720")
392             .setMachineType("machineType-218117087")
393             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
394             .setInstallGpuDriver(true)
395             .setCustomGpuDriverPath("customGpuDriverPath509224520")
396             .setBootDiskSizeGb(1398920548)
397             .setDataDiskSizeGb(-1668379732)
398             .setNoRemoveDataDisk(true)
399             .setKmsKey("kmsKey-1127483058")
400             .setNoPublicIp(true)
401             .setNoProxyAccess(true)
402             .setNetwork("network1843485230")
403             .setSubnet("subnet-891534499")
404             .putAllLabels(new HashMap<String, String>())
405             .putAllMetadata(new HashMap<String, String>())
406             .setReservationAffinity(ReservationAffinity.newBuilder().build())
407             .setCanIpForward(true)
408             .setCreateTime(Timestamp.newBuilder().build())
409             .setUpdateTime(Timestamp.newBuilder().build())
410             .build();
411     Operation resultOperation =
412         Operation.newBuilder()
413             .setName("setInstanceAcceleratorTest")
414             .setDone(true)
415             .setResponse(Any.pack(expectedResponse))
416             .build();
417     mockNotebookService.addResponse(resultOperation);
418 
419     SetInstanceAcceleratorRequest request =
420         SetInstanceAcceleratorRequest.newBuilder()
421             .setName("name3373707")
422             .setCoreCount(-1963855761)
423             .build();
424 
425     Instance actualResponse = client.setInstanceAcceleratorAsync(request).get();
426     Assert.assertEquals(expectedResponse, actualResponse);
427 
428     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
429     Assert.assertEquals(1, actualRequests.size());
430     SetInstanceAcceleratorRequest actualRequest =
431         ((SetInstanceAcceleratorRequest) actualRequests.get(0));
432 
433     Assert.assertEquals(request.getName(), actualRequest.getName());
434     Assert.assertEquals(request.getType(), actualRequest.getType());
435     Assert.assertEquals(request.getCoreCount(), actualRequest.getCoreCount());
436     Assert.assertTrue(
437         channelProvider.isHeaderSent(
438             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
439             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
440   }
441 
442   @Test
setInstanceAcceleratorExceptionTest()443   public void setInstanceAcceleratorExceptionTest() throws Exception {
444     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
445     mockNotebookService.addException(exception);
446 
447     try {
448       SetInstanceAcceleratorRequest request =
449           SetInstanceAcceleratorRequest.newBuilder()
450               .setName("name3373707")
451               .setCoreCount(-1963855761)
452               .build();
453       client.setInstanceAcceleratorAsync(request).get();
454       Assert.fail("No exception raised");
455     } catch (ExecutionException e) {
456       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
457       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
458       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
459     }
460   }
461 
462   @Test
setInstanceMachineTypeTest()463   public void setInstanceMachineTypeTest() throws Exception {
464     Instance expectedResponse =
465         Instance.newBuilder()
466             .setName("name3373707")
467             .setPostStartupScript("postStartupScript870779112")
468             .setProxyUri("proxyUri-985185250")
469             .addAllInstanceOwners(new ArrayList<String>())
470             .setServiceAccount("serviceAccount1079137720")
471             .setMachineType("machineType-218117087")
472             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
473             .setInstallGpuDriver(true)
474             .setCustomGpuDriverPath("customGpuDriverPath509224520")
475             .setBootDiskSizeGb(1398920548)
476             .setDataDiskSizeGb(-1668379732)
477             .setNoRemoveDataDisk(true)
478             .setKmsKey("kmsKey-1127483058")
479             .setNoPublicIp(true)
480             .setNoProxyAccess(true)
481             .setNetwork("network1843485230")
482             .setSubnet("subnet-891534499")
483             .putAllLabels(new HashMap<String, String>())
484             .putAllMetadata(new HashMap<String, String>())
485             .setReservationAffinity(ReservationAffinity.newBuilder().build())
486             .setCanIpForward(true)
487             .setCreateTime(Timestamp.newBuilder().build())
488             .setUpdateTime(Timestamp.newBuilder().build())
489             .build();
490     Operation resultOperation =
491         Operation.newBuilder()
492             .setName("setInstanceMachineTypeTest")
493             .setDone(true)
494             .setResponse(Any.pack(expectedResponse))
495             .build();
496     mockNotebookService.addResponse(resultOperation);
497 
498     SetInstanceMachineTypeRequest request =
499         SetInstanceMachineTypeRequest.newBuilder()
500             .setName("name3373707")
501             .setMachineType("machineType-218117087")
502             .build();
503 
504     Instance actualResponse = client.setInstanceMachineTypeAsync(request).get();
505     Assert.assertEquals(expectedResponse, actualResponse);
506 
507     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
508     Assert.assertEquals(1, actualRequests.size());
509     SetInstanceMachineTypeRequest actualRequest =
510         ((SetInstanceMachineTypeRequest) actualRequests.get(0));
511 
512     Assert.assertEquals(request.getName(), actualRequest.getName());
513     Assert.assertEquals(request.getMachineType(), actualRequest.getMachineType());
514     Assert.assertTrue(
515         channelProvider.isHeaderSent(
516             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
517             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
518   }
519 
520   @Test
setInstanceMachineTypeExceptionTest()521   public void setInstanceMachineTypeExceptionTest() throws Exception {
522     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
523     mockNotebookService.addException(exception);
524 
525     try {
526       SetInstanceMachineTypeRequest request =
527           SetInstanceMachineTypeRequest.newBuilder()
528               .setName("name3373707")
529               .setMachineType("machineType-218117087")
530               .build();
531       client.setInstanceMachineTypeAsync(request).get();
532       Assert.fail("No exception raised");
533     } catch (ExecutionException e) {
534       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
535       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
536       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
537     }
538   }
539 
540   @Test
setInstanceLabelsTest()541   public void setInstanceLabelsTest() throws Exception {
542     Instance expectedResponse =
543         Instance.newBuilder()
544             .setName("name3373707")
545             .setPostStartupScript("postStartupScript870779112")
546             .setProxyUri("proxyUri-985185250")
547             .addAllInstanceOwners(new ArrayList<String>())
548             .setServiceAccount("serviceAccount1079137720")
549             .setMachineType("machineType-218117087")
550             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
551             .setInstallGpuDriver(true)
552             .setCustomGpuDriverPath("customGpuDriverPath509224520")
553             .setBootDiskSizeGb(1398920548)
554             .setDataDiskSizeGb(-1668379732)
555             .setNoRemoveDataDisk(true)
556             .setKmsKey("kmsKey-1127483058")
557             .setNoPublicIp(true)
558             .setNoProxyAccess(true)
559             .setNetwork("network1843485230")
560             .setSubnet("subnet-891534499")
561             .putAllLabels(new HashMap<String, String>())
562             .putAllMetadata(new HashMap<String, String>())
563             .setReservationAffinity(ReservationAffinity.newBuilder().build())
564             .setCanIpForward(true)
565             .setCreateTime(Timestamp.newBuilder().build())
566             .setUpdateTime(Timestamp.newBuilder().build())
567             .build();
568     Operation resultOperation =
569         Operation.newBuilder()
570             .setName("setInstanceLabelsTest")
571             .setDone(true)
572             .setResponse(Any.pack(expectedResponse))
573             .build();
574     mockNotebookService.addResponse(resultOperation);
575 
576     SetInstanceLabelsRequest request =
577         SetInstanceLabelsRequest.newBuilder()
578             .setName("name3373707")
579             .putAllLabels(new HashMap<String, String>())
580             .build();
581 
582     Instance actualResponse = client.setInstanceLabelsAsync(request).get();
583     Assert.assertEquals(expectedResponse, actualResponse);
584 
585     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
586     Assert.assertEquals(1, actualRequests.size());
587     SetInstanceLabelsRequest actualRequest = ((SetInstanceLabelsRequest) actualRequests.get(0));
588 
589     Assert.assertEquals(request.getName(), actualRequest.getName());
590     Assert.assertEquals(request.getLabelsMap(), actualRequest.getLabelsMap());
591     Assert.assertTrue(
592         channelProvider.isHeaderSent(
593             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
594             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
595   }
596 
597   @Test
setInstanceLabelsExceptionTest()598   public void setInstanceLabelsExceptionTest() throws Exception {
599     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
600     mockNotebookService.addException(exception);
601 
602     try {
603       SetInstanceLabelsRequest request =
604           SetInstanceLabelsRequest.newBuilder()
605               .setName("name3373707")
606               .putAllLabels(new HashMap<String, String>())
607               .build();
608       client.setInstanceLabelsAsync(request).get();
609       Assert.fail("No exception raised");
610     } catch (ExecutionException e) {
611       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
612       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
613       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
614     }
615   }
616 
617   @Test
deleteInstanceTest()618   public void deleteInstanceTest() throws Exception {
619     Empty expectedResponse = Empty.newBuilder().build();
620     Operation resultOperation =
621         Operation.newBuilder()
622             .setName("deleteInstanceTest")
623             .setDone(true)
624             .setResponse(Any.pack(expectedResponse))
625             .build();
626     mockNotebookService.addResponse(resultOperation);
627 
628     DeleteInstanceRequest request =
629         DeleteInstanceRequest.newBuilder().setName("name3373707").build();
630 
631     client.deleteInstanceAsync(request).get();
632 
633     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
634     Assert.assertEquals(1, actualRequests.size());
635     DeleteInstanceRequest actualRequest = ((DeleteInstanceRequest) actualRequests.get(0));
636 
637     Assert.assertEquals(request.getName(), actualRequest.getName());
638     Assert.assertTrue(
639         channelProvider.isHeaderSent(
640             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
641             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
642   }
643 
644   @Test
deleteInstanceExceptionTest()645   public void deleteInstanceExceptionTest() throws Exception {
646     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
647     mockNotebookService.addException(exception);
648 
649     try {
650       DeleteInstanceRequest request =
651           DeleteInstanceRequest.newBuilder().setName("name3373707").build();
652       client.deleteInstanceAsync(request).get();
653       Assert.fail("No exception raised");
654     } catch (ExecutionException e) {
655       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
656       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
657       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
658     }
659   }
660 
661   @Test
startInstanceTest()662   public void startInstanceTest() throws Exception {
663     Instance expectedResponse =
664         Instance.newBuilder()
665             .setName("name3373707")
666             .setPostStartupScript("postStartupScript870779112")
667             .setProxyUri("proxyUri-985185250")
668             .addAllInstanceOwners(new ArrayList<String>())
669             .setServiceAccount("serviceAccount1079137720")
670             .setMachineType("machineType-218117087")
671             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
672             .setInstallGpuDriver(true)
673             .setCustomGpuDriverPath("customGpuDriverPath509224520")
674             .setBootDiskSizeGb(1398920548)
675             .setDataDiskSizeGb(-1668379732)
676             .setNoRemoveDataDisk(true)
677             .setKmsKey("kmsKey-1127483058")
678             .setNoPublicIp(true)
679             .setNoProxyAccess(true)
680             .setNetwork("network1843485230")
681             .setSubnet("subnet-891534499")
682             .putAllLabels(new HashMap<String, String>())
683             .putAllMetadata(new HashMap<String, String>())
684             .setReservationAffinity(ReservationAffinity.newBuilder().build())
685             .setCanIpForward(true)
686             .setCreateTime(Timestamp.newBuilder().build())
687             .setUpdateTime(Timestamp.newBuilder().build())
688             .build();
689     Operation resultOperation =
690         Operation.newBuilder()
691             .setName("startInstanceTest")
692             .setDone(true)
693             .setResponse(Any.pack(expectedResponse))
694             .build();
695     mockNotebookService.addResponse(resultOperation);
696 
697     StartInstanceRequest request = StartInstanceRequest.newBuilder().setName("name3373707").build();
698 
699     Instance actualResponse = client.startInstanceAsync(request).get();
700     Assert.assertEquals(expectedResponse, actualResponse);
701 
702     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
703     Assert.assertEquals(1, actualRequests.size());
704     StartInstanceRequest actualRequest = ((StartInstanceRequest) actualRequests.get(0));
705 
706     Assert.assertEquals(request.getName(), actualRequest.getName());
707     Assert.assertTrue(
708         channelProvider.isHeaderSent(
709             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
710             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
711   }
712 
713   @Test
startInstanceExceptionTest()714   public void startInstanceExceptionTest() throws Exception {
715     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
716     mockNotebookService.addException(exception);
717 
718     try {
719       StartInstanceRequest request =
720           StartInstanceRequest.newBuilder().setName("name3373707").build();
721       client.startInstanceAsync(request).get();
722       Assert.fail("No exception raised");
723     } catch (ExecutionException e) {
724       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
725       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
726       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
727     }
728   }
729 
730   @Test
stopInstanceTest()731   public void stopInstanceTest() throws Exception {
732     Instance expectedResponse =
733         Instance.newBuilder()
734             .setName("name3373707")
735             .setPostStartupScript("postStartupScript870779112")
736             .setProxyUri("proxyUri-985185250")
737             .addAllInstanceOwners(new ArrayList<String>())
738             .setServiceAccount("serviceAccount1079137720")
739             .setMachineType("machineType-218117087")
740             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
741             .setInstallGpuDriver(true)
742             .setCustomGpuDriverPath("customGpuDriverPath509224520")
743             .setBootDiskSizeGb(1398920548)
744             .setDataDiskSizeGb(-1668379732)
745             .setNoRemoveDataDisk(true)
746             .setKmsKey("kmsKey-1127483058")
747             .setNoPublicIp(true)
748             .setNoProxyAccess(true)
749             .setNetwork("network1843485230")
750             .setSubnet("subnet-891534499")
751             .putAllLabels(new HashMap<String, String>())
752             .putAllMetadata(new HashMap<String, String>())
753             .setReservationAffinity(ReservationAffinity.newBuilder().build())
754             .setCanIpForward(true)
755             .setCreateTime(Timestamp.newBuilder().build())
756             .setUpdateTime(Timestamp.newBuilder().build())
757             .build();
758     Operation resultOperation =
759         Operation.newBuilder()
760             .setName("stopInstanceTest")
761             .setDone(true)
762             .setResponse(Any.pack(expectedResponse))
763             .build();
764     mockNotebookService.addResponse(resultOperation);
765 
766     StopInstanceRequest request = StopInstanceRequest.newBuilder().setName("name3373707").build();
767 
768     Instance actualResponse = client.stopInstanceAsync(request).get();
769     Assert.assertEquals(expectedResponse, actualResponse);
770 
771     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
772     Assert.assertEquals(1, actualRequests.size());
773     StopInstanceRequest actualRequest = ((StopInstanceRequest) actualRequests.get(0));
774 
775     Assert.assertEquals(request.getName(), actualRequest.getName());
776     Assert.assertTrue(
777         channelProvider.isHeaderSent(
778             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
779             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
780   }
781 
782   @Test
stopInstanceExceptionTest()783   public void stopInstanceExceptionTest() throws Exception {
784     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
785     mockNotebookService.addException(exception);
786 
787     try {
788       StopInstanceRequest request = StopInstanceRequest.newBuilder().setName("name3373707").build();
789       client.stopInstanceAsync(request).get();
790       Assert.fail("No exception raised");
791     } catch (ExecutionException e) {
792       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
793       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
794       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
795     }
796   }
797 
798   @Test
resetInstanceTest()799   public void resetInstanceTest() throws Exception {
800     Instance expectedResponse =
801         Instance.newBuilder()
802             .setName("name3373707")
803             .setPostStartupScript("postStartupScript870779112")
804             .setProxyUri("proxyUri-985185250")
805             .addAllInstanceOwners(new ArrayList<String>())
806             .setServiceAccount("serviceAccount1079137720")
807             .setMachineType("machineType-218117087")
808             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
809             .setInstallGpuDriver(true)
810             .setCustomGpuDriverPath("customGpuDriverPath509224520")
811             .setBootDiskSizeGb(1398920548)
812             .setDataDiskSizeGb(-1668379732)
813             .setNoRemoveDataDisk(true)
814             .setKmsKey("kmsKey-1127483058")
815             .setNoPublicIp(true)
816             .setNoProxyAccess(true)
817             .setNetwork("network1843485230")
818             .setSubnet("subnet-891534499")
819             .putAllLabels(new HashMap<String, String>())
820             .putAllMetadata(new HashMap<String, String>())
821             .setReservationAffinity(ReservationAffinity.newBuilder().build())
822             .setCanIpForward(true)
823             .setCreateTime(Timestamp.newBuilder().build())
824             .setUpdateTime(Timestamp.newBuilder().build())
825             .build();
826     Operation resultOperation =
827         Operation.newBuilder()
828             .setName("resetInstanceTest")
829             .setDone(true)
830             .setResponse(Any.pack(expectedResponse))
831             .build();
832     mockNotebookService.addResponse(resultOperation);
833 
834     ResetInstanceRequest request = ResetInstanceRequest.newBuilder().setName("name3373707").build();
835 
836     Instance actualResponse = client.resetInstanceAsync(request).get();
837     Assert.assertEquals(expectedResponse, actualResponse);
838 
839     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
840     Assert.assertEquals(1, actualRequests.size());
841     ResetInstanceRequest actualRequest = ((ResetInstanceRequest) actualRequests.get(0));
842 
843     Assert.assertEquals(request.getName(), actualRequest.getName());
844     Assert.assertTrue(
845         channelProvider.isHeaderSent(
846             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
847             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
848   }
849 
850   @Test
resetInstanceExceptionTest()851   public void resetInstanceExceptionTest() throws Exception {
852     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
853     mockNotebookService.addException(exception);
854 
855     try {
856       ResetInstanceRequest request =
857           ResetInstanceRequest.newBuilder().setName("name3373707").build();
858       client.resetInstanceAsync(request).get();
859       Assert.fail("No exception raised");
860     } catch (ExecutionException e) {
861       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
862       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
863       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
864     }
865   }
866 
867   @Test
reportInstanceInfoTest()868   public void reportInstanceInfoTest() throws Exception {
869     Instance expectedResponse =
870         Instance.newBuilder()
871             .setName("name3373707")
872             .setPostStartupScript("postStartupScript870779112")
873             .setProxyUri("proxyUri-985185250")
874             .addAllInstanceOwners(new ArrayList<String>())
875             .setServiceAccount("serviceAccount1079137720")
876             .setMachineType("machineType-218117087")
877             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
878             .setInstallGpuDriver(true)
879             .setCustomGpuDriverPath("customGpuDriverPath509224520")
880             .setBootDiskSizeGb(1398920548)
881             .setDataDiskSizeGb(-1668379732)
882             .setNoRemoveDataDisk(true)
883             .setKmsKey("kmsKey-1127483058")
884             .setNoPublicIp(true)
885             .setNoProxyAccess(true)
886             .setNetwork("network1843485230")
887             .setSubnet("subnet-891534499")
888             .putAllLabels(new HashMap<String, String>())
889             .putAllMetadata(new HashMap<String, String>())
890             .setReservationAffinity(ReservationAffinity.newBuilder().build())
891             .setCanIpForward(true)
892             .setCreateTime(Timestamp.newBuilder().build())
893             .setUpdateTime(Timestamp.newBuilder().build())
894             .build();
895     Operation resultOperation =
896         Operation.newBuilder()
897             .setName("reportInstanceInfoTest")
898             .setDone(true)
899             .setResponse(Any.pack(expectedResponse))
900             .build();
901     mockNotebookService.addResponse(resultOperation);
902 
903     ReportInstanceInfoRequest request =
904         ReportInstanceInfoRequest.newBuilder()
905             .setName("name3373707")
906             .setVmId("vmId3622450")
907             .putAllMetadata(new HashMap<String, String>())
908             .build();
909 
910     Instance actualResponse = client.reportInstanceInfoAsync(request).get();
911     Assert.assertEquals(expectedResponse, actualResponse);
912 
913     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
914     Assert.assertEquals(1, actualRequests.size());
915     ReportInstanceInfoRequest actualRequest = ((ReportInstanceInfoRequest) actualRequests.get(0));
916 
917     Assert.assertEquals(request.getName(), actualRequest.getName());
918     Assert.assertEquals(request.getVmId(), actualRequest.getVmId());
919     Assert.assertEquals(request.getMetadataMap(), actualRequest.getMetadataMap());
920     Assert.assertTrue(
921         channelProvider.isHeaderSent(
922             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
923             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
924   }
925 
926   @Test
reportInstanceInfoExceptionTest()927   public void reportInstanceInfoExceptionTest() throws Exception {
928     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
929     mockNotebookService.addException(exception);
930 
931     try {
932       ReportInstanceInfoRequest request =
933           ReportInstanceInfoRequest.newBuilder()
934               .setName("name3373707")
935               .setVmId("vmId3622450")
936               .putAllMetadata(new HashMap<String, String>())
937               .build();
938       client.reportInstanceInfoAsync(request).get();
939       Assert.fail("No exception raised");
940     } catch (ExecutionException e) {
941       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
942       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
943       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
944     }
945   }
946 
947   @Test
isInstanceUpgradeableTest()948   public void isInstanceUpgradeableTest() throws Exception {
949     IsInstanceUpgradeableResponse expectedResponse =
950         IsInstanceUpgradeableResponse.newBuilder()
951             .setUpgradeable(true)
952             .setUpgradeVersion("upgradeVersion-392903908")
953             .setUpgradeInfo("upgradeInfo-1844902678")
954             .setUpgradeImage("upgradeImage-1357442913")
955             .build();
956     mockNotebookService.addResponse(expectedResponse);
957 
958     IsInstanceUpgradeableRequest request =
959         IsInstanceUpgradeableRequest.newBuilder()
960             .setNotebookInstance("notebookInstance-544239728")
961             .build();
962 
963     IsInstanceUpgradeableResponse actualResponse = client.isInstanceUpgradeable(request);
964     Assert.assertEquals(expectedResponse, actualResponse);
965 
966     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
967     Assert.assertEquals(1, actualRequests.size());
968     IsInstanceUpgradeableRequest actualRequest =
969         ((IsInstanceUpgradeableRequest) actualRequests.get(0));
970 
971     Assert.assertEquals(request.getNotebookInstance(), actualRequest.getNotebookInstance());
972     Assert.assertTrue(
973         channelProvider.isHeaderSent(
974             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
975             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
976   }
977 
978   @Test
isInstanceUpgradeableExceptionTest()979   public void isInstanceUpgradeableExceptionTest() throws Exception {
980     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
981     mockNotebookService.addException(exception);
982 
983     try {
984       IsInstanceUpgradeableRequest request =
985           IsInstanceUpgradeableRequest.newBuilder()
986               .setNotebookInstance("notebookInstance-544239728")
987               .build();
988       client.isInstanceUpgradeable(request);
989       Assert.fail("No exception raised");
990     } catch (InvalidArgumentException e) {
991       // Expected exception.
992     }
993   }
994 
995   @Test
upgradeInstanceTest()996   public void upgradeInstanceTest() throws Exception {
997     Instance expectedResponse =
998         Instance.newBuilder()
999             .setName("name3373707")
1000             .setPostStartupScript("postStartupScript870779112")
1001             .setProxyUri("proxyUri-985185250")
1002             .addAllInstanceOwners(new ArrayList<String>())
1003             .setServiceAccount("serviceAccount1079137720")
1004             .setMachineType("machineType-218117087")
1005             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
1006             .setInstallGpuDriver(true)
1007             .setCustomGpuDriverPath("customGpuDriverPath509224520")
1008             .setBootDiskSizeGb(1398920548)
1009             .setDataDiskSizeGb(-1668379732)
1010             .setNoRemoveDataDisk(true)
1011             .setKmsKey("kmsKey-1127483058")
1012             .setNoPublicIp(true)
1013             .setNoProxyAccess(true)
1014             .setNetwork("network1843485230")
1015             .setSubnet("subnet-891534499")
1016             .putAllLabels(new HashMap<String, String>())
1017             .putAllMetadata(new HashMap<String, String>())
1018             .setReservationAffinity(ReservationAffinity.newBuilder().build())
1019             .setCanIpForward(true)
1020             .setCreateTime(Timestamp.newBuilder().build())
1021             .setUpdateTime(Timestamp.newBuilder().build())
1022             .build();
1023     Operation resultOperation =
1024         Operation.newBuilder()
1025             .setName("upgradeInstanceTest")
1026             .setDone(true)
1027             .setResponse(Any.pack(expectedResponse))
1028             .build();
1029     mockNotebookService.addResponse(resultOperation);
1030 
1031     UpgradeInstanceRequest request =
1032         UpgradeInstanceRequest.newBuilder().setName("name3373707").build();
1033 
1034     Instance actualResponse = client.upgradeInstanceAsync(request).get();
1035     Assert.assertEquals(expectedResponse, actualResponse);
1036 
1037     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
1038     Assert.assertEquals(1, actualRequests.size());
1039     UpgradeInstanceRequest actualRequest = ((UpgradeInstanceRequest) actualRequests.get(0));
1040 
1041     Assert.assertEquals(request.getName(), actualRequest.getName());
1042     Assert.assertTrue(
1043         channelProvider.isHeaderSent(
1044             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1045             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1046   }
1047 
1048   @Test
upgradeInstanceExceptionTest()1049   public void upgradeInstanceExceptionTest() throws Exception {
1050     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1051     mockNotebookService.addException(exception);
1052 
1053     try {
1054       UpgradeInstanceRequest request =
1055           UpgradeInstanceRequest.newBuilder().setName("name3373707").build();
1056       client.upgradeInstanceAsync(request).get();
1057       Assert.fail("No exception raised");
1058     } catch (ExecutionException e) {
1059       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1060       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1061       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1062     }
1063   }
1064 
1065   @Test
upgradeInstanceInternalTest()1066   public void upgradeInstanceInternalTest() throws Exception {
1067     Instance expectedResponse =
1068         Instance.newBuilder()
1069             .setName("name3373707")
1070             .setPostStartupScript("postStartupScript870779112")
1071             .setProxyUri("proxyUri-985185250")
1072             .addAllInstanceOwners(new ArrayList<String>())
1073             .setServiceAccount("serviceAccount1079137720")
1074             .setMachineType("machineType-218117087")
1075             .setAcceleratorConfig(Instance.AcceleratorConfig.newBuilder().build())
1076             .setInstallGpuDriver(true)
1077             .setCustomGpuDriverPath("customGpuDriverPath509224520")
1078             .setBootDiskSizeGb(1398920548)
1079             .setDataDiskSizeGb(-1668379732)
1080             .setNoRemoveDataDisk(true)
1081             .setKmsKey("kmsKey-1127483058")
1082             .setNoPublicIp(true)
1083             .setNoProxyAccess(true)
1084             .setNetwork("network1843485230")
1085             .setSubnet("subnet-891534499")
1086             .putAllLabels(new HashMap<String, String>())
1087             .putAllMetadata(new HashMap<String, String>())
1088             .setReservationAffinity(ReservationAffinity.newBuilder().build())
1089             .setCanIpForward(true)
1090             .setCreateTime(Timestamp.newBuilder().build())
1091             .setUpdateTime(Timestamp.newBuilder().build())
1092             .build();
1093     Operation resultOperation =
1094         Operation.newBuilder()
1095             .setName("upgradeInstanceInternalTest")
1096             .setDone(true)
1097             .setResponse(Any.pack(expectedResponse))
1098             .build();
1099     mockNotebookService.addResponse(resultOperation);
1100 
1101     UpgradeInstanceInternalRequest request =
1102         UpgradeInstanceInternalRequest.newBuilder()
1103             .setName("name3373707")
1104             .setVmId("vmId3622450")
1105             .build();
1106 
1107     Instance actualResponse = client.upgradeInstanceInternalAsync(request).get();
1108     Assert.assertEquals(expectedResponse, actualResponse);
1109 
1110     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
1111     Assert.assertEquals(1, actualRequests.size());
1112     UpgradeInstanceInternalRequest actualRequest =
1113         ((UpgradeInstanceInternalRequest) actualRequests.get(0));
1114 
1115     Assert.assertEquals(request.getName(), actualRequest.getName());
1116     Assert.assertEquals(request.getVmId(), actualRequest.getVmId());
1117     Assert.assertTrue(
1118         channelProvider.isHeaderSent(
1119             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1120             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1121   }
1122 
1123   @Test
upgradeInstanceInternalExceptionTest()1124   public void upgradeInstanceInternalExceptionTest() throws Exception {
1125     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1126     mockNotebookService.addException(exception);
1127 
1128     try {
1129       UpgradeInstanceInternalRequest request =
1130           UpgradeInstanceInternalRequest.newBuilder()
1131               .setName("name3373707")
1132               .setVmId("vmId3622450")
1133               .build();
1134       client.upgradeInstanceInternalAsync(request).get();
1135       Assert.fail("No exception raised");
1136     } catch (ExecutionException e) {
1137       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1138       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1139       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1140     }
1141   }
1142 
1143   @Test
listEnvironmentsTest()1144   public void listEnvironmentsTest() throws Exception {
1145     Environment responsesElement = Environment.newBuilder().build();
1146     ListEnvironmentsResponse expectedResponse =
1147         ListEnvironmentsResponse.newBuilder()
1148             .setNextPageToken("")
1149             .addAllEnvironments(Arrays.asList(responsesElement))
1150             .build();
1151     mockNotebookService.addResponse(expectedResponse);
1152 
1153     ListEnvironmentsRequest request =
1154         ListEnvironmentsRequest.newBuilder()
1155             .setParent("parent-995424086")
1156             .setPageSize(883849137)
1157             .setPageToken("pageToken873572522")
1158             .build();
1159 
1160     ListEnvironmentsPagedResponse pagedListResponse = client.listEnvironments(request);
1161 
1162     List<Environment> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1163 
1164     Assert.assertEquals(1, resources.size());
1165     Assert.assertEquals(expectedResponse.getEnvironmentsList().get(0), resources.get(0));
1166 
1167     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
1168     Assert.assertEquals(1, actualRequests.size());
1169     ListEnvironmentsRequest actualRequest = ((ListEnvironmentsRequest) actualRequests.get(0));
1170 
1171     Assert.assertEquals(request.getParent(), actualRequest.getParent());
1172     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1173     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1174     Assert.assertTrue(
1175         channelProvider.isHeaderSent(
1176             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1177             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1178   }
1179 
1180   @Test
listEnvironmentsExceptionTest()1181   public void listEnvironmentsExceptionTest() throws Exception {
1182     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1183     mockNotebookService.addException(exception);
1184 
1185     try {
1186       ListEnvironmentsRequest request =
1187           ListEnvironmentsRequest.newBuilder()
1188               .setParent("parent-995424086")
1189               .setPageSize(883849137)
1190               .setPageToken("pageToken873572522")
1191               .build();
1192       client.listEnvironments(request);
1193       Assert.fail("No exception raised");
1194     } catch (InvalidArgumentException e) {
1195       // Expected exception.
1196     }
1197   }
1198 
1199   @Test
getEnvironmentTest()1200   public void getEnvironmentTest() throws Exception {
1201     Environment expectedResponse =
1202         Environment.newBuilder()
1203             .setName("name3373707")
1204             .setDisplayName("displayName1714148973")
1205             .setDescription("description-1724546052")
1206             .setPostStartupScript("postStartupScript870779112")
1207             .setCreateTime(Timestamp.newBuilder().build())
1208             .build();
1209     mockNotebookService.addResponse(expectedResponse);
1210 
1211     GetEnvironmentRequest request =
1212         GetEnvironmentRequest.newBuilder().setName("name3373707").build();
1213 
1214     Environment actualResponse = client.getEnvironment(request);
1215     Assert.assertEquals(expectedResponse, actualResponse);
1216 
1217     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
1218     Assert.assertEquals(1, actualRequests.size());
1219     GetEnvironmentRequest actualRequest = ((GetEnvironmentRequest) actualRequests.get(0));
1220 
1221     Assert.assertEquals(request.getName(), actualRequest.getName());
1222     Assert.assertTrue(
1223         channelProvider.isHeaderSent(
1224             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1225             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1226   }
1227 
1228   @Test
getEnvironmentExceptionTest()1229   public void getEnvironmentExceptionTest() throws Exception {
1230     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1231     mockNotebookService.addException(exception);
1232 
1233     try {
1234       GetEnvironmentRequest request =
1235           GetEnvironmentRequest.newBuilder().setName("name3373707").build();
1236       client.getEnvironment(request);
1237       Assert.fail("No exception raised");
1238     } catch (InvalidArgumentException e) {
1239       // Expected exception.
1240     }
1241   }
1242 
1243   @Test
createEnvironmentTest()1244   public void createEnvironmentTest() throws Exception {
1245     Environment expectedResponse =
1246         Environment.newBuilder()
1247             .setName("name3373707")
1248             .setDisplayName("displayName1714148973")
1249             .setDescription("description-1724546052")
1250             .setPostStartupScript("postStartupScript870779112")
1251             .setCreateTime(Timestamp.newBuilder().build())
1252             .build();
1253     Operation resultOperation =
1254         Operation.newBuilder()
1255             .setName("createEnvironmentTest")
1256             .setDone(true)
1257             .setResponse(Any.pack(expectedResponse))
1258             .build();
1259     mockNotebookService.addResponse(resultOperation);
1260 
1261     CreateEnvironmentRequest request =
1262         CreateEnvironmentRequest.newBuilder()
1263             .setParent("parent-995424086")
1264             .setEnvironmentId("environmentId-950205810")
1265             .setEnvironment(Environment.newBuilder().build())
1266             .build();
1267 
1268     Environment actualResponse = client.createEnvironmentAsync(request).get();
1269     Assert.assertEquals(expectedResponse, actualResponse);
1270 
1271     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
1272     Assert.assertEquals(1, actualRequests.size());
1273     CreateEnvironmentRequest actualRequest = ((CreateEnvironmentRequest) actualRequests.get(0));
1274 
1275     Assert.assertEquals(request.getParent(), actualRequest.getParent());
1276     Assert.assertEquals(request.getEnvironmentId(), actualRequest.getEnvironmentId());
1277     Assert.assertEquals(request.getEnvironment(), actualRequest.getEnvironment());
1278     Assert.assertTrue(
1279         channelProvider.isHeaderSent(
1280             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1281             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1282   }
1283 
1284   @Test
createEnvironmentExceptionTest()1285   public void createEnvironmentExceptionTest() throws Exception {
1286     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1287     mockNotebookService.addException(exception);
1288 
1289     try {
1290       CreateEnvironmentRequest request =
1291           CreateEnvironmentRequest.newBuilder()
1292               .setParent("parent-995424086")
1293               .setEnvironmentId("environmentId-950205810")
1294               .setEnvironment(Environment.newBuilder().build())
1295               .build();
1296       client.createEnvironmentAsync(request).get();
1297       Assert.fail("No exception raised");
1298     } catch (ExecutionException e) {
1299       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1300       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1301       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1302     }
1303   }
1304 
1305   @Test
deleteEnvironmentTest()1306   public void deleteEnvironmentTest() throws Exception {
1307     Empty expectedResponse = Empty.newBuilder().build();
1308     Operation resultOperation =
1309         Operation.newBuilder()
1310             .setName("deleteEnvironmentTest")
1311             .setDone(true)
1312             .setResponse(Any.pack(expectedResponse))
1313             .build();
1314     mockNotebookService.addResponse(resultOperation);
1315 
1316     DeleteEnvironmentRequest request =
1317         DeleteEnvironmentRequest.newBuilder().setName("name3373707").build();
1318 
1319     client.deleteEnvironmentAsync(request).get();
1320 
1321     List<AbstractMessage> actualRequests = mockNotebookService.getRequests();
1322     Assert.assertEquals(1, actualRequests.size());
1323     DeleteEnvironmentRequest actualRequest = ((DeleteEnvironmentRequest) actualRequests.get(0));
1324 
1325     Assert.assertEquals(request.getName(), actualRequest.getName());
1326     Assert.assertTrue(
1327         channelProvider.isHeaderSent(
1328             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1329             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1330   }
1331 
1332   @Test
deleteEnvironmentExceptionTest()1333   public void deleteEnvironmentExceptionTest() throws Exception {
1334     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1335     mockNotebookService.addException(exception);
1336 
1337     try {
1338       DeleteEnvironmentRequest request =
1339           DeleteEnvironmentRequest.newBuilder().setName("name3373707").build();
1340       client.deleteEnvironmentAsync(request).get();
1341       Assert.fail("No exception raised");
1342     } catch (ExecutionException e) {
1343       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1344       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1345       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1346     }
1347   }
1348 
1349   @Test
listLocationsTest()1350   public void listLocationsTest() throws Exception {
1351     Location responsesElement = Location.newBuilder().build();
1352     ListLocationsResponse expectedResponse =
1353         ListLocationsResponse.newBuilder()
1354             .setNextPageToken("")
1355             .addAllLocations(Arrays.asList(responsesElement))
1356             .build();
1357     mockLocations.addResponse(expectedResponse);
1358 
1359     ListLocationsRequest request =
1360         ListLocationsRequest.newBuilder()
1361             .setName("name3373707")
1362             .setFilter("filter-1274492040")
1363             .setPageSize(883849137)
1364             .setPageToken("pageToken873572522")
1365             .build();
1366 
1367     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
1368 
1369     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1370 
1371     Assert.assertEquals(1, resources.size());
1372     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
1373 
1374     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1375     Assert.assertEquals(1, actualRequests.size());
1376     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
1377 
1378     Assert.assertEquals(request.getName(), actualRequest.getName());
1379     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
1380     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
1381     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
1382     Assert.assertTrue(
1383         channelProvider.isHeaderSent(
1384             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1385             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1386   }
1387 
1388   @Test
listLocationsExceptionTest()1389   public void listLocationsExceptionTest() throws Exception {
1390     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1391     mockLocations.addException(exception);
1392 
1393     try {
1394       ListLocationsRequest request =
1395           ListLocationsRequest.newBuilder()
1396               .setName("name3373707")
1397               .setFilter("filter-1274492040")
1398               .setPageSize(883849137)
1399               .setPageToken("pageToken873572522")
1400               .build();
1401       client.listLocations(request);
1402       Assert.fail("No exception raised");
1403     } catch (InvalidArgumentException e) {
1404       // Expected exception.
1405     }
1406   }
1407 
1408   @Test
getLocationTest()1409   public void getLocationTest() throws Exception {
1410     Location expectedResponse =
1411         Location.newBuilder()
1412             .setName("name3373707")
1413             .setLocationId("locationId1541836720")
1414             .setDisplayName("displayName1714148973")
1415             .putAllLabels(new HashMap<String, String>())
1416             .setMetadata(Any.newBuilder().build())
1417             .build();
1418     mockLocations.addResponse(expectedResponse);
1419 
1420     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1421 
1422     Location actualResponse = client.getLocation(request);
1423     Assert.assertEquals(expectedResponse, actualResponse);
1424 
1425     List<AbstractMessage> actualRequests = mockLocations.getRequests();
1426     Assert.assertEquals(1, actualRequests.size());
1427     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
1428 
1429     Assert.assertEquals(request.getName(), actualRequest.getName());
1430     Assert.assertTrue(
1431         channelProvider.isHeaderSent(
1432             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1433             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1434   }
1435 
1436   @Test
getLocationExceptionTest()1437   public void getLocationExceptionTest() throws Exception {
1438     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1439     mockLocations.addException(exception);
1440 
1441     try {
1442       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
1443       client.getLocation(request);
1444       Assert.fail("No exception raised");
1445     } catch (InvalidArgumentException e) {
1446       // Expected exception.
1447     }
1448   }
1449 
1450   @Test
setIamPolicyTest()1451   public void setIamPolicyTest() throws Exception {
1452     Policy expectedResponse =
1453         Policy.newBuilder()
1454             .setVersion(351608024)
1455             .addAllBindings(new ArrayList<Binding>())
1456             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1457             .setEtag(ByteString.EMPTY)
1458             .build();
1459     mockIAMPolicy.addResponse(expectedResponse);
1460 
1461     SetIamPolicyRequest request =
1462         SetIamPolicyRequest.newBuilder()
1463             .setResource("SetIamPolicyRequest1223629066".toString())
1464             .setPolicy(Policy.newBuilder().build())
1465             .setUpdateMask(FieldMask.newBuilder().build())
1466             .build();
1467 
1468     Policy actualResponse = client.setIamPolicy(request);
1469     Assert.assertEquals(expectedResponse, actualResponse);
1470 
1471     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1472     Assert.assertEquals(1, actualRequests.size());
1473     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1474 
1475     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1476     Assert.assertEquals(request.getPolicy(), actualRequest.getPolicy());
1477     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
1478     Assert.assertTrue(
1479         channelProvider.isHeaderSent(
1480             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1481             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1482   }
1483 
1484   @Test
setIamPolicyExceptionTest()1485   public void setIamPolicyExceptionTest() throws Exception {
1486     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1487     mockIAMPolicy.addException(exception);
1488 
1489     try {
1490       SetIamPolicyRequest request =
1491           SetIamPolicyRequest.newBuilder()
1492               .setResource("SetIamPolicyRequest1223629066".toString())
1493               .setPolicy(Policy.newBuilder().build())
1494               .setUpdateMask(FieldMask.newBuilder().build())
1495               .build();
1496       client.setIamPolicy(request);
1497       Assert.fail("No exception raised");
1498     } catch (InvalidArgumentException e) {
1499       // Expected exception.
1500     }
1501   }
1502 
1503   @Test
getIamPolicyTest()1504   public void getIamPolicyTest() throws Exception {
1505     Policy expectedResponse =
1506         Policy.newBuilder()
1507             .setVersion(351608024)
1508             .addAllBindings(new ArrayList<Binding>())
1509             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1510             .setEtag(ByteString.EMPTY)
1511             .build();
1512     mockIAMPolicy.addResponse(expectedResponse);
1513 
1514     GetIamPolicyRequest request =
1515         GetIamPolicyRequest.newBuilder()
1516             .setResource("GetIamPolicyRequest-1527610370".toString())
1517             .setOptions(GetPolicyOptions.newBuilder().build())
1518             .build();
1519 
1520     Policy actualResponse = client.getIamPolicy(request);
1521     Assert.assertEquals(expectedResponse, actualResponse);
1522 
1523     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1524     Assert.assertEquals(1, actualRequests.size());
1525     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
1526 
1527     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1528     Assert.assertEquals(request.getOptions(), actualRequest.getOptions());
1529     Assert.assertTrue(
1530         channelProvider.isHeaderSent(
1531             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1532             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1533   }
1534 
1535   @Test
getIamPolicyExceptionTest()1536   public void getIamPolicyExceptionTest() throws Exception {
1537     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1538     mockIAMPolicy.addException(exception);
1539 
1540     try {
1541       GetIamPolicyRequest request =
1542           GetIamPolicyRequest.newBuilder()
1543               .setResource("GetIamPolicyRequest-1527610370".toString())
1544               .setOptions(GetPolicyOptions.newBuilder().build())
1545               .build();
1546       client.getIamPolicy(request);
1547       Assert.fail("No exception raised");
1548     } catch (InvalidArgumentException e) {
1549       // Expected exception.
1550     }
1551   }
1552 
1553   @Test
testIamPermissionsTest()1554   public void testIamPermissionsTest() throws Exception {
1555     TestIamPermissionsResponse expectedResponse =
1556         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1557     mockIAMPolicy.addResponse(expectedResponse);
1558 
1559     TestIamPermissionsRequest request =
1560         TestIamPermissionsRequest.newBuilder()
1561             .setResource("TestIamPermissionsRequest942398222".toString())
1562             .addAllPermissions(new ArrayList<String>())
1563             .build();
1564 
1565     TestIamPermissionsResponse actualResponse = client.testIamPermissions(request);
1566     Assert.assertEquals(expectedResponse, actualResponse);
1567 
1568     List<AbstractMessage> actualRequests = mockIAMPolicy.getRequests();
1569     Assert.assertEquals(1, actualRequests.size());
1570     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
1571 
1572     Assert.assertEquals(request.getResource(), actualRequest.getResource());
1573     Assert.assertEquals(request.getPermissionsList(), actualRequest.getPermissionsList());
1574     Assert.assertTrue(
1575         channelProvider.isHeaderSent(
1576             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1577             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1578   }
1579 
1580   @Test
testIamPermissionsExceptionTest()1581   public void testIamPermissionsExceptionTest() throws Exception {
1582     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1583     mockIAMPolicy.addException(exception);
1584 
1585     try {
1586       TestIamPermissionsRequest request =
1587           TestIamPermissionsRequest.newBuilder()
1588               .setResource("TestIamPermissionsRequest942398222".toString())
1589               .addAllPermissions(new ArrayList<String>())
1590               .build();
1591       client.testIamPermissions(request);
1592       Assert.fail("No exception raised");
1593     } catch (InvalidArgumentException e) {
1594       // Expected exception.
1595     }
1596   }
1597 }
1598