maven-plugin-testing-harness/src/main/java/org/apache/maven/plugin/testing/ArtifactStubFactory.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.maven.plugin.testing;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Set;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DefaultArtifact;
import org.apache.maven.artifact.handler.ArtifactHandler;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.plugin.testing.stubs.DefaultArtifactHandlerStub;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.manager.ArchiverManager;
import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
import org.codehaus.plexus.archiver.war.WarArchiver;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.ReflectionUtils;
import org.codehaus.plexus.util.StringUtils;

/**
 * This class creates artifacts to be used for testing purposes. It can optionally create actual files on the local disk
 * for things like copying. It can create these files as archives with named files inside to be used for testing things
 * like unpack. Also provided are some utility methods to quickly get a set of artifacts distinguished by various things
 * like group,artifact,type,scope, etc It was originally developed for the dependency plugin, but can be useful in other
 * plugins that need to simulate artifacts for unit tests.
 *
 * @author <a href="mailto:brianf@apache.org">Brian Fox</a>
 */
public class ArtifactStubFactory {
    private File workingDir;

    private boolean createFiles;

    private File srcFile;

    private boolean createUnpackableFile;

    private ArchiverManager archiverManager;

    /**
     * Default constructor. This should be used only if real files aren't needed...just the artifact objects
     */
    public ArtifactStubFactory() {
        this.workingDir = null;
        this.createFiles = false;
    }

    /**
     * This constructor is to be used if files are needed and to set a working dir
     *
     * @param workingDir
     * @param createFiles
     */
    public ArtifactStubFactory(File workingDir, boolean createFiles) {
        this.workingDir = new File(workingDir, "localTestRepo");
        this.createFiles = createFiles;
    }

    /**
     * If set, the file will be created as a zip/jar/war with a file inside that can be checked to exist after
     * unpacking.
     *
     * @param archiverManager
     */
    public void setUnpackableFile(ArchiverManager archiverManager) {
        this.createUnpackableFile = true;
        this.archiverManager = archiverManager;
    }

    /**
     * @param groupId
     * @param artifactId
     * @param version
     * @return a <code>DefaultArtifact</code> instance for the given parameters
     * @throws IOException if any
     * @see #createArtifact(String, String, String, String, String, String)
     */
    public Artifact createArtifact(String groupId, String artifactId, String version) throws IOException {
        return createArtifact(groupId, artifactId, version, Artifact.SCOPE_COMPILE, "jar", "");
    }

    /**
     * @param groupId
     * @param artifactId
     * @param version
     * @param scope
     * @return a <code>DefaultArtifact</code> instance for the given parameters
     * @throws IOException if any
     * @see #createArtifact(String, String, String, String, String, String)
     */
    public Artifact createArtifact(String groupId, String artifactId, String version, String scope) throws IOException {
        return createArtifact(groupId, artifactId, version, scope, "jar", "");
    }

    /**
     * @param groupId
     * @param artifactId
     * @param version
     * @param scope
     * @param type
     * @param classifier
     * @return a <code>DefaultArtifact</code> instance for the given parameters
     * @throws IOException if any
     * @see #createArtifact(String, String, VersionRange, String, String, String, boolean)
     */
    public Artifact createArtifact(
            String groupId, String artifactId, String version, String scope, String type, String classifier)
            throws IOException {
        VersionRange vr = VersionRange.createFromVersion(version);
        return createArtifact(groupId, artifactId, vr, scope, type, classifier, false);
    }

    /**
     * @param groupId not null
     * @param artifactId not null
     * @param versionRange not null
     * @param scope not null
     * @param type not null
     * @param classifier
     * @param optional not null
     * @return a <code>DefaultArtifact</code> instance
     * @throws IOException if any
     */
    public Artifact createArtifact(
            String groupId,
            String artifactId,
            VersionRange versionRange,
            String scope,
            String type,
            String classifier,
            boolean optional)
            throws IOException {
        ArtifactHandler ah = new DefaultArtifactHandlerStub(type, classifier);

        Artifact artifact =
                new DefaultArtifact(groupId, artifactId, versionRange, scope, type, classifier, ah, optional);

        // i have no idea why this needs to be done manually when isSnapshot is able to figure it out.
        artifact.setRelease(!artifact.isSnapshot());

        if (createFiles) {
            setArtifactFile(artifact, this.workingDir, this.srcFile, this.createUnpackableFile);
        }
        return artifact;
    }

