/*
 *  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 org.apache.directory.server.constants.MetaSchemaConstants;
import org.apache.directory.server.core.DirectoryService;
import org.apache.directory.server.core.integ.CiRunner;
import static org.apache.directory.server.core.integ.IntegrationUtils.getSchemaContext;
import org.apache.directory.server.schema.bootstrap.Schema;
import org.apache.directory.server.schema.registries.AttributeTypeRegistry;
import org.apache.directory.shared.ldap.exception.LdapNameNotFoundException;
import org.apache.directory.shared.ldap.exception.LdapOperationNotSupportedException;
import org.apache.directory.shared.ldap.message.AttributeImpl;
import org.apache.directory.shared.ldap.message.AttributesImpl;
import org.apache.directory.shared.ldap.message.ModificationItemImpl;
import org.apache.directory.shared.ldap.message.ResultCodeEnum;
import org.apache.directory.shared.ldap.constants.SchemaConstants;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.DirContext;
import javax.naming.ldap.LdapContext;
import java.util.Map;


/**
 * A test case which tests the correct operation of the schema 
 * entity handler.  
 *
 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
 * @version $Rev$
 */
@RunWith ( CiRunner.class )
public class MetaSchemaHandlerIT
{
    /** the schema to use for this test: one that is not loaded by default */
    private static final String TEST_SCHEMA = "nis";
    /** a test attribute in the test schema: uidNumber in nis schema */
    private static final String TEST_ATTR_OID = "1.3.6.1.1.1.1.0";
    /** the name of the dummy schema to test metaSchema adds/deletes with */
    private static final String DUMMY_SCHEMA = "dummy";
    

    public static DirectoryService service;


    private static AttributeTypeRegistry getAttributeTypeRegistry()
    {
        return service.getRegistries().getAttributeTypeRegistry();
    }


    private static Map<String, Schema> getLoadedSchemas()
    {
        return service.getRegistries().getLoadedSchemas();
    }


    @Before
    public void checkSambaSchema() throws NamingException
    {
        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" ) );
    }


