/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt * or http://forgerock.org/license/CDDLv1.0.html. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at legal-notices/CDDLv1_0.txt. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: * Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END * * * Copyright 2009-2010 Sun Microsystems, Inc. * Portions copyright 2012 ForgeRock AS. */ package org.forgerock.opendj.ldif; import static org.fest.assertions.Assertions.assertThat; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.List; import java.util.NoSuchElementException; import java.util.SortedMap; import java.util.TreeMap; import org.forgerock.i18n.LocalizedIllegalArgumentException; import org.forgerock.opendj.ldap.DN; import org.forgerock.opendj.ldap.DecodeException; import org.forgerock.opendj.ldap.Entry; import org.forgerock.opendj.ldap.LinkedHashMapEntry; import org.forgerock.opendj.ldap.Modification; import org.forgerock.opendj.ldap.ModificationType; import org.forgerock.opendj.ldap.SearchScope; import org.forgerock.opendj.ldap.requests.AddRequest; import org.forgerock.opendj.ldap.requests.DeleteRequest; import org.forgerock.opendj.ldap.requests.ModifyRequest; import org.forgerock.opendj.ldap.requests.Requests; import org.forgerock.opendj.ldap.requests.SearchRequest; import org.forgerock.opendj.ldap.schema.Schema; import org.testng.annotations.Test; /** * This class tests the LDIF functionality. */ @SuppressWarnings("javadoc") public class LDIFTestCase extends AbstractLDIFTestCase { /** * Provide a standard entry for the tests below. * * @return well formed LDIF entry */ public final String[] getStandardEntry() { // @formatter:off final String[] entry = { "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "postalAddress: Aaccf Amar$01251 Chestnut Street$Panama City, DE 50369", "postalCode: 50369", "uid: user.0", "description: This is the description for Aaccf Amar.", "userPassword: {SSHA}hpbT8dLi8xgYy2kl4aP6QKGzsFdhESWpPmDTEw==", "employeeNumber: 0", "initials: ASA", "givenName: Aaccf", "pager: +1 779 041 6341", "mobile: +1 010 154 3228", "cn: Aaccf Amar", "telephoneNumber: +1 685 622 6202", "sn: Amar", "street: 01251 Chestnut Street", "homePhone: +1 225 216 5900", "mail: user.0@maildomain.net", "l: Panama City", "st: DE", "pwdChangedTime: 20120903142126.219Z", "entryDN: uid=user.0,ou=people,dc=example,dc=org", "entryUUID: ad55a34a-763f-358f-93f9-da86f9ecd9e4", "modifyTimestamp: 20120903142126Z", "modifiersName: cn=Internal Client,cn=Root DNs,cn=config" }; // @formatter:on return entry; } /** * Number of attributes of the standard entry. */ public final int nbStandardEntryAttributes = new LinkedHashMapEntry(getStandardEntry()) .getAttributeCount(); /** * Testing LDIF Search with match. * * @throws Exception */ @Test() public final void testLdifSearchWithMatch() throws Exception { final EntryReader reader = new LDIFEntryReader(getStandardEntry()); final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)"); final EntryReader resultReader = LDIF.search(reader, sr); final Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo("uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(nbStandardEntryAttributes); reader.close(); resultReader.close(); } /** * Testing LDIF Search with no match. * * @throws Exception */ @Test() public final void testLdifSearchWithNoMatch() throws Exception { final EntryReader reader = new LDIFEntryReader(getStandardEntry()); final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=org", SearchScope.WHOLE_SUBTREE, "(uid=user.0)"); final EntryReader resultReader = LDIF.search(reader, sr); // No result found in the reader. assertThat(resultReader.hasNext()).isFalse(); resultReader.close(); } /** * LDIF Search with null parameters throw a NullPointerException. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifSearchDoesntAllowNull() throws Exception { LDIF.search(null, null); } /** * LDIF Search doesn't allow a null search request. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifSearchDoesntAllowNullSearchRequest() throws Exception { final EntryReader reader = new LDIFEntryReader(getStandardEntry()); try { LDIF.search(reader, null); } finally { reader.close(); } } /** * LDIF Search with null reader is allowed but throws null pointer * exception. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifSearchAllowsNullReader() throws Exception { final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)"); final EntryReader resultReader = LDIF.search(null, sr); resultReader.readEntry(); resultReader.close(); } /** * Test the search request using a schema and no specifying attribute * description. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchNoAttributeDescription() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "uid=*"); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(2); assertThat(entry.getAttribute("uid")).isNotNull(); assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull(); assertThat(entry.getAttribute("uid").firstValueAsString()).isNotNull(); } resultReader.close(); } /** * Test the search request using a schema and no specifying attribute * description. TypesOnly = true. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchNoAttributeDescriptionTypeOnly() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "uid=*") .setTypesOnly(true); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(2); assertThat(entry.getAttribute("uid")).isNotNull(); assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull(); assertThat(entry.getAttribute("uid")).isEmpty(); } resultReader.close(); } /** * LDIF Search with Schema use : all attributes. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchFullAttributes() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "*"); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(2); assertThat(entry.getAttribute("uid")).isNotNull(); assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull(); assertThat(entry.getAttribute("uid").firstValueAsString()).isEqualTo("user.0"); } resultReader.close(); } /** * LDIF Search with Schema use : all attributes. Types only. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchFullAttributesTypeOnly() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "*").setTypesOnly(true); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(2); assertThat(entry.getAttribute("objectClass")).isNotNull(); assertThat(entry.getAttribute("uid")).isNotNull(); assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull(); assertThat(entry.getAttribute("uid")).isEmpty(); try { assertThat(entry.getAttribute("uid").firstValueAsString()).isNull(); } catch (NoSuchElementException ex) { // No values, only type. // Expected exception on entry.getAttribute("uid").firstValueAsString() } } resultReader.close(); } /** * Testing the new search request with the + operator == operational * attributes only. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchOnlyOperationalAttributes() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0", "entryDN: uid=user.0,ou=People,dc=example,dc=com", "entryUUID: ad55a34a-763f-358f-93f9-da86f9ecd9e4", "modifyTimestamp: 20120903142126Z", "modifiersName: cn=Internal Client,cn=Root DNs,cn=config" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "+"); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getCoreSchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(4); assertThat(entry.getAttribute("entryDN").firstValueAsString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttribute("entryUUID")).isNotEmpty(); assertThat(entry.getAttribute("modifyTimestamp")).isNotEmpty(); assertThat(entry.getAttribute("modifiersName")).isNotEmpty(); } resultReader.close(); } /** * Testing the new search request with the + operator == operational * attributes only. Combined here with the TypeOnly = true. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchOnlyOperationalAttributesTypeOnly() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0", "entryDN: uid=user.0,ou=People,dc=example,dc=com", "entryUUID: ad55a34a-763f-358f-93f9-da86f9ecd9e4", "modifyTimestamp: 20120903142126Z", "modifiersName: cn=Internal Client,cn=Root DNs,cn=config" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "+").setTypesOnly(true); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getCoreSchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(4); assertThat(entry.getAttribute("entryDN")).isEmpty(); assertThat(entry.getAttribute("entryUUID")).isEmpty(); assertThat(entry.getAttribute("modifyTimestamp")).isEmpty(); assertThat(entry.getAttribute("modifiersName")).isEmpty(); } resultReader.close(); } /** * LDIF Search with Schema use filter on uid attribute. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchSpecifiedAttribute() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "uid"); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(1); } resultReader.close(); } /** * LDIF Search with Schema use filter on uid attribute. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaMatchSpecifiedAttributeTypeOnly() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "uid").setTypesOnly(true); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(1); assertThat(entry.getAttribute("uid").getAttributeDescription()).isNotNull(); assertThat(entry.getAttribute("uid")).isEmpty(); try { assertThat(entry.getAttribute("uid").firstValueAsString()).isNull(); } catch (NoSuchElementException ex) { // No values, only type. // Expected exception on entry.getAttribute("uid").firstValueAsString() } } resultReader.close(); } /** * LDIF Search with Schema use with filter not contained in this entry. * * @throws Exception */ @Test() public final void testLdifSearchWithSchemaNoMatchSpecifiedAttribute() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "email"); final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { Entry entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isEqualTo( "uid=user.0,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(0); } resultReader.close(); } /** * The attribute description contains an internal white space : must throw * an exception. * * @throws Exception */ @Test(expectedExceptions = LocalizedIllegalArgumentException.class) public final void testLdifSearchWithSchemaThrowsException() throws Exception { // @formatter:off final EntryReader reader = new LDIFEntryReader( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson", "objectClass: organizationalperson", "objectClass: top", "uid: user.0" ); // @formatter:on final SearchRequest sr = Requests.newSearchRequest("dc=example,dc=com", SearchScope.WHOLE_SUBTREE, "(uid=user.0)", "wro ng"); // wrong syntax filter final EntryReader resultReader = LDIF.search(reader, sr, Schema.getEmptySchema()); if (resultReader.hasNext()) { resultReader.readEntry(); } resultReader.close(); } /** * Verifying LDIF Collection reader. * * @throws Exception */ @Test() public final void testLdifNewEntryCollectionReader() throws Exception { // @formatter:off Entry e = new LinkedHashMapEntry( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson" ); Entry e1 = new LinkedHashMapEntry("dn: uid=user.1,ou=People,dc=example,dc=com", "objectClass: person"); Entry e2 = new LinkedHashMapEntry("dn: uid=user.2,ou=People,dc=example,dc=com", "objectClass: person"); // @formatter:on Collection collection = new ArrayList(); collection.add(e); collection.add(e1); collection.add(e2); final EntryReader resultReader = LDIF.newEntryCollectionReader(collection); Entry entry = null; int cCount = 0; while (resultReader.hasNext()) { entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isNotNull(); assertThat(entry.getAttributeCount()).isGreaterThanOrEqualTo(1); cCount++; } assertThat(cCount).isEqualTo(3); resultReader.close(); } /** * The LDIF newEntryCollectionReader allows a null parameter. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifNewEntryCollectionDoesntAllowNull() throws Exception { EntryReader resultReader = null; try { resultReader = LDIF.newEntryCollectionReader(null); resultReader.readEntry(); } finally { resultReader.close(); } } /** * LDIF newEntryIteratorReader. * * @throws Exception */ @Test() public final void testLdifNewEntryIteratorReader() throws Exception { // @formatter:off final Entry e = new LinkedHashMapEntry( "dn: uid=user.0,ou=People,dc=example,dc=com", "objectClass: person", "objectClass: inetorgperson" ); final Entry e1 = new LinkedHashMapEntry("dn: uid=user.1,ou=People,dc=example,dc=com", "objectClass: person"); // @formatter:on final SortedMap sourceEntries = new TreeMap(); sourceEntries.put(DN.valueOf("uid=user.0,ou=People,dc=example,dc=com"), e); sourceEntries.put(DN.valueOf("uid=user.1,ou=People,dc=example,dc=com"), e1); final Iterator sourceIterator = sourceEntries.values().iterator(); final EntryReader resultReader = LDIF.newEntryIteratorReader(sourceIterator); Entry entry = null; int cCount = 0; while (resultReader.hasNext()) { entry = resultReader.readEntry(); assertThat(entry.getName().toString()).isNotNull(); assertThat(entry.getName().toString()).contains("ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isGreaterThanOrEqualTo(1); cCount++; } assertThat(cCount).isEqualTo(2); resultReader.close(); } /** * LDIF newEntryIteratorReader doesn't allow null. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifNewEntryIteratorReaderDoesntAllowsNull() throws Exception { EntryReader resultReader = null; try { resultReader = LDIF.newEntryIteratorReader(null); resultReader.readEntry(); } finally { resultReader.close(); } } /** * Verify LDIF CopyToChangeRecord is working. * * @throws Exception */ @Test() public final void testLdifCopyToChangeRecord() throws Exception { // @formatter:off final LDIFChangeRecordReader reader = new LDIFChangeRecordReader( "# Entry to delete", "dn: uid=scarter,ou=People,dc=example,dc=com", "changetype: delete" ); // @formatter:on final java.util.List actual = new ArrayList(); final LDIFChangeRecordWriter writer = new LDIFChangeRecordWriter(actual); try { LDIF.copyTo(reader, writer); // Comment is skipped. assertThat(actual.get(0)).isEqualTo("dn: uid=scarter,ou=People,dc=example,dc=com"); assertThat(actual.get(1)).isEqualTo("changetype: delete"); assertThat(actual.get(2)).isEqualTo(""); assertThat(actual.size()).isEqualTo(3); // 2 lines + 1 empty } finally { reader.close(); writer.close(); } } /** * LDIF copyTo - ChangeRecord doesn't allow null parameters. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifCopyToChangeRecordDoesntAllowNull() throws Exception { LDIF.copyTo((ChangeRecordReader) null, (ChangeRecordWriter) null); } /** * LDIF copyTo - ChangeRecord doesn't allow a null writer. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifCopyToChangeRecordDoesntAllowNullWriter() throws Exception { // @formatter:off final LDIFChangeRecordReader reader = new LDIFChangeRecordReader( "# Entry to delete", "dn: uid=scarter,ou=People,dc=example,dc=com", "changetype: delete" ); // @formatter:on LDIF.copyTo(reader, null); } /** * LDIF copyTo - ChangeRecord doesn't allow a null reader. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifCopyToChangeRecordDoesntAllowNullReader() throws Exception { final java.util.List actual = new ArrayList(); final LDIFChangeRecordWriter writer = new LDIFChangeRecordWriter(actual); LDIF.copyTo(null, writer); } /** * LDIF copyTo - EntryWriter doesn't allow null. * * @throws Exception */ @Test() public final void testLdifCopyToEntryWriter() throws Exception { // @formatter:off final LDIFEntryReader reader = new LDIFEntryReader( "# Entry to delete", "dn: uid=scarter,ou=People,dc=example,dc=com", "changetype: delete" ); // @formatter:on final List actual = new ArrayList(); final LDIFEntryWriter writer = new LDIFEntryWriter(actual); try { LDIF.copyTo(reader, writer); // Comment is skipped. assertThat(actual.get(0)).isEqualTo("dn: uid=scarter,ou=People,dc=example,dc=com"); assertThat(actual.get(1)).isEqualTo("changetype: delete"); assertThat(actual.get(2)).isEqualTo(""); assertThat(actual.size()).isEqualTo(3); // 2 lines + 1 empty } finally { reader.close(); writer.close(); } } /** * LDIF copyTo - EntryWriter doesn't allow a null writer. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifCopyToEntryWriterDoesntAllowNullWriter() throws Exception { // @formatter:off final LDIFEntryReader reader = new LDIFEntryReader( "# Entry to delete", "dn: uid=scarter,ou=People,dc=example,dc=com", "changetype: delete" ); // @formatter:on LDIF.copyTo(reader, null); } /** * LDIF copyTo - EntryWriter doesn't allow a null reader. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifCopyToEntryWriterDoesntAllowNullReader() throws Exception { final List actual = new ArrayList(); final LDIFEntryWriter writer = new LDIFEntryWriter(actual); LDIF.copyTo(null, writer); } /** * Testing the diff function. Following example from the admin guide. * * @see Admin Guide * @throws Exception */ @Test() public final void testLdifDiffEntriesModsOnSameDN() throws Exception { // @formatter:off final LDIFEntryReader source = new LDIFEntryReader( "dn: uid=newuser,ou=People,dc=example,dc=com", "uid: newuser", "objectClass: person", "objectClass: organizationalPerson", "objectClass: inetOrgPerson", "objectClass: top", "cn: New User", "sn: User", "ou: People", "mail: newuser@example.com", "userPassword: changeme" // diff here ); final LDIFEntryReader target = new LDIFEntryReader( "dn: uid=newuser,ou=People,dc=example,dc=com", "uid: newuser", "objectClass: person", "objectClass: organizationalPerson", "objectClass: inetOrgPerson", "objectClass: top", "cn: New User", "sn: User", "ou: People", "mail: newuser@example.com", "userPassword: secret12", // diff here "description: A new description." // diff here ); // @formatter:on final ChangeRecordReader reader = LDIF.diff(source, target); final ChangeRecord cr = reader.readChangeRecord(); assertThat(cr.getName().toString()).isEqualTo("uid=newuser,ou=People,dc=example,dc=com"); assertThat(cr).isInstanceOf(ModifyRequest.class); // @formatter:off /* Expected : 2 add / 1 delete. * dn: uid=newuser,ou=People,dc=example,dc=com * changetype: modify * add: userPassword * userPassword: secret12 * - * delete: userPassword * userPassword: changeme * - * add: description * description: A new description. */ // @formatter:on assertThat(((ModifyRequest) cr).getModifications().size()).isEqualTo(3); for (Modification mod : ((ModifyRequest) cr).getModifications()) { if (mod.getModificationType() == ModificationType.ADD) { assertThat((mod.getAttribute().getAttributeDescription().toString()) .equals("description") || (mod.getAttribute().getAttributeDescription().toString()) .equals("userPassword")); assertThat((mod.getAttribute().firstValueAsString()).equals("A new description.") || (mod.getAttribute().firstValueAsString()).equals("secret12")); } if (mod.getModificationType() == ModificationType.DELETE) { assertThat(mod.getAttribute().getAttributeDescription().toString()).isEqualTo( "userPassword"); assertThat(mod.getAttribute().firstValueAsString()).isEqualTo("changeme"); } } reader.close(); target.close(); } /** * Testing the diff : entry in source but not in target. * * @throws Exception */ @Test() public final void testLdifDiffEntriesEntryInSourceNotInTarget() throws Exception { // @formatter:off final LDIFEntryReader source = new LDIFEntryReader( "dn: uid=newuser,ou=People,dc=example,dc=com", "cn: New User" ); final LDIFEntryReader target = new LDIFEntryReader( "dn: uid=scarter,ou=People,dc=example,dc=com", "cn: Samantha Carter" ); // @formatter:on final ChangeRecordReader reader = LDIF.diff(source, target); // @formatter:off /* output is : dn: uid=newuser,ou=People,dc=example,dc=com changetype: delete dn: uid=scarter,ou=People,dc=example,dc=com changetype: add cn: Samantha Carter */ // @formatter:on ChangeRecord cr = reader.readChangeRecord(); assertThat(cr.getName().toString()).isEqualTo("uid=newuser,ou=People,dc=example,dc=com"); assertThat(cr).isInstanceOf(DeleteRequest.class); cr = reader.readChangeRecord(); assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com"); assertThat(cr).isInstanceOf(AddRequest.class); assertThat(((AddRequest) cr).getAttributeCount()).isEqualTo(1); assertThat(((AddRequest) cr).getAttribute("cn").firstValueAsString()).isEqualTo( "Samantha Carter"); reader.close(); target.close(); } /** * Testing the diff : entry in target not in source. The rdn of the * following example is completed by ou=People. * * @throws Exception */ @Test() public final void testLdifDiffEntriesEntryInTargetNotInSource() throws Exception { // @formatter:off final LDIFEntryReader source = new LDIFEntryReader( "dn: uid=scarter,dc=example,dc=com", "cn: Samantha Carter" ); final LDIFEntryReader target = new LDIFEntryReader( "dn: uid=scarter,ou=People,dc=example,dc=com", "cn: Samantha Carter" ); // @formatter:on final ChangeRecordReader reader = LDIF.diff(source, target); // @formatter:off /* output is : dn: uid=scarter,ou=People,dc=example,dc=com changetype: add cn: Samantha Carter dn: uid=scarter,dc=example,dc=com changetype: delete */ // @formatter:on ChangeRecord cr = reader.readChangeRecord(); assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com"); assertThat(cr).isInstanceOf(AddRequest.class); assertThat(((AddRequest) cr).getAttributeCount()).isEqualTo(1); assertThat(((AddRequest) cr).getAttribute("cn").firstValueAsString()).isEqualTo( "Samantha Carter"); cr = reader.readChangeRecord(); assertThat(cr.getName().toString()).isEqualTo("uid=scarter,dc=example,dc=com"); assertThat(cr).isInstanceOf(DeleteRequest.class); reader.close(); source.close(); target.close(); } /** * Diff between two same entries : no modifications expected. * * @throws Exception */ @Test() public final void testLdifDiffEntriesNoDiff() throws Exception { // @formatter:off final LDIFEntryReader source = new LDIFEntryReader( "dn: uid=scarter,ou=People,dc=example,dc=com", "cn: Samantha Carter" ); final LDIFEntryReader target = new LDIFEntryReader( "dn: uid=scarter,ou=People,dc=example,dc=com", "cn: Samantha Carter" ); // @formatter:on final ChangeRecordReader reader = LDIF.diff(source, target); assertThat(reader.hasNext()).isTrue(); final ChangeRecord cr = reader.readChangeRecord(); assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com"); assertThat(cr instanceof ModifyRequest); assertThat(((ModifyRequest) cr).getModifications()).isEmpty(); reader.close(); target.close(); } /** * Diff between two same entries : no modifications expected. * * @throws Exception */ @Test() public final void testLdifDiffEntriesNoDiffBase64() throws Exception { // @formatter:off final LDIFEntryReader source = new LDIFEntryReader( "dn: uid=scarter,ou=People,dc=example,dc=com", "cn: Samantha Carter" ); final LDIFEntryReader target = new LDIFEntryReader( "dn:: dWlkPXNjYXJ0ZXIsb3U9UGVvcGxlLGRjPWV4YW1wbGUsZGM9Y29t", "cn: Samantha Carter" ); // @formatter:on final ChangeRecordReader reader = LDIF.diff(source, target); assertThat(reader.hasNext()).isTrue(); final ChangeRecord cr = reader.readChangeRecord(); assertThat(cr.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com"); assertThat(cr instanceof ModifyRequest); assertThat(((ModifyRequest) cr).getModifications()).isEmpty(); reader.close(); target.close(); } /** * The diff function doesn't allow malformed ldif. Exception expected. * * @throws Exception */ @Test(expectedExceptions = DecodeException.class) public final void testLdifDiffEntriesNoDiffMalformedTarget() throws Exception { final LDIFEntryReader source = new LDIFEntryReader("dn: uid=scarter,ou=People,dc=example,dc=com"); final LDIFEntryReader target = new LDIFEntryReader("dn: wrongRDN"); LDIF.diff(source, target); } /** * LDIF diff - EntryReader/Writer doesn't allow null. Exception expected. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifDiffEntriesDoesntAllowNull() throws Exception { LDIF.diff(null, null); } /** * Test the patch function. Apply simple patch to replace/add data to the * input. * * @throws Exception */ @Test() public final void testLdifPatch() throws Exception { // @formatter:off final LDIFEntryReader input = new LDIFEntryReader( "dn: uid=scarter,ou=People,dc=example,dc=com", "objectClass: person", "sn: new user", "mail: mail@mailme.org" ); // @formatter:off final LDIFChangeRecordReader patch = new LDIFChangeRecordReader( "dn: uid=scarter,ou=People,dc=example,dc=com", "changetype: modify", "replace:sn", "sn: scarter", "-", "add: manager", "manager: uid=joneill,ou=People,dc=example,dc=com" ); // @formatter:on // @formatter:on final EntryReader reader = LDIF.patch(input, patch); Entry entry = reader.readEntry(); assertThat(entry.getName().toString()).isEqualTo("uid=scarter,ou=People,dc=example,dc=com"); assertThat(entry.getAttributeCount()).isEqualTo(4); // objectclass - sn - mail - manager assertThat(entry.getAttribute("manager").firstValueAsString()).isEqualTo( "uid=joneill,ou=People,dc=example,dc=com"); reader.close(); } /** * LDIF patch - EntryReader/ChangeRecordReader doesn't allow null. Exception * expected. * * @throws Exception */ @Test(expectedExceptions = NullPointerException.class) public final void testLdifPatchDoesntAllowNull() throws Exception { LDIF.patch(null, null); } }