src/com/facebook/buck/java/JUnitStep.java - buck - Git at Google

 /*
  * Copyright 2012-present Facebook, Inc.
  *
  * Licensed 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 com.facebook.buck.java;

 import com.facebook.buck.model.BuildId;
 import com.facebook.buck.shell.ShellStep;
 import com.facebook.buck.step.ExecutionContext;
 import com.facebook.buck.test.selectors.TestSelectorList;
 import com.facebook.buck.util.BuckConstant;
 import com.facebook.buck.util.ProcessExecutor;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Joiner;
 import com.google.common.base.Optional;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;

 import java.io.File;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.List;
 import java.util.Set;

 public class JUnitStep extends ShellStep {

   // Note that the default value is used when `buck test --all` is run on Buck itself.
   @VisibleForTesting
   static final String JUNIT_TEST_RUNNER_CLASS_NAME =
       "com.facebook.buck.junit.JUnitMain";
   @VisibleForTesting
   static final String TESTNG_TEST_RUNNER_CLASS_NAME =
       "com.facebook.buck.junit.TestNGMain";

   private static final Path TESTRUNNER_CLASSES =
       Paths.get(
           System.getProperty(
               "buck.testrunner_classes",
               new File("build/testrunner/classes").getAbsolutePath()));

   @VisibleForTesting
   public static final String BUILD_ID_PROPERTY = "com.facebook.buck.buildId";

   private final ImmutableSet<Path> classpathEntries;
   private final Iterable<String> testClassNames;
   private final List<String> vmArgs;
   private final Path directoryForTestResults;
   private final Path tmpDirectory;
   private final Path testRunnerClasspath;
   private final boolean isCodeCoverageEnabled;
   private final boolean isDebugEnabled;
   private final BuildId buildId;
   private TestSelectorList testSelectorList;
   private final boolean isDryRun;
   private final TestType type;
   private final Optional<Long> testRuleTimeoutMs;

   // Set when the junit command times out.
   private boolean hasTimedOut = false;

   /**
    *  JaCoco is enabled for the code-coverage analysis.
    */
   public static final String PATH_TO_JACOCO_AGENT_JAR =
       System.getProperty(
           "buck.jacoco_agent_jar",
           "third-party/java/jacoco/jacocoagent.jar");

   public static final String JACOCO_EXEC_COVERAGE_FILE = "jacoco.exec";

   public static final Path JACOCO_OUTPUT_DIR = BuckConstant.GEN_PATH.resolve("jacoco");

   /**
    * @param classpathEntries contains the entries that will be listed first in the classpath when
    *     running JUnit. Entries for the bootclasspath for Android will be appended to this list, as
    *     well as an entry for the test runner. classpathEntries must include entries for the tests
    *     that will be run, as well as an entry for JUnit.
    * @param testClassNames the fully qualified names of the Java tests to run
    * @param directoryForTestResults directory where test results should be written
    * @param tmpDirectory directory tests can use for local file scratch space.
    */
   public JUnitStep(
       Set<Path> classpathEntries,
       Iterable<String> testClassNames,
       List<String> vmArgs,
       Path directoryForTestResults,
       Path tmpDirectory,
       boolean isCodeCoverageEnabled,
       boolean isDebugEnabled,
       BuildId buildId,
       TestSelectorList testSelectorList,
       boolean isDryRun,
       TestType type,
       Optional<Long> testRuleTimeoutMs) {
     this(classpathEntries,
         testClassNames,
         vmArgs,
         directoryForTestResults,
         tmpDirectory,
         isCodeCoverageEnabled,
         isDebugEnabled,
         buildId,
         testSelectorList,
         isDryRun,
         type,
         TESTRUNNER_CLASSES,
         testRuleTimeoutMs);
   }

   @VisibleForTesting
   JUnitStep(
       Set<Path> classpathEntries,
       Iterable<String> testClassNames,
       List<String> vmArgs,
       Path directoryForTestResults,
       Path tmpDirectory,
       boolean isCodeCoverageEnabled,
       boolean isDebugEnabled,
       BuildId buildId,
       TestSelectorList testSelectorList,
       boolean isDryRun,
       TestType type,
       Path testRunnerClasspath,
       Optional<Long> testRuleTimeoutMs) {
     this.classpathEntries = ImmutableSet.copyOf(classpathEntries);
     this.testClassNames = Iterables.unmodifiableIterable(testClassNames);
     this.vmArgs = ImmutableList.copyOf(vmArgs);
     this.directoryForTestResults = directoryForTestResults;
     this.tmpDirectory = tmpDirectory;
     this.isCodeCoverageEnabled = isCodeCoverageEnabled;
     this.isDebugEnabled = isDebugEnabled;
     this.buildId = buildId;
     this.testSelectorList = testSelectorList;
     this.isDryRun = isDryRun;
     this.type = type;
     this.testRunnerClasspath = testRunnerClasspath;
     this.testRuleTimeoutMs = testRuleTimeoutMs;
   }

   @Override
   public String getShortName() {
     return "junit";
   }

   @Override
   protected ImmutableList<String> getShellCommandInternal(ExecutionContext context) {
     ImmutableList.Builder<String> args = ImmutableList.builder();
     args.add("java");
     args.add(String.format("-Djava.io.tmpdir=%s", tmpDirectory));

     // NOTE(agallagher): These propbably don't belong here, but buck integration tests need
     // to find the test runner classes, so propagate these down via the relevant properties.
     args.add(
         String.format(
             "-Dbuck.testrunner_classes=%s",
             testRunnerClasspath));

     if (isCodeCoverageEnabled) {
       args.add(String.format("-javaagent:%s=destfile=%s/%s,append=true",
           PATH_TO_JACOCO_AGENT_JAR,
           JACOCO_OUTPUT_DIR,
           JACOCO_EXEC_COVERAGE_FILE));
     }

     // Include the buildId
     args.add(String.format("-D%s=%s", BUILD_ID_PROPERTY, buildId));

     if (isDebugEnabled) {
       // This is the default config used by IntelliJ. By doing this, all a user
       // needs to do is create a new "Remote" debug config. Note that we start
       // suspended, so tests will not run until the user connects.
       args.add("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
       warnUser(context,
           "Debugging. Suspending JVM. Connect a JDWP debugger to port 5005 to proceed.");
     }

     // User-defined VM arguments, such as -D or -X.
     args.addAll(vmArgs);

     // verbose flag, if appropriate.
     if (context.getVerbosity().shouldUseVerbosityFlagIfAvailable()) {
       args.add("-verbose");
     }

     // Build up the -classpath argument, starting with the classpath entries the client specified.
     List<Path> classpath = Lists.newArrayList(classpathEntries);

     // Finally, include an entry for the test runner.
     classpath.add(testRunnerClasspath);

     // Add the -classpath argument.
     args.add("-classpath").add(Joiner.on(File.pathSeparator).join(classpath));

     // Specify the Java class whose main() method should be run. This is the class that is
     // responsible for running the tests.
     if (TestType.JUNIT == type) {
       args.add(JUNIT_TEST_RUNNER_CLASS_NAME);
     } else if (TestType.TESTNG == type) {
       args.add(TESTNG_TEST_RUNNER_CLASS_NAME);
     } else {
       throw new IllegalArgumentException(
           "java_test: unrecognized type " + type + ", expected eg. junit or testng");
     }

     // The first argument to the test runner is where the test results should be written. It is not
     // reliable to write test results to stdout or stderr because there may be output from the unit
     // tests written to those file descriptors, as well.
     args.add(directoryForTestResults.toString());

     // Add the default test timeout if --debug flag is not set
     long timeout = isDebugEnabled ? 0 : context.getDefaultTestTimeoutMillis();
     args.add(String.valueOf(timeout));

     // Add the test selectors, one per line, in a single argument.
     StringBuilder selectorsArgBuilder = new StringBuilder();
     if (!testSelectorList.isEmpty()) {
       for (String rawSelector : this.testSelectorList.getRawSelectors()) {
         selectorsArgBuilder.append(rawSelector).append("\n");
       }
     }
     args.add(selectorsArgBuilder.toString());

     // Dry-run flag.
     args.add(isDryRun ? "non-empty-dry-run-flag" : "");

     // List all of the tests to be run.
     for (String testClassName : testClassNames) {
       args.add(testClassName);
     }

     return args.build();
   }

   @Override
   public ImmutableMap<String, String> getEnvironmentVariables(ExecutionContext context) {
     return ImmutableMap.of("TMP", tmpDirectory.toString());
   }

   private void warnUser(ExecutionContext context, String message) {
     context.getStdErr().println(context.getAnsi().asWarningText(message));
   }

   @Override
   protected Optional<Long> getTimeout() {
     return testRuleTimeoutMs;
   }

   @Override
   protected int getExitCodeFromResult(ExecutionContext context, ProcessExecutor.Result result) {
     int exitCode = result.getExitCode();

     // If we timed out, force the exit code to 0 just so that the step itself doesn't fail,
     // allowing us to interpret any test cases that finished before the bad test.  We signify
     // this special case by setting `hasTimedOut` which the result interpreter will query to
     // properly format its results.
     if (result.isTimedOut()) {
       exitCode = 0;
       hasTimedOut = true;
     }

     return exitCode;
   }

   public boolean hasTimedOut() {
     return hasTimedOut;
   }

 }
	/*
	* Copyright 2012-present Facebook, Inc.
	*
	* Licensed 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 com.facebook.buck.java;

	import com.facebook.buck.model.BuildId;
	import com.facebook.buck.shell.ShellStep;
	import com.facebook.buck.step.ExecutionContext;
	import com.facebook.buck.test.selectors.TestSelectorList;
	import com.facebook.buck.util.BuckConstant;
	import com.facebook.buck.util.ProcessExecutor;
	import com.google.common.annotations.VisibleForTesting;
	import com.google.common.base.Joiner;
	import com.google.common.base.Optional;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Iterables;
	import com.google.common.collect.Lists;

	import java.io.File;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.util.List;
	import java.util.Set;

	public class JUnitStep extends ShellStep {

	// Note that the default value is used when `buck test --all` is run on Buck itself.
	@VisibleForTesting
	static final String JUNIT_TEST_RUNNER_CLASS_NAME =
	"com.facebook.buck.junit.JUnitMain";
	@VisibleForTesting
	static final String TESTNG_TEST_RUNNER_CLASS_NAME =
	"com.facebook.buck.junit.TestNGMain";

	private static final Path TESTRUNNER_CLASSES =
	Paths.get(
	System.getProperty(
	"buck.testrunner_classes",
	new File("build/testrunner/classes").getAbsolutePath()));

	@VisibleForTesting
	public static final String BUILD_ID_PROPERTY = "com.facebook.buck.buildId";

	private final ImmutableSet<Path> classpathEntries;
	private final Iterable<String> testClassNames;
	private final List<String> vmArgs;
	private final Path directoryForTestResults;
	private final Path tmpDirectory;
	private final Path testRunnerClasspath;
	private final boolean isCodeCoverageEnabled;
	private final boolean isDebugEnabled;
	private final BuildId buildId;
	private TestSelectorList testSelectorList;
	private final boolean isDryRun;
	private final TestType type;
	private final Optional<Long> testRuleTimeoutMs;

	// Set when the junit command times out.
	private boolean hasTimedOut = false;

	/**
	* JaCoco is enabled for the code-coverage analysis.
	*/
	public static final String PATH_TO_JACOCO_AGENT_JAR =
	System.getProperty(
	"buck.jacoco_agent_jar",
	"third-party/java/jacoco/jacocoagent.jar");

	public static final String JACOCO_EXEC_COVERAGE_FILE = "jacoco.exec";

	public static final Path JACOCO_OUTPUT_DIR = BuckConstant.GEN_PATH.resolve("jacoco");

	/**
	* @param classpathEntries contains the entries that will be listed first in the classpath when
	* running JUnit. Entries for the bootclasspath for Android will be appended to this list, as
	* well as an entry for the test runner. classpathEntries must include entries for the tests
	* that will be run, as well as an entry for JUnit.
	* @param testClassNames the fully qualified names of the Java tests to run
	* @param directoryForTestResults directory where test results should be written
	* @param tmpDirectory directory tests can use for local file scratch space.
	*/
	public JUnitStep(
	Set<Path> classpathEntries,
	Iterable<String> testClassNames,
	List<String> vmArgs,
	Path directoryForTestResults,
	Path tmpDirectory,
	boolean isCodeCoverageEnabled,
	boolean isDebugEnabled,
	BuildId buildId,
	TestSelectorList testSelectorList,
	boolean isDryRun,
	TestType type,
	Optional<Long> testRuleTimeoutMs) {
	this(classpathEntries,
	testClassNames,
	vmArgs,
	directoryForTestResults,
	tmpDirectory,
	isCodeCoverageEnabled,
	isDebugEnabled,
	buildId,
	testSelectorList,
	isDryRun,
	type,
	TESTRUNNER_CLASSES,
	testRuleTimeoutMs);
	}

	@VisibleForTesting
	JUnitStep(
	Set<Path> classpathEntries,
	Iterable<String> testClassNames,
	List<String> vmArgs,
	Path directoryForTestResults,
	Path tmpDirectory,
	boolean isCodeCoverageEnabled,
	boolean isDebugEnabled,
	BuildId buildId,
	TestSelectorList testSelectorList,
	boolean isDryRun,
	TestType type,
	Path testRunnerClasspath,
	Optional<Long> testRuleTimeoutMs) {
	this.classpathEntries = ImmutableSet.copyOf(classpathEntries);
	this.testClassNames = Iterables.unmodifiableIterable(testClassNames);
	this.vmArgs = ImmutableList.copyOf(vmArgs);
	this.directoryForTestResults = directoryForTestResults;
	this.tmpDirectory = tmpDirectory;
	this.isCodeCoverageEnabled = isCodeCoverageEnabled;
	this.isDebugEnabled = isDebugEnabled;
	this.buildId = buildId;
	this.testSelectorList = testSelectorList;
	this.isDryRun = isDryRun;
	this.type = type;
	this.testRunnerClasspath = testRunnerClasspath;
	this.testRuleTimeoutMs = testRuleTimeoutMs;
	}

	@Override
	public String getShortName() {
	return "junit";
	}

	@Override
	protected ImmutableList<String> getShellCommandInternal(ExecutionContext context) {
	ImmutableList.Builder<String> args = ImmutableList.builder();
	args.add("java");
	args.add(String.format("-Djava.io.tmpdir=%s", tmpDirectory));

	// NOTE(agallagher): These propbably don't belong here, but buck integration tests need
	// to find the test runner classes, so propagate these down via the relevant properties.
	args.add(
	String.format(
	"-Dbuck.testrunner_classes=%s",
	testRunnerClasspath));

	if (isCodeCoverageEnabled) {
	args.add(String.format("-javaagent:%s=destfile=%s/%s,append=true",
	PATH_TO_JACOCO_AGENT_JAR,
	JACOCO_OUTPUT_DIR,
	JACOCO_EXEC_COVERAGE_FILE));
	}

	// Include the buildId
	args.add(String.format("-D%s=%s", BUILD_ID_PROPERTY, buildId));

	if (isDebugEnabled) {
	// This is the default config used by IntelliJ. By doing this, all a user
	// needs to do is create a new "Remote" debug config. Note that we start
	// suspended, so tests will not run until the user connects.
	args.add("-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005");
	warnUser(context,
	"Debugging. Suspending JVM. Connect a JDWP debugger to port 5005 to proceed.");
	}

	// User-defined VM arguments, such as -D or -X.
	args.addAll(vmArgs);

	// verbose flag, if appropriate.
	if (context.getVerbosity().shouldUseVerbosityFlagIfAvailable()) {
	args.add("-verbose");
	}

	// Build up the -classpath argument, starting with the classpath entries the client specified.
	List<Path> classpath = Lists.newArrayList(classpathEntries);

	// Finally, include an entry for the test runner.
	classpath.add(testRunnerClasspath);

	// Add the -classpath argument.
	args.add("-classpath").add(Joiner.on(File.pathSeparator).join(classpath));

	// Specify the Java class whose main() method should be run. This is the class that is
	// responsible for running the tests.
	if (TestType.JUNIT == type) {
	args.add(JUNIT_TEST_RUNNER_CLASS_NAME);
	} else if (TestType.TESTNG == type) {
	args.add(TESTNG_TEST_RUNNER_CLASS_NAME);
	} else {
	throw new IllegalArgumentException(
	"java_test: unrecognized type " + type + ", expected eg. junit or testng");
	}

	// The first argument to the test runner is where the test results should be written. It is not
	// reliable to write test results to stdout or stderr because there may be output from the unit
	// tests written to those file descriptors, as well.
	args.add(directoryForTestResults.toString());

	// Add the default test timeout if --debug flag is not set
	long timeout = isDebugEnabled ? 0 : context.getDefaultTestTimeoutMillis();
	args.add(String.valueOf(timeout));

	// Add the test selectors, one per line, in a single argument.
	StringBuilder selectorsArgBuilder = new StringBuilder();
	if (!testSelectorList.isEmpty()) {
	for (String rawSelector : this.testSelectorList.getRawSelectors()) {
	selectorsArgBuilder.append(rawSelector).append("\n");
	}
	}
	args.add(selectorsArgBuilder.toString());

	// Dry-run flag.
	args.add(isDryRun ? "non-empty-dry-run-flag" : "");

	// List all of the tests to be run.
	for (String testClassName : testClassNames) {
	args.add(testClassName);
	}

	return args.build();
	}

	@Override
	public ImmutableMap<String, String> getEnvironmentVariables(ExecutionContext context) {
	return ImmutableMap.of("TMP", tmpDirectory.toString());
	}

	private void warnUser(ExecutionContext context, String message) {
	context.getStdErr().println(context.getAnsi().asWarningText(message));
	}

	@Override
	protected Optional<Long> getTimeout() {
	return testRuleTimeoutMs;
	}

	@Override
	protected int getExitCodeFromResult(ExecutionContext context, ProcessExecutor.Result result) {
	int exitCode = result.getExitCode();

	// If we timed out, force the exit code to 0 just so that the step itself doesn't fail,
	// allowing us to interpret any test cases that finished before the bad test. We signify
	// this special case by setting `hasTimedOut` which the result interpreter will query to
	// properly format its results.
	if (result.isTimedOut()) {
	exitCode = 0;
	hasTimedOut = true;
	}

	return exitCode;
	}

	public boolean hasTimedOut() {
	return hasTimedOut;
	}

	}