How to Write JUnit Test Cases: Step-by-Step Guide

Why Use JUnit to Automate Unit Tests?

JUnit is a widely used framework for automating unit tests in Java due to the following key reasons:

• Simplifies Testing: Makes it easy to write, run, and manage tests for individual components.
• Annotations for Structure: Offers annotations like @Test and @BeforeEach to help organize tests and handle setup or teardown tasks.
• Integration-Friendly: Works seamlessly with build tools like Maven, Gradle, and CI/CD pipelines, ensuring tests are automated and consistent.

Note: Automate JUnit tests with Selenium on the cloud. Try TestMu AI Now!

How to Write JUnit Test Cases on the Cloud?

To achieve maximum browser and OS coverage, running JUnit test cases over the cloud ensures access to a wide range of environments and also speeds up execution with parallel testing and eliminates infrastructure setup overhead.

For example, running JUnit test cases over the cloud, like on TestMu AI, provides effortless access to multiple web browsers online for comprehensive cross-browser and platform testing.

TestMu AI is an AI-powered test execution that offers automation testing with JUnit. It also boosts efficiency with parallel execution, reducing time and effort.

We will be performing the basic level unit test of the login page by logging in with valid credentials on the TestMu AI eCommerce Playground website.

Test Scenario:

• Navigate to the Login page of the TestMu AI eCommerce Playground website.
• Enter a valid username and password in the respective fields.
• Click on the Login button.
• Check that the page header “My Account” is displayed after successful login.

Test Implementation:

A new LoginTest class is created in the existing project to validate this test scenario. The setup() method will run before any of the tests execute and will help in setting up the RemoteWebDriver session on the TestMu AI cloud grid.

@BeforeAll
public static void setup () {
   final String userName = System.getenv ("LT_USERNAME") == null ? "LT_USERNAME" : System.getenv ("LT_USERNAME");
   final String accessKey = System.getenv ("LT_ACCESS_KEY") == null
                            ? "LT_ACCESS_KEY"
                            : System.getenv ("LT_ACCESS_KEY");
   final String gridUrl = "@hub.lambdatest.com/wd/hub";
   try {
       driver = new RemoteWebDriver (new URL ("http://" + userName + ":" + accessKey + gridUrl),
           getChromeOptions ());
   } catch (final MalformedURLException e) {
       System.out.println ("Could not start the remote session on LambdaTest cloud grid");
   }
   driver.manage ()
       .timeouts ()
       .pageLoadTimeout (Duration.ofSeconds (10));
}

The TestMu AI Username and Access Key are mandatorily required to run the tests on the TestMu AI cloud grid. Similarly, the gridURL allows connecting to the remote session on the cloud.

The getChromeOptions() method provides the necessary capabilities like browser name, browser version, and other capabilities like selenium version, build name, test name, plugin, etc.

public static ChromeOptions getChromeOptions () {
   final ChromeOptions browserOptions = new ChromeOptions ();
   browserOptions.setPlatformName ("Windows 10");
   browserOptions.setBrowserVersion ("130.0");
   final HashMap<String, Object> ltOptions = new HashMap<String, Object> ();
   ltOptions.put ("project", "LambdaTest E-Commerce Playground");
   ltOptions.put ("build", "LambdaTest E-Commerce Login page");
   ltOptions.put ("name", "Unit Test for Login Page");
   ltOptions.put ("selenium_version", "4.0.0")
   ltOptions.put ("w3c", true);
   ltOptions.put ("plugin", "java-testNG");

   browserOptions.setCapability ("LT:Options", ltOptions);

   return browserOptions;
}

These capabilities can be set using the Automation Capabilities Generator which allows users to set the capabilities using UI and generates the required code that could be used directly in the test scripts.

The tearDown() method that has the @AfterAll annotation, will be called after all the tests are executed. It will gracefully close the RemoteWebDriver session on the TestMu AI cloud.

The testLoginFunction() method will implement the test scenario. It will first navigate to the TestMu AI eCommerce Playground website, locate the WebElement for the Email-Address field and enter the valid email ID – [email protected] in the respective field.

@Test
public void testLoginFunction () {
   driver.get ("https://ecommerce-playground.lambdatest.io/index.php?route=account/login");

   WebElement emailAddressField = driver.findElement (By.id ("input-email"));
   emailAddressField.sendKeys ("[email protected]");

   WebElement passwordField = driver.findElement (By.id ("input-password"));
   passwordField.sendKeys ("Password123");

   WebElement loginBtn = driver.findElement (By.cssSelector ("input.btn"));
   loginBtn.click ();

   String myAccountHeader = driver.findElement (By.cssSelector ("#content h2"))
       .getText ();
   assertEquals (myAccountHeader, "My Account");

}

Next, it will locate the Password field and enter the valid password – Password123 in the respective field. It will locate the Login button and then click on it to perform the login operation.

After logging in, it will locate the page header and assert that its text equals “My Account”.

Test Execution:

The following screenshot of the test execution shows the test execution was successful on the TestMu AI cloud grid. The TestMu AI Web Automation dashboard shows insightful test execution details, including screenshots and video recordings of the test.

It also displays the step by step test execution details that can help the testing team analyze the test execution briefly.

