SchemaBackendTestCase.java revision ea1068c292e9b341af6d6b563cd8988a96be20a9
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at legal-notices/CDDLv1_0.txt.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2006-2010 Sun Microsystems, Inc.
* Portions Copyright 2013-2015 ForgeRock AS.
*/
/**
* A set of test cases for the schema backend.
*/
@SuppressWarnings("javadoc")
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.
*/
public void startServer() throws Exception
{
}
/**
* Tests the {@code initializeBackend} method by providing a null
* configuration entry.
*
* @throws Exception If an unexpected problem occurs.
*/
InitializationException.class })
public void testInitializeWithNullEntry()
throws Exception
{
}
/**
* Tests the {@code isLocal} method to ensure that it is considered local.
*/
@Test
public void testIsLocal()
{
}
/**
* 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
{
}
/**
* 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
{
}
/**
* 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
{
}
/**
* Tests the {@code entryExists} method with a valid schema DN.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testEntryExistsValidDN()
throws Exception
{
}
/**
* Tests the {@code entryExists} method with an invalid schema DN.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testEntryExistsInvalidDN()
throws Exception
{
}
/**
* Tests to ensure that the {@code addEntry} method always throws an
* exception.
*/
public void testAddEntry() throws Exception
{
}
/**
* Tests to ensure that the {@code deleteEntry} method always throws an
* exception.
*/
public void testDeleteEntry()
throws Exception
{
new DeleteOperationBasis(conn, InternalClientConnection.nextOperationID(), InternalClientConnection.nextMessageID(),
}
/**
* Tests to ensure that the {@code renameEntry} method always throws an
* exception.
*/
public void testRenameEntry()
throws Exception
{
true, null);
}
/**
* 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
{
}
/**
* 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
{
final SearchRequest request = newSearchRequest("cn=schema", SearchScope.SINGLE_LEVEL, filterString);
}
/**
* 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
{
final SearchRequest request = newSearchRequest("cn=schema", SearchScope.WHOLE_SUBTREE, filterString);
}
/**
* 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
{
final SearchRequest request = newSearchRequest("cn=schema", SearchScope.SUBORDINATES, filterString);
}
/**
* 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
{
{
"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
{
schemaBackend.setShowAllAttributes(false);
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClass",
"objectClass: extensibleObject");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"delete: objectClass",
"objectClass: subschema",
"-",
"add: objectClass",
"objectClass: extensibleObject");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"delete: attributeTypes");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"replace: attributeTypes");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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)");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
"98-schema-test-attrtype.ldif");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
"98-schema-test-replaceattrtype.ldif");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: attributeTypes",
"attributeTypes: invalidsyntax");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testAddATObsoleteEMRMatch", "1.3.6.1.4.1.26027.1.999.20", true);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testRemoveATRefByMRUMatch", "1.3.6.1.4.1.26027.1.999.17", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddobjectclasssuccessfulnooid-oid NAME " +
"'testAddObjectClassSuccessfulNoOID' SUP top STRUCTURAL " +
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
"98-schema-test-oc.ldif");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddobjectclassmultipleconflicts-oid " +
"NAME ( 'testAddObjectClassMultipleConflicts' 'person' " +
"'device' ) SUP top STRUCTURAL MUST cn " +
"X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: invalidsyntax");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddocundefinedsuperior-oid NAME " +
"'testAddOCUndefinedSuperior' SUP undefined STRUCTURAL " +
"MUST cn X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddocundefinedrequired-oid NAME " +
"'testAddOCUndefinedRequired' SUP top STRUCTURAL " +
"MUST undefined X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddocmultipleundefinedrequired-oid NAME " +
"'testAddOCMultipleUndefinedRequired' SUP top STRUCTURAL " +
"MUST ( cn $ xxxundefinedxxx ) " +
"X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddocundefinedoptional-oid NAME " +
"'testAddOCUndefinedOptional' SUP top STRUCTURAL " +
"MAY undefined X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddocmultipleundefinedoptional-oid NAME " +
"'testAddOCMultipleUndefinedOptional' SUP top STRUCTURAL " +
"MAY ( cn $ xxxundefinedxxx ) " +
"X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddabstractocwithnonabstractsuperior-oid NAME " +
"'testAddAbstractOCWithNonAbstractSuperior' SUP person " +
"ABSTRACT MAY description X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddauxiliaryocwithstructuralsuperior-oid NAME " +
"'testAddAuxiliaryOCWithStructuralSuperior' SUP person " +
"AUXILIARY MAY description X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddstructuralocwithauxiliarysuperior-oid NAME " +
"'testAddStructuralOCWithAuxiliarySuperior' SUP posixAccount " +
"STRUCTURAL MAY description X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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')");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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')");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
"98-schema-test-nameform.ldif");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: nameForms",
"nameForms: ( testaddnameformwithundefinedoc-oid " +
"NAME 'testAddNameFormWithUndefinedOC' " +
"OC xxxundefinedxxx MUST cn X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
"98-schema-test-dcr.ldif");
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: ditContentRules",
"ditContentRules: ( xxxundefinedxxx-oid " +
"NAME 'testAddDITContentRuleUndefinedOC' NOT description " +
"X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999001;
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999002;
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999010;
"98-schema-test-dsr.ldif");
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999003;
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: ditStructureRules",
"ditStructureRules: ( 999004 " +
"NAME 'testAddDITStructureRuleUndefinedNameForm' " +
"FORM xxxundefinedxxx " +
"X-ORIGIN 'SchemaBackendTestCase' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999004;
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999005;
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999006;
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
int ruleID = 999007;
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
{
.addToSchema().toSchema();
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testAddMRUSuccessfulMatch", "1.3.6.1.4.1.26027.1.999.10", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testAddMRUToAltSchemaFileMatch", "1.3.6.1.4.1.26027.1.999.18", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
"98-schema-test-mru.ldif");
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testReplaceMRUSuccessfulMatch", "1.3.6.1.4.1.26027.1.999.11", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testRemoveAndAddMRUMatch", "1.3.6.1.4.1.26027.1.999.12", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testAddMRUMRConflictMatch", "1.3.6.1.4.1.26027.1.999.14", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testAddMRUATUndefinedMatch", "1.3.6.1.4.1.26027.1.999.16", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testAddMRUObsoleteMRMatch", "1.3.6.1.4.1.26027.1.999.21", true);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testAddMRUObsoleteATMatch", "1.3.6.1.4.1.26027.1.999.22", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
MatchingRule matchingRule = getMatchingRule("testRemoveMRUSuccessfulMatch", "1.3.6.1.4.1.26027.1.999.13", false);
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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 )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* Tests the behavior of schema backend when attribute type definitions
* are added without a space before closing parenthesis.
*/
@Test
public void testAddAttributeTypeNoSpaceBeforeParenthesis() throws Exception
{
"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')");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
}
/**
* 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
{
"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' )");
{
"-h", "127.0.0.1",
"-D", "cn=Directory Manager",
"-w", "password",
"-f", path
};
// Sleep longer than the TimeThread delay to ensure the modifytimestamp
// will be different.
}
/**
* 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
{
"dn: cn=schema",
"changetype: modify",
"add: objectClasses",
"objectClasses: ( testaddanddeletedefinitionwithextraspaces-oid",
" NAME 'testAddAndDeleteDefinitionWithExtraSpaces' SUP person",
" MAY ( street $ c) X-ORIGIN 'user defined' )");
"testaddanddeletedefinitionwithextraspaces"));
"testaddanddeletedefinitionwithextraspaces-oid"));
"dn: cn=schema",
"changetype: modify",
"delete: objectClasses",
"objectClasses: ( testaddanddeletedefinitionwithextraspaces-oid",
" NAME 'testAddAndDeleteDefinitionWithExtraSpaces' SUP person",
" MAY ( street $ c) X-ORIGIN 'user defined' )");
"testaddanddeletedefinitionwithextraspaces"));
"testaddanddeletedefinitionwithextraspaces-oid"));
}
/**
* Tests the {@code exportLDIF} method with a valid configuration.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testExportLDIF()
throws Exception
{
}
/**
* 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
{
}
/**
* Tests the {@code getComponentEntryDN} method.
*
* @throws Exception If an unexpected problem occurs.
*/
@Test
public void testGetComponentEntryDN()
throws Exception
{
}
/**
* Tests the {@code getClassName} method.
*/
@Test
public void testGetClassName()
{
}
/**
* Tests the {@code getAlerts} method.
*/
@Test
public void testGetAlerts()
{
}
}