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}