/******************************************************************************
* Copyright (c) 2006, 2010 VMware Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Apache License v2.0 which accompanies this distribution.
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html and the Apache License v2.0
* is available at http://www.opensource.org/licenses/apache2.0.php.
* You may elect to redistribute this code under either of these licenses.
*
* Contributors:
* VMware Inc.
*****************************************************************************/
package org.eclipse.gemini.blueprint.test;
import java.io.InputStream;
import java.util.Properties;
import org.eclipse.gemini.blueprint.test.internal.util.IOUtils;
import org.eclipse.gemini.blueprint.test.internal.util.jar.JarCreator;
import org.osgi.framework.BundleContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.util.StringUtils;
/**
* Abstract JUnit base class that allows easy OSGi integration testing. It
* builds on its super classes to allow full configuration of the underlying
* OSGi platform implementation, of the test bundle creation (including the
* manifest automatic generation).
*
* <p/>This class follows the <em>traditional</em> Spring style of integration
* testing in which the test simply indicates the dependencies, leaving the rest
* of the work to be done by its super classes. Consider the following simple
* example:
*
* <pre class="code">
* public class SimpleOsgiTest extends AbstractConfigurableBundleCreatorTests {
*
* public void testOsgiPlatformStarts() throws Exception {
* System.out.println(bundleContext.getProperty(Constants.FRAMEWORK_VENDOR));
* System.out.println(bundleContext.getProperty(Constants.FRAMEWORK_VERSION));
* System.out.println(bundleContext.getProperty(Constants.FRAMEWORK_EXECUTIONENVIRONMENT));
* }
* }
* </pre>
*
* <p/> The above class can be ran just like any other JUnit test. Equinox
* platform will be automatically started, the test will packed in an OSGi
* bundle (with its manifest created automatically) which will be deployed
* inside the OSGi platform. After running the test inside the OSGi environment,
* the test results (whether they are exceptions or failures) will be reported
* back to the running tool transparently. Please see the reference
* documentation for more examples, customization tips and help on how to do
* efficient and fast integration testing.
*
* <p/> This class allows the test on-the-fly bundle (jar) can be configured
* declaratively by indicating the locations for:
* <ul>
* <li>root folder ({@value #ROOT_DIR}) - the starting point on which the
* resource patterns are applied</li>
* <li>inclusion patterns ({@value #INCLUDE_PATTERNS})- comma separated
* strings which identify the resources that should be included into the
* archive.</li>
* <li>manifest ({@value #MANIFEST})- the location of the manifest used for
* testing (if automatic generation is undesired).</li>
* </ul>
* <p/> These settings can be configured by:
* <ul>
* <li>using a properties file. By default the property name follows the
* pattern "[testName]-bundle.properties", (i.e. /foo/bar/SomeTest will try to
* load file /foo/bar/SomeTest-bundle.properties). If no properties file is
* found, a set of defaults will be used.</li>
*
* <li>overriding the default getXXX methods and providing an alternative
* implementation.</li>
* </ul>
*
* <p/>Another useful functionality inherited from
* {@link AbstractOnTheFlyBundleCreatorTests} class is the ability to create a
* manifest for the test bundle on the fly, based on the classes present in the
* archive.
*
* <p/><b>Note:</b> This class is the main testing framework entry point
*
* @author Costin Leau
*
* @see AbstractOnTheFlyBundleCreatorTests
*/
public abstract class AbstractConfigurableBundleCreatorTests extends AbstractOnTheFlyBundleCreatorTests {
protected static final String ROOT_DIR = "root.dir";
protected static final String INCLUDE_PATTERNS = "include.patterns";
protected static final String LIBS = "libs";
protected static final String MANIFEST = "manifest";
private static final Properties DEFAULT_SETTINGS = new Properties();
static {
DEFAULT_SETTINGS.setProperty(ROOT_DIR, Thread.currentThread().getContextClassLoader().getResource(".").toString());
DEFAULT_SETTINGS.setProperty(INCLUDE_PATTERNS, JarCreator.EVERYTHING_PATTERN);
DEFAULT_SETTINGS.setProperty(LIBS, "");
DEFAULT_SETTINGS.setProperty(MANIFEST, "");
}
/**
* Settings for the jar creation. Static as it has to be cached between test
* runs and it is being initialized once in
* {@link #postProcessBundleContext(BundleContext)}.
*/
private static Properties jarSettings;
protected String getRootPath() {
return jarSettings.getProperty(ROOT_DIR);
}
/**
* {@inheritDoc}
*
* <p/>Ant-style patterns for identifying the resources added to the jar.The
* patterns are considered from the root path when performing the search.
*
* <p/> By default, the content pattern is <code>**/*</code> which
* includes all sources from the root. One can configure the pattern to
* include specific files by using different patterns. For example, to
* include just the classes, XML and properties files one can use the
* following patterns:
* <ol>
* <li><code>**/*.class</code> for classes
* <li><code>**/*.xml</code> for XML files
* <li><code>**/*.properties</code> for properties files
* </ol>
*
* @return array of Ant-style pattern
*/
protected String[] getBundleContentPattern() {
return StringUtils.commaDelimitedListToStringArray(jarSettings.getProperty(INCLUDE_PATTERNS));
}
protected String getManifestLocation() {
return jarSettings.getProperty(MANIFEST);
}
/**
* Returns the settings location (by default, the test name; i.e.
* <code>foo.bar.SomeTest</code> will try to load
* <code>foo/bar/SomeTest-bundle.properties</code>).
*
* @return settings location for this test
*/
protected String getSettingsLocation() {
return getClass().getName().replace('.', '/') + "-bundle.properties";
}
/**
* Returns the default settings used when creating the jar, in case no
* customisations have been applied. Unless the base class is used as a
* testing framework, consider using a properties file for specifying
* specific properties for a test case.
*
* @return default settings for creating the jar
* @see #getSettingsLocation()
*/
protected Properties getDefaultSettings() {
return DEFAULT_SETTINGS;
}
/**
* Returns the settings used for creating this jar. This method tries to
* locate and load the settings from the location indicated by
* {@link #getSettingsLocation()}. If no file is found, the default
* settings will be used.
*
* <p/> A non-null properties object will always be returned.
*
* @return settings for creating the on the fly jar
* @throws Exception if loading the settings file fails
*/
protected Properties getSettings() throws Exception {
Properties settings = new Properties(getDefaultSettings());
// settings.setProperty(ROOT_DIR, getRootPath());
Resource resource = new ClassPathResource(getSettingsLocation());
if (resource.exists()) {
InputStream stream = resource.getInputStream();
try {
if (stream != null) {
settings.load(stream);
logger.debug("Loaded jar settings from " + getSettingsLocation());
}
}
finally {
IOUtils.closeStream(stream);
}
}
else
logger.info(getSettingsLocation() + " was not found; using defaults");
return settings;
}
/*
* Loads the jar settings, first from the disk falling back to the default
* settings, if none is found.
*/
protected void postProcessBundleContext(BundleContext context) throws Exception {
// hook in properties loading
// reset the settings (useful when running multiple tests)
jarSettings = null;
// load settings
jarSettings = getSettings();
// Somehow the JarCreator needs to get this
jarCreator.setRootPath(getRootPath());
super.postProcessBundleContext(context);
}
}