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