/*
|
* 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
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE
|
* or https://OpenDS.dev.java.net/OpenDS.LICENSE.
|
* 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
|
* trunk/opends/resource/legal-notices/OpenDS.LICENSE. 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 2006-2010 Sun Microsystems, Inc.
|
* Portions Copyright 2013 ForgeRock AS.
|
*/
|
package org.opends.server.backends;
|
|
|
|
import java.io.File;
|
import java.util.LinkedHashMap;
|
|
import org.testng.annotations.BeforeClass;
|
import org.testng.annotations.Test;
|
|
import org.opends.server.TestCaseUtils;
|
import org.opends.server.config.ConfigException;
|
import org.opends.server.core.AddOperationBasis;
|
import org.opends.server.core.DeleteOperationBasis;
|
import org.opends.server.core.DirectoryServer;
|
import org.opends.server.core.ModifyDNOperationBasis;
|
import org.opends.server.core.SchemaConfigManager;
|
import org.opends.server.protocols.internal.InternalClientConnection;
|
import org.opends.server.protocols.internal.InternalSearchOperation;
|
import org.opends.server.tools.LDAPModify;
|
import org.opends.server.types.AttributeType;
|
import org.opends.server.types.AttributeValue;
|
import org.opends.server.types.DirectoryException;
|
import org.opends.server.types.DITContentRule;
|
import org.opends.server.types.DN;
|
import org.opends.server.types.Entry;
|
import org.opends.server.types.ExistingFileBehavior;
|
import org.opends.server.types.InitializationException;
|
import org.opends.server.types.LDIFExportConfig;
|
import org.opends.server.types.LDIFImportConfig;
|
import org.opends.server.types.MatchingRuleUse;
|
import org.opends.server.types.ObjectClass;
|
import org.opends.server.types.ResultCode;
|
import org.opends.server.types.SearchFilter;
|
import org.opends.server.types.SearchScope;
|
|
import static org.testng.Assert.*;
|
|
import static org.opends.server.util.StaticUtils.*;
|
|
|
|
/**
|
* A set of test cases for the schema backend.
|
*/
|
public class SchemaBackendTestCase
|
extends BackendTestCase
|
{
|
// A reference to the schema backend.
|
private SchemaBackend schemaBackend;
|
|
|
/**
|
* Ensures that the Directory Server is running and gets a reference to the
|
* schema backend.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@BeforeClass()
|
public void startServer()
|
throws Exception
|
{
|
TestCaseUtils.startServer();
|
|
schemaBackend = (SchemaBackend) DirectoryServer.getBackend("schema");
|
assertNotNull(schemaBackend);
|
}
|
|
|
|
/**
|
* Tests the {@code initializeBackend} method by providing a null
|
* configuration entry.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test(expectedExceptions = { ConfigException.class,
|
InitializationException.class })
|
public void testInitializeWithNullEntry()
|
throws Exception
|
{
|
SchemaBackend schemaBackend = new SchemaBackend();
|
schemaBackend.configureBackend(null);
|
}
|
|
|
|
/**
|
* Tests the {@code isLocal} method to ensure that it is considered local.
|
*/
|
@Test()
|
public void testIsLocal()
|
{
|
assertTrue(schemaBackend.isLocal());
|
}
|
|
|
|
/**
|
* Tests the {@code getEntry} method to ensure that it is able to retrieve
|
* the schema entry if it is given a valid entry DN.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testGetValidEntry()
|
throws Exception
|
{
|
DN schemaDN = DN.decode("cn=schema");
|
Entry schemaEntry = schemaBackend.getEntry(schemaDN);
|
assertNotNull(schemaEntry);
|
assertEquals(schemaEntry.getDN(), schemaDN);
|
|
AttributeType t = DirectoryServer.getAttributeType("attributetypes");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("objectclasses");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("ldapsyntaxes");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("matchingrules");
|
assertTrue(schemaEntry.hasAttribute(t));
|
}
|
|
|
|
/**
|
* Tests the {@code getEntry} method to ensure that it is not able to retrieve
|
* anything when given an inappropriate DN.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testGetInvalidEntry()
|
throws Exception
|
{
|
DN schemaDN = DN.decode("cn=notschema");
|
Entry schemaEntry = schemaBackend.getEntry(schemaDN);
|
assertNull(schemaEntry);
|
|
schemaDN = DN.decode("cn=child,cn=schema");
|
schemaEntry = schemaBackend.getEntry(schemaDN);
|
assertNull(schemaEntry);
|
}
|
|
|
|
/**
|
* Tests the {@code getSchemaEntry} method to ensure that it is able to
|
* retrieve the appropriate information with different DNs.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testGetSchemaEntry()
|
throws Exception
|
{
|
DN schemaDN = DN.decode("cn=schema");
|
Entry schemaEntry = schemaBackend.getSchemaEntry(schemaDN, false);
|
assertNotNull(schemaEntry);
|
assertEquals(schemaEntry.getDN(), schemaDN);
|
|
AttributeType t = DirectoryServer.getAttributeType("attributetypes");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("objectclasses");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("ldapsyntaxes");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("matchingrules");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
|
schemaDN = DN.decode("cn=subschema");
|
schemaEntry = schemaBackend.getSchemaEntry(schemaDN, false);
|
assertNotNull(schemaEntry);
|
assertEquals(schemaEntry.getDN(), schemaDN);
|
|
t = DirectoryServer.getAttributeType("attributetypes");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("objectclasses");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("ldapsyntaxes");
|
assertTrue(schemaEntry.hasAttribute(t));
|
|
t = DirectoryServer.getAttributeType("matchingrules");
|
assertTrue(schemaEntry.hasAttribute(t));
|
}
|
|
|
|
/**
|
* Tests the {@code entryExists} method with a valid schema DN.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testEntryExistsValidDN()
|
throws Exception
|
{
|
DN schemaDN = DN.decode("cn=schema");
|
assertTrue(schemaBackend.entryExists(schemaDN));
|
}
|
|
|
|
/**
|
* Tests the {@code entryExists} method with an invalid schema DN.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testEntryExistsInvalidDN()
|
throws Exception
|
{
|
DN schemaDN = DN.decode("cn=notschema");
|
assertFalse(schemaBackend.entryExists(schemaDN));
|
}
|
|
|
|
/**
|
* Tests to ensure that the {@code addEntry} method always throws an
|
* exception.
|
*/
|
@Test(expectedExceptions = { DirectoryException.class })
|
public void testAddEntry()
|
throws Exception
|
{
|
Entry entry = createEntry(DN.decode("cn=schema"));
|
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
AddOperationBasis addOperation =
|
new AddOperationBasis(conn, InternalClientConnection.nextOperationID(), InternalClientConnection.nextMessageID(),
|
null, entry.getDN(), entry.getObjectClasses(),
|
entry.getUserAttributes(),
|
entry.getOperationalAttributes());
|
|
schemaBackend.addEntry(entry, addOperation);
|
}
|
|
|
|
/**
|
* Tests to ensure that the {@code deleteEntry} method always throws an
|
* exception.
|
*/
|
@Test(expectedExceptions = { DirectoryException.class })
|
public void testDeleteEntry()
|
throws Exception
|
{
|
DN schemaDN = DN.decode("cn=schema");
|
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
DeleteOperationBasis deleteOperation =
|
new DeleteOperationBasis(conn, InternalClientConnection.nextOperationID(), InternalClientConnection.nextMessageID(),
|
null, schemaDN);
|
|
schemaBackend.deleteEntry(schemaDN, deleteOperation);
|
}
|
|
|
|
/**
|
* Tests to ensure that the {@code renameEntry} method always throws an
|
* exception.
|
*/
|
@Test(expectedExceptions = { DirectoryException.class })
|
public void testRenameEntry()
|
throws Exception
|
{
|
DN currentSchemaDN = DN.decode("cn=schema");
|
DN newSchemaDN = DN.decode("cn=newschema");
|
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
ModifyDNOperationBasis modifyDNOperation =
|
new ModifyDNOperationBasis(conn, InternalClientConnection.nextOperationID(),
|
InternalClientConnection.nextMessageID(), null,
|
currentSchemaDN, newSchemaDN.getRDN(),
|
true, null);
|
|
schemaBackend.renameEntry(currentSchemaDN,
|
schemaBackend.getSchemaEntry(newSchemaDN, false),
|
modifyDNOperation);
|
}
|
|
|
|
/**
|
* Performs a simple base-level search to verify that the schema entry is
|
* returned.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testSimpleBaseSearch()
|
throws Exception
|
{
|
String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))";
|
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
InternalSearchOperation searchOperation =
|
conn.processSearch(DN.decode("cn=schema"), SearchScope.BASE_OBJECT,
|
SearchFilter.createFilterFromString(filterString));
|
assertNotNull(searchOperation);
|
assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS);
|
assertFalse(searchOperation.getSearchEntries().isEmpty());
|
}
|
|
|
|
/**
|
* Performs a simple single-level search to verify that nothing is returned.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testSimpleOneLevelSearch()
|
throws Exception
|
{
|
String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))";
|
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
InternalSearchOperation searchOperation =
|
conn.processSearch(DN.decode("cn=schema"), SearchScope.SINGLE_LEVEL,
|
SearchFilter.createFilterFromString(filterString));
|
assertNotNull(searchOperation);
|
assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS);
|
assertTrue(searchOperation.getSearchEntries().isEmpty());
|
}
|
|
|
|
/**
|
* Performs a simple subtree search to verify that the schema entry is
|
* returned.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testSimpleSubtreeSearch()
|
throws Exception
|
{
|
String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))";
|
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
InternalSearchOperation searchOperation =
|
conn.processSearch(DN.decode("cn=schema"), SearchScope.WHOLE_SUBTREE,
|
SearchFilter.createFilterFromString(filterString));
|
assertNotNull(searchOperation);
|
assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS);
|
assertFalse(searchOperation.getSearchEntries().isEmpty());
|
}
|
|
|
|
/**
|
* Performs a simple subordinate subtree search to verify that nothing is
|
* returned.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testSimpleSubordinateSubtreeSearch()
|
throws Exception
|
{
|
String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))";
|
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
InternalSearchOperation searchOperation =
|
conn.processSearch(DN.decode("cn=schema"),
|
SearchScope.SUBORDINATE_SUBTREE,
|
SearchFilter.createFilterFromString(filterString));
|
assertNotNull(searchOperation);
|
assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS);
|
assertTrue(searchOperation.getSearchEntries().isEmpty());
|
}
|
|
|
|
/**
|
* Performs a set of searches in the schema backend to ensure that they
|
* correctly set the matched DN in the response.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testSearchMatchedDN()
|
throws Exception
|
{
|
InternalClientConnection conn =
|
InternalClientConnection.getRootConnection();
|
DN baseDN = DN.decode("o=bogus,cn=schema");
|
SearchFilter filter =
|
SearchFilter.createFilterFromString("(objectClass=*)");
|
|
for (SearchScope scope : SearchScope.values())
|
{
|
InternalSearchOperation searchOperation =
|
conn.processSearch(baseDN, scope, filter);
|
assertNotNull(searchOperation.getMatchedDN(),
|
"No matched DN for scope " + scope);
|
}
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend with regard to the
|
* ds-cfg-show-all-attributes configuration.
|
*
|
* @throws Exception If a problem occurs.
|
*/
|
@Test()
|
public void testTreatAsUserAttrs()
|
throws Exception
|
{
|
DN schemaDN = DN.decode("cn=schema");
|
AttributeType a = DirectoryServer.getAttributeType("attributetypes");
|
AttributeType o = DirectoryServer.getAttributeType("objectclasses");
|
AttributeType m = DirectoryServer.getAttributeType("matchingrules");
|
AttributeType s = DirectoryServer.getAttributeType("ldapsyntaxes");
|
|
assertFalse(schemaBackend.showAllAttributes());
|
Entry schemaEntry = schemaBackend.getSchemaEntry(schemaDN, false);
|
assertTrue(schemaEntry.hasOperationalAttribute(a));
|
assertTrue(schemaEntry.hasOperationalAttribute(o));
|
assertTrue(schemaEntry.hasOperationalAttribute(m));
|
assertTrue(schemaEntry.hasOperationalAttribute(s));
|
|
schemaBackend.setShowAllAttributes(true);
|
assertTrue(schemaBackend.showAllAttributes());
|
schemaEntry = schemaBackend.getSchemaEntry(schemaDN, false);
|
assertFalse(schemaEntry.hasOperationalAttribute(a));
|
assertFalse(schemaEntry.hasOperationalAttribute(o));
|
assertFalse(schemaEntry.hasOperationalAttribute(m));
|
assertTrue(schemaEntry.hasOperationalAttribute(s));
|
|
schemaBackend.setShowAllAttributes(false);
|
assertFalse(schemaBackend.showAllAttributes());
|
schemaEntry = schemaBackend.getSchemaEntry(schemaDN, false);
|
assertTrue(schemaEntry.hasOperationalAttribute(a));
|
assertTrue(schemaEntry.hasOperationalAttribute(o));
|
assertTrue(schemaEntry.hasOperationalAttribute(m));
|
assertTrue(schemaEntry.hasOperationalAttribute(s));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type that is not allowed to be altered.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddUnsupportedAttr()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClass",
|
"objectClass: extensibleObject");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is not allowed to be altered.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveUnsupportedAttr()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClass",
|
"objectClass: subschema",
|
"-",
|
"add: objectClass",
|
"objectClass: extensibleObject");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove all
|
* attribute type definitions.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAllAttributeTypes()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to replace all
|
* attribute types.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testReplaceAllAttributeTypes()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"replace: attributeTypes");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with a valid syntax and that isn't already defined.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( 1.3.6.1.4.1.26027.1.999.4 " +
|
"NAME 'testAddAttributeTypeSuccessful' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testaddattributetypesuccessful";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with a valid syntax (but using a textual OID rather than
|
* numeric) and that isn't already defined.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeSuccessfulNoOID()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddattributetypesuccessfulnooid-oid " +
|
"NAME 'testAddAttributeTypeSuccessfulNoOID' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testaddattributetypesuccessfulnooid";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with a valid syntax (but using a textual OID rather than
|
* numeric) and that has no space before last parenthesis.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeType()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddattributetypenospacebeforepathenthesis-oid " +
|
"NAME 'testAddAttributeTypeNoSpaceBeforeParenthesis' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"SINGLE-VALUE)");
|
|
String attrName = "testaddattributetypenospacebeforeparenthesis";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type to a specific schema file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test
|
public void testAddAttributeTypeToAltSchemaFile()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddattributetypetoaltschemafile-oid " +
|
"NAME 'testAddAttributeTypeToAltSchemaFile' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' " +
|
"X-SCHEMA-FILE '98-schema-test-attrtype.ldif' )");
|
|
String attrName = "testaddattributetypetoaltschemafile";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(),
|
"98-schema-test-attrtype.ldif");
|
assertFalse(schemaFile.exists());
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
assertTrue(schemaFile.exists());
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type in a manner that replaces an existing definition.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeSuccessfulReplace()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddattributetypesuccessfulreplace-oid " +
|
"NAME 'testAddAttributeTypeSuccessfulReplace' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddattributetypesuccessfulreplace-oid " +
|
"NAME 'testAddAttributeTypeSuccessfulReplace' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testaddattributetypesuccessfulreplace";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to replace an
|
* attribute type definition in a custom schema file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test
|
public void testReplaceAttributeTypeInAltSchemaFile()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testreplaceattributetypeinaltschemafile-oid " +
|
"NAME 'testReplaceAttributeTypeInAltSchemaFile' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' " +
|
"X-SCHEMA-FILE '98-schema-test-replaceattrtype.ldif' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testreplaceattributetypeinaltschemafile-oid " +
|
"NAME 'testReplaceAttributeTypeInAltSchemaFile' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testreplaceattributetypeinaltschemafile";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(),
|
"98-schema-test-replaceattrtype.ldif");
|
assertFalse(schemaFile.exists());
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
assertTrue(schemaFile.exists());
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type definition that can't be parsed.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeInvalidSyntax()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: invalidsyntax");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with an undefined syntax.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeUndefinedSyntax()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatundefinedsyntax-oid " +
|
"NAME 'testAddATUndefinedSyntax' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.99999 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with an undefined equality matching rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeUndefinedEMR()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatundefinedemr-oid " +
|
"NAME 'testAddATUndefinedEMR' EQUALITY xxxundefinedxxx " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with an undefined ordering matching rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeUndefinedOMR()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatundefinedomr-oid " +
|
"NAME 'testAddATUndefinedOMR' ORDERING xxxundefinedxxx " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with an undefined substring matching rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeUndefinedSMR()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatundefinedsmr-oid " +
|
"NAME 'testAddATUndefinedSMR' SUBSTR xxxundefinedxxx " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with an undefined approximate matching rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeUndefinedAMR()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatundefinedamr-oid " +
|
"NAME 'testAddATUndefinedAMR' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-APPROX 'xxxundefinedxxx' X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type with an invalid usage.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeInvalidUsage()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatundefinedsyntax-oid " +
|
"NAME 'testAddATUndefinedSyntax' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"USAGE xxxinvalidxxx X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type whose superior type is marked OBSOLETE in the server schema.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeObsoleteSuperior()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatobsoletesuperiorsup-oid " +
|
"NAME 'testAddATObsoleteSuperiorSup' OBSOLETE " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )",
|
"attributeTypes: ( testaddatobsoletesuperior-oid " +
|
"NAME 'testAddATObsoleteSuperior' " +
|
"SUP testAddATObsoleteSuperiorSup " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type whose equality matching rule is marked OBSOLETE in the
|
* server schema.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeObsoleteEMR()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddATObsoleteEMRMatch",
|
"1.3.6.1.4.1.26027.1.999.20", true);
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddatobsoleteemr-oid " +
|
"NAME 'testAddATObsoleteEMR' " +
|
"EQUALITY testAddATObsoleteEMRMatch " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, System.err) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type that conflicts with multiple existing types.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeMultipleConflicts()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddattributetypemultipleconflicts-oid NAME " +
|
"( 'testAddAttributeTypeMultipleConflicts' 'cn' 'uid' ) SYNTAX " +
|
"1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN " +
|
"'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* attribute type that references an undefined superior attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAttributeTypeUndefinedSuperior()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddattributetypeundefinedsuperior-oid NAME " +
|
"'testAddAttributeTypeUndefinedSuperior' SUP undefined SYNTAX " +
|
"1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN " +
|
"'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is defined in the server schema and does not have any
|
* dependencies.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAttributeTypeSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( 1.3.6.1.4.1.26027.1.999.6 NAME " +
|
"'testRemoveAttributeTypeSuccessful' SYNTAX " +
|
"1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN " +
|
"'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( 1.3.6.1.4.1.26027.1.999.6 NAME " +
|
"'testRemoveAttributeTypeSuccessful' SYNTAX " +
|
"1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN " +
|
"'SchemaBackendTestCase' )");
|
|
String attrName = "testremoveattributetypesuccessful";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type and add it back in the same modification.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveThenAddAttributeTypeSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testremovethenaddattributetypesuccessful-oid " +
|
"NAME 'testRemoveThenAddAttributeTypeSuccessful' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( testremovethenaddattributetypesuccessful-oid " +
|
"NAME 'testRemoveThenAddAttributeTypeSuccessful' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: attributeTypes",
|
"attributeTypes: ( testremovethenaddattributetypesuccessful-oid " +
|
"NAME 'testRemoveThenAddAttributeTypeSuccessful' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testremoveattributetypesuccessful";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is not defined in the server schema.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAttributeTypeUndefined()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( testremoveattributetypeundefined-oid " +
|
"NAME 'testRemoveAttributeTypeUndefined' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testremoveattributetypeundefined";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is referenced as the superior type for another
|
* attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveSuperiorAttributeType()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( 2.5.4.41 NAME 'name' EQUALITY caseIgnoreMatch " +
|
"SUBSTR caseIgnoreSubstringsMatch " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{32768} " +
|
"X-ORIGIN 'RFC 2256' )");
|
|
String attrName = "name";
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is referenced by an existing objectclass.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAttributeTypeReferencedByObjectClass()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( 0.9.2342.19200300.100.1.1 NAME 'uid' " +
|
"EQUALITY caseIgnoreMatch SUBSTR caseIgnoreSubstringsMatch " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{256} " +
|
"X-ORIGIN 'RFC 1274' )");
|
|
String attrName = "uid";
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is referenced by an existing name form.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAttributeTypeReferencedByNameForm()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testremoveattributetypereferencedbynf-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByNF' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testremoveattributetypereferencedbynfoc-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByNFOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremoveattributetypereferencedbynfnf-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByNFNF' " +
|
"OC testRemoveAttributeTypeReferencedByNFOC " +
|
"MUST testRemoveAttributeTypeReferencedByNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( testremoveattributetypereferencedbynf-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByNF' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testremoveattributetypereferencedbynf";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is referenced by an existing DIT content rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAttributeTypeReferencedByDCR()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testremoveattributetypereferencedbydcr-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByDCR' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testremoveattributetypereferencedbydcroc-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByDCROC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testremoveattributetypereferencedbydcroc-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByDCRDCR' " +
|
"MAY testRemoveAttributeTypeReferencedByDCR " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( testremoveattributetypereferencedbydcr-oid " +
|
"NAME 'testRemoveAttributeTypeReferencedByDCR' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testremoveattributetypereferencedbydcr";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* attribute type that is referenced by an existing matching rule use.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAttributeTypeReferencedByMRU()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testRemoveATRefByMRUMatch",
|
"1.3.6.1.4.1.26027.1.999.17");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testremoveatrefbymruat-oid " +
|
"NAME 'testRemoveATRefByMRUAT' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.17 " +
|
"NAME 'testRemoveATRefByMRUMRU' APPLIES testRemoveATRefByMRUAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: attributeTypes",
|
"attributeTypes: ( testremoveatrefbymruat-oid " +
|
"NAME 'testRemoveATRefByMRUAT' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String attrName = "testremoveatrefbymruat";
|
assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
|
MatchingRuleUse mru =
|
DirectoryServer.getSchema().getMatchingRuleUse(matchingRule);
|
assertNotNull(mru);
|
assertTrue(mru.hasName("testremoveatrefbymrumru"));
|
|
assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that doesn't already exist, that has a valid superior class,
|
* and for which all attributes contained in it are already defined.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( 1.3.6.1.4.1.26027.1.999.5 NAME " +
|
"'testAddObjectClassSuccessful' SUP top STRUCTURAL MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String ocName = "testaddobjectclasssuccessful";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that doesn't already exist, that has a textual OID rather than
|
* numeric, has a valid superior class, and for which all attributes contained
|
* in it are already defined.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassSuccessfulNoOID()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddobjectclasssuccessfulnooid-oid NAME " +
|
"'testAddObjectClassSuccessfulNoOID' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String ocName = "testaddobjectclasssuccessfulnooid";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass to a specific schema file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassToAltSchemaFile()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddobjectclasstoaltschemafile-oid NAME " +
|
"'testAddObjectClassToAltSchemaFile' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase' " +
|
"X-SCHEMA-FILE '98-schema-test-oc.ldif' )");
|
|
String ocName = "testaddobjectclasstoaltschemafile";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(),
|
"98-schema-test-oc.ldif");
|
assertFalse(schemaFile.exists());
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
assertTrue(schemaFile.exists());
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that already exists (i.e., a replace)
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassSuccessfulReplace()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddobjectclasssuccessfulreplace-oid " +
|
"NAME 'testAddObjectClassSuccessfulReplace' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddobjectclasssuccessfulreplace-oid " +
|
"NAME 'testAddObjectClassSuccessfulReplace' SUP top STRUCTURAL " +
|
"MUST cn MAY description X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String ocName = "testaddobjectclasssuccessfulreplace";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that conflicts with multiple existing objectclasses.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassMultipleConflicts()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddobjectclassmultipleconflicts-oid " +
|
"NAME ( 'testAddObjectClassMultipleConflicts' 'person' " +
|
"'device' ) SUP top STRUCTURAL MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String ocName = "testaddobjectclassmultipleconflicts";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing objectclass definition and then add it back in the same operation
|
* with a different definition.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveThenAddAddObjectClassSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremovethenaddobjectclasssuccessful-oid " +
|
"NAME 'testRemoveThenAddObjectClassSuccessful' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClasses",
|
"objectClasses: ( testremovethenaddobjectclasssuccessful-oid " +
|
"NAME 'testRemoveThenAddObjectClassSuccessful' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testremovethenaddobjectclasssuccessful-oid " +
|
"NAME 'testRemoveThenAddObjectClassSuccessful' SUP top " +
|
"STRUCTURAL MUST cn MAY description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String ocName = "testremovethenaddobjectclasssuccessful";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass definition that can't be parsed.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassInvalidSyntax()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: invalidsyntax");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an undefined superior class.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassUndefinedSuperiorClass()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddocundefinedsuperior-oid NAME " +
|
"'testAddOCUndefinedSuperior' SUP undefined STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an obsolete superior class.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassObsoleteSuperiorClass()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddocobsoletesuperiorsup-oid " +
|
"NAME 'testAddOCObsoleteSuperiorSup' OBSOLETE STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"objectClasses: ( testaddocobsoletesuperior-oid " +
|
"NAME 'testAddOCObsoleteSuperior' OBSOLETE " +
|
"SUP testAddOCObsoleteSuperiorSup STRUCTURAL MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an obsolete required attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassObsoleteRequiredAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddocobsoleterequiredattrat-oid " +
|
"NAME 'testAddOCObsoleteRequiredAttrAT' OBSOLETE " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testaddocobsoleterequiredattroc-oid " +
|
"NAME 'testAddOCObsoleteRequiredAttrOC' " +
|
"STRUCTURAL MUST testAddOCObsoleteRequiredAttrAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an obsolete optional attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassObsoleteOptionalAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddocobsoleteoptionalattrat-oid " +
|
"NAME 'testAddOCObsoleteOptionalAttrAT' OBSOLETE " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testaddocobsoleteoptionalattroc-oid " +
|
"NAME 'testAddOCObsoleteOptionalAttrOC' " +
|
"STRUCTURAL MAY testAddOCObsoleteOptionalAttrAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an undefined required attribute.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassUndefinedRequiredAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddocundefinedrequired-oid NAME " +
|
"'testAddOCUndefinedRequired' SUP top STRUCTURAL " +
|
"MUST undefined X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an undefined required attribute when multiple
|
* required attributes were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassMultipleUndefinedRequiredAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddocmultipleundefinedrequired-oid NAME " +
|
"'testAddOCMultipleUndefinedRequired' SUP top STRUCTURAL " +
|
"MUST ( cn $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an undefined optional attribute.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassUndefinedOptionalAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddocundefinedoptional-oid NAME " +
|
"'testAddOCUndefinedOptional' SUP top STRUCTURAL " +
|
"MAY undefined X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* objectclass that references an undefined optional attribute when multiple
|
* optional attributes were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddObjectClassMultipleUndefinedOptionalAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddocmultipleundefinedoptional-oid NAME " +
|
"'testAddOCMultipleUndefinedOptional' SUP top STRUCTURAL " +
|
"MAY ( cn $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* abstract objectclass whose superior class is not abstract.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAbstractObjectClassWithNonAbstractSuperior()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddabstractocwithnonabstractsuperior-oid NAME " +
|
"'testAddAbstractOCWithNonAbstractSuperior' SUP person " +
|
"ABSTRACT MAY description X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* auxiliary objectclass whose superior class is structural.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAuxiliaryObjectClassWithStructuralSuperior()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddauxiliaryocwithstructuralsuperior-oid NAME " +
|
"'testAddAuxiliaryOCWithStructuralSuperior' SUP person " +
|
"AUXILIARY MAY description X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* structural objectclass whose superior class is auxiliary.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddStructuralObjectClassWithAuxiliarySuperior()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddstructuralocwithauxiliarysuperior-oid NAME " +
|
"'testAddStructuralOCWithAuxiliarySuperior' SUP posixAccount " +
|
"STRUCTURAL MAY description X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* objectclass that exists and for which there are no dependencies.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveObjectClassSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( 1.3.6.1.4.1.26027.1.999.7 NAME " +
|
"'testRemoveObjectClassSuccessful' SUP top STRUCTURAL MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClasses",
|
"objectClasses: ( 1.3.6.1.4.1.26027.1.999.7 NAME " +
|
"'testRemoveObjectClassSuccessful' SUP top STRUCTURAL MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String ocName = "testremoveobjectclasssuccessful";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* objectclass that is the superior class for another objectclass.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveSuperiorObjectClass()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClasses",
|
"objectClasses: ( 2.5.6.6 NAME 'person' SUP top STRUCTURAL " +
|
"MUST ( sn $ cn ) MAY ( userPassword $ telephoneNumber $ " +
|
"seeAlso $ description ) X-ORIGIN 'RFC 2256' )");
|
|
String ocName = "person";
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* objectclass that is referenced by an existing name form.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveObjectClassReferencedByNameForm()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremoveobjectclassreferencedbynf-oid " +
|
"NAME 'testRemoveObjectClassReferencedByNF' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremoveattributetypereferencedbynfnf-oid " +
|
"NAME 'testRemoveObjectClassReferencedByNFNF' " +
|
"OC testRemoveObjectClassReferencedByNF MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClasses",
|
"objectClasses: ( testremoveobjectclassreferencedbynf-oid " +
|
"NAME 'testRemoveObjectClassReferencedByNF' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')");
|
|
String ocName = "testremoveobjectclassreferencedbynf";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* objectclass that is referenced by an existing DIT content rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveObjectClassReferencedByDCR()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremoveobjectclassreferencedbydcr-oid " +
|
"NAME 'testRemoveObjectClassReferencedByDCR' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testremoveobjectclassreferencedbydcr-oid " +
|
"NAME 'testRemoveObjectClassReferencedByDCRDCR' " +
|
"MAY description X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClasses",
|
"objectClasses: ( testremoveobjectclassreferencedbydcr-oid " +
|
"NAME 'testRemoveObjectClassReferencedByDCR' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')");
|
|
String ocName = "testremoveobjectclassreferencedbydcr";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form that doesn't already exist.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformsuccessfuloc-oid " +
|
"NAME 'testAddNameFormSuccessfulOC' SUP top STRUCTURAL MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( 1.3.6.1.4.1.26027.1.999.8 " +
|
"NAME 'testAddNameFormSuccessful' " +
|
"OC testAddNameFormSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformsuccessful";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form that doesn't already exist to an alternate schema file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormToAltSchemaFile()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformtoaltschemafileoc-oid " +
|
"NAME 'testAddNameFormToAltSchemaFileOC' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformtoaltschemafile-oid " +
|
"NAME 'testAddNameFormToAltSchemaFile' " +
|
"OC testAddNameFormToAltSchemaFileOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' " +
|
"X-SCHEMA-FILE '98-schema-test-nameform.ldif' )");
|
|
String nameFormName = "testaddnameformtoaltschemafile";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(),
|
"98-schema-test-nameform.ldif");
|
assertFalse(schemaFile.exists());
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
assertTrue(schemaFile.exists());
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form that references a required attribute type not defined in the server
|
* schema.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithUndefinedReqAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformwithundefinedreqatoc-oid " +
|
"NAME 'testAddNameFormWithUndefinedReqATOC' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformwithundefinedreqat-oid " +
|
"NAME 'testAddNameFormWithUndefinedReqAT' " +
|
"OC testAddNameFormWithUndefinedReqATOC MUST xxxundefinedxxx " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformwithundefinedreqat";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form that references a required attribute type not defined in the server
|
* schema when multiple required attributes were given.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithMultipleUndefinedReqAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformwithmultipleundefinedreqatoc-oid " +
|
"NAME 'testAddNameFormWithMultipleUndefinedReqATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformwithmultipleundefinedreqat-oid " +
|
"NAME 'testAddNameFormWithMultipleUndefinedReqAT' " +
|
"OC testAddNameFormWithMultipleUndefinedReqATOC " +
|
"MUST ( cn $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformwithmultipleundefinedreqat";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form that references an optional attribute type not defined in the server
|
* schema.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithUndefinedOptAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformwithundefinedoptatoc-oid " +
|
"NAME 'testAddNameFormWithUndefinedOptATOC' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformwithundefinedoptat-oid " +
|
"NAME 'testAddNameFormWithUndefinedOptAT' " +
|
"OC testAddNameFormWithUndefinedOptATOC MUST cn " +
|
"MAY xxxundefinedxxx X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformwithundefinedoptat";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form that references an optional attribute type not defined in the server
|
* schema when multiple optional attribute types were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithMultipleUndefinedOptAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformwithmultipleundefinedoptatoc-oid " +
|
"NAME 'testAddNameFormWithMultipleUndefinedOptATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformwithmultipleundefinedoptat-oid " +
|
"NAME 'testAddNameFormWithMultipleUndefinedOptAT' " +
|
"OC testAddNameFormWithMultipleUndefinedOptATOC MUST cn " +
|
"MAY ( description $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformwithmultipleundefinedoptat";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form whose structural objectclass is not defined in the server schema.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithUndefinedOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: nameForms",
|
"nameForms: ( testaddnameformwithundefinedoc-oid " +
|
"NAME 'testAddNameFormWithUndefinedOC' " +
|
"OC xxxundefinedxxx MUST cn X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformwithundefinedoc";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form whose objectclass auxiliary rather than structural.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithAuxiliaryOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformwithauxiliaryococ-oid " +
|
"NAME 'testAddNameFormWithAuxiliaryOCOC' SUP top AUXILIARY " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformwithauxiliaryoc-oid " +
|
"NAME 'testAddNameFormWithAuxiliaryOC' " +
|
"OC testAddNameFormWithAuxiliaryOCOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformwithauxiliaryoc";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form whose structural objectclass is OBSOLETE rather than structural.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithObsoleteOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformwithobsoleteococ-oid " +
|
"NAME 'testAddNameFormWithObsoleteOCOC' OBSOLETE SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformwithobsoleteoc-oid " +
|
"NAME 'testAddNameFormWithObsoleteOC' " +
|
"OC testAddNameFormWithObsoleteOCOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformwithobsoleteoc";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form with a required attribute type that is declared OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithObsoleteReqAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddnfwithobsoletereqatat-oid " +
|
"NAME 'testAddNFWithObsoleteReqATAT' OBSOLETE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testaddnfwithobsoletereqatoc-oid " +
|
"NAME 'testAddNFWithObsoleteReqATOC' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnfwithobsoletereqatnf-oid " +
|
"NAME 'testAddNFWithObsoleteReqATNF' " +
|
"OC testAddNFWithObsoleteReqATOC " +
|
"MUST testAddNFWithObsoleteReqATAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form with an optional attribute type that is declared OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormWithObsoleteOptAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddnfwithobsoleteoptatat-oid " +
|
"NAME 'testAddNFWithObsoleteOptATAT' OBSOLETE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testaddnfwithobsoleteoptatoc-oid " +
|
"NAME 'testAddNFWithObsoleteOptATOC' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnfwithobsoleteoptatnf-oid " +
|
"NAME 'testAddNFWithObsoleteOptATNF' " +
|
"OC testAddNFWithObsoleteOptATOC " +
|
"MUST cn MAY testAddNFWithObsoleteOptATAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new name
|
* form that references a structural objectclass already referenced by another
|
* name form.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddNameFormOCConflict()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddnameformocconflictoc-oid " +
|
"NAME 'testAddNameFormOCConflictOC' SUP top STRUCTURAL MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddnameformocconflict-oid " +
|
"NAME 'testAddNameFormOCConflict' " +
|
"OC testAddNameFormOCConflictOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: nameForms",
|
"nameForms: ( testaddnameformocconflict2-oid " +
|
"NAME 'testAddNameFormOCConflict2' " +
|
"OC testAddNameFormOCConflictOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testaddnameformocconflict2";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertTrue(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing name form.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveNameFormSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremovenameformsuccessfuloc-oid " +
|
"NAME 'testRemoveNameFormSuccessfulOC' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( 1.3.6.1.4.1.26027.1.999.9 " +
|
"NAME 'testRemoveNameFormSuccessful' " +
|
"OC testRemoveNameFormSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: nameForms",
|
"nameForms: ( 1.3.6.1.4.1.26027.1.999.9 " +
|
"NAME 'testRemoveNameFormSuccessful' " +
|
"OC testRemoveNameFormSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testremovenameformsuccessful";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing name form and then add it back in the same operation.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveThenAddNameFormSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremovethenaddnameformsuccessfuloc-oid " +
|
"NAME 'testRemoveThenAddNameFormSuccessfulOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremovethenaddnameformsuccessful-oid " +
|
"NAME 'testRemoveThenAddNameFormSuccessful' " +
|
"OC testRemoveThenAddNameFormSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: nameForms",
|
"nameForms: ( testremovethenaddnameformsuccessful-oid " +
|
"NAME 'testRemoveThenAddNameFormSuccessful' " +
|
"OC testRemoveThenAddNameFormSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremovethenaddnameformsuccessful-oid " +
|
"NAME 'testRemoveThenAddNameFormSuccessful' " +
|
"OC testRemoveThenAddNameFormSuccessfulOC MUST cn MAY sn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String nameFormName = "testremovethenaddnameformsuccessful";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove a name
|
* form that is referenced by a DIT structure rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveNameFormReferencedByDSR()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremovenameformreferencedbydsroc-oid " +
|
"NAME 'testRemoveNameFormReferencedByDSROC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremovenameformreferencedbydsrnf-oid " +
|
"NAME 'testRemoveNameFormReferencedByDSRNF' " +
|
"OC testRemoveNameFormReferencedByDSROC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999009 " +
|
"NAME 'testRemoveNameFormReferencedByDSRDSR' " +
|
"FORM testRemoveNameFormReferencedByDSRNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: nameForms",
|
"nameForms: ( testremovenameformreferencedbydsrnf-oid " +
|
"NAME 'testRemoveNameFormReferencedByDSRNF' " +
|
"OC testRemoveNameFormReferencedByDSROC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
String nameFormName = "testremovenameformreferencedbydsrnf";
|
assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that doesn't already exist.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentrulesuccessfuloc-oid " +
|
"NAME 'testAddDITContentRuleSuccessfulOC' SUP top STRUCTURAL " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentrulesuccessfuloc-oid " +
|
"NAME 'testAddDITContentRuleSuccessful' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
String ocName = "testaddditcontentrulesuccessfuloc";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName);
|
assertNotNull(oc);
|
|
DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc);
|
assertNotNull(dcr);
|
assertTrue(dcr.hasName("testaddditcontentrulesuccessful"));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to replace an
|
* existing DIT content rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testReplaceDITContentRuleSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testreplaceditcontentrulesuccessfuloc-oid " +
|
"NAME 'testReplaceDITContentRuleSuccessfulOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testreplaceditcontentrulesuccessfuloc-oid " +
|
"NAME 'testReplaceDITContentRuleSuccessful' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: ditContentRules",
|
"ditContentRules: ( testreplaceditcontentrulesuccessfuloc-oid " +
|
"NAME 'testReplaceDITContentRuleSuccessful' MAY sn " +
|
"NOT description X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
String ocName = "testreplaceditcontentrulesuccessfuloc";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName);
|
assertNotNull(oc);
|
|
DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc);
|
assertNotNull(dcr);
|
assertTrue(dcr.hasName("testreplaceditcontentrulesuccessful"));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule to an alternate schema file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleToAltSchemaFile()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testadddcrtoaltschemafileoc-oid " +
|
"NAME 'testAddDCRToAltSchemaFileOC' SUP top STRUCTURAL " +
|
"MUST cn X-SCHEMA-FILE '98-schema-test-dcr.ldif' " +
|
"X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testadddcrtoaltschemafileoc-oid " +
|
"NAME 'testAddDCRToAltSchemaFile' NOT description " +
|
"X-SCHEMA-FILE '98-schema-test-dcr.ldif' " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
String ocName = "testadddcrtoaltschemafileoc";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(),
|
"98-schema-test-dcr.ldif");
|
assertFalse(schemaFile.exists());
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName);
|
assertNotNull(oc);
|
|
DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc);
|
assertNotNull(dcr);
|
assertTrue(dcr.hasName("testadddcrtoaltschemafile"));
|
|
assertTrue(schemaFile.exists());
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing DIT content rule and add it back in the same operation.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveThenAddDITContentRule()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremovethenaddditcontentruleoc-oid " +
|
"NAME 'testRemoveThenAddDITContentRuleOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testremovethenaddditcontentruleoc-oid " +
|
"NAME 'testRemoveThenAddDITContentRule' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: ditContentRules",
|
"ditContentRules: ( testremovethenaddditcontentruleoc-oid " +
|
"NAME 'testRemoveThenAddDITContentRule' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testremovethenaddditcontentruleoc-oid " +
|
"NAME 'testRemoveThenAddDITContentRule' MAY sn " +
|
"NOT description X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
String ocName = "testremovethenaddditcontentruleoc";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName);
|
assertNotNull(oc);
|
|
DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc);
|
assertNotNull(dcr);
|
assertTrue(dcr.hasName("testremovethenaddditcontentrule"));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule whose structural objectclass is not defined in the schema.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleUndefinedOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: ditContentRules",
|
"ditContentRules: ( xxxundefinedxxx-oid " +
|
"NAME 'testAddDITContentRuleUndefinedOC' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule whose structural objectclass is not actually structural.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleAuxiliaryOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleauxiliaryococ-oid " +
|
"NAME 'testAddDITContentRuleAuxiliaryOCOC' SUP top AUXILIARY " +
|
"MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleauxiliaryococ-oid " +
|
"NAME 'testAddDITContentRuleAuxiliaryOC' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule whose structural objectclass is OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleObsoleteOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleobsoleteococ-oid " +
|
"NAME 'testAddDITContentRuleObsoleteOCOC' OBSOLETE SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleobsoleteococ-oid " +
|
"NAME 'testAddDITContentRuleObsoleteOC' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule whose structural objectclass is already referenced by an
|
* existing DIT content rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleConflictingOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleconflictingococ-oid " +
|
"NAME 'testAddDITContentRuleConflictingOCOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleconflictingococ-oid " +
|
"NAME 'testAddDITContentRuleConflictingOC' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleconflictingococ-oid " +
|
"NAME 'testAddDITContentRuleConflictingOC2' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an undefined auxiliary objectclass.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleUndefinedAuxOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleundefinedauxococ-oid " +
|
"NAME 'testAddDITContentRuleUndefinedAuxOCOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleundefinedauxococ-oid " +
|
"NAME 'testAddDITContentRuleUndefinedAuxOC' " +
|
"AUX xxxundefinedxxx X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an undefined auxiliary objectclass when multiple
|
* auxiliary classes were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleMultipleUndefinedAuxOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentrulemultundefinedauxococ-oid " +
|
"NAME 'testAddDITContentRuleMultUndefinedAuxOCOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentrulemultundefinedauxococ-oid " +
|
"NAME 'testAddDITContentRuleMultUndefinedAuxOC' " +
|
"AUX ( posixAccount $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an auxiliary objectclass that is not auxiliary.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleAuxOCNotAux()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleauxocnotauxoc-oid " +
|
"NAME 'testAddDITContentRuleAuxOCNotAuxOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleauxocnotaux-oid " +
|
"NAME 'testAddDITContentRuleAuxOCNotAuxOC' " +
|
"AUX person X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an auxiliary objectclass that is not auxiliary when
|
* multiple auxiliary classes were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleMultipleAuxOCNotAux()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentrulemultipleauxocnotauxoc-oid " +
|
"NAME 'testAddDITContentRuleMultipleAuxOCNotAuxOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentrulemultipleauxocnotaux-oid " +
|
"NAME 'testAddDITContentRuleMultipleAuxOCNotAuxOC' " +
|
"AUX ( posixAccount $ person ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an auxiliary objectclass that is OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleObsoleteAuxOC()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleobsoleteauxstructural-oid " +
|
"NAME 'testAddDITContentRuleObsoleteAuxOCStructural' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"objectClasses: ( testaddditcontentruleobsoleteauxauxiliary-oid " +
|
"NAME 'testAddDITContentRuleObsoleteAuxOCAuxiliary' OBSOLETE " +
|
"SUP top AUXILIARY MUST cn X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleobsoleteauxstructural-oid " +
|
"NAME 'testAddDITContentRuleObsoleteAuxOC' " +
|
"AUX testAddDITContentRuleObsoleteAuxOCAuxiliary " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that references an undefined required attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleUndefinedReqAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleundefinedreqatoc-oid " +
|
"NAME 'testAddDITContentRuleUndefinedReqATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleundefinedreqatoc-oid " +
|
"NAME 'testAddDITContentRuleUndefinedReqAT' " +
|
"MUST xxxundefinedxxx X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that references an undefined required attribute type when
|
* multiple required attributes were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleMultipleUndefinedReqAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentrulemultundefinedreqatoc-oid " +
|
"NAME 'testAddDITContentRuleMultUndefinedReqATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentrulemultundefinedreqatoc-oid " +
|
"NAME 'testAddDITContentMultRuleUndefinedReqAT' " +
|
"MUST ( cn $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that references an undefined optional attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleUndefinedOptAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleundefinedoptatoc-oid " +
|
"NAME 'testAddDITContentRuleUndefinedOptATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleundefinedoptatoc-oid " +
|
"NAME 'testAddDITContentRuleUndefinedOptAT' " +
|
"MAY xxxundefinedxxx X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that references an undefined optional attribute type when
|
* multiple optional attributes were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleMultipleUndefinedOptAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentrulemultundefinedoptatoc-oid " +
|
"NAME 'testAddDITContentRuleMultUndefinedOptATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentrulemultundefinedoptatoc-oid " +
|
"NAME 'testAddDITContentRuleMultUndefinedOptAT' " +
|
"MAY ( cn $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that references an undefined prohibited attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleUndefinedNotAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentruleundefinednotatoc-oid " +
|
"NAME 'testAddDITContentRuleUndefinedNotATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentruleundefinednotatoc-oid " +
|
"NAME 'testAddDITContentRuleUndefinedNotAT' " +
|
"NOT xxxundefinedxxx X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that references an undefined prohibited attribute type when
|
* multiple prohibited attributes were provided.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleMultipleUndefinedNotAT()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditcontentrulemultundefinednotatoc-oid " +
|
"NAME 'testAddDITContentRuleMultUndefinedNotATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testaddditcontentrulemultundefinednotatoc-oid " +
|
"NAME 'testAddDITContentRuleMultUndefinedNotAT' " +
|
"NOT ( description $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that prohibits an attribute type that is required by the
|
* structural object class.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleProhibitRequiredStructuralAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testadddcrprohibitreqstructuralatoc-oid " +
|
"NAME 'testAddDCRProhibitReqStructuralATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testadddcrprohibitreqstructuralatoc-oid " +
|
"NAME 'testAddDCRProhibitReqStructuralAT' " +
|
"NOT cn X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule that prohibits an attribute type that is required by an
|
* associated auxiliary object class.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleProhibitRequiredAuxiliaryAttribute()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testadddcrprohibitreqauxiliaryatoc-oid " +
|
"NAME 'testAddDCRProhibitReqAuxiliaryATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testadddcrprohibitreqauxiliaryatoc-oid " +
|
"NAME 'testAddDCRProhibitReqAuxiliaryAT' AUX posixAccount " +
|
"NOT uid X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an OBSOLETE required attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleObsoleteRequiredAttributeType()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testadddcrobsoletereqatat-oid " +
|
"NAME 'testAddDCRObsoleteReqATAT' OBSOLETE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testadddcrobsoletereqatoc-oid " +
|
"NAME 'testAddDCRObsoleteReqATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testadddcrobsoletereqatoc-oid " +
|
"NAME 'testAddDCRObsoleteReqATDCR' " +
|
"MUST testAddDCRObsoleteReqATAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an OBSOLETE optional attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleObsoleteOptionalAttributeType()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testadddcrobsoleteoptatat-oid " +
|
"NAME 'testAddDCRObsoleteOptATAT' OBSOLETE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testadddcrobsoleteoptatoc-oid " +
|
"NAME 'testAddDCRObsoleteOptATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testadddcrobsoleteoptatoc-oid " +
|
"NAME 'testAddDCRObsoleteOptATDCR' " +
|
"MAY testAddDCRObsoleteOptATAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new DIT
|
* content rule with an OBSOLETE prohibited attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITContentRuleObsoleteProhibitedAttributeType()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testadddcrobsoletenotatat-oid " +
|
"NAME 'testAddDCRObsoleteNotATAT' OBSOLETE " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testadddcrobsoletenotatoc-oid " +
|
"NAME 'testAddDCRObsoleteNotATOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testadddcrobsoletenotatoc-oid " +
|
"NAME 'testAddDCRObsoleteNotATDCR' " +
|
"NOT testAddDCRObsoleteNotATAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing DIT content rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveDITContentRuleSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremoveditcontentrulesuccessfuloc-oid " +
|
"NAME 'testRemoveDITContentRuleSuccessfulOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: ditContentRules",
|
"ditContentRules: ( testremoveditcontentrulesuccessfuloc-oid " +
|
"NAME 'testRemoveDITContentRuleSuccessful' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: ditContentRules",
|
"ditContentRules: ( testremoveditcontentrulesuccessfuloc-oid " +
|
"NAME 'testRemoveDITContentRuleSuccessful' NOT description " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
String ocName = "testremoveditcontentrulesuccessfuloc";
|
assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName);
|
assertNotNull(oc);
|
|
DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc);
|
assertNull(dcr);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* DIT structure rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITStructureRuleSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditstructurerulesuccessfuloc-oid " +
|
"NAME 'testAddDITStructureRuleSuccessfulOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddditstructurerulesuccessfulnf-oid " +
|
"NAME 'testAddDITStructureRuleSuccessfulNF' " +
|
"OC testAddDITStructureRuleSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999001 " +
|
"NAME 'testAddDITStructureRuleSuccessful' " +
|
"FORM testAddDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999001;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to replace an
|
* existing DIT structure rule definition.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testReplaceDITStructureRuleSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testreplaceditstructurerulesuccessfuloc-oid " +
|
"NAME 'testReplaceDITStructureRuleSuccessfulOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testreplaceditstructurerulesuccessfulnf-oid " +
|
"NAME 'testReplaceDITStructureRuleSuccessfulNF' " +
|
"OC testReplaceDITStructureRuleSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999002 " +
|
"NAME 'testReplaceDITStructureRuleSuccessful' " +
|
"FORM testReplaceDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999002 " +
|
"NAME 'testReplaceDITStructureRuleSuccessful' " +
|
"DESC 'Testing the replacement of an existing DSR' " +
|
"FORM testReplaceDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999002;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* DIT structure rule to an alternate schema file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITStructureRuleToAltSchemaFile()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditstructureruletoaltschemafileoc-oid " +
|
"NAME 'testAddDITStructureRuleToAltSchemaFileOC' SUP top " +
|
"STRUCTURAL MUST cn X-SCHEMA-FILE '98-schema-test-dsr.ldif' " +
|
"X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddditstructureruletoaltschemafilenf-oid " +
|
"NAME 'testAddDITStructureRuleToAltSchemaFileNF' " +
|
"OC testAddDITStructureRuleToAltSchemaFileOC MUST cn " +
|
"X-SCHEMA-FILE '98-schema-test-dsr.ldif' " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999010 " +
|
"NAME 'testAddDITStructureRuleToAltSchemaFile' " +
|
"FORM testAddDITStructureRuleToAltSchemaFileNF " +
|
"X-SCHEMA-FILE '98-schema-test-dsr.ldif' " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999010;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(),
|
"98-schema-test-dsr.ldif");
|
assertFalse(schemaFile.exists());
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertTrue(schemaFile.exists());
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing DIT structure rule definition and add it back in the same
|
* operation.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAndAddDITStructureRuleSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremoveandaddditstructurerulesuccessfuloc-oid " +
|
"NAME 'testRemoveAndAddDITStructureRuleSuccessfulOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremoveandaddditstructurerulesuccessfulnf-oid " +
|
"NAME 'testRemoveAndAddDITStructureRuleSuccessfulNF' " +
|
"OC testRemoveAndAddDITStructureRuleSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999003 " +
|
"NAME 'testRemoveAndAddDITStructureRuleSuccessful' " +
|
"FORM testRemoveAndAddDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: ditStructureRules",
|
"ditStructureRules: ( 999003 " +
|
"NAME 'testRemoveAndAddDITStructureRuleSuccessful' " +
|
"FORM testRemoveAndAddDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999003 " +
|
"NAME 'testRemoveAndAddDITStructureRuleSuccessful' " +
|
"DESC 'Testing removing and re-adding an existing DSR' " +
|
"FORM testRemoveAndAddDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999003;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertTrue(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* DIT structure rule with an undefined name form.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITStructureRuleUndefinedNameForm()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999004 " +
|
"NAME 'testAddDITStructureRuleUndefinedNameForm' " +
|
"FORM xxxundefinedxxx " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999004;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* DIT structure rule that references an undefined superior rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITStructureRuleUndefinedSuperior()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testadddsrundefinedsuperioroc-oid " +
|
"NAME 'testAddDSRUndefinedSuperiorOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testadddsrundefinedsuperiornf-oid " +
|
"NAME 'testAddDSRUndefinedSuperiorNF' " +
|
"OC testAddDSRUndefinedSuperiorOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999005 " +
|
"NAME 'testAddDSRUndefinedSuperior' " +
|
"FORM testAddDSRUndefinedSuperiorNF SUP 999000 " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999005;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* DIT structure rule that references a name form which is OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITStructureRuleObsoleteNameForm()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditstructureruleobsoletenameformoc-oid " +
|
"NAME 'testAddDITStructureRuleObsoleteNameFormOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddditstructureruleobsoletenameformnf-oid " +
|
"NAME 'testAddDITStructureRuleObsoleteNameFormNF' OBSOLETE " +
|
"OC testAddDITStructureRuleObsoleteNameFormOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999011 " +
|
"NAME 'testAddDITStructureRuleObsoleteNameForm' " +
|
"FORM testAddDITStructureRuleObsoleteNameFormNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* DIT structure rule that references a superior rule which is OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddDITStructureRuleObsoleteSuperiorRule()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddditstructureruleobsoletesuperioroc1-oid " +
|
"NAME 'testAddDITStructureRuleObsoleteSuperiorOC1' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"objectClasses: ( testaddditstructureruleobsoletesuperioroc2-oid " +
|
"NAME 'testAddDITStructureRuleObsoleteSuperiorOC2' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testaddditstructureruleobsoletesuperiornf1-oid " +
|
"NAME 'testAddDITStructureRuleObsoleteSuperiorNF1' " +
|
"OC testAddDITStructureRuleObsoleteSuperiorOC1 MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"nameForms: ( testaddditstructureruleobsoletesuperiornf2-oid " +
|
"NAME 'testAddDITStructureRuleObsoleteSuperiorNF2' " +
|
"OC testAddDITStructureRuleObsoleteSuperiorOC2 MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999012 " +
|
"NAME 'testAddDITStructureRuleObsoleteSuperiorSup' OBSOLETE " +
|
"FORM testAddDITStructureRuleObsoleteSuperiorNF1 " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"ditStructureRules: ( 999013 " +
|
"NAME 'testAddDITStructureRuleObsoleteSuperiorSub' " +
|
"FORM testAddDITStructureRuleObsoleteSuperiorNF2 SUP 999012 " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing DIT structure rule definition.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveDITStructureRuleSuccessful()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremoveditstructurerulesuccessfuloc-oid " +
|
"NAME 'testRemoveDITStructureRuleSuccessfulOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremoveditstructurerulesuccessfulnf-oid " +
|
"NAME 'testRemoveDITStructureRuleSuccessfulNF' " +
|
"OC testRemoveDITStructureRuleSuccessfulOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999006 " +
|
"NAME 'testRemoveDITStructureRuleSuccessful' " +
|
"FORM testRemoveDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: ditStructureRules",
|
"ditStructureRules: ( 999006 " +
|
"NAME 'testRemoveDITStructureRuleSuccessful' " +
|
"FORM testRemoveDITStructureRuleSuccessfulNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999006;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing DIT structure rule definition which is the superior rule for
|
* another DIT structure rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveSuperiorDITStructureRule()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testremovesuperiorditstructureruleoc-oid " +
|
"NAME 'testRemoveSuperiorDITStructureRuleOC' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"objectClasses: ( testremovesuperiorditstructureruleoc2-oid " +
|
"NAME 'testRemoveSuperiorDITStructureRuleOC2' SUP top " +
|
"STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')",
|
"-",
|
"add: nameForms",
|
"nameForms: ( testremovesuperiorditstructurerulenf-oid " +
|
"NAME 'testRemoveSuperiorDITStructureRuleNF' " +
|
"OC testRemoveSuperiorDITStructureRuleOC MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"nameForms: ( testremovesuperiorditstructurerulenf2-oid " +
|
"NAME 'testRemoveSuperiorDITStructureRuleNF2' " +
|
"OC testRemoveSuperiorDITStructureRuleOC2 MUST cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: ditStructureRules",
|
"ditStructureRules: ( 999007 " +
|
"NAME 'testRemoveSuperiorDITStructureRule' " +
|
"FORM testRemoveSuperiorDITStructureRuleNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"ditStructureRules: ( 999008 " +
|
"NAME 'testRemoveSuperiorDITStructureRule2' " +
|
"FORM testRemoveSuperiorDITStructureRuleNF2 SUP 999007 " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: ditStructureRules",
|
"ditStructureRules: ( 999007 " +
|
"NAME 'testRemoveSuperiorDITStructureRule' " +
|
"FORM testRemoveSuperiorDITStructureRuleNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
int ruleID = 999007;
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
assertTrue(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
|
|
path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: ditStructureRules",
|
"ditStructureRules: ( 999008 " +
|
"NAME 'testRemoveSuperiorDITStructureRule2' " +
|
"FORM testRemoveSuperiorDITStructureRuleNF2 SUP 999007 " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"ditStructureRules: ( 999007 " +
|
"NAME 'testRemoveSuperiorDITStructureRule' " +
|
"FORM testRemoveSuperiorDITStructureRuleNF " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
args = new String[]
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
assertFalse(DirectoryServer.getSchema().hasDITStructureRule(ruleID));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* matching rule use that doesn't already exist.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseSuccessful()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddMRUSuccessfulMatch",
|
"1.3.6.1.4.1.26027.1.999.10");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.10 " +
|
"NAME 'testAddMRUSuccessful' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
MatchingRuleUse mru =
|
DirectoryServer.getSchema().getMatchingRuleUse(matchingRule);
|
assertNotNull(mru);
|
assertTrue(mru.hasName("testaddmrusuccessful"));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* matching rule to an alternate schema file.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseToAltSchemaFile()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddMRUToAltSchemaFileMatch",
|
"1.3.6.1.4.1.26027.1.999.18");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.18 " +
|
"NAME 'testAddMRUToAltSchemaFile' APPLIES cn " +
|
"X-SCHEMA-FILE '98-schema-test-mru.ldif' " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(),
|
"98-schema-test-mru.ldif");
|
assertFalse(schemaFile.exists());
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
MatchingRuleUse mru =
|
DirectoryServer.getSchema().getMatchingRuleUse(matchingRule);
|
assertNotNull(mru);
|
assertTrue(mru.hasName("testaddmrutoaltschemafile"));
|
|
assertTrue(schemaFile.exists());
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to replace an
|
* existing matching rule use.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testReplaceMatchingRuleUseSuccessful()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testReplaceMRUSuccessfulMatch",
|
"1.3.6.1.4.1.26027.1.999.11");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.11 " +
|
"NAME 'testReplaceMRUSuccessful' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.11 " +
|
"NAME 'testReplaceMRUSuccessful' APPLIES ( cn $ sn ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
MatchingRuleUse mru =
|
DirectoryServer.getSchema().getMatchingRuleUse(matchingRule);
|
assertNotNull(mru);
|
assertTrue(mru.hasName("testreplacemrusuccessful"));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove and
|
* re-add an existing matching rule use in the same operation.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAndAddMatchingRuleUse()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testRemoveAndAddMRUMatch",
|
"1.3.6.1.4.1.26027.1.999.12");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.12 " +
|
"NAME 'testRemoveAndAddMRU' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.12 " +
|
"NAME 'testRemoveAndAddMRU' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"-",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.12 " +
|
"NAME 'testRemoveAndAddMRU' APPLIES ( cn $ sn ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
MatchingRuleUse mru =
|
DirectoryServer.getSchema().getMatchingRuleUse(matchingRule);
|
assertNotNull(mru);
|
assertTrue(mru.hasName("testremoveandaddmru"));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a matching
|
* rule use that references the same matching rule as another matching rule
|
* use.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseMRConflict()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddMRUMRConflictMatch",
|
"1.3.6.1.4.1.26027.1.999.14");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.14 " +
|
"NAME 'testAddMRUMRConflict' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.14 " +
|
"NAME 'testAddMRUMRConflict2' APPLIES sn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
|
MatchingRuleUse mru =
|
DirectoryServer.getSchema().getMatchingRuleUse(matchingRule);
|
assertNotNull(mru);
|
assertTrue(mru.hasName("testaddmrumrconflict"));
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* matching rule use that references an undefined matching rule.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseMRUndefined()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.15 " +
|
"NAME 'testAddMRUMRUndefined' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* matching rule use that references an undefined attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseAttributeTypeUndefined()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddMRUATUndefinedMatch",
|
"1.3.6.1.4.1.26027.1.999.16");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.16 " +
|
"NAME 'testAddMatchingRuleUseATUndefined' " +
|
"APPLIES xxxundefinedxxx " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* matching rule use that references an undefined attribute type.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseAttributeTypeMultipleUndefined()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddMRUATMultipleUndefinedMatch",
|
"1.3.6.1.4.1.26027.1.999.19");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.19 " +
|
"NAME 'testAddMatchingRuleUseATMultipleUndefined' " +
|
"APPLIES ( cn $ xxxundefinedxxx ) " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* matching rule whose matching rule is OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseObsoleteMatchingRule()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddMRUObsoleteMRMatch",
|
"1.3.6.1.4.1.26027.1.999.21", true);
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.21 " +
|
"NAME 'testAddMatchingRuleUseObsoleteMatchingRule' " +
|
"APPLIES cn X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to add a new
|
* matching rule with an associated attribute type that is marked OBSOLETE.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddMatchingRuleUseObsoleteAttributeType()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testAddMRUObsoleteATMatch",
|
"1.3.6.1.4.1.26027.1.999.22");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testaddmruobsoleteat-oid " +
|
"NAME 'testAddMRUObsoleteAT' OBSOLETE )",
|
"-",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.22 " +
|
"NAME 'testAddMatchingRuleUseObsoleteAttributeType' " +
|
"APPLIES testAddMRUObsoleteAT " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertFalse(LDAPModify.mainModify(args, false, null, null) == 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of the schema backend when attempting to remove an
|
* existing matching rule use.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveMatchingRuleUseSuccessful()
|
throws Exception
|
{
|
SchemaTestMatchingRule matchingRule =
|
new SchemaTestMatchingRule("testRemoveMRUSuccessfulMatch",
|
"1.3.6.1.4.1.26027.1.999.13");
|
DirectoryServer.registerMatchingRule(matchingRule, false);
|
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.13 " +
|
"NAME 'testRemoveMRUSuccessful' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: matchingRuleUse",
|
"matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.13 " +
|
"NAME 'testRemoveMRUSuccessful' APPLIES cn " +
|
"X-ORIGIN 'SchemaBackendTestCase' )");
|
|
assertFalse(DirectoryServer.getSchema().hasMatchingRuleUse(matchingRule));
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
MatchingRuleUse mru =
|
DirectoryServer.getSchema().getMatchingRuleUse(matchingRule);
|
assertNull(mru);
|
}
|
|
|
|
/**
|
* This test case covers the problem identified in issue #1318. In that
|
* issue, a problem arose if the following elements occurred in the following
|
* order in a single modify request:
|
*
|
* <OL>
|
* <LI>Delete an existing object class</LI>
|
* <LI>Add a new attribute type</LI>
|
* <LI>Add a new object class (different from the one that was removed) that
|
* depends on the new attribute type</LI>
|
* </OL>
|
*
|
* The problem was that in the process of removing the object class in step 1,
|
* the server checks to see if the same object class is going to be re-added
|
* again later. It does that by looking through the remaining modifications
|
* in the operation and for each modification that would add a new object
|
* class we decode it to see if it has the same OID. The process of decoding
|
* that object class would fail because it depended on a new attribute type
|
* that wasn't yet defined in the schema, and the server wasn't told to ignore
|
* missing schema elements.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testRemoveAndAddObjectClassIssue1318()
|
throws Exception
|
{
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testissue1318oc1-oid NAME 'testIssue1381OC1' )",
|
"",
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClasses",
|
"objectClasses: ( testissue1318oc1-oid NAME 'testIssue1381OC1' )",
|
"-",
|
"add: attributeTypes",
|
"attributeTypes: ( testissue1318at-oid NAME 'testIssue1381AT' )",
|
"-",
|
"add: objectClasses",
|
"objectClasses: ( testissue1318oc2-oid NAME 'testIssue1381OC2' " +
|
"MUST testIssue1381AT )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
}
|
|
|
|
/**
|
* Tests the behavior of schema backend when attribute type definitions
|
* are added without a space before closing parenthesis.
|
*/
|
@Test()
|
public void testAddAttributeTypeNoSpaceBeforeParenthesis() throws Exception
|
{
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( test-oid1)",
|
"attributeTypes: ( test-oid2 NAME 'test2')",
|
"attributeTypes: ( test-oid3 NAME ('test3' 'test4'))",
|
"attributeTypes: ( test-oid4 DESC 'test')",
|
"attributeTypes: ( test-oid5 OBSOLETE)",
|
"attributeTypes: ( test-oid6 SUP test-oid4)",
|
"attributeTypes: ( test-oid7 EQUALITY caseIgnoreMatch)",
|
"attributeTypes: ( test-oid8 SINGLE-VALUE)",
|
"attributeTypes: ( test-oid9 COLLECTIVE)",
|
"attributeTypes: ( test-oid10 NO-USER-MODIFICATION USAGE directoryOperation)",
|
"attributeTypes: ( test-oid11 USAGE userApplications)",
|
"attributeTypes: (test-oid12 EQUALITY caseIgnoreMatch" +
|
" SUBSTR caseIgnoreSubstringsMatch)",
|
"attributeTypes: (test-oid13 EQUALITY caseIgnoreMatch ORDERING " +
|
" caseIgnoreOrderingMatch SUBSTR caseIgnoreSubstringsMatch " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.44 X-ORIGIN 'RFC 4519')");
|
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
}
|
|
|
|
|
|
|
|
|
/**
|
* Tests to ensure that the schema subentry includes the lastmod attributes
|
* and that the modifiersName and modifyTimestamp attributes get updated when
|
* the schema is modified.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test
|
public void testLastModAttributes()
|
throws Exception
|
{
|
Entry schemaEntry = DirectoryServer.getEntry(DN.decode("cn=schema"));
|
assertNotNull(schemaEntry);
|
|
AttributeType cnType =
|
DirectoryServer.getAttributeType("creatorsname", true);
|
AttributeType ctType =
|
DirectoryServer.getAttributeType("createtimestamp", true);
|
AttributeType mnType =
|
DirectoryServer.getAttributeType("modifiersname", true);
|
AttributeType mtType =
|
DirectoryServer.getAttributeType("modifytimestamp", true);
|
|
assertTrue(schemaEntry.hasAttribute(cnType));
|
assertTrue(schemaEntry.hasAttribute(ctType));
|
assertTrue(schemaEntry.hasAttribute(mnType));
|
assertTrue(schemaEntry.hasAttribute(mtType));
|
|
AttributeValue oldMTValue =
|
schemaEntry.getAttribute(mtType).get(0).iterator().next();
|
|
String path = TestCaseUtils.createTempFile(
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: attributeTypes",
|
"attributeTypes: ( testlastmodattributes-oid " +
|
"NAME 'testLastModAttributes' " +
|
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " +
|
"X-ORGIN 'SchemaBackendTestCase' )");
|
|
String[] args =
|
{
|
"-h", "127.0.0.1",
|
"-p", String.valueOf(TestCaseUtils.getServerLdapPort()),
|
"-D", "cn=Directory Manager",
|
"-w", "password",
|
"-f", path
|
};
|
|
// Sleep longer than the TimeThread delay to ensure the modifytimestamp
|
// will be different.
|
Thread.sleep(6000);
|
assertEquals(LDAPModify.mainModify(args, false, null, System.err), 0);
|
|
schemaEntry = DirectoryServer.getEntry(DN.decode("cn=schema"));
|
assertNotNull(schemaEntry);
|
assertTrue(schemaEntry.hasAttribute(cnType));
|
assertTrue(schemaEntry.hasAttribute(ctType));
|
assertTrue(schemaEntry.hasAttribute(mnType));
|
assertTrue(schemaEntry.hasAttribute(mtType));
|
|
AttributeValue newMTValue =
|
schemaEntry.getAttribute(mtType).get(0).iterator().next();
|
assertFalse(oldMTValue.equals(newMTValue));
|
}
|
|
|
|
/**
|
* Tests the ability to properly handle adding and removing a schema
|
* definition in which the definition has extra spaces. This was added as a
|
* test case for issue #2171.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testAddAndDeleteDefinitionWithExtraSpaces()
|
throws Exception
|
{
|
int resultCode = TestCaseUtils.applyModifications(false,
|
"dn: cn=schema",
|
"changetype: modify",
|
"add: objectClasses",
|
"objectClasses: ( testaddanddeletedefinitionwithextraspaces-oid",
|
" NAME 'testAddAndDeleteDefinitionWithExtraSpaces' SUP person",
|
" MAY ( street $ c) X-ORIGIN 'user defined' )");
|
assertEquals(resultCode, 0);
|
|
assertNotNull(DirectoryServer.getObjectClass(
|
"testaddanddeletedefinitionwithextraspaces"));
|
assertNotNull(DirectoryServer.getObjectClass(
|
"testaddanddeletedefinitionwithextraspaces-oid"));
|
|
resultCode = TestCaseUtils.applyModifications(false,
|
"dn: cn=schema",
|
"changetype: modify",
|
"delete: objectClasses",
|
"objectClasses: ( testaddanddeletedefinitionwithextraspaces-oid",
|
" NAME 'testAddAndDeleteDefinitionWithExtraSpaces' SUP person",
|
" MAY ( street $ c) X-ORIGIN 'user defined' )");
|
assertEquals(resultCode, 0);
|
|
assertNull(DirectoryServer.getObjectClass(
|
"testaddanddeletedefinitionwithextraspaces"));
|
assertNull(DirectoryServer.getObjectClass(
|
"testaddanddeletedefinitionwithextraspaces-oid"));
|
}
|
|
|
|
/**
|
* Tests the {@code exportLDIF} method with a valid configuration.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testExportLDIF()
|
throws Exception
|
{
|
File tempFile = File.createTempFile("schema", "testExportLDIF");
|
tempFile.deleteOnExit();
|
LDIFExportConfig exportConfig =
|
new LDIFExportConfig(tempFile.getAbsolutePath(),
|
ExistingFileBehavior.OVERWRITE);
|
|
schemaBackend.exportLDIF(exportConfig);
|
|
assertTrue(tempFile.exists());
|
assertTrue(tempFile.length() > 0);
|
}
|
|
|
|
/**
|
* Tests the {@code importLDIF} method to ensure that it throws an exception.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testImportLDIF()
|
throws Exception
|
{
|
File tempFile = File.createTempFile("schema", "testImportLDIF");
|
tempFile.deleteOnExit();
|
|
LDIFExportConfig exportConfig =
|
new LDIFExportConfig(tempFile.getAbsolutePath(),
|
ExistingFileBehavior.OVERWRITE);
|
|
schemaBackend.exportLDIF(exportConfig);
|
|
LDIFImportConfig importConfig =
|
new LDIFImportConfig(tempFile.getAbsolutePath());
|
|
schemaBackend.importLDIF(importConfig);
|
}
|
|
|
|
/**
|
* Tests the {@code getComponentEntryDN} method.
|
*
|
* @throws Exception If an unexpected problem occurs.
|
*/
|
@Test()
|
public void testGetComponentEntryDN()
|
throws Exception
|
{
|
DN configEntryDN =
|
DN.decode("ds-cfg-backend-id=schema,cn=Backends,cn=config");
|
assertEquals(schemaBackend.getComponentEntryDN(), configEntryDN);
|
}
|
|
|
|
/**
|
* Tests the {@code getClassName} method.
|
*/
|
@Test()
|
public void testGetClassName()
|
{
|
assertEquals(schemaBackend.getClassName(), SchemaBackend.class.getName());
|
}
|
|
|
|
/**
|
* Tests the {@code getAlerts} method.
|
*/
|
@Test()
|
public void testGetAlerts()
|
{
|
LinkedHashMap<String,String> alerts = schemaBackend.getAlerts();
|
assertNotNull(alerts);
|
assertFalse(alerts.isEmpty());
|
}
|
}
|
