| /* |
| * 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.ivy.osgi.obr; |
| |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.text.ParseException; |
| import java.util.Arrays; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.jar.JarInputStream; |
| import java.util.jar.Manifest; |
| |
| import org.apache.ivy.Ivy; |
| import org.apache.ivy.core.cache.RepositoryCacheManager; |
| import org.apache.ivy.core.module.descriptor.Artifact; |
| import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor; |
| import org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor; |
| import org.apache.ivy.core.module.id.ModuleRevisionId; |
| import org.apache.ivy.core.report.ArtifactDownloadReport; |
| import org.apache.ivy.core.report.DownloadReport; |
| import org.apache.ivy.core.report.DownloadStatus; |
| import org.apache.ivy.core.report.ResolveReport; |
| import org.apache.ivy.core.resolve.DownloadOptions; |
| import org.apache.ivy.core.resolve.ResolveData; |
| import org.apache.ivy.core.resolve.ResolveOptions; |
| import org.apache.ivy.core.resolve.ResolvedModuleRevision; |
| import org.apache.ivy.core.settings.IvySettings; |
| import org.apache.ivy.osgi.core.BundleArtifact; |
| import org.apache.ivy.osgi.core.BundleInfo; |
| import org.apache.ivy.osgi.core.BundleInfoAdapter; |
| import org.apache.ivy.osgi.core.ExecutionEnvironmentProfileProvider; |
| import org.apache.ivy.osgi.core.ManifestParser; |
| import org.apache.ivy.osgi.core.OSGiManifestParser; |
| import org.apache.ivy.osgi.repo.AbstractOSGiResolver.RequirementStrategy; |
| import org.apache.ivy.plugins.resolver.DependencyResolver; |
| import org.apache.ivy.plugins.resolver.DualResolver; |
| import org.apache.ivy.plugins.resolver.FileSystemResolver; |
| |
| import junit.framework.AssertionFailedError; |
| import junit.framework.TestCase; |
| |
| public class OBRResolverTest extends TestCase { |
| |
| private static final ModuleRevisionId MRID_TEST_BUNDLE = ModuleRevisionId.newInstance( |
| BundleInfo.BUNDLE_TYPE, "org.apache.ivy.osgi.testbundle", "1.2.3"); |
| |
| private static final ModuleRevisionId MRID_TEST_BUNDLE_IMPORTING = ModuleRevisionId |
| .newInstance(BundleInfo.BUNDLE_TYPE, "org.apache.ivy.osgi.testbundle.importing", |
| "3.2.1"); |
| |
| private static final ModuleRevisionId MRID_TEST_BUNDLE_IMPORTING_VERSION = ModuleRevisionId |
| .newInstance(BundleInfo.BUNDLE_TYPE, |
| "org.apache.ivy.osgi.testbundle.importing.version", "3.2.1"); |
| |
| private static final ModuleRevisionId MRID_TEST_BUNDLE_IMPORTING_OPTIONAL = ModuleRevisionId |
| .newInstance(BundleInfo.BUNDLE_TYPE, |
| "org.apache.ivy.osgi.testbundle.importing.optional", "3.2.1"); |
| |
| private static final ModuleRevisionId MRID_TEST_BUNDLE_USE = ModuleRevisionId.newInstance( |
| BundleInfo.BUNDLE_TYPE, "org.apache.ivy.osgi.testbundle.use", "2.2.2"); |
| |
| private static final ModuleRevisionId MRID_TEST_BUNDLE_EXPORTING_AMBIGUITY = ModuleRevisionId |
| .newInstance(BundleInfo.BUNDLE_TYPE, |
| "org.apache.ivy.osgi.testbundle.exporting.ambiguity", "3.3.3"); |
| |
| private static final ModuleRevisionId MRID_TEST_BUNDLE_IMPORTING_JREPACKAGE = ModuleRevisionId |
| .newInstance(BundleInfo.BUNDLE_TYPE, |
| "org.apache.ivy.osgi.testbundle.importing.jrepackage", "1.2.3"); |
| |
| private IvySettings settings; |
| |
| private File cache; |
| |
| private ResolveData data; |
| |
| private Ivy ivy; |
| |
| private OBRResolver bundleResolver; |
| |
| private OBRResolver bundleUrlResolver; |
| |
| private DualResolver dualResolver; |
| |
| private ExecutionEnvironmentProfileProvider profileProvider = ExecutionEnvironmentProfileProvider |
| .getInstance(); |
| |
| public void setUp() throws Exception { |
| settings = new IvySettings(); |
| |
| bundleResolver = new OBRResolver(); |
| bundleResolver.setRepoXmlFile(new File("test/test-repo/bundlerepo/repo.xml") |
| .getAbsolutePath()); |
| bundleResolver.setName("bundle"); |
| bundleResolver.setSettings(settings); |
| settings.addResolver(bundleResolver); |
| |
| bundleUrlResolver = new OBRResolver(); |
| bundleUrlResolver.setRepoXmlURL(new File("test/test-repo/bundlerepo/repo.xml").toURI() |
| .toURL().toExternalForm()); |
| bundleUrlResolver.setName("bundleurl"); |
| bundleUrlResolver.setSettings(settings); |
| settings.addResolver(bundleUrlResolver); |
| |
| dualResolver = new DualResolver(); |
| OBRResolver resolver = new OBRResolver(); |
| resolver.setRepoXmlFile(new File("test/test-repo/ivyrepo/repo.xml").getAbsolutePath()); |
| resolver.setName("dual-bundle"); |
| resolver.setSettings(settings); |
| dualResolver.add(resolver); |
| dualResolver.setName("dual"); |
| File ivyrepo = new File("test/test-repo/ivyrepo"); |
| FileSystemResolver fileSystemResolver = new FileSystemResolver(); |
| fileSystemResolver.addIvyPattern(ivyrepo.getAbsolutePath() |
| + "/[organisation]/[module]/[revision]/ivy.xml"); |
| fileSystemResolver.addArtifactPattern(ivyrepo.getAbsolutePath() |
| + "/[organisation]/[module]/[revision]/[type]s/[artifact]-[revision].[ext]"); |
| fileSystemResolver.setName("dual-file"); |
| fileSystemResolver.setSettings(settings); |
| dualResolver.add(fileSystemResolver); |
| settings.addResolver(dualResolver); |
| |
| settings.setDefaultResolver("bundle"); |
| |
| cache = new File("build/cache"); |
| cache.mkdirs(); |
| settings.setDefaultCache(cache); |
| |
| ivy = new Ivy(); |
| ivy.setSettings(settings); |
| ivy.bind(); |
| |
| ivy.getResolutionCacheManager().clean(); |
| RepositoryCacheManager[] caches = settings.getRepositoryCacheManagers(); |
| for (int i = 0; i < caches.length; i++) { |
| caches[i].clean(); |
| } |
| |
| data = new ResolveData(ivy.getResolveEngine(), new ResolveOptions()); |
| } |
| |
| public void testSimpleResolve() throws Exception { |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance(BundleInfo.BUNDLE_TYPE, |
| "org.apache.ivy.osgi.testbundle", "1.2.3"); |
| genericTestResolveDownload(bundleResolver, mrid); |
| } |
| |
| public void testSimpleUrlResolve() throws Exception { |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance(BundleInfo.BUNDLE_TYPE, |
| "org.apache.ivy.osgi.testbundle", "1.2.3"); |
| genericTestResolveDownload(bundleUrlResolver, mrid); |
| } |
| |
| public void testResolveDual() throws Exception { |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance(BundleInfo.BUNDLE_TYPE, |
| "org.apache.ivy.osgi.testbundle", "1.2.3"); |
| genericTestResolveDownload(dualResolver, mrid); |
| } |
| |
| private void genericTestResolveDownload(DependencyResolver resolver, ModuleRevisionId mrid) |
| throws ParseException { |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull(rmr); |
| assertEquals(mrid, rmr.getId()); |
| |
| Artifact artifact = rmr.getDescriptor().getAllArtifacts()[0]; |
| DownloadReport report = resolver.download(new Artifact[] {artifact}, new DownloadOptions()); |
| assertNotNull(report); |
| |
| assertEquals(1, report.getArtifactsReports().length); |
| |
| ArtifactDownloadReport ar = report.getArtifactReport(artifact); |
| assertNotNull(ar); |
| |
| assertEquals(artifact, ar.getArtifact()); |
| assertEquals(DownloadStatus.SUCCESSFUL, ar.getDownloadStatus()); |
| |
| // test to ask to download again, should use cache |
| report = resolver.download(new Artifact[] {artifact}, new DownloadOptions()); |
| assertNotNull(report); |
| |
| assertEquals(1, report.getArtifactsReports().length); |
| |
| ar = report.getArtifactReport(artifact); |
| assertNotNull(ar); |
| |
| assertEquals(artifact, ar.getArtifact()); |
| assertEquals(DownloadStatus.NO, ar.getDownloadStatus()); |
| } |
| |
| public void testResolveImporting() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing_3.2.1.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {MRID_TEST_BUNDLE}); |
| } |
| |
| public void testResolveImportingOptional() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing.optional_3.2.1.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {}); |
| genericTestResolve(jarName, "optional", new ModuleRevisionId[] {MRID_TEST_BUNDLE}); |
| genericTestResolve(jarName, "transitive-optional", |
| new ModuleRevisionId[] {MRID_TEST_BUNDLE}); |
| } |
| |
| public void testResolveImportingTransitiveOptional() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing.transitiveoptional_3.2.1.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {}); |
| genericTestResolve(jarName, "optional", |
| new ModuleRevisionId[] {MRID_TEST_BUNDLE_IMPORTING_OPTIONAL}); |
| genericTestResolve(jarName, "transitive-optional", new ModuleRevisionId[] { |
| MRID_TEST_BUNDLE, MRID_TEST_BUNDLE_IMPORTING_OPTIONAL}); |
| } |
| |
| public void testResolveImportingVersion() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing.version_3.2.1.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {MRID_TEST_BUNDLE}); |
| } |
| |
| public void testResolveImportingRangeVersion() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing.rangeversion_3.2.1.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {MRID_TEST_BUNDLE}); |
| } |
| |
| public void testResolveUse() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.use_2.2.2.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {}); |
| } |
| |
| public void testResolveImportingUse() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing.use_3.2.1.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {MRID_TEST_BUNDLE_USE, |
| MRID_TEST_BUNDLE_IMPORTING, MRID_TEST_BUNDLE}); |
| } |
| |
| public void testResolveRequire() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.require_1.1.1.jar"; |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {MRID_TEST_BUNDLE, |
| MRID_TEST_BUNDLE_IMPORTING_VERSION}); |
| } |
| |
| public void testResolveOptionalConf() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.require_1.1.1.jar"; |
| genericTestResolve(jarName, "optional", new ModuleRevisionId[] {MRID_TEST_BUNDLE, |
| MRID_TEST_BUNDLE_IMPORTING_VERSION}); |
| } |
| |
| public void testResolveImportAmbiguity() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing.ambiguity_3.2.1.jar"; |
| bundleResolver.setRequirementStrategy(RequirementStrategy.first); |
| genericTestResolve(jarName, "default", |
| new ModuleRevisionId[] {MRID_TEST_BUNDLE_EXPORTING_AMBIGUITY}, new ModuleRevisionId[] { |
| MRID_TEST_BUNDLE, MRID_TEST_BUNDLE_IMPORTING_VERSION}); |
| } |
| |
| public void testResolveImportNoAmbiguity() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.importing.ambiguity_3.2.1.jar"; |
| bundleResolver.setRequirementStrategy(RequirementStrategy.noambiguity); |
| genericTestFailingResolve(jarName, "default"); |
| } |
| |
| public void testResolveRequireAmbiguity() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.require.ambiguity_1.1.1.jar"; |
| bundleResolver.setRequirementStrategy(RequirementStrategy.noambiguity); |
| genericTestResolve(jarName, "default", new ModuleRevisionId[] {MRID_TEST_BUNDLE, |
| MRID_TEST_BUNDLE_IMPORTING_VERSION}); |
| } |
| |
| public void testResolveRequireJre() throws Exception { |
| String jarName = "org.apache.ivy.osgi.testbundle.requirejre_2.2.2.jar"; |
| bundleResolver.setRequirementStrategy(RequirementStrategy.noambiguity); |
| genericTestResolve(jarName, "default", |
| new ModuleRevisionId[] {MRID_TEST_BUNDLE_IMPORTING_JREPACKAGE}); |
| } |
| |
| private void genericTestResolve(String jarName, String conf, ModuleRevisionId[] expectedMrids) |
| throws Exception { |
| genericTestResolve(jarName, conf, expectedMrids, null); |
| } |
| |
| private void genericTestResolve(String jarName, String conf, ModuleRevisionId[] expectedMrids, |
| ModuleRevisionId[] expected2Mrids) throws Exception { |
| Manifest manifest = new JarInputStream(new FileInputStream("test/test-repo/bundlerepo/" |
| + jarName)).getManifest(); |
| BundleInfo bundleInfo = ManifestParser.parseManifest(manifest); |
| bundleInfo.addArtifact(new BundleArtifact(false, new File("test/test-repo/bundlerepo/" |
| + jarName).toURI(), null)); |
| DefaultModuleDescriptor md = BundleInfoAdapter.toModuleDescriptor( |
| OSGiManifestParser.getInstance(), null, bundleInfo, profileProvider); |
| ResolveReport resolveReport = ivy.resolve(md, |
| new ResolveOptions().setConfs(new String[] {conf}).setOutputReport(false)); |
| assertFalse("resolve failed " + resolveReport.getAllProblemMessages(), |
| resolveReport.hasError()); |
| Set<ModuleRevisionId> actual = new HashSet<ModuleRevisionId>(); |
| List<Artifact> artifacts = resolveReport.getArtifacts(); |
| for (Artifact artfact : artifacts) { |
| actual.add(artfact.getModuleRevisionId()); |
| } |
| Set<ModuleRevisionId> expected = new HashSet<ModuleRevisionId>(Arrays.asList(expectedMrids)); |
| if (expected2Mrids != null) { |
| // in this use case, we have two choices, let's try the second one |
| try { |
| Set<ModuleRevisionId> expected2 = new HashSet<ModuleRevisionId>( |
| Arrays.asList(expected2Mrids)); |
| assertEquals(expected2, actual); |
| return; // test passed |
| } catch (AssertionFailedError e) { |
| // too bad, let's continue |
| } |
| } |
| assertEquals(expected, actual); |
| } |
| |
| private void genericTestFailingResolve(String jarName, String conf) throws Exception { |
| Manifest manifest = new JarInputStream(new FileInputStream("test/test-repo/bundlerepo/" |
| + jarName)).getManifest(); |
| BundleInfo bundleInfo = ManifestParser.parseManifest(manifest); |
| bundleInfo.addArtifact(new BundleArtifact(false, new File("test/test-repo/bundlerepo/" |
| + jarName).toURI(), null)); |
| DefaultModuleDescriptor md = BundleInfoAdapter.toModuleDescriptor( |
| OSGiManifestParser.getInstance(), null, bundleInfo, manifest, profileProvider); |
| ResolveReport resolveReport = ivy.resolve(md, |
| new ResolveOptions().setConfs(new String[] {conf}).setOutputReport(false)); |
| assertTrue(resolveReport.hasError()); |
| } |
| |
| } |
