ClassLoadingHelperIntegrationTests.java

/*******************************************************************************
 * Copyright (c) 2010 SAP AG
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Hristo Iliev, SAP AG - initial contribution
 *******************************************************************************/
package org.eclipse.virgo.kernel.osgicommand.helper.test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

import org.eclipse.virgo.shell.osgicommand.helper.ClassLoadingHelper;
import org.eclipse.virgo.kernel.test.AbstractKernelIntegrationTest;
import org.eclipse.virgo.test.framework.dmkernel.DmKernelTestRunner;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;

/**
 * Class for integration testing {@link org.eclipse.virgo.shell.osgicommand.helper.ClassLoadingHelper}
 */
@RunWith(DmKernelTestRunner.class)
public class ClassLoadingHelperIntegrationTests extends AbstractKernelIntegrationTest {
    private static final String SHELL_COMMANDS_BUNDLE_NAME = "org.eclipse.virgo.shell.command";
    private static final String CLASSLOADING_PACKAGE = "org.eclipse.virgo.shell.osgicommand.helper";

    private static final String TEST_CLASS_NAME = ClassLoadingHelperIntegrationTests.class.getName();
    private static final String TEST_CLASS_PACKAGE = ClassLoadingHelperIntegrationTests.class.getPackage().getName();

    private static final String TEST_CLASS_NAME_PATH = TEST_CLASS_NAME.replace(".", "/");

    private final String FRAMEWORK_CLASS_PACKAGE = BundleContext.class.getPackage().getName();
    private final String FRAMEWORK_CLASS_NAME = BundleContext.class.getName();

    private Bundle currentBundle = null;
    private Bundle shellCommandsBundle = null;
    private Bundle systemBundle = null;

    private final String UNEXPORTED_ERROR_MESSAGE = "Package [%s] is reported as exported by [%s] with id [%s], but it is not";
    private final String EXPORTED_ERROR_MESSAGE = "Package [%s] is reported as not exported by [%s] with id [%s], but it is";
    private final String LOADED = "Class [%s] was loaded by by bundle [%s] with id [%s], but it should be available only in [%s]";
    private final String NOT_LOADED = "Class [%s] was not loaded from bundle [%s] with id [%s]";

    @Before
    public void setUp() throws Exception {
        // execute initialization code
        super.setup();

        for (Bundle bundle : context.getBundles()) {
            if (SHELL_COMMANDS_BUNDLE_NAME.equals(bundle.getSymbolicName())) {
               this.shellCommandsBundle = bundle; 
            }
        }
        
        assertNotNull("No bundles with symbolic name [" + SHELL_COMMANDS_BUNDLE_NAME + "] found in bundles " + Arrays.toString(context.getBundles()),
                      this.shellCommandsBundle);

        // get this bundle
        this.currentBundle = context.getBundle();

        // get the system bundle
        this.systemBundle = context.getBundle(0);
    }