    // -----------------------------------------------------------------------
    // Schema Add Tests
    // -----------------------------------------------------------------------

    
    /**
     * Tests the addition of a new metaSchema object that is disabled 
     * on addition and has no dependencies.
     *
     * @throws Exception on error
     */
    @Test
    public void testAddDisabledSchemaNoDeps() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
        dummySchema.put( "cn", DUMMY_SCHEMA );
        dummySchema.put( MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
        
        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
        assertNotNull( schemaRoot.lookup( "cn=" + DUMMY_SCHEMA ) );
    }
    
    
    /**
     * Tests the addition of a new metaSchema object that is disabled 
     * on addition and has dependencies.
     *
     * @throws Exception on error
     */
    @Test
    public void testAddDisabledSchemaWithDeps() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
        dummySchema.put( "cn", DUMMY_SCHEMA );
        dummySchema.put( MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, TEST_SCHEMA );
        dummySchema.get( MetaSchemaConstants.M_DEPENDENCIES_AT ).add( "core" );
        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
        
        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
        assertNotNull( schemaRoot.lookup( "cn=" + DUMMY_SCHEMA ) );
    }
    
    
    /**
     * Tests the rejection of a new metaSchema object that is disabled 
     * on addition and has missing dependencies.
     *
     * @throws Exception on error
     */
    @Test
    public void testRejectDisabledSchemaAddWithMissingDeps() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
        dummySchema.put( "cn", DUMMY_SCHEMA );
        dummySchema.put( MetaSchemaConstants.M_DISABLED_AT, "TRUE" );
        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, "missing" );
        dummySchema.get( MetaSchemaConstants.M_DEPENDENCIES_AT ).add( "core" );
        
        try
        {
            schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
        } 
        catch( LdapOperationNotSupportedException e )
        {
            assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
        }
        
        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );

        //noinspection EmptyCatchBlock
        try
        {
            schemaRoot.lookup( "cn=" + DUMMY_SCHEMA );
            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
    public void testAddEnabledSchemaNoDeps() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
        dummySchema.put( "cn", DUMMY_SCHEMA );
        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
        
        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
        assertNotNull( schemaRoot.lookup( "cn=" + DUMMY_SCHEMA ) );
    }
    
    
    /**
     * Tests the rejection of a metaSchema object add that is enabled 
     * on addition yet has disabled dependencies.
     *
     * @throws Exception on error
     */
    @Test
    public void testRejectEnabledSchemaAddWithDisabledDeps() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
        dummySchema.put( "cn", DUMMY_SCHEMA );
        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, TEST_SCHEMA );
        
        try
        {
            schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, 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 ) );
        }
        
        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );

        //noinspection EmptyCatchBlock
        try
        {
            schemaRoot.lookup( "cn=" + DUMMY_SCHEMA );
            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
    public void testDeleteSchemaNoDependents() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );

        // add the dummy schema enabled 
        testAddEnabledSchemaNoDeps();
        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
        
        // delete it now
        schemaRoot.destroySubcontext( "cn=" + DUMMY_SCHEMA );
        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
    }
    
    
    /**
     * Makes sure we can NOT delete schemas that have dependents.
     *
     * @throws Exception on error
     */
    @Test
    public void testRejectSchemaDeleteWithDependents() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );

        // add the dummy schema enabled
        testAddEnabledSchemaNoDeps();
        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
        
        // make the nis schema depend on the dummy schema
        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE,
                new AttributeImpl( MetaSchemaConstants.M_DEPENDENCIES_AT, DUMMY_SCHEMA ) );
        schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
        
        // attempt to delete it now & it should fail
        try
        {
            schemaRoot.destroySubcontext( "cn=" + DUMMY_SCHEMA );
            fail( "should not be able to delete a schema with dependents" );
        }
        catch ( LdapOperationNotSupportedException e )
        {
            assertTrue( e.getResultCode().equals( ResultCodeEnum.UNWILLING_TO_PERFORM ) );
        }

        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
    }
    
    
    /**
     * Tests the rejection of a new metaSchema object that is enabled 
     * on addition and missing dependencies.
     *
     * @throws Exception on error
     */
    @Test
    public void testRejectEnabledSchemaAddWithMisingDeps() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );

        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
        dummySchema.put( "cn", DUMMY_SCHEMA );
        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, "missing" );
        
        try
        {
            schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, 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 ) );
        }
        
        assertNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );

        //noinspection EmptyCatchBlock
        try
        {
            schemaRoot.lookup( "cn=" + DUMMY_SCHEMA );
            fail( "schema should not be added to schema partition" );
        }
        catch( NamingException e )
        {
        }
    }

    
    // -----------------------------------------------------------------------
    // Enable/Disable Schema Tests
    // -----------------------------------------------------------------------

    
    private void enableSchema( String schemaName ) throws NamingException
    {
        LdapContext schemaRoot = getSchemaContext( service );

        // now enable the test schema
        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        Attribute attr = new AttributeImpl( "m-disabled", "FALSE" );
        mods[0] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
        schemaRoot.modifyAttributes( "cn=" + schemaName, mods );
    }
    
    
    private void disableSchema( String schemaName ) throws NamingException
    {
        LdapContext schemaRoot = getSchemaContext( service );

        // now enable the test schema
        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        Attribute attr = new AttributeImpl( "m-disabled", "TRUE" );
        mods[0] = new ModificationItemImpl( DirContext.REPLACE_ATTRIBUTE, attr );
        schemaRoot.modifyAttributes( "cn=" + schemaName, mods );
    }
    
    
    /**
     * 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 testEnableSchema() throws Exception
    {
        AttributeTypeRegistry atr = getAttributeTypeRegistry();
        
        // check that the nis schema is not loaded
        assertNull( getLoadedSchemas().get( TEST_SCHEMA ) );
        
        // double check and make sure an attribute from that schema is 
        // not in the AttributeTypeRegistry
        assertFalse( atr.hasAttributeType( TEST_ATTR_OID ) );
        
        // now enable the test schema
        enableSchema( "nis" );
        
        // now test that the schema is loaded 
        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
        
        // double check and make sure the test attribute from the 
        // test schema is now loaded and present within the attr registry
        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
    }


    /**
     * Checks to make sure an attempt to disable a metaSchema fails if 
     * that schema has dependents which are enabled.
     *
     * @throws Exception on error
     */
    @Test
    public void testDisableSchema() throws Exception
    {
        // let's enable the test schema
        testEnableSchema();
        
        AttributeTypeRegistry atr = getAttributeTypeRegistry();
        
        // check that the nis schema is loaded
        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
        
        // double check and make sure an attribute from that schema is 
        // in the AttributeTypeRegistry
        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
        
        // now disable the test schema 
        disableSchema( "samba" );
        disableSchema( "nis" );
        
        // now test that the schema is NOT loaded 
        assertNull( getLoadedSchemas().get( TEST_SCHEMA ) );
        
        // double check and make sure the test attribute from the test  
        // schema is now NOT loaded and present within the attr registry
        assertFalse( atr.hasAttributeType( TEST_ATTR_OID ) );
    }

    
    /**
     * 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
    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
        testEnableSchema(); 
        
        // adds enabled dummy schema that depends on the test schema  
        Attributes dummySchema = new AttributesImpl( "objectClass", "top" );
        dummySchema.get( "objectClass" ).add( MetaSchemaConstants.META_SCHEMA_OC );
        dummySchema.put( "cn", DUMMY_SCHEMA );
        dummySchema.put( MetaSchemaConstants.M_DEPENDENCIES_AT, TEST_SCHEMA );
        schemaRoot.createSubcontext( "cn=" + DUMMY_SCHEMA, dummySchema );
        
        // check that the nis schema is loaded and the dummy schema is loaded
        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
        
        AttributeTypeRegistry atr = getAttributeTypeRegistry();
        
        // double check and make sure an attribute from that schema is 
        // in the AttributeTypeRegistry
        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
        
        // now try to disable the test schema which should fail 
        // since it's dependent, the dummy schema, is enabled
        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        Attribute attr = new AttributeImpl( "m-disabled", "TRUE" );
        mods[0] = new ModificationItemImpl( 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 
        assertNotNull( getLoadedSchemas().get( TEST_SCHEMA ) );
        assertNotNull( getLoadedSchemas().get( DUMMY_SCHEMA ) );
        
        // double check and make sure the test attribute from the test  
        // schema is still loaded and present within the attr registry
        assertTrue( atr.hasAttributeType( TEST_ATTR_OID ) );
    }
    
    
    // -----------------------------------------------------------------------
    // 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
    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
    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
    public void testSchemaRenameEnabledSchema() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );

        enableSchema( "samba" );
        assertTrue( getAttributeTypeRegistry().hasAttributeType( "sambaNTPassword" ) );
        assertEquals( "samba", getAttributeTypeRegistry().getSchemaName( "sambaNTPassword" ) );
        
        schemaRoot.rename( "cn=samba", "cn=foo" );
        assertNotNull( schemaRoot.lookup( "cn=foo" ) );
        assertTrue( getAttributeTypeRegistry().hasAttributeType( "sambaNTPassword" ) );
        assertEquals( "foo", 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
    public void testRejectAddBogusDependency() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );

        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        Attribute attr = new AttributeImpl( "m-dependencies", "bogus" );
        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
        
        try
        {
            schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, 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
    public void testRejectAddOfDisabledDependencyToEnabledSchema() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        enableSchema( TEST_SCHEMA );
        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        Attribute attr = new AttributeImpl( "m-dependencies", "mozilla" );
        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
        
        try
        {
            schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, 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
    public void testAddOfDisabledDependencyToDisabledSchema() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        Attribute attr = new AttributeImpl( "m-dependencies", "mozilla" );
        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
        schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
        Attributes attrs = schemaRoot.getAttributes( "cn=" + TEST_SCHEMA );
        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
    public void testAddOfEnabledDependencyToDisabledSchema() throws Exception
    {
        LdapContext schemaRoot = getSchemaContext( service );
        ModificationItemImpl[] mods = new ModificationItemImpl[1];
        Attribute attr = new AttributeImpl( "m-dependencies", "java" );
        mods[0] = new ModificationItemImpl( DirContext.ADD_ATTRIBUTE, attr );
        schemaRoot.modifyAttributes( "cn=" + TEST_SCHEMA, mods );
        Attributes attrs = schemaRoot.getAttributes( "cn=" + TEST_SCHEMA );
        Attribute dependencies = attrs.get( "m-dependencies" );
        assertTrue( dependencies.contains( "java" ) );
    }
}