GallioCommandBuilder.java

/*
 * .NET tools :: Gallio Runner
 * Copyright (C) 2010 Jose Chillan, Alexandre Victoor and SonarSource
 * dev@sonar.codehaus.org
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
 */
package org.sonar.dotnet.tools.gallio;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.sonar.api.utils.command.Command;
import org.sonar.dotnet.tools.commons.visualstudio.VisualStudioProject;
import org.sonar.dotnet.tools.commons.visualstudio.VisualStudioSolution;

import com.google.common.collect.Lists;

/**
 * Class used to build the command line to run Gallio.
 */
public final class GallioCommandBuilder {

  private static final Logger LOG = LoggerFactory.getLogger(GallioCommandBuilder.class);

  private static final String DEFAULT_GALLIO_RUNNER = "IsolatedProcess";
  private static final String PART_COVER_EXE = "PartCover.exe";

  private VisualStudioSolution solution;
  private String buildConfigurations = "Debug";
  // Information needed for simple Gallio execution
  private File gallioExecutable;
  private File gallioReportFile;
  private String filter;
  private File workDir;
  // Information needed for coverage execution
  private CoverageTool coverageTool;
  private File partCoverInstallDirectory;
  private String coverageExcludes;
  private File coverageReportFile;

  private GallioCommandBuilder() {
  }

  /**
   * Constructs a {@link GallioCommandBuilder} object for the given Visual Studio solution.
   * 
   * @param solution
   *          the solution to analyse
   * @return a Gallio builder for this solution
   */
  public static GallioCommandBuilder createBuilder(VisualStudioSolution solution) {
    GallioCommandBuilder builder = new GallioCommandBuilder();
    builder.solution = solution;
    return builder;
  }

  /**
   * Sets the install dir for Gallio
   * 
   * @param gallioExecutable
   *          the executable
   * @return the current builder
   */
  public GallioCommandBuilder setExecutable(File gallioExecutable) {
    this.gallioExecutable = gallioExecutable;
    return this;
  }

  /**
   * Sets the report file to generate
   * 
   * @param reportFile
   *          the report file
   * @return the current builder
   */
  public GallioCommandBuilder setReportFile(File reportFile) {
    this.gallioReportFile = reportFile;
    return this;
  }

  /**
   * Sets Gallio test filter. <br/>
   * This can be used to execute only a specific test category (i.e. CategotyName:unit to consider only tests from the 'unit' category)
   * 
   * @param gallioFilter
   *          the filter for Gallio
   * @return the current builder
   */
  public GallioCommandBuilder setFilter(String gallioFilter) {
    this.filter = gallioFilter;
    return this;
  }

  /**
   * Sets the build configurations. By default, it is "Debug".
   * 
   * @param buildConfigurations
   *          the build configurations
   * @return the current builder
   */
  public GallioCommandBuilder setBuildConfigurations(String buildConfigurations) {
    this.buildConfigurations = buildConfigurations;
    return this;
  }

  /**
   * Set the working directory
   * 
   * @param workDir
   *          the working directory
   */
  public GallioCommandBuilder setWorkDir(File workDir) {
    this.workDir = workDir;
    return this;
  }

  /**
   * Sets the coverage tool to use, given its name (insensitive, for instance "ncover" or "NCover"). If none corresponding to the given name
   * is found, or if an empty string is passed, then no coverage tool will be used and no coverage report will be generated. <br>
   * <br/>
   * To know which tools are currently supported, check {@link CoverageTool}
   * 
   * @see CoverageTool
   * @param coverageToolName
   *          the name of the tool
   */
  public GallioCommandBuilder setCoverageTool(String coverageToolName) {
    this.coverageTool = CoverageTool.findFromName(coverageToolName);
    return this;
  }

  /**
   * Sets PartCover installation directory.
   * 
   * @param partCoverInstallDirectory
   *          the install dir
   */
  public GallioCommandBuilder setPartCoverInstallDirectory(File partCoverInstallDirectory) {
    this.partCoverInstallDirectory = partCoverInstallDirectory;
    return this;
  }

  /**
   * Sets the namespaces and assemblies excluded from the code coverage, seperated by a comma. The format for an exclusion is the PartCover
   * format: "[assembly]namespace".
   * 
   * @param coverageExcludes
   *          the excludes
   */
  public GallioCommandBuilder setCoverageExcludes(String coverageExcludes) {
    this.coverageExcludes = coverageExcludes;
    return this;
  }

