001/* 002 * Copyright 2019-2020 Ping Identity Corporation 003 * All Rights Reserved. 004 */ 005/* 006 * Copyright 2019-2020 Ping Identity Corporation 007 * 008 * Licensed under the Apache License, Version 2.0 (the "License"); 009 * you may not use this file except in compliance with the License. 010 * You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, software 015 * distributed under the License is distributed on an "AS IS" BASIS, 016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 017 * See the License for the specific language governing permissions and 018 * limitations under the License. 019 */ 020/* 021 * Copyright (C) 2019-2020 Ping Identity Corporation 022 * 023 * This program is free software; you can redistribute it and/or modify 024 * it under the terms of the GNU General Public License (GPLv2 only) 025 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 026 * as published by the Free Software Foundation. 027 * 028 * This program is distributed in the hope that it will be useful, 029 * but WITHOUT ANY WARRANTY; without even the implied warranty of 030 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 031 * GNU General Public License for more details. 032 * 033 * You should have received a copy of the GNU General Public License 034 * along with this program; if not, see <http://www.gnu.org/licenses>. 035 */ 036package com.unboundid.ldap.sdk; 037 038 039 040import java.util.Collection; 041import java.util.List; 042 043import com.unboundid.asn1.ASN1OctetString; 044import com.unboundid.ldap.sdk.schema.Schema; 045import com.unboundid.ldif.LDIFException; 046import com.unboundid.util.Extensible; 047import com.unboundid.util.ThreadSafety; 048import com.unboundid.util.ThreadSafetyLevel; 049import com.unboundid.util.Validator; 050 051 052 053/** 054 * This class provides an implementation of an {@link FullLDAPInterface} that 055 * provides a basic means of mocking an {@link LDAPConnection} (which itself is 056 * not easily mockable because it is final, as a commonly recognized best 057 * practice for APIs). 058 */ 059@Extensible() 060@ThreadSafety(level= ThreadSafetyLevel.MOSTLY_THREADSAFE) 061public class MockableLDAPConnection 062 implements FullLDAPInterface 063{ 064 // The wrapped connection. 065 private final LDAPConnection connection; 066 067 068 069 /** 070 * Creates a new mockable LDAP connection from the provided connection. All 071 * non-overridden methods will simply be delegated to the provided connection. 072 * 073 * @param connection The connection to which all non-overridden method calls 074 * will be delegated. 075 */ 076 public MockableLDAPConnection(final LDAPConnection connection) 077 { 078 Validator.ensureNotNullWithMessage(connection, 079 "MockableLDAPConnection.connection must not be null."); 080 081 this.connection = connection; 082 } 083 084 085 086 /** 087 * Retrieves the connection that has been wrapped by this mockable LDAP 088 * connection, and to which all non-overridden method calls will be delegated. 089 * 090 * @return The connection that has been wrapped by this mockable LDAP 091 * connection, and to which all non-overridden method calls will be 092 * delegated. 093 */ 094 public final LDAPConnection getWrappedConnection() 095 { 096 return connection; 097 } 098 099 100 101 /** 102 * {@inheritDoc} 103 */ 104 @Override() 105 public void close() 106 { 107 connection.close(); 108 } 109 110 111 112 /** 113 * {@inheritDoc} 114 */ 115 @Override() 116 public RootDSE getRootDSE() 117 throws LDAPException 118 { 119 return connection.getRootDSE(); 120 } 121 122 123 124 /** 125 * {@inheritDoc} 126 */ 127 @Override() 128 public Schema getSchema() 129 throws LDAPException 130 { 131 return connection.getSchema(); 132 } 133 134 135 136 /** 137 * {@inheritDoc} 138 */ 139 @Override() 140 public Schema getSchema(final String entryDN) 141 throws LDAPException 142 { 143 return connection.getSchema(entryDN); 144 } 145 146 147 148 /** 149 * {@inheritDoc} 150 */ 151 @Override() 152 public SearchResultEntry getEntry(final String dn) 153 throws LDAPException 154 { 155 return connection.getEntry(dn); 156 } 157 158 159 160 /** 161 * {@inheritDoc} 162 */ 163 @Override() 164 public SearchResultEntry getEntry(final String dn, final String... attributes) 165 throws LDAPException 166 { 167 return connection.getEntry(dn, attributes); 168 } 169 170 171 172 /** 173 * {@inheritDoc} 174 */ 175 @Override() 176 public LDAPResult add(final String dn, final Attribute... attributes) 177 throws LDAPException 178 { 179 return connection.add(dn, attributes); 180 } 181 182 183 184 /** 185 * {@inheritDoc} 186 */ 187 @Override() 188 public LDAPResult add(final String dn, final Collection<Attribute> attributes) 189 throws LDAPException 190 { 191 return connection.add(dn, attributes); 192 } 193 194 195 196 /** 197 * {@inheritDoc} 198 */ 199 @Override() 200 public LDAPResult add(final Entry entry) 201 throws LDAPException 202 { 203 return connection.add(entry); 204 } 205 206 207 208 /** 209 * {@inheritDoc} 210 */ 211 @Override() 212 public LDAPResult add(final String... ldifLines) 213 throws LDIFException, LDAPException 214 { 215 return connection.add(ldifLines); 216 } 217 218 219 220 /** 221 * {@inheritDoc} 222 */ 223 @Override() 224 public LDAPResult add(final AddRequest addRequest) 225 throws LDAPException 226 { 227 return connection.add(addRequest); 228 } 229 230 231 232 /** 233 * {@inheritDoc} 234 */ 235 @Override() 236 public LDAPResult add(final ReadOnlyAddRequest addRequest) 237 throws LDAPException 238 { 239 return connection.add(addRequest); 240 } 241 242 243 244 /** 245 * {@inheritDoc} 246 */ 247 @Override() 248 public BindResult bind(final String bindDN, final String password) 249 throws LDAPException 250 { 251 return connection.bind(bindDN, password); 252 } 253 254 255 256 /** 257 * {@inheritDoc} 258 */ 259 @Override() 260 public BindResult bind(final BindRequest bindRequest) 261 throws LDAPException 262 { 263 return connection.bind(bindRequest); 264 } 265 266 267 268 /** 269 * {@inheritDoc} 270 */ 271 @Override() 272 public CompareResult compare(final String dn, final String attributeName, 273 final String assertionValue) 274 throws LDAPException 275 { 276 return connection.compare(dn, attributeName, assertionValue); 277 } 278 279 280 281 /** 282 * {@inheritDoc} 283 */ 284 @Override() 285 public CompareResult compare(final CompareRequest compareRequest) 286 throws LDAPException 287 { 288 return connection.compare(compareRequest); 289 } 290 291 292 293 /** 294 * {@inheritDoc} 295 */ 296 @Override() 297 public CompareResult compare(final ReadOnlyCompareRequest compareRequest) 298 throws LDAPException 299 { 300 return connection.compare(compareRequest); 301 } 302 303 304 305 /** 306 * {@inheritDoc} 307 */ 308 @Override() 309 public LDAPResult delete(final String dn) 310 throws LDAPException 311 { 312 return connection.delete(dn); 313 } 314 315 316 317 /** 318 * {@inheritDoc} 319 */ 320 @Override() 321 public LDAPResult delete(final DeleteRequest deleteRequest) 322 throws LDAPException 323 { 324 return connection.delete(deleteRequest); 325 } 326 327 328 329 /** 330 * {@inheritDoc} 331 */ 332 @Override() 333 public LDAPResult delete(final ReadOnlyDeleteRequest deleteRequest) 334 throws LDAPException 335 { 336 return connection.delete(deleteRequest); 337 } 338 339 340 341 /** 342 * {@inheritDoc} 343 */ 344 @Override() 345 public ExtendedResult processExtendedOperation(final String requestOID) 346 throws LDAPException 347 { 348 return connection.processExtendedOperation(requestOID); 349 } 350 351 352 353 /** 354 * {@inheritDoc} 355 */ 356 @Override() 357 public ExtendedResult processExtendedOperation(final String requestOID, 358 final ASN1OctetString requestValue) 359 throws LDAPException 360 { 361 return connection.processExtendedOperation(requestOID, requestValue); 362 } 363 364 365 366 /** 367 * {@inheritDoc} 368 */ 369 @Override() 370 public ExtendedResult processExtendedOperation( 371 final ExtendedRequest extendedRequest) 372 throws LDAPException 373 { 374 return connection.processExtendedOperation(extendedRequest); 375 } 376 377 378 379 /** 380 * {@inheritDoc} 381 */ 382 @Override() 383 public LDAPResult modify(final String dn, final Modification mod) 384 throws LDAPException 385 { 386 return connection.modify(dn, mod); 387 } 388 389 390 391 /** 392 * {@inheritDoc} 393 */ 394 @Override() 395 public LDAPResult modify(final String dn, final Modification... mods) 396 throws LDAPException 397 { 398 return connection.modify(dn, mods); 399 } 400 401 402 403 /** 404 * {@inheritDoc} 405 */ 406 @Override() 407 public LDAPResult modify(final String dn, final List<Modification> mods) 408 throws LDAPException 409 { 410 return connection.modify(dn, mods); 411 } 412 413 414 415 /** 416 * {@inheritDoc} 417 */ 418 @Override() 419 public LDAPResult modify(final String... ldifModificationLines) 420 throws LDIFException, LDAPException 421 { 422 return connection.modify(ldifModificationLines); 423 } 424 425 426 427 /** 428 * {@inheritDoc} 429 */ 430 @Override() 431 public LDAPResult modify(final ModifyRequest modifyRequest) 432 throws LDAPException 433 { 434 return connection.modify(modifyRequest); 435 } 436 437 438 439 /** 440 * {@inheritDoc} 441 */ 442 @Override() 443 public LDAPResult modify(final ReadOnlyModifyRequest modifyRequest) 444 throws LDAPException 445 { 446 return connection.modify(modifyRequest); 447 } 448 449 450 451 /** 452 * {@inheritDoc} 453 */ 454 @Override() 455 public LDAPResult modifyDN(final String dn, final String newRDN, 456 final boolean deleteOldRDN) 457 throws LDAPException 458 { 459 return connection.modifyDN(dn, newRDN, deleteOldRDN); 460 } 461 462 463 464 /** 465 * {@inheritDoc} 466 */ 467 @Override() 468 public LDAPResult modifyDN(final String dn, final String newRDN, 469 final boolean deleteOldRDN, 470 final String newSuperiorDN) 471 throws LDAPException 472 { 473 return connection.modifyDN(dn, newRDN, deleteOldRDN, newSuperiorDN); 474 } 475 476 477 478 /** 479 * {@inheritDoc} 480 */ 481 @Override() 482 public LDAPResult modifyDN(final ModifyDNRequest modifyDNRequest) 483 throws LDAPException 484 { 485 return connection.modifyDN(modifyDNRequest); 486 } 487 488 489 490 /** 491 * {@inheritDoc} 492 */ 493 @Override() 494 public LDAPResult modifyDN(final ReadOnlyModifyDNRequest modifyDNRequest) 495 throws LDAPException 496 { 497 return connection.modifyDN(modifyDNRequest); 498 } 499 500 501 502 /** 503 * {@inheritDoc} 504 */ 505 @Override() 506 public SearchResult search(final String baseDN, final SearchScope scope, 507 final String filter, final String... attributes) 508 throws LDAPSearchException 509 { 510 return connection.search(baseDN, scope, filter, attributes); 511 } 512 513 514 515 /** 516 * {@inheritDoc} 517 */ 518 @Override() 519 public SearchResult search(final String baseDN, final SearchScope scope, 520 final Filter filter, final String... attributes) 521 throws LDAPSearchException 522 { 523 return connection.search(baseDN, scope, filter, attributes); 524 } 525 526 527 528 /** 529 * {@inheritDoc} 530 */ 531 @Override() 532 public SearchResult search(final SearchResultListener searchResultListener, 533 final String baseDN, final SearchScope scope, 534 final String filter, final String... attributes) 535 throws LDAPSearchException 536 { 537 return connection.search(searchResultListener, baseDN, scope, filter, 538 attributes); 539 } 540 541 542 543 /** 544 * {@inheritDoc} 545 */ 546 @Override() 547 public SearchResult search(final SearchResultListener searchResultListener, 548 final String baseDN, final SearchScope scope, 549 final Filter filter, final String... attributes) 550 throws LDAPSearchException 551 { 552 return connection.search(searchResultListener, baseDN, scope, filter, 553 attributes); 554 } 555 556 557 558 /** 559 * {@inheritDoc} 560 */ 561 @Override() 562 public SearchResult search(final String baseDN, final SearchScope scope, 563 final DereferencePolicy derefPolicy, 564 final int sizeLimit, final int timeLimit, 565 final boolean typesOnly, final String filter, 566 final String... attributes) 567 throws LDAPSearchException 568 { 569 return connection.search(baseDN, scope, derefPolicy, sizeLimit, timeLimit, 570 typesOnly, filter, attributes); 571 } 572 573 574 575 /** 576 * {@inheritDoc} 577 */ 578 @Override() 579 public SearchResult search(final String baseDN, final SearchScope scope, 580 final DereferencePolicy derefPolicy, 581 final int sizeLimit, final int timeLimit, 582 final boolean typesOnly, final Filter filter, 583 final String... attributes) 584 throws LDAPSearchException 585 { 586 return connection.search(baseDN, scope, derefPolicy, sizeLimit, timeLimit, 587 typesOnly, filter, attributes); 588 } 589 590 591 592 /** 593 * {@inheritDoc} 594 */ 595 @Override() 596 public SearchResult search(final SearchResultListener searchResultListener, 597 final String baseDN, final SearchScope scope, 598 final DereferencePolicy derefPolicy, 599 final int sizeLimit, final int timeLimit, 600 final boolean typesOnly, final String filter, 601 final String... attributes) 602 throws LDAPSearchException 603 { 604 return connection.search(searchResultListener, baseDN, scope, derefPolicy, 605 sizeLimit, timeLimit, typesOnly, filter, attributes); 606 } 607 608 609 610 /** 611 * {@inheritDoc} 612 */ 613 @Override() 614 public SearchResult search(final SearchResultListener searchResultListener, 615 final String baseDN, final SearchScope scope, 616 final DereferencePolicy derefPolicy, 617 final int sizeLimit, final int timeLimit, 618 final boolean typesOnly, final Filter filter, 619 final String... attributes) 620 throws LDAPSearchException 621 { 622 return connection.search(searchResultListener, baseDN, scope, derefPolicy, 623 sizeLimit, timeLimit, typesOnly, filter, attributes); 624 } 625 626 627 628 /** 629 * {@inheritDoc} 630 */ 631 @Override() 632 public SearchResult search(final SearchRequest searchRequest) 633 throws LDAPSearchException 634 { 635 return connection.search(searchRequest); 636 } 637 638 639 640 /** 641 * {@inheritDoc} 642 */ 643 @Override() 644 public SearchResult search(final ReadOnlySearchRequest searchRequest) 645 throws LDAPSearchException 646 { 647 return connection.search(searchRequest); 648 } 649 650 651 652 /** 653 * {@inheritDoc} 654 */ 655 @Override() 656 public SearchResultEntry searchForEntry(final String baseDN, 657 final SearchScope scope, 658 final String filter, 659 final String... attributes) 660 throws LDAPSearchException 661 { 662 return connection.searchForEntry(baseDN, scope, filter, attributes); 663 } 664 665 666 667 /** 668 * {@inheritDoc} 669 */ 670 @Override() 671 public SearchResultEntry searchForEntry(final String baseDN, 672 final SearchScope scope, 673 final Filter filter, 674 final String... attributes) 675 throws LDAPSearchException 676 { 677 return connection.searchForEntry(baseDN, scope, filter, attributes); 678 } 679 680 681 682 /** 683 * {@inheritDoc} 684 */ 685 @Override() 686 public SearchResultEntry searchForEntry(final String baseDN, 687 final SearchScope scope, 688 final DereferencePolicy derefPolicy, 689 final int timeLimit, 690 final boolean typesOnly, 691 final String filter, 692 final String... attributes) 693 throws LDAPSearchException 694 { 695 return connection.searchForEntry(baseDN, scope, derefPolicy, timeLimit, 696 typesOnly, filter, attributes); 697 } 698 699 700 701 /** 702 * {@inheritDoc} 703 */ 704 @Override() 705 public SearchResultEntry searchForEntry(final String baseDN, 706 final SearchScope scope, 707 final DereferencePolicy derefPolicy, 708 final int timeLimit, 709 final boolean typesOnly, 710 final Filter filter, 711 final String... attributes) 712 throws LDAPSearchException 713 { 714 return connection.searchForEntry(baseDN, scope, derefPolicy, timeLimit, 715 typesOnly, filter, attributes); 716 } 717 718 719 720 /** 721 * {@inheritDoc} 722 */ 723 @Override() 724 public SearchResultEntry searchForEntry(final SearchRequest searchRequest) 725 throws LDAPSearchException 726 { 727 return connection.searchForEntry(searchRequest); 728 } 729 730 731 732 /** 733 * {@inheritDoc} 734 */ 735 @Override() 736 public SearchResultEntry searchForEntry( 737 final ReadOnlySearchRequest searchRequest) 738 throws LDAPSearchException 739 { 740 return connection.searchForEntry(searchRequest); 741 } 742}