Alexey Zvolinskiy

About Alexey Zvolinskiy

Alexey is a test developer with solid experience in automation of web-applications using Java, TestNG and Selenium. He is so much into QA that even after work he provides training courses for junior QA engineers.

JUnit and EasyMock cooperation

Developers always need to take care about code which they produced. They should be ensured that code works properly after a new feature was implemented or some bug was fixed. That’s can be achieved at least with the help of unit tests. Since this blog is dedicated to Java programming language, today I will write the article about JUnit 4.1 and EasyMock 3.1 frameworks. The main purpose of these frameworks is to make writing of unit tests easier.

Introduction

For the demonstration of JUnit and EasyMock capabilities I need to have some code which I’m going to cover with tests. So at the start I’m going to introduce you a simple
 
application which I have developed for this tutorial. It should be very familiar for Java developers, because it emulates work of a coffee machine. Now I will describe in a few words functionality of the application. Coffee machine has two containers: for the water and for the coffee. You can make three varieties of coffee depends on portion size (small, medium, large).

  • Positive scenario: you make a portion of coffee and containers have enough water and coffee beans.
  • Negative scenario: you make a portion of coffee and containers haven’t enough water or coffee beans.

If any container isn’t complete enough you can refill it. After the concise description of application’s functionality you can easily imagine how it should work. It’s time to provide code samples of classes.

Application code

Now try to be more patient and attentive. You will see a plenty of classes below, which I’m going to test in the next paragraph. As was mentioned above, coffee machine can produce three types of coffee depends on portion size you want to get. Portions in the application will be represented as an enumeration.

public enum Portion {
	SMALL(1), MEDIUM(2), LARGE(3);

	private int size;

	private Portion(int size) {
		this.size = size;
	}

	public int size() {
		return size;
	}
}

Our coffee machine has two containers, that’s mean we need to build logical architecture for them. Let’s adhere to smart coding approaches based on interfaces.

public interface IContainer {

	public boolean getPortion(Portion portion) throws NotEnoughException;
	public int getCurrentVolume();
	public int getTotalVolume();
	public void refillContainer();

}

In order to avoid a code dublication I need to develop an abstract class for the container. In context of this programming approach I want to bethink one of my posts about Abstract class VS Interface.

public abstract class AbstractContainer implements IContainer {

	private int containerTotalVolume;
	private int currentVolume;

	public AbstractContainer(int volume) {
		if (volume < 1)
			throw new IllegalArgumentException('Container's value must be greater then 0.');
		containerTotalVolume = volume;
		currentVolume = volume;
	}

	@Override
	public boolean getPortion(Portion portion) throws NotEnoughException {
		int delta = currentVolume - portion.size();
		if (delta > -1) {
			currentVolume -= portion.size();
			return true;
		} else
			throw new NotEnoughException('Refill the '
					+ this.getClass().getName());
	}

	@Override
	public int getCurrentVolume() {
		return currentVolume;
	}

	@Override
	public int getTotalVolume() {
		return containerTotalVolume;
	}

	@Override
	public void refillContainer() {
		currentVolume = containerTotalVolume;
	}

}

Methods in the Abstract Container are self explained, so there is no need to stop on them more detail. You probably noticed NotEnoughException, don’t worry, it’s nothing special, just custom specific exception for the application.

public class NotEnoughException extends Exception {

	public NotEnoughException(String text) {
		super(text);
	}

}

After development of container interface and abstract class were completed, we can proceed with concrete container realisation.

public class CoffeeContainer extends AbstractContainer {

	public CoffeeContainer(int volume) {
		super(volume);
	}

}

The same class will be for the water container:

public class WaterContainer extends AbstractContainer {

	public WaterContainer(int volume) {
		super(volume);
	}

}

Now we have all required stuff to develop code related to the coffee machine. As previously, I will start from interface development.

public interface ICoffeeMachine {

	public boolean makeCoffee(Portion portion) throws NotEnoughException;
	public IContainer getCoffeeContainer();
	public IContainer getWaterContainer();

}

And finally here is a realisation of coffee machine:

public class CoffeeMachine implements ICoffeeMachine {

	private IContainer coffeeContainer;
	private IContainer waterContainer;

	public CoffeeMachine(IContainer cContainer, IContainer wContainer) {
		coffeeContainer = cContainer;
		waterContainer = wContainer;
	}

