How does Junit @Rule work?

Question

I want to write test cases for a bulk of code, I would like to know details of JUnit @Rule annotation feature, so that I can use it for writing test cases. Please provide some good answers or links, which give detailed description of its functionality through a simple example.

Quirinal

i already gone through this link http://cwd.dhemery.com/2011/01/what-junit-rules-are-good-for/ – Quirinal

I found this article explains @Rules rather well, especially check out the last section "The Sequence Of Events In Detail" – Indecency

I think it is similar to the concept of injection, am I right? – Furfuran

Thanks for sharing that link. One thing is not clear. When does the DEFAULT Statement.evaluate() get called ? Is it called before the evaluate() of all rules or after all of them ? I am guessing after all of them. – Thomism

@testerjoe2 you may choose to ignore the default Statement completely. You may choose to delegate to it or you may simply replace it altogether with some other Statement of your own. It doesn't get called, you may call it or not. That was in point 10: "The screenshot statement’s evaluate() method calls the default statement’s evaluate() method." – Indecency

Answer 1

Rules are used to add additional functionality which applies to all tests within a test class, but in a more generic way.

For instance, ExternalResource executes code before and after a test method, without having to use @Before and @After. Using an ExternalResource rather than @Before and @After gives opportunities for better code reuse; the same rule can be used from two different test classes.

The design was based upon: Interceptors in JUnit

For more information see JUnit wiki : Rules.

Mertiemerton

Correction: "For instance, ExternalResource executes code before and after a test class." There's something about using apply() to get the ExternalResource to run between tests. – Blackguard

Reading this helped me to understand ExternalResource mentioned in the answer. – Recognition

Answer 2

Junit Rules work on the principle of AOP (aspect oriented programming). It intercepts the test method thus providing an opportunity to do some stuff before or after the execution of a particular test method.

Take the example of the below code:

public class JunitRuleTest {

  @Rule
  public TemporaryFolder tempFolder = new TemporaryFolder();

  @Test
  public void testRule() throws IOException {
    File newFolder = tempFolder.newFolder("Temp Folder");
    assertTrue(newFolder.exists());
  }
} 

Every time the above test method is executed, a temporary folder is created and it gets deleted after the execution of the method. This is an example of an out-of-box rule provided by Junit.

Similar behaviour can also be achieved by creating our own rules. Junit provides the TestRule interface, which can be implemented to create our own Junit Rule.

Here is a useful link for reference:

• http://www.codeaffine.com/2012/09/24/junit-rules/

Inexpressible

so it gets deleted without writing any code to delete/clear the object ? – Bingham

look at the source of github.com/junit-team/junit4/blob/master/src/main/java/org/… , the folder is created in the before() callback method and deleted in the after() callback method ... – Tetanic

For people who might have not understood why the TemporaryFolder gets deleted it is because it's a TemporaryFolder provided by Junit to serve as a temp folder that gets automatically deleted - i.e. the teardown step is part of the TemporaryFolder class itself. – Standing

Answer 3

The explanation for how it works:

JUnit wraps your test method in a Statement object so statement and Execute() runs your test. Then instead of calling statement.Execute() directly to run your test, JUnit passes the Statement to a TestRule with the @Rule annotation. The TestRule's "apply" function returns a new Statement given the Statement with your test. The new Statement's Execute() method can call the test Statement's execute method (or not, or call it multiple times), and do whatever it wants before and after.

Now, JUnit has a new Statement that does more than just run the test, and it can again pass that to any more rules before finally calling Execute.

Achilles

Statement has method evaluate not execute. – Swarth

Answer 4

Rules are used to enhance the behaviour of each test method in a generic way. Junit rule intercept the test method and allows us to do something before a test method starts execution and after a test method has been executed.

For example, Using @Timeout rule we can set the timeout for all the tests.

public class TestApp {
    @Rule
    public Timeout globalTimeout = new Timeout(20, TimeUnit.MILLISECONDS);

    ......
    ......

 }

@TemporaryFolder rule is used to create temporary folders, files. Every time the test method is executed, a temporary folder is created and it gets deleted after the execution of the method.

public class TempFolderTest {

 @Rule
 public TemporaryFolder tempFolder= new TemporaryFolder();

 @Test
 public void testTempFolder() throws IOException {
  File folder = tempFolder.newFolder("demos");
  File file = tempFolder.newFile("Hello.txt");

  assertEquals(folder.getName(), "demos");
  assertEquals(file.getName(), "Hello.txt");

 }


}

You can see examples of some in-built rules provided by junit at this link.

Atrabilious