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