	@Override
	public boolean makeCoffee(Portion portion) throws NotEnoughException {

		boolean isEnoughCoffee = coffeeContainer.getPortion(portion);
		boolean isEnoughWater = waterContainer.getPortion(portion);

		if (isEnoughCoffee && isEnoughWater) {
			return true;
		} else {
			return false;
		}
	}

	@Override
	public IContainer getWaterContainer() {
		return waterContainer;
	}

	@Override
	public IContainer getCoffeeContainer() {
		return coffeeContainer;
	}

}

That’s it, what relates to the program which I’m going to test with the help of unit tests.

JUnit testing

Before I start a JUnit tests development, I want to repeat canonical aims of unit tests. An unit test checks the smallest part of functionality – method or a class. This circumstance imposes some logical restrictions on a development. That’s mean that you don’t need to put some extra logic in a method, because after this it becomes more difficult for a testing. And one more important thing – unit testing implies an isolation of functionality from other parts of application. We don’t need to check functionality of a method “A” while we are working with a method “B”. So let’s stat to write JUnit tests for the coffee machine application. For this purpose we need to add some dependencies to the pom.xml

...
		<dependency>
			<groupid>org.easymock</groupid>
			<artifactid>easymock</artifactid>
			<version>3.1</version>
		</dependency>
		<dependency>
			<groupid>junit</groupid>
			<artifactid>junit</artifactid>
			<version>4.11</version>
		</dependency>
...

I have choosen AbstractContainer class for the demonstration of JUnit tests. Because in context of the application we have two realisations of this class and if we will write tests for it, automaticaly we will test WaterContainer class and CoffeeContainer class.

import static org.junit.Assert.assertEquals;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.app.data.Portion;
import com.app.exceptions.NotEnoughException;
import com.app.mechanism.WaterContainer;
import com.app.mechanism.interfaces.IContainer;

public class AbstractContainerTest {

	IContainer waterContainer;
	private final static int VOLUME = 10;

	@Before
	public void beforeTest() {
		waterContainer = new WaterContainer(VOLUME);
	}

	@After
	public void afterTest() {
		waterContainer = null;
	}

	@Test(expected = IllegalArgumentException.class)
	public void testAbstractContainer() {
		waterContainer = new WaterContainer(0);
	}

	@Test
	public void testGetPortion() throws NotEnoughException {
		int expCurVolume = VOLUME;

		waterContainer.getPortion(Portion.SMALL);
		expCurVolume -= Portion.SMALL.size();
		assertEquals('Calculation for the SMALL portion is incorrect',
				expCurVolume, waterContainer.getCurrentVolume());

		waterContainer.getPortion(Portion.MEDIUM);
		expCurVolume -= Portion.MEDIUM.size();
		assertEquals('Calculation for the MEDIUM portion is incorrect',
				expCurVolume, waterContainer.getCurrentVolume());

		waterContainer.getPortion(Portion.LARGE);
		expCurVolume -= Portion.LARGE.size();
		assertEquals('Calculation for the LARGE portion is incorrect',
				expCurVolume, waterContainer.getCurrentVolume());

	}

	@Test(expected = NotEnoughException.class)
	public void testNotEnoughException() throws NotEnoughException {
		waterContainer.getPortion(Portion.LARGE);
		waterContainer.getPortion(Portion.LARGE);
		waterContainer.getPortion(Portion.LARGE);
		waterContainer.getPortion(Portion.LARGE);
	}

	@Test
	public void testGetCurrentVolume() {
		assertEquals('Current volume has incorrect value.', VOLUME,
				waterContainer.getCurrentVolume());
	}

	@Test
	public void testGetTotalVolume() {
		assertEquals('Total volume has incorrect value.', VOLUME,
				waterContainer.getTotalVolume());
	}

