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}