/*******************************************************************************
* 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.model.internal.bundle;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.reset;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.equinox.region.Region;
import org.eclipse.equinox.region.RegionDigraph;
import org.eclipse.virgo.kernel.model.Artifact;
import org.eclipse.virgo.kernel.model.BundleArtifact;
import org.eclipse.virgo.kernel.model.RuntimeArtifactRepository;
import org.eclipse.virgo.kernel.model.StubArtifactRepository;
import org.eclipse.virgo.kernel.model.StubCompositeArtifact;
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.QuasiRequiredBundle;
import org.eclipse.virgo.nano.serviceability.Assert.FatalAssertionException;
import org.junit.Before;
import org.junit.Test;
import org.osgi.framework.Version;
public class BundleDependencyDeterminerTests {
private static final String BUNDLE_TYPE = "bundle";
private static final Version TEST_BUNDLE_VERSION = Version.emptyVersion;
private static final String TEST_BUNDLE_NAME = "bundle";
private static final String EXPORTING_BUNDLE_NAME = "exportingBundle";
private static final String HOST_BUNDLE_NAME = "hostBundle";
private static final String REQUIRED_BUNDLE_NAME = "requiredBundle";
private static final String REGION_A_NAME = "regionA-name";
private static final String REGION_B_NAME = "regionB-name";
private static final long BUNDLE_1_ID = 10l;
private static final long BUNDLE_2_ID = 100l;
private static final long EXPORTING_BUNDLE_ID = 2l;
private static final long HOST_BUNDLE_ID = 3l;
private static final long REQUIRED_BUNDLE_ID = 4l;
private final QuasiFrameworkFactory quasiFrameworkFactory = createMock(QuasiFrameworkFactory.class);
private final RuntimeArtifactRepository artifactRepository = new StubArtifactRepository();
private final RegionDigraph regionDigraph = createMock(RegionDigraph.class);
private final Region regionA = createMock(Region.class);
private final Region regionB = createMock(Region.class);
private final BundleDependencyDeterminer determiner = new BundleDependencyDeterminer(quasiFrameworkFactory, artifactRepository, regionDigraph);
private QuasiBundle bundle1;
private QuasiBundle bundle2;
@Before
public void setUp() {
reset(quasiFrameworkFactory, regionDigraph);
}
@Test(expected = FatalAssertionException.class)
public void nullFactory() {
new BundleDependencyDeterminer(null, artifactRepository, regionDigraph);
}
@Test(expected = FatalAssertionException.class)
public void nullRepository() {
new BundleDependencyDeterminer(quasiFrameworkFactory, null, regionDigraph);
}
@Test(expected = FatalAssertionException.class)
public void nullRegionDigraph() {
new BundleDependencyDeterminer(quasiFrameworkFactory, artifactRepository, null);
}
@Test
public void unknownBundle() {
QuasiFramework framework = createMock(QuasiFramework.class);
replay(quasiFrameworkFactory, regionDigraph, framework);
Set<Artifact> dependents = this.determiner.getDependents(new StubCompositeArtifact("bar", "foo", regionB));
assertEquals(Collections.<Artifact> emptySet(), dependents);
verify(quasiFrameworkFactory, regionDigraph, framework);
}
@Test
public void bundleFromDifferentRegion() {
setTestBundleExpectations();
QuasiFramework framework = createMock(QuasiFramework.class);
expect(quasiFrameworkFactory.create()).andReturn(framework);
expect(framework.getBundles()).andReturn(getTestBundleSet());
expect(bundle2.getHosts()).andReturn(null).anyTimes();
expect(bundle2.getRequiredBundles()).andReturn(null).anyTimes();
expect(regionDigraph.getRegion(BUNDLE_1_ID)).andReturn(regionA);
expect(regionDigraph.getRegion(BUNDLE_2_ID)).andReturn(regionB);
expect(regionB.getName()).andReturn(REGION_B_NAME).anyTimes();
expect(bundle2.getImportPackages()).andReturn(new ArrayList<QuasiImportPackage>());
BundleArtifact bundleArtifact = createMockBundleArtifact(TEST_BUNDLE_NAME, TEST_BUNDLE_VERSION, regionB);
replay(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionB);
Set<Artifact> dependents = this.determiner.getDependents(bundleArtifact);
assertEquals(Collections.<Artifact> emptySet(), dependents);
verify(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionB);
}
private void setTestBundleExpectations() {
this.bundle1 = createMockQuasiBundle(TEST_BUNDLE_NAME, TEST_BUNDLE_VERSION, BUNDLE_1_ID);
this.bundle2 = createMockQuasiBundle(TEST_BUNDLE_NAME, TEST_BUNDLE_VERSION, BUNDLE_2_ID);
}
private static QuasiBundle createMockQuasiBundle(String bundleSymbolicName, Version bundleVersion, long bundleId) {
QuasiBundle quasiBundle = createMock(QuasiBundle.class);
expect(quasiBundle.getSymbolicName()).andReturn(bundleSymbolicName).anyTimes();
expect(quasiBundle.getVersion()).andReturn(bundleVersion).anyTimes();
expect(quasiBundle.getBundleId()).andReturn(bundleId).anyTimes();
return quasiBundle;
}
private static BundleArtifact createMockBundleArtifact(String bundleSymbolicName, Version bundleVersion, Region region) {
BundleArtifact bundleArtifact = createMock(BundleArtifact.class);
expect(bundleArtifact.getType()).andReturn(BUNDLE_TYPE).anyTimes();
expect(bundleArtifact.getName()).andReturn(bundleSymbolicName).anyTimes();
expect(bundleArtifact.getVersion()).andReturn(bundleVersion).anyTimes();
expect(bundleArtifact.getRegion()).andReturn(region).anyTimes();
return bundleArtifact;
}
@Test
public void bundleWithImport() {
setTestBundleExpectations();
QuasiFramework framework = createMock(QuasiFramework.class);
expect(quasiFrameworkFactory.create()).andReturn(framework);
expect(framework.getBundles()).andReturn(getTestBundleSet());
QuasiImportPackage importedPackage = createMock(QuasiImportPackage.class);
QuasiExportPackage provider = createMock(QuasiExportPackage.class);
QuasiBundle exporter = createMockQuasiBundle(EXPORTING_BUNDLE_NAME, TEST_BUNDLE_VERSION, EXPORTING_BUNDLE_ID);
expect(provider.getExportingBundle()).andReturn(exporter);
expect(importedPackage.getProvider()).andReturn(provider);
ArrayList<QuasiImportPackage> b = new ArrayList<QuasiImportPackage>();
b.add(importedPackage);
expect(bundle1.getImportPackages()).andReturn(b);
expect(bundle1.getHosts()).andReturn(new ArrayList<QuasiBundle>());
expect(bundle1.getRequiredBundles()).andReturn(new ArrayList<QuasiRequiredBundle>());
expect(regionDigraph.getRegion(BUNDLE_1_ID)).andReturn(regionA);
expect(regionDigraph.getRegion(EXPORTING_BUNDLE_ID)).andReturn(regionB);
expect(regionA.getName()).andReturn(REGION_A_NAME).anyTimes();
expect(regionB.getName()).andReturn(REGION_B_NAME).anyTimes();
BundleArtifact bundleArtifact = createMockBundleArtifact(TEST_BUNDLE_NAME, TEST_BUNDLE_VERSION, regionA);
BundleArtifact exporterArtifact = createMockBundleArtifact(EXPORTING_BUNDLE_NAME, TEST_BUNDLE_VERSION, regionB);
this.artifactRepository.add(exporterArtifact);
replay(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionA, regionB, importedPackage, provider,
exporter, exporterArtifact);
Set<Artifact> dependents = this.determiner.getDependents(bundleArtifact);
Set<Artifact> expected = new HashSet<Artifact>();
expected.add(exporterArtifact);
assertEquals(expected, dependents);
verify(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionA, regionB, importedPackage, provider,
exporter, exporterArtifact);
}
@Test
public void bundleWithHost() {
setTestBundleExpectations();
QuasiFramework framework = createMock(QuasiFramework.class);
expect(quasiFrameworkFactory.create()).andReturn(framework);
expect(framework.getBundles()).andReturn(getTestBundleSet());
expect(bundle1.getImportPackages()).andReturn(new ArrayList<QuasiImportPackage>());
ArrayList<QuasiBundle> b = new ArrayList<QuasiBundle>();
QuasiBundle host = createMockQuasiBundle(HOST_BUNDLE_NAME, TEST_BUNDLE_VERSION, HOST_BUNDLE_ID);
b.add(host);
expect(bundle1.getHosts()).andReturn(b);
expect(bundle1.getRequiredBundles()).andReturn(new ArrayList<QuasiRequiredBundle>());
expect(regionDigraph.getRegion(BUNDLE_1_ID)).andReturn(regionA);
expect(regionDigraph.getRegion(HOST_BUNDLE_ID)).andReturn(regionB);
expect(regionA.getName()).andReturn(REGION_A_NAME).anyTimes();
expect(regionB.getName()).andReturn(REGION_B_NAME).anyTimes();
BundleArtifact bundleArtifact = createMockBundleArtifact(TEST_BUNDLE_NAME, TEST_BUNDLE_VERSION, regionA);
BundleArtifact hostArtifact = createMockBundleArtifact(HOST_BUNDLE_NAME, TEST_BUNDLE_VERSION, regionB);
this.artifactRepository.add(hostArtifact);
replay(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionA, regionB, host, hostArtifact);
Set<Artifact> dependents = this.determiner.getDependents(bundleArtifact);
Set<Artifact> expected = new HashSet<Artifact>();
expected.add(hostArtifact);
assertEquals(expected, dependents);
verify(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionA, regionB, host, hostArtifact);
}
@Test
public void bundleRequiringAnotherBundle() {
setTestBundleExpectations();
QuasiFramework framework = createMock(QuasiFramework.class);
expect(quasiFrameworkFactory.create()).andReturn(framework);
expect(framework.getBundles()).andReturn(getTestBundleSet());
expect(bundle1.getImportPackages()).andReturn(new ArrayList<QuasiImportPackage>());
ArrayList<QuasiRequiredBundle> b = new ArrayList<QuasiRequiredBundle>();
QuasiBundle required = createMockQuasiBundle(REQUIRED_BUNDLE_NAME, TEST_BUNDLE_VERSION, REQUIRED_BUNDLE_ID);
expect(bundle1.getHosts()).andReturn(new ArrayList<QuasiBundle>());
QuasiRequiredBundle requiredBundle = createMock(QuasiRequiredBundle.class);
expect(requiredBundle.getProvider()).andReturn(required);
b.add(requiredBundle);
expect(bundle1.getRequiredBundles()).andReturn(b);
expect(regionDigraph.getRegion(BUNDLE_1_ID)).andReturn(regionA);
expect(regionDigraph.getRegion(REQUIRED_BUNDLE_ID)).andReturn(regionB);
expect(regionA.getName()).andReturn(REGION_A_NAME).anyTimes();
expect(regionB.getName()).andReturn(REGION_B_NAME).anyTimes();
BundleArtifact bundleArtifact = createMockBundleArtifact(TEST_BUNDLE_NAME, TEST_BUNDLE_VERSION, regionA);
BundleArtifact requiredArtifact = createMockBundleArtifact(REQUIRED_BUNDLE_NAME, TEST_BUNDLE_VERSION, regionB);
this.artifactRepository.add(requiredArtifact);
replay(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionA, regionB, requiredBundle, required,
requiredArtifact);
Set<Artifact> dependents = this.determiner.getDependents(bundleArtifact);
Set<Artifact> expected = new HashSet<Artifact>();
expected.add(requiredArtifact);
assertEquals(expected, dependents);
verify(bundleArtifact, quasiFrameworkFactory, regionDigraph, framework, bundle1, bundle2, regionA, regionB, requiredBundle, required,
requiredArtifact);
}
private List<QuasiBundle> getTestBundleSet() {
List<QuasiBundle> bundles = new ArrayList<QuasiBundle>();
bundles.add(bundle1);
bundles.add(bundle2);
return bundles;
}
}