TrackedPackageImportsTests.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.userregion.internal.importexpansion;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Assert;
import org.junit.Test;

import org.eclipse.virgo.kernel.osgi.framework.ImportMergeException;
import org.eclipse.virgo.kernel.userregion.internal.importexpansion.StandardTrackedPackageImportsFactory;
import org.eclipse.virgo.kernel.userregion.internal.importexpansion.TrackedPackageImports;
import org.eclipse.virgo.kernel.userregion.internal.importexpansion.TrackedPackageImportsFactory;
import org.eclipse.virgo.util.osgi.manifest.VersionRange;
import org.eclipse.virgo.util.osgi.manifest.BundleManifest;
import org.eclipse.virgo.util.osgi.manifest.BundleManifestFactory;
import org.eclipse.virgo.util.osgi.manifest.ImportedPackage;
import org.eclipse.virgo.util.osgi.manifest.Resolution;

/**
 */
public class TrackedPackageImportsTests {

    private static final String TEST_SOURCE = "test source";

    private final TrackedPackageImportsFactory trackedPackageImportsFactory = new StandardTrackedPackageImportsFactory();

    @Test public void testTrivialMerge() throws ImportMergeException, IOException {

        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader("bundle-symbolicname: A\nimport-package: p"));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader("bundle-symbolicname: B\nimport-package: p"));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);
        
        TrackedPackageImports empty = this.trackedPackageImportsFactory.createEmpty();
        
        Assert.assertTrue(empty.isEmpty());
        Assert.assertFalse(tpiB.isEmpty());
        Assert.assertTrue(tpiA.isEquivalent(tpiB));
        Assert.assertFalse(tpiA.isEquivalent(empty));

        tpiB.merge(tpiA);
        tpiB.merge(empty);
        Map<String, ImportedPackage> mergedImports = convertImportedPackageListToMap(tpiB.getMergedImports());
        ImportedPackage pImport = mergedImports.get("p");
        Assert.assertNotNull("Missing merged import", pImport);
    }

    @Test public void testOverlappingVersionRanges() throws ImportMergeException, IOException {

        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;version=\"[1,3]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;version=\"2\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        tpiB.merge(tpiA);
        Map<String, ImportedPackage> mergedImports = convertImportedPackageListToMap(tpiB.getMergedImports());
        ImportedPackage pImport = mergedImports.get("p");
        Assert.assertNotNull("Missing merged import", pImport);
        VersionRange v = new VersionRange(pImport.getAttributes().get("version"));
        Assert.assertTrue("Incorrectly merged version", v.isFloorInclusive() && v.isCeilingInclusive() && v.getFloor().getMajor() == 2
            && v.getCeiling().getMajor() == 3);
    }

    @Test public void testDisjointVersionRanges() throws IOException {
      
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;version=\"[1,2]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;version=\"[3,4]\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        try {
            tpiB.merge(tpiA);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            Assert.assertEquals("Incorrect sources", "bundle B, bundle A", e.getSources());
        }
    }

    @Test public void testOverlappingBundleVersionRanges() throws ImportMergeException, IOException {

        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;bundle-version=\"[1,3]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;bundle-version=\"2\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        tpiB.merge(tpiA);
        Map<String, ImportedPackage> mergedImports = convertImportedPackageListToMap(tpiB.getMergedImports());
        ImportedPackage pImport = mergedImports.get("p");
        Assert.assertNotNull("Missing merged import", pImport);
        VersionRange v = new VersionRange(pImport.getAttributes().get("bundle-version"));
        Assert.assertTrue("Incorrectly merged version", v.isFloorInclusive() && v.isCeilingInclusive() && v.getFloor().getMajor() == 2
            && v.getCeiling().getMajor() == 3);
    }

    @Test public void testDisjointBundleVersionRanges() throws IOException {
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;bundle-version=\"[1,2]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;bundle-version=\"[3,4]\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        try {
            tpiB.merge(tpiA);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            Assert.assertEquals("Incorrect sources", "bundle B, bundle A", e.getSources());
        }
    }

    @Test public void testResolution() throws ImportMergeException, IOException {
        
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;resolution:=optional"));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;resolution:=mandatory"));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        tpiB.merge(tpiA);
        Map<String, ImportedPackage> mergedImports = convertImportedPackageListToMap(tpiB.getMergedImports());
        ImportedPackage pImport = mergedImports.get("p");
        Assert.assertNotNull("Missing merged import", pImport);
        Assert.assertTrue("Incorrectly merged resolution", pImport.getResolution() == Resolution.MANDATORY);
    }

    @Test public void testConsistentAttributes() throws ImportMergeException, IOException {
        
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;a1=v1;a2=v2"));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;a1=v1;a3=v3"));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        tpiB.merge(tpiA);
        Map<String, ImportedPackage> mergedImports = convertImportedPackageListToMap(tpiB.getMergedImports());
        ImportedPackage pImport = mergedImports.get("p");
        Assert.assertNotNull("Missing merged import", pImport);
        Map<String, String> pAttrs = pImport.getAttributes();
        Assert.assertEquals("Incorrectly merged attribute for a1", "v1", pAttrs.get("a1"));
        Assert.assertEquals("Incorrectly merged attribute for a2", "v2", pAttrs.get("a2"));
        Assert.assertEquals("Incorrectly merged attribute for a3", "v3", pAttrs.get("a3"));
    }

    @Test public void testInconsistentAttributes() throws ImportMergeException, IOException {
        
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader("bundle-symbolicname: A\nimport-package: p;a1=v1"));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader("bundle-symbolicname: B\nimport-package: p;a1=v2"));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        BundleManifest manifestC = BundleManifestFactory.createBundleManifest(new StringReader("bundle-symbolicname: C\nimport-package: q"));
        TrackedPackageImports tpiC = this.trackedPackageImportsFactory.create(manifestC);
        tpiB.merge(tpiC);

        try {
            tpiB.merge(tpiA);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            Assert.assertEquals("Incorrect sources", "bundle B, bundle A", e.getSources());
        }
    }

    @Test public void testTrivialAddition() throws ImportMergeException, IOException {

        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader("bundle-symbolicname: A\nimport-package: p"));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        ImportedPackage packageImport = BundleManifestFactory.createBundleManifest().getImportPackage().addImportedPackage("p");
        List<ImportedPackage> packageImports = new ArrayList<ImportedPackage>();
        packageImports.add(packageImport);
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(packageImports, TEST_SOURCE);

        tpiA.merge(tpiB);
        Map<String, ImportedPackage> mergedImports = convertImportedPackageListToMap(tpiA.getMergedImports());
        ImportedPackage pImport = mergedImports.get("p");
        Assert.assertNotNull("Missing merged import", pImport);
    }

    @Test public void testClashingAddition() throws IOException {

        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;attr=x"));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        ImportedPackage packageImport = BundleManifestFactory.createBundleManifest().getImportPackage().addImportedPackage("p");
        packageImport.getAttributes().put("attr", "y");
        List<ImportedPackage> packageImports = new ArrayList<ImportedPackage>();
        packageImports.add(packageImport);
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(packageImports, TEST_SOURCE);

        try {
            tpiA.merge(tpiB);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            Assert.assertEquals("Incorrect sources", "bundle A, " + TEST_SOURCE, e.getSources());
        }
    }

    @Test public void testOverlappingVersionRangesInCollection() throws ImportMergeException, IOException {

        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;version=\"[1,3]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;version=\"2\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        TrackedPackageImports tpiC = this.trackedPackageImportsFactory.createCollector();

        tpiC.merge(tpiB);
        tpiC.merge(tpiA);

        Map<String, ImportedPackage> mergedImports = convertImportedPackageListToMap(tpiC.getMergedImports());
        ImportedPackage pImport = mergedImports.get("p");
        Assert.assertNotNull("Missing merged import", pImport);
        VersionRange v = new VersionRange(pImport.getAttributes().get("version"));
        Assert.assertTrue("Incorrectly merged version", v.isFloorInclusive() && v.isCeilingInclusive() && v.getFloor().getMajor() == 2
            && v.getCeiling().getMajor() == 3);
    }

    @Test public void testDisjointVersionRangesInCollection() throws IOException {
        
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;version=\"[1,2]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;version=\"[3,4]\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        TrackedPackageImports tpiC = this.trackedPackageImportsFactory.createCollector();

        try {
            tpiC.merge(tpiB);
            tpiC.merge(tpiA);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            Assert.assertEquals("Incorrect sources", "bundle B, bundle A", e.getSources());
        }
    }

    @Test public void testThreeWayClash() throws IOException {
        
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;version=\"[1,2]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;version=\"[2,3]\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        TrackedPackageImports tpiC = this.trackedPackageImportsFactory.createCollector();

        BundleManifest manifestD = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: D\nimport-package: p;version=\"[3,3]\""));
        TrackedPackageImports tpiD = this.trackedPackageImportsFactory.create(manifestD);

        try {
            tpiC.merge(tpiB);
            tpiC.merge(tpiA);
            tpiD.merge(tpiC);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            /*
             * Note that in a N-way clash of version ranges, there must be a pair of version ranges that clash, but the
             * current implementation simply reports all N.
             */
            Assert.assertEquals("Incorrect sources", "bundle D, bundle B, bundle A", e.getSources());
        }
    }

    @Test public void testThreeWayNestedClash() throws IOException {
        
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;version=\"[1,2]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;version=\"[2,3]\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        BundleManifest manifestD = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: D\nimport-package: p;version=\"[3,3]\""));
        TrackedPackageImports tpiD = this.trackedPackageImportsFactory.create(manifestD);

        TrackedPackageImports tpiContainer = this.trackedPackageImportsFactory.createContainer("container");

        try {
            tpiContainer.merge(tpiA);
            tpiContainer.merge(tpiB);
            tpiD.merge(tpiContainer);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            /*
             * Note that in a N-way clash of version ranges, there must be a pair of version ranges that clash, but the
             * current implementation simply reports all N.
             */
            Assert.assertEquals("Incorrect sources", "bundle D, container(bundle A, bundle B)", e.getSources());
        }
    }

    @Test public void testFourWayNestedClashInACollector() throws IOException {
        
        BundleManifest manifestA = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: A\nimport-package: p;version=\"[1,2]\""));
        TrackedPackageImports tpiA = this.trackedPackageImportsFactory.create(manifestA);

        BundleManifest manifestB = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: B\nimport-package: p;version=\"[2,3]\""));
        TrackedPackageImports tpiB = this.trackedPackageImportsFactory.create(manifestB);

        BundleManifest manifestC = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: C\nimport-package: p;version=\"[3,4]\""));
        TrackedPackageImports tpiC = this.trackedPackageImportsFactory.create(manifestC);

        BundleManifest manifestD = BundleManifestFactory.createBundleManifest(new StringReader(
            "bundle-symbolicname: D\nimport-package: p;version=\"[4,5]\""));
        TrackedPackageImports tpiD = this.trackedPackageImportsFactory.create(manifestD);

        TrackedPackageImports tpiContainerX = this.trackedPackageImportsFactory.createContainer("containerX");
        
        TrackedPackageImports tpiContainerY = this.trackedPackageImportsFactory.createContainer("containerY");
        
        TrackedPackageImports tpiCollector = this.trackedPackageImportsFactory.createCollector();

        try {
            tpiContainerX.merge(tpiA);
            tpiContainerX.merge(tpiB);
            tpiContainerY.merge(tpiC);
            tpiContainerY.merge(tpiD);
            tpiCollector.merge(tpiContainerX);
            tpiCollector.merge(tpiContainerY);
            Assert.assertTrue("Exception should be thrown", false);
        } catch (ImportMergeException e) {
            System.out.println(e);
            Assert.assertEquals("Incorrect conflicting package name", "p", e.getConflictingPackageName());
            /*
             * Note that in a N-way clash of version ranges, there must be a pair of version ranges that clash, but the
             * current implementation simply reports all N.
             */
            Assert.assertEquals("Incorrect sources", "containerX(bundle A, bundle B), containerY(bundle C, bundle D)", e.getSources());
        }
    }

    /**
     * Convert a given list of package imports with no duplicate package names to a map of package name to
     * {@link ImportedPackage}.
     * 
     * @param importedPackages a list of <code>PackageImport</code>
     * @return a map of package name to <code>PackageImport</code>
     */
    private static Map<String, ImportedPackage> convertImportedPackageListToMap(List<ImportedPackage> importedPackages) {
        Map<String, ImportedPackage> initialPackageImports = new HashMap<String, ImportedPackage>();
        for (ImportedPackage importedPackage : importedPackages) {            
            Assert.assertNull(initialPackageImports.put(importedPackage.getPackageName(), importedPackage));
        }
        return initialPackageImports;
    }
}