Test Driven Development for Java using JUnit | Quick Guide

Introduction

Before we get started, let us understand some basics. Software testing plays an important role in the life cycle of software development. It is imperative to identify bugs and errors during software development and increase the quality of the product. Additionally we need software testing to ensure that the software fulfils the client specifications, responds correctly to inputs (input validation), runs in a reasonable time (performance testing), is easy to install and run (deployment testing), and meets the stakeholders' goals.

Therefore, one must focus on software testing. There are many approaches and TDD approach is one of them. It is a key practice for extreme programming, it suggests that the code is developed or changed exclusively based on the Unit Testing.

A key practice for extreme programming; it suggests that the code is developed or changed exclusively by the unit testing. Click to explore about, Test-Driven Development (TDD) Tools

What is Test Driven Development?

1. Firstly, add a test.
2. Run all the tests and see if any new test fails.
3. Update the code to make it pass the new tests.
4. Run the test again and if they fail then refactor again and repeat.

What is Behaviour Driven Development (BDD)?

• Explained the behaviour of the software/program.
• User friendly

The key practice for extreme programming, suggests that the code is developed or changed exclusively on the basis of the unit test results. Source - Test Driven and Behavior Driven Development

What is a Legacy Code?

What are the advantages?

1. It gives a way to think through our requirements or design before we write our functional code.
2. Enables us to take small steps during building software.
3. Makes us more productive in nature rather as compared attempting to code in large steps.

• The most efficient and attractive way to proceed in smaller and smaller steps.
• Following TDD means -
  • Fewer bugs
  • Higher quality software
  • Focus on single functionality at a given point in time

Why is Test Driven Development Important?

• Requirements - Drive out requirement issues early (more focus on requirements in depth).
• Rapid Feedback - Many small changes Vs One big change.
• Values Refactoring - Refactor often to lower impact and risk.
• Design to Test - Testing driving good design practice.
• Tests as information - Documenting decisions and assumptions.

Test Driven Development with Java

• Improving the code
• Side by side, increasing the programmer’s productivity.

• Will save our time which is getting wasted for rework.
• Able to identify the error/problem quicker and faster.
• The programmer will be able to write small classes which will be focused only on a single functionality instead of writing the big classes.

• Means we have automated tests
• We are writing the test cases for our program which is a safe side for the programmers.

API Testing in TDD

• Testing APIs (Application Programming Interfaces)
• To determine if the API created meets the expectations.
• End-to-end functionality (how an API technically works).
• Response time.
• Load Testing
• Only API functions are tested.

1. The output can contain status.
2. The output can contain any type of data or information.
3. Or an API can be calling another API.

• Unit testing (testing the API methods and checking if the output meets the expectations).
• Using many tools for checking the performance and load i.e how many requests can be handled by the API at the same time and many more. We can use Apache JMeter for performance and load testing.

Unit testing operates on a low level and is tightly coupled with source code. Click to explore about, Golang Unit Testing and Testing Best Practices

What are the best Test-Driven Development Tools for java?

JUnit for Unit Tests 

JMeter for Load/Performance Testing

Features of Apache JMeter -

1. Web - HTTP, HTTPS (Java, NodeJS, PHP, ASP.NET, …)
2. SOAP/REST Webservices
3. FTP
4. Database via JDBC
5. LDAP
6. Message-oriented middleware (MOM) via JMS
7. Mail - SMTP(S), POP3(S) and IMAP(S)
8. Native commands or shell scripts
9. TCP
10. Java Objects

Mockito for Rest API Testing

How to set up environment for Test Driven Development in Java?

The steps to set up environment for TDD in Java are listed below:

Setting up it with JUnit

• Install Java first.
• Then we need Eclipse or any other IDE(Integrated Development Environment).
• Create a new project (Maven project) and place the JUnit maven dependency in pom.xml file.

Setting up it with JMeter

• Install Java.
• Install Apache JMeter
  • For Ubuntu - $ Sudo apt-get install JMeter
  • For CentOS7 - Sudo yum install JMeter

Setting Up TDD with Mockito

• Install Java.
• Then we need Eclipse or any other IDE(Integrated Development Environment).
• Create a new project and download the mockito jar and include it in the project and if it is a maven project then add mockito dependency in pom.xml file for that particular project.

Database Unit testing can be performed in a web application or desktop because the database can be used in the application. Click to explore about, Database Unit Testing and Test-Driven Database Development

How to implementing Java Test Driven Development?

The steps to implement Java TDD are described below:

Naming the test class

Packages for production code

We don’t use the same package for production code and testing code. The best practice is to use different source directories, “src/main/java” for production and “src/test/java” for testing. 3. Structure and Annotation - @Test annotation (JUnit4/5) tells JUnit to execute the testDisplayStudentAddress() method as a test method and report whether it passes or fails. As long as all assertions (if any) pass and no exceptions are thrown, the test is considered to pass. So our test code should follow AAA (Arrange Act Assert) pattern.

• • Create student object that will be tested (arrange) - Student student = new Student("Joe", "Brian");
  • Exercise the production code’s Student.getdisplayStudentName() method(act) - String displayName = student.getdisplayStudentName();
  • Verify if the result is as expected (assert) - assertEquals("Joe, Brian", displayName); If the result did not match, the test would be marked as failed.

Unit Testing With JUnit

• Production Code

public class Student {
 public String displayStudentName(String firstName, String lastName) {
  return firstName + lastName;
 }
}

• Testing Code

Import org.junit.Test;
Import static org.junit.Assert.*;
Public class StudentTest {
 @Test
 Public void testDisplayStudentName() {
  Student student = new Student();
  String studentName = student.displayStudentName(“Anshuman”, ”Nain”);
  assertEquals(“AnshumanNain”, studentName);
 }
}

Now build the project and run

Unit Testing With JMeter

• First of all, we need to add an HTTP Request Sampler inside a thread group (Test Plan -> Thread Group -> Sampler->HTTP Request)

• Next, we need to enter the Server Name or IP of the API and its port (if required) in the web server section.

• The user also needs to add HTTP Header Manager as a child to the HTTP Request sampler (for the current example this is not required) with the content-type header.

• At last, we add different listeners like 'Summary Report' to conclude.

Then finally run the test. In the above example, we hit 1000 requests per sec, out of which 992 were successful.

Unit Testing With Mockito

Basic Simple Demo code for using mockito with JUnit -

• Production Code

public class TestService {
 public int getUniqueId() {
  return 43;
 }
}

• Testing Code

public class JUnitServiceTestExample {

 @Test
 public void testGetInt() {
  // create mock
  TestService test = Mockito.mock(TestService.class);

  // define return value for method getUniqueId()
  when(test.getUniqueId()).thenReturn(43);

  // use mock in test....
  assertEquals(test.getUniqueId(), 43);
 }
}

Conclusion

How Can XenonStack Help You?

Application Modernization

Java Cloud Services

Continuous Integration and Continuous Deployment

Microservices Architecture

Take a cloud-native approach to building Enterprise Applications for Web and Mobile with a Microservices Architecture. An Application based on Microservices Architecture is Small, Messaging–enabled, Bounded by contexts, Autonomously developed, Independently deployable, Decentralized, Language–agnostic, Built and released with automated processes.

• Discover more about Reactive Programming Solutions
• Read More about System Testing Types, Best Practices and Tools