/* * The contents of this file are subject to the terms of the Common Development and * Distribution License (the License). You may not use this file except in compliance with the * License. * * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the * specific language governing permission and limitations under the License. * * When distributing Covered Software, include this CDDL Header Notice in each file and include * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL * Header, with the fields enclosed by brackets [] replaced by your own identifying * information: "Portions Copyright [year] [name of copyright owner]". * * Copyright 2006-2008 Sun Microsystems, Inc. * Portions Copyright 2013-2016 ForgeRock AS. */ package org.opends.server.tools; import static org.opends.server.TestCaseUtils.*; import static org.opends.server.util.CollectionUtils.*; import static org.testng.Assert.*; import java.io.File; import java.io.FileOutputStream; import java.io.PrintStream; import java.util.ArrayList; import java.util.List; import org.forgerock.opendj.ldap.DN; import org.forgerock.opendj.server.config.server.RootCfg; import org.opends.server.TestCaseUtils; import org.opends.server.core.DirectoryServer; import org.opends.server.tasks.TaskUtils; import org.opends.server.types.Attribute; import org.opends.server.types.Attributes; import org.opends.server.types.Entry; import org.testng.annotations.AfterClass; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; @SuppressWarnings("javadoc") public class ImportLDIFTestCase extends ToolsTestCase { private File tempDir; private String ldifFilePath; private String configFilePath; private String homeDirName; private String beID; private String baseDN = "dc=example,dc=com"; /** * Ensures that the ldif file is created with the entry. */ @BeforeClass public void setUp() throws Exception { TestCaseUtils.restartServer(); beID = "userRoot"; configFilePath = DirectoryServer.getConfigFile(); TaskUtils.disableBackend(beID); String entry = "dn: dc=example,dc=com\n" + "objectclass: domain\n" + "objectclass: top\n" + "dc: example\n" + "\n" + "dn: uid=user.0,dc=example,dc=com\n" + "objectClass: person\n" + "objectClass: inetorgperson\n" + "objectClass: organizationalPerson\n" + "objectClass: top\n" + "givenName: Aaccf\n" + "sn: Amar\n" + "cn: Aaccf Amar\n" + "employeeNumber: 0\n" + "uid: user.0\n" + "mail: user.0@example.com\n" + "userPassword: password\n" + "telephoneNumber: +1 380-535-2354\n" + "description: This is the description for Aaccf Amar\n" + "creatorsName: cn=Import\n" + "modifiersName: cn=Import\n"; tempDir = TestCaseUtils.createTemporaryDirectory("importLDIFtest"); homeDirName = tempDir.getAbsolutePath(); ldifFilePath = homeDirName + File.separator + "entries.ldif"; FileOutputStream ldifFile = new FileOutputStream(ldifFilePath); PrintStream writer = new PrintStream(ldifFile); writer.println(entry); writer.close(); ldifFile.close(); } /** * Tests an import of LDIF with only the operational attributes * included. */ @Test public void testImportIncludeOnlyOperational() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", configFilePath, "--noPropertiesFile", "-l", ldifFilePath, "-F", "-R", rejectFilePath, "-n", beID, "-i", "+" }; assertEquals(importLDIF(args), 0); // Expecting a non-empty reject file. assertRejectedFile(reject, false); } /** * Tests an import of LDIF with only the user attributes included. */ @Test public void testImportIncludeOnlyUser() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", configFilePath, "--noPropertiesFile", "-l", ldifFilePath, "-F", "-R", rejectFilePath, "-n", beID, "-i", "*" }; assertEquals(importLDIF(args), 0); // Expecting an empty reject file. assertRejectedFile(reject, true); // operational attributes shouldn't be present. assertEntry(false, Attributes.create("creatorsname", "cn=Import"), Attributes.create("modifiersname", "cn=Import")); } /** * Tests a simple Import LDIF with none of the attributes excluded * or included. It is expected to import the entry(ies) with all the * attributes in the ldif file. */ @Test public void testImportDefault() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-n", beID, "-R", rejectFilePath }; assertEquals(importLDIF(args), 0); // Reject file should be empty. assertRejectedFile(reject, true); // check the presence of some random attributes. assertEntry(true, Attributes.create("description", "This is the description for Aaccf Amar"), Attributes.create("mail", "user.0@example.com"), Attributes.create("creatorsname", "cn=Import"), Attributes.create("modifiersname", "cn=Import")); } /** * Tests a simple Import LDIF using base DN with none of the * attributes excluded or included. It is expected to import the * entry(ies) with all the attributes in the ldif file. */ @Test public void testImportDefaultBaseDN() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-b", baseDN, "-R", rejectFilePath }; assertEquals(importLDIF(args), 0); // Reject file should be empty. assertRejectedFile(reject, true); // check the presence of some random attributes. assertEntry(true, Attributes.create("description", "This is the description for Aaccf Amar"), Attributes.create("mail", "user.0@example.com"), Attributes.create("creatorsname", "cn=Import"), Attributes.create("modifiersname", "cn=Import")); } /** * Tests an import of LDIF with all the user attributes included but * "description". */ @Test public void testImportLDIFIncludeUserExcludeDescription() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-n", beID, "-R", rejectFilePath, "-i", "*", "-e", "description" }; assertEquals(importLDIF(args), 0); assertRejectedFile(reject, true); assertEntry(false, Attributes.create("description", "This is the description for Aaccf Amar")); } /** * Tests an import of LDIF with all user attributes excluded option. */ @Test public void testImportLDIFExcludeUser() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-n", beID, "-R", rejectFilePath, "-e", "*" }; assertEquals(importLDIF(args), 0); assertRejectedFile(reject, false); } /** * Tests an import of LDIF with all the operational attributes * excluded option. */ @Test public void testImportLDIFExcludeOperational() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-n", beID, "-R", rejectFilePath, "-e", "+" }; assertEquals(importLDIF(args), 0); assertRejectedFile(reject, true); assertEntry(false, Attributes.create("creatorsname", "cn=Import"), Attributes.create("modifiersname", "cn=Import")); } /** * Tests an import of LDIF with all user attributes and one * operational attribute included.. */ @Test public void testImportLDIFUserAndOperational() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-n", beID, "-R", rejectFilePath, "-i", "*", "-i", "creatorsname" }; assertEquals(importLDIF(args), 0); assertRejectedFile(reject, true); assertEntry(true, Attributes.create("creatorsname", "cn=Import")); } /** * Tests an import of LDIF with select user and operational * attributes included.. */ @Test public void testImportLDIFSelectiveIncludeAttributes() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-n", beID, "-R", rejectFilePath, "-i", "cn", "-i", "uid", "-i", "dc", "-i", "sn", "-i", "creatorsname" }; assertEquals(importLDIF(args), 0); assertRejectedFile(reject, true); assertEntry(true, Attributes.create("creatorsname", "cn=Import")); assertEntry(false, Attributes.create("givenname", "Aaccf"), Attributes.create("employeenumber", "0")); } /** * Tests an import of LDIF with select user and operational attributes * included. */ @Test public void testImportLDIFSelectiveExcludeAttributes() throws Exception { File reject = File.createTempFile("reject", ".ldif"); String rejectFilePath = reject.getAbsolutePath(); String[] args = { "-f", DirectoryServer.getConfigFile(), "--noPropertiesFile", "-l", ldifFilePath, "-F", "-n", beID, "-R", rejectFilePath, "-e", "givenName", "-e", "creatorsname" }; assertEquals(importLDIF(args), 0); assertRejectedFile(reject, true); assertEntry(true, Attributes.create("modifiersname", "cn=Import"), Attributes.create("employeenumber", "0")); assertEntry(false, Attributes.create("creatorsname", "cn=Import"), Attributes.create("givenname", "Aaccf")); } private int importLDIF(String[] args) { return ImportLDIF.mainImportLDIF(args, false, System.out, System.err); } /** * Utility method which is called by the testcase for asserting the rejected * file. * * @param reject * The file to be asserted * @param shouldBeEmpty * whether the file should be empty. */ private void assertRejectedFile(File reject, boolean shouldBeEmpty) throws Exception { try { final RootCfg root = DirectoryServer.getInstance().getServerContext().getRootConfig(); final String errorMsg = "Unexpected content in reject file:\n\n" + readFile(reject) + "\n\nThe backend was configured with the following base DNs: " + root.getBackend(beID).getBaseDN() + "\n\n"; assertEquals(reject.length() == 0, shouldBeEmpty, errorMsg); } finally { reject.delete(); } } /** * Utility method which is called by the testcase for asserting the imported * entry. * @param attrsShouldExistInEntry * the boolean flag for assert type. * @param attrs * The array of attributes to be asserted. */ private void assertEntry(boolean attrsShouldExistInEntry, Attribute... attrs) throws Exception { if (attrs != null && attrs.length > 0) { TaskUtils.enableBackend(beID); Entry entry = DirectoryServer.getEntry( DN.valueOf(" uid=user.0,dc=example,dc=com")); TaskUtils.disableBackend(beID); assertNotNull(entry); for (Attribute a : attrs) { final List attributes = collect(entry.getAllAttributes(), new ArrayList()); assertEquals(attributes.contains(a), attrsShouldExistInEntry); } } } /** Clean up method. */ @AfterClass public void cleanUp() throws Exception { // reinstate the backend. TaskUtils.enableBackend(beID); TestCaseUtils.deleteDirectory(tempDir); } }