• 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.shell.v1;
18 
19 import com.google.api.gax.core.NoCredentialsProvider;
20 import com.google.api.gax.grpc.GaxGrpcProperties;
21 import com.google.api.gax.grpc.testing.LocalChannelProvider;
22 import com.google.api.gax.grpc.testing.MockGrpcService;
23 import com.google.api.gax.grpc.testing.MockServiceHelper;
24 import com.google.api.gax.rpc.ApiClientHeaderProvider;
25 import com.google.api.gax.rpc.InvalidArgumentException;
26 import com.google.api.gax.rpc.StatusCode;
27 import com.google.longrunning.Operation;
28 import com.google.protobuf.AbstractMessage;
29 import com.google.protobuf.Any;
30 import com.google.protobuf.Timestamp;
31 import io.grpc.StatusRuntimeException;
32 import java.io.IOException;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.List;
36 import java.util.UUID;
37 import java.util.concurrent.ExecutionException;
38 import javax.annotation.Generated;
39 import org.junit.After;
40 import org.junit.AfterClass;
41 import org.junit.Assert;
42 import org.junit.Before;
43 import org.junit.BeforeClass;
44 import org.junit.Test;
45 
46 @Generated("by gapic-generator-java")
47 public class CloudShellServiceClientTest {
48   private static MockCloudShellService mockCloudShellService;
49   private static MockServiceHelper mockServiceHelper;
50   private LocalChannelProvider channelProvider;
51   private CloudShellServiceClient client;
52 
53   @BeforeClass
startStaticServer()54   public static void startStaticServer() {
55     mockCloudShellService = new MockCloudShellService();
56     mockServiceHelper =
57         new MockServiceHelper(
58             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockCloudShellService));
59     mockServiceHelper.start();
60   }
61 
62   @AfterClass
stopServer()63   public static void stopServer() {
64     mockServiceHelper.stop();
65   }
66 
67   @Before
setUp()68   public void setUp() throws IOException {
69     mockServiceHelper.reset();
70     channelProvider = mockServiceHelper.createChannelProvider();
71     CloudShellServiceSettings settings =
72         CloudShellServiceSettings.newBuilder()
73             .setTransportChannelProvider(channelProvider)
74             .setCredentialsProvider(NoCredentialsProvider.create())
75             .build();
76     client = CloudShellServiceClient.create(settings);
77   }
78 
79   @After
tearDown()80   public void tearDown() throws Exception {
81     client.close();
82   }
83 
84   @Test
getEnvironmentTest()85   public void getEnvironmentTest() throws Exception {
86     Environment expectedResponse =
87         Environment.newBuilder()
88             .setName(EnvironmentName.of("[USER]", "[ENVIRONMENT]").toString())
89             .setId("id3355")
90             .setDockerImage("dockerImage2086149915")
91             .setWebHost("webHost1223060252")
92             .setSshUsername("sshUsername-812965122")
93             .setSshHost("sshHost-1920605232")
94             .setSshPort(612046936)
95             .addAllPublicKeys(new ArrayList<String>())
96             .build();
97     mockCloudShellService.addResponse(expectedResponse);
98 
99     EnvironmentName name = EnvironmentName.of("[USER]", "[ENVIRONMENT]");
100 
101     Environment actualResponse = client.getEnvironment(name);
102     Assert.assertEquals(expectedResponse, actualResponse);
103 
104     List<AbstractMessage> actualRequests = mockCloudShellService.getRequests();
105     Assert.assertEquals(1, actualRequests.size());
106     GetEnvironmentRequest actualRequest = ((GetEnvironmentRequest) actualRequests.get(0));
107 
108     Assert.assertEquals(name.toString(), actualRequest.getName());
109     Assert.assertTrue(
110         channelProvider.isHeaderSent(
111             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
112             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
113   }
114 
115   @Test
getEnvironmentExceptionTest()116   public void getEnvironmentExceptionTest() throws Exception {
117     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
118     mockCloudShellService.addException(exception);
119 
120     try {
121       EnvironmentName name = EnvironmentName.of("[USER]", "[ENVIRONMENT]");
122       client.getEnvironment(name);
123       Assert.fail("No exception raised");
124     } catch (InvalidArgumentException e) {
125       // Expected exception.
126     }
127   }
128 
129   @Test
getEnvironmentTest2()130   public void getEnvironmentTest2() throws Exception {
131     Environment expectedResponse =
132         Environment.newBuilder()
133             .setName(EnvironmentName.of("[USER]", "[ENVIRONMENT]").toString())
134             .setId("id3355")
135             .setDockerImage("dockerImage2086149915")
136             .setWebHost("webHost1223060252")
137             .setSshUsername("sshUsername-812965122")
138             .setSshHost("sshHost-1920605232")
139             .setSshPort(612046936)
140             .addAllPublicKeys(new ArrayList<String>())
141             .build();
142     mockCloudShellService.addResponse(expectedResponse);
143 
144     String name = "name3373707";
145 
146     Environment actualResponse = client.getEnvironment(name);
147     Assert.assertEquals(expectedResponse, actualResponse);
148 
149     List<AbstractMessage> actualRequests = mockCloudShellService.getRequests();
150     Assert.assertEquals(1, actualRequests.size());
151     GetEnvironmentRequest actualRequest = ((GetEnvironmentRequest) actualRequests.get(0));
152 
153     Assert.assertEquals(name, actualRequest.getName());
154     Assert.assertTrue(
155         channelProvider.isHeaderSent(
156             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
157             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
158   }
159 
160   @Test
getEnvironmentExceptionTest2()161   public void getEnvironmentExceptionTest2() throws Exception {
162     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
163     mockCloudShellService.addException(exception);
164 
165     try {
166       String name = "name3373707";
167       client.getEnvironment(name);
168       Assert.fail("No exception raised");
169     } catch (InvalidArgumentException e) {
170       // Expected exception.
171     }
172   }
173 
174   @Test
startEnvironmentTest()175   public void startEnvironmentTest() throws Exception {
176     StartEnvironmentResponse expectedResponse =
177         StartEnvironmentResponse.newBuilder()
178             .setEnvironment(Environment.newBuilder().build())
179             .build();
180     Operation resultOperation =
181         Operation.newBuilder()
182             .setName("startEnvironmentTest")
183             .setDone(true)
184             .setResponse(Any.pack(expectedResponse))
185             .build();
186     mockCloudShellService.addResponse(resultOperation);
187 
188     StartEnvironmentRequest request =
189         StartEnvironmentRequest.newBuilder()
190             .setName("name3373707")
191             .setAccessToken("accessToken-1042689291")
192             .addAllPublicKeys(new ArrayList<String>())
193             .build();
194 
195     StartEnvironmentResponse actualResponse = client.startEnvironmentAsync(request).get();
196     Assert.assertEquals(expectedResponse, actualResponse);
197 
198     List<AbstractMessage> actualRequests = mockCloudShellService.getRequests();
199     Assert.assertEquals(1, actualRequests.size());
200     StartEnvironmentRequest actualRequest = ((StartEnvironmentRequest) actualRequests.get(0));
201 
202     Assert.assertEquals(request.getName(), actualRequest.getName());
203     Assert.assertEquals(request.getAccessToken(), actualRequest.getAccessToken());
204     Assert.assertEquals(request.getPublicKeysList(), actualRequest.getPublicKeysList());
205     Assert.assertTrue(
206         channelProvider.isHeaderSent(
207             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
208             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
209   }
210 
211   @Test
startEnvironmentExceptionTest()212   public void startEnvironmentExceptionTest() throws Exception {
213     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
214     mockCloudShellService.addException(exception);
215 
216     try {
217       StartEnvironmentRequest request =
218           StartEnvironmentRequest.newBuilder()
219               .setName("name3373707")
220               .setAccessToken("accessToken-1042689291")
221               .addAllPublicKeys(new ArrayList<String>())
222               .build();
223       client.startEnvironmentAsync(request).get();
224       Assert.fail("No exception raised");
225     } catch (ExecutionException e) {
226       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
227       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
228       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
229     }
230   }
231 
232   @Test
authorizeEnvironmentTest()233   public void authorizeEnvironmentTest() throws Exception {
234     AuthorizeEnvironmentResponse expectedResponse =
235         AuthorizeEnvironmentResponse.newBuilder().build();
236     Operation resultOperation =
237         Operation.newBuilder()
238             .setName("authorizeEnvironmentTest")
239             .setDone(true)
240             .setResponse(Any.pack(expectedResponse))
241             .build();
242     mockCloudShellService.addResponse(resultOperation);
243 
244     AuthorizeEnvironmentRequest request =
245         AuthorizeEnvironmentRequest.newBuilder()
246             .setName("name3373707")
247             .setAccessToken("accessToken-1042689291")
248             .setIdToken("idToken1642509726")
249             .setExpireTime(Timestamp.newBuilder().build())
250             .build();
251 
252     AuthorizeEnvironmentResponse actualResponse = client.authorizeEnvironmentAsync(request).get();
253     Assert.assertEquals(expectedResponse, actualResponse);
254 
255     List<AbstractMessage> actualRequests = mockCloudShellService.getRequests();
256     Assert.assertEquals(1, actualRequests.size());
257     AuthorizeEnvironmentRequest actualRequest =
258         ((AuthorizeEnvironmentRequest) actualRequests.get(0));
259 
260     Assert.assertEquals(request.getName(), actualRequest.getName());
261     Assert.assertEquals(request.getAccessToken(), actualRequest.getAccessToken());
262     Assert.assertEquals(request.getIdToken(), actualRequest.getIdToken());
263     Assert.assertEquals(request.getExpireTime(), actualRequest.getExpireTime());
264     Assert.assertTrue(
265         channelProvider.isHeaderSent(
266             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
267             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
268   }
269 
270   @Test
authorizeEnvironmentExceptionTest()271   public void authorizeEnvironmentExceptionTest() throws Exception {
272     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
273     mockCloudShellService.addException(exception);
274 
275     try {
276       AuthorizeEnvironmentRequest request =
277           AuthorizeEnvironmentRequest.newBuilder()
278               .setName("name3373707")
279               .setAccessToken("accessToken-1042689291")
280               .setIdToken("idToken1642509726")
281               .setExpireTime(Timestamp.newBuilder().build())
282               .build();
283       client.authorizeEnvironmentAsync(request).get();
284       Assert.fail("No exception raised");
285     } catch (ExecutionException e) {
286       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
287       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
288       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
289     }
290   }
291 
292   @Test
addPublicKeyTest()293   public void addPublicKeyTest() throws Exception {
294     AddPublicKeyResponse expectedResponse =
295         AddPublicKeyResponse.newBuilder().setKey("key106079").build();
296     Operation resultOperation =
297         Operation.newBuilder()
298             .setName("addPublicKeyTest")
299             .setDone(true)
300             .setResponse(Any.pack(expectedResponse))
301             .build();
302     mockCloudShellService.addResponse(resultOperation);
303 
304     AddPublicKeyRequest request =
305         AddPublicKeyRequest.newBuilder()
306             .setEnvironment("environment-85904877")
307             .setKey("key106079")
308             .build();
309 
310     AddPublicKeyResponse actualResponse = client.addPublicKeyAsync(request).get();
311     Assert.assertEquals(expectedResponse, actualResponse);
312 
313     List<AbstractMessage> actualRequests = mockCloudShellService.getRequests();
314     Assert.assertEquals(1, actualRequests.size());
315     AddPublicKeyRequest actualRequest = ((AddPublicKeyRequest) actualRequests.get(0));
316 
317     Assert.assertEquals(request.getEnvironment(), actualRequest.getEnvironment());
318     Assert.assertEquals(request.getKey(), actualRequest.getKey());
319     Assert.assertTrue(
320         channelProvider.isHeaderSent(
321             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
322             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
323   }
324 
325   @Test
addPublicKeyExceptionTest()326   public void addPublicKeyExceptionTest() throws Exception {
327     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
328     mockCloudShellService.addException(exception);
329 
330     try {
331       AddPublicKeyRequest request =
332           AddPublicKeyRequest.newBuilder()
333               .setEnvironment("environment-85904877")
334               .setKey("key106079")
335               .build();
336       client.addPublicKeyAsync(request).get();
337       Assert.fail("No exception raised");
338     } catch (ExecutionException e) {
339       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
340       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
341       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
342     }
343   }
344 
345   @Test
removePublicKeyTest()346   public void removePublicKeyTest() throws Exception {
347     RemovePublicKeyResponse expectedResponse = RemovePublicKeyResponse.newBuilder().build();
348     Operation resultOperation =
349         Operation.newBuilder()
350             .setName("removePublicKeyTest")
351             .setDone(true)
352             .setResponse(Any.pack(expectedResponse))
353             .build();
354     mockCloudShellService.addResponse(resultOperation);
355 
356     RemovePublicKeyRequest request =
357         RemovePublicKeyRequest.newBuilder()
358             .setEnvironment("environment-85904877")
359             .setKey("key106079")
360             .build();
361 
362     RemovePublicKeyResponse actualResponse = client.removePublicKeyAsync(request).get();
363     Assert.assertEquals(expectedResponse, actualResponse);
364 
365     List<AbstractMessage> actualRequests = mockCloudShellService.getRequests();
366     Assert.assertEquals(1, actualRequests.size());
367     RemovePublicKeyRequest actualRequest = ((RemovePublicKeyRequest) actualRequests.get(0));
368 
369     Assert.assertEquals(request.getEnvironment(), actualRequest.getEnvironment());
370     Assert.assertEquals(request.getKey(), actualRequest.getKey());
371     Assert.assertTrue(
372         channelProvider.isHeaderSent(
373             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
374             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
375   }
376 
377   @Test
removePublicKeyExceptionTest()378   public void removePublicKeyExceptionTest() throws Exception {
379     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
380     mockCloudShellService.addException(exception);
381 
382     try {
383       RemovePublicKeyRequest request =
384           RemovePublicKeyRequest.newBuilder()
385               .setEnvironment("environment-85904877")
386               .setKey("key106079")
387               .build();
388       client.removePublicKeyAsync(request).get();
389       Assert.fail("No exception raised");
390     } catch (ExecutionException e) {
391       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
392       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
393       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
394     }
395   }
396 }
397