  /**
   * Sets the coverage report file to generate
   * 
   * @param coverageReportFile
   *          the report file
   * @return the current builder
   */
  public GallioCommandBuilder setCoverageReportFile(File coverageReportFile) {
    this.coverageReportFile = coverageReportFile;
    return this;
  }

  /**
   * Transforms this command object into a Command object that can be passed to the CommandExecutor.
   * 
   * @return the Command object that represents the command to launch.
   */
  public Command toCommand() throws GallioException {
    List<File> testAssemblies = findTestAssemblies();
    validateGallioInfo(testAssemblies);

    Command command = createCommand();
    List<String> gallioArguments = generateGallioArguments(testAssemblies);

    if (CoverageTool.PARTCOVER.equals(coverageTool)) {
      addPartCoverArguments(command, gallioArguments);
    } else if (CoverageTool.NCOVER.equals(coverageTool)) {
      addNCoverArguments(command, gallioArguments);
    } else {
      command.addArguments(gallioArguments);
    }

    return command;
  }

  protected Command createCommand() throws GallioException {
    Command command = null;
    LOG.debug("- Gallio executable   : " + gallioExecutable);

    if (CoverageTool.PARTCOVER.equals(coverageTool)) {
      // In case of PartCover, the executable is not Gallio but PartCover itself
      File partCoverExecutable = new File(partCoverInstallDirectory, PART_COVER_EXE);
      validatePartCoverInfo(partCoverExecutable);
      LOG.debug("- PartCover executable: " + partCoverExecutable);
      command = Command.create(partCoverExecutable.getAbsolutePath());
    } else {
      command = Command.create(gallioExecutable.getAbsolutePath());
    }

    command.setDirectory(workDir);

    return command;
  }

  protected List<String> generateGallioArguments(List<File> testAssemblies) {
    List<String> gallioArguments = Lists.newArrayList();

    String runner = DEFAULT_GALLIO_RUNNER;
    if (coverageTool != null) {
      LOG.debug("- Coverage tool       : {}", coverageTool.getName());
      runner = coverageTool.getGallioRunner();
    }
    LOG.debug("- Runner              : {}", runner);
    gallioArguments.add("/r:" + runner);

    File reportDirectory = gallioReportFile.getParentFile();
    LOG.debug("- Report directory    : {}", reportDirectory.getAbsolutePath());
    gallioArguments.add("/report-directory:" + reportDirectory.getAbsolutePath());

    String reportName = trimFileReportName();
    LOG.debug("- Report file         : {}", reportName);
    gallioArguments.add("/report-name-format:" + reportName);

    gallioArguments.add("/report-type:Xml");

    if (StringUtils.isNotEmpty(filter)) {
      LOG.debug("- Filter              : {}", filter);
      gallioArguments.add("/f:" + filter);
    }

    LOG.debug("- Test assemblies     :");
    for (File testAssembly : testAssemblies) {
      LOG.debug("   o {}", testAssembly);
      gallioArguments.add(testAssembly.getAbsolutePath());
    }
    return gallioArguments;
  }

  protected void addPartCoverArguments(Command command, List<String> gallioArguments) {
    // DEBUG info has already been printed out for "--target"
    command.addArgument("--target");
    command.addArgument(gallioExecutable.getAbsolutePath());

    LOG.debug("- Working directory   : {}", workDir.getAbsolutePath());
    command.addArgument("--target-work-dir");
    command.addArgument(workDir.getAbsolutePath());

    // DEBUG info has already been printed out for "--target-args"
    command.addArgument("--target-args");
    command.addArgument(escapeGallioArguments(gallioArguments));

    // We add all the covered assemblies
    for (String assemblyName : listCoveredAssemblies()) {
      LOG.debug("- Partcover include   : [{}]*", assemblyName);
      command.addArgument("--include");
      command.addArgument("[" + assemblyName + "]*");
    }

    // We add all the configured exclusions
    if ( !StringUtils.isEmpty(coverageExcludes)) {
      for (String exclusion : StringUtils.split(coverageExcludes, ",")) {
        LOG.debug("- Partcover exclude   : {}", exclusion.trim());
        command.addArgument("--exclude");
        command.addArgument(exclusion.trim());
      }
    }

    LOG.debug("- Coverage report     : {}", coverageReportFile.getAbsolutePath());
    command.addArgument("--output");
    command.addArgument(coverageReportFile.getAbsolutePath());
  }

