/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*/
package org.apache.directory.server.core.schema;
import static org.apache.directory.server.core.integ.IntegrationUtils.getSchemaContext;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.BasicAttribute;
import javax.naming.directory.DirContext;
import javax.naming.directory.ModificationItem;
import javax.naming.ldap.LdapContext;
import org.apache.directory.server.core.integ.FrameworkRunner;
import org.apache.directory.server.core.integ.IntegrationUtils;
import org.apache.directory.shared.ldap.constants.MetaSchemaConstants;
import org.apache.directory.shared.ldap.constants.SchemaConstants;
import org.apache.directory.shared.ldap.exception.LdapNameNotFoundException;
import org.apache.directory.shared.ldap.exception.LdapOperationNotSupportedException;
import org.apache.directory.shared.ldap.ldif.LdifUtils;
import org.apache.directory.shared.ldap.message.ResultCodeEnum;
import org.apache.directory.shared.ldap.name.DN;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
/**
* A test case which tests the correct operation of the schema entity handler.
* <br>
* We have many things to check. Here is a list of what we want to control :
* <ul>
* <li>Enabling Schema</li>
* <ul>
* <li>an existing schema</li>
* <li>a non existing schema</li>
* <li>an already enabled Schema</li>
* <li>an existing schema which will break the Registries when enabled</li>
* </ul>
* <li>Disabling Schema</li>
* <ul>
* <li>an already disabled Schema</li>
* <li>an existing schema</li>
* <li>an existing schema which will break the Registries when disabled</li>
* <li>a non existing schema</li>
* </ul>
* </ul>
* <ul>
* <li>Adding a new schema</li>
* <ul>
* <li>enabled schema</li>
* <ul>
* <li>Adding a new enabled valid schema with no deps</li>
* <li>Adding a new enabled schema with existing deps</li>
* <li>Adding a new enabled schema with non existing deps</li>
* <li>Adding a new enabled schema with an already existing name</li>
* <li>Adding a new enabled schema with deps on disabled schema</li>
* </ul>
* <li>disabled schema</li>
* <ul>
* <li>Adding a new disabled valid schema with no deps</li>
* <li>Adding a new disabled schema with existing deps</li>
* <li>Adding a new disabled schema with non existing deps</li>
* <li>Adding a new disabled schema with an already existing name</li>
* <li>Adding a new disabled schema with deps on disabled schema</li>
* </ul>
* </ul>
* </ul>
*
* @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
* @version $Rev$
*/
@RunWith(FrameworkRunner.class)
public class MetaSchemaHandlerIT extends AbstractMetaSchemaObjectHandler
{
/** a test attribute in the test schema: uidNumber in nis schema */
private static final String UID_NUMBER_ATTR = "uidnumber";
/** Another test attribute : krb5principalName taken from the Krb5Kdc schema */
private static final String KRB5_PRINCIPAL_NAME_ATTR = "krb5PrincipalName";
@Before
public void checkSambaSchema() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
// check that there is a samba schema installed and that is is disabled
Attributes attributes = schemaRoot.getAttributes( "cn=samba" );
assertNotNull( attributes );
assertTrue( attributes.get( MetaSchemaConstants.M_DISABLED_AT ).contains( "TRUE" ) );
attributes = schemaRoot.getAttributes( "ou=attributeTypes,cn=samba" );
assertNotNull( attributes );
assertTrue( attributes.get( SchemaConstants.OU_AT ).contains( "attributetypes" ) );
// Disable the NIS schema
IntegrationUtils.disableSchema( service, "nis" );
}
private void createDisabledBrokenSchema() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
// Create the schema
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: broken",
MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
schemaRoot.createSubcontext( "cn=broken", dummySchema );
}
private void createEnabledValidSchema( String schemaName ) throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
// Create the schema
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn", schemaName );
schemaRoot.createSubcontext( "cn=" + schemaName, dummySchema );
}
// -----------------------------------------------------------------------
// Enabling Schema tests
// -----------------------------------------------------------------------
/**
* Checks to make sure updates enabling a metaSchema object in
* the schema partition triggers the loading of that schema into
* the global registries.
*
* @throws Exception on error
*/
@Test
public void testEnableExistingSchema() throws Exception
{
// Chck that the nis schema is loaded
assertTrue( IntegrationUtils.isLoaded( service, "nis" ) );
// check that the nis schema is not enabled
assertTrue( IntegrationUtils.isDisabled( service, "nis" ) );
// double check and make sure an attribute from that schema is
// not in the AttributeTypeRegistry
assertFalse( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
// now enable the test schema
IntegrationUtils.enableSchema( service, "nis" );
// now test that the schema is loaded
assertTrue( IntegrationUtils.isEnabled( service, "nis" ) );
// double check and make sure the test attribute from the
// test schema is now loaded and present within the attr registry
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
}
/**
* Checks that trying to enable a non existing schema does not work
*
* @throws Exception on error
*/
@Test
public void testEnableNotExistingSchema() throws Exception
{
// check that the 'wrong' schema is not loaded
assertFalse( IntegrationUtils.isLoaded( service, "wrong" ) );
// now enable the 'wrong' schema
try
{
IntegrationUtils.enableSchema( service, "wrong" );
fail();
}
catch ( LdapNameNotFoundException lnnfe )
{
// Expected
assertTrue( true );
}
// Test again that the schema is not loaded
assertFalse( IntegrationUtils.isLoaded( service, "wrong" ) );
}
/**
* Checks to make sure that if we try to enable an already enabled
* schema, we don't do anything.
*
* @throws Exception on error
*/
@Test
public void testEnableSchemaAlreadyEnabled() throws Exception
{
// check that the nis schema is loaded
assertTrue( IntegrationUtils.isLoaded( service, "nis" ) );
// Ceck that it's not enabled
assertTrue( IntegrationUtils.isDisabled( service, "nis" ) );
// double check and make sure an attribute from that schema is
// not in the AttributeTypeRegistry
assertFalse( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
// now enable the test schema
IntegrationUtils.enableSchema( service, "nis" );
// and enable it again (it should not do anything)
IntegrationUtils.enableSchema( service, "nis" );
// now test that the schema is loaded
assertTrue( IntegrationUtils.isEnabled( service, "nis" ) );
// double check and make sure the test attribute from the
// test schema is now loaded and present within the attr registry
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
}
/**
* Checks that if we enable a schema which will break the registries, we get
* an error.
*
* @throws Exception on error
*/
@Test
public void testEnableSchemaBreakingRegistries() throws Exception
{
// TODO : create a special Schema colliding with an existing one
}
// -----------------------------------------------------------------------
// Disabling Schema tests
// -----------------------------------------------------------------------
/**
* Checks to make sure updates disabling a metaSchema object in
* the schema partition triggers the loading of that schema into
* the global registries.
*
* @throws Exception on error
*/
@Test
public void testDisableExistingSchema() throws Exception
{
// Check that the krb5kdc schema is loaded
assertTrue( IntegrationUtils.isLoaded( service, "krb5kdc" ) );
// check that the krb5kdc schema is enabled
assertTrue( IntegrationUtils.isEnabled( service, "krb5kdc" ) );
// double check and make sure an attribute from that schema is
// in the AttributeTypeRegistry
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( KRB5_PRINCIPAL_NAME_ATTR ) );
// now disable the krb5kdc schema
IntegrationUtils.disableSchema( service, "krb5kdc" );
// now test that the schema is not enabled
assertTrue( IntegrationUtils.isDisabled( service, "krb5kdc" ) );
// double check and make sure the test attribute from the
// test schema is now loaded and present within the attr registry
assertFalse( service.getSchemaManager().getAttributeTypeRegistry().contains( KRB5_PRINCIPAL_NAME_ATTR ) );
}
/**
* Checks that trying to disable a non existing schema does not work
*
* @throws Exception on error
*/
@Test
public void testDisableNotExistingSchema() throws Exception
{
// check that the 'wrong' schema is not loaded
assertFalse( IntegrationUtils.isLoaded( service, "wrong" ) );
// now disable the 'wrong' schema
try
{
IntegrationUtils.disableSchema( service, "wrong" );
fail();
}
catch ( LdapNameNotFoundException lnnfe )
{
// Expected
assertTrue( true );
}
// Test again that the schema is not loaded
assertFalse( IntegrationUtils.isLoaded( service, "wrong" ) );
}
/**
* Checks to make sure that if we try to disable an already disabled
* schema, we don't do anything.
*
* @throws Exception on error
*/
@Test
public void testDisableSchemaAlreadyDisabled() throws Exception
{
// check that the nis schema is loaded
assertTrue( IntegrationUtils.isLoaded( service, "nis" ) );
// Check that it's not enabled
assertTrue( IntegrationUtils.isDisabled( service, "nis" ) );
// double check and make sure an attribute from that schema is
// not in the AttributeTypeRegistry
assertFalse( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
// now disable the test schema again
IntegrationUtils.disableSchema( service, "nis" );
// now test that the schema is not loaded
assertTrue( IntegrationUtils.isDisabled( service, "nis" ) );
// double check and make sure the test attribute from the
// test schema is not loaded and present within the attr registry
assertFalse( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
}
/**
* Checks that if we disable a schema which will break the registries, we get
* an error.
*
* @throws Exception on error
*/
@Test
public void testDisableSchemaBreakingRegistries() throws Exception
{
// check that the nis schema is loaded
assertTrue( IntegrationUtils.isLoaded( service, "system" ) );
// Check that it's enabled
assertTrue( IntegrationUtils.isEnabled( service, "system" ) );
// double check and make sure an attribute from that schema is
// in the AttributeTypeRegistry
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( "cn" ) );
// now disable the system schema : it should break the registries, thus being rejected
IntegrationUtils.disableSchema( service, "system" );
// now test that the schema is not loaded
assertTrue( IntegrationUtils.isEnabled( service, "system" ) );
// double check and make sure the test attribute from the
// test schema is loaded and present within the attr registry
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( "cn" ) );
}
// -----------------------------------------------------------------------
// Schema Add Tests
// -----------------------------------------------------------------------
/**
* Add a valid and enabled schema
*/
@Test
public void testAddEnabledValidSchema() throws Exception
{
DN dn = getSchemaContainer( "dummy" );
assertFalse( isOnDisk( dn ) );
LdapContext schemaRoot = getSchemaContext( service );
createEnabledValidSchema( "dummy" );
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
assertNotNull( schemaRoot.lookup( "cn=dummy" ) );
assertTrue( isOnDisk( dn ) );
}
/**
* Add a valid and enabled schema with existing enabled deps
*/
@Test
public void testAddEnabledSchemaWithExistingEnabledDeps() throws Exception
{
DN dn = getSchemaContainer( "dummy" );
assertFalse( isOnDisk( dn ) );
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
"m-dependencies: core",
"m-dependencies: system",
MetaSchemaConstants.M_DISABLED_AT, "FALSE" );
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
assertNotNull( schemaRoot.lookup( "cn=dummy" ) );
assertTrue( isOnDisk( dn ) );
}
/**
* Add a valid and enabled schema with existing disabled deps. It should not be loaded.
*/
@Test
public void testAddEnabledSchemaWithExistingDisabledDeps() throws Exception
{
DN dn = getSchemaContainer( "dummy" );
assertFalse( isOnDisk( dn ) );
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
"m-dependencies: core",
"m-dependencies: nis",
MetaSchemaConstants.M_DISABLED_AT, "FALSE" );
try
{
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
fail();
}
catch ( LdapOperationNotSupportedException lonse )
{
assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, lonse.getResultCode() );
}
assertFalse( IntegrationUtils.isLoaded( service, "dummy" ) );
assertFalse( isOnDisk( dn ) );
}
/**
* Add a valid and enabled schema with not existing deps. It should not be loaded.
*/
@Test
public void testAddEnabledSchemaWithNotExistingDeps() throws Exception
{
DN dn = getSchemaContainer( "dummy" );
assertFalse( isOnDisk( dn ) );
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
"m-dependencies: core",
"m-dependencies: wrong",
MetaSchemaConstants.M_DISABLED_AT, "FALSE" );
try
{
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
fail();
}
catch ( LdapOperationNotSupportedException lonse )
{
assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, lonse.getResultCode() );
}
assertFalse( IntegrationUtils.isLoaded( service, "dummy" ) );
assertFalse( isOnDisk( dn ) );
}
// -----------------------------------------------------------------------
// Schema Delete Tests
// -----------------------------------------------------------------------
/**
* Delete a valid and enabled schema
*/
@Test
public void testDeleteEnabledValidSchema() throws Exception
{
DN dn = getSchemaContainer( "dummy" );
LdapContext schemaRoot = getSchemaContext( service );
// Create a schema we will delete
createEnabledValidSchema( "dummy" );
assertTrue( isOnDisk( dn ) );
assertTrue( IntegrationUtils.isLoaded( service, "dummy" ) );
// Delete the schema
schemaRoot.destroySubcontext( "cn=dummy" );
assertFalse( isOnDisk( dn ) );
assertFalse( IntegrationUtils.isLoaded( service, "dummy" ) );
}
/**
* Tests the addition of a new metaSchema object that is disabled
* on addition and has no dependencies.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testAddDisabledSchemaNoDeps() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
assertFalse( IntegrationUtils.isEnabled( service, "dummy" ) );
assertNotNull( schemaRoot.lookup( "cn=dummy" ) );
}
/**
* Tests the addition of a new metaSchema object that is disabled
* on addition and has dependencies.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testAddDisabledSchemaWithDeps() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
MetaSchemaConstants.M_DISABLED_AT, "TRUE",
"m-dependencies: nis",
"m-dependencies: core" );
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
assertFalse( IntegrationUtils.isEnabled( service, "dummy" ) );
assertNotNull( schemaRoot.lookup( "cn=dummy" ) );
}
/**
* Tests the rejection of a new metaSchema object that is disabled
* on addition and has missing dependencies.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testRejectDisabledSchemaAddWithMissingDeps() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
MetaSchemaConstants.M_DISABLED_AT, "TRUE",
"m-dependencies: missing",
"m-dependencies: core" );
try
{
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
}
catch( LdapOperationNotSupportedException e )
{
assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
}
assertFalse( IntegrationUtils.isEnabled( service, "dummy" ) );
//noinspection EmptyCatchBlock
try
{
schemaRoot.lookup( "cn=dummy" );
fail( "schema should not be added to schema partition" );
}
catch( NamingException e )
{
}
}
/**
* Tests the addition of a new metaSchema object that is enabled
* on addition and has no dependencies.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testAddEnabledSchemaNoDeps() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass: metaSchema",
"cn: dummy"
);
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
assertNotNull( schemaRoot.lookup( "cn=dummy" ) );
}
/**
* Tests the rejection of a metaSchema object add that is enabled
* on addition yet has disabled dependencies.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testRejectEnabledSchemaAddWithDisabledDeps() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
"m-dependencies: nis" );
try
{
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
fail( "should not be able to add enabled schema with deps on disabled schemas" );
}
catch( LdapOperationNotSupportedException e )
{
assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
}
assertFalse( IntegrationUtils.isEnabled( service, "dummy" ) );
//noinspection EmptyCatchBlock
try
{
schemaRoot.lookup( "cn=dummy" );
fail( "schema should not be added to schema partition" );
}
catch( NamingException e )
{
}
}
// -----------------------------------------------------------------------
// Schema Delete Tests
// -----------------------------------------------------------------------
/**
* Makes sure we can delete schemas that have no dependents.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testDeleteSchemaNoDependents() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
// add the dummy schema enabled
testAddEnabledSchemaNoDeps();
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
// delete it now
schemaRoot.destroySubcontext( "cn=dummy" );
assertFalse( IntegrationUtils.isEnabled( service, "dummy" ) );
}
/**
* Makes sure we can NOT delete schemas that have dependents.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testRejectSchemaDeleteWithDependents() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
// add the dummy schema enabled
testAddEnabledSchemaNoDeps();
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
// make the nis schema depend on the dummy schema
ModificationItem[] mods = new ModificationItem[1];
mods[0] = new ModificationItem( DirContext.ADD_ATTRIBUTE,
new BasicAttribute( "m-dependencies", "dummy" ) );
schemaRoot.modifyAttributes( "cn=nis", mods );
// attempt to delete it now & it should fail
try
{
schemaRoot.destroySubcontext( "cn=dummy" );
fail( "should not be able to delete a schema with dependents" );
}
catch ( LdapOperationNotSupportedException e )
{
assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
}
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
}
/**
* Tests the rejection of a new metaSchema object that is enabled
* on addition and missing dependencies.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testRejectEnabledSchemaAddWithMisingDeps() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
"m-dependencies: missing" );
try
{
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
fail( "should not be able to add enabled schema with deps on missing schemas" );
}
catch( LdapOperationNotSupportedException e )
{
assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
}
assertFalse( IntegrationUtils.isEnabled( service, "dummy" ) );
//noinspection EmptyCatchBlock
try
{
schemaRoot.lookup( "cn=dummy" );
fail( "schema should not be added to schema partition" );
}
catch( NamingException e )
{
}
}
/**
* Checks to make sure updates disabling a metaSchema object in
* the schema partition triggers the unloading of that schema from
* the global registries.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testDisableSchemaWithEnabledDependents() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
// let's enable the test schema and add the dummy schema
// as enabled by default and dependends on the test schema
// enables the test schema and samba
testEnableExistingSchema();
// adds enabled dummy schema that depends on the test schema
Attributes dummySchema = LdifUtils.createAttributes(
"objectClass: top",
"objectClass", MetaSchemaConstants.META_SCHEMA_OC,
"cn: dummy",
"m-dependencies: nis" );
schemaRoot.createSubcontext( "cn=dummy", dummySchema );
// check that the nis schema is loaded and the dummy schema is loaded
assertTrue( IntegrationUtils.isEnabled( service, "nis" ) );
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
// double check and make sure an attribute from that schema is
// in the AttributeTypeRegistry
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
// now try to disable the test schema which should fail
// since it's dependent, the dummy schema, is enabled
ModificationItem[] mods = new ModificationItem[1];
Attribute attr = new BasicAttribute( "m-disabled", "TRUE" );
mods[0] = new ModificationItem( DirContext.REPLACE_ATTRIBUTE, attr );
try
{
schemaRoot.modifyAttributes( "cn=nis", mods );
fail( "attempt to disable schema with enabled dependents should fail" );
}
catch ( LdapOperationNotSupportedException e )
{
assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
}
// now test that both schema are still loaded
assertTrue( IntegrationUtils.isEnabled( service, "nis" ) );
assertTrue( IntegrationUtils.isEnabled( service, "dummy" ) );
// double check and make sure the test attribute from the test
// schema is still loaded and present within the attr registry
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( UID_NUMBER_ATTR ) );
}
// -----------------------------------------------------------------------
// Schema Rename Tests
// -----------------------------------------------------------------------
/**
* Makes sure we can change the name of a schema with entities in it.
* Will use the samba schema which comes out of the box and nothing
* depends on.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testSchemaRenameDisabledSchema() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
schemaRoot.rename( "cn=samba", "cn=foo" );
assertNotNull( schemaRoot.lookup( "cn=foo" ) );
// check that there is a samba schema installed and that is is disabled
Attributes attributes = schemaRoot.getAttributes( "cn=foo" );
assertNotNull( attributes );
assertTrue( attributes.get( MetaSchemaConstants.M_DISABLED_AT ).contains( "TRUE" ) );
attributes = schemaRoot.getAttributes( "ou=attributeTypes,cn=foo" );
assertNotNull( attributes );
assertTrue( attributes.get( SchemaConstants.OU_AT ).contains( "attributetypes" ) );
//noinspection EmptyCatchBlock
try
{
schemaRoot.lookup( "cn=samba" );
fail( "the samba schema should not be present after a rename to foo" );
}
catch( LdapNameNotFoundException e )
{
}
}
/**
* Makes sure we can NOT change the name of a schema that has dependents.
* Will use the nis schema which comes out of the box and has samba as
* it's dependent.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testRejectSchemaRenameWithDeps() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
try
{
schemaRoot.rename( "cn=nis", "cn=foo" );
fail( "should not be able to rename nis which has samba as it's dependent" );
}
catch ( LdapOperationNotSupportedException e )
{
assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, e.getResultCode() );
}
assertNotNull( schemaRoot.lookup( "cn=nis" ) );
//noinspection EmptyCatchBlock
try
{
schemaRoot.lookup( "cn=foo" );
fail( "the foo schema should not be present after rejecting the rename" );
}
catch( LdapNameNotFoundException e )
{
}
}
/**
* Makes sure we can change the name of a schema with entities in it.
* Will use the samba schema which comes out of the box and nothing
* depends on.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testSchemaRenameEnabledSchema() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
IntegrationUtils.enableSchema( service, "samba" );
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( "sambaNTPassword" ) );
assertEquals( "samba", service.getSchemaManager().getAttributeTypeRegistry().getSchemaName( "sambaNTPassword" ) );
schemaRoot.rename( "cn=samba", "cn=foo" );
assertNotNull( schemaRoot.lookup( "cn=foo" ) );
assertTrue( service.getSchemaManager().getAttributeTypeRegistry().contains( "sambaNTPassword" ) );
assertEquals( "foo", service.getSchemaManager().getAttributeTypeRegistry().getSchemaName( "sambaNTPassword" ) );
//noinspection EmptyCatchBlock
try
{
schemaRoot.lookup( "cn=samba" );
fail( "the samba schema should not be present after a rename to foo" );
}
catch( LdapNameNotFoundException e )
{
}
}
// -----------------------------------------------------------------------
// Dependency Modify Tests
// -----------------------------------------------------------------------
/**
* Checks to make sure the addition of an undefined schema to the dependencies
* of an existing schema fail with an UNWILLING_TO_PERFORM result code.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testRejectAddBogusDependency() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
ModificationItem[] mods = new ModificationItem[1];
Attribute attr = new BasicAttribute( "m-dependencies", "bogus" );
mods[0] = new ModificationItem( DirContext.ADD_ATTRIBUTE, attr );
try
{
schemaRoot.modifyAttributes( "cn=nis", mods );
fail( "Should not be able to add bogus dependency to schema" );
}
catch ( LdapOperationNotSupportedException e )
{
assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, e.getResultCode() );
}
}
/**
* Checks to make sure the addition of an defined yet disabled schema to the
* dependencies of an existing enabled schema fails with an UNWILLING_TO_PERFORM
* result code. You must enable the dependency to add it or disable the schema
* depending on it to add it.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testRejectAddOfDisabledDependencyToEnabledSchema() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
IntegrationUtils.enableSchema( service, "nis" );
ModificationItem[] mods = new ModificationItem[1];
Attribute attr = new BasicAttribute( "m-dependencies", "mozilla" );
mods[0] = new ModificationItem( DirContext.ADD_ATTRIBUTE, attr );
try
{
schemaRoot.modifyAttributes( "cn=nis", mods );
fail( "Should not be able to add disabled dependency to schema" );
}
catch ( LdapOperationNotSupportedException e )
{
assertEquals( ResultCodeEnum.UNWILLING_TO_PERFORM, e.getResultCode() );
}
}
/**
* Checks to make sure the addition of an defined yet disabled schema to the
* dependencies of an existing disabled schema succeeds.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testAddOfDisabledDependencyToDisabledSchema() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
ModificationItem[] mods = new ModificationItem[1];
Attribute attr = new BasicAttribute( "m-dependencies", "mozilla" );
mods[0] = new ModificationItem( DirContext.ADD_ATTRIBUTE, attr );
schemaRoot.modifyAttributes( "cn=nis", mods );
Attributes attrs = schemaRoot.getAttributes( "cn=nis" );
Attribute dependencies = attrs.get( "m-dependencies" );
assertTrue( dependencies.contains( "mozilla" ) );
}
/**
* Checks to make sure the addition of an defined yet enabled schema to the
* dependencies of an existing disabled schema succeeds.
*
* @throws Exception on error
*/
@Test
@Ignore
public void testAddOfEnabledDependencyToDisabledSchema() throws Exception
{
LdapContext schemaRoot = getSchemaContext( service );
ModificationItem[] mods = new ModificationItem[1];
Attribute attr = new BasicAttribute( "m-dependencies", "java" );
mods[0] = new ModificationItem( DirContext.ADD_ATTRIBUTE, attr );
schemaRoot.modifyAttributes( "cn=nis", mods );
Attributes attrs = schemaRoot.getAttributes( "cn=nis" );
Attribute dependencies = attrs.get( "m-dependencies" );
assertTrue( dependencies.contains( "java" ) );
}
}