• 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.oslogin.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.cloud.oslogin.common.OsLoginProto;
27 import com.google.protobuf.AbstractMessage;
28 import com.google.protobuf.Empty;
29 import com.google.protobuf.FieldMask;
30 import io.grpc.StatusRuntimeException;
31 import java.io.IOException;
32 import java.util.ArrayList;
33 import java.util.Arrays;
34 import java.util.HashMap;
35 import java.util.List;
36 import java.util.UUID;
37 import javax.annotation.Generated;
38 import org.junit.After;
39 import org.junit.AfterClass;
40 import org.junit.Assert;
41 import org.junit.Before;
42 import org.junit.BeforeClass;
43 import org.junit.Test;
44 
45 @Generated("by gapic-generator-java")
46 public class OsLoginServiceClientTest {
47   private static MockOsLoginService mockOsLoginService;
48   private static MockServiceHelper mockServiceHelper;
49   private LocalChannelProvider channelProvider;
50   private OsLoginServiceClient client;
51 
52   @BeforeClass
startStaticServer()53   public static void startStaticServer() {
54     mockOsLoginService = new MockOsLoginService();
55     mockServiceHelper =
56         new MockServiceHelper(
57             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockOsLoginService));
58     mockServiceHelper.start();
59   }
60 
61   @AfterClass
stopServer()62   public static void stopServer() {
63     mockServiceHelper.stop();
64   }
65 
66   @Before
setUp()67   public void setUp() throws IOException {
68     mockServiceHelper.reset();
69     channelProvider = mockServiceHelper.createChannelProvider();
70     OsLoginServiceSettings settings =
71         OsLoginServiceSettings.newBuilder()
72             .setTransportChannelProvider(channelProvider)
73             .setCredentialsProvider(NoCredentialsProvider.create())
74             .build();
75     client = OsLoginServiceClient.create(settings);
76   }
77 
78   @After
tearDown()79   public void tearDown() throws Exception {
80     client.close();
81   }
82 
83   @Test
createSshPublicKeyTest()84   public void createSshPublicKeyTest() throws Exception {
85     OsLoginProto.SshPublicKey expectedResponse =
86         OsLoginProto.SshPublicKey.newBuilder()
87             .setKey("key106079")
88             .setExpirationTimeUsec(-2058878882)
89             .setFingerprint("fingerprint-1375934236")
90             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
91             .build();
92     mockOsLoginService.addResponse(expectedResponse);
93 
94     UserName parent = UserName.of("[USER]");
95     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
96 
97     OsLoginProto.SshPublicKey actualResponse = client.createSshPublicKey(parent, sshPublicKey);
98     Assert.assertEquals(expectedResponse, actualResponse);
99 
100     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
101     Assert.assertEquals(1, actualRequests.size());
102     CreateSshPublicKeyRequest actualRequest = ((CreateSshPublicKeyRequest) actualRequests.get(0));
103 
104     Assert.assertEquals(parent.toString(), actualRequest.getParent());
105     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
106     Assert.assertTrue(
107         channelProvider.isHeaderSent(
108             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
109             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
110   }
111 
112   @Test
createSshPublicKeyExceptionTest()113   public void createSshPublicKeyExceptionTest() throws Exception {
114     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
115     mockOsLoginService.addException(exception);
116 
117     try {
118       UserName parent = UserName.of("[USER]");
119       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
120       client.createSshPublicKey(parent, sshPublicKey);
121       Assert.fail("No exception raised");
122     } catch (InvalidArgumentException e) {
123       // Expected exception.
124     }
125   }
126 
127   @Test
createSshPublicKeyTest2()128   public void createSshPublicKeyTest2() throws Exception {
129     OsLoginProto.SshPublicKey expectedResponse =
130         OsLoginProto.SshPublicKey.newBuilder()
131             .setKey("key106079")
132             .setExpirationTimeUsec(-2058878882)
133             .setFingerprint("fingerprint-1375934236")
134             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
135             .build();
136     mockOsLoginService.addResponse(expectedResponse);
137 
138     String parent = "parent-995424086";
139     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
140 
141     OsLoginProto.SshPublicKey actualResponse = client.createSshPublicKey(parent, sshPublicKey);
142     Assert.assertEquals(expectedResponse, actualResponse);
143 
144     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
145     Assert.assertEquals(1, actualRequests.size());
146     CreateSshPublicKeyRequest actualRequest = ((CreateSshPublicKeyRequest) actualRequests.get(0));
147 
148     Assert.assertEquals(parent, actualRequest.getParent());
149     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
150     Assert.assertTrue(
151         channelProvider.isHeaderSent(
152             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
153             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
154   }
155 
156   @Test
createSshPublicKeyExceptionTest2()157   public void createSshPublicKeyExceptionTest2() throws Exception {
158     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
159     mockOsLoginService.addException(exception);
160 
161     try {
162       String parent = "parent-995424086";
163       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
164       client.createSshPublicKey(parent, sshPublicKey);
165       Assert.fail("No exception raised");
166     } catch (InvalidArgumentException e) {
167       // Expected exception.
168     }
169   }
170 
171   @Test
deletePosixAccountTest()172   public void deletePosixAccountTest() throws Exception {
173     Empty expectedResponse = Empty.newBuilder().build();
174     mockOsLoginService.addResponse(expectedResponse);
175 
176     ProjectName name = ProjectName.of("[USER]", "[PROJECT]");
177 
178     client.deletePosixAccount(name);
179 
180     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
181     Assert.assertEquals(1, actualRequests.size());
182     DeletePosixAccountRequest actualRequest = ((DeletePosixAccountRequest) actualRequests.get(0));
183 
184     Assert.assertEquals(name.toString(), actualRequest.getName());
185     Assert.assertTrue(
186         channelProvider.isHeaderSent(
187             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
188             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
189   }
190 
191   @Test
deletePosixAccountExceptionTest()192   public void deletePosixAccountExceptionTest() throws Exception {
193     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
194     mockOsLoginService.addException(exception);
195 
196     try {
197       ProjectName name = ProjectName.of("[USER]", "[PROJECT]");
198       client.deletePosixAccount(name);
199       Assert.fail("No exception raised");
200     } catch (InvalidArgumentException e) {
201       // Expected exception.
202     }
203   }
204 
205   @Test
deletePosixAccountTest2()206   public void deletePosixAccountTest2() throws Exception {
207     Empty expectedResponse = Empty.newBuilder().build();
208     mockOsLoginService.addResponse(expectedResponse);
209 
210     String name = "name3373707";
211 
212     client.deletePosixAccount(name);
213 
214     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
215     Assert.assertEquals(1, actualRequests.size());
216     DeletePosixAccountRequest actualRequest = ((DeletePosixAccountRequest) actualRequests.get(0));
217 
218     Assert.assertEquals(name, actualRequest.getName());
219     Assert.assertTrue(
220         channelProvider.isHeaderSent(
221             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
222             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
223   }
224 
225   @Test
deletePosixAccountExceptionTest2()226   public void deletePosixAccountExceptionTest2() throws Exception {
227     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
228     mockOsLoginService.addException(exception);
229 
230     try {
231       String name = "name3373707";
232       client.deletePosixAccount(name);
233       Assert.fail("No exception raised");
234     } catch (InvalidArgumentException e) {
235       // Expected exception.
236     }
237   }
238 
239   @Test
deleteSshPublicKeyTest()240   public void deleteSshPublicKeyTest() throws Exception {
241     Empty expectedResponse = Empty.newBuilder().build();
242     mockOsLoginService.addResponse(expectedResponse);
243 
244     FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
245 
246     client.deleteSshPublicKey(name);
247 
248     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
249     Assert.assertEquals(1, actualRequests.size());
250     DeleteSshPublicKeyRequest actualRequest = ((DeleteSshPublicKeyRequest) actualRequests.get(0));
251 
252     Assert.assertEquals(name.toString(), actualRequest.getName());
253     Assert.assertTrue(
254         channelProvider.isHeaderSent(
255             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
256             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
257   }
258 
259   @Test
deleteSshPublicKeyExceptionTest()260   public void deleteSshPublicKeyExceptionTest() throws Exception {
261     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
262     mockOsLoginService.addException(exception);
263 
264     try {
265       FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
266       client.deleteSshPublicKey(name);
267       Assert.fail("No exception raised");
268     } catch (InvalidArgumentException e) {
269       // Expected exception.
270     }
271   }
272 
273   @Test
deleteSshPublicKeyTest2()274   public void deleteSshPublicKeyTest2() throws Exception {
275     Empty expectedResponse = Empty.newBuilder().build();
276     mockOsLoginService.addResponse(expectedResponse);
277 
278     String name = "name3373707";
279 
280     client.deleteSshPublicKey(name);
281 
282     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
283     Assert.assertEquals(1, actualRequests.size());
284     DeleteSshPublicKeyRequest actualRequest = ((DeleteSshPublicKeyRequest) actualRequests.get(0));
285 
286     Assert.assertEquals(name, actualRequest.getName());
287     Assert.assertTrue(
288         channelProvider.isHeaderSent(
289             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
290             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
291   }
292 
293   @Test
deleteSshPublicKeyExceptionTest2()294   public void deleteSshPublicKeyExceptionTest2() throws Exception {
295     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
296     mockOsLoginService.addException(exception);
297 
298     try {
299       String name = "name3373707";
300       client.deleteSshPublicKey(name);
301       Assert.fail("No exception raised");
302     } catch (InvalidArgumentException e) {
303       // Expected exception.
304     }
305   }
306 
307   @Test
getLoginProfileTest()308   public void getLoginProfileTest() throws Exception {
309     LoginProfile expectedResponse =
310         LoginProfile.newBuilder()
311             .setName("name3373707")
312             .addAllPosixAccounts(new ArrayList<OsLoginProto.PosixAccount>())
313             .putAllSshPublicKeys(new HashMap<String, OsLoginProto.SshPublicKey>())
314             .build();
315     mockOsLoginService.addResponse(expectedResponse);
316 
317     UserName name = UserName.of("[USER]");
318 
319     LoginProfile actualResponse = client.getLoginProfile(name);
320     Assert.assertEquals(expectedResponse, actualResponse);
321 
322     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
323     Assert.assertEquals(1, actualRequests.size());
324     GetLoginProfileRequest actualRequest = ((GetLoginProfileRequest) actualRequests.get(0));
325 
326     Assert.assertEquals(name.toString(), actualRequest.getName());
327     Assert.assertTrue(
328         channelProvider.isHeaderSent(
329             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
330             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
331   }
332 
333   @Test
getLoginProfileExceptionTest()334   public void getLoginProfileExceptionTest() throws Exception {
335     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
336     mockOsLoginService.addException(exception);
337 
338     try {
339       UserName name = UserName.of("[USER]");
340       client.getLoginProfile(name);
341       Assert.fail("No exception raised");
342     } catch (InvalidArgumentException e) {
343       // Expected exception.
344     }
345   }
346 
347   @Test
getLoginProfileTest2()348   public void getLoginProfileTest2() throws Exception {
349     LoginProfile expectedResponse =
350         LoginProfile.newBuilder()
351             .setName("name3373707")
352             .addAllPosixAccounts(new ArrayList<OsLoginProto.PosixAccount>())
353             .putAllSshPublicKeys(new HashMap<String, OsLoginProto.SshPublicKey>())
354             .build();
355     mockOsLoginService.addResponse(expectedResponse);
356 
357     String name = "name3373707";
358 
359     LoginProfile actualResponse = client.getLoginProfile(name);
360     Assert.assertEquals(expectedResponse, actualResponse);
361 
362     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
363     Assert.assertEquals(1, actualRequests.size());
364     GetLoginProfileRequest actualRequest = ((GetLoginProfileRequest) actualRequests.get(0));
365 
366     Assert.assertEquals(name, actualRequest.getName());
367     Assert.assertTrue(
368         channelProvider.isHeaderSent(
369             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
370             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
371   }
372 
373   @Test
getLoginProfileExceptionTest2()374   public void getLoginProfileExceptionTest2() throws Exception {
375     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
376     mockOsLoginService.addException(exception);
377 
378     try {
379       String name = "name3373707";
380       client.getLoginProfile(name);
381       Assert.fail("No exception raised");
382     } catch (InvalidArgumentException e) {
383       // Expected exception.
384     }
385   }
386 
387   @Test
getSshPublicKeyTest()388   public void getSshPublicKeyTest() throws Exception {
389     OsLoginProto.SshPublicKey expectedResponse =
390         OsLoginProto.SshPublicKey.newBuilder()
391             .setKey("key106079")
392             .setExpirationTimeUsec(-2058878882)
393             .setFingerprint("fingerprint-1375934236")
394             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
395             .build();
396     mockOsLoginService.addResponse(expectedResponse);
397 
398     FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
399 
400     OsLoginProto.SshPublicKey actualResponse = client.getSshPublicKey(name);
401     Assert.assertEquals(expectedResponse, actualResponse);
402 
403     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
404     Assert.assertEquals(1, actualRequests.size());
405     GetSshPublicKeyRequest actualRequest = ((GetSshPublicKeyRequest) actualRequests.get(0));
406 
407     Assert.assertEquals(name.toString(), actualRequest.getName());
408     Assert.assertTrue(
409         channelProvider.isHeaderSent(
410             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
411             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
412   }
413 
414   @Test
getSshPublicKeyExceptionTest()415   public void getSshPublicKeyExceptionTest() throws Exception {
416     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
417     mockOsLoginService.addException(exception);
418 
419     try {
420       FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
421       client.getSshPublicKey(name);
422       Assert.fail("No exception raised");
423     } catch (InvalidArgumentException e) {
424       // Expected exception.
425     }
426   }
427 
428   @Test
getSshPublicKeyTest2()429   public void getSshPublicKeyTest2() throws Exception {
430     OsLoginProto.SshPublicKey expectedResponse =
431         OsLoginProto.SshPublicKey.newBuilder()
432             .setKey("key106079")
433             .setExpirationTimeUsec(-2058878882)
434             .setFingerprint("fingerprint-1375934236")
435             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
436             .build();
437     mockOsLoginService.addResponse(expectedResponse);
438 
439     String name = "name3373707";
440 
441     OsLoginProto.SshPublicKey actualResponse = client.getSshPublicKey(name);
442     Assert.assertEquals(expectedResponse, actualResponse);
443 
444     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
445     Assert.assertEquals(1, actualRequests.size());
446     GetSshPublicKeyRequest actualRequest = ((GetSshPublicKeyRequest) actualRequests.get(0));
447 
448     Assert.assertEquals(name, actualRequest.getName());
449     Assert.assertTrue(
450         channelProvider.isHeaderSent(
451             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
452             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
453   }
454 
455   @Test
getSshPublicKeyExceptionTest2()456   public void getSshPublicKeyExceptionTest2() throws Exception {
457     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
458     mockOsLoginService.addException(exception);
459 
460     try {
461       String name = "name3373707";
462       client.getSshPublicKey(name);
463       Assert.fail("No exception raised");
464     } catch (InvalidArgumentException e) {
465       // Expected exception.
466     }
467   }
468 
469   @Test
importSshPublicKeyTest()470   public void importSshPublicKeyTest() throws Exception {
471     ImportSshPublicKeyResponse expectedResponse =
472         ImportSshPublicKeyResponse.newBuilder()
473             .setLoginProfile(LoginProfile.newBuilder().build())
474             .setDetails("details1557721666")
475             .build();
476     mockOsLoginService.addResponse(expectedResponse);
477 
478     UserName parent = UserName.of("[USER]");
479     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
480 
481     ImportSshPublicKeyResponse actualResponse = client.importSshPublicKey(parent, sshPublicKey);
482     Assert.assertEquals(expectedResponse, actualResponse);
483 
484     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
485     Assert.assertEquals(1, actualRequests.size());
486     ImportSshPublicKeyRequest actualRequest = ((ImportSshPublicKeyRequest) actualRequests.get(0));
487 
488     Assert.assertEquals(parent.toString(), actualRequest.getParent());
489     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
490     Assert.assertTrue(
491         channelProvider.isHeaderSent(
492             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
493             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
494   }
495 
496   @Test
importSshPublicKeyExceptionTest()497   public void importSshPublicKeyExceptionTest() throws Exception {
498     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
499     mockOsLoginService.addException(exception);
500 
501     try {
502       UserName parent = UserName.of("[USER]");
503       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
504       client.importSshPublicKey(parent, sshPublicKey);
505       Assert.fail("No exception raised");
506     } catch (InvalidArgumentException e) {
507       // Expected exception.
508     }
509   }
510 
511   @Test
importSshPublicKeyTest2()512   public void importSshPublicKeyTest2() throws Exception {
513     ImportSshPublicKeyResponse expectedResponse =
514         ImportSshPublicKeyResponse.newBuilder()
515             .setLoginProfile(LoginProfile.newBuilder().build())
516             .setDetails("details1557721666")
517             .build();
518     mockOsLoginService.addResponse(expectedResponse);
519 
520     String parent = "parent-995424086";
521     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
522 
523     ImportSshPublicKeyResponse actualResponse = client.importSshPublicKey(parent, sshPublicKey);
524     Assert.assertEquals(expectedResponse, actualResponse);
525 
526     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
527     Assert.assertEquals(1, actualRequests.size());
528     ImportSshPublicKeyRequest actualRequest = ((ImportSshPublicKeyRequest) actualRequests.get(0));
529 
530     Assert.assertEquals(parent, actualRequest.getParent());
531     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
532     Assert.assertTrue(
533         channelProvider.isHeaderSent(
534             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
535             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
536   }
537 
538   @Test
importSshPublicKeyExceptionTest2()539   public void importSshPublicKeyExceptionTest2() throws Exception {
540     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
541     mockOsLoginService.addException(exception);
542 
543     try {
544       String parent = "parent-995424086";
545       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
546       client.importSshPublicKey(parent, sshPublicKey);
547       Assert.fail("No exception raised");
548     } catch (InvalidArgumentException e) {
549       // Expected exception.
550     }
551   }
552 
553   @Test
importSshPublicKeyTest3()554   public void importSshPublicKeyTest3() throws Exception {
555     ImportSshPublicKeyResponse expectedResponse =
556         ImportSshPublicKeyResponse.newBuilder()
557             .setLoginProfile(LoginProfile.newBuilder().build())
558             .setDetails("details1557721666")
559             .build();
560     mockOsLoginService.addResponse(expectedResponse);
561 
562     UserName parent = UserName.of("[USER]");
563     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
564     String projectId = "projectId-894832108";
565 
566     ImportSshPublicKeyResponse actualResponse =
567         client.importSshPublicKey(parent, sshPublicKey, projectId);
568     Assert.assertEquals(expectedResponse, actualResponse);
569 
570     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
571     Assert.assertEquals(1, actualRequests.size());
572     ImportSshPublicKeyRequest actualRequest = ((ImportSshPublicKeyRequest) actualRequests.get(0));
573 
574     Assert.assertEquals(parent.toString(), actualRequest.getParent());
575     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
576     Assert.assertEquals(projectId, actualRequest.getProjectId());
577     Assert.assertTrue(
578         channelProvider.isHeaderSent(
579             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
580             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
581   }
582 
583   @Test
importSshPublicKeyExceptionTest3()584   public void importSshPublicKeyExceptionTest3() throws Exception {
585     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
586     mockOsLoginService.addException(exception);
587 
588     try {
589       UserName parent = UserName.of("[USER]");
590       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
591       String projectId = "projectId-894832108";
592       client.importSshPublicKey(parent, sshPublicKey, projectId);
593       Assert.fail("No exception raised");
594     } catch (InvalidArgumentException e) {
595       // Expected exception.
596     }
597   }
598 
599   @Test
importSshPublicKeyTest4()600   public void importSshPublicKeyTest4() throws Exception {
601     ImportSshPublicKeyResponse expectedResponse =
602         ImportSshPublicKeyResponse.newBuilder()
603             .setLoginProfile(LoginProfile.newBuilder().build())
604             .setDetails("details1557721666")
605             .build();
606     mockOsLoginService.addResponse(expectedResponse);
607 
608     String parent = "parent-995424086";
609     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
610     String projectId = "projectId-894832108";
611 
612     ImportSshPublicKeyResponse actualResponse =
613         client.importSshPublicKey(parent, sshPublicKey, projectId);
614     Assert.assertEquals(expectedResponse, actualResponse);
615 
616     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
617     Assert.assertEquals(1, actualRequests.size());
618     ImportSshPublicKeyRequest actualRequest = ((ImportSshPublicKeyRequest) actualRequests.get(0));
619 
620     Assert.assertEquals(parent, actualRequest.getParent());
621     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
622     Assert.assertEquals(projectId, actualRequest.getProjectId());
623     Assert.assertTrue(
624         channelProvider.isHeaderSent(
625             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
626             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
627   }
628 
629   @Test
importSshPublicKeyExceptionTest4()630   public void importSshPublicKeyExceptionTest4() throws Exception {
631     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
632     mockOsLoginService.addException(exception);
633 
634     try {
635       String parent = "parent-995424086";
636       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
637       String projectId = "projectId-894832108";
638       client.importSshPublicKey(parent, sshPublicKey, projectId);
639       Assert.fail("No exception raised");
640     } catch (InvalidArgumentException e) {
641       // Expected exception.
642     }
643   }
644 
645   @Test
updateSshPublicKeyTest()646   public void updateSshPublicKeyTest() throws Exception {
647     OsLoginProto.SshPublicKey expectedResponse =
648         OsLoginProto.SshPublicKey.newBuilder()
649             .setKey("key106079")
650             .setExpirationTimeUsec(-2058878882)
651             .setFingerprint("fingerprint-1375934236")
652             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
653             .build();
654     mockOsLoginService.addResponse(expectedResponse);
655 
656     FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
657     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
658 
659     OsLoginProto.SshPublicKey actualResponse = client.updateSshPublicKey(name, sshPublicKey);
660     Assert.assertEquals(expectedResponse, actualResponse);
661 
662     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
663     Assert.assertEquals(1, actualRequests.size());
664     UpdateSshPublicKeyRequest actualRequest = ((UpdateSshPublicKeyRequest) actualRequests.get(0));
665 
666     Assert.assertEquals(name.toString(), actualRequest.getName());
667     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
668     Assert.assertTrue(
669         channelProvider.isHeaderSent(
670             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
671             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
672   }
673 
674   @Test
updateSshPublicKeyExceptionTest()675   public void updateSshPublicKeyExceptionTest() throws Exception {
676     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
677     mockOsLoginService.addException(exception);
678 
679     try {
680       FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
681       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
682       client.updateSshPublicKey(name, sshPublicKey);
683       Assert.fail("No exception raised");
684     } catch (InvalidArgumentException e) {
685       // Expected exception.
686     }
687   }
688 
689   @Test
updateSshPublicKeyTest2()690   public void updateSshPublicKeyTest2() throws Exception {
691     OsLoginProto.SshPublicKey expectedResponse =
692         OsLoginProto.SshPublicKey.newBuilder()
693             .setKey("key106079")
694             .setExpirationTimeUsec(-2058878882)
695             .setFingerprint("fingerprint-1375934236")
696             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
697             .build();
698     mockOsLoginService.addResponse(expectedResponse);
699 
700     String name = "name3373707";
701     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
702 
703     OsLoginProto.SshPublicKey actualResponse = client.updateSshPublicKey(name, sshPublicKey);
704     Assert.assertEquals(expectedResponse, actualResponse);
705 
706     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
707     Assert.assertEquals(1, actualRequests.size());
708     UpdateSshPublicKeyRequest actualRequest = ((UpdateSshPublicKeyRequest) actualRequests.get(0));
709 
710     Assert.assertEquals(name, actualRequest.getName());
711     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
712     Assert.assertTrue(
713         channelProvider.isHeaderSent(
714             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
715             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
716   }
717 
718   @Test
updateSshPublicKeyExceptionTest2()719   public void updateSshPublicKeyExceptionTest2() throws Exception {
720     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
721     mockOsLoginService.addException(exception);
722 
723     try {
724       String name = "name3373707";
725       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
726       client.updateSshPublicKey(name, sshPublicKey);
727       Assert.fail("No exception raised");
728     } catch (InvalidArgumentException e) {
729       // Expected exception.
730     }
731   }
732 
733   @Test
updateSshPublicKeyTest3()734   public void updateSshPublicKeyTest3() throws Exception {
735     OsLoginProto.SshPublicKey expectedResponse =
736         OsLoginProto.SshPublicKey.newBuilder()
737             .setKey("key106079")
738             .setExpirationTimeUsec(-2058878882)
739             .setFingerprint("fingerprint-1375934236")
740             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
741             .build();
742     mockOsLoginService.addResponse(expectedResponse);
743 
744     FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
745     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
746     FieldMask updateMask = FieldMask.newBuilder().build();
747 
748     OsLoginProto.SshPublicKey actualResponse =
749         client.updateSshPublicKey(name, sshPublicKey, updateMask);
750     Assert.assertEquals(expectedResponse, actualResponse);
751 
752     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
753     Assert.assertEquals(1, actualRequests.size());
754     UpdateSshPublicKeyRequest actualRequest = ((UpdateSshPublicKeyRequest) actualRequests.get(0));
755 
756     Assert.assertEquals(name.toString(), actualRequest.getName());
757     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
758     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
759     Assert.assertTrue(
760         channelProvider.isHeaderSent(
761             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
762             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
763   }
764 
765   @Test
updateSshPublicKeyExceptionTest3()766   public void updateSshPublicKeyExceptionTest3() throws Exception {
767     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
768     mockOsLoginService.addException(exception);
769 
770     try {
771       FingerprintName name = FingerprintName.of("[USER]", "[FINGERPRINT]");
772       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
773       FieldMask updateMask = FieldMask.newBuilder().build();
774       client.updateSshPublicKey(name, sshPublicKey, updateMask);
775       Assert.fail("No exception raised");
776     } catch (InvalidArgumentException e) {
777       // Expected exception.
778     }
779   }
780 
781   @Test
updateSshPublicKeyTest4()782   public void updateSshPublicKeyTest4() throws Exception {
783     OsLoginProto.SshPublicKey expectedResponse =
784         OsLoginProto.SshPublicKey.newBuilder()
785             .setKey("key106079")
786             .setExpirationTimeUsec(-2058878882)
787             .setFingerprint("fingerprint-1375934236")
788             .setName(FingerprintName.of("[USER]", "[FINGERPRINT]").toString())
789             .build();
790     mockOsLoginService.addResponse(expectedResponse);
791 
792     String name = "name3373707";
793     OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
794     FieldMask updateMask = FieldMask.newBuilder().build();
795 
796     OsLoginProto.SshPublicKey actualResponse =
797         client.updateSshPublicKey(name, sshPublicKey, updateMask);
798     Assert.assertEquals(expectedResponse, actualResponse);
799 
800     List<AbstractMessage> actualRequests = mockOsLoginService.getRequests();
801     Assert.assertEquals(1, actualRequests.size());
802     UpdateSshPublicKeyRequest actualRequest = ((UpdateSshPublicKeyRequest) actualRequests.get(0));
803 
804     Assert.assertEquals(name, actualRequest.getName());
805     Assert.assertEquals(sshPublicKey, actualRequest.getSshPublicKey());
806     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
807     Assert.assertTrue(
808         channelProvider.isHeaderSent(
809             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
810             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
811   }
812 
813   @Test
updateSshPublicKeyExceptionTest4()814   public void updateSshPublicKeyExceptionTest4() throws Exception {
815     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
816     mockOsLoginService.addException(exception);
817 
818     try {
819       String name = "name3373707";
820       OsLoginProto.SshPublicKey sshPublicKey = OsLoginProto.SshPublicKey.newBuilder().build();
821       FieldMask updateMask = FieldMask.newBuilder().build();
822       client.updateSshPublicKey(name, sshPublicKey, updateMask);
823       Assert.fail("No exception raised");
824     } catch (InvalidArgumentException e) {
825       // Expected exception.
826     }
827   }
828 }
829