/*
* 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;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import junit.framework.Assert;
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.descriptor.DefaultModuleDescriptor;
import org.apache.ivy.core.module.descriptor.ModuleDescriptor;
import org.apache.ivy.core.module.id.ModuleRevisionId;
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.settings.IvySettings;
import org.apache.ivy.core.sort.SortEngine;
import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorWriter;
import org.apache.ivy.plugins.resolver.DependencyResolver;
import org.apache.ivy.plugins.resolver.FileSystemResolver;
import org.apache.ivy.util.FileUtil;
public class TestHelper {
public static DefaultArtifact newArtifact(String organisation, String module, String revision,
String artifact, String type, String ext) {
return new DefaultArtifact(ModuleRevisionId.newInstance(organisation, module, revision),
new Date(), artifact, type, ext);
}
public static File getArchiveFileInCache(Ivy ivy, String mrid, String artifactName,
String type, String ext) {
DefaultArtifact artifact = new DefaultArtifact(ModuleRevisionId.parse(mrid), new Date(),
artifactName, type, ext);
return getRepositoryCacheManager(ivy, artifact.getModuleRevisionId())
.getArchiveFileInCache(artifact);
}
public static File getArchiveFileInCache(Ivy ivy, String organisation, String module,
String revision, String artifactName, String type, String ext) {
DefaultArtifact artifact = newArtifact(organisation, module, revision, artifactName, type,
ext);
return getRepositoryCacheManager(ivy, artifact.getModuleRevisionId())
.getArchiveFileInCache(artifact);
}
public static DefaultRepositoryCacheManager getRepositoryCacheManager(Ivy ivy,
ModuleRevisionId id) {
// WARN: this doesn't work if the resolver registered is a compound resolver (chain or dual)
// and a sub resolver doesn't use the same cache manager as the parent
return (DefaultRepositoryCacheManager) ivy.getSettings().getResolver(id)
.getRepositoryCacheManager();
}
/**
* Assertion utility methods to test if a collection of {@link ModuleRevisionId} matches a given
* expected set of mrids.
* <p>
* Expected mrids is given as a String of comma separated string representations of
* {@link ModuleRevisionId}.
*
* @param expectedMrids
* the expected set of mrids
* @param mrids
* the3 mrids to test
*/
public static void assertModuleRevisionIds(String expectedMrids,
Collection/* <ModuleRevisionId> */mrids) {
Collection expected = parseMrids(expectedMrids);
Assert.assertEquals(expected, mrids);
}
/**
* Returns a Set of {@link ModuleRevisionId} corresponding to the given comma separated list of
* their text representation.
*
* @param mrids
* the text representation of the {@link ModuleRevisionId}
* @return a collection of {@link ModuleRevisionId}
*/
public static Collection parseMrids(String mrids) {
String[] m = mrids.split(",?\\s+");
Collection c = new LinkedHashSet();
for (int i = 0; i < m.length; i++) {
c.add(ModuleRevisionId.parse(m[i]));
}
return c;
}
/**
* Returns an array of {@link ModuleRevisionId} corresponding to the given comma separated list
* of their text representation.
*
* @param mrids
* the text representation of the {@link ModuleRevisionId}
* @return an array of {@link ModuleRevisionId}
*/
public static ModuleRevisionId[] parseMridsToArray(String mrids) {
Collection parsedMrids = parseMrids(mrids);
return (ModuleRevisionId[]) parsedMrids.toArray(new ModuleRevisionId[parsedMrids.size()]);
}
/**
* Parses a string represenation of a module descriptor in micro ivy format.
* <p>
* Examples:
*
* <pre>
* #A;1
* </pre>
*
* <hr/>
*
* <pre>
* #A;2-> #B;[1.0,1.5]
* </pre>
*
* <hr/>
*
* <pre>
* #A;3-> { #B;[1.0,1.5] #C;[2.0,2.5] }
* </pre>
*
* </p>
*
* @param microIvy
* the micro ivy description of the module descriptor
* @return the parsed module descriptor
*/
public static ModuleDescriptor parseMicroIvyDescriptor(String microIvy) {
Pattern mridPattern = ModuleRevisionId.NON_CAPTURING_PATTERN;
Matcher m = mridPattern.matcher(microIvy);
if (m.matches()) {
return DefaultModuleDescriptor.newBasicInstance(ModuleRevisionId.parse(microIvy),
new Date());
}
Pattern oneDependencyPattern = Pattern.compile("(" + mridPattern.pattern() + ")\\s*->\\s*("
+ mridPattern.pattern() + ")");
m = oneDependencyPattern.matcher(microIvy);
if (m.matches()) {
DefaultModuleDescriptor md = DefaultModuleDescriptor.newBasicInstance(
ModuleRevisionId.parse(m.group(1)), new Date());
md.addDependency(new DefaultDependencyDescriptor(ModuleRevisionId.parse(m.group(2)),
false));
return md;
}
String p = "(" + mridPattern.pattern() + ")\\s*->\\s*\\{\\s*((?:" + mridPattern.pattern()
+ ",?\\s+)*" + mridPattern.pattern() + ")?\\s*\\}";
Pattern multipleDependenciesPattern = Pattern.compile(p);
m = multipleDependenciesPattern.matcher(microIvy);
if (m.matches()) {
DefaultModuleDescriptor md = DefaultModuleDescriptor.newBasicInstance(
ModuleRevisionId.parse(m.group(1)), new Date());
String mrids = m.group(2);
if (mrids != null) {
Collection depMrids = parseMrids(mrids);
for (Iterator iter = depMrids.iterator(); iter.hasNext();) {
ModuleRevisionId dep = (ModuleRevisionId) iter.next();
md.addDependency(new DefaultDependencyDescriptor(dep, false));
}
}
return md;
}
throw new IllegalArgumentException("invalid micro ivy format: " + microIvy);
}
/**
* Parses a collection of module descriptors in the micro ivy format, separated by double semi
* columns.
*
* @param microIvy
* the text representation of the collection of module descriptors
* @return the collection of module descriptors parsed
*/
public static Collection/* <ModuleDescriptor> */parseMicroIvyDescriptors(String microIvy) {
String[] mds = microIvy.split("\\s*;;\\s*");
Collection r = new ArrayList();
for (int i = 0; i < mds.length; i++) {
r.add(parseMicroIvyDescriptor(mds[i]));
}
return r;
}
/**
* Fills a repository with a set of module, using empty files for published artifacts.
*
* @param resolver
* the resolver to use to publish the modules
* @param mds
* the descriptors of the modules to put in the repository
* @throws IOException
* if an IO problem occurs while filling the repository
*/
public static void fillRepository(DependencyResolver resolver,
Collection/* <ModuleDescriptor> */mds) throws IOException {
File tmp = File.createTempFile("ivy", "tmp");
try {
for (Iterator iter = mds.iterator(); iter.hasNext();) {
boolean overwrite = false;
ModuleDescriptor md = (ModuleDescriptor) iter.next();
resolver.beginPublishTransaction(md.getModuleRevisionId(), overwrite);
boolean published = false;
try {
XmlModuleDescriptorWriter.write(md, tmp);
resolver.publish(md.getMetadataArtifact(), tmp, overwrite);
tmp.delete();
tmp.createNewFile();
Artifact[] artifacts = md.getAllArtifacts();
for (int i = 0; i < artifacts.length; i++) {
resolver.publish(artifacts[i], tmp, overwrite);
}
resolver.commitPublishTransaction();
published = true;
} finally {
if (!published) {
resolver.abortPublishTransaction();
}
}
}
} finally {
tmp.delete();
}
}
/**
* A file system resolver which can be used with the
* {@link #fillRepository(DependencyResolver, Collection)} method to create a test case of
* module descriptor.
* <p>
* When finished you should call {@link #cleanTestRepository()}
* </p>
*/
public static FileSystemResolver newTestRepository() {
FileSystemResolver testRepository = new FileSystemResolver();
testRepository.setName("test");
String testRepoDir = new File("build/test/test-repo").getAbsolutePath();
testRepository.addIvyPattern(testRepoDir
+ "/[organisation]/[module]/[revision]/[artifact].[ext]");
testRepository.addArtifactPattern(testRepoDir
+ "/[organisation]/[module]/[revision]/[artifact].[ext]");
return testRepository;
}
/**
* Cleans up the test repository.
*
* @see #newTestRepository()
*/
public static void cleanTestRepository() {
FileUtil.forceDelete(new File("build/test/test-repo"));
}
/**
* Cleans up the test repository and cache.
*
* @see #newTestSettings()
*/
public static void cleanTest() {
cleanTestRepository();
FileUtil.forceDelete(new File("build/test/cache"));
}
/**
* Init a test resolver as default, useful combined with
* {@link #fillRepository(DependencyResolver, Collection)}.
*
* @param settings
* the settings to initialize
* @return test settings
*/
public static IvySettings loadTestSettings(IvySettings settings) {
settings.setDefaultCache(new File("build/test/cache"));
settings.addResolver(newTestRepository());
settings.setDefaultResolver("test");
return settings;
}
/**
* Create basic resolve data using the given settings
*
* @param settings
* the settings to use to create the resolve data
* @return basic resolve data useful for testing
*/
public static ResolveData newResolveData(IvySettings settings) {
return new ResolveData(new ResolveEngine(settings, new EventManager(), new SortEngine(
settings)), newResolveOptions(settings));
}
/**
* Create basic resolve options using the given settings
*
* @param settings
* the settings to use to create the resolve options
* @return the basic resolve options, useful for testing
*/
public static ResolveOptions newResolveOptions(IvySettings settings) {
return new ResolveOptions();
}
}