/*
|
* 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 2008 Sun Microsystems, Inc.
|
* Portions Copyright 2014-2016 ForgeRock AS.
|
*/
|
package org.opends.server.protocols;
|
|
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileReader;
|
|
import org.testng.annotations.BeforeClass;
|
import org.testng.annotations.Test;
|
|
import org.opends.server.DirectoryServerTestCase;
|
import org.opends.server.TestCaseUtils;
|
import org.opends.server.api.ConnectionHandler;
|
import org.opends.server.core.CoreConfigManager;
|
import org.opends.server.core.DirectoryServer;
|
|
import static org.testng.Assert.*;
|
|
|
|
/**
|
* This class defines a set of tests for the
|
* org.opends.server.protocols.LDIFConnectionHandler class.
|
*/
|
public class LDIFConnectionHandlerTestCase
|
extends DirectoryServerTestCase
|
{
|
/**
|
* Ensures that the server is running.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@BeforeClass
|
public void startServer()
|
throws Exception
|
{
|
TestCaseUtils.startServer();
|
}
|
|
|
|
/**
|
* Tests the ability of the LDIF connection handler to process a valid LDIF
|
* file containing user data.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test(groups = "slow")
|
public void testValidUserLDIF()
|
throws Exception
|
{
|
TestCaseUtils.initializeTestBackend(false);
|
|
File tempDir = TestCaseUtils.createTemporaryDirectory("testValidUserLDIF");
|
|
TestCaseUtils.dsconfig(
|
"set-connection-handler-prop",
|
"--handler-name", "LDIF Connection Handler",
|
"--set", "ldif-directory:" + tempDir.getAbsolutePath(),
|
"--set", "enabled:true");
|
|
try
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: o=test",
|
"changetype: add",
|
"objectClass: top",
|
"objectClass: organization",
|
"o: test",
|
"",
|
"dn: cn=test,o=test",
|
"changetype: add",
|
"objectClass: top",
|
"objectClass: device",
|
"objectClass: extensibleObject",
|
"cn: test",
|
"",
|
"dn: cn=test,o=test",
|
"changetype: modify",
|
"replace: description",
|
"description: foo",
|
"-",
|
"add: givenName",
|
"givenName: bar",
|
"",
|
"dn: cn=test,o=test",
|
"changetype: moddn",
|
"newrdn: uid=test",
|
"deleteoldrdn: 0",
|
"",
|
"dn: uid=test,o=test",
|
"changetype: delete");
|
|
File tempFile = new File(path);
|
File newFile = new File(tempDir, "testValidUser.ldif");
|
assertTrue(tempFile.renameTo(newFile));
|
|
boolean found = false;
|
long stopTime = System.currentTimeMillis() + 10000L;
|
while (System.currentTimeMillis() < stopTime)
|
{
|
if (! newFile.exists())
|
{
|
// The file should have been processed. Make sure that there is
|
// a new file with the appropriate prefix.
|
for (File f : tempDir.listFiles())
|
{
|
found = f.getName().startsWith("testValidUser.ldif.applied.");
|
if (! found)
|
{
|
System.err.println("Contents of file " + f.getName() + ":");
|
BufferedReader reader = new BufferedReader(new FileReader(f));
|
while (true)
|
{
|
String line = reader.readLine();
|
if (line == null)
|
{
|
break;
|
}
|
|
System.err.println(line);
|
}
|
|
throw new AssertionError("Found unexpected file " + f.getName() +
|
" instead of testValidUser.ldif.applied.*");
|
}
|
}
|
|
break;
|
}
|
|
Thread.sleep(10);
|
}
|
|
assertTrue(found);
|
}
|
finally
|
{
|
TestCaseUtils.deleteDirectory(tempDir);
|
}
|
}
|
|
|
|
/**
|
* Tests the ability of the LDIF connection handler to process a valid LDIF
|
* file containing configuration changes
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test(groups = "slow")
|
public void testValidConfigLDIF()
|
throws Exception
|
{
|
CoreConfigManager coreConfigManager = TestCaseUtils.getServerContext().getCoreConfigManager();
|
assertEquals(coreConfigManager.getSizeLimit(), 1000);
|
TestCaseUtils.initializeTestBackend(false);
|
|
File tempDir =
|
TestCaseUtils.createTemporaryDirectory("testValidConfigLDIF");
|
|
TestCaseUtils.dsconfig(
|
"set-connection-handler-prop",
|
"--handler-name", "LDIF Connection Handler",
|
"--set", "ldif-directory:" + tempDir.getAbsolutePath(),
|
"--set", "enabled:true");
|
|
try
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=config",
|
"changetype: modify",
|
"replace: ds-cfg-size-limit",
|
"ds-cfg-size-limit: 100");
|
|
File tempFile = new File(path);
|
File newFile = new File(tempDir, "testValidConfig.ldif");
|
assertTrue(tempFile.renameTo(newFile));
|
|
boolean found = false;
|
long stopTime = System.currentTimeMillis() + 10000L;
|
while (System.currentTimeMillis() < stopTime)
|
{
|
if (! newFile.exists())
|
{
|
// The file should have been processed. Make sure that there is
|
// a new file with the appropriate prefix.
|
for (File f : tempDir.listFiles())
|
{
|
found = f.getName().startsWith("testValidConfig.ldif.applied.");
|
if (! found)
|
{
|
System.err.println("Contents of file " + f.getName() + ":");
|
BufferedReader reader = new BufferedReader(new FileReader(f));
|
while (true)
|
{
|
String line = reader.readLine();
|
if (line == null)
|
{
|
break;
|
}
|
|
System.err.println(line);
|
}
|
|
throw new AssertionError("Found unexpected file " + f.getName() +
|
" instead of testValidConfig.ldif.applied.*");
|
}
|
}
|
|
break;
|
}
|
|
Thread.sleep(10);
|
}
|
|
assertTrue(found);
|
assertEquals(coreConfigManager.getSizeLimit(), 100);
|
}
|
finally
|
{
|
TestCaseUtils.deleteDirectory(tempDir);
|
|
TestCaseUtils.dsconfig(
|
"set-global-configuration-prop",
|
"--set", "size-limit:1000");
|
assertEquals(coreConfigManager.getSizeLimit(), 1000);
|
}
|
}
|
|
|
|
/**
|
* Tests the ability of the LDIF connection handler to properly deal with an
|
* unparseable LDIF file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test(groups = "slow")
|
public void testUnparseableLDIF()
|
throws Exception
|
{
|
TestCaseUtils.initializeTestBackend(false);
|
|
File tempDir = TestCaseUtils.createTemporaryDirectory("testValidUserLDIF");
|
|
TestCaseUtils.dsconfig(
|
"set-connection-handler-prop",
|
"--handler-name", "LDIF Connection Handler",
|
"--set", "ldif-directory:" + tempDir.getAbsolutePath(),
|
"--set", "enabled:true");
|
|
try
|
{
|
String path = TestCaseUtils.createTempFile(
|
"unparseable");
|
|
File tempFile = new File(path);
|
File newFile = new File(tempDir, "testUnparseable.ldif");
|
assertTrue(tempFile.renameTo(newFile));
|
|
boolean appliedFound = false;
|
boolean errorsFound = false;
|
|
long stopTime = System.currentTimeMillis() + 10000L;
|
while (System.currentTimeMillis() < stopTime)
|
{
|
if (! newFile.exists())
|
{
|
// The file should have been processed. Make sure that there is an
|
// applied file, and that there is an errors file.
|
for (File f : tempDir.listFiles())
|
{
|
if (f.getName().startsWith("testUnparseable.ldif.applied."))
|
{
|
appliedFound = true;
|
}
|
else if (f.getName().startsWith(
|
"testUnparseable.ldif.errors-encountered."))
|
{
|
errorsFound = true;
|
}
|
else
|
{
|
System.err.println("Contents of file " + f.getName() + ":");
|
BufferedReader reader = new BufferedReader(new FileReader(f));
|
while (true)
|
{
|
String line = reader.readLine();
|
if (line == null)
|
{
|
break;
|
}
|
|
System.err.println(line);
|
}
|
|
throw new AssertionError("Found unexpected file " + f.getName());
|
}
|
}
|
|
break;
|
}
|
|
Thread.sleep(10);
|
}
|
|
assertFalse(newFile.exists());
|
assertTrue(appliedFound);
|
assertTrue(errorsFound);
|
}
|
finally
|
{
|
TestCaseUtils.deleteDirectory(tempDir);
|
}
|
}
|
|
|
|
/**
|
* Tests a number of methods that are part of the generic connection handler
|
* API.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test
|
public void testGenericConnectionHandlerMethods()
|
throws Exception
|
{
|
TestCaseUtils.dsconfig(
|
"set-connection-handler-prop",
|
"--handler-name", "LDIF Connection Handler",
|
"--set", "enabled:true");
|
|
// Get the connection handler from the server.
|
LDIFConnectionHandler connHandler = null;
|
for (ConnectionHandler handler : DirectoryServer.getConnectionHandlers())
|
{
|
if (handler instanceof LDIFConnectionHandler)
|
{
|
assertNull(connHandler);
|
connHandler = (LDIFConnectionHandler) handler;
|
}
|
}
|
assertNotNull(connHandler);
|
|
|
// Generic connection handler methods.
|
assertNotNull(connHandler.getConnectionHandlerName());
|
assertNotNull(connHandler.getProtocol());
|
assertNotNull(connHandler.toString());
|
|
assertNotNull(connHandler.getListeners());
|
assertTrue(connHandler.getListeners().isEmpty());
|
|
assertNotNull(connHandler.getClientConnections());
|
assertTrue(connHandler.getClientConnections().isEmpty());
|
|
|
// Alert handler methods.
|
assertNotNull(connHandler.getComponentEntryDN());
|
|
assertNotNull(connHandler.getClassName());
|
assertEquals(connHandler.getClassName(), connHandler.getClass().getName());
|
|
assertNotNull(connHandler.getAlerts());
|
assertFalse(connHandler.getAlerts().isEmpty());
|
}
|
}
|
