@BeforeAll method in JUnit - Build an Automation Script

Verify @BeforeAll method runs once before all tests

Preconditions (2)

Step 1: Create a test class with a static method annotated with @BeforeAll

Step 2: In the @BeforeAll method, set a static boolean flag to true

Step 3: Create two test methods that assert the static boolean flag is true

Step 4: Run the test class

✅ Expected Result: The @BeforeAll method runs once before any test method, so both test methods pass asserting the flag is true

Automation Requirements - JUnit 5

Assertions Needed:

Assert that the static boolean flag is true in each test method

Best Practices:

Use static method for @BeforeAll

Use assertions from org.junit.jupiter.api.Assertions

Keep @BeforeAll method simple and fast

Automated Solution

JUnit

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class BeforeAllExampleTest {
    private static boolean isSetupDone = false;

    @BeforeAll
    public static void setup() {
        isSetupDone = true;
    }

    @Test
    public void testOne() {
        assertTrue(isSetupDone, "Setup should be done before testOne");
    }

    @Test
    public void testTwo() {
        assertTrue(isSetupDone, "Setup should be done before testTwo");
    }
}

The @BeforeAll method setup() is static and runs once before any test method in the class.

It sets the static boolean isSetupDone to true.

Each test method asserts that isSetupDone is true, confirming the @BeforeAll method ran before tests.

This shows how @BeforeAll prepares shared setup for all tests.

Common Mistakes - 3 Pitfalls

Making the @BeforeAll method non-static

Putting heavy or slow operations in @BeforeAll

Not using assertions to verify setup effects

Bonus Challenge

Now add a @BeforeAll method that initializes a shared resource (like a List) and verify it is not null in multiple tests

Show Hint

Practice

1. What is the main purpose of the @BeforeAll annotation in JUnit 5?

easy

A. To run a method once after all test methods

B. To run a method before each test method

C. To run a method after each test method

D. To run a method once before all test methods in the class

Solution

1. Step 1: Understand the role of @BeforeAll

   The @BeforeAll annotation marks a method to run once before any test methods in the class.

2. Step 2: Compare with other lifecycle annotations

   @BeforeEach runs before each test, @AfterEach runs after each test, and @AfterAll runs once after all tests.

3. Final Answer:

   To run a method once before all test methods in the class -> Option D

4. Quick Check:

   @BeforeAll = run once before all tests [OK]

Hint: Runs once before all tests, not before each [OK]

Common Mistakes:

• Confusing @BeforeAll with @BeforeEach
• Thinking it runs after tests
• Assuming it runs multiple times

2. Which of the following is the correct way to declare a @BeforeAll method in JUnit 5?

easy

A. public void setup() { ... }

B. private static void setup() { ... }

C. public static void setup() { ... }

D. void setup() { ... }

Solution

1. Step 1: Recall method requirements for @BeforeAll

   In JUnit 5, @BeforeAll methods must be static and public (or package-private) to run before all tests.

2. Step 2: Check each option's signature

   public void setup() { ... } is non-static, so invalid. private static void setup() { ... } is private, so invalid. void setup() { ... } is non-static and missing access modifier. public static void setup() { ... } is public static void, which is correct.

3. Final Answer:

   public static void setup() { ... } -> Option C

4. Quick Check:

   Static + public method = correct @BeforeAll signature [OK]

Hint: Must be static and public for @BeforeAll [OK]

Common Mistakes:

• Omitting static keyword
• Using private or protected access
• Missing void return type

3. Consider the following JUnit 5 test class snippet:

public class SampleTest {
    static int counter = 0;

    @BeforeAll
    public static void init() {
        counter = 5;
    }

    @Test
    public void testOne() {
        counter += 1;
        assertEquals(6, counter);
    }

    @Test
    public void testTwo() {
        counter += 2;
        assertEquals(7, counter);
    }
}

What will happen when these tests run?

medium

A. testOne passes, testTwo fails

B. Both tests pass

C. testOne fails, testTwo passes

D. Both tests fail

Solution

1. Step 1: Analyze @BeforeAll effect on counter

   The init() method sets counter = 5 once before all tests.

2. Step 2: Trace testOne execution

   testOne adds 1 to counter (5 + 1 = 6) and asserts 6, so it passes.

3. Step 3: Trace testTwo execution

   testTwo adds 2 to counter, but counter was modified by testOne and is now 6, so 6 + 2 = 8. It asserts 7, which fails.

4. Final Answer:

   testOne passes, testTwo fails -> Option A

5. Quick Check:

   Shared static state changes cause testTwo failure [OK]

Hint: Static state shared; second test sees changed value [OK]

Common Mistakes:

• Assuming counter resets before each test
• Ignoring static variable persistence
• Expecting both tests to pass

4. Given this JUnit 5 test class:

public class DemoTest {

    @BeforeAll
    public void setup() {
        System.out.println("Setup");
    }

    @Test
    public void testA() {
        assertTrue(true);
    }
}

What is the problem with this code?

medium

A. The @Test method must be static

B. The @BeforeAll method must be static

C. The @BeforeAll method cannot print output

D. The @BeforeAll method must return a value

Solution

1. Step 1: Check @BeforeAll method signature

   In JUnit 5, @BeforeAll methods must be static unless using a test instance lifecycle that allows non-static.

2. Step 2: Identify error in code

   The setup() method is non-static, which causes a runtime error or test failure.

3. Final Answer:

   The @BeforeAll method must be static -> Option B

4. Quick Check:

   @BeforeAll requires static method [OK]

Hint: Remember: @BeforeAll methods must be static [OK]

Common Mistakes:

• Making @BeforeAll method non-static
• Thinking @BeforeAll can return values
• Confusing @BeforeAll with @BeforeEach

5. You want to initialize a database connection once before all tests in a JUnit 5 test class. Which approach correctly uses @BeforeAll to achieve this, considering best practices?

hard

A. Use a static @BeforeAll method to open the connection and store it in a static variable

B. Use a non-static @BeforeAll method to open the connection

C. Open the connection inside each @Test method separately

D. Use @BeforeEach to open the connection before every test

Solution

1. Step 1: Understand @BeforeAll usage for shared setup

   @BeforeAll runs once before all tests, ideal for expensive setup like database connections.

2. Step 2: Apply static method and static variable for shared resource

   The method must be static, and the connection should be stored in a static variable to be accessible by all tests.

3. Step 3: Evaluate other options

   Use a non-static @BeforeAll method to open the connection is invalid because @BeforeAll must be static. Open the connection inside each @Test method separately and D open connection multiple times, which is inefficient.

4. Final Answer:

   Use a static @BeforeAll method to open the connection and store it in a static variable -> Option A

5. Quick Check:

   Static @BeforeAll + static resource = efficient shared setup [OK]

Hint: Static method + static variable for shared setup [OK]

Common Mistakes:

• Using non-static @BeforeAll method
• Opening connection multiple times unnecessarily
• Not storing connection in static variable