    @Test
    public void testIsPackageExportedMethod() throws Exception {
        // Check which bundles export CLASSLOADING_PACKAGE
        assertTrue(String.format(EXPORTED_ERROR_MESSAGE, CLASSLOADING_PACKAGE, SHELL_COMMANDS_BUNDLE_NAME, shellCommandsBundle.getBundleId()),
                   ClassLoadingHelper.isPackageExported(context, CLASSLOADING_PACKAGE, shellCommandsBundle));
        assertFalse(String.format(UNEXPORTED_ERROR_MESSAGE, CLASSLOADING_PACKAGE, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                    ClassLoadingHelper.isPackageExported(context, CLASSLOADING_PACKAGE, currentBundle));
        assertFalse(String.format(UNEXPORTED_ERROR_MESSAGE, CLASSLOADING_PACKAGE, systemBundle.getSymbolicName(), systemBundle.getBundleId()),
                    ClassLoadingHelper.isPackageExported(context, CLASSLOADING_PACKAGE, systemBundle));

        // Check which bundles export CLASSLOADING_TEST_PACKAGE
        assertFalse(String.format(UNEXPORTED_ERROR_MESSAGE, TEST_CLASS_PACKAGE, SHELL_COMMANDS_BUNDLE_NAME, shellCommandsBundle.getBundleId()),
                    ClassLoadingHelper.isPackageExported(context, TEST_CLASS_PACKAGE, shellCommandsBundle));
        assertTrue(String.format(EXPORTED_ERROR_MESSAGE, TEST_CLASS_PACKAGE, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                   ClassLoadingHelper.isPackageExported(context, TEST_CLASS_PACKAGE, currentBundle));
        assertFalse(String.format(UNEXPORTED_ERROR_MESSAGE, TEST_CLASS_PACKAGE, systemBundle.getSymbolicName(), systemBundle.getBundleId()),
                    ClassLoadingHelper.isPackageExported(context, TEST_CLASS_PACKAGE, systemBundle));
    }

    @Test
    public void testGetBundlesContainingResource() throws Exception {
        final String CONTAINS_ERROR_MESSAGE = "Bundle [%s] is returned as bundle that contains the test class [%s]. The returned set of bundles is %s";
        final String DOES_NOT_CONTAIN_ERROR_MESSAGE = "Bundle [%s] is not returned as bundle that contains the test class [%s]. The returned set of bundles is %s";
        final String RESOURCE_NOT_FOUND = "Bundle [%s] is returned as bundle that contains the test class [%s], but the returned URLs [%s] doesn't seem to have it.";

        // Check which bundles contain this class
        Map<Bundle, List<String>> result = ClassLoadingHelper.getBundlesContainingResource(context, TEST_CLASS_NAME_PATH + ".class");
        assertFalse(String.format(CONTAINS_ERROR_MESSAGE, SHELL_COMMANDS_BUNDLE_NAME, TEST_CLASS_NAME, Arrays.toString(result.keySet().toArray())),
                    result.containsKey(shellCommandsBundle));
        assertTrue(String.format(DOES_NOT_CONTAIN_ERROR_MESSAGE, currentBundle.getSymbolicName(), TEST_CLASS_NAME, Arrays.toString(result.keySet().toArray())),
                   result.containsKey(currentBundle));

        // Check the resources contained in the bundles
        assertTrue(String.format(RESOURCE_NOT_FOUND, currentBundle.getSymbolicName(), TEST_CLASS_NAME, result.toString().contains(TEST_CLASS_NAME_PATH)),
                   result.toString().contains(TEST_CLASS_NAME_PATH));
    }

    @Test
    public void testGetBundlesLoadingClassMethod() throws Exception {
        final String CAN_LOAD_ERROR_MESSAGE = "Bundle [%s] is returned as bundle that can load the test class [%s]. The returned set of bundles is %s";
        final String CANNOT_LOAD_ERROR_MESSAGE = "Bundle [%s] is not returned as bundle that can load the test class [%s]. The returned set of bundles is %s";
        final String ORIGINATING_ERROR_MESSAGE = "Bundle [%s] is returned as originating bundle for class [%s]. The returned set of bundles is %s";
        final String NON_ORIGINATING_ERROR_MESSAGE = "Bundle [%s] is not returned as originating bundle for class [%s]. The returned set of bundles is %s";

        // Check which bundles can load this class
        Map<Bundle, Bundle> result = ClassLoadingHelper.getBundlesLoadingClass(context, TEST_CLASS_NAME);
        assertFalse(String.format(CAN_LOAD_ERROR_MESSAGE, SHELL_COMMANDS_BUNDLE_NAME, TEST_CLASS_NAME, Arrays.toString(result.keySet().toArray())),
                    result.containsKey(shellCommandsBundle));
        assertFalse(String.format(ORIGINATING_ERROR_MESSAGE, SHELL_COMMANDS_BUNDLE_NAME, TEST_CLASS_NAME, Arrays.toString(result.values().toArray())),
                    result.containsValue(shellCommandsBundle));
        assertTrue(String.format(CANNOT_LOAD_ERROR_MESSAGE, currentBundle.getSymbolicName(), TEST_CLASS_NAME, Arrays.toString(result.keySet().toArray())),
                   result.containsKey(currentBundle));
        assertTrue(String.format(NON_ORIGINATING_ERROR_MESSAGE, currentBundle.getSymbolicName(), TEST_CLASS_NAME, Arrays.toString(result.values().toArray())),
                   result.containsValue(currentBundle));

        // Check how osgicommand bundle can load BundleContext
        result = ClassLoadingHelper.getBundlesLoadingClass(context, FRAMEWORK_CLASS_NAME, SHELL_COMMANDS_BUNDLE_NAME);
        assertTrue(String.format(CANNOT_LOAD_ERROR_MESSAGE, SHELL_COMMANDS_BUNDLE_NAME, FRAMEWORK_CLASS_NAME, Arrays.toString(result.keySet().toArray())),
                   result.containsKey(shellCommandsBundle));
        assertTrue(String.format(NON_ORIGINATING_ERROR_MESSAGE, systemBundle.getSymbolicName(), FRAMEWORK_CLASS_NAME, Arrays.toString(result.values().toArray())),
                   result.containsValue(systemBundle));
    }

    @Test
    public void testTryToLoadClassMethod() throws Exception {
        assertNotNull(String.format(NOT_LOADED, TEST_CLASS_NAME, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                      ClassLoadingHelper.tryToLoadClass(TEST_CLASS_NAME, currentBundle));
        assertNull(String.format(LOADED, TEST_CLASS_NAME, SHELL_COMMANDS_BUNDLE_NAME, shellCommandsBundle.getBundleId(), currentBundle.getSymbolicName()),
                   ClassLoadingHelper.tryToLoadClass(TEST_CLASS_NAME, shellCommandsBundle));
    }

    @Test
    public void testExportAndLoad() throws Exception {
        // Check TEST_CLASS_* export and load
        assertFalse(String.format(UNEXPORTED_ERROR_MESSAGE, TEST_CLASS_PACKAGE, shellCommandsBundle.getSymbolicName(), shellCommandsBundle.getBundleId()),
                    ClassLoadingHelper.isPackageExported(context, TEST_CLASS_PACKAGE, shellCommandsBundle));
        assertNull(String.format(LOADED, TEST_CLASS_NAME, SHELL_COMMANDS_BUNDLE_NAME, shellCommandsBundle.getBundleId(), SHELL_COMMANDS_BUNDLE_NAME),
                   ClassLoadingHelper.tryToLoadClass(TEST_CLASS_NAME, shellCommandsBundle));
        assertTrue(String.format(EXPORTED_ERROR_MESSAGE, TEST_CLASS_PACKAGE, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                   ClassLoadingHelper.isPackageExported(context, TEST_CLASS_PACKAGE, currentBundle));
        assertNotNull(String.format(NOT_LOADED, TEST_CLASS_NAME, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                      ClassLoadingHelper.tryToLoadClass(TEST_CLASS_NAME, currentBundle));

        // Check FRAMEWORK_CLASS_* export and load
        assertFalse(String.format(UNEXPORTED_ERROR_MESSAGE, FRAMEWORK_CLASS_PACKAGE, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                    ClassLoadingHelper.isPackageExported(context, FRAMEWORK_CLASS_PACKAGE, currentBundle));
        assertNotNull(String.format(NOT_LOADED, FRAMEWORK_CLASS_NAME, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                      ClassLoadingHelper.tryToLoadClass(FRAMEWORK_CLASS_NAME, currentBundle));
        assertTrue(String.format(EXPORTED_ERROR_MESSAGE, FRAMEWORK_CLASS_PACKAGE, systemBundle.getSymbolicName(), systemBundle.getBundleId()),
                   ClassLoadingHelper.isPackageExported(context, FRAMEWORK_CLASS_PACKAGE, systemBundle));
        assertNotNull(String.format(NOT_LOADED, FRAMEWORK_CLASS_NAME, currentBundle.getSymbolicName(), currentBundle.getBundleId()),
                      ClassLoadingHelper.tryToLoadClass(FRAMEWORK_CLASS_NAME, systemBundle));
    }
}