RequirementsCapabilitiesTest.java

/*
 * 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.felix.framework;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;

import junit.framework.TestCase;

import org.osgi.framework.Bundle;
import org.osgi.framework.Constants;
import org.osgi.framework.Version;
import org.osgi.framework.launch.Framework;
import org.osgi.framework.wiring.BundleCapability;
import org.osgi.framework.wiring.BundleRevision;
import org.osgi.framework.wiring.BundleWiring;
import org.osgi.resource.Capability;
import org.osgi.resource.Resource;

public class RequirementsCapabilitiesTest extends TestCase
{
    private File tempDir;
    private Framework felix;
    private File cacheDir;

    @Override
    protected void setUp() throws Exception
    {
        super.setUp();
        tempDir = File.createTempFile("felix-temp", ".dir");
        assertTrue("precondition", tempDir.delete());
        assertTrue("precondition", tempDir.mkdirs());

        cacheDir = new File(tempDir, "felix-cache");
        assertTrue("precondition", cacheDir.mkdir());

        String cache = cacheDir.getPath();

        Map<String,String> params = new HashMap<String, String>();
        params.put("felix.cache.profiledir", cache);
        params.put("felix.cache.dir", cache);
        params.put(Constants.FRAMEWORK_STORAGE, cache);

        felix = new Felix(params);
        felix.init();
        felix.start();
    }

    @Override
    protected void tearDown() throws Exception
    {
        super.tearDown();

        felix.stop(); // Note that this method is async
        felix = null;

        deleteDir(tempDir);
        tempDir = null;
        cacheDir = null;
    }

    public void testIdentityCapabilityBundleFragment() throws Exception
    {
        String bmf = "Bundle-SymbolicName: cap.bundle\n"
                + "Bundle-Version: 1.2.3.Blah\n"
                + "Bundle-ManifestVersion: 2\n"
                + "Import-Package: org.osgi.framework\n";
        File bundleFile = createBundle(bmf);

        String fmf = "Bundle-SymbolicName: cap.frag\n"
                + "Bundle-Version: 1.0.0\n"
                + "Fragment-Host: cap.bundle\n"
                + "Bundle-ManifestVersion: 2\n"
                + "Export-Package: org.foo.bar;version=\"2.0.0\"\n"
                + "Import-Package: org.osgi.util.tracker\n";
        File fragFile = createBundle(fmf);

        Bundle b = felix.getBundleContext().installBundle(bundleFile.toURI().toASCIIString());
        Bundle f = felix.getBundleContext().installBundle(fragFile.toURI().toASCIIString());

        // Check the bundle capabilities.
        // First check the capabilities on the Bundle Revision, which is available on installed bundles
        BundleRevision bbr = b.adapt(BundleRevision.class);
        List<Capability> bwbCaps = bbr.getCapabilities("osgi.wiring.bundle");
        assertEquals(1, bwbCaps.size());

        Map<String, Object> expectedBWBAttrs = new HashMap<String, Object>();
        expectedBWBAttrs.put("osgi.wiring.bundle", "cap.bundle");
        expectedBWBAttrs.put("bundle-version", Version.parseVersion("1.2.3.Blah"));
        Capability expectedBWBCap = new TestCapability("osgi.wiring.bundle",
                expectedBWBAttrs, Collections.<String, String>emptyMap());
        assertCapsEquals(expectedBWBCap, bwbCaps.get(0));

        List<Capability> bwhCaps = bbr.getCapabilities("osgi.wiring.host");
        assertEquals(1, bwhCaps.size());

        Map<String, Object> expectedBWHAttrs = new HashMap<String, Object>();
        expectedBWHAttrs.put("osgi.wiring.host", "cap.bundle");
        expectedBWHAttrs.put("bundle-version", Version.parseVersion("1.2.3.Blah"));
        Capability expectedBWHCap = new TestCapability("osgi.wiring.host",
                expectedBWHAttrs, Collections.<String, String>emptyMap());
        assertCapsEquals(expectedBWHCap, bwhCaps.get(0));

        List<Capability> bwiCaps = bbr.getCapabilities("osgi.identity");
        assertEquals(1, bwiCaps.size());

        Map<String, Object> expectedBWIAttrs = new HashMap<String, Object>();
        expectedBWIAttrs.put("osgi.identity", "cap.bundle");
        expectedBWIAttrs.put("type", "osgi.bundle");
        expectedBWIAttrs.put("version", Version.parseVersion("1.2.3.Blah"));
        Capability expectedBWICap = new TestCapability("osgi.identity",
                expectedBWIAttrs, Collections.<String, String>emptyMap());
        assertCapsEquals(expectedBWICap, bwiCaps.get(0));

        assertEquals("The Bundle should not directly expose osgi.wiring.package",
                0, bbr.getCapabilities("osgi.wiring.package").size());

        // Check the fragment's capabilities.
        // First check the capabilities on the Bundle Revision, which is available on installed fragments
        BundleRevision fbr = f.adapt(BundleRevision.class);
        List<Capability> fwpCaps = fbr.getCapabilities("osgi.wiring.package");
        assertEquals(1, fwpCaps.size());

        Map<String, Object> expectedFWAttrs = new HashMap<String, Object>();
        expectedFWAttrs.put("osgi.wiring.package", "org.foo.bar");
        expectedFWAttrs.put("version", Version.parseVersion("2"));
        expectedFWAttrs.put("bundle-symbolic-name", "cap.frag");
        expectedFWAttrs.put("bundle-version", Version.parseVersion("1.0.0"));
        Capability expectedFWCap = new TestCapability("osgi.wiring.package",
                expectedFWAttrs, Collections.<String, String>emptyMap());
        assertCapsEquals(expectedFWCap, fwpCaps.get(0));

        List<Capability> fiCaps = fbr.getCapabilities("osgi.identity");
        assertEquals(1, fiCaps.size());
        Map<String, Object> expectedFIAttrs = new HashMap<String, Object>();
        expectedFIAttrs.put("osgi.identity", "cap.frag");
        expectedFIAttrs.put("type", "osgi.fragment");
        expectedFIAttrs.put("version", Version.parseVersion("1.0.0"));
        Capability expectedFICap = new TestCapability("osgi.identity",
                expectedFIAttrs, Collections.<String, String>emptyMap());
        assertCapsEquals(expectedFICap, fiCaps.get(0));

        // Start the bundle. This will make the BundleWiring available on both the bundle and the fragment
        b.start();

        // Check the Bundle Wiring on the fragment. It should only contain the osgi.identity capability
        // All the other capabilities should have migrated to the bundle's BundleWiring.
        BundleWiring fbw = f.adapt(BundleWiring.class);
        List<BundleCapability> fbwCaps = fbw.getCapabilities(null);
        assertEquals("Fragment should only have 1 capability: it's osgi.identity", 1, fbwCaps.size());
        assertCapsEquals(expectedFICap, fbwCaps.get(0));

        // Check the Bundle Wiring on the bundle. It should contain all the capabilities originally on the
        // bundle and also contain the osgi.wiring.package capability from the fragment.
        BundleWiring bbw = b.adapt(BundleWiring.class);
        List<BundleCapability> bwbCaps2 = bbw.getCapabilities("osgi.wiring.bundle");
        assertEquals(1, bwbCaps2.size());
        assertCapsEquals(expectedBWBCap, bwbCaps2.get(0));
        List<BundleCapability> bwhCaps2 = bbw.getCapabilities("osgi.wiring.host");
        assertEquals(1, bwhCaps2.size());
        assertCapsEquals(expectedBWHCap, bwhCaps2.get(0));
        List<BundleCapability> bwiCaps2 = bbw.getCapabilities("osgi.identity");
        assertEquals(1, bwiCaps2.size());
        assertCapsEquals(expectedBWICap, bwiCaps2.get(0));
        List<BundleCapability> bwpCaps2 = bbw.getCapabilities("osgi.wiring.package");
        assertEquals("Bundle should have inherited the osgi.wiring.package capability from the fragment",
                1, bwpCaps2.size());
        assertCapsEquals(expectedFWCap, bwpCaps2.get(0));
    }

    public void testIdentityCapabilityFrameworkExtension() throws Exception
    {
        String femf = "Bundle-SymbolicName: fram.ext\n"
                + "Bundle-Version: 1.2.3.test\n"
                + "Fragment-Host: system.bundle; extension:=framework\n"
                + "Bundle-ManifestVersion: 2\n"
                + "Export-Package: org.foo.bar;version=\"2.0.0\"\n";
        File feFile = createBundle(femf);

        Bundle fe = felix.getBundleContext().installBundle(feFile.toURI().toASCIIString());

        BundleRevision fbr = fe.adapt(BundleRevision.class);

        List<Capability> feCaps = fbr.getCapabilities("osgi.identity");
        assertEquals(1, feCaps.size());
        Map<String, Object> expectedFEAttrs = new HashMap<String, Object>();
        expectedFEAttrs.put("osgi.identity", "fram.ext");
        expectedFEAttrs.put("type", "osgi.fragment");
        expectedFEAttrs.put("version", Version.parseVersion("1.2.3.test"));
        Capability expectedFICap = new TestCapability("osgi.identity",
                expectedFEAttrs, Collections.<String, String>emptyMap());
        assertCapsEquals(expectedFICap, feCaps.get(0));
    }

    private File createBundle(String manifest) throws IOException
    {
        File f = File.createTempFile("felix-bundle", ".jar", tempDir);

        Manifest mf = new Manifest(new ByteArrayInputStream(manifest.getBytes("utf-8")));
        mf.getMainAttributes().putValue("Manifest-Version", "1.0");
        JarOutputStream os = new JarOutputStream(new FileOutputStream(f), mf);
        os.close();
        return f;
    }

    private static void assertCapsEquals(Capability expected, Capability actual)
    {
        assertEquals(expected.getNamespace(), actual.getNamespace());
        assertSubMap(expected.getAttributes(), actual.getAttributes());
        assertSubMap(expected.getDirectives(), actual.getDirectives());
        // We ignore the resource in the comparison
    }

    private static void assertSubMap(Map<?,?> subMap, Map<?,?> fullMap)
    {
        for (Map.Entry<?,?> entry : subMap.entrySet())
        {
            assertEquals(entry.getValue(), fullMap.get(entry.getKey()));
        }
    }

    private static void deleteDir(File root) throws IOException
    {
        if (root.isDirectory())
        {
            for (File file : root.listFiles())
            {
                deleteDir(file);
            }
        }
        assertTrue(root.delete());
    }

    static class TestCapability implements Capability
    {
        private final String namespace;
        private final Map<String, Object> attributes;
        private final Map<String, String> directives;

        TestCapability(String ns, Map<String,Object> attrs, Map<String,String> dirs)
        {
            namespace = ns;
            attributes = attrs;
            directives = dirs;
        }

        public String getNamespace()
        {
            return namespace;
        }

        public Map<String, Object> getAttributes()
        {
            return attributes;
        }

        public Map<String, String> getDirectives()
        {
            return directives;
        }

        public Resource getResource()
        {
            return null;
        }
    }
}