    /**
     * Creates a new empty file and attaches it to the artifact.
     *
     * @param artifact to attach the file to.
     * @param workingDir where to locate the new file
     * @throws IOException
     */
    public void setArtifactFile(Artifact artifact, File workingDir) throws IOException {
        setArtifactFile(artifact, workingDir, null, false);
    }

    /**
     * Copyies the srcFile to the workingDir and then attaches it to the artifact. If srcFile is null, a new empty file
     * will be created.
     *
     * @param artifact to attach
     * @param workingDir where to copy the srcFile.
     * @param srcFile file to be attached.
     * @throws IOException
     */
    public void setArtifactFile(Artifact artifact, File workingDir, File srcFile) throws IOException {
        setArtifactFile(artifact, workingDir, srcFile, false);
    }

    /**
     * Creates an unpackable file (zip,jar etc) containing an empty file.
     *
     * @param artifact to attach
     * @param workingDir where to create the file.
     * @throws IOException
     */
    public void setUnpackableArtifactFile(Artifact artifact, File workingDir) throws IOException {
        setArtifactFile(artifact, workingDir, null, true);
    }

    /**
     * Creates an unpackable file (zip,jar etc) containing the srcFile. If srcFile is null, a new empty file will be
     * created.
     *
     * @param artifact to attach
     * @param workingDir where to create the file.
     * @param srcFile
     * @throws IOException if any
     */
    public void setUnpackableArtifactFile(Artifact artifact, File workingDir, File srcFile) throws IOException {
        setArtifactFile(artifact, workingDir, srcFile, true);
    }

    /**
     * Creates a file that can be copied or unpacked based on the passed in artifact
     *
     * @param artifact
     * @param workingDir
     * @param srcFile
     * @param createUnpackableFile
     * @throws IOException if any
     */
    private void setArtifactFile(Artifact artifact, File workingDir, File srcFile, boolean createUnpackableFile)
            throws IOException {
        if (workingDir == null) {
            throw new IllegalArgumentException("The workingDir must be set.");
        }

        String fileName = getFormattedFileName(artifact, false);

        File theFile = new File(workingDir, fileName);
        theFile.getParentFile().mkdirs();

        if (srcFile == null) {
            theFile.createNewFile();
        } else if (createUnpackableFile) {
            try {
                createUnpackableFile(artifact, theFile);
            } catch (NoSuchArchiverException e) {
                throw new IOException("NoSuchArchiverException: " + e.getMessage());
            } catch (ArchiverException e) {
                throw new IOException("ArchiverException: " + e.getMessage());
            }
        } else {
            FileUtils.copyFile(srcFile, theFile);
        }

        artifact.setFile(theFile);
    }

    /**
     * @param artifact
     * @return
     */
    public static String getUnpackableFileName(Artifact artifact) {
        return "" + artifact.getGroupId() + "-" + artifact.getArtifactId() + "-" + artifact.getVersion() + "-"
                + artifact.getClassifier() + "-" + artifact.getType() + ".txt";
    }

    /**
     * @param artifact
     * @param destFile
     * @throws NoSuchArchiverException
     * @throws ArchiverException if any
     * @throws IOException if any
     */
    public void createUnpackableFile(Artifact artifact, File destFile)
            throws NoSuchArchiverException, ArchiverException, IOException {
        Archiver archiver = archiverManager.getArchiver(destFile);

        archiver.setDestFile(destFile);
        archiver.addFile(srcFile, getUnpackableFileName(artifact));

        if (archiver instanceof WarArchiver) {
            WarArchiver war = (WarArchiver) archiver;
            war.setExpectWebXml(false);
        }
        archiver.createArchive();
    }

    /**
     * @return a <code>DefaultArtifact</code> instance for <code>testGroupId:release:jar:1.0</code>
     * @throws IOException if any
     */
    public Artifact getReleaseArtifact() throws IOException {
        return createArtifact("testGroupId", "release", "1.0");
    }