  private void addNCoverArguments(Command command, List<String> gallioArguments) {
    command.addArguments(gallioArguments);

    LOG.debug("- Coverage report     : {}", coverageReportFile.getAbsolutePath());
    command.addArgument("/runner-property:NCoverCoverageFile=" + coverageReportFile.getAbsolutePath());

    String coveredAssemblies = StringUtils.join(listCoveredAssemblies().toArray(), ";");
    LOG.debug("- NCover arguments    : {}", coveredAssemblies);
    command.addArgument("/runner-property:NCoverArguments=//ias " + coveredAssemblies);
  }

  protected List<String> listCoveredAssemblies() {
    List<String> coveredAssemblyNames = new ArrayList<String>();
    for (VisualStudioProject visualProject : solution.getProjects()) {
      if ( !visualProject.isTest()) {
        coveredAssemblyNames.add(visualProject.getAssemblyName());
      }
    }
    return coveredAssemblyNames;
  }

  // TODO : try to refactor this
  protected String escapeGallioArguments(List<String> gallioArguments) {
    StringBuilder targetArgsBuilder = new StringBuilder();
    boolean isFirst = true;
    for (String currentArg : gallioArguments) {
      if (isFirst) {
        isFirst = false;
      } else {
        targetArgsBuilder.append(' ');
      }
      String escapedArg = escapeQuotes(currentArg);
      targetArgsBuilder.append(escapedArg);
    }
    return targetArgsBuilder.toString();
  }

  /*
   * Escapes the quotes of a string. TODO : try to refactor this
   */
  protected String escapeQuotes(String input) {
    StringBuilder result = new StringBuilder(input.length());
    for (int idxChar = 0, len = input.length(); idxChar < len; idxChar++) {
      char currentChar = input.charAt(idxChar);
      if (currentChar == '"') {
        result.append('\\');
      } else if (idxChar == 0) {
        result.append("\\\"");
      }

      result.append(currentChar);

      if (currentChar != '"' && idxChar == len - 1) {
        result.append("\\\"");
      }
    }
    return result.toString();
  }

  protected String trimFileReportName() {
    String reportName = gallioReportFile.getName();
    if (StringUtils.endsWithIgnoreCase(reportName, ".xml")) {
      // We remove the terminal .xml that will be added by the Gallio runner
      reportName = reportName.substring(0, reportName.length() - 4);
    }
    return reportName;
  }

  protected List<File> findTestAssemblies() throws GallioException {
    List<File> assemblyFileList = Lists.newArrayList();
    if (solution != null) {
      for (VisualStudioProject visualStudioProject : solution.getTestProjects()) {
        addAssembly(assemblyFileList, visualStudioProject);
      }
    } else {
      throw new GallioException("No .NET solution or project has been given to the Gallio command builder.");
    }
    return assemblyFileList;
  }

  protected void addAssembly(List<File> assemblyFileList, VisualStudioProject visualStudioProject) {
    File assembly = visualStudioProject.getArtifact(buildConfigurations);
    if (assembly != null && assembly.isFile()) {
      assemblyFileList.add(assembly);
    }
  }

  protected void validateGallioInfo(List<File> testAssemblies) throws GallioException {
    if (gallioExecutable == null || !gallioExecutable.isFile()) {
      throw new GallioException("Gallio executable cannot be found at the following location:" + gallioExecutable);
    }
    if (gallioReportFile == null) {
      throw new GallioException("Gallio report file has not been specified.");
    }
    if (workDir == null || !workDir.isDirectory()) {
      throw new GallioException("The working directory cannot be found at the following location:" + workDir);
    }
    if (testAssemblies.isEmpty()) {
      throw new GallioException("No test assembly was found. Please check your project's Gallio plugin configuration.");
    }
  }

  protected void validatePartCoverInfo(File partCoverExecutable) throws GallioException {
    if (partCoverExecutable == null || !partCoverExecutable.isFile()) {
      throw new GallioException("PartCover executable cannot be found at the following location:" + partCoverExecutable);
    }
    if (coverageReportFile == null) {
      throw new GallioException("Gallio coverage report file has not been specified.");
    }
  }
}