/* * The contents of this file are subject to the terms of the Common Development and * Distribution License (the License). You may not use this file except in compliance with the * License. * * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the * specific language governing permission and limitations under the License. * * When distributing Covered Software, include this CDDL Header Notice in each file and include * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL * Header, with the fields enclosed by brackets [] replaced by your own identifying * information: "Portions Copyright [year] [name of copyright owner]". * * Copyright 2006-2010 Sun Microsystems, Inc. * Portions Copyright 2013-2016 ForgeRock AS. */ package org.opends.server.backends; import static org.forgerock.opendj.ldap.ResultCode.*; import static org.forgerock.opendj.ldap.schema.CoreSchema.*; import static org.mockito.Mockito.*; import static org.opends.server.TestCaseUtils.*; import static org.opends.server.core.DirectoryServer.*; import static org.opends.server.protocols.internal.InternalClientConnection.*; import static org.opends.server.protocols.internal.Requests.*; import static org.opends.server.types.ExistingFileBehavior.*; import static org.opends.server.util.StaticUtils.*; import static org.testng.Assert.*; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.InputStream; import java.io.PrintStream; import java.util.Arrays; import java.util.List; import java.util.Map; import org.forgerock.opendj.config.server.ConfigException; import org.forgerock.opendj.ldap.ByteString; import org.forgerock.opendj.ldap.DN; import org.forgerock.opendj.ldap.ResultCode; import org.forgerock.opendj.ldap.SearchScope; import org.forgerock.opendj.ldap.schema.AttributeType; import org.forgerock.opendj.ldap.schema.DITContentRule; import org.forgerock.opendj.ldap.schema.MatchingRule; import org.forgerock.opendj.ldap.schema.MatchingRuleUse; import org.forgerock.opendj.ldap.schema.ObjectClass; import org.forgerock.opendj.ldap.schema.Schema; import org.forgerock.opendj.ldap.schema.SchemaBuilder; import org.forgerock.opendj.server.config.server.SchemaBackendCfg; import org.forgerock.util.Utils; import org.opends.server.TestCaseUtils; import org.opends.server.core.AddOperation; import org.opends.server.core.DeleteOperationBasis; import org.opends.server.core.DirectoryServer; import org.opends.server.core.ModifyDNOperationBasis; import org.opends.server.core.SchemaConfigManager; import org.opends.server.core.ServerContext; import org.opends.server.protocols.internal.InternalClientConnection; import org.opends.server.protocols.internal.InternalSearchOperation; import org.opends.server.protocols.internal.SearchRequest; import org.opends.server.schema.SchemaConstants; import org.opends.server.tools.LDAPModify; import org.opends.server.types.DirectoryException; import org.opends.server.types.Entry; import org.opends.server.types.InitializationException; import org.opends.server.types.LDIFExportConfig; import org.opends.server.types.LDIFImportConfig; import org.opends.server.types.LDIFImportResult; import org.opends.server.types.SearchFilter; import org.opends.server.util.CollectionUtils; import org.opends.server.util.ServerConstants; import org.testng.annotations.AfterClass; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; /** 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. */ @BeforeClass public void startServer() throws Exception { TestCaseUtils.startServer(); schemaBackend = (SchemaBackend) DirectoryServer.getBackend("schema"); assertNotNull(schemaBackend); } @AfterClass public void removeFilesCreatedInTests() { final File schemaDir = DirectoryServer.getEnvironmentConfig().getSchemaDirectory(); final List filesCreatedInTests = Arrays.asList( "98-schema-test-attrtype.ldif", "98-schema-test-replaceattrtype.ldif", "98-schema-test-oc.ldif", "98-schema-test-nameform.ldif", "98-schema-test-dcr.ldif", "98-schema-test-dsr.ldif", "98-schema-test-mru.ldif"); for (String fileCreatedInTests : filesCreatedInTests) { new File(schemaDir, fileCreatedInTests).delete(); } } /** * Tests the {@code initializeBackend} method by providing a null * configuration entry. * * @throws Exception If an unexpected problem occurs. */ @Test(expectedExceptions = { ConfigException.class, InitializationException.class }) public void testInitializeWithNullEntry() throws Exception { SchemaBackend schemaBackend = new SchemaBackend(); schemaBackend.configureBackend(null, null); } /** * Tests the {@code getEntry} method to ensure that it is able to retrieve * the schema entry if it is given a valid entry DN. * * @throws Exception If an unexpected problem occurs. */ @Test public void testGetValidEntry() throws Exception { DN schemaDN = DN.valueOf("cn=schema"); Entry schemaEntry = schemaBackend.getEntry(schemaDN); assertNotNull(schemaEntry); assertEquals(schemaEntry.getName(), schemaDN); assertTrue(schemaEntry.hasAttribute(getAttributeTypesAttributeType())); assertTrue(schemaEntry.hasAttribute(getObjectClassesAttributeType())); assertTrue(schemaEntry.hasAttribute(getLDAPSyntaxesAttributeType())); assertTrue(schemaEntry.hasAttribute(getMatchingRulesAttributeType())); } /** * Tests the {@code getEntry} method to ensure that it is not able to retrieve * anything when given an inappropriate DN. * * @throws Exception If an unexpected problem occurs. */ @Test public void testGetInvalidEntry() throws Exception { DN schemaDN = DN.valueOf("cn=notschema"); Entry schemaEntry = schemaBackend.getEntry(schemaDN); assertNull(schemaEntry); schemaDN = DN.valueOf("cn=child,cn=schema"); schemaEntry = schemaBackend.getEntry(schemaDN); assertNull(schemaEntry); } /** * Tests the {@code getSchemaEntry} method to ensure that it is able to * retrieve the appropriate information with different DNs. * * @throws Exception If an unexpected problem occurs. */ @Test public void testGetSchemaEntry() throws Exception { DN schemaDN = DN.valueOf("cn=schema"); Entry schemaEntry = schemaBackend.getSchemaEntry(schemaDN); assertNotNull(schemaEntry); assertEquals(schemaEntry.getName(), schemaDN); assertTrue(schemaEntry.hasAttribute(getAttributeTypesAttributeType())); assertTrue(schemaEntry.hasAttribute(getObjectClassesAttributeType())); assertTrue(schemaEntry.hasAttribute(getLDAPSyntaxesAttributeType())); assertTrue(schemaEntry.hasAttribute(getMatchingRulesAttributeType())); schemaDN = DN.valueOf("cn=subschema"); schemaEntry = schemaBackend.getSchemaEntry(schemaDN); assertNotNull(schemaEntry); assertEquals(schemaEntry.getName(), schemaDN); assertTrue(schemaEntry.hasAttribute(getAttributeTypesAttributeType())); assertTrue(schemaEntry.hasAttribute(getObjectClassesAttributeType())); assertTrue(schemaEntry.hasAttribute(getLDAPSyntaxesAttributeType())); assertTrue(schemaEntry.hasAttribute(getMatchingRulesAttributeType())); } /** * Tests the {@code entryExists} method with a valid schema DN. * * @throws Exception If an unexpected problem occurs. */ @Test public void testEntryExistsValidDN() throws Exception { DN schemaDN = DN.valueOf("cn=schema"); assertTrue(schemaBackend.entryExists(schemaDN)); } /** * Tests the {@code entryExists} method with an invalid schema DN. * * @throws Exception If an unexpected problem occurs. */ @Test public void testEntryExistsInvalidDN() throws Exception { DN schemaDN = DN.valueOf("cn=notschema"); assertFalse(schemaBackend.entryExists(schemaDN)); } /** Tests to ensure that the {@code addEntry} method always throws an exception. */ @Test(expectedExceptions = DirectoryException.class) public void testAddEntry() throws Exception { Entry entry = createEntry(DN.valueOf("cn=schema")); AddOperation addOperation = getRootConnection().processAdd(entry); schemaBackend.addEntry(entry, addOperation); } /** Tests to ensure that the {@code deleteEntry} method always throws an exception. */ @Test(expectedExceptions = DirectoryException.class) public void testDeleteEntry() throws Exception { DN schemaDN = DN.valueOf("cn=schema"); DeleteOperationBasis deleteOperation = new DeleteOperationBasis( getRootConnection(), nextOperationID(), nextMessageID(), null, schemaDN); schemaBackend.deleteEntry(schemaDN, deleteOperation); } /** Tests to ensure that the {@code renameEntry} method always throws an exception. */ @Test(expectedExceptions = DirectoryException.class) public void testRenameEntry() throws Exception { DN currentSchemaDN = DN.valueOf("cn=schema"); DN newSchemaDN = DN.valueOf("cn=newschema"); ModifyDNOperationBasis modifyDNOperation = new ModifyDNOperationBasis( getRootConnection(), nextOperationID(), nextMessageID(), null, currentSchemaDN, newSchemaDN.rdn(), true, null); Entry newSchemaEntry = schemaBackend.getSchemaEntry(newSchemaDN); schemaBackend.renameEntry(currentSchemaDN, newSchemaEntry, modifyDNOperation); } /** * Performs a simple base-level search to verify that the schema entry is * returned. * * @throws Exception If an unexpected problem occurs. */ @Test public void testSimpleBaseSearch() throws Exception { String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))"; final SearchRequest request = newSearchRequest("cn=schema", SearchScope.BASE_OBJECT, filterString); InternalSearchOperation searchOperation = getRootConnection().processSearch(request); assertNotNull(searchOperation); assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS); assertFalse(searchOperation.getSearchEntries().isEmpty()); } /** * Performs a simple single-level search to verify that nothing is returned. * * @throws Exception If an unexpected problem occurs. */ @Test public void testSimpleOneLevelSearch() throws Exception { String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))"; final SearchRequest request = newSearchRequest("cn=schema", SearchScope.SINGLE_LEVEL, filterString); InternalSearchOperation searchOperation = getRootConnection().processSearch(request); assertNotNull(searchOperation); assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS); assertTrue(searchOperation.getSearchEntries().isEmpty()); } /** * Performs a simple subtree search to verify that the schema entry is * returned. * * @throws Exception If an unexpected problem occurs. */ @Test public void testSimpleSubtreeSearch() throws Exception { String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))"; final SearchRequest request = newSearchRequest("cn=schema", SearchScope.WHOLE_SUBTREE, filterString); InternalSearchOperation searchOperation = getRootConnection().processSearch(request); assertNotNull(searchOperation); assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS); assertFalse(searchOperation.getSearchEntries().isEmpty()); } /** * Performs a simple subordinate subtree search to verify that nothing is * returned. * * @throws Exception If an unexpected problem occurs. */ @Test public void testSimpleSubordinateSubtreeSearch() throws Exception { String filterString = "(|(objectClass=*)(objectClass=ldapSubentry))"; final SearchRequest request = newSearchRequest("cn=schema", SearchScope.SUBORDINATES, filterString); InternalSearchOperation searchOperation = getRootConnection().processSearch(request); assertNotNull(searchOperation); assertEquals(searchOperation.getResultCode(), ResultCode.SUCCESS); assertTrue(searchOperation.getSearchEntries().isEmpty()); } /** * Performs a set of searches in the schema backend to ensure that they * correctly set the matched DN in the response. * * @throws Exception If an unexpected problem occurs. */ @Test public void testSearchMatchedDN() throws Exception { InternalClientConnection conn = getRootConnection(); DN baseDN = DN.valueOf("o=bogus,cn=schema"); SearchFilter filter = SearchFilter.objectClassPresent(); for (SearchScope scope : SearchScope.values()) { final SearchRequest request = newSearchRequest(baseDN, scope, filter); InternalSearchOperation searchOperation = conn.processSearch(request); assertNotNull(searchOperation.getMatchedDN(), "No matched DN for scope " + scope); } } /** * Tests the behavior of the schema backend with regard to the * ds-cfg-show-all-attributes configuration. * * @throws Exception If a problem occurs. */ @Test public void testTreatAsUserAttrs() throws Exception { DN schemaDN = DN.valueOf("cn=schema"); AttributeType a = getAttributeTypesAttributeType(); AttributeType o = getObjectClassesAttributeType(); AttributeType m = getMatchingRulesAttributeType(); AttributeType s = getLDAPSyntaxesAttributeType(); assertFalse(schemaBackend.showAllAttributes()); Entry schemaEntry = schemaBackend.getSchemaEntry(schemaDN); assertTrue(schemaEntry.hasOperationalAttribute(a)); assertTrue(schemaEntry.hasOperationalAttribute(o)); assertTrue(schemaEntry.hasOperationalAttribute(m)); assertTrue(schemaEntry.hasOperationalAttribute(s)); setShowAllAttributes(schemaBackend, true); schemaEntry = schemaBackend.getSchemaEntry(schemaDN); assertFalse(schemaEntry.hasOperationalAttribute(a)); assertFalse(schemaEntry.hasOperationalAttribute(o)); assertFalse(schemaEntry.hasOperationalAttribute(m)); assertTrue(schemaEntry.hasOperationalAttribute(s)); setShowAllAttributes(schemaBackend, false); assertFalse(schemaBackend.showAllAttributes()); schemaEntry = schemaBackend.getSchemaEntry(schemaDN); assertTrue(schemaEntry.hasOperationalAttribute(a)); assertTrue(schemaEntry.hasOperationalAttribute(o)); assertTrue(schemaEntry.hasOperationalAttribute(m)); assertTrue(schemaEntry.hasOperationalAttribute(s)); } private void setShowAllAttributes(SchemaBackend schemaBackend, boolean showAllAttributes) { SchemaBackendCfg cfg = spy(SchemaBackendCfg.class); when(cfg.isShowAllAttributes()).thenReturn(showAllAttributes); schemaBackend.applyConfigurationChange(cfg); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type that is not allowed to be altered. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddUnsupportedAttr() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClass", "objectClass: extensibleObject"); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is not allowed to be altered. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveUnsupportedAttr() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "delete: objectClass", "objectClass: subschema", "-", "add: objectClass", "objectClass: extensibleObject"); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); } /** * Tests the behavior of the schema backend when attempting to remove all * attribute type definitions. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAllAttributeTypes() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "delete: attributeTypes"); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); } /** * Tests the behavior of the schema backend when attempting to replace all * attribute types. * * @throws Exception If an unexpected problem occurs. */ @Test public void testReplaceAllAttributeTypes() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "replace: attributeTypes"); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with a valid syntax and that isn't already defined. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( 1.3.6.1.4.1.26027.1.999.4 " + "NAME 'testAddAttributeTypeSuccessful' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORGIN 'SchemaBackendTestCase' )"); String attrName = "testaddattributetypesuccessful"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with a valid syntax (but using a textual OID rather than * numeric) and that isn't already defined. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeSuccessfulNoOID() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testaddattributetypesuccessfulnooid-oid " + "NAME 'testAddAttributeTypeSuccessfulNoOID' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORGIN 'SchemaBackendTestCase' )"); String attrName = "testaddattributetypesuccessfulnooid"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with a valid syntax (but using a textual OID rather than * numeric) and that has no space before last parenthesis. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeType() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testaddattributetypenospacebeforepathenthesis-oid " + "NAME 'testAddAttributeTypeNoSpaceBeforeParenthesis' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "SINGLE-VALUE)"); String attrName = "testaddattributetypenospacebeforeparenthesis"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type to a specific schema file. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeToAltSchemaFile() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testaddattributetypetoaltschemafile-oid " + "NAME 'testAddAttributeTypeToAltSchemaFile' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' " + "X-SCHEMA-FILE '98-schema-test-attrtype.ldif' )"); String attrName = "testaddattributetypetoaltschemafile"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); assertSchemaFileExists("98-schema-test-attrtype.ldif", false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); assertSchemaFileExists("98-schema-test-attrtype.ldif", true); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type in a manner that replaces an existing definition. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeSuccessfulReplace() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testaddattributetypesuccessfulreplace-oid " + "NAME 'testAddAttributeTypeSuccessfulReplace' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testaddattributetypesuccessfulreplace-oid " + "NAME 'testAddAttributeTypeSuccessfulReplace' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testaddattributetypesuccessfulreplace"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to replace an * attribute type definition in a custom schema file. * * @throws Exception If an unexpected problem occurs. */ @Test public void testReplaceAttributeTypeInAltSchemaFile() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testreplaceattributetypeinaltschemafile-oid " + "NAME 'testReplaceAttributeTypeInAltSchemaFile' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' " + "X-SCHEMA-FILE '98-schema-test-replaceattrtype.ldif' )", "", "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testreplaceattributetypeinaltschemafile-oid " + "NAME 'testReplaceAttributeTypeInAltSchemaFile' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testreplaceattributetypeinaltschemafile"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); assertSchemaFileExists("98-schema-test-replaceattrtype.ldif", false); runModify(argsPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); assertSchemaFileExists("98-schema-test-replaceattrtype.ldif", true); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type definition that can't be parsed. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeInvalidSyntax() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: invalidsyntax"); runModify(argsNotPermissive(), ldif, INVALID_ATTRIBUTE_SYNTAX); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with an undefined syntax. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeUndefinedSyntax() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with an undefined equality matching rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeUndefinedEMR() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with an undefined ordering matching rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeUndefinedOMR() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with an undefined substring matching rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeUndefinedSMR() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with an undefined approximate matching rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeUndefinedAMR() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type with an invalid usage. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeInvalidUsage() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, INVALID_ATTRIBUTE_SYNTAX); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type whose superior type is marked OBSOLETE in the server schema. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeObsoleteSuperior() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, CONSTRAINT_VIOLATION); } /** * 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 = registerNewMatchingRule("testAddATObsoleteEMRMatch", "1.3.6.1.4.1.26027.1.999.20", true); try { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, CONSTRAINT_VIOLATION); } finally { deregisterAttributeType("testaddatobsoleteemr-oid"); deregisterMatchingRule(matchingRule); } } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type that conflicts with multiple existing types. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeMultipleConflicts() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * attribute type that references an undefined superior attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAttributeTypeUndefinedSuperior() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is defined in the server schema and does not have any * dependencies. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAttributeTypeSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( 1.3.6.1.4.1.26027.1.999.6 NAME " + "'testRemoveAttributeTypeSuccessful' SYNTAX " + "1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN " + "'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: attributeTypes", "attributeTypes: ( 1.3.6.1.4.1.26027.1.999.6 NAME " + "'testRemoveAttributeTypeSuccessful' SYNTAX " + "1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN " + "'SchemaBackendTestCase' )"); String attrName = "testremoveattributetypesuccessful"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type and add it back in the same modification. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveThenAddAttributeTypeSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testremovethenaddattributetypesuccessful-oid " + "NAME 'testRemoveThenAddAttributeTypeSuccessful' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: attributeTypes", "attributeTypes: ( testremovethenaddattributetypesuccessful-oid " + "NAME 'testRemoveThenAddAttributeTypeSuccessful' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: attributeTypes", "attributeTypes: ( testremovethenaddattributetypesuccessful-oid " + "NAME 'testRemoveThenAddAttributeTypeSuccessful' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testremoveattributetypesuccessful"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is not defined in the server schema. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAttributeTypeUndefined() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "delete: attributeTypes", "attributeTypes: ( testremoveattributetypeundefined-oid " + "NAME 'testRemoveAttributeTypeUndefined' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testremoveattributetypeundefined"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, NO_SUCH_ATTRIBUTE); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is referenced as the superior type for another * attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveSuperiorAttributeType() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "delete: attributeTypes", "attributeTypes: ( 2.5.4.41 NAME 'name' EQUALITY caseIgnoreMatch " + "SUBSTR caseIgnoreSubstringsMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{32768} " + "X-ORIGIN 'RFC 2256' )"); String attrName = "name"; assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is referenced by an existing objectclass. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAttributeTypeReferencedByObjectClass() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "delete: attributeTypes", "attributeTypes: ( 0.9.2342.19200300.100.1.1 NAME 'uid' " + "EQUALITY caseIgnoreMatch SUBSTR caseIgnoreSubstringsMatch " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15{256} " + "X-ORIGIN 'RFC 1274' )"); String attrName = "uid"; assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is referenced by an existing name form. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAttributeTypeReferencedByNameForm() throws Exception { String attrName = "testremoveattributetypereferencedbynf"; String modifyAttributeTypes = "attributeTypes: ( " + attrName + "-oid " + "NAME '" + attrName + "' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )"; String modifyObjectClasses = "objectClasses: ( " + attrName + "oc-oid " + "NAME '" + attrName + "OC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')"; String modifyNameForms = "nameForms: ( " + attrName + "nf-oid " + "NAME '" + attrName + "NF' " + "OC " + attrName + "OC " + "MUST " + attrName + " " + "X-ORIGIN 'SchemaBackendTestCase' )"; String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", modifyAttributeTypes, "-", "add: objectClasses", modifyObjectClasses, "-", "add: nameForms", modifyNameForms); String ldif1 = toLdif( "dn: cn=schema", "changetype: modify", "delete: attributeTypes", modifyAttributeTypes); String ldif2 = toLdif( "dn: cn=schema", "changetype: modify", "delete: nameForms", modifyNameForms, "-", "delete: objectClasses", modifyObjectClasses, "-", "delete: attributeTypes", modifyAttributeTypes); try { assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, SUCCESS); runModify(argsNotPermissive(), ldif1, CONSTRAINT_VIOLATION); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } finally { runModify(argsNotPermissive(), ldif2, SUCCESS); assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); } } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is referenced by an existing DIT content rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAttributeTypeReferencedByDCR() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testremoveattributetypereferencedbydcr-oid " + "NAME 'testRemoveAttributeTypeReferencedByDCR' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: objectClasses", "objectClasses: ( testremoveattributetypereferencedbydcroc-oid " + "NAME 'testRemoveAttributeTypeReferencedByDCROC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: ditContentRules", "ditContentRules: ( testremoveattributetypereferencedbydcroc-oid " + "NAME 'testRemoveAttributeTypeReferencedByDCRDCR' " + "MAY testRemoveAttributeTypeReferencedByDCR " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: attributeTypes", "attributeTypes: ( testremoveattributetypereferencedbydcr-oid " + "NAME 'testRemoveAttributeTypeReferencedByDCR' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testremoveattributetypereferencedbydcr"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } /** * Tests the behavior of the schema backend when attempting to remove an * attribute type that is referenced by an existing matching rule use. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAttributeTypeReferencedByMRU() throws Exception { MatchingRule matchingRule = registerNewMatchingRule("testRemoveATRefByMRUMatch", "1.3.6.1.4.1.26027.1.999.17", false); try { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testremoveatrefbymruat-oid " + "NAME 'testRemoveATRefByMRUAT' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: matchingRuleUse", "matchingRuleUse: ( 1.3.6.1.4.1.26027.1.999.17 " + "NAME 'testRemoveATRefByMRUMRU' APPLIES testRemoveATRefByMRUAT " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: attributeTypes", "attributeTypes: ( testremoveatrefbymruat-oid " + "NAME 'testRemoveATRefByMRUAT' " + "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testremoveatrefbymruat"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertMatchingRuleUseExistsWithName(matchingRule, "testremoveatrefbymrumru"); assertTrue(DirectoryServer.getSchema().hasAttributeType(attrName)); } finally { DirectoryServer.getSchema(); deregisterMatchingRuleUse(matchingRule); deregisterAttributeType("testremoveatrefbymruat-oid"); deregisterMatchingRule(matchingRule); } } private void deregisterAttributeType(String nameOrOid) throws DirectoryException { org.opends.server.types.Schema schema = DirectoryServer.getSchema(); schema.deregisterAttributeType(schema.getAttributeType(nameOrOid)); } private void deregisterMatchingRuleUse(MatchingRule matchingRule) throws DirectoryException { org.opends.server.types.Schema schema = DirectoryServer.getSchema(); schema.deregisterMatchingRuleUse(schema.getMatchingRuleUse(matchingRule)); } private void deregisterMatchingRule(MatchingRule matchingRule) throws DirectoryException { DirectoryServer.getSchema().deregisterMatchingRule(matchingRule); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that doesn't already exist, that has a valid superior class, * and for which all attributes contained in it are already defined. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( 1.3.6.1.4.1.26027.1.999.5 NAME " + "'testAddObjectClassSuccessful' SUP top STRUCTURAL MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testaddobjectclasssuccessful"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that doesn't already exist, that has a textual OID rather than * numeric, has a valid superior class, and for which all attributes contained * in it are already defined. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassSuccessfulNoOID() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddobjectclasssuccessfulnooid-oid NAME " + "'testAddObjectClassSuccessfulNoOID' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testaddobjectclasssuccessfulnooid"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass to a specific schema file. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassToAltSchemaFile() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddobjectclasstoaltschemafile-oid NAME " + "'testAddObjectClassToAltSchemaFile' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase' " + "X-SCHEMA-FILE '98-schema-test-oc.ldif' )"); String ocName = "testaddobjectclasstoaltschemafile"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); assertSchemaFileExists("98-schema-test-oc.ldif", false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); assertSchemaFileExists("98-schema-test-oc.ldif", true); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that already exists (i.e., a replace) * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassSuccessfulReplace() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddobjectclasssuccessfulreplace-oid " + "NAME 'testAddObjectClassSuccessfulReplace' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddobjectclasssuccessfulreplace-oid " + "NAME 'testAddObjectClassSuccessfulReplace' SUP top STRUCTURAL " + "MUST cn MAY description X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testaddobjectclasssuccessfulreplace"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that conflicts with multiple existing objectclasses. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassMultipleConflicts() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddobjectclassmultipleconflicts-oid " + "NAME ( 'testAddObjectClassMultipleConflicts' 'person' " + "'device' ) SUP top STRUCTURAL MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testaddobjectclassmultipleconflicts"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); } /** * Tests the behavior of the schema backend when attempting to remove an * existing objectclass definition and then add it back in the same operation * with a different definition. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveThenAddAddObjectClassSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testremovethenaddobjectclasssuccessful-oid " + "NAME 'testRemoveThenAddObjectClassSuccessful' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: objectClasses", "objectClasses: ( testremovethenaddobjectclasssuccessful-oid " + "NAME 'testRemoveThenAddObjectClassSuccessful' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: objectClasses", "objectClasses: ( testremovethenaddobjectclasssuccessful-oid " + "NAME 'testRemoveThenAddObjectClassSuccessful' SUP top " + "STRUCTURAL MUST cn MAY description " + "X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testremovethenaddobjectclasssuccessful"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass definition that can't be parsed. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassInvalidSyntax() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: invalidsyntax"); runModify(argsNotPermissive(), ldif, INVALID_ATTRIBUTE_SYNTAX); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an undefined superior class. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassUndefinedSuperiorClass() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddocundefinedsuperior-oid NAME " + "'testAddOCUndefinedSuperior' SUP undefined STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an obsolete superior class. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassObsoleteSuperiorClass() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an obsolete required attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassObsoleteRequiredAttribute() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an obsolete optional attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassObsoleteOptionalAttribute() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an undefined required attribute. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassUndefinedRequiredAttribute() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddocundefinedrequired-oid NAME " + "'testAddOCUndefinedRequired' SUP top STRUCTURAL " + "MUST undefined X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an undefined required attribute when multiple * required attributes were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassMultipleUndefinedRequiredAttribute() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddocmultipleundefinedrequired-oid NAME " + "'testAddOCMultipleUndefinedRequired' SUP top STRUCTURAL " + "MUST ( cn $ xxxundefinedxxx ) " + "X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an undefined optional attribute. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassUndefinedOptionalAttribute() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddocundefinedoptional-oid NAME " + "'testAddOCUndefinedOptional' SUP top STRUCTURAL " + "MAY undefined X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * objectclass that references an undefined optional attribute when multiple * optional attributes were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddObjectClassMultipleUndefinedOptionalAttribute() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddocmultipleundefinedoptional-oid NAME " + "'testAddOCMultipleUndefinedOptional' SUP top STRUCTURAL " + "MAY ( cn $ xxxundefinedxxx ) " + "X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * abstract objectclass whose superior class is not abstract. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAbstractObjectClassWithNonAbstractSuperior() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddabstractocwithnonabstractsuperior-oid NAME " + "'testAddAbstractOCWithNonAbstractSuperior' SUP person " + "ABSTRACT MAY description X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * auxiliary objectclass whose superior class is structural. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAuxiliaryObjectClassWithStructuralSuperior() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddauxiliaryocwithstructuralsuperior-oid NAME " + "'testAddAuxiliaryOCWithStructuralSuperior' SUP person " + "AUXILIARY MAY description X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * structural objectclass whose superior class is auxiliary. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddStructuralObjectClassWithAuxiliarySuperior() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddstructuralocwithauxiliarysuperior-oid NAME " + "'testAddStructuralOCWithAuxiliarySuperior' SUP posixAccount " + "STRUCTURAL MAY description X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to remove an * objectclass that exists and for which there are no dependencies. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveObjectClassSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( 1.3.6.1.4.1.26027.1.999.7 NAME " + "'testRemoveObjectClassSuccessful' SUP top STRUCTURAL MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: objectClasses", "objectClasses: ( 1.3.6.1.4.1.26027.1.999.7 NAME " + "'testRemoveObjectClassSuccessful' SUP top STRUCTURAL MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testremoveobjectclasssuccessful"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); } /** * Tests the behavior of the schema backend when attempting to remove an * objectclass that is the superior class for another objectclass. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveSuperiorObjectClass() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "delete: objectClasses", "objectClasses: ( 2.5.6.6 NAME 'person' SUP top STRUCTURAL " + "MUST ( sn $ cn ) MAY ( userPassword $ telephoneNumber $ " + "seeAlso $ description ) X-ORIGIN 'RFC 2256' )"); String ocName = "person"; assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); } /** * Tests the behavior of the schema backend when attempting to remove an * objectclass that is referenced by an existing name form. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveObjectClassReferencedByNameForm() throws Exception { String ocName = "testremoveobjectclassreferencedbynf"; String modifyObjectClasses = "objectClasses: ( " + ocName + "-oid " + "NAME '" + ocName + "' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')"; String modifyNameForms = "nameForms: ( testremoveattributetypereferencedbynfnf-oid " + "NAME '" + ocName + "NF' " + "OC " + ocName + " MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"; String addOCThenNF = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", modifyObjectClasses, "-", "add: nameForms", modifyNameForms); String deleteOC = toLdif( "dn: cn=schema", "changetype: modify", "delete: objectClasses", modifyObjectClasses); String deleteNFThenOC = toLdif( "dn: cn=schema", "changetype: modify", "delete: nameForms", modifyNameForms, "-", "delete: objectClasses", modifyObjectClasses); try { assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsPermissive(), addOCThenNF, SUCCESS); runModify(argsPermissive(), deleteOC, UNWILLING_TO_PERFORM); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); } finally { runModify(argsPermissive(), deleteNFThenOC, SUCCESS); assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); } } /** * Tests the behavior of the schema backend when attempting to remove an * objectclass that is referenced by an existing DIT content rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveObjectClassReferencedByDCR() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testremoveobjectclassreferencedbydcr-oid " + "NAME 'testRemoveObjectClassReferencedByDCR' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: ditContentRules", "ditContentRules: ( testremoveobjectclassreferencedbydcr-oid " + "NAME 'testRemoveObjectClassReferencedByDCRDCR' " + "MAY description X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: objectClasses", "objectClasses: ( testremoveobjectclassreferencedbydcr-oid " + "NAME 'testRemoveObjectClassReferencedByDCR' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')"); String ocName = "testremoveobjectclassreferencedbydcr"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertTrue(DirectoryServer.getSchema().hasObjectClass(ocName)); } private String[] argsNotPermissive() { return args(false); } private String[] argsPermissive() { return args(true); } private String[] args(boolean usePermissiveModifyControl) { final List args = CollectionUtils.newArrayList( "-h", "127.0.0.1", "-p", String.valueOf(TestCaseUtils.getServerLdapPort()), "-D", "cn=Directory Manager", "-w", "password" ); if (usePermissiveModifyControl) { args.add("-J"); args.add(ServerConstants.OID_PERMISSIVE_MODIFY_CONTROL); } return args.toArray(new String[0]); } /** * Tests the behavior of the schema backend when attempting to add a new name * form that doesn't already exist. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformsuccessfuloc-oid " + "NAME 'testAddNameFormSuccessfulOC' SUP top STRUCTURAL MUST cn " + "X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( 1.3.6.1.4.1.26027.1.999.8 " + "NAME 'testAddNameFormSuccessful' " + "OC testAddNameFormSuccessfulOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformsuccessful"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form that doesn't already exist to an alternate schema file. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormToAltSchemaFile() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformtoaltschemafileoc-oid " + "NAME 'testAddNameFormToAltSchemaFileOC' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformtoaltschemafile-oid " + "NAME 'testAddNameFormToAltSchemaFile' " + "OC testAddNameFormToAltSchemaFileOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' " + "X-SCHEMA-FILE '98-schema-test-nameform.ldif' )"); String nameFormName = "testaddnameformtoaltschemafile"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); assertSchemaFileExists("98-schema-test-nameform.ldif", false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName)); assertSchemaFileExists("98-schema-test-nameform.ldif", true); } /** * Tests the behavior of the schema backend when attempting to add a new name * form that references a required attribute type not defined in the server * schema. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithUndefinedReqAT() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformwithundefinedreqatoc-oid " + "NAME 'testAddNameFormWithUndefinedReqATOC' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformwithundefinedreqat-oid " + "NAME 'testAddNameFormWithUndefinedReqAT' " + "OC testAddNameFormWithUndefinedReqATOC MUST xxxundefinedxxx " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformwithundefinedreqat"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form that references a required attribute type not defined in the server * schema when multiple required attributes were given. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithMultipleUndefinedReqAT() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformwithmultipleundefinedreqatoc-oid " + "NAME 'testAddNameFormWithMultipleUndefinedReqATOC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformwithmultipleundefinedreqat-oid " + "NAME 'testAddNameFormWithMultipleUndefinedReqAT' " + "OC testAddNameFormWithMultipleUndefinedReqATOC " + "MUST ( cn $ xxxundefinedxxx ) " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformwithmultipleundefinedreqat"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form that references an optional attribute type not defined in the server * schema. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithUndefinedOptAT() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformwithundefinedoptatoc-oid " + "NAME 'testAddNameFormWithUndefinedOptATOC' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformwithundefinedoptat-oid " + "NAME 'testAddNameFormWithUndefinedOptAT' " + "OC testAddNameFormWithUndefinedOptATOC MUST cn " + "MAY xxxundefinedxxx X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformwithundefinedoptat"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form that references an optional attribute type not defined in the server * schema when multiple optional attribute types were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithMultipleUndefinedOptAT() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformwithmultipleundefinedoptatoc-oid " + "NAME 'testAddNameFormWithMultipleUndefinedOptATOC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformwithmultipleundefinedoptat-oid " + "NAME 'testAddNameFormWithMultipleUndefinedOptAT' " + "OC testAddNameFormWithMultipleUndefinedOptATOC MUST cn " + "MAY ( description $ xxxundefinedxxx ) " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformwithmultipleundefinedoptat"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form whose structural objectclass is not defined in the server schema. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithUndefinedOC() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( testaddnameformwithundefinedoc-oid " + "NAME 'testAddNameFormWithUndefinedOC' " + "OC xxxundefinedxxx MUST cn X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformwithundefinedoc"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form whose objectclass auxiliary rather than structural. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithAuxiliaryOC() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformwithauxiliaryococ-oid " + "NAME 'testAddNameFormWithAuxiliaryOCOC' SUP top AUXILIARY " + "MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformwithauxiliaryoc-oid " + "NAME 'testAddNameFormWithAuxiliaryOC' " + "OC testAddNameFormWithAuxiliaryOCOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformwithauxiliaryoc"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form whose structural objectclass is OBSOLETE rather than structural. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithObsoleteOC() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformwithobsoleteococ-oid " + "NAME 'testAddNameFormWithObsoleteOCOC' OBSOLETE SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformwithobsoleteoc-oid " + "NAME 'testAddNameFormWithObsoleteOC' " + "OC testAddNameFormWithObsoleteOCOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformwithobsoleteoc"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new name * form with a required attribute type that is declared OBSOLETE. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithObsoleteReqAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new name * form with an optional attribute type that is declared OBSOLETE. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormWithObsoleteOptAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new name * form that references a structural objectclass already referenced by another * name form. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddNameFormOCConflict() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddnameformocconflictoc-oid " + "NAME 'testAddNameFormOCConflictOC' SUP top STRUCTURAL MUST cn " + "X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testaddnameformocconflict-oid " + "NAME 'testAddNameFormOCConflict' " + "OC testAddNameFormOCConflictOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( testaddnameformocconflict2-oid " + "NAME 'testAddNameFormOCConflict2' " + "OC testAddNameFormOCConflictOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testaddnameformocconflict2"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, SUCCESS); assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to remove an * existing name form. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveNameFormSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testremovenameformsuccessfuloc-oid " + "NAME 'testRemoveNameFormSuccessfulOC' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( 1.3.6.1.4.1.26027.1.999.9 " + "NAME 'testRemoveNameFormSuccessful' " + "OC testRemoveNameFormSuccessfulOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: nameForms", "nameForms: ( 1.3.6.1.4.1.26027.1.999.9 " + "NAME 'testRemoveNameFormSuccessful' " + "OC testRemoveNameFormSuccessfulOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testremovenameformsuccessful"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to remove an * existing name form and then add it back in the same operation. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveThenAddNameFormSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testremovethenaddnameformsuccessfuloc-oid " + "NAME 'testRemoveThenAddNameFormSuccessfulOC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: nameForms", "nameForms: ( testremovethenaddnameformsuccessful-oid " + "NAME 'testRemoveThenAddNameFormSuccessful' " + "OC testRemoveThenAddNameFormSuccessfulOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: nameForms", "nameForms: ( testremovethenaddnameformsuccessful-oid " + "NAME 'testRemoveThenAddNameFormSuccessful' " + "OC testRemoveThenAddNameFormSuccessfulOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: nameForms", "nameForms: ( testremovethenaddnameformsuccessful-oid " + "NAME 'testRemoveThenAddNameFormSuccessful' " + "OC testRemoveThenAddNameFormSuccessfulOC MUST cn MAY sn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testremovethenaddnameformsuccessful"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to remove a name * form that is referenced by a DIT structure rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveNameFormReferencedByDSR() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testremovenameformreferencedbydsroc-oid " + "NAME 'testRemoveNameFormReferencedByDSROC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: nameForms", "nameForms: ( testremovenameformreferencedbydsrnf-oid " + "NAME 'testRemoveNameFormReferencedByDSRNF' " + "OC testRemoveNameFormReferencedByDSROC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: ditStructureRules", "ditStructureRules: ( 999009 " + "NAME 'testRemoveNameFormReferencedByDSRDSR' " + "FORM testRemoveNameFormReferencedByDSRNF " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: nameForms", "nameForms: ( testremovenameformreferencedbydsrnf-oid " + "NAME 'testRemoveNameFormReferencedByDSRNF' " + "OC testRemoveNameFormReferencedByDSROC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testremovenameformreferencedbydsrnf"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertTrue(DirectoryServer.getSchema().hasNameForm(nameFormName)); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that doesn't already exist. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddditcontentrulesuccessfuloc-oid " + "NAME 'testAddDITContentRuleSuccessfulOC' SUP top STRUCTURAL " + "MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: ditContentRules", "ditContentRules: ( testaddditcontentrulesuccessfuloc-oid " + "NAME 'testAddDITContentRuleSuccessful' NOT description " + "X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testaddditcontentrulesuccessfuloc"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName); assertFalse(oc.isPlaceHolder()); DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc); assertNotNull(dcr); assertTrue(dcr.hasName("testaddditcontentrulesuccessful")); } /** * Tests the behavior of the schema backend when attempting to replace an * existing DIT content rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testReplaceDITContentRuleSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testreplaceditcontentrulesuccessfuloc-oid " + "NAME 'testReplaceDITContentRuleSuccessfulOC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: ditContentRules", "ditContentRules: ( testreplaceditcontentrulesuccessfuloc-oid " + "NAME 'testReplaceDITContentRuleSuccessful' NOT description " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: ditContentRules", "ditContentRules: ( testreplaceditcontentrulesuccessfuloc-oid " + "NAME 'testReplaceDITContentRuleSuccessful' MAY sn " + "NOT description X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testreplaceditcontentrulesuccessfuloc"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsPermissive(), ldif, System.err, SUCCESS); ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName); assertFalse(oc.isPlaceHolder()); DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc); assertNotNull(dcr); assertTrue(dcr.hasName("testreplaceditcontentrulesuccessful")); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule to an alternate schema file. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleToAltSchemaFile() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testadddcrtoaltschemafileoc-oid " + "NAME 'testAddDCRToAltSchemaFileOC' SUP top STRUCTURAL " + "MUST cn X-SCHEMA-FILE '98-schema-test-dcr.ldif' " + "X-ORIGIN 'SchemaBackendTestCase')", "-", "add: ditContentRules", "ditContentRules: ( testadddcrtoaltschemafileoc-oid " + "NAME 'testAddDCRToAltSchemaFile' NOT description " + "X-SCHEMA-FILE '98-schema-test-dcr.ldif' " + "X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testadddcrtoaltschemafileoc"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); assertSchemaFileExists("98-schema-test-dcr.ldif", false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName); assertFalse(oc.isPlaceHolder()); DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc); assertNotNull(dcr); assertTrue(dcr.hasName("testadddcrtoaltschemafile")); assertSchemaFileExists("98-schema-test-dcr.ldif", true); } /** * Tests the behavior of the schema backend when attempting to remove an * existing DIT content rule and add it back in the same operation. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveThenAddDITContentRule() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testremovethenaddditcontentruleoc-oid " + "NAME 'testRemoveThenAddDITContentRuleOC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: ditContentRules", "ditContentRules: ( testremovethenaddditcontentruleoc-oid " + "NAME 'testRemoveThenAddDITContentRule' NOT description " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: ditContentRules", "ditContentRules: ( testremovethenaddditcontentruleoc-oid " + "NAME 'testRemoveThenAddDITContentRule' NOT description " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "add: ditContentRules", "ditContentRules: ( testremovethenaddditcontentruleoc-oid " + "NAME 'testRemoveThenAddDITContentRule' MAY sn " + "NOT description X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testremovethenaddditcontentruleoc"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName); assertFalse(oc.isPlaceHolder()); DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc); assertNotNull(dcr); assertTrue(dcr.hasName("testremovethenaddditcontentrule")); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule whose structural objectclass is not defined in the schema. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleUndefinedOC() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: ditContentRules", "ditContentRules: ( xxxundefinedxxx-oid " + "NAME 'testAddDITContentRuleUndefinedOC' NOT description " + "X-ORIGIN 'SchemaBackendTestCase' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule whose structural objectclass is not actually structural. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleAuxiliaryOC() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule whose structural objectclass is OBSOLETE. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleObsoleteOC() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule whose structural objectclass is already referenced by an * existing DIT content rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleConflictingOC() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, ATTRIBUTE_OR_VALUE_EXISTS); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an undefined auxiliary objectclass. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleUndefinedAuxOC() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an undefined auxiliary objectclass when multiple * auxiliary classes were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleMultipleUndefinedAuxOC() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an auxiliary objectclass that is not auxiliary. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleAuxOCNotAux() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an auxiliary objectclass that is not auxiliary when * multiple auxiliary classes were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleMultipleAuxOCNotAux() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an auxiliary objectclass that is OBSOLETE. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleObsoleteAuxOC() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that references an undefined required attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleUndefinedReqAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that references an undefined required attribute type when * multiple required attributes were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleMultipleUndefinedReqAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that references an undefined optional attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleUndefinedOptAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that references an undefined optional attribute type when * multiple optional attributes were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleMultipleUndefinedOptAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that references an undefined prohibited attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleUndefinedNotAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that references an undefined prohibited attribute type when * multiple prohibited attributes were provided. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleMultipleUndefinedNotAT() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that prohibits an attribute type that is required by the * structural object class. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleProhibitRequiredStructuralAttribute() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule that prohibits an attribute type that is required by an * associated auxiliary object class. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleProhibitRequiredAuxiliaryAttribute() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an OBSOLETE required attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleObsoleteRequiredAttributeType() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an OBSOLETE optional attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleObsoleteOptionalAttributeType() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new DIT * content rule with an OBSOLETE prohibited attribute type. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITContentRuleObsoleteProhibitedAttributeType() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to remove an * existing DIT content rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveDITContentRuleSuccessful() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testremoveditcontentrulesuccessfuloc-oid " + "NAME 'testRemoveDITContentRuleSuccessfulOC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')", "-", "add: ditContentRules", "ditContentRules: ( testremoveditcontentrulesuccessfuloc-oid " + "NAME 'testRemoveDITContentRuleSuccessful' NOT description " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "delete: ditContentRules", "ditContentRules: ( testremoveditcontentrulesuccessfuloc-oid " + "NAME 'testRemoveDITContentRuleSuccessful' NOT description " + "X-ORIGIN 'SchemaBackendTestCase' )"); String ocName = "testremoveditcontentrulesuccessfuloc"; assertFalse(DirectoryServer.getSchema().hasObjectClass(ocName)); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); ObjectClass oc = DirectoryServer.getSchema().getObjectClass(ocName); assertFalse(oc.isPlaceHolder()); DITContentRule dcr = DirectoryServer.getSchema().getDITContentRule(oc); assertNull(dcr); } /** * Tests the behavior of the schema backend when attempting to add a new * DIT structure rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleSuccessful() throws Exception { String ldif = toLdif( "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' )"); int ruleID = 999001; assertSchemaHasDITStructureRule(ruleID, false); try { runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertSchemaHasDITStructureRule(ruleID, true); } finally { // delete in reverse order String ldif2 = toLdif( "dn: cn=schema", "changetype: modify", "delete: ditStructureRules", "ditStructureRules: ( 999001 " + "NAME 'testAddDITStructureRuleSuccessful' " + "FORM testAddDITStructureRuleSuccessfulNF " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "delete: nameForms", "nameForms: ( testaddditstructurerulesuccessfulnf-oid " + "NAME 'testAddDITStructureRuleSuccessfulNF' " + "OC testAddDITStructureRuleSuccessfulOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "-", "delete: objectClasses", "objectClasses: ( testaddditstructurerulesuccessfuloc-oid " + "NAME 'testAddDITStructureRuleSuccessfulOC' SUP top " + "STRUCTURAL MUST cn X-ORIGIN 'SchemaBackendTestCase')"); runModify(argsNotPermissive(), ldif2, System.err, SUCCESS); assertSchemaHasDITStructureRule(ruleID, false); } } private void assertSchemaHasDITStructureRule(int ruleID, boolean expected) { boolean hasDITStructureRule = DirectoryServer.getSchema().getSchemaNG().hasDITStructureRule(ruleID); assertEquals(hasDITStructureRule, expected, "Expected to find a DITStructureRule with ruleID " + ruleID); } /** * Tests the behavior of the schema backend when attempting to replace an * existing DIT structure rule definition. * * @throws Exception If an unexpected problem occurs. */ @Test public void testReplaceDITStructureRuleSuccessful() throws Exception { String ldif = toLdif( "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' )"); int ruleID = 999002; assertSchemaHasDITStructureRule(ruleID, false); runModify(argsPermissive(), ldif, System.err, SUCCESS); assertSchemaHasDITStructureRule(ruleID, true); } /** * Tests the behavior of the schema backend when attempting to add a new * DIT structure rule to an alternate schema file. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleToAltSchemaFile() throws Exception { String ldif = toLdif( "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' )"); int ruleID = 999010; assertSchemaHasDITStructureRule(ruleID, false); assertSchemaFileExists("98-schema-test-dsr.ldif", false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertSchemaHasDITStructureRule(ruleID, true); assertSchemaFileExists("98-schema-test-dsr.ldif", true); } /** * Tests the behavior of the schema backend when attempting to remove an * existing DIT structure rule definition and add it back in the same * operation. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAndAddDITStructureRuleSuccessful() throws Exception { String ldif = toLdif( "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' )"); int ruleID = 999003; assertSchemaHasDITStructureRule(ruleID, false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertSchemaHasDITStructureRule(ruleID, true); } /** * Tests the behavior of the schema backend when attempting to add a new * DIT structure rule with an undefined name form. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleUndefinedNameForm() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: ditStructureRules", "ditStructureRules: ( 999004 " + "NAME 'testAddDITStructureRuleUndefinedNameForm' " + "FORM xxxundefinedxxx " + "X-ORIGIN 'SchemaBackendTestCase' )"); int ruleID = 999004; assertSchemaHasDITStructureRule(ruleID, false); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertSchemaHasDITStructureRule(ruleID, false); } /** * Tests the behavior of the schema backend when attempting to add a new * DIT structure rule that references an undefined superior rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleUndefinedSuperior() throws Exception { String ldif = toLdif( "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' )"); int ruleID = 999005; assertSchemaHasDITStructureRule(ruleID, false); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); assertSchemaHasDITStructureRule(ruleID, false); } /** * Tests the addition of a new DITContentRule with a conflicting rule identifier. * * @throws Exception * If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleConflictingRuleID() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( 1.3.6.1.1.10.15.100 NAME 'domainNameForm' OC domain MUST ( dc ) )", "-", "add: dITStructureRules", "dITStructureRules: ( 1 NAME 'dummyStructureRule' FORM domainNameForm )"); runModify(argsNotPermissive(), ldif, ATTRIBUTE_OR_VALUE_EXISTS); } /** * Tests the addition of a new DITContentRule with a conflicting rule identifier. * * @throws Exception * If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleConflictingRuleIDWithPermissiveControl() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( 1.3.6.1.1.10.15.100 NAME 'domainNameForm' OC domain MUST ( dc ) )", "-", "add: dITStructureRules", "dITStructureRules: ( 1 NAME 'dummyStructureRule' FORM domainNameForm )"); runModify(argsPermissive(), ldif, UNWILLING_TO_PERFORM); } /** * Tests the behavior of the schema backend when attempting to add a new * DIT structure rule that references a name form which is OBSOLETE. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleObsoleteNameForm() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to add a new * DIT structure rule that references a superior rule which is OBSOLETE. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddDITStructureRuleObsoleteSuperiorRule() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * Tests the behavior of the schema backend when attempting to remove an * existing DIT structure rule definition. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveDITStructureRuleSuccessful() throws Exception { String ldif = toLdif( "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' )"); int ruleID = 999006; assertSchemaHasDITStructureRule(ruleID, false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertSchemaHasDITStructureRule(ruleID, false); } /** * Tests the behavior of the schema backend when attempting to remove an * existing DIT structure rule definition which is the superior rule for * another DIT structure rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveSuperiorDITStructureRule() throws Exception { String ldif = toLdif( "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' )"); int ruleID = 999007; assertSchemaHasDITStructureRule(ruleID, false); runModify(argsNotPermissive(), ldif, UNWILLING_TO_PERFORM); assertSchemaHasDITStructureRule(ruleID, true); ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertSchemaHasDITStructureRule(ruleID, false); } private MatchingRule getMatchingRule(String name, String oid, boolean isObsolete) { Schema schema = new SchemaBuilder(Schema.getCoreSchema()) .buildMatchingRule(oid) .syntaxOID(SchemaConstants.SYNTAX_DIRECTORY_STRING_OID) .names(name) .implementation(new SchemaTestMatchingRuleImpl()) .obsolete(isObsolete) .addToSchema().toSchema(); return schema.getMatchingRule(oid); } /** * 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 = registerNewMatchingRule("testAddMRUSuccessfulMatch", "1.3.6.1.4.1.26027.1.999.10", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertMatchingRuleUseExistsWithName(matchingRule, "testaddmrusuccessful"); } finally { deregisterMatchingRuleUse(matchingRule); deregisterMatchingRule(matchingRule); } } /** * 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 = registerNewMatchingRule("testAddMRUToAltSchemaFileMatch", "1.3.6.1.4.1.26027.1.999.18", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); assertSchemaFileExists("98-schema-test-mru.ldif", false); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertMatchingRuleUseExistsWithName(matchingRule, "testaddmrutoaltschemafile"); assertSchemaFileExists("98-schema-test-mru.ldif", true); } finally { deregisterMatchingRuleUse(matchingRule); deregisterMatchingRule(matchingRule); } } private File assertSchemaFileExists(String schemaFileName, boolean expectExists) { File schemaFile = new File(SchemaConfigManager.getSchemaDirectoryPath(), schemaFileName); assertEquals(schemaFile.exists(), expectExists); return schemaFile; } /** * 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 = registerNewMatchingRule("testReplaceMRUSuccessfulMatch", "1.3.6.1.4.1.26027.1.999.11", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsPermissive(), ldif, System.err, SUCCESS); assertMatchingRuleUseExistsWithName(matchingRule, "testreplacemrusuccessful"); } finally { deregisterMatchingRuleUse(matchingRule); deregisterMatchingRule(matchingRule); } } /** * 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 = registerNewMatchingRule("testRemoveAndAddMRUMatch", "1.3.6.1.4.1.26027.1.999.12", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertMatchingRuleUseExistsWithName(matchingRule, "testremoveandaddmru"); } finally { deregisterMatchingRuleUse(matchingRule); deregisterMatchingRule(matchingRule); } } /** * 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 = registerNewMatchingRule("testAddMRUMRConflictMatch", "1.3.6.1.4.1.26027.1.999.14", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, ATTRIBUTE_OR_VALUE_EXISTS); assertMatchingRuleUseExistsWithName(matchingRule, "testaddmrumrconflict"); } finally { deregisterMatchingRuleUse(matchingRule); deregisterMatchingRule(matchingRule); } } private void assertMatchingRuleUseExistsWithName(MatchingRule matchingRule, String mruName) { MatchingRuleUse mru = DirectoryServer.getSchema().getMatchingRuleUse(matchingRule); assertNotNull(mru); assertTrue(mru.hasName(mruName)); } /** * Tests the behavior of the schema backend when attempting to add a new * matching rule use that references an undefined matching rule. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddMatchingRuleUseMRUndefined() throws Exception { String ldif = toLdif( "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' )"); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } /** * 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 = registerNewMatchingRule("testAddMRUATUndefinedMatch", "1.3.6.1.4.1.26027.1.999.16", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } finally { deregisterMatchingRule(matchingRule); } } /** * 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 { MatchingRule matchingRule = registerNewMatchingRule("testAddMRUATMultipleUndefinedMatch", "1.3.6.1.4.1.26027.1.999.19", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } finally { deregisterMatchingRule(matchingRule); } } private void assertSchemaDoesNotHaveMatchingRuleUse(MatchingRule matchingRule) { for (MatchingRuleUse matchingRuleUse : DirectoryServer.getSchema().getMatchingRuleUses()) { assertFalse(matchingRuleUse.getMatchingRule().equals(matchingRule)); } } /** * 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 = registerNewMatchingRule("testAddMRUObsoleteMRMatch", "1.3.6.1.4.1.26027.1.999.21", true); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } finally { deregisterMatchingRule(matchingRule); } } /** * 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 = registerNewMatchingRule("testAddMRUObsoleteATMatch", "1.3.6.1.4.1.26027.1.999.22", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, CONSTRAINT_VIOLATION); } finally { deregisterAttributeType("testaddmruobsoleteat-oid"); deregisterMatchingRule(matchingRule); } } private MatchingRule registerNewMatchingRule(String name, String oid, boolean obsolete) throws DirectoryException { MatchingRule matchingRule = getMatchingRule(name, oid, obsolete); DirectoryServer.getSchema().registerMatchingRules(Arrays.asList(matchingRule), false); return matchingRule; } private void runModify(String[] args, String ldifContent, ResultCode expectedRC) { runModify(args, ldifContent, null, expectedRC); } private void runModify(String[] args, String ldifContent, PrintStream stderr, ResultCode expectedRC) { ByteArrayOutputStream output = new ByteArrayOutputStream(); int rc = runModify(args, ldifContent, new PrintStream(output), stderr); assertEquals(rc, expectedRC.intValue(), output.toString()); } private int runModify(String[] args, String ldifContent, PrintStream stdout, PrintStream stderr) { final InputStream stdin = System.in; try { System.setIn(new ByteArrayInputStream(ldifContent.getBytes())); return LDAPModify.mainModify(args, false, stdout, stderr); } finally { System.setIn(stdin); } } private String toLdif(Object... ldifLines) { return Utils.joinAsString("\n", ldifLines); } /** * 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 = registerNewMatchingRule("testRemoveMRUSuccessfulMatch", "1.3.6.1.4.1.26027.1.999.13", false); try { String ldif = toLdif( "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' )"); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); assertSchemaDoesNotHaveMatchingRuleUse(matchingRule); } finally { deregisterMatchingRule(matchingRule); } } /** * Tests the behavior of the schema backend when attempting to add another * value to attributeTypes that matches an existing one using the correct * matching rules. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAttributeTypesMatchingRule() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testattributetypesmatchingrule-oid " + "NAME 'testAttributeTypesMatchingRule' " + "EQUALITY booleanMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testattributetypesmatchingrule-oid " + "NAME 'testAttributeTypesMatchingRule' " + "EQUALITY caseIgnoreMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testattributetypesmatchingrule"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, System.err, ATTRIBUTE_OR_VALUE_EXISTS); } /** * Tests the behavior of the schema backend when attempting to add another * value to objectClasses that matches an existing one using the correct * matching rules. * * @throws Exception If an unexpected problem occurs. */ @Test public void testObjectClassesMatchingRule() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testobjectclassesmatchingrule-oid " + "NAME 'testObjectClassesMatchingRule' " + "SUP top STRUCTURAL MAY cn " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testobjectclassesmatchingrule-oid " + "NAME 'testObjectClassesMatchingRule' " + "SUP top AUXILIARY MAY mail " + "X-ORIGIN 'SchemaBackendTestCase' )"); String objectClassName = "testobjectclassesmatchingrule"; assertFalse(DirectoryServer.getSchema().hasObjectClass(objectClassName)); runModify(argsNotPermissive(), ldif, System.err, ATTRIBUTE_OR_VALUE_EXISTS); } /** * Tests the behavior of the schema backend when attempting to add another * value to nameForms that matches an existing one using the correct * matching rules. * * @throws Exception If an unexpected problem occurs. */ @Test public void testNameFormsMatchingRule() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testnameformsmatchingruleoc-oid " + "NAME 'testNameFormsMatchingRuleOC' " + "SUP top STRUCTURAL MAY ( cn $ mail ) " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( testnameformsmatchingrule-oid " + "NAME 'testNameFormsMatchingRule' " + "OC testNameFormsMatchingRuleOC MUST mail " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( testnameformsmatchingrule-oid " + "NAME 'testNameFormsMatchingRule' " + "OC testNameFormsMatchingRuleOC MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String nameFormName = "testnameformsmatchingrule"; assertFalse(DirectoryServer.getSchema().hasNameForm(nameFormName)); runModify(argsNotPermissive(), ldif, System.err, ATTRIBUTE_OR_VALUE_EXISTS); } /** * Tests the behavior of the schema backend when attempting to add another * value to dITContentRules that matches an existing one using the correct * matching rules. * * @throws Exception If an unexpected problem occurs. */ @Test public void testDitContentRulesMatchingRule() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testditcontentrulesmatchingrule-oid " + "NAME 'testDitContentRulesMatchingRuleOC' " + "SUP top STRUCTURAL MAY ( cn $ mail ) " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: dITContentRules", "dITContentRules: ( testditcontentrulesmatchingrule-oid " + "NAME 'testDitContentRulesMatchingRule' " + "MUST mail " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: dITContentRules", "dITContentRules: ( testditcontentrulesmatchingrule-oid " + "NAME 'testDitContentRulesMatchingRule' " + "MUST cn " + "X-ORIGIN 'SchemaBackendTestCase' )"); String objectClassName = "testditcontentrulesmatchingruleoc"; assertTrue(DirectoryServer.getSchema().getObjectClass(objectClassName).isPlaceHolder()); runModify(argsNotPermissive(), ldif, System.err, ATTRIBUTE_OR_VALUE_EXISTS); } /** * Tests the behavior of the schema backend when attempting to add another * value to dITStructureRules that matches an existing one using the correct * matching rules. * * @throws Exception If an unexpected problem occurs. */ @Test public void testDitStructureRulesMatchingRule() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testditstructurerulesmatchingruleoc1-oid " + "NAME 'testDitStructureRulesMatchingRuleOC1' " + "SUP top STRUCTURAL MAY ( cn $ mail ) " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testditstructurerulesmatchingruleoc2-oid " + "NAME 'testDitStructureRulesMatchingRuleOC2' " + "SUP top STRUCTURAL MAY ( cn $ mail ) " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( testditstructurerulesmatchingrulenf1-oid " + "NAME 'testDitStructureRulesMatchingRuleNF1' " + "OC testDitStructureRulesMatchingRuleOC1 MUST mail " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: nameForms", "nameForms: ( testditstructurerulesmatchingrulenf2-oid " + "NAME 'testDitStructureRulesMatchingRuleNF2' " + "OC testDitStructureRulesMatchingRuleOC2 MUST mail " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: dITStructureRules", "dITStructureRules: ( 999666 " + "NAME 'testDitStructureRulesMatchingRule' " + "FORM testDitStructureRulesMatchingRuleNF1 " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: dITStructureRules", "dITStructureRules: ( 999666 " + "NAME 'testDitStructureRulesMatchingRule' " + "FORM testDitStructureRulesMatchingRuleNF2 " + "X-ORIGIN 'SchemaBackendTestCase' )"); String objectClassName = "testditcontentrulesmatchingruleoc1"; assertTrue(DirectoryServer.getSchema().getObjectClass(objectClassName).isPlaceHolder()); runModify(argsNotPermissive(), ldif, System.err, ATTRIBUTE_OR_VALUE_EXISTS); } /** * Tests the behavior of the schema backend when attempting to add another * value to matchingRuleUse that matches an existing one using the correct * matching rules. * * @throws Exception If an unexpected problem occurs. */ @Test public void testMatchingRuleUseMatchingRule() throws Exception { String ldif = toLdif( "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testmatchingruleusematchingruleat1-oid " + "NAME 'testMatchingRuleUseMatchingRuleAT1' " + "EQUALITY caseIgnoreMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: attributeTypes", "attributeTypes: ( testmatchingruleusematchingruleat2-oid " + "NAME 'testMatchingRuleUseMatchingRuleAT2' " + "EQUALITY caseIgnoreMatch SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: matchingRuleUse", "matchingRuleUse: ( booleanMatch " + "NAME 'testMatchingRuleUseMatchingRule' " + "APPLIES testMatchingRuleUseMatchingRuleAT1 " + "X-ORIGIN 'SchemaBackendTestCase' )", "", "dn: cn=schema", "changetype: modify", "add: matchingRuleUse", "matchingRuleUse: ( booleanMatch " + "NAME 'testMatchingRuleUseMatchingRule' " + "APPLIES testMatchingRuleUseMatchingRuleAT2 " + "X-ORIGIN 'SchemaBackendTestCase' )"); String attrName = "testmatchingruleusematchingruleat1"; assertFalse(DirectoryServer.getSchema().hasAttributeType(attrName)); runModify(argsNotPermissive(), ldif, System.err, ATTRIBUTE_OR_VALUE_EXISTS); } /** * 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: * *
    *
  1. Delete an existing object class
    2. *
  2. Add a new attribute type
    3. *
  3. Add a new object class (different from the one that was removed) that * depends on the new attribute type
    4. *
* * The problem was that in the process of removing the object class in step 1, * the server checks to see if the same object class is going to be re-added * again later. It does that by looking through the remaining modifications * in the operation and for each modification that would add a new object * class we decode it to see if it has the same OID. The process of decoding * that object class would fail because it depended on a new attribute type * that wasn't yet defined in the schema, and the server wasn't told to ignore * missing schema elements. * * @throws Exception If an unexpected problem occurs. */ @Test public void testRemoveAndAddObjectClassIssue1318() throws Exception { String ldif = toLdif( "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' SUP name)", "-", "add: objectClasses", "objectClasses: ( testissue1318oc2-oid NAME 'testIssue1381OC2' " + "MUST testIssue1381AT )"); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); } /** * Tests to ensure that the schema subentry includes the lastmod attributes * and that the modifiersName and modifyTimestamp attributes get updated when * the schema is modified. * * @throws Exception If an unexpected problem occurs. */ @Test public void testLastModAttributes() throws Exception { Entry schemaEntry = DirectoryServer.getEntry(DN.valueOf("cn=schema")); assertNotNull(schemaEntry); AttributeType cnType = getCreatorsNameAttributeType(); AttributeType ctType = getCreateTimestampAttributeType(); AttributeType mnType = getModifiersNameAttributeType(); AttributeType mtType = getModifyTimestampAttributeType(); assertTrue(schemaEntry.hasAttribute(cnType)); assertTrue(schemaEntry.hasAttribute(ctType)); assertTrue(schemaEntry.hasAttribute(mnType)); assertTrue(schemaEntry.hasAttribute(mtType)); ByteString oldMTValue = schemaEntry.getAttribute(mtType).get(0).iterator().next(); String ldif = toLdif( "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' )"); // Sleep longer than the TimeThread delay to ensure the modifytimestamp // will be different. Thread.sleep(6000); runModify(argsNotPermissive(), ldif, System.err, SUCCESS); schemaEntry = DirectoryServer.getEntry(DN.valueOf("cn=schema")); assertNotNull(schemaEntry); assertTrue(schemaEntry.hasAttribute(cnType)); assertTrue(schemaEntry.hasAttribute(ctType)); assertTrue(schemaEntry.hasAttribute(mnType)); assertTrue(schemaEntry.hasAttribute(mtType)); ByteString newMTValue = schemaEntry.getAttribute(mtType).get(0).iterator().next(); assertNotEquals(oldMTValue, newMTValue); } /** * Tests the ability to properly handle adding and removing a schema * definition in which the definition has extra spaces. This was added as a * test case for issue #2171. * * @throws Exception If an unexpected problem occurs. */ @Test public void testAddAndDeleteDefinitionWithExtraSpaces() throws Exception { int resultCode = TestCaseUtils.applyModifications(false, "dn: cn=schema", "changetype: modify", "add: objectClasses", "objectClasses: ( testaddanddeletedefinitionwithextraspaces-oid", " NAME 'testAddAndDeleteDefinitionWithExtraSpaces' SUP person", " MAY ( street $ c) X-ORIGIN 'user defined' )"); assertEquals(resultCode, 0); assertFalse(getSchema().getObjectClass("testaddanddeletedefinitionwithextraspaces").isPlaceHolder()); assertFalse(getSchema().getObjectClass("testaddanddeletedefinitionwithextraspaces-oid").isPlaceHolder()); resultCode = TestCaseUtils.applyModifications(false, "dn: cn=schema", "changetype: modify", "delete: objectClasses", "objectClasses: ( testaddanddeletedefinitionwithextraspaces-oid", " NAME 'testAddAndDeleteDefinitionWithExtraSpaces' SUP person", " MAY ( street $ c) X-ORIGIN 'user defined' )"); assertEquals(resultCode, 0); assertTrue(getSchema().getObjectClass("testaddanddeletedefinitionwithextraspaces").isPlaceHolder()); assertTrue(getSchema().getObjectClass("testaddanddeletedefinitionwithextraspaces-oid").isPlaceHolder()); } /** * Tests the {@code exportLDIF} method with a valid configuration. * * @throws Exception If an unexpected problem occurs. */ @Test public void testExportLDIF() throws Exception { File tempFile = File.createTempFile("schema", "testExportLDIF"); tempFile.deleteOnExit(); LDIFExportConfig exportConfig = new LDIFExportConfig(tempFile.getAbsolutePath(), OVERWRITE); schemaBackend.exportLDIF(exportConfig); assertTrue(tempFile.exists()); assertTrue(tempFile.length() > 0); } /** * Tests the {@code importLDIF} method to ensure that it throws an exception. * * @throws Exception If an unexpected problem occurs. */ @Test public void testImportLDIFFails() throws Exception { File tempFile = File.createTempFile("schema", "testImportLDIFFails"); tempFile.deleteOnExit(); LDIFExportConfig exportConfig = new LDIFExportConfig(tempFile.getAbsolutePath(), OVERWRITE); schemaBackend.exportLDIF(exportConfig); ServerContext serverContext = DirectoryServer.getInstance().getServerContext(); LDIFImportConfig importConfig = new LDIFImportConfig(tempFile.getAbsolutePath()); LDIFImportResult importResult = schemaBackend.importLDIF(importConfig, serverContext); assertEquals(importResult.getEntriesRead(), 1); assertEquals(importResult.getEntriesImported(), 0); assertEquals(importResult.getEntriesRejected(), 1); assertEquals(importResult.getEntriesSkipped(), 0); } @Test public void testImportLDIFSuccess() throws Exception { File tempFile = File.createTempFile("schema", "testImportLDIFSucceeds"); tempFile.deleteOnExit(); LDIFExportConfig exportConfig = new LDIFExportConfig(tempFile.getAbsolutePath(), OVERWRITE); schemaBackend.exportLDIF(exportConfig); // replication does not validate schema LDIFImportConfig importConfig = new LDIFImportConfig(tempFile.getAbsolutePath()); importConfig.setValidateSchema(false); ServerContext serverContext = DirectoryServer.getInstance().getServerContext(); LDIFImportResult importResult = schemaBackend.importLDIF(importConfig, serverContext); assertEquals(importResult.getEntriesRead(), 1); assertEquals(importResult.getEntriesImported(), 1); assertEquals(importResult.getEntriesRejected(), 0); assertEquals(importResult.getEntriesSkipped(), 0); } /** * Tests the {@code getComponentEntryDN} method. * * @throws Exception If an unexpected problem occurs. */ @Test public void testGetComponentEntryDN() throws Exception { DN configEntryDN = DN.valueOf("ds-cfg-backend-id=schema,cn=Backends,cn=config"); assertEquals(schemaBackend.getComponentEntryDN(), configEntryDN); } /** Tests the {@code getClassName} method. */ @Test public void testGetClassName() { assertEquals(schemaBackend.getClassName(), SchemaBackend.class.getName()); } /** Tests the {@code getAlerts} method. */ @Test public void testGetAlerts() { Map alerts = schemaBackend.getAlerts(); assertNotNull(alerts); assertFalse(alerts.isEmpty()); } }