    /**
     * @return a default <code>DefaultArtifact</code> instance for <code>testGroupId:snapshot:jar:2.0-SNAPSHOT</code>
     * @throws IOException if any
     */
    public Artifact getSnapshotArtifact() throws IOException {
        return createArtifact("testGroupId", "snapshot", "2.0-SNAPSHOT");
    }

    /**
     * @return a default set of release and snapshot <code>DefaultArtifact</code>, i.e.:
     * <code>testGroupId:snapshot:jar:2.0-SNAPSHOT, testGroupId:release:jar:1.0</code>
     * @throws IOException if any
     * @see #getReleaseArtifact()
     * @see #getSnapshotArtifact()
     */
    public Set<Artifact> getReleaseAndSnapshotArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.add(getReleaseArtifact());
        set.add(getSnapshotArtifact());
        return set;
    }

    /**
     * @return a default set of <code>DefaultArtifact</code>, i.e.:
     * <code>g:provided:jar:1.0, g:compile:jar:1.0, g:system:jar:1.0, g:test:jar:1.0, g:runtime:jar:1.0</code>
     * @throws IOException if any
     */
    public Set<Artifact> getScopedArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.add(createArtifact("g", "compile", "1.0", Artifact.SCOPE_COMPILE));
        set.add(createArtifact("g", "provided", "1.0", Artifact.SCOPE_PROVIDED));
        set.add(createArtifact("g", "test", "1.0", Artifact.SCOPE_TEST));
        set.add(createArtifact("g", "runtime", "1.0", Artifact.SCOPE_RUNTIME));
        set.add(createArtifact("g", "system", "1.0", Artifact.SCOPE_SYSTEM));
        return set;
    }

    /**
     * @return a set of <code>DefaultArtifact</code>, i.e.:
     * <code>g:d:zip:1.0, g:a:war:1.0, g:b:jar:1.0, g:c:sources:1.0, g:e:rar:1.0</code>
     * @throws IOException if any
     */
    public Set<Artifact> getTypedArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.add(createArtifact("g", "a", "1.0", Artifact.SCOPE_COMPILE, "war", null));
        set.add(createArtifact("g", "b", "1.0", Artifact.SCOPE_COMPILE, "jar", null));
        set.add(createArtifact("g", "c", "1.0", Artifact.SCOPE_COMPILE, "sources", null));
        set.add(createArtifact("g", "d", "1.0", Artifact.SCOPE_COMPILE, "zip", null));
        set.add(createArtifact("g", "e", "1.0", Artifact.SCOPE_COMPILE, "rar", null));
        return set;
    }

    /**
     * @return a set of <code>DefaultArtifact</code>, i.e.:
     * <code>g:c:jar:three:1.0, g:b:jar:two:1.0, g:d:jar:four:1.0, g:a:jar:one:1.0</code>
     * @throws IOException if any
     */
    public Set<Artifact> getClassifiedArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.add(createArtifact("g", "a", "1.0", Artifact.SCOPE_COMPILE, "jar", "one"));
        set.add(createArtifact("g", "b", "1.0", Artifact.SCOPE_COMPILE, "jar", "two"));
        set.add(createArtifact("g", "c", "1.0", Artifact.SCOPE_COMPILE, "jar", "three"));
        set.add(createArtifact("g", "d", "1.0", Artifact.SCOPE_COMPILE, "jar", "four"));
        return set;
    }

    /**
     * @return a set of <code>DefaultArtifact</code>, i.e.:
     * <code>g:d:zip:1.0, g:a:war:1.0, g:b:jar:1.0, g:e:rar:1.0</code>
     * @throws IOException if any
     */
    public Set<Artifact> getTypedArchiveArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.add(createArtifact("g", "a", "1.0", Artifact.SCOPE_COMPILE, "war", null));
        set.add(createArtifact("g", "b", "1.0", Artifact.SCOPE_COMPILE, "jar", null));
        set.add(createArtifact("g", "d", "1.0", Artifact.SCOPE_COMPILE, "zip", null));
        set.add(createArtifact("g", "e", "1.0", Artifact.SCOPE_COMPILE, "rar", null));
        return set;
    }

    /**
     * @return a set of <code>DefaultArtifact</code>, i.e.:
     * <code>g:one:jar:a:1.0, g:two:jar:a:1.0, g:four:jar:a:1.0, g:three:jar:a:1.0</code>
     * @throws IOException if any
     */
    public Set<Artifact> getArtifactArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.add(createArtifact("g", "one", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        set.add(createArtifact("g", "two", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        set.add(createArtifact("g", "three", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        set.add(createArtifact("g", "four", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        return set;
    }

    /**
     * @return a set of <code>DefaultArtifact</code>, i.e.:
     * <code>one:group-one:jar:a:1.0, three:group-three:jar:a:1.0, four:group-four:jar:a:1.0,
     * two:group-two:jar:a:1.0</code>
     * @throws IOException if any
     */
    public Set<Artifact> getGroupIdArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.add(createArtifact("one", "group-one", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        set.add(createArtifact("two", "group-two", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        set.add(createArtifact("three", "group-three", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        set.add(createArtifact("four", "group-four", "1.0", Artifact.SCOPE_COMPILE, "jar", "a"));
        return set;
    }

    /**
     * @return a set of <code>DefaultArtifact</code>
     * @throws IOException if any
     * @see #getTypedArtifacts()
     * @see #getScopedArtifacts()
     * @see #getReleaseAndSnapshotArtifacts()
     */
    public Set<Artifact> getMixedArtifacts() throws IOException {
        Set<Artifact> set = new HashSet<>();
        set.addAll(getTypedArtifacts());
        set.addAll(getScopedArtifacts());
        set.addAll(getReleaseAndSnapshotArtifacts());
        return set;
    }

    /**
     * @return Returns the createFiles.
     */
    public boolean isCreateFiles() {
        return this.createFiles;
    }

    /**
     * @param createFiles The createFiles to set.
     */
    public void setCreateFiles(boolean createFiles) {
        this.createFiles = createFiles;
    }

    /**
     * @return Returns the workingDir.
     */
    public File getWorkingDir() {
        return this.workingDir;
    }

    /**
     * @param workingDir The workingDir to set.
     */
    public void setWorkingDir(File workingDir) {
        this.workingDir = workingDir;
    }

    /**
     * @return Returns the srcFile.
     */
    public File getSrcFile() {
        return this.srcFile;
    }

    /**
     * @param srcFile The srcFile to set.
     */
    public void setSrcFile(File srcFile) {
        this.srcFile = srcFile;
    }

    /**
     * Convenience method to set values to variables in objects that don't have setters
     *
     * @param object
     * @param variable
     * @param value
     * @throws IllegalAccessException
     */
    public static void setVariableValueToObject(Object object, String variable, Object value)
            throws IllegalAccessException {
        Field field = ReflectionUtils.getFieldByNameIncludingSuperclasses(variable, object.getClass());

        field.setAccessible(true);

        field.set(object, value);
    }

    /**
     * Builds the file name. If removeVersion is set, then the file name must be reconstructed from the artifactId,
     * Classifier (if used) and Type. Otherwise, this method returns the artifact file name.
     *
     * @param artifact File to be formatted.
     * @param removeVersion Specifies if the version should be removed from the file name.
     * @return Formatted file name in the format artifactId-[version]-[classifier].[type]
     */
    public static String getFormattedFileName(Artifact artifact, boolean removeVersion) {
        String destFileName = null;

        // if there is a file and we aren't stripping the version, just get the
        // name directly
        if (artifact.getFile() != null && !removeVersion) {
            destFileName = artifact.getFile().getName();
        } else
        // if offline
        {
            String versionString = null;
            if (!removeVersion) {
                versionString = "-" + artifact.getVersion();
            } else {
                versionString = "";
            }

            String classifierString = "";

            if (StringUtils.isNotEmpty(artifact.getClassifier())) {
                classifierString = "-" + artifact.getClassifier();
            }

            destFileName = artifact.getArtifactId() + versionString + classifierString + "."
                    + artifact.getArtifactHandler().getExtension();
        }
        return destFileName;
    }
}