Better Parsing of Bazel Test Filter for JUnit5

BazelJunit5FilterParser.java

static List<String> parseOptions(String testBridgeTestOnly) {
  // transform env.TESTBRIDGE_TEST_ONLY

  List<String> methodNames = new ArrayList<>();
  List<String> classNames = new ArrayList<>();
  List<String> packageNames = new ArrayList<>();

  ArrayList<String> tests = new ArrayList<>();

  // Tests are separated by | But so are methods so we can't blindly split on the | character.
  // So what we need to do is detect that if we see a | that's preceded by a # or $ then we can
  // split it into separate tests
  StringTokenizer tokenizer = new StringTokenizer(testBridgeTestOnly, "#$|", true);
  String currentTest = "";
  boolean nextTokenMayBeSplit = false;
  while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();
    if (nextTokenMayBeSplit && token.equals("|")) {
      tests.add(currentTest);
      currentTest = "";
    } else {
      currentTest += token;
    }

    nextTokenMayBeSplit = token.equals("#") || token.equals("$");
  }
  if (!currentTest.isEmpty()) {
    tests.add(currentTest);
  }

  for(String test : tests) {
    String[] parts = test.split("#");

    if (parts.length > 2) {
      throw new IllegalStateException("Unexpected test with more than 1 '#' character");


    // Class, i.e. com.MyTest#
    } else if (test.endsWith("#")) {
      classNames.add(JUnit5ReflectionUtils.parseClassNameWithNestedSupport(parts[0]).getName());

    // Parsing a class with a method, i.e. com.MyTest#validateFrontEndHostPath$
    } else if (parts.length == 2) {
      Class<?> klass = JUnit5ReflectionUtils.parseClassNameWithNestedSupport(parts[0]);
      List<String> parsedMethodNames = getMethodNames(parts[1]);

      Map<String, Method> methodsByName = Stream.of(klass.getDeclaredMethods())
          .collect(Collectors.toUnmodifiableMap(Method::getName, Function.identity()));

      // In the case of a test with an argument (i.e. parameterized tests), the test filter from
      // intellij doesn't provide us with the argument name. So given something like:
      //
      //    com.squareup.MyClass#myParameterizedMethod
      //
      // where it has a boolean argument, we need to adjust the actual method sent to JUnit as:
      //
      //    com.squareup.MyClass#myParameterizedMethod(boolean)
      //
      // Hence why we reference the list of declared methods on the Class object
      parsedMethodNames.forEach(methodName -> {
        Method method = methodsByName.get(methodName);
        Preconditions.checkState(
            method != null,
            "Class '%s' does not have method '%s' defined",
            klass.getName(), methodName);
        methodNames.add(ReflectionUtils.getFullyQualifiedMethodName(klass, method));
      });

    // Package, i.e. com.my.package
    } else {
      packageNames.add(parts[0]);
    }
  }

  List<String> parsedOptions = new ArrayList<>();

  methodNames.forEach(method -> parsedOptions.add(SELECT_METHOD + "=" + method));
  classNames.forEach(className -> parsedOptions.add(SELECT_CLASS + "=" + className));
  packageNames.forEach(packageName -> parsedOptions.add(SELECT_PACKAGE + "=" + packageName));

  return parsedOptions;
}

BazelJunit5FilterParserTest.java

@Test
public void testParseOptions() {
  // Examples from https://github.com/bazelbuild/rules_scala/issues/212#issuecomment-305878010
  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest#"))
      .containsExactly("--select-class=com.squareup.bazel.junit.faketests.FakeTest");

  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest#testTrue$"))
      .containsExactly("--select-method=com.squareup.bazel.junit.faketests.FakeTest#testTrue()");

  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest#(testTrue|testAddition)$"))
      .containsExactly(
        "--select-method=com.squareup.bazel.junit.faketests.FakeTest#testTrue()",
        "--select-method=com.squareup.bazel.junit.faketests.FakeTest#testAddition()");

  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest#|com.squareup.bazel.junit.faketests.FakeSecondTest#"))
      .containsExactly(
        "--select-class=com.squareup.bazel.junit.faketests.FakeTest",
        "--select-class=com.squareup.bazel.junit.faketests.FakeSecondTest");

  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest#(testTrue,testAddition)$|com.squareup.bazel.junit.faketests.FakeSecondTest#testTrue$"))
      .containsExactly(
          "--select-method=com.squareup.bazel.junit.faketests.FakeTest#testTrue()",
          "--select-method=com.squareup.bazel.junit.faketests.FakeTest#testAddition()",
          "--select-method=com.squareup.bazel.junit.faketests.FakeSecondTest#testTrue()");

  // Other examples

  // Package
  assertThat(parseOptions("com.squareup.bazel.junit.faketests"))
      .containsExactly("--select-package=com.squareup.bazel.junit.faketests");

  // Running an entire class which has nested tests. Note that the options doesn't have the subclass
  // separated by an $, which we need to detect and adjust
  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest#|com.squareup.bazel.junit.faketests.FakeTest.MyNested#"))
      .containsExactly(
          "--select-class=com.squareup.bazel.junit.faketests.FakeTest",
          "--select-class=com.squareup.bazel.junit.faketests.FakeTest$MyNested");

  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest.MyNested#"))
      .containsExactly("--select-class=com.squareup.bazel.junit.faketests.FakeTest$MyNested");

  // Parameterized test
  assertThat(parseOptions("com.squareup.bazel.junit.faketests.FakeTest#testParameterized$"))
      .containsExactly("--select-method=com.squareup.bazel.junit.faketests.FakeTest#testParameterized(boolean)");
}

JUnit5ReflectionUtils.java

import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ListMultimap;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Stream;
import org.junit.platform.commons.util.ReflectionUtils;

class JUnit5ReflectionUtils {
  private JUnit5ReflectionUtils() { }

  /**
   * Tries parsing class names that could be nested. For example, given the properly named class:
   *
   *    com.my.SomeClass$MyNested
   *
   * intellij reports it as:
   *
   *   com.my.SomeClass.MyNested
   *
   * Useful for @Nested support
   */
  static Class<?> parseClassNameWithNestedSupport(String className) {
    return tryParseClassNameWithNestedSupport(className)
        .orElseThrow(() -> new IllegalStateException("Could not find test class " + className));
  }

  static Optional<Class<?>> tryParseClassNameWithNestedSupport(String className) {
    int guessCount = 0;
    String guess = className;
    do {
      try {
        return Optional.of(Class.forName(guess));
      } catch (ClassNotFoundException e) {
        // continue guessing
      }

      guessCount++;

      if (guessCount >= 10) {
        break;
      }

      guess = StringUtils.replaceLast(".", "$", guess);
    } while (guess.contains("."));
    return Optional.empty();
  }

  static Optional<Class<?>> tryParseClass(String className) {
    try {
      return Optional.of(Class.forName(className));
    } catch (ClassNotFoundException e) {
      return Optional.empty();
    }
  }

  static boolean isPackage(String maybePackage) {
    return Package.getPackage(maybePackage) != null;
  }

  // Parses a Kotlin test filter, and attempts to get the class it belongs to, and any methods selected.
  //
  // Cases:
  //
  // A: Selecting a class:    com.myorg.bazel.junit.kotlin.faketests.FakeTest
  // B: a nested class:       com.myorg.bazel.junit.kotlin.faketests.FakeTest.MyNested
  // C: a method:             com.myorg.bazel.junit.kotlin.faketests.FakeTest.testTrue
  //
  // For scenarios A & B, this simply re-uses tryParseClassNameWithNestedSupport() directly.
  // For scenario C, we assume that methods can't have a . in them, so we will try assuming
  // that "com.myorg.bazel.junit.kotlin.faketests.FakeTest" is the class name, and assume "testTrue"
  // is the method name.
  static Optional<Pair<Class<?>, List<String>>> parseKotlin(String filter) {
    Optional<Pair<Class<?>, List<String>>> classPair = tryParseClassNameWithNestedSupport(filter)
        .map(klass -> new Pair<>(klass, ImmutableList.of()));

    if (classPair.isPresent()) {
      return classPair;
    }

    String methodName = StringUtils.lastSplit(filter, "\\.");
    String filterWithoutMethod = StringUtils.replaceLast("." + methodName, "", filter);

    return tryParseClassNameWithNestedSupport(filterWithoutMethod).map(aKlass -> {
      List<String> fullyQualifiedMethods = getFullyQualifiedMethods(aKlass, ImmutableList.of(methodName));
      return new Pair<>(aKlass, fullyQualifiedMethods);
    });
  }

  static List<String> getFullyQualifiedMethods(Class<?> klass, List<String> methodNames) {
    ListMultimap<String, Method> methodsByName = Stream.of(klass.getDeclaredMethods())
        .collect(ImmutableListMultimap.toImmutableListMultimap(Method::getName, Function.identity()));

    // In the case of a test with an argument (i.e. parameterized tests), the test filter from
    // intellij doesn't provide us with the argument name. So given something like:
    //
    //    com.myorg.MyClass#myParameterizedMethod
    //
    // where it has a boolean argument, we need to adjust the actual method sent to JUnit as:
    //
    //    com.myorg.MyClass#myParameterizedMethod(boolean)
    //
    // Hence why we reference the list of declared methods on the Class object
    return methodNames.stream()
        .flatMap(methodName -> {
          List<Method> methods = methodsByName.get(methodName);

          Preconditions.checkState(
              !methods.isEmpty(),
              "Class '%s' does not have method '%s' defined",
              klass.getName(), methodName);

          if (methods.size() > 1) {
            System.err.printf(
                "More than one test method named '%s' exists on class '%s' -- %d methods will be run in no particular order\n",
                methodName,
                klass.getName(),
                methods.size());
          }

          return methods.stream();
        })
        .map(method -> {
          return ReflectionUtils.getFullyQualifiedMethodName(klass, method);
        })
        .collect(ImmutableList.toImmutableList());
  }
}

Pair.java

class Pair<L,R> {
  final L left;
  final R right;

  Pair(L left, R right) {
    this.left = left;
    this.right = right;
  }
}

Note for these test cases to work, you need to reference actual files that exist

Modified from junit-team/junit5-samples#133

Note that this also uses a List to preserve ordering, versus a HashSet

where can i find the class JUnit5ReflectionUtils ?

@birdayz whoops, I added it here. Note this makes heavy use of the Guava library