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.devtools.cloudbuild.v2; 18 19 import static com.google.cloud.devtools.cloudbuild.v2.RepositoryManagerClient.FetchLinkableRepositoriesPagedResponse; 20 import static com.google.cloud.devtools.cloudbuild.v2.RepositoryManagerClient.ListConnectionsPagedResponse; 21 import static com.google.cloud.devtools.cloudbuild.v2.RepositoryManagerClient.ListRepositoriesPagedResponse; 22 23 import com.google.api.gax.core.NoCredentialsProvider; 24 import com.google.api.gax.httpjson.GaxHttpJsonProperties; 25 import com.google.api.gax.httpjson.testing.MockHttpService; 26 import com.google.api.gax.rpc.ApiClientHeaderProvider; 27 import com.google.api.gax.rpc.ApiException; 28 import com.google.api.gax.rpc.ApiExceptionFactory; 29 import com.google.api.gax.rpc.InvalidArgumentException; 30 import com.google.api.gax.rpc.StatusCode; 31 import com.google.api.gax.rpc.testing.FakeStatusCode; 32 import com.google.cloud.devtools.cloudbuild.v2.stub.HttpJsonRepositoryManagerStub; 33 import com.google.cloudbuild.v2.BatchCreateRepositoriesResponse; 34 import com.google.cloudbuild.v2.Connection; 35 import com.google.cloudbuild.v2.ConnectionName; 36 import com.google.cloudbuild.v2.CreateRepositoryRequest; 37 import com.google.cloudbuild.v2.FetchLinkableRepositoriesRequest; 38 import com.google.cloudbuild.v2.FetchLinkableRepositoriesResponse; 39 import com.google.cloudbuild.v2.FetchReadTokenResponse; 40 import com.google.cloudbuild.v2.FetchReadWriteTokenResponse; 41 import com.google.cloudbuild.v2.InstallationState; 42 import com.google.cloudbuild.v2.ListConnectionsResponse; 43 import com.google.cloudbuild.v2.ListRepositoriesResponse; 44 import com.google.cloudbuild.v2.LocationName; 45 import com.google.cloudbuild.v2.Repository; 46 import com.google.cloudbuild.v2.RepositoryName; 47 import com.google.common.collect.Lists; 48 import com.google.iam.v1.AuditConfig; 49 import com.google.iam.v1.Binding; 50 import com.google.iam.v1.GetIamPolicyRequest; 51 import com.google.iam.v1.GetPolicyOptions; 52 import com.google.iam.v1.Policy; 53 import com.google.iam.v1.SetIamPolicyRequest; 54 import com.google.iam.v1.TestIamPermissionsRequest; 55 import com.google.iam.v1.TestIamPermissionsResponse; 56 import com.google.longrunning.Operation; 57 import com.google.protobuf.Any; 58 import com.google.protobuf.ByteString; 59 import com.google.protobuf.Empty; 60 import com.google.protobuf.FieldMask; 61 import com.google.protobuf.Timestamp; 62 import java.io.IOException; 63 import java.util.ArrayList; 64 import java.util.Arrays; 65 import java.util.HashMap; 66 import java.util.List; 67 import java.util.concurrent.ExecutionException; 68 import javax.annotation.Generated; 69 import org.junit.After; 70 import org.junit.AfterClass; 71 import org.junit.Assert; 72 import org.junit.Before; 73 import org.junit.BeforeClass; 74 import org.junit.Test; 75 76 @Generated("by gapic-generator-java") 77 public class RepositoryManagerClientHttpJsonTest { 78 private static MockHttpService mockService; 79 private static RepositoryManagerClient client; 80 81 @BeforeClass startStaticServer()82 public static void startStaticServer() throws IOException { 83 mockService = 84 new MockHttpService( 85 HttpJsonRepositoryManagerStub.getMethodDescriptors(), 86 RepositoryManagerSettings.getDefaultEndpoint()); 87 RepositoryManagerSettings settings = 88 RepositoryManagerSettings.newHttpJsonBuilder() 89 .setTransportChannelProvider( 90 RepositoryManagerSettings.defaultHttpJsonTransportProviderBuilder() 91 .setHttpTransport(mockService) 92 .build()) 93 .setCredentialsProvider(NoCredentialsProvider.create()) 94 .build(); 95 client = RepositoryManagerClient.create(settings); 96 } 97 98 @AfterClass stopServer()99 public static void stopServer() { 100 client.close(); 101 } 102 103 @Before setUp()104 public void setUp() {} 105 106 @After tearDown()107 public void tearDown() throws Exception { 108 mockService.reset(); 109 } 110 111 @Test createConnectionTest()112 public void createConnectionTest() throws Exception { 113 Connection expectedResponse = 114 Connection.newBuilder() 115 .setName(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 116 .setCreateTime(Timestamp.newBuilder().build()) 117 .setUpdateTime(Timestamp.newBuilder().build()) 118 .setInstallationState(InstallationState.newBuilder().build()) 119 .setDisabled(true) 120 .setReconciling(true) 121 .putAllAnnotations(new HashMap<String, String>()) 122 .setEtag("etag3123477") 123 .build(); 124 Operation resultOperation = 125 Operation.newBuilder() 126 .setName("createConnectionTest") 127 .setDone(true) 128 .setResponse(Any.pack(expectedResponse)) 129 .build(); 130 mockService.addResponse(resultOperation); 131 132 LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]"); 133 Connection connection = Connection.newBuilder().build(); 134 String connectionId = "connectionId1923106969"; 135 136 Connection actualResponse = 137 client.createConnectionAsync(parent, connection, connectionId).get(); 138 Assert.assertEquals(expectedResponse, actualResponse); 139 140 List<String> actualRequests = mockService.getRequestPaths(); 141 Assert.assertEquals(1, actualRequests.size()); 142 143 String apiClientHeaderKey = 144 mockService 145 .getRequestHeaders() 146 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 147 .iterator() 148 .next(); 149 Assert.assertTrue( 150 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 151 .matcher(apiClientHeaderKey) 152 .matches()); 153 } 154 155 @Test createConnectionExceptionTest()156 public void createConnectionExceptionTest() throws Exception { 157 ApiException exception = 158 ApiExceptionFactory.createException( 159 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 160 mockService.addException(exception); 161 162 try { 163 LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]"); 164 Connection connection = Connection.newBuilder().build(); 165 String connectionId = "connectionId1923106969"; 166 client.createConnectionAsync(parent, connection, connectionId).get(); 167 Assert.fail("No exception raised"); 168 } catch (ExecutionException e) { 169 } 170 } 171 172 @Test createConnectionTest2()173 public void createConnectionTest2() throws Exception { 174 Connection expectedResponse = 175 Connection.newBuilder() 176 .setName(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 177 .setCreateTime(Timestamp.newBuilder().build()) 178 .setUpdateTime(Timestamp.newBuilder().build()) 179 .setInstallationState(InstallationState.newBuilder().build()) 180 .setDisabled(true) 181 .setReconciling(true) 182 .putAllAnnotations(new HashMap<String, String>()) 183 .setEtag("etag3123477") 184 .build(); 185 Operation resultOperation = 186 Operation.newBuilder() 187 .setName("createConnectionTest") 188 .setDone(true) 189 .setResponse(Any.pack(expectedResponse)) 190 .build(); 191 mockService.addResponse(resultOperation); 192 193 String parent = "projects/project-5833/locations/location-5833"; 194 Connection connection = Connection.newBuilder().build(); 195 String connectionId = "connectionId1923106969"; 196 197 Connection actualResponse = 198 client.createConnectionAsync(parent, connection, connectionId).get(); 199 Assert.assertEquals(expectedResponse, actualResponse); 200 201 List<String> actualRequests = mockService.getRequestPaths(); 202 Assert.assertEquals(1, actualRequests.size()); 203 204 String apiClientHeaderKey = 205 mockService 206 .getRequestHeaders() 207 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 208 .iterator() 209 .next(); 210 Assert.assertTrue( 211 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 212 .matcher(apiClientHeaderKey) 213 .matches()); 214 } 215 216 @Test createConnectionExceptionTest2()217 public void createConnectionExceptionTest2() throws Exception { 218 ApiException exception = 219 ApiExceptionFactory.createException( 220 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 221 mockService.addException(exception); 222 223 try { 224 String parent = "projects/project-5833/locations/location-5833"; 225 Connection connection = Connection.newBuilder().build(); 226 String connectionId = "connectionId1923106969"; 227 client.createConnectionAsync(parent, connection, connectionId).get(); 228 Assert.fail("No exception raised"); 229 } catch (ExecutionException e) { 230 } 231 } 232 233 @Test getConnectionTest()234 public void getConnectionTest() throws Exception { 235 Connection expectedResponse = 236 Connection.newBuilder() 237 .setName(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 238 .setCreateTime(Timestamp.newBuilder().build()) 239 .setUpdateTime(Timestamp.newBuilder().build()) 240 .setInstallationState(InstallationState.newBuilder().build()) 241 .setDisabled(true) 242 .setReconciling(true) 243 .putAllAnnotations(new HashMap<String, String>()) 244 .setEtag("etag3123477") 245 .build(); 246 mockService.addResponse(expectedResponse); 247 248 ConnectionName name = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 249 250 Connection actualResponse = client.getConnection(name); 251 Assert.assertEquals(expectedResponse, actualResponse); 252 253 List<String> actualRequests = mockService.getRequestPaths(); 254 Assert.assertEquals(1, actualRequests.size()); 255 256 String apiClientHeaderKey = 257 mockService 258 .getRequestHeaders() 259 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 260 .iterator() 261 .next(); 262 Assert.assertTrue( 263 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 264 .matcher(apiClientHeaderKey) 265 .matches()); 266 } 267 268 @Test getConnectionExceptionTest()269 public void getConnectionExceptionTest() throws Exception { 270 ApiException exception = 271 ApiExceptionFactory.createException( 272 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 273 mockService.addException(exception); 274 275 try { 276 ConnectionName name = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 277 client.getConnection(name); 278 Assert.fail("No exception raised"); 279 } catch (InvalidArgumentException e) { 280 // Expected exception. 281 } 282 } 283 284 @Test getConnectionTest2()285 public void getConnectionTest2() throws Exception { 286 Connection expectedResponse = 287 Connection.newBuilder() 288 .setName(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 289 .setCreateTime(Timestamp.newBuilder().build()) 290 .setUpdateTime(Timestamp.newBuilder().build()) 291 .setInstallationState(InstallationState.newBuilder().build()) 292 .setDisabled(true) 293 .setReconciling(true) 294 .putAllAnnotations(new HashMap<String, String>()) 295 .setEtag("etag3123477") 296 .build(); 297 mockService.addResponse(expectedResponse); 298 299 String name = "projects/project-7851/locations/location-7851/connections/connection-7851"; 300 301 Connection actualResponse = client.getConnection(name); 302 Assert.assertEquals(expectedResponse, actualResponse); 303 304 List<String> actualRequests = mockService.getRequestPaths(); 305 Assert.assertEquals(1, actualRequests.size()); 306 307 String apiClientHeaderKey = 308 mockService 309 .getRequestHeaders() 310 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 311 .iterator() 312 .next(); 313 Assert.assertTrue( 314 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 315 .matcher(apiClientHeaderKey) 316 .matches()); 317 } 318 319 @Test getConnectionExceptionTest2()320 public void getConnectionExceptionTest2() throws Exception { 321 ApiException exception = 322 ApiExceptionFactory.createException( 323 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 324 mockService.addException(exception); 325 326 try { 327 String name = "projects/project-7851/locations/location-7851/connections/connection-7851"; 328 client.getConnection(name); 329 Assert.fail("No exception raised"); 330 } catch (InvalidArgumentException e) { 331 // Expected exception. 332 } 333 } 334 335 @Test listConnectionsTest()336 public void listConnectionsTest() throws Exception { 337 Connection responsesElement = Connection.newBuilder().build(); 338 ListConnectionsResponse expectedResponse = 339 ListConnectionsResponse.newBuilder() 340 .setNextPageToken("") 341 .addAllConnections(Arrays.asList(responsesElement)) 342 .build(); 343 mockService.addResponse(expectedResponse); 344 345 LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]"); 346 347 ListConnectionsPagedResponse pagedListResponse = client.listConnections(parent); 348 349 List<Connection> resources = Lists.newArrayList(pagedListResponse.iterateAll()); 350 351 Assert.assertEquals(1, resources.size()); 352 Assert.assertEquals(expectedResponse.getConnectionsList().get(0), resources.get(0)); 353 354 List<String> actualRequests = mockService.getRequestPaths(); 355 Assert.assertEquals(1, actualRequests.size()); 356 357 String apiClientHeaderKey = 358 mockService 359 .getRequestHeaders() 360 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 361 .iterator() 362 .next(); 363 Assert.assertTrue( 364 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 365 .matcher(apiClientHeaderKey) 366 .matches()); 367 } 368 369 @Test listConnectionsExceptionTest()370 public void listConnectionsExceptionTest() throws Exception { 371 ApiException exception = 372 ApiExceptionFactory.createException( 373 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 374 mockService.addException(exception); 375 376 try { 377 LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]"); 378 client.listConnections(parent); 379 Assert.fail("No exception raised"); 380 } catch (InvalidArgumentException e) { 381 // Expected exception. 382 } 383 } 384 385 @Test listConnectionsTest2()386 public void listConnectionsTest2() throws Exception { 387 Connection responsesElement = Connection.newBuilder().build(); 388 ListConnectionsResponse expectedResponse = 389 ListConnectionsResponse.newBuilder() 390 .setNextPageToken("") 391 .addAllConnections(Arrays.asList(responsesElement)) 392 .build(); 393 mockService.addResponse(expectedResponse); 394 395 String parent = "projects/project-5833/locations/location-5833"; 396 397 ListConnectionsPagedResponse pagedListResponse = client.listConnections(parent); 398 399 List<Connection> resources = Lists.newArrayList(pagedListResponse.iterateAll()); 400 401 Assert.assertEquals(1, resources.size()); 402 Assert.assertEquals(expectedResponse.getConnectionsList().get(0), resources.get(0)); 403 404 List<String> actualRequests = mockService.getRequestPaths(); 405 Assert.assertEquals(1, actualRequests.size()); 406 407 String apiClientHeaderKey = 408 mockService 409 .getRequestHeaders() 410 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 411 .iterator() 412 .next(); 413 Assert.assertTrue( 414 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 415 .matcher(apiClientHeaderKey) 416 .matches()); 417 } 418 419 @Test listConnectionsExceptionTest2()420 public void listConnectionsExceptionTest2() throws Exception { 421 ApiException exception = 422 ApiExceptionFactory.createException( 423 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 424 mockService.addException(exception); 425 426 try { 427 String parent = "projects/project-5833/locations/location-5833"; 428 client.listConnections(parent); 429 Assert.fail("No exception raised"); 430 } catch (InvalidArgumentException e) { 431 // Expected exception. 432 } 433 } 434 435 @Test updateConnectionTest()436 public void updateConnectionTest() throws Exception { 437 Connection expectedResponse = 438 Connection.newBuilder() 439 .setName(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 440 .setCreateTime(Timestamp.newBuilder().build()) 441 .setUpdateTime(Timestamp.newBuilder().build()) 442 .setInstallationState(InstallationState.newBuilder().build()) 443 .setDisabled(true) 444 .setReconciling(true) 445 .putAllAnnotations(new HashMap<String, String>()) 446 .setEtag("etag3123477") 447 .build(); 448 Operation resultOperation = 449 Operation.newBuilder() 450 .setName("updateConnectionTest") 451 .setDone(true) 452 .setResponse(Any.pack(expectedResponse)) 453 .build(); 454 mockService.addResponse(resultOperation); 455 456 Connection connection = 457 Connection.newBuilder() 458 .setName(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 459 .setCreateTime(Timestamp.newBuilder().build()) 460 .setUpdateTime(Timestamp.newBuilder().build()) 461 .setInstallationState(InstallationState.newBuilder().build()) 462 .setDisabled(true) 463 .setReconciling(true) 464 .putAllAnnotations(new HashMap<String, String>()) 465 .setEtag("etag3123477") 466 .build(); 467 FieldMask updateMask = FieldMask.newBuilder().build(); 468 469 Connection actualResponse = client.updateConnectionAsync(connection, updateMask).get(); 470 Assert.assertEquals(expectedResponse, actualResponse); 471 472 List<String> actualRequests = mockService.getRequestPaths(); 473 Assert.assertEquals(1, actualRequests.size()); 474 475 String apiClientHeaderKey = 476 mockService 477 .getRequestHeaders() 478 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 479 .iterator() 480 .next(); 481 Assert.assertTrue( 482 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 483 .matcher(apiClientHeaderKey) 484 .matches()); 485 } 486 487 @Test updateConnectionExceptionTest()488 public void updateConnectionExceptionTest() throws Exception { 489 ApiException exception = 490 ApiExceptionFactory.createException( 491 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 492 mockService.addException(exception); 493 494 try { 495 Connection connection = 496 Connection.newBuilder() 497 .setName(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 498 .setCreateTime(Timestamp.newBuilder().build()) 499 .setUpdateTime(Timestamp.newBuilder().build()) 500 .setInstallationState(InstallationState.newBuilder().build()) 501 .setDisabled(true) 502 .setReconciling(true) 503 .putAllAnnotations(new HashMap<String, String>()) 504 .setEtag("etag3123477") 505 .build(); 506 FieldMask updateMask = FieldMask.newBuilder().build(); 507 client.updateConnectionAsync(connection, updateMask).get(); 508 Assert.fail("No exception raised"); 509 } catch (ExecutionException e) { 510 } 511 } 512 513 @Test deleteConnectionTest()514 public void deleteConnectionTest() throws Exception { 515 Empty expectedResponse = Empty.newBuilder().build(); 516 Operation resultOperation = 517 Operation.newBuilder() 518 .setName("deleteConnectionTest") 519 .setDone(true) 520 .setResponse(Any.pack(expectedResponse)) 521 .build(); 522 mockService.addResponse(resultOperation); 523 524 ConnectionName name = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 525 526 client.deleteConnectionAsync(name).get(); 527 528 List<String> actualRequests = mockService.getRequestPaths(); 529 Assert.assertEquals(1, actualRequests.size()); 530 531 String apiClientHeaderKey = 532 mockService 533 .getRequestHeaders() 534 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 535 .iterator() 536 .next(); 537 Assert.assertTrue( 538 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 539 .matcher(apiClientHeaderKey) 540 .matches()); 541 } 542 543 @Test deleteConnectionExceptionTest()544 public void deleteConnectionExceptionTest() throws Exception { 545 ApiException exception = 546 ApiExceptionFactory.createException( 547 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 548 mockService.addException(exception); 549 550 try { 551 ConnectionName name = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 552 client.deleteConnectionAsync(name).get(); 553 Assert.fail("No exception raised"); 554 } catch (ExecutionException e) { 555 } 556 } 557 558 @Test deleteConnectionTest2()559 public void deleteConnectionTest2() throws Exception { 560 Empty expectedResponse = Empty.newBuilder().build(); 561 Operation resultOperation = 562 Operation.newBuilder() 563 .setName("deleteConnectionTest") 564 .setDone(true) 565 .setResponse(Any.pack(expectedResponse)) 566 .build(); 567 mockService.addResponse(resultOperation); 568 569 String name = "projects/project-7851/locations/location-7851/connections/connection-7851"; 570 571 client.deleteConnectionAsync(name).get(); 572 573 List<String> actualRequests = mockService.getRequestPaths(); 574 Assert.assertEquals(1, actualRequests.size()); 575 576 String apiClientHeaderKey = 577 mockService 578 .getRequestHeaders() 579 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 580 .iterator() 581 .next(); 582 Assert.assertTrue( 583 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 584 .matcher(apiClientHeaderKey) 585 .matches()); 586 } 587 588 @Test deleteConnectionExceptionTest2()589 public void deleteConnectionExceptionTest2() throws Exception { 590 ApiException exception = 591 ApiExceptionFactory.createException( 592 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 593 mockService.addException(exception); 594 595 try { 596 String name = "projects/project-7851/locations/location-7851/connections/connection-7851"; 597 client.deleteConnectionAsync(name).get(); 598 Assert.fail("No exception raised"); 599 } catch (ExecutionException e) { 600 } 601 } 602 603 @Test createRepositoryTest()604 public void createRepositoryTest() throws Exception { 605 Repository expectedResponse = 606 Repository.newBuilder() 607 .setName( 608 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]") 609 .toString()) 610 .setRemoteUri("remoteUri1280517958") 611 .setCreateTime(Timestamp.newBuilder().build()) 612 .setUpdateTime(Timestamp.newBuilder().build()) 613 .putAllAnnotations(new HashMap<String, String>()) 614 .setEtag("etag3123477") 615 .build(); 616 Operation resultOperation = 617 Operation.newBuilder() 618 .setName("createRepositoryTest") 619 .setDone(true) 620 .setResponse(Any.pack(expectedResponse)) 621 .build(); 622 mockService.addResponse(resultOperation); 623 624 ConnectionName parent = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 625 Repository repository = Repository.newBuilder().build(); 626 String repositoryId = "repositoryId2113747461"; 627 628 Repository actualResponse = 629 client.createRepositoryAsync(parent, repository, repositoryId).get(); 630 Assert.assertEquals(expectedResponse, actualResponse); 631 632 List<String> actualRequests = mockService.getRequestPaths(); 633 Assert.assertEquals(1, actualRequests.size()); 634 635 String apiClientHeaderKey = 636 mockService 637 .getRequestHeaders() 638 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 639 .iterator() 640 .next(); 641 Assert.assertTrue( 642 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 643 .matcher(apiClientHeaderKey) 644 .matches()); 645 } 646 647 @Test createRepositoryExceptionTest()648 public void createRepositoryExceptionTest() throws Exception { 649 ApiException exception = 650 ApiExceptionFactory.createException( 651 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 652 mockService.addException(exception); 653 654 try { 655 ConnectionName parent = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 656 Repository repository = Repository.newBuilder().build(); 657 String repositoryId = "repositoryId2113747461"; 658 client.createRepositoryAsync(parent, repository, repositoryId).get(); 659 Assert.fail("No exception raised"); 660 } catch (ExecutionException e) { 661 } 662 } 663 664 @Test createRepositoryTest2()665 public void createRepositoryTest2() throws Exception { 666 Repository expectedResponse = 667 Repository.newBuilder() 668 .setName( 669 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]") 670 .toString()) 671 .setRemoteUri("remoteUri1280517958") 672 .setCreateTime(Timestamp.newBuilder().build()) 673 .setUpdateTime(Timestamp.newBuilder().build()) 674 .putAllAnnotations(new HashMap<String, String>()) 675 .setEtag("etag3123477") 676 .build(); 677 Operation resultOperation = 678 Operation.newBuilder() 679 .setName("createRepositoryTest") 680 .setDone(true) 681 .setResponse(Any.pack(expectedResponse)) 682 .build(); 683 mockService.addResponse(resultOperation); 684 685 String parent = "projects/project-7002/locations/location-7002/connections/connection-7002"; 686 Repository repository = Repository.newBuilder().build(); 687 String repositoryId = "repositoryId2113747461"; 688 689 Repository actualResponse = 690 client.createRepositoryAsync(parent, repository, repositoryId).get(); 691 Assert.assertEquals(expectedResponse, actualResponse); 692 693 List<String> actualRequests = mockService.getRequestPaths(); 694 Assert.assertEquals(1, actualRequests.size()); 695 696 String apiClientHeaderKey = 697 mockService 698 .getRequestHeaders() 699 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 700 .iterator() 701 .next(); 702 Assert.assertTrue( 703 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 704 .matcher(apiClientHeaderKey) 705 .matches()); 706 } 707 708 @Test createRepositoryExceptionTest2()709 public void createRepositoryExceptionTest2() throws Exception { 710 ApiException exception = 711 ApiExceptionFactory.createException( 712 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 713 mockService.addException(exception); 714 715 try { 716 String parent = "projects/project-7002/locations/location-7002/connections/connection-7002"; 717 Repository repository = Repository.newBuilder().build(); 718 String repositoryId = "repositoryId2113747461"; 719 client.createRepositoryAsync(parent, repository, repositoryId).get(); 720 Assert.fail("No exception raised"); 721 } catch (ExecutionException e) { 722 } 723 } 724 725 @Test batchCreateRepositoriesTest()726 public void batchCreateRepositoriesTest() throws Exception { 727 BatchCreateRepositoriesResponse expectedResponse = 728 BatchCreateRepositoriesResponse.newBuilder() 729 .addAllRepositories(new ArrayList<Repository>()) 730 .build(); 731 Operation resultOperation = 732 Operation.newBuilder() 733 .setName("batchCreateRepositoriesTest") 734 .setDone(true) 735 .setResponse(Any.pack(expectedResponse)) 736 .build(); 737 mockService.addResponse(resultOperation); 738 739 ConnectionName parent = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 740 List<CreateRepositoryRequest> requests = new ArrayList<>(); 741 742 BatchCreateRepositoriesResponse actualResponse = 743 client.batchCreateRepositoriesAsync(parent, requests).get(); 744 Assert.assertEquals(expectedResponse, actualResponse); 745 746 List<String> actualRequests = mockService.getRequestPaths(); 747 Assert.assertEquals(1, actualRequests.size()); 748 749 String apiClientHeaderKey = 750 mockService 751 .getRequestHeaders() 752 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 753 .iterator() 754 .next(); 755 Assert.assertTrue( 756 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 757 .matcher(apiClientHeaderKey) 758 .matches()); 759 } 760 761 @Test batchCreateRepositoriesExceptionTest()762 public void batchCreateRepositoriesExceptionTest() throws Exception { 763 ApiException exception = 764 ApiExceptionFactory.createException( 765 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 766 mockService.addException(exception); 767 768 try { 769 ConnectionName parent = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 770 List<CreateRepositoryRequest> requests = new ArrayList<>(); 771 client.batchCreateRepositoriesAsync(parent, requests).get(); 772 Assert.fail("No exception raised"); 773 } catch (ExecutionException e) { 774 } 775 } 776 777 @Test batchCreateRepositoriesTest2()778 public void batchCreateRepositoriesTest2() throws Exception { 779 BatchCreateRepositoriesResponse expectedResponse = 780 BatchCreateRepositoriesResponse.newBuilder() 781 .addAllRepositories(new ArrayList<Repository>()) 782 .build(); 783 Operation resultOperation = 784 Operation.newBuilder() 785 .setName("batchCreateRepositoriesTest") 786 .setDone(true) 787 .setResponse(Any.pack(expectedResponse)) 788 .build(); 789 mockService.addResponse(resultOperation); 790 791 String parent = "projects/project-7002/locations/location-7002/connections/connection-7002"; 792 List<CreateRepositoryRequest> requests = new ArrayList<>(); 793 794 BatchCreateRepositoriesResponse actualResponse = 795 client.batchCreateRepositoriesAsync(parent, requests).get(); 796 Assert.assertEquals(expectedResponse, actualResponse); 797 798 List<String> actualRequests = mockService.getRequestPaths(); 799 Assert.assertEquals(1, actualRequests.size()); 800 801 String apiClientHeaderKey = 802 mockService 803 .getRequestHeaders() 804 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 805 .iterator() 806 .next(); 807 Assert.assertTrue( 808 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 809 .matcher(apiClientHeaderKey) 810 .matches()); 811 } 812 813 @Test batchCreateRepositoriesExceptionTest2()814 public void batchCreateRepositoriesExceptionTest2() throws Exception { 815 ApiException exception = 816 ApiExceptionFactory.createException( 817 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 818 mockService.addException(exception); 819 820 try { 821 String parent = "projects/project-7002/locations/location-7002/connections/connection-7002"; 822 List<CreateRepositoryRequest> requests = new ArrayList<>(); 823 client.batchCreateRepositoriesAsync(parent, requests).get(); 824 Assert.fail("No exception raised"); 825 } catch (ExecutionException e) { 826 } 827 } 828 829 @Test getRepositoryTest()830 public void getRepositoryTest() throws Exception { 831 Repository expectedResponse = 832 Repository.newBuilder() 833 .setName( 834 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]") 835 .toString()) 836 .setRemoteUri("remoteUri1280517958") 837 .setCreateTime(Timestamp.newBuilder().build()) 838 .setUpdateTime(Timestamp.newBuilder().build()) 839 .putAllAnnotations(new HashMap<String, String>()) 840 .setEtag("etag3123477") 841 .build(); 842 mockService.addResponse(expectedResponse); 843 844 RepositoryName name = 845 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 846 847 Repository actualResponse = client.getRepository(name); 848 Assert.assertEquals(expectedResponse, actualResponse); 849 850 List<String> actualRequests = mockService.getRequestPaths(); 851 Assert.assertEquals(1, actualRequests.size()); 852 853 String apiClientHeaderKey = 854 mockService 855 .getRequestHeaders() 856 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 857 .iterator() 858 .next(); 859 Assert.assertTrue( 860 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 861 .matcher(apiClientHeaderKey) 862 .matches()); 863 } 864 865 @Test getRepositoryExceptionTest()866 public void getRepositoryExceptionTest() throws Exception { 867 ApiException exception = 868 ApiExceptionFactory.createException( 869 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 870 mockService.addException(exception); 871 872 try { 873 RepositoryName name = 874 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 875 client.getRepository(name); 876 Assert.fail("No exception raised"); 877 } catch (InvalidArgumentException e) { 878 // Expected exception. 879 } 880 } 881 882 @Test getRepositoryTest2()883 public void getRepositoryTest2() throws Exception { 884 Repository expectedResponse = 885 Repository.newBuilder() 886 .setName( 887 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]") 888 .toString()) 889 .setRemoteUri("remoteUri1280517958") 890 .setCreateTime(Timestamp.newBuilder().build()) 891 .setUpdateTime(Timestamp.newBuilder().build()) 892 .putAllAnnotations(new HashMap<String, String>()) 893 .setEtag("etag3123477") 894 .build(); 895 mockService.addResponse(expectedResponse); 896 897 String name = 898 "projects/project-5305/locations/location-5305/connections/connection-5305/repositories/repositorie-5305"; 899 900 Repository actualResponse = client.getRepository(name); 901 Assert.assertEquals(expectedResponse, actualResponse); 902 903 List<String> actualRequests = mockService.getRequestPaths(); 904 Assert.assertEquals(1, actualRequests.size()); 905 906 String apiClientHeaderKey = 907 mockService 908 .getRequestHeaders() 909 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 910 .iterator() 911 .next(); 912 Assert.assertTrue( 913 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 914 .matcher(apiClientHeaderKey) 915 .matches()); 916 } 917 918 @Test getRepositoryExceptionTest2()919 public void getRepositoryExceptionTest2() throws Exception { 920 ApiException exception = 921 ApiExceptionFactory.createException( 922 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 923 mockService.addException(exception); 924 925 try { 926 String name = 927 "projects/project-5305/locations/location-5305/connections/connection-5305/repositories/repositorie-5305"; 928 client.getRepository(name); 929 Assert.fail("No exception raised"); 930 } catch (InvalidArgumentException e) { 931 // Expected exception. 932 } 933 } 934 935 @Test listRepositoriesTest()936 public void listRepositoriesTest() throws Exception { 937 Repository responsesElement = Repository.newBuilder().build(); 938 ListRepositoriesResponse expectedResponse = 939 ListRepositoriesResponse.newBuilder() 940 .setNextPageToken("") 941 .addAllRepositories(Arrays.asList(responsesElement)) 942 .build(); 943 mockService.addResponse(expectedResponse); 944 945 ConnectionName parent = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 946 947 ListRepositoriesPagedResponse pagedListResponse = client.listRepositories(parent); 948 949 List<Repository> resources = Lists.newArrayList(pagedListResponse.iterateAll()); 950 951 Assert.assertEquals(1, resources.size()); 952 Assert.assertEquals(expectedResponse.getRepositoriesList().get(0), resources.get(0)); 953 954 List<String> actualRequests = mockService.getRequestPaths(); 955 Assert.assertEquals(1, actualRequests.size()); 956 957 String apiClientHeaderKey = 958 mockService 959 .getRequestHeaders() 960 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 961 .iterator() 962 .next(); 963 Assert.assertTrue( 964 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 965 .matcher(apiClientHeaderKey) 966 .matches()); 967 } 968 969 @Test listRepositoriesExceptionTest()970 public void listRepositoriesExceptionTest() throws Exception { 971 ApiException exception = 972 ApiExceptionFactory.createException( 973 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 974 mockService.addException(exception); 975 976 try { 977 ConnectionName parent = ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]"); 978 client.listRepositories(parent); 979 Assert.fail("No exception raised"); 980 } catch (InvalidArgumentException e) { 981 // Expected exception. 982 } 983 } 984 985 @Test listRepositoriesTest2()986 public void listRepositoriesTest2() throws Exception { 987 Repository responsesElement = Repository.newBuilder().build(); 988 ListRepositoriesResponse expectedResponse = 989 ListRepositoriesResponse.newBuilder() 990 .setNextPageToken("") 991 .addAllRepositories(Arrays.asList(responsesElement)) 992 .build(); 993 mockService.addResponse(expectedResponse); 994 995 String parent = "projects/project-7002/locations/location-7002/connections/connection-7002"; 996 997 ListRepositoriesPagedResponse pagedListResponse = client.listRepositories(parent); 998 999 List<Repository> resources = Lists.newArrayList(pagedListResponse.iterateAll()); 1000 1001 Assert.assertEquals(1, resources.size()); 1002 Assert.assertEquals(expectedResponse.getRepositoriesList().get(0), resources.get(0)); 1003 1004 List<String> actualRequests = mockService.getRequestPaths(); 1005 Assert.assertEquals(1, actualRequests.size()); 1006 1007 String apiClientHeaderKey = 1008 mockService 1009 .getRequestHeaders() 1010 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1011 .iterator() 1012 .next(); 1013 Assert.assertTrue( 1014 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1015 .matcher(apiClientHeaderKey) 1016 .matches()); 1017 } 1018 1019 @Test listRepositoriesExceptionTest2()1020 public void listRepositoriesExceptionTest2() throws Exception { 1021 ApiException exception = 1022 ApiExceptionFactory.createException( 1023 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1024 mockService.addException(exception); 1025 1026 try { 1027 String parent = "projects/project-7002/locations/location-7002/connections/connection-7002"; 1028 client.listRepositories(parent); 1029 Assert.fail("No exception raised"); 1030 } catch (InvalidArgumentException e) { 1031 // Expected exception. 1032 } 1033 } 1034 1035 @Test deleteRepositoryTest()1036 public void deleteRepositoryTest() throws Exception { 1037 Empty expectedResponse = Empty.newBuilder().build(); 1038 Operation resultOperation = 1039 Operation.newBuilder() 1040 .setName("deleteRepositoryTest") 1041 .setDone(true) 1042 .setResponse(Any.pack(expectedResponse)) 1043 .build(); 1044 mockService.addResponse(resultOperation); 1045 1046 RepositoryName name = 1047 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 1048 1049 client.deleteRepositoryAsync(name).get(); 1050 1051 List<String> actualRequests = mockService.getRequestPaths(); 1052 Assert.assertEquals(1, actualRequests.size()); 1053 1054 String apiClientHeaderKey = 1055 mockService 1056 .getRequestHeaders() 1057 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1058 .iterator() 1059 .next(); 1060 Assert.assertTrue( 1061 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1062 .matcher(apiClientHeaderKey) 1063 .matches()); 1064 } 1065 1066 @Test deleteRepositoryExceptionTest()1067 public void deleteRepositoryExceptionTest() throws Exception { 1068 ApiException exception = 1069 ApiExceptionFactory.createException( 1070 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1071 mockService.addException(exception); 1072 1073 try { 1074 RepositoryName name = 1075 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 1076 client.deleteRepositoryAsync(name).get(); 1077 Assert.fail("No exception raised"); 1078 } catch (ExecutionException e) { 1079 } 1080 } 1081 1082 @Test deleteRepositoryTest2()1083 public void deleteRepositoryTest2() throws Exception { 1084 Empty expectedResponse = Empty.newBuilder().build(); 1085 Operation resultOperation = 1086 Operation.newBuilder() 1087 .setName("deleteRepositoryTest") 1088 .setDone(true) 1089 .setResponse(Any.pack(expectedResponse)) 1090 .build(); 1091 mockService.addResponse(resultOperation); 1092 1093 String name = 1094 "projects/project-5305/locations/location-5305/connections/connection-5305/repositories/repositorie-5305"; 1095 1096 client.deleteRepositoryAsync(name).get(); 1097 1098 List<String> actualRequests = mockService.getRequestPaths(); 1099 Assert.assertEquals(1, actualRequests.size()); 1100 1101 String apiClientHeaderKey = 1102 mockService 1103 .getRequestHeaders() 1104 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1105 .iterator() 1106 .next(); 1107 Assert.assertTrue( 1108 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1109 .matcher(apiClientHeaderKey) 1110 .matches()); 1111 } 1112 1113 @Test deleteRepositoryExceptionTest2()1114 public void deleteRepositoryExceptionTest2() throws Exception { 1115 ApiException exception = 1116 ApiExceptionFactory.createException( 1117 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1118 mockService.addException(exception); 1119 1120 try { 1121 String name = 1122 "projects/project-5305/locations/location-5305/connections/connection-5305/repositories/repositorie-5305"; 1123 client.deleteRepositoryAsync(name).get(); 1124 Assert.fail("No exception raised"); 1125 } catch (ExecutionException e) { 1126 } 1127 } 1128 1129 @Test fetchReadWriteTokenTest()1130 public void fetchReadWriteTokenTest() throws Exception { 1131 FetchReadWriteTokenResponse expectedResponse = 1132 FetchReadWriteTokenResponse.newBuilder() 1133 .setToken("token110541305") 1134 .setExpirationTime(Timestamp.newBuilder().build()) 1135 .build(); 1136 mockService.addResponse(expectedResponse); 1137 1138 RepositoryName repository = 1139 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 1140 1141 FetchReadWriteTokenResponse actualResponse = client.fetchReadWriteToken(repository); 1142 Assert.assertEquals(expectedResponse, actualResponse); 1143 1144 List<String> actualRequests = mockService.getRequestPaths(); 1145 Assert.assertEquals(1, actualRequests.size()); 1146 1147 String apiClientHeaderKey = 1148 mockService 1149 .getRequestHeaders() 1150 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1151 .iterator() 1152 .next(); 1153 Assert.assertTrue( 1154 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1155 .matcher(apiClientHeaderKey) 1156 .matches()); 1157 } 1158 1159 @Test fetchReadWriteTokenExceptionTest()1160 public void fetchReadWriteTokenExceptionTest() throws Exception { 1161 ApiException exception = 1162 ApiExceptionFactory.createException( 1163 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1164 mockService.addException(exception); 1165 1166 try { 1167 RepositoryName repository = 1168 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 1169 client.fetchReadWriteToken(repository); 1170 Assert.fail("No exception raised"); 1171 } catch (InvalidArgumentException e) { 1172 // Expected exception. 1173 } 1174 } 1175 1176 @Test fetchReadWriteTokenTest2()1177 public void fetchReadWriteTokenTest2() throws Exception { 1178 FetchReadWriteTokenResponse expectedResponse = 1179 FetchReadWriteTokenResponse.newBuilder() 1180 .setToken("token110541305") 1181 .setExpirationTime(Timestamp.newBuilder().build()) 1182 .build(); 1183 mockService.addResponse(expectedResponse); 1184 1185 String repository = 1186 "projects/project-6024/locations/location-6024/connections/connection-6024/repositories/repositorie-6024"; 1187 1188 FetchReadWriteTokenResponse actualResponse = client.fetchReadWriteToken(repository); 1189 Assert.assertEquals(expectedResponse, actualResponse); 1190 1191 List<String> actualRequests = mockService.getRequestPaths(); 1192 Assert.assertEquals(1, actualRequests.size()); 1193 1194 String apiClientHeaderKey = 1195 mockService 1196 .getRequestHeaders() 1197 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1198 .iterator() 1199 .next(); 1200 Assert.assertTrue( 1201 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1202 .matcher(apiClientHeaderKey) 1203 .matches()); 1204 } 1205 1206 @Test fetchReadWriteTokenExceptionTest2()1207 public void fetchReadWriteTokenExceptionTest2() throws Exception { 1208 ApiException exception = 1209 ApiExceptionFactory.createException( 1210 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1211 mockService.addException(exception); 1212 1213 try { 1214 String repository = 1215 "projects/project-6024/locations/location-6024/connections/connection-6024/repositories/repositorie-6024"; 1216 client.fetchReadWriteToken(repository); 1217 Assert.fail("No exception raised"); 1218 } catch (InvalidArgumentException e) { 1219 // Expected exception. 1220 } 1221 } 1222 1223 @Test fetchReadTokenTest()1224 public void fetchReadTokenTest() throws Exception { 1225 FetchReadTokenResponse expectedResponse = 1226 FetchReadTokenResponse.newBuilder() 1227 .setToken("token110541305") 1228 .setExpirationTime(Timestamp.newBuilder().build()) 1229 .build(); 1230 mockService.addResponse(expectedResponse); 1231 1232 RepositoryName repository = 1233 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 1234 1235 FetchReadTokenResponse actualResponse = client.fetchReadToken(repository); 1236 Assert.assertEquals(expectedResponse, actualResponse); 1237 1238 List<String> actualRequests = mockService.getRequestPaths(); 1239 Assert.assertEquals(1, actualRequests.size()); 1240 1241 String apiClientHeaderKey = 1242 mockService 1243 .getRequestHeaders() 1244 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1245 .iterator() 1246 .next(); 1247 Assert.assertTrue( 1248 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1249 .matcher(apiClientHeaderKey) 1250 .matches()); 1251 } 1252 1253 @Test fetchReadTokenExceptionTest()1254 public void fetchReadTokenExceptionTest() throws Exception { 1255 ApiException exception = 1256 ApiExceptionFactory.createException( 1257 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1258 mockService.addException(exception); 1259 1260 try { 1261 RepositoryName repository = 1262 RepositoryName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]", "[REPOSITORY]"); 1263 client.fetchReadToken(repository); 1264 Assert.fail("No exception raised"); 1265 } catch (InvalidArgumentException e) { 1266 // Expected exception. 1267 } 1268 } 1269 1270 @Test fetchReadTokenTest2()1271 public void fetchReadTokenTest2() throws Exception { 1272 FetchReadTokenResponse expectedResponse = 1273 FetchReadTokenResponse.newBuilder() 1274 .setToken("token110541305") 1275 .setExpirationTime(Timestamp.newBuilder().build()) 1276 .build(); 1277 mockService.addResponse(expectedResponse); 1278 1279 String repository = 1280 "projects/project-6024/locations/location-6024/connections/connection-6024/repositories/repositorie-6024"; 1281 1282 FetchReadTokenResponse actualResponse = client.fetchReadToken(repository); 1283 Assert.assertEquals(expectedResponse, actualResponse); 1284 1285 List<String> actualRequests = mockService.getRequestPaths(); 1286 Assert.assertEquals(1, actualRequests.size()); 1287 1288 String apiClientHeaderKey = 1289 mockService 1290 .getRequestHeaders() 1291 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1292 .iterator() 1293 .next(); 1294 Assert.assertTrue( 1295 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1296 .matcher(apiClientHeaderKey) 1297 .matches()); 1298 } 1299 1300 @Test fetchReadTokenExceptionTest2()1301 public void fetchReadTokenExceptionTest2() throws Exception { 1302 ApiException exception = 1303 ApiExceptionFactory.createException( 1304 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1305 mockService.addException(exception); 1306 1307 try { 1308 String repository = 1309 "projects/project-6024/locations/location-6024/connections/connection-6024/repositories/repositorie-6024"; 1310 client.fetchReadToken(repository); 1311 Assert.fail("No exception raised"); 1312 } catch (InvalidArgumentException e) { 1313 // Expected exception. 1314 } 1315 } 1316 1317 @Test fetchLinkableRepositoriesTest()1318 public void fetchLinkableRepositoriesTest() throws Exception { 1319 Repository responsesElement = Repository.newBuilder().build(); 1320 FetchLinkableRepositoriesResponse expectedResponse = 1321 FetchLinkableRepositoriesResponse.newBuilder() 1322 .setNextPageToken("") 1323 .addAllRepositories(Arrays.asList(responsesElement)) 1324 .build(); 1325 mockService.addResponse(expectedResponse); 1326 1327 FetchLinkableRepositoriesRequest request = 1328 FetchLinkableRepositoriesRequest.newBuilder() 1329 .setConnection(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1330 .setPageSize(883849137) 1331 .setPageToken("pageToken873572522") 1332 .build(); 1333 1334 FetchLinkableRepositoriesPagedResponse pagedListResponse = 1335 client.fetchLinkableRepositories(request); 1336 1337 List<Repository> resources = Lists.newArrayList(pagedListResponse.iterateAll()); 1338 1339 Assert.assertEquals(1, resources.size()); 1340 Assert.assertEquals(expectedResponse.getRepositoriesList().get(0), resources.get(0)); 1341 1342 List<String> actualRequests = mockService.getRequestPaths(); 1343 Assert.assertEquals(1, actualRequests.size()); 1344 1345 String apiClientHeaderKey = 1346 mockService 1347 .getRequestHeaders() 1348 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1349 .iterator() 1350 .next(); 1351 Assert.assertTrue( 1352 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1353 .matcher(apiClientHeaderKey) 1354 .matches()); 1355 } 1356 1357 @Test fetchLinkableRepositoriesExceptionTest()1358 public void fetchLinkableRepositoriesExceptionTest() throws Exception { 1359 ApiException exception = 1360 ApiExceptionFactory.createException( 1361 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1362 mockService.addException(exception); 1363 1364 try { 1365 FetchLinkableRepositoriesRequest request = 1366 FetchLinkableRepositoriesRequest.newBuilder() 1367 .setConnection( 1368 ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1369 .setPageSize(883849137) 1370 .setPageToken("pageToken873572522") 1371 .build(); 1372 client.fetchLinkableRepositories(request); 1373 Assert.fail("No exception raised"); 1374 } catch (InvalidArgumentException e) { 1375 // Expected exception. 1376 } 1377 } 1378 1379 @Test setIamPolicyTest()1380 public void setIamPolicyTest() throws Exception { 1381 Policy expectedResponse = 1382 Policy.newBuilder() 1383 .setVersion(351608024) 1384 .addAllBindings(new ArrayList<Binding>()) 1385 .addAllAuditConfigs(new ArrayList<AuditConfig>()) 1386 .setEtag(ByteString.EMPTY) 1387 .build(); 1388 mockService.addResponse(expectedResponse); 1389 1390 SetIamPolicyRequest request = 1391 SetIamPolicyRequest.newBuilder() 1392 .setResource(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1393 .setPolicy(Policy.newBuilder().build()) 1394 .setUpdateMask(FieldMask.newBuilder().build()) 1395 .build(); 1396 1397 Policy actualResponse = client.setIamPolicy(request); 1398 Assert.assertEquals(expectedResponse, actualResponse); 1399 1400 List<String> actualRequests = mockService.getRequestPaths(); 1401 Assert.assertEquals(1, actualRequests.size()); 1402 1403 String apiClientHeaderKey = 1404 mockService 1405 .getRequestHeaders() 1406 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1407 .iterator() 1408 .next(); 1409 Assert.assertTrue( 1410 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1411 .matcher(apiClientHeaderKey) 1412 .matches()); 1413 } 1414 1415 @Test setIamPolicyExceptionTest()1416 public void setIamPolicyExceptionTest() throws Exception { 1417 ApiException exception = 1418 ApiExceptionFactory.createException( 1419 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1420 mockService.addException(exception); 1421 1422 try { 1423 SetIamPolicyRequest request = 1424 SetIamPolicyRequest.newBuilder() 1425 .setResource(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1426 .setPolicy(Policy.newBuilder().build()) 1427 .setUpdateMask(FieldMask.newBuilder().build()) 1428 .build(); 1429 client.setIamPolicy(request); 1430 Assert.fail("No exception raised"); 1431 } catch (InvalidArgumentException e) { 1432 // Expected exception. 1433 } 1434 } 1435 1436 @Test getIamPolicyTest()1437 public void getIamPolicyTest() throws Exception { 1438 Policy expectedResponse = 1439 Policy.newBuilder() 1440 .setVersion(351608024) 1441 .addAllBindings(new ArrayList<Binding>()) 1442 .addAllAuditConfigs(new ArrayList<AuditConfig>()) 1443 .setEtag(ByteString.EMPTY) 1444 .build(); 1445 mockService.addResponse(expectedResponse); 1446 1447 GetIamPolicyRequest request = 1448 GetIamPolicyRequest.newBuilder() 1449 .setResource(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1450 .setOptions(GetPolicyOptions.newBuilder().build()) 1451 .build(); 1452 1453 Policy actualResponse = client.getIamPolicy(request); 1454 Assert.assertEquals(expectedResponse, actualResponse); 1455 1456 List<String> actualRequests = mockService.getRequestPaths(); 1457 Assert.assertEquals(1, actualRequests.size()); 1458 1459 String apiClientHeaderKey = 1460 mockService 1461 .getRequestHeaders() 1462 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1463 .iterator() 1464 .next(); 1465 Assert.assertTrue( 1466 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1467 .matcher(apiClientHeaderKey) 1468 .matches()); 1469 } 1470 1471 @Test getIamPolicyExceptionTest()1472 public void getIamPolicyExceptionTest() throws Exception { 1473 ApiException exception = 1474 ApiExceptionFactory.createException( 1475 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1476 mockService.addException(exception); 1477 1478 try { 1479 GetIamPolicyRequest request = 1480 GetIamPolicyRequest.newBuilder() 1481 .setResource(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1482 .setOptions(GetPolicyOptions.newBuilder().build()) 1483 .build(); 1484 client.getIamPolicy(request); 1485 Assert.fail("No exception raised"); 1486 } catch (InvalidArgumentException e) { 1487 // Expected exception. 1488 } 1489 } 1490 1491 @Test testIamPermissionsTest()1492 public void testIamPermissionsTest() throws Exception { 1493 TestIamPermissionsResponse expectedResponse = 1494 TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build(); 1495 mockService.addResponse(expectedResponse); 1496 1497 TestIamPermissionsRequest request = 1498 TestIamPermissionsRequest.newBuilder() 1499 .setResource(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1500 .addAllPermissions(new ArrayList<String>()) 1501 .build(); 1502 1503 TestIamPermissionsResponse actualResponse = client.testIamPermissions(request); 1504 Assert.assertEquals(expectedResponse, actualResponse); 1505 1506 List<String> actualRequests = mockService.getRequestPaths(); 1507 Assert.assertEquals(1, actualRequests.size()); 1508 1509 String apiClientHeaderKey = 1510 mockService 1511 .getRequestHeaders() 1512 .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey()) 1513 .iterator() 1514 .next(); 1515 Assert.assertTrue( 1516 GaxHttpJsonProperties.getDefaultApiClientHeaderPattern() 1517 .matcher(apiClientHeaderKey) 1518 .matches()); 1519 } 1520 1521 @Test testIamPermissionsExceptionTest()1522 public void testIamPermissionsExceptionTest() throws Exception { 1523 ApiException exception = 1524 ApiExceptionFactory.createException( 1525 new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false); 1526 mockService.addException(exception); 1527 1528 try { 1529 TestIamPermissionsRequest request = 1530 TestIamPermissionsRequest.newBuilder() 1531 .setResource(ConnectionName.of("[PROJECT]", "[LOCATION]", "[CONNECTION]").toString()) 1532 .addAllPermissions(new ArrayList<String>()) 1533 .build(); 1534 client.testIamPermissions(request); 1535 Assert.fail("No exception raised"); 1536 } catch (InvalidArgumentException e) { 1537 // Expected exception. 1538 } 1539 } 1540 } 1541