| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| package org.apache.directory.api.ldap.model.ldif; |
| |
| |
| import static org.junit.jupiter.api.Assertions.assertEquals; |
| import static org.junit.jupiter.api.Assertions.assertFalse; |
| import static org.junit.jupiter.api.Assertions.assertNotNull; |
| import static org.junit.jupiter.api.Assertions.assertNull; |
| import static org.junit.jupiter.api.Assertions.assertTrue; |
| import static org.junit.jupiter.api.Assertions.fail; |
| |
| import java.util.List; |
| |
| import javax.naming.NamingException; |
| import javax.naming.directory.Attribute; |
| import javax.naming.directory.Attributes; |
| import javax.naming.directory.BasicAttribute; |
| import javax.naming.directory.BasicAttributes; |
| |
| import org.apache.directory.api.ldap.model.entry.DefaultEntry; |
| import org.apache.directory.api.ldap.model.entry.Entry; |
| import org.apache.directory.api.ldap.model.exception.LdapException; |
| import org.apache.directory.api.ldap.model.exception.LdapInvalidAttributeValueException; |
| import org.apache.directory.api.ldap.model.ldif.ChangeType; |
| import org.apache.directory.api.ldap.model.ldif.LdapLdifException; |
| import org.apache.directory.api.ldap.model.ldif.LdifEntry; |
| import org.apache.directory.api.ldap.model.ldif.LdifReader; |
| import org.apache.directory.api.ldap.model.ldif.LdifRevertor; |
| import org.apache.directory.api.ldap.model.ldif.LdifUtils; |
| import org.apache.directory.api.ldap.model.message.controls.ManageDsaITImpl; |
| import org.apache.directory.api.ldap.model.name.Dn; |
| import org.apache.directory.api.ldap.model.name.Rdn; |
| import org.apache.directory.api.util.Strings; |
| import org.junit.jupiter.api.Test; |
| import org.junit.jupiter.api.parallel.Execution; |
| import org.junit.jupiter.api.parallel.ExecutionMode; |
| |
| |
| /** |
| * Tests the LdifUtils methods |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| */ |
| @Execution(ExecutionMode.CONCURRENT) |
| public class LdifUtilsTest |
| { |
| private String testString = "this is a test"; |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a null String |
| */ |
| @Test |
| public void testIsLdifNullString() |
| { |
| assertTrue( LdifUtils.isLDIFSafe( null ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with an empty String |
| */ |
| @Test |
| public void testIsLdifEmptyString() |
| { |
| assertTrue( LdifUtils.isLDIFSafe( "" ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char NUL (ASCII code 0) |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithNUL() |
| { |
| char c = ( char ) 0; |
| |
| assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char LF (ASCII code 10) |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithLF() |
| { |
| char c = ( char ) 10; |
| |
| assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char CR (ASCII code 13) |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithCR() |
| { |
| char c = ( char ) 13; |
| |
| assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char SPACE (ASCII code 32) |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithSpace() |
| { |
| char c = ( char ) 32; |
| |
| assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char COLON (:) (ASCII code 58) |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithColon() |
| { |
| char c = ( char ) 58; |
| |
| assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char LESS_THAN (<) (ASCII code 60) |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithLessThan() |
| { |
| char c = ( char ) 60; |
| |
| assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char with ASCII code 127 |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithCharGreaterThan127() |
| { |
| char c = ( char ) 127; |
| |
| assertTrue( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String starting with the |
| * char with ASCII code greater than 127 |
| */ |
| @Test |
| public void testIsLdifSafeStartingWithCharGreaterThan127Bis() |
| { |
| char c = ( char ) 222; |
| |
| assertFalse( LdifUtils.isLDIFSafe( c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String containing the |
| * char NUL (ASCII code 0) |
| */ |
| @Test |
| public void testIsLdifSafeContainsNUL() |
| { |
| char c = ( char ) 0; |
| |
| assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String containing the |
| * char LF (ASCII code 10) |
| */ |
| @Test |
| public void testIsLdifSafeContainsLF() |
| { |
| char c = ( char ) 10; |
| |
| assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String containing the |
| * char CR (ASCII code 13) |
| */ |
| @Test |
| public void testIsLdifSafeContainsCR() |
| { |
| char c = ( char ) 13; |
| |
| assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String containing the |
| * char with ASCII code 127 |
| */ |
| @Test |
| public void testIsLdifSafeContainsCharGreaterThan127() |
| { |
| char c = ( char ) 127; |
| |
| assertTrue( LdifUtils.isLDIFSafe( testString + c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String containing a |
| * char with ASCII code greater than 127 |
| */ |
| @Test |
| public void testIsLdifSafeContainsCharGreaterThan127Bis() |
| { |
| char c = ( char ) 328; |
| |
| assertFalse( LdifUtils.isLDIFSafe( testString + c + testString ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a String ending with the |
| * char SPACE (ASCII code 32) |
| */ |
| @Test |
| public void testIsLdifSafeEndingWithSpace() |
| { |
| char c = ( char ) 32; |
| |
| assertFalse( LdifUtils.isLDIFSafe( testString + c ) ); |
| } |
| |
| |
| /** |
| * Tests the method IsLdifSafe with a correct String |
| */ |
| @Test |
| public void testIsLdifSafeCorrectString() |
| { |
| assertTrue( LdifUtils.isLDIFSafe( testString ) ); |
| } |
| |
| |
| /** |
| * Test the way LDIF lines are stripped to a number of chars |
| */ |
| @Test |
| public void testStripLineToNChars() |
| { |
| String line = "abc"; |
| |
| try |
| { |
| LdifUtils.stripLineToNChars( line, 1 ); |
| fail(); |
| } |
| catch ( IllegalArgumentException iae ) |
| { |
| // This is correct |
| } |
| |
| String res = LdifUtils.stripLineToNChars( line, 2 ); |
| assertEquals( "ab\n c", res ); |
| assertEquals( "abc", LdifUtils.stripLineToNChars( line, 3 ) ); |
| } |
| |
| |
| /** |
| * Test that the LDIF is stripped to 5 chars per line |
| * |
| */ |
| @Test |
| public void testStripLineTo5Chars() |
| { |
| assertEquals( "a", LdifUtils.stripLineToNChars( "a", 5 ) ); |
| assertEquals( "ab", LdifUtils.stripLineToNChars( "ab", 5 ) ); |
| assertEquals( "abc", LdifUtils.stripLineToNChars( "abc", 5 ) ); |
| assertEquals( "abcd", LdifUtils.stripLineToNChars( "abcd", 5 ) ); |
| assertEquals( "abcde", LdifUtils.stripLineToNChars( "abcde", 5 ) ); |
| assertEquals( "abcde\n f", LdifUtils.stripLineToNChars( "abcdef", 5 ) ); |
| assertEquals( "abcde\n fg", LdifUtils.stripLineToNChars( "abcdefg", 5 ) ); |
| assertEquals( "abcde\n fgh", LdifUtils.stripLineToNChars( "abcdefgh", 5 ) ); |
| assertEquals( "abcde\n fghi", LdifUtils.stripLineToNChars( "abcdefghi", 5 ) ); |
| assertEquals( "abcde\n fghi\n j", LdifUtils.stripLineToNChars( "abcdefghij", 5 ) ); |
| assertEquals( "abcde\n fghi\n jk", LdifUtils.stripLineToNChars( "abcdefghijk", 5 ) ); |
| assertEquals( "abcde\n fghi\n jkl", LdifUtils.stripLineToNChars( "abcdefghijkl", 5 ) ); |
| assertEquals( "abcde\n fghi\n jklm", LdifUtils.stripLineToNChars( "abcdefghijklm", 5 ) ); |
| assertEquals( "abcde\n fghi\n jklm\n n", LdifUtils.stripLineToNChars( "abcdefghijklmn", 5 ) ); |
| assertEquals( "abcde\n fghi\n jklm\n no", LdifUtils.stripLineToNChars( "abcdefghijklmno", 5 ) ); |
| assertEquals( "abcde\n fghi\n jklm\n nop", LdifUtils.stripLineToNChars( "abcdefghijklmnop", 5 ) ); |
| } |
| |
| |
| /** |
| * Tests that unsafe characters are encoded using UTF-8 charset. |
| * @throws LdapException |
| * |
| * @throws NamingException |
| */ |
| @Test |
| public void testConvertToLdifEncoding() throws LdapException |
| { |
| Attributes attributes = new BasicAttributes( "cn", "Saarbr\u00FCcken" ); |
| String ldif = LdifUtils.convertToLdif( attributes ); |
| assertEquals( "cn:: U2FhcmJyw7xja2Vu\n", ldif ); |
| } |
| |
| |
| /** |
| * Tests that null values are correctly encoded |
| * |
| * @throws NamingException |
| */ |
| @Test |
| public void testConvertToLdifAttrWithNullValues() throws LdapException |
| { |
| Attributes attributes = new BasicAttributes( "cn", null ); |
| String ldif = LdifUtils.convertToLdif( attributes ); |
| assertEquals( "cn:\n", ldif ); |
| } |
| |
| |
| /** |
| * Test a conversion of an entry from a LDIF file |
| */ |
| @Test |
| public void testConvertToLdif() throws LdapException |
| { |
| LdifEntry entry = new LdifEntry(); |
| entry.setDn( "cn=Saarbr\u00FCcken, dc=example, dc=com" ); |
| entry.setChangeType( ChangeType.Add ); |
| |
| entry.addAttribute( "objectClass", "top", "person", "inetorgPerson" ); |
| entry.addAttribute( "cn", "Saarbr\u00FCcken" ); |
| entry.addAttribute( "sn", "test" ); |
| |
| LdifUtils.convertToLdif( entry, 15 ); |
| } |
| |
| |
| /** |
| * Test a conversion of an attributes from a LDIF file |
| * @throws org.apache.directory.api.ldap.model.ldif.LdapLdifException |
| */ |
| @Test |
| public void testConvertAttributesfromLdif() throws LdapException, LdapLdifException |
| { |
| Attributes attributes = new BasicAttributes( true ); |
| |
| Attribute oc = new BasicAttribute( "objectclass" ); |
| oc.add( "top" ); |
| oc.add( "person" ); |
| oc.add( "inetorgPerson" ); |
| |
| attributes.put( oc ); |
| |
| attributes.put( "cn", "Saarbrucken" ); |
| attributes.put( "sn", "test" ); |
| |
| String ldif = LdifUtils.convertToLdif( attributes, ( Dn ) null, 15 ); |
| Attributes result = LdifUtils.getJndiAttributesFromLdif( ldif ); |
| assertEquals( attributes, result ); |
| } |
| |
| |
| /** |
| * Check that the correct reverse LDIF is produced for a modifyDn |
| * operation that moves and renames the entry while preserving the |
| * old rdn. |
| * |
| * @throws NamingException on error |
| */ |
| @Test |
| public void testReverseModifyDNSuperior() throws LdapException |
| { |
| Dn dn = new Dn( "cn=john doe, dc=example, dc=com" ); |
| Dn newSuperior = new Dn( "ou=system" ); |
| |
| Entry entry = new DefaultEntry( dn ); |
| entry.add( "objectClass", "person", "uidObject" ); |
| entry.add( "cn", "john doe", "jack doe" ); |
| entry.add( "sn", "doe" ); |
| entry.add( "uid", "jdoe" ); |
| |
| List<LdifEntry> reverseds = LdifRevertor.reverseMoveAndRename( entry, newSuperior, new Rdn( "cn=jack doe" ), |
| false ); |
| |
| assertNotNull( reverseds ); |
| assertEquals( 1, reverseds.size() ); |
| |
| LdifEntry reversed = reverseds.get( 0 ); |
| assertEquals( "cn=jack doe,ou=system", reversed.getDn().getName() ); |
| assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); |
| assertFalse( reversed.isDeleteOldRdn() ); |
| assertEquals( "cn=john doe", reversed.getNewRdn() ); |
| assertEquals( "dc=example, dc=com", Strings.trim( reversed.getNewSuperior() ) ); |
| assertNull( reversed.getEntry() ); |
| } |
| |
| |
| /** |
| * Test a reversed ModifyDN with a deleteOldRdn, rdn change, and a superior |
| * |
| * @throws NamingException on error |
| */ |
| @Test |
| public void testReverseModifyDNDeleteOldRdnSuperior() throws LdapException |
| { |
| Dn dn = new Dn( "cn=john doe, dc=example, dc=com" ); |
| Dn newSuperior = new Dn( "ou=system" ); |
| |
| Entry entry = new DefaultEntry( dn ); |
| entry.add( "objectClass", "person", "uidObject" ); |
| entry.add( "cn", "john doe" ); |
| entry.add( "sn", "doe" ); |
| entry.add( "uid", "jdoe" ); |
| |
| List<LdifEntry> reverseds = LdifRevertor.reverseMoveAndRename( entry, newSuperior, new Rdn( "cn=jack doe" ), |
| false ); |
| |
| assertNotNull( reverseds ); |
| assertEquals( 1, reverseds.size() ); |
| |
| LdifEntry reversed = reverseds.get( 0 ); |
| assertEquals( "cn=jack doe,ou=system", reversed.getDn().getName() ); |
| assertEquals( ChangeType.ModRdn, reversed.getChangeType() ); |
| assertTrue( reversed.isDeleteOldRdn() ); |
| assertEquals( "cn=john doe", reversed.getNewRdn() ); |
| assertEquals( "dc=example, dc=com", Strings.trim( reversed.getNewSuperior() ) ); |
| assertNull( reversed.getEntry() ); |
| } |
| |
| |
| @Test |
| public void testCreateAttributesVarargs() throws LdapException, LdapLdifException, NamingException |
| { |
| String mOid = "m-oid: 1.2.3.4"; |
| String description = "description"; |
| |
| Attributes attrs = LdifUtils.createJndiAttributes( |
| "objectClass: top", |
| "objectClass: metaTop", |
| "objectClass: metaSyntax", |
| mOid, |
| "m-description", description ); |
| |
| assertEquals( "top", attrs.get( "objectClass" ).get( 0 ) ); |
| assertEquals( "metaTop", attrs.get( "objectClass" ).get( 1 ) ); |
| assertEquals( "metaSyntax", attrs.get( "objectClass" ).get( 2 ) ); |
| assertEquals( "1.2.3.4", attrs.get( "m-oid" ).get() ); |
| assertEquals( "description", attrs.get( "m-description" ).get() ); |
| |
| try |
| { |
| LdifUtils.createJndiAttributes( |
| "objectClass", "top", |
| "objectClass" ); |
| fail(); |
| } |
| catch ( LdapInvalidAttributeValueException iave ) |
| { |
| assertTrue( true ); |
| } |
| } |
| |
| |
| @Test |
| public void testConvertEntryNoControls() throws Exception |
| { |
| LdifReader reader = new LdifReader(); |
| |
| String expected = |
| "dn: ou=test\n" + |
| "ObjectClass: top\n" + |
| "ObjectClass: metaTop\n" + |
| "ObjectClass: metaSyntax\n" + |
| "m-oid: 1.2.3.4\n" + |
| "m-description: description\n\n"; |
| |
| List<LdifEntry> entries = reader.parseLdif( expected ); |
| LdifEntry expectedEntry = entries.get( 0 ); |
| |
| LdifEntry entry = new LdifEntry(); |
| |
| entry.setDn( "ou=test" ); |
| entry.addAttribute( "ObjectClass", "top", "metaTop", "metaSyntax" ); |
| entry.addAttribute( "m-oid", "1.2.3.4" ); |
| entry.addAttribute( "m-description", "description" ); |
| |
| String converted = LdifUtils.convertToLdif( entry ); |
| |
| assertNotNull( converted ); |
| |
| entries = reader.parseLdif( converted ); |
| LdifEntry convertedEntry = entries.get( 0 ); |
| |
| assertEquals( expectedEntry, convertedEntry ); |
| |
| reader.close(); |
| } |
| |
| |
| @Test |
| public void testConvertEntryOneControl() throws Exception |
| { |
| LdifReader reader = new LdifReader(); |
| |
| String expected = |
| "dn: ou=test\n" + |
| "control: 2.16.840.1.113730.3.4.2 false\n" + |
| "changetype: add\n" + |
| "ObjectClass: top\n" + |
| "ObjectClass: metaTop\n" + |
| "ObjectClass: metaSyntax\n" + |
| "m-oid: 1.2.3.4\n" + |
| "m-description: description\n\n"; |
| |
| List<LdifEntry> entries = reader.parseLdif( expected ); |
| LdifEntry expectedEntry = entries.get( 0 ); |
| |
| LdifEntry entry = new LdifEntry(); |
| |
| entry.setDn( "ou=test" ); |
| entry.addAttribute( "ObjectClass", "top", "metaTop", "metaSyntax" ); |
| entry.addAttribute( "m-oid", "1.2.3.4" ); |
| entry.addAttribute( "m-description", "description" ); |
| |
| ManageDsaITImpl control = new ManageDsaITImpl(); |
| |
| entry.addControl( control ); |
| |
| String converted = LdifUtils.convertToLdif( entry ); |
| |
| assertNotNull( converted ); |
| |
| entries = reader.parseLdif( converted ); |
| LdifEntry convertedEntry = entries.get( 0 ); |
| |
| assertEquals( expectedEntry, convertedEntry ); |
| reader.close(); |
| } |
| } |
