| /* |
| * 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 |
| * |
| * https://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.plugins.resolver; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.IOException; |
| import java.util.Date; |
| import java.util.GregorianCalendar; |
| |
| import org.apache.ivy.core.cache.DefaultRepositoryCacheManager; |
| import org.apache.ivy.core.event.EventManager; |
| import org.apache.ivy.core.module.descriptor.Artifact; |
| import org.apache.ivy.core.module.descriptor.DefaultArtifact; |
| import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor; |
| 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.resolve.DownloadOptions; |
| import org.apache.ivy.core.resolve.ResolveData; |
| import org.apache.ivy.core.resolve.ResolveEngine; |
| import org.apache.ivy.core.resolve.ResolveOptions; |
| import org.apache.ivy.core.resolve.ResolvedModuleRevision; |
| import org.apache.ivy.core.search.ModuleEntry; |
| import org.apache.ivy.core.search.OrganisationEntry; |
| import org.apache.ivy.core.search.RevisionEntry; |
| import org.apache.ivy.core.settings.IvySettings; |
| import org.apache.ivy.core.sort.SortEngine; |
| import org.apache.ivy.plugins.latest.LatestRevisionStrategy; |
| import org.apache.ivy.plugins.latest.LatestTimeStrategy; |
| import org.apache.ivy.plugins.resolver.util.ResolvedResource; |
| import org.apache.ivy.util.CacheCleaner; |
| import org.apache.ivy.util.FileUtil; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.rules.ExpectedException; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| |
| /** |
| * |
| */ |
| public class FileSystemResolverTest extends AbstractDependencyResolverTest { |
| // CheckStyle:MagicNumberCheck OFF |
| |
| private static final String FS = File.separator; |
| |
| private static final String REL_IVY_PATTERN = "test" + FS + "repositories" + FS + "1" + FS |
| + "[organisation]" + FS + "[module]" + FS + "ivys" + FS + "ivy-[revision].xml"; |
| |
| private static final String IVY_PATTERN = new File(".").getAbsolutePath() + FS |
| + REL_IVY_PATTERN; |
| |
| private IvySettings settings; |
| |
| private ResolveEngine engine; |
| |
| private ResolveData data; |
| |
| private File cache; |
| |
| private DefaultRepositoryCacheManager cacheManager; |
| |
| public FileSystemResolverTest() { |
| setupLastModified(); |
| } |
| |
| @Rule |
| public ExpectedException expExc = ExpectedException.none(); |
| |
| @Before |
| public void setUp() { |
| settings = new IvySettings(); |
| engine = new ResolveEngine(settings, new EventManager(), new SortEngine(settings)); |
| cache = new File("build/cache"); |
| data = new ResolveData(engine, new ResolveOptions()); |
| cache.mkdirs(); |
| settings.setDefaultCache(cache); |
| cacheManager = (DefaultRepositoryCacheManager) settings.getDefaultRepositoryCacheManager(); |
| } |
| |
| private void setupLastModified() { |
| // change important last modified dates cause svn doesn't keep them |
| long minute = 60 * 1000; |
| long time = new GregorianCalendar().getTimeInMillis() - (4 * minute); |
| new File("test/repositories/1/org1/mod1.1/ivys/ivy-1.0.xml").setLastModified(time); |
| time += minute; |
| new File("test/repositories/1/org1/mod1.1/ivys/ivy-1.0.1.xml").setLastModified(time); |
| time += minute; |
| new File("test/repositories/1/org1/mod1.1/ivys/ivy-1.1.xml").setLastModified(time); |
| time += minute; |
| new File("test/repositories/1/org1/mod1.1/ivys/ivy-2.0.xml").setLastModified(time); |
| } |
| |
| @After |
| public void tearDown() { |
| CacheCleaner.deleteDir(cache); |
| FileUtil.forceDelete(new File("test/repositories/1/myorg")); |
| FileUtil.forceDelete(new File("test/repositories/m2/org/apache/mymodule")); |
| } |
| |
| @Test |
| public void testFixedRevision() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[type]s/[artifact]-[revision].[type]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "1.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| Date pubdate = new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime(); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| |
| // test to ask to download |
| DefaultArtifact artifact = new DefaultArtifact(mrid, pubdate, "mod1.1", "jar", "jar"); |
| DownloadReport report = resolver.download(new Artifact[] {artifact}, getDownloadOptions()); |
| 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}, getDownloadOptions()); |
| assertNotNull(report); |
| |
| assertEquals(1, report.getArtifactsReports().length); |
| |
| ar = report.getArtifactReport(artifact); |
| assertNotNull(ar); |
| |
| assertEquals(artifact, ar.getArtifact()); |
| assertEquals(DownloadStatus.NO, ar.getDownloadStatus()); |
| } |
| |
| /** |
| * Test case for IVY-676. |
| * |
| * @throws Exception if something goes wrong |
| * @see <a href="https://issues.apache.org/jira/browse/IVY-676">IVY-676</a> |
| */ |
| @Test |
| public void testFindIvyFileRefWithMultipleIvyPatterns() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/multi-ivypattern/ivy1/ivy-[revision].xml"); |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/multi-ivypattern/ivy2/ivy-[revision].xml"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "1.0+"); |
| ResolvedResource ivyRef = resolver.findIvyFileRef(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| |
| // check that the found ivy file is the one from the first pattern! |
| assertEquals( |
| new File("test/repositories/multi-ivypattern/ivy1/ivy-1.0.xml").getCanonicalPath(), |
| new File(ivyRef.getResource().getName()).getCanonicalPath()); |
| } |
| |
| private DownloadOptions getDownloadOptions() { |
| return new DownloadOptions(); |
| } |
| |
| @Test |
| public void testMaven2() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| resolver.setM2compatible(true); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(settings.getBaseDir() + "/test/repositories/m2/" |
| + "[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/m2/" |
| + "[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org.apache", "test", "1.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull(rmr); |
| |
| mrid = ModuleRevisionId.newInstance("org.apache.unknown", "test", "1.0"); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNull(rmr); |
| resolver.reportFailure(); |
| } |
| |
| @Test |
| public void testChecksum() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/checksums/[module]/[artifact]-[revision].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/checksums/[module]/[artifact]-[revision].[ext]"); |
| |
| resolver.setChecksums("sha1, md5"); |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("test", "allright", "1.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull("Resolver could not get dependency " + mrid, rmr); |
| DownloadReport dr = resolver.download(rmr.getDescriptor().getAllArtifacts(), |
| getDownloadOptions()); |
| assertEquals(4, dr.getArtifactsReports(DownloadStatus.SUCCESSFUL).length); |
| |
| resolver.setChecksums("md5"); |
| mrid = ModuleRevisionId.newInstance("test", "badivycs", "1.0"); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNull(rmr); |
| resolver.setChecksums("none"); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull(rmr); |
| dr = resolver.download(new Artifact[] {new DefaultArtifact(mrid, rmr.getPublicationDate(), |
| mrid.getName(), "jar", "jar")}, getDownloadOptions()); |
| assertEquals(1, dr.getArtifactsReports(DownloadStatus.SUCCESSFUL).length); |
| |
| resolver.setChecksums("md5"); |
| mrid = ModuleRevisionId.newInstance("test", "badartcs", "1.0"); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull("Could not get dependency " + mrid, rmr); |
| dr = resolver.download(new Artifact[] {new DefaultArtifact(mrid, rmr.getPublicationDate(), |
| mrid.getName(), "jar", "jar")}, getDownloadOptions()); |
| assertEquals(1, dr.getArtifactsReports(DownloadStatus.FAILED).length); |
| |
| resolver.setChecksums(""); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull(rmr); |
| dr = resolver.download(new Artifact[] {new DefaultArtifact(mrid, rmr.getPublicationDate(), |
| mrid.getName(), "jar", "jar")}, getDownloadOptions()); |
| assertEquals(1, dr.getArtifactsReports(DownloadStatus.SUCCESSFUL).length); |
| } |
| |
| /** |
| * Tests that <code>SHA-256</code> algorithm can be used for checksums on resolvers |
| * |
| * @throws Exception if something goes wrong |
| */ |
| @Test |
| public void testSHA256Checksum() throws Exception { |
| final FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("sha256-checksum-resolver"); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/checksums/[module]/[revision]/[artifact]-[revision].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/checksums/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| resolver.setChecksums("SHA-256"); |
| final ModuleRevisionId mrid = ModuleRevisionId.newInstance("test", "allright", "2.0"); |
| final ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull("Resolved module revision was null for " + mrid, rmr); |
| final DownloadReport dr = resolver.download(rmr.getDescriptor().getAllArtifacts(), getDownloadOptions()); |
| final ArtifactDownloadReport[] successfulDownloadReports = dr.getArtifactsReports(DownloadStatus.SUCCESSFUL); |
| assertNotNull("No artifacts were downloaded successfully", successfulDownloadReports); |
| assertEquals("Unexpected number of successfully downloaded artifacts", 1, successfulDownloadReports.length); |
| final ArtifactDownloadReport successfulDownloadReport = successfulDownloadReports[0]; |
| final Artifact downloadedArtifact = successfulDownloadReport.getArtifact(); |
| assertEquals("Unexpected organization of downloaded artifact", "test", downloadedArtifact.getModuleRevisionId().getOrganisation()); |
| assertEquals("Unexpected module of downloaded artifact", "allright", downloadedArtifact.getModuleRevisionId().getModuleId().getName()); |
| assertEquals("Unexpected revision of downloaded artifact", "2.0", downloadedArtifact.getModuleRevisionId().getRevision()); |
| } |
| |
| /** |
| * Tests that <code>SHA-512</code> algorithm can be used for checksums on resolvers |
| * |
| * @throws Exception if something goes wrong |
| */ |
| @Test |
| public void testSHA512Checksum() throws Exception { |
| final FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("sha256-checksum-resolver"); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/checksums/[module]/[revision]/[artifact]-[revision].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/checksums/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| resolver.setChecksums("SHA-512"); |
| final ModuleRevisionId mrid = ModuleRevisionId.newInstance("test", "allright", "3.0"); |
| final ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull("Resolved module revision was null for " + mrid, rmr); |
| final DownloadReport dr = resolver.download(rmr.getDescriptor().getAllArtifacts(), getDownloadOptions()); |
| final ArtifactDownloadReport[] successfulDownloadReports = dr.getArtifactsReports(DownloadStatus.SUCCESSFUL); |
| assertNotNull("No artifacts were downloaded successfully", successfulDownloadReports); |
| assertEquals("Unexpected number of successfully downloaded artifacts", 1, successfulDownloadReports.length); |
| final ArtifactDownloadReport successfulDownloadReport = successfulDownloadReports[0]; |
| final Artifact downloadedArtifact = successfulDownloadReport.getArtifact(); |
| assertEquals("Unexpected organization of downloaded artifact", "test", downloadedArtifact.getModuleRevisionId().getOrganisation()); |
| assertEquals("Unexpected module of downloaded artifact", "allright", downloadedArtifact.getModuleRevisionId().getModuleId().getName()); |
| assertEquals("Unexpected revision of downloaded artifact", "3.0", downloadedArtifact.getModuleRevisionId().getRevision()); |
| } |
| |
| @Test |
| public void testCheckModified() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| settings.addResolver(resolver); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(settings.getBaseDir() + FS + "test" + FS + "repositories" + FS |
| + "checkmodified" + FS + "ivy-[revision].xml"); |
| File modify = new File("test/repositories/checkmodified/ivy-1.0.xml"); |
| FileUtil.copy(new File("test/repositories/checkmodified/ivy-1.0-before.xml"), modify, null, |
| true); |
| Date pubdate = new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime(); |
| modify.setLastModified(pubdate.getTime()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "1.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| |
| // updates ivy file in repository |
| FileUtil.copy(new File("test/repositories/checkmodified/ivy-1.0-after.xml"), modify, null, |
| true); |
| pubdate = new GregorianCalendar(2005, 4, 1, 11, 0, 0).getTime(); |
| modify.setLastModified(pubdate.getTime()); |
| |
| // should not get the new version |
| resolver.setCheckmodified(false); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| assertEquals(new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime(), |
| rmr.getPublicationDate()); |
| |
| // should now get the new version |
| resolver.setCheckmodified(true); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| } |
| |
| @Test |
| public void testNoRevision() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| settings.addResolver(resolver); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(settings.getBaseDir() + FS + "test" + FS + "repositories" + FS |
| + "norevision" + FS + "ivy-[module].xml"); |
| resolver.addArtifactPattern(settings.getBaseDir() + FS + "test" + FS + "repositories" + FS |
| + "norevision" + FS + "[artifact].[ext]"); |
| File modify = new File("test/repositories/norevision/ivy-mod1.1.xml"); |
| File artifact = new File("test/repositories/norevision/mod1.1.jar"); |
| |
| // 'publish' 'before' version |
| FileUtil.copy(new File("test/repositories/norevision/ivy-mod1.1-before.xml"), modify, null, |
| true); |
| FileUtil.copy(new File("test/repositories/norevision/mod1.1-before.jar"), artifact, null, |
| true); |
| Date pubdate = new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime(); |
| modify.setLastModified(pubdate.getTime()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId |
| .newInstance("org1", "mod1.1", "latest.integration"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(ModuleRevisionId.newInstance("org1", "mod1.1", "1.0"), rmr.getId()); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| |
| Artifact[] artifacts = rmr.getDescriptor().getArtifacts("default"); |
| File archiveFileInCache = cacheManager.getArchiveFileInCache(artifacts[0]); |
| resolver.download(artifacts, getDownloadOptions()); |
| assertTrue(archiveFileInCache.exists()); |
| BufferedReader r = new BufferedReader(new FileReader(archiveFileInCache)); |
| assertEquals("before", r.readLine()); |
| r.close(); |
| |
| // updates ivy file and artifact in repository |
| FileUtil.copy(new File("test/repositories/norevision/ivy-mod1.1-after.xml"), modify, null, |
| true); |
| FileUtil.copy(new File("test/repositories/norevision/mod1.1-after.jar"), artifact, null, |
| true); |
| pubdate = new GregorianCalendar(2005, 4, 1, 11, 0, 0).getTime(); |
| modify.setLastModified(pubdate.getTime()); |
| // no need to update new artifact timestamp cause it isn't used |
| |
| // should get the new version even if checkModified is false, because we ask a |
| // latest.integration |
| resolver.setCheckmodified(false); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(ModuleRevisionId.newInstance("org1", "mod1.1", "1.1"), rmr.getId()); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| |
| artifacts = rmr.getDescriptor().getArtifacts("default"); |
| archiveFileInCache = cacheManager.getArchiveFileInCache(artifacts[0]); |
| |
| assertFalse(archiveFileInCache.exists()); |
| |
| // should download the new artifact |
| artifacts = rmr.getDescriptor().getArtifacts("default"); |
| resolver.download(artifacts, getDownloadOptions()); |
| assertTrue(archiveFileInCache.exists()); |
| r = new BufferedReader(new FileReader(archiveFileInCache)); |
| assertEquals("after", r.readLine()); |
| r.close(); |
| } |
| |
| @Test |
| public void testChanging() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| settings.addResolver(resolver); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(settings.getBaseDir() + FS + "test" + FS + "repositories" + FS |
| + "checkmodified" + FS + "ivy-[revision].xml"); |
| resolver.addArtifactPattern(settings.getBaseDir() + FS + "test" + FS + "repositories" + FS |
| + "checkmodified" + FS + "[artifact]-[revision].[ext]"); |
| File modify = new File("test/repositories/checkmodified/ivy-1.0.xml"); |
| File artifact = new File("test/repositories/checkmodified/mod1.1-1.0.jar"); |
| |
| // 'publish' 'before' version |
| FileUtil.copy(new File("test/repositories/checkmodified/ivy-1.0-before.xml"), modify, null, |
| true); |
| FileUtil.copy(new File("test/repositories/checkmodified/mod1.1-1.0-before.jar"), artifact, |
| null, true); |
| Date pubdate = new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime(); |
| modify.setLastModified(pubdate.getTime()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "1.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| |
| Artifact[] artifacts = rmr.getDescriptor().getArtifacts("default"); |
| resolver.download(artifacts, getDownloadOptions()); |
| File archiveFileInCache = cacheManager.getArchiveFileInCache(artifacts[0]); |
| assertTrue(archiveFileInCache.exists()); |
| BufferedReader r = new BufferedReader(new FileReader(archiveFileInCache)); |
| assertEquals("before", r.readLine()); |
| r.close(); |
| |
| // updates ivy file and artifact in repository |
| FileUtil.copy(new File("test/repositories/checkmodified/ivy-1.0-after.xml"), modify, null, |
| true); |
| FileUtil.copy(new File("test/repositories/checkmodified/mod1.1-1.0-after.jar"), artifact, |
| null, true); |
| pubdate = new GregorianCalendar(2005, 4, 1, 11, 0, 0).getTime(); |
| modify.setLastModified(pubdate.getTime()); |
| // no need to update new artifact timestamp cause it isn't used |
| |
| // should not get the new version: checkmodified is false and dependency is not told to be a |
| // changing one |
| resolver.setCheckmodified(false); |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| assertEquals(new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime(), |
| rmr.getPublicationDate()); |
| |
| assertTrue(archiveFileInCache.exists()); |
| r = new BufferedReader(new FileReader(archiveFileInCache)); |
| assertEquals("before", r.readLine()); |
| r.close(); |
| |
| // should now get the new version cause we say it's a changing one |
| rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, false, true), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| |
| assertFalse(archiveFileInCache.exists()); |
| |
| artifacts = rmr.getDescriptor().getArtifacts("default"); |
| resolver.download(artifacts, getDownloadOptions()); |
| assertTrue(archiveFileInCache.exists()); |
| r = new BufferedReader(new FileReader(archiveFileInCache)); |
| assertEquals("after", r.readLine()); |
| r.close(); |
| } |
| |
| @Test |
| public void testLatestTime() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[type]"); |
| |
| resolver.setLatestStrategy(new LatestTimeStrategy()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "2.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor( |
| ModuleRevisionId.newInstance("org1", "mod1.1", "latest.integration"), false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| Date pubdate = new GregorianCalendar(2005, 1, 15, 11, 0, 0).getTime(); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| } |
| |
| @Test |
| public void testLatestRevision() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[type]"); |
| |
| resolver.setLatestStrategy(new LatestRevisionStrategy()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "2.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor( |
| ModuleRevisionId.newInstance("org1", "mod1.1", "latest.integration"), false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| Date pubdate = new GregorianCalendar(2005, 1, 15, 11, 0, 0).getTime(); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| } |
| |
| @Test |
| public void testRelativePath() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(new File("src/java").getAbsolutePath() + "/../../" + REL_IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/src/../test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[type]"); |
| |
| resolver.setLatestStrategy(new LatestRevisionStrategy()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "2.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor( |
| ModuleRevisionId.newInstance("org1", "mod1.1", "latest.integration"), false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| Date pubdate = new GregorianCalendar(2005, 1, 15, 11, 0, 0).getTime(); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| } |
| |
| @Test |
| public void testFormattedLatestTime() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[type]"); |
| |
| resolver.setLatestStrategy(new LatestTimeStrategy()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "1.1"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor( |
| ModuleRevisionId.newInstance("org1", "mod1.1", "1+"), false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| Date pubdate = new GregorianCalendar(2005, 0, 2, 11, 0, 0).getTime(); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| } |
| |
| @Test |
| public void testFormattedLatestRevision() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[type]"); |
| |
| resolver.setLatestStrategy(new LatestRevisionStrategy()); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "1.1"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor( |
| ModuleRevisionId.newInstance("org1", "mod1.1", "1+"), false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| Date pubdate = new GregorianCalendar(2005, 0, 2, 11, 0, 0).getTime(); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| } |
| |
| @Test |
| public void testPublish() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(settings.getBaseDir() + FS + "test" + FS + "repositories" + FS |
| + "1" + FS + "[organisation]" + FS + "[module]" + FS + "[revision]" + FS |
| + "[artifact].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() + FS + "test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| resolver.beginPublishTransaction(mrid, false); |
| resolver.publish(ivyArtifact, src, false); |
| resolver.publish(artifact, src, false); |
| resolver.commitPublishTransaction(); |
| |
| assertTrue(new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml").exists()); |
| assertTrue(new File( |
| "test/repositories/1/myorg/mymodule/mytypes/myartifact-myrevision.myext") |
| .exists()); |
| } |
| |
| @Test |
| public void testPublishOverwrite() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| File ivyFile = new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml"); |
| File artifactFile = new File( |
| "test/repositories/1/myorg/mymodule/myrevision/myartifact-myrevision.myext"); |
| touch(ivyFile); |
| touch(artifactFile); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| resolver.beginPublishTransaction(mrid, true); |
| resolver.publish(ivyArtifact, src, true); |
| resolver.publish(artifact, src, true); |
| resolver.commitPublishTransaction(); |
| |
| long length = src.length(); |
| assertEquals(length, ivyFile.length()); |
| assertEquals(length, artifactFile.length()); |
| } |
| |
| private void touch(File file) throws IOException { |
| file.getParentFile().mkdirs(); |
| file.createNewFile(); |
| } |
| |
| @Test |
| public void testPublishTransaction() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| |
| resolver.beginPublishTransaction(mrid, false); |
| |
| // files should not be available until the transaction is committed |
| resolver.publish(ivyArtifact, src, false); |
| assertFalse(new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml").exists()); |
| |
| resolver.publish(artifact, src, false); |
| assertFalse(new File( |
| "test/repositories/1/myorg/mymodule/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| |
| resolver.commitPublishTransaction(); |
| |
| assertTrue(new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml").exists()); |
| assertTrue(new File( |
| "test/repositories/1/myorg/mymodule/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| } |
| |
| @Test |
| public void testPublishTransactionWithBranch() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[branch]/[revision]/[artifact].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[branch]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "mybranch", |
| "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| |
| resolver.beginPublishTransaction(mrid, false); |
| |
| // files should not be available until the transaction is committed |
| resolver.publish(ivyArtifact, src, false); |
| assertFalse(new File("test/repositories/1/myorg/mymodule/mybranch/myrevision/ivy.xml") |
| .exists()); |
| |
| resolver.publish(artifact, src, false); |
| assertFalse(new File( |
| "test/repositories/1/myorg/mymodule/mybranch/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| |
| resolver.commitPublishTransaction(); |
| |
| assertTrue(new File("test/repositories/1/myorg/mymodule/mybranch/myrevision/ivy.xml") |
| .exists()); |
| assertTrue(new File( |
| "test/repositories/1/myorg/mymodule/mybranch/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| } |
| |
| @Test |
| public void testPublishTransactionWithSubDirectories() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[type]/[artifact].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[type]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| |
| resolver.beginPublishTransaction(mrid, false); |
| |
| // files should not be available until the transaction is committed |
| resolver.publish(ivyArtifact, src, false); |
| assertFalse(new File("test/repositories/1/myorg/mymodule/myrevision/ivy/ivy.xml") |
| .exists()); |
| |
| resolver.publish(artifact, src, false); |
| assertFalse(new File( |
| "test/repositories/1/myorg/mymodule/myrevision/mytype/myartifact-myrevision.myext") |
| .exists()); |
| |
| resolver.commitPublishTransaction(); |
| |
| assertTrue(new File("test/repositories/1/myorg/mymodule/myrevision/ivy/ivy.xml") |
| .exists()); |
| assertTrue(new File( |
| "test/repositories/1/myorg/mymodule/myrevision/mytype/myartifact-myrevision.myext") |
| .exists()); |
| } |
| |
| @Test |
| public void testPublishTransactionWithDottedOrganisation() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setM2compatible(true); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/m2/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/m2/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org.apache", "mymodule", |
| "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| |
| resolver.beginPublishTransaction(mrid, false); |
| |
| // files should not be available until the transaction is committed |
| resolver.publish(ivyArtifact, src, false); |
| assertFalse(new File( |
| "test/repositories/m2/org/apache/mymodule/myrevision/ivy-myrevision.xml") |
| .exists()); |
| resolver.publish(artifact, src, false); |
| assertFalse(new File( |
| "test/repositories/m2/org/apache/mymodule/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| |
| resolver.commitPublishTransaction(); |
| assertTrue(new File( |
| "test/repositories/m2/org/apache/mymodule/myrevision/ivy-myrevision.xml") |
| .exists()); |
| assertTrue(new File( |
| "test/repositories/m2/org/apache/mymodule/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| } |
| |
| @Test |
| public void testAbortTransaction() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| resolver.beginPublishTransaction(mrid, false); |
| resolver.publish(ivyArtifact, src, false); |
| resolver.publish(artifact, src, false); |
| resolver.abortPublishTransaction(); |
| |
| assertFalse(new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml").exists()); |
| assertFalse(new File( |
| "test/repositories/1/myorg/mymodule/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| } |
| |
| /** |
| * Publishing with transaction=true and an unsupported pattern must fail. |
| * |
| * @throws Exception if something goes wrong |
| */ |
| @Test |
| public void testUnsupportedTransaction() throws Exception { |
| expExc.expect(IllegalStateException.class); |
| expExc.expectMessage("transactional"); |
| |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| resolver.setTransactional("true"); |
| |
| resolver.addArtifactPattern( |
| // this pattern is not supported for transaction publish |
| settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| |
| resolver.beginPublishTransaction(mrid, false); |
| resolver.publish(artifact, src, false); |
| } |
| |
| /** |
| * Publishing with transaction=true and an unsupported combination of patterns must fail. |
| * |
| * @throws Exception if something goes wrong |
| */ |
| @Test |
| public void testUnsupportedTransaction2() throws Exception { |
| expExc.expect(IllegalStateException.class); |
| expExc.expectMessage("transactional"); |
| |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| resolver.setTransactional("true"); |
| |
| // the two patterns are inconsistent and thus not supported for transactions |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]-[module]/[revision]/[artifact]-[revision].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| |
| resolver.beginPublishTransaction(mrid, false); |
| resolver.publish(ivyArtifact, src, false); |
| resolver.publish(artifact, src, false); |
| } |
| |
| /** |
| * Publishing with transaction=true and overwrite mode must fail. |
| * |
| * @throws Exception if something goes wrong |
| */ |
| @Test |
| public void testUnsupportedTransaction3() throws Exception { |
| expExc.expect(IllegalStateException.class); |
| expExc.expectMessage("transactional"); |
| |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| resolver.setTransactional("true"); |
| |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| |
| // overwrite transaction not supported |
| resolver.beginPublishTransaction(mrid, true); |
| resolver.publish(artifact, src, true); |
| } |
| |
| @Test |
| public void testDisableTransaction() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| resolver.setTransactional("false"); |
| |
| resolver.addIvyPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact].[ext]"); |
| resolver.addArtifactPattern(settings.getBaseDir() |
| + "/test/repositories/1/[organisation]/[module]/[revision]/[artifact]-[revision].[ext]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("myorg", "mymodule", "myrevision"); |
| Artifact ivyArtifact = new DefaultArtifact(mrid, new Date(), "ivy", "ivy", "xml"); |
| Artifact artifact = new DefaultArtifact(mrid, new Date(), "myartifact", "mytype", |
| "myext"); |
| File src = new File("test/repositories/ivysettings.xml"); |
| resolver.beginPublishTransaction(mrid, false); |
| |
| // with transactions disabled the file should be available as soon as they are published |
| resolver.publish(ivyArtifact, src, false); |
| assertTrue(new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml").exists()); |
| |
| resolver.publish(artifact, src, false); |
| assertTrue(new File( |
| "test/repositories/1/myorg/mymodule/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| |
| resolver.commitPublishTransaction(); |
| |
| assertTrue(new File("test/repositories/1/myorg/mymodule/myrevision/ivy.xml").exists()); |
| assertTrue(new File( |
| "test/repositories/1/myorg/mymodule/myrevision/myartifact-myrevision.myext") |
| .exists()); |
| } |
| |
| @Test |
| public void testListing() { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[ext]"); |
| |
| OrganisationEntry[] orgs = resolver.listOrganisations(); |
| ResolverTestHelper.assertOrganisationEntriesContains(resolver, new String[] {"org1", |
| "org2", "org6", "org9", "orgfailure", "yourorg", "IVY-644"}, orgs); |
| |
| OrganisationEntry org = ResolverTestHelper.getEntry(orgs, "org1"); |
| assertNotNull("organisation not found: org1", org); |
| ModuleEntry[] mods = resolver.listModules(org); |
| ResolverTestHelper.assertModuleEntries(resolver, org, new String[] {"mod1.1", "mod1.2", |
| "mod1.3", "mod1.4", "mod1.5", "mod1.6", "mod1.7"}, mods); |
| |
| ModuleEntry mod = ResolverTestHelper.getEntry(mods, "mod1.1"); |
| assertNotNull("module not found: mod1.1", mod); |
| RevisionEntry[] revs = resolver.listRevisions(mod); |
| ResolverTestHelper.assertRevisionEntries(resolver, mod, new String[] {"1.0", "1.0.1", |
| "1.1", "2.0"}, revs); |
| |
| mod = ResolverTestHelper.getEntry(mods, "mod1.2"); |
| assertNotNull("module not found: mod1.2", mod); |
| revs = resolver.listRevisions(mod); |
| ResolverTestHelper.assertRevisionEntries(resolver, mod, new String[] {"0.9", "1.0", "1.1", |
| "2.0", "2.1", "2.2"}, revs); |
| } |
| |
| @Test |
| public void testDownloadWithUseOriginIsTrue() throws Exception { |
| FileSystemResolver resolver = new FileSystemResolver(); |
| resolver.setName("test"); |
| resolver.setSettings(settings); |
| ((DefaultRepositoryCacheManager) resolver.getRepositoryCacheManager()).setUseOrigin(true); |
| assertEquals("test", resolver.getName()); |
| |
| resolver.addIvyPattern(IVY_PATTERN); |
| resolver.addArtifactPattern(settings.getBaseDir() + "/test/repositories/1/" |
| + "[organisation]/[module]/[type]s/[artifact]-[revision].[type]"); |
| |
| ModuleRevisionId mrid = ModuleRevisionId.newInstance("org1", "mod1.1", "1.0"); |
| ResolvedModuleRevision rmr = resolver.getDependency(new DefaultDependencyDescriptor(mrid, |
| false), data); |
| assertNotNull(rmr); |
| |
| assertEquals(mrid, rmr.getId()); |
| Date pubdate = new GregorianCalendar(2004, 10, 1, 11, 0, 0).getTime(); |
| assertEquals(pubdate, rmr.getPublicationDate()); |
| |
| // test to ask to download |
| DefaultArtifact artifact = new DefaultArtifact(mrid, pubdate, "mod1.1", "jar", "jar"); |
| DownloadReport report = resolver.download(new Artifact[] {artifact}, getDownloadOptions()); |
| assertNotNull(report); |
| |
| assertEquals(1, report.getArtifactsReports().length); |
| |
| ArtifactDownloadReport ar = report.getArtifactReport(artifact); |
| assertNotNull(ar); |
| |
| assertEquals(artifact, ar.getArtifact()); |
| assertEquals(DownloadStatus.NO, ar.getDownloadStatus()); |
| } |
| } |