Once you understand how to write JUnit test cases on the cloud, leveraging cloud platforms for scalability and parallel execution, it’s important to know how cloud testing integrates with different versions of JUnit.

Before we compare JUnit 4 and JUnit 5, here’s a quick video tutorial that walks you through executing JUnit 5 test scripts step-by-step.

JUnit 4 vs JUnit 5 – A Comparison

With the release of the latest version of JUnit, i.e. JUnit 5, there are multiple changes and new features added to the framework. The differences between the two versions JUnit 4 and JUnit 5 are listed below:

JUnit 5 improves upon JUnit 4 by introducing a more flexible and modular structure, making it easier to manage and execute tests. One key enhancement is the introduction of more specific annotations for test lifecycle management. Let’s look at some of these annotations in JUnit 5.

Basic Annotations Used in JUnit 5

Following are some basic annotations that you can use while writing JUnit 5 tests:

• @BeforeAll: The @BeforeAll annotation indicates that the annotated method should be executed before any @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory methods in the current class. It must be a static method in the test class. @BeforeAll serves as the replacement for the @BeforeClass annotation used in JUnit 4.

  Syntax:

public class BasicTest {

   @BeforeAll
   public static void beforeAllTest() {

       System.out.println("Before All method called!!");
   }

//..
}

• @BeforeEach: The @BeforeEach annotation indicates that the annotated method should be executed before each invocation of @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory methods in the current class. It is part of the test lifecycle methods and replaces the @Before annotation used in JUnit 4.

  Syntax:

public class BasicTest {

   @BeforeEach
   public void beforeEachTest() {
       System.out.println("Before Each method called!!");
   }

}

• @AfterAll: The @AfterAll annotation indicates that the annotated method should be called after all the tests in the current class have been executed. It must be a static method and is used as a tear down method in the test class. The @AfterAll annotation is the replacement of @AfterClass annotation in JUnit 4.

  Syntax:

public class BasicTest {

@AfterAll
public static void afterAllMethod() {
   System.out.println("After All method called!!");
   }
}

• @AfterEach: The @AfterEach annotation indicates that the annotated method should be executed after each @Test, @RepeatedTest, @ParameterizedTest, or @TestFactory method in the current class. It serves as the JUnit 5 replacement for the @After annotation used in JUnit 4.

  Syntax:

public class BasicTest {

@AfterEach
public void afterEachMethod() {
   System.out.println("After Each method called!!");
   }
}

• @Test: The @Test annotation indicates that the annotated method is a test method. The test method must not be a private or static method and must not return a value.

  Syntax:

public class BasicTest {

@Test
public void testMethod() {
   System.out.println("Test Method Called!!");
  }
}

• @DisplayName: The @DisplayName annotation is used to specify a custom name for the annotated test class or method. These custom names can include spaces, special characters and even emojis and are typically utilized in the test reports generated by IDEs and build tools.

  Syntax:

@DisplayName("Demo Test class")
public class BasicTest {

@DisplayName("This is a demo test")
@Test
public void testMethod() {
   System.out.println("Test Method Called!!");
   }
}

• @Disabled: The @Disabled annotation in JUnit is used for excluding the test method or test class from the test suite for execution. When applied to a test class, all the methods inside the test class are automatically considered as disabled. This annotation has an optional parameter that allows to specify the reason for disabling the test.

  Syntax:

public class BasicTest {

@Disabled("Test method disabled")
public void testMethod() {
   System.out.println("Test Method Called!!");
 }
}

Best Practices to Write JUnit Test Cases

Here are five best practices to follow when writing JUnit test cases:

• Write Clear and Descriptive Test Names: Use meaningful names that explain what the test is checking. For example, use the shouldReturnTrueWhenInputIsValid() method instead of something generic like the testValidation() method. It makes it easier to understand the purpose of the test at a glance.
• Follow the Arrange-Act-Assert (AAA) Pattern: Structure your tests into three clear sections:
• Test One Thing at a Time: Ensure each test case focuses on a single behavior or scenario. It simplifies debugging when a test fails and helps maintain clarity.
• Use Assertions: Use appropriate assertion methods (assertEquals, assertThrows, etc.) to validate outcomes effectively. Avoid excessive assertions in a single test, as it can make identifying issues harder.
• Keep Tests Independent: Avoid dependencies between tests. Each test should run in isolation and not rely on the results or state of another test. Use setup (@BeforeEach) and teardown (@AfterEach) methods to initialize or clean up as needed.

Conclusion

JUnit simplifies writing and executing unit test cases, making it a favorite among developers and testers for unit testing. It provides powerful features to validate code functionality and ensure reliability. With its rich set of annotations and methods for assertions and verifications, JUnit allows you to create precise and well-structured test cases with ease.

Beyond just running tests, JUnit offers detailed test reports that help demonstrate execution results and showcase test coverage to stakeholders.

Citations

Best Practices to Write JUnit Test Cases

Conclusion

Citations

• JUnit 5 User Guide: https://junit.org/junit5/docs/current/user-guide/
• Writing Tests with JUnit 5: https://blog.jetbrains.com/idea/2020/09/writing-tests-with-junit-5/