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