	@Test
	public void testRefillContainer() throws NotEnoughException {
		waterContainer.getPortion(Portion.SMALL);
		waterContainer.refillContainer();
		assertEquals('Refill functionality works incorectly.', VOLUME,
				waterContainer.getCurrentVolume());
	}

}

I need to explain, for what all of annotations are used. But I’m to lazy for this and I just give you a link to the JUnit API. There you can read the most correct explanations. Notice common things for all tests – they are all marked with @Test annotation, it indicates that a following method is a test, and every test ends with some of “assert” methods. Assertions are an essential part for each test, because all manipulations in a test should be checked in the end of it.

JUnit with EasyMock testing

Ok, in the previous paragraph I show you the example of sveral simple JUnit tests. In that example tests doesn’t colaborate with any other classes. What if we need to involve some extra class in a JUnit test? I mentioned above that unit tests should be isolated from a rest application’s functionality. For this purpose you can use EasyMock testing framework. With the help of EasyMock you can crate mocks. Mocks are objects which emulates behaviour of real concrete object, but with the one big plus, you can specify state for the mock, and in this way you obtain that state for the fake object which you need in particular moment of unit test.

import static org.junit.Assert.*;

import org.easymock.EasyMock;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class CoffeeMachineTest {

	ICoffeeMachine coffeeMachine;
	IContainer coffeeContainer;
	IContainer waterContainer;

	@Before
	public void setUp() {
		coffeeContainer = EasyMock.createMock(CoffeeContainer.class);
		waterContainer = EasyMock.createMock(WaterContainer.class);
		coffeeMachine = new CoffeeMachine(coffeeContainer, waterContainer);
	}

	@After
	public void tearDown() {
		coffeeContainer = null;
		waterContainer = null;
		coffeeMachine = null;		
	}

	@Test
	public void testMakeCoffe() throws NotEnoughException {
		EasyMock.expect(coffeeContainer.getPortion(Portion.LARGE)).andReturn(true);
		EasyMock.replay(coffeeContainer);

		EasyMock.expect(waterContainer.getPortion(Portion.LARGE)).andReturn(true);
		EasyMock.replay(waterContainer);

		assertTrue(coffeeMachine.makeCoffee(Portion.LARGE));
	}

	@Test
	public void testNotEnoughException() throws NotEnoughException {
		EasyMock.expect(coffeeContainer.getPortion(Portion.LARGE)).andReturn(false);
		EasyMock.replay(coffeeContainer);

		EasyMock.expect(waterContainer.getPortion(Portion.LARGE)).andReturn(true);
		EasyMock.replay(waterContainer);

		assertFalse(coffeeMachine.makeCoffee(Portion.LARGE));
	}

}

In the previous code snippet you see cooperation of JUnit and EasyMock. I can underline several fundamental things in EasyMock usage.

  1. If test requires interaction with some external object you should mock it.
    coffeeContainer = EasyMock.createMock(CoffeeContainer.class);
  2. Set a behavior for a mock or for a concrete method which is required for the testing of object under the test.
    EasyMock.expect(coffeeContainer.getPortion(Portion.LARGE)).andReturn(true);
  3. Switch a mock to a reply mode.
    EasyMock.replay(coffeeContainer);

    EasyMock has a lot of different methods its API not small, so I recomend to read more on the official site.

JUnit test suite

When you have a small application, you can launch JUnit tests separately, but what if you work on a large and complex application? In this case unit tests can be aggregated in test suits by some feature. JUnit provide convenient way for this.

@RunWith(Suite.class)
@SuiteClasses({ AbstractContainerTest.class, CoffeeMachineTest.class })
public class AllTests {

}

Summary

Unit testing it’s a very important part of software development, it has a lot of approaches, methodologies and tools. In this post I have made an overview of JUnit and EasyMock, but I omited many interesting moments and technics which I plan to cover in following tutorials. You can download source code of the tutorial from my DropBox.
 

Reference: JUnit and EasyMock cooperation from our JCG partner Alex Fruzenshtein at the Fruzenshtein’s notes blog.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you two of our best selling eBooks for FREE!

JPA Mini Book

Learn how to leverage the power of JPA in order to create robust and flexible Java applications. With this Mini Book, you will get introduced to JPA and smoothly transition to more advanced concepts.

JVM Troubleshooting Guide

The Java virtual machine is really the foundation of any Java EE platform. Learn how to master it with this advanced guide!

Given email address is already subscribed, thank you!
Oops. Something went wrong. Please try again later.
Please provide a valid email address.
Thank you, your sign-up request was successful! Please check your e-mail inbox.
Please complete the CAPTCHA.
Please fill in the required fields.

Leave a Reply


3 × three =



Java Code Geeks and all content copyright © 2010-2014, Exelixis Media Ltd | Terms of Use | Privacy Policy | Contact
All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners.
Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries.
Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.
Do you want to know how to develop your skillset and become a ...
Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you two of our best selling eBooks for FREE!

Get ready to Rock!
You can download the complementary eBooks using the links below:
Close