Exploring JUnit

Here I am going to explore JUnit framework so that you can find the framework that fits your testing needs better. This blog will explore the capabilities and limitations of JUnit in detail. Let’s begin! 

JUnit-Overview

JUnit is a framework for Java programming language to perform unit testing. It plays an essential role in test-driven development and is a family of unit testing frameworks known as xUnit. JUnit is based on the idea of "Testing first, then coding." Meaning JUNIT focuses on setting up the test data for a block of code that can first be tested and then implemented. This approach is like a cycle of minor Testing and minor coding, which increases a developer's productivity and code stability. This approach dramatically reduces the debugging time required by a programmer. 

Features of JUnit

• It is an open-source framework for Java, used to write and run test cases.

• It identifies test methods by providing annotations.

• It gives assertions to test expected results.

• It runs tests by providing test runners.

• It allows developers to provide error-free quality code.

• It makes the code cleaner and run faster. 

• It is straightforward to use.

• It can run tests automatically and provide feedback for the intermediate result.

• It can provide the test progress in a progress bar that turns green if the test runs efficiently and red if the test fails.

Dependency for JUnit

Include the below snippet in your pom.xml file

Annotations in JUnit

The following are the JUnit Annotations:

• @Test: Informs JUnit about which public void method could run as a test case

• @Before: It is used to execute a statement before a test case

• @After: It is used to execute a statement after a test case

• @Ignores: It is used to ignore a statement during the execution process

• @BeforeClass: It is used to execute a statement before all the test cases

• @AfterClass: It is used to execute a statement after all the test cases

• @Test: It is used to set a timeout while executing a test case

Assertions in JUnit

Overall, the general process of unit testing is fairly simple. You’ll define inputs to explore selected paths in your software, and determine what output you expect to receive. If the expected value is returned, the test will pass, and you can go on coding. If it fails, you’ll need to fix your implementation to make sure your unit test passes.The test method isValidNegativeSide has the typical structure of first initializing the object under test t; declaring the expected result ‘expected’, calling the method under test, and finally using an assertion to ensure that the actual behavior matches the expected one.

• assertTrue(boolean condition)-Checks that a condition is true.

• assertEquals(boolean expected, boolean actual)-Checks that two primitives/objects are equal.

• assertFalse(boolean condition)-Checks that a condition is false.

• assertNotNull(Object object)-Checks that an object isn't null.

• assertNull(Object object)-Checks that an object is null.

• assertSame(object1, object2)-The assertSame() method tests if two object references point to the same object.

• assertNotSame(object1, object2)-The assertNotSame() method tests if two object references do not point to the same object.

• assertArrayEquals(expectedArray, resultArray);

• The assertArrayEquals() method will test whether two arrays are equal to each other.

Best practices for using TestNG in Selenium automation:

 1. Always test Core Methods

It's not practically possible to get 100% code coverage, so don't aim to write unit tests for each method and trivial operations, instead, write unit tests for a method that is likely to have bugs during maintenance. Always test core methods and core classes which are used heavily by different parts of a program. 

2. Run the JUnit test as part of the Build Process

You should Integrate Junit tests with your build script so that with every compile your tests run automatically. Maven and ANT, two most popular build technologies for Java applications, provide support to run Junit tests. This is not just a best practice but a standard of building Java applications. 

3. Always Test for boundary Conditions

Develop test cases based on usage and boundary conditions, This is my favorite Junit test practice and mostly asked as an interview question on JUnit as well.  For example, if you are asked to write a function to replace all occurrence of a given character from String e.g.

public String replace(String text, char ch){ …}

How will you write a test case for that? to my surprise, many Java program starts focusing on JUnit test syntax like setUp() and tearDown() even before thinking of actual test scenarios like :

1) Test for empty text or empty character?

2) Test for the character which is not in String?

3) Test for characters that come during start, end, or middle of String?

4) Test to cover if text String contains just one character which is equal or not equal to the replaced one?

5) Test with a String containing just one character multiple times?

These are just a few test cases I can think of but the idea is to focus on what to test and not how to test, most IDE like Eclipse and Netbeans will take care of that. Though you should have basic Ideas of the essential functionality of JUnit testing like how to test Exceptions, Timeout, etc.

4. Alight Test with Business Requirements 

Make sure your JUnit test is aligned with your business requirement specified in the BRD or Business Requirement document. 

5.  Tests for Non-Functional Requirements

Write a test for the non-functional requirement as well, while writing a Thread-safe class, it's important to write tests that try to break thread safety.

6.  Test for Ordering

If a function or method depends on upon the order of events then make sure your JUnit test covers ordering requirement and my take is to test both sides of the coin means with correct ordering method should produce a correct result and with incorrect ordering, it should throw Exception or confirms the alternative operation. Another JUnit best practice that is worth remembering.

7. Use @Ignore Annotation

One Idea which helps me while writing a unit test is to create dummy tests while working with requirements because that’s the best time you remember requirements and having a test case with a comment that describes the intent of test lets you to implement it later or just put @Ignore if you don’t have time to implement test and using Junit4 annotations. This helps me to cover most of the requirements while writing code as well as tests. This just enforces you to write as many test cases as defined by requirements.

8. Avoid testing simple getter methods

Writing trivial JUnit tests like for getter and setter methods is mostly a waste of time. remember that you don't have the liberty to write an infinite number of unit tests either in terms of your development time or while you are building your application. As unit tests run automatically during the build process, they are required to finish early and trivial unit tests just add on time and hide more useful cases to run later.

9.  Avoid dependence on Database and File System

Keep your Unit test independent of Environmental data like Database, File System, etc.  The unit test depends on environmental data that may work in some environments and may not work on others. It's a good idea to use a carefully chosen set of data embedded in test cases as well as a placeholder method that can be plugged to the database if required using configuration.

10. Use Tools

You should always use available tools like DBunit, XMLUnit, and Spring test framework based upon your project and your need.

Conclusion

This article also proves why JUnit is so important when it comes to automated testing.  I hope these JUnit and testing best practices will help you to write better code. I highly recommend you to follow the Test Driven Development because it results in better code and design.