在调用@Before setup（）之后，如何反射地访问要运行的测试方法？

Question

We have lots of selenium tests running through junit, and they all have a few steps which need to run before the actual tests. For this we have a parent TestCase class which has some @Before and @After methods in it.

Now, due to a new feature of our site I would like to parameterise part of this set up, I'd like to create a new annotation to put on some tests to indicate to the setup() method that the setup is slightly different, whilst allowing the others to use the default. So, is it possible to reflectively access the test method about to be run in an @Before method?

eg.

class SomeTest extends MyTestCase {

  @Test
  @Flavour(Red.class)
  public void testRedFlavouredHomepage() {
    testHomepage();
  }

  @Test
  public void testBlueFlavouredHomepage() {  // assuming Blue is my default flavour
    testHomepage();
  } 

  public void testHomepage() {
    // test some stuff
  }
}

Answer 1

I'd rather suggest to use different test classes for those 2 methods.

class MyTestCase {

    @Before
    public void setUp() {
        /* Default setup */
    }

    public void testHomepage() {
        // test some stuff
    }

}

class MyRedTestCase extends MyTestCase {

    @Before
    public void setUp() {
        super.setUp();
        /* Red setup */
    }

}

And then you can put your tests into 2 different classes extending from MyTestCase and MyRedTestCase respectively.

class BlueTest extends MyTestCase {

    @Test
    public void testBlueFlavouredHomepage() {  // assuming Blue is my default flavour
        testHomepage();
    } 

}

class RedTest extends MyRedTestCase {

    @Test
    public void testRedFlavouredHomepage() {
        testHomepage();
    }

}

You can do it another way as well, without introducing new classes. Declare an absract (or concrete with the default value) method in your parent class.

class MyTestCase {

    protected abstract Flour getFlour();

}

And your child class will look like this

class SomeTest extends MyTestCase {

    private Flour flour;

    @Test
    public void testRedFlavouredHomepage() {
        flour = Flour.RED;
        testHomepage();
    }

    @Test
    public void testBlueFlavouredHomepage() {  // assuming Blue is my default flavour
        flour = Flour.BLUE;
        testHomepage();
    } 

    public void testHomepage() {
        // test some stuff
    }

    protected abstract Flour getFlour() {
        return flour;
    }

}

I'd say the 1st solution is "cleaner"; even though you have to create additional classes, you don't include logic of different types in one class (like in the anti-pattern God object ).

Answer 2

You can do this using @Rule (with the later versions of JUnit >= 4.9). If you have a class which implements TestRule , specifically apply(), you can do extra things before your test gets run. The Description is passed to the apply method, which contains the annotations on your method:

Using @Deprecated as an example:

public class ExtraSetupTest {
  @Rule
  public TestRule moreSetup = new TestRule() {
    public Statement apply(Statement base, Description description) {
      return statement(base, description);
    }

    private Statement statement(final Statement base,
        final Description description) {
      return new Statement() {
        @Override
        public void evaluate() throws Throwable {
          if (description.getAnnotation(Deprecated.class) != null) {
            System.out.println("more setup here");
          }
          base.evaluate();
        }
      };
    }
  };

  @Test
  public void noExtraSetup() {
    System.out.println("noExtraSetup");
  }

  @Test
  @Deprecated
  public void withExtraSetup() {
    System.out.println("withExtraSetup");
  }
}

This produces as output:

noExtraSetup
more setup here
withExtraSetup