kernel/org.eclipse.virgo.kernel.test/src/test/java/org/eclipse/virgo/kernel/osgi/test/QuasiFrameworkIntegrationTests.java

/*******************************************************************************
 * Copyright (c) 2008, 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
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   VMware Inc. - initial contribution
 *******************************************************************************/

package org.eclipse.virgo.kernel.osgi.test;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.List;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.Version;

import org.eclipse.virgo.kernel.osgi.framework.OsgiFrameworkUtils;
import org.eclipse.virgo.kernel.osgi.framework.OsgiServiceHolder;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiBundle;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiExportPackage;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiFramework;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiFrameworkFactory;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiImportPackage;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiPackageResolutionFailure;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiRequiredBundle;
import org.eclipse.virgo.kernel.osgi.quasi.QuasiResolutionFailure;
import org.eclipse.virgo.kernel.test.AbstractKernelIntegrationTest;
import org.eclipse.virgo.util.osgi.manifest.BundleManifest;
import org.eclipse.virgo.util.osgi.manifest.BundleManifestFactory;
import org.eclipse.virgo.util.osgi.manifest.RequireBundle;

/**
 */
public class QuasiFrameworkIntegrationTests extends AbstractKernelIntegrationTest {

    private static final String EXPORTER_BSN = "exporter";

    private static final String IMPORTER_BSN = "importer";
    
    private static final String REQUIRING_BSN = "requirer";

    private static final String IMPORTER_JAR_PATH = "src/test/resources/quasi/simpleimporter.jar";
    
    private static final String EXPORTER_JAR_PATH = "src/test/resources/quasi/simpleexporter.jar";

    private static final String QUASI_TEST_PACKAGE = "quasi.test";

    private static final Version BUNDLE_VERSION = new Version("2.3");

    private QuasiFrameworkFactory quasiFrameworkFactory;

    private QuasiFramework quasiFramework;

    @Before
    public void setUp() {
        BundleContext bundleContext = this.framework.getBundleContext();
        OsgiServiceHolder<QuasiFrameworkFactory> holder = OsgiFrameworkUtils.getService(bundleContext, QuasiFrameworkFactory.class);
        this.quasiFrameworkFactory = holder.getService();
        Assert.assertNotNull(this.quasiFrameworkFactory);
        this.quasiFramework = this.quasiFrameworkFactory.create();
        Assert.assertNotNull(this.quasiFramework);
    }
    
    @After
    public void tearDown() {
        this.quasiFramework.destroy();
    }

    @Test
    public void testInstall() throws Exception {
        BundleManifest bundleManifest = getBundleManifest("test", BUNDLE_VERSION);

        QuasiBundle quasiBundle = this.quasiFramework.install(new URI("test"), bundleManifest);
        Assert.assertEquals("test", quasiBundle.getSymbolicName());
        Assert.assertEquals(BUNDLE_VERSION, quasiBundle.getVersion());
        Assert.assertFalse(quasiBundle.isResolved());
        Assert.assertNull(quasiBundle.getBundle());
        
        long bundleId = quasiBundle.getBundleId();
        Assert.assertFalse(bundleId == 0);
        Assert.assertEquals(quasiBundle, this.quasiFramework.getBundle(bundleId));
    }

    @Test
    public void testBasicResolve() throws Exception {
        QuasiBundle exporterQuasiBundle = installExporterBundle();

        List<QuasiResolutionFailure> resolutionFailures = this.quasiFramework.resolve();
        Assert.assertNotNull(resolutionFailures);
        Assert.assertEquals(0, resolutionFailures.size());
        Assert.assertTrue(exporterQuasiBundle.isResolved());
    }

    @Test
    public void testWiringResolve() throws Exception {
        QuasiBundle importerQuasiBundle = installImporterBundle();
        QuasiBundle exporterQuasiBundle = installExporterBundle();

        List<QuasiResolutionFailure> resolutionFailures = this.quasiFramework.resolve();
        Assert.assertNotNull(resolutionFailures);
        Assert.assertEquals(0, resolutionFailures.size());
        Assert.assertTrue(importerQuasiBundle.isResolved());
        Assert.assertTrue(exporterQuasiBundle.isResolved());
    }

    @Test
    public void testFailedResolve() throws Exception {
        QuasiBundle importerQuasiBundle = installImporterBundle();

        List<QuasiResolutionFailure> resolutionFailures = this.quasiFramework.resolve();
        Assert.assertNotNull(resolutionFailures);
        Assert.assertEquals(1, resolutionFailures.size());
        QuasiResolutionFailure failure = resolutionFailures.get(0);
        Assert.assertTrue(failure instanceof QuasiPackageResolutionFailure);
        QuasiPackageResolutionFailure qprFailure = (QuasiPackageResolutionFailure) failure;
        Assert.assertEquals(QUASI_TEST_PACKAGE, qprFailure.getPackage());
        Assert.assertFalse(importerQuasiBundle.isResolved());
    }

    @Test
    public void testPackageWiringExploration() throws Exception {
        QuasiBundle importerQuasiBundle = installImporterBundle();
        QuasiBundle exporterQuasiBundle = installExporterBundle();
        
        List<QuasiResolutionFailure> resolutionFailures = this.quasiFramework.resolve();
        Assert.assertNotNull(resolutionFailures);
        Assert.assertEquals(0, resolutionFailures.size());
        Assert.assertTrue(importerQuasiBundle.isResolved());
        Assert.assertTrue(exporterQuasiBundle.isResolved());
        
        checkGetBundles(importerQuasiBundle, exporterQuasiBundle);
        
        checkDependents(importerQuasiBundle, exporterQuasiBundle);
        
        QuasiImportPackage qip = checkImportPackages(importerQuasiBundle, exporterQuasiBundle);
        
        QuasiExportPackage qep = checkExportPackages(importerQuasiBundle, exporterQuasiBundle);
        
        checkConsumers(qep, qip);
        
        checkProvider(qip, qep);
    }
    
    @Test
    public void testRequiredBundleExploration() throws Exception {
        QuasiBundle requiringQuasiBundle = installRequiringBundle();
        QuasiBundle exporterQuasiBundle = installExporterBundle();
        
        List<QuasiResolutionFailure> resolutionFailures = this.quasiFramework.resolve();
        Assert.assertNotNull(resolutionFailures);
        Assert.assertEquals(0, resolutionFailures.size());
        Assert.assertTrue(requiringQuasiBundle.isResolved());
        Assert.assertTrue(exporterQuasiBundle.isResolved());
        
        checkGetBundles(requiringQuasiBundle, exporterQuasiBundle);
        
        List<QuasiRequiredBundle> requiredBundles = requiringQuasiBundle.getRequiredBundles();
        Assert.assertEquals(1, requiredBundles.size());
        QuasiRequiredBundle quasiRequiredBundle = requiredBundles.get(0);
        QuasiBundle provider = quasiRequiredBundle.getProvider();
        Assert.assertEquals(exporterQuasiBundle, provider);
        
    }

    private void checkProvider(QuasiImportPackage qip, QuasiExportPackage qep) {
        QuasiExportPackage provider = qip.getProvider();
        Assert.assertEquals(qep, provider);
    }

    private void checkConsumers(QuasiExportPackage qep, QuasiImportPackage qip) {
        List<QuasiImportPackage> consumers = qep.getConsumers();
        Assert.assertEquals(1, consumers.size());
        QuasiImportPackage consumer = consumers.get(0);
        Assert.assertEquals(qip, consumer);
    }

    private QuasiImportPackage checkImportPackages(QuasiBundle importerQuasiBundle, QuasiBundle exporterQuasiBundle) {
        List<QuasiImportPackage> exporterImportPackages = exporterQuasiBundle.getImportPackages();
        Assert.assertEquals(0, exporterImportPackages.size());
        
        List<QuasiImportPackage> importPackages = importerQuasiBundle.getImportPackages();
        Assert.assertEquals(1, importPackages.size());
        QuasiImportPackage qip = importPackages.get(0);
        Assert.assertEquals("quasi.test", qip.getPackageName());
        return qip;
    }

    private QuasiExportPackage checkExportPackages(QuasiBundle importerQuasiBundle, QuasiBundle exporterQuasiBundle) {
        Assert.assertEquals(0, importerQuasiBundle.getExportPackages().size());
        
        List<QuasiExportPackage> exportPackages = exporterQuasiBundle.getExportPackages();
        Assert.assertEquals(1, exportPackages.size());
        QuasiExportPackage qep = exportPackages.get(0);
        Assert.assertEquals("quasi.test", qep.getPackageName());
        return qep;
    }

    private void checkDependents(QuasiBundle importerQuasiBundle, QuasiBundle exporterQuasiBundle) {
        List<QuasiBundle> dependents = exporterQuasiBundle.getDependents();
        Assert.assertEquals(1, dependents.size());
        Assert.assertEquals(importerQuasiBundle, dependents.get(0));
    }

    private void checkGetBundles(QuasiBundle importerQuasiBundle, QuasiBundle exporterQuasiBundle) {
        List<QuasiBundle> quasiBundles = this.quasiFramework.getBundles();
        
        boolean foundImporter = false;
        boolean foundExporter = false;
        
        for (QuasiBundle quasiBundle : quasiBundles) {
            if (quasiBundle.equals(importerQuasiBundle)) {
                foundImporter = true;
            }
            if (quasiBundle.equals(exporterQuasiBundle)) {
                foundExporter = true;
            }
            
        }
        
        Assert.assertTrue(foundImporter);
        Assert.assertTrue(foundExporter);
    }
    
    @Test
    public void testCommit() throws Exception {
        QuasiBundle importerQuasiBundle = installImporterBundle();
        QuasiBundle exporterQuasiBundle = installExporterBundle();

        List<QuasiResolutionFailure> resolutionFailures = this.quasiFramework.resolve();
        Assert.assertNotNull(resolutionFailures);
        Assert.assertEquals(0, resolutionFailures.size());
        this.quasiFramework.commit();
        
        Assert.assertTrue(importerQuasiBundle.isResolved());
        Bundle importerBundle = importerQuasiBundle.getBundle();
        Assert.assertNotNull(importerBundle);
        Assert.assertEquals(IMPORTER_BSN, importerBundle.getSymbolicName());
        
        Assert.assertTrue(exporterQuasiBundle.isResolved());
        Bundle exporterBundle = exporterQuasiBundle.getBundle();
        Assert.assertNotNull(exporterBundle);
        Assert.assertEquals(EXPORTER_BSN, exporterBundle.getSymbolicName());
        
        // Tidy up since test methods may run in any order in Java 7 
        importerBundle.uninstall();
        exporterBundle.uninstall();
    }
    
    private QuasiBundle installExporterBundle() throws BundleException, URISyntaxException {
        QuasiBundle exporterQuasiBundle;
        BundleManifest exporterBundleManifest = getBundleManifest(EXPORTER_BSN, BUNDLE_VERSION);
        exporterBundleManifest.getExportPackage().addExportedPackage(QUASI_TEST_PACKAGE);

        exporterQuasiBundle = this.quasiFramework.install(new URI(EXPORTER_JAR_PATH), exporterBundleManifest);
        Assert.assertEquals(EXPORTER_BSN, exporterQuasiBundle.getSymbolicName());
        Assert.assertEquals(BUNDLE_VERSION, exporterQuasiBundle.getVersion());
        Assert.assertFalse(exporterQuasiBundle.isResolved());
        Assert.assertNull(exporterQuasiBundle.getBundle());
        return exporterQuasiBundle;
    }

    private QuasiBundle installImporterBundle() throws BundleException, URISyntaxException {
        QuasiBundle importerQuasiBundle;
        BundleManifest importerBundleManifest = getBundleManifest(IMPORTER_BSN, BUNDLE_VERSION);
        importerBundleManifest.getImportPackage().addImportedPackage(QUASI_TEST_PACKAGE);

        importerQuasiBundle = this.quasiFramework.install(new URI(IMPORTER_JAR_PATH), importerBundleManifest);
        Assert.assertEquals(IMPORTER_BSN, importerQuasiBundle.getSymbolicName());
        Assert.assertEquals(BUNDLE_VERSION, importerQuasiBundle.getVersion());
        Assert.assertFalse(importerQuasiBundle.isResolved());
        Assert.assertNull(importerQuasiBundle.getBundle());
        return importerQuasiBundle;
    }
    
    private QuasiBundle installRequiringBundle() throws BundleException, URISyntaxException {
        QuasiBundle requiringQuasiBundle;
        BundleManifest requiringBundleManifest = getBundleManifest(REQUIRING_BSN, BUNDLE_VERSION);
        RequireBundle requireBundle = requiringBundleManifest.getRequireBundle();
        requireBundle.addRequiredBundle(EXPORTER_BSN);

        requiringQuasiBundle = this.quasiFramework.install(new URI(IMPORTER_JAR_PATH), requiringBundleManifest);
        Assert.assertEquals(REQUIRING_BSN, requiringQuasiBundle.getSymbolicName());
        Assert.assertEquals(BUNDLE_VERSION, requiringQuasiBundle.getVersion());
        Assert.assertFalse(requiringQuasiBundle.isResolved());
        Assert.assertNull(requiringQuasiBundle.getBundle());
        return requiringQuasiBundle;
    }

    private BundleManifest getBundleManifest(String symbolicName, Version bundleVersion) {
        BundleManifest bundleManifest;
        bundleManifest = BundleManifestFactory.createBundleManifest();
        bundleManifest.setBundleManifestVersion(2);
        bundleManifest.getBundleSymbolicName().setSymbolicName(symbolicName);
        bundleManifest.setBundleVersion(bundleVersion);
        return bundleManifest;
    }

}