Home » Core Java » Mockito » Mockito Maven Dependency Example

About Mohammad Meraj Zia

Mohammad Meraj Zia
I did my Engineering in Information Technology from IET, Lucknow, India. Currently doing MSc in Information Technology from Derby University. I have worked in Java/J2EE domain for the last 10 years. Have good understanding of Payment and Finance domains.

Mockito Maven Dependency Example

A unit test should test a class in isolation. Side effects from other classes or the system should be eliminated if possible. Mockito lets you write beautiful tests with a clean & simple API. In this example we will learn how to define Mockito dependency in maven and how to use it. Tools and technologies used in this example are Java 1.8, Eclipse Luna 4.4.2

1. Introduction

Mockito is a popular mocking framework which can be used in conjunction with JUnit. Mockito allows us to create and configure mock objects. Using Mockito simplifies the development of tests for classes with external dependencies significantly. We can create the mock objects manually or can use the mocking framewors like Mockito, EasyMock. jMock etc. Mock frameworks allow us to create mock objects at runtime and define their behavior. The classical example for a mock object is a data provider. In production a real database is used, but for testing a mock object simulates the database and ensures that the test conditions are always the same.

Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project’s build, reporting and documentation from a central piece of information. When creating a project in Eclipse, one may use Maven to manage dependencies more easily and to resolve transitive dependencies automatically.

2. Creating a project

In this section we will see how Eclipse can help us create a simple maven project. Below are the steps we need to take to create the project.

  • Open Eclipse. Go to File=>New=>Other. Type ‘Maven’ in the search wizard and choose ‘Maven Project’ under ‘Maven’ folder.
Figure 1. Create Maven Project

Figure 1. Create Maven Project

  • Click ‘Next’. In the next section you need to select the project name and location. Tick the checkbox ‘Create a simple project (skip archetype selection)’. For the purposes of this tutorial, we will choose the simple project. This will create a basic, Maven-enabled Java project. If you require a more advanced setup, leave this setting unchecked, and you will be able to use more advanced Maven project setup features. Leave other options as is, and click ‘Next’.
Figure 2. New Maven Project

Figure 2. New Maven Project

  • Now, you will need to enter information regarding the Maven Project you are creating. You may visit the Maven documentation for a more in-depth look at the Maven Coordinates (Maven Coordinates). In general, the Group Id should correspond to your organization name, and the Artifact Id should correspond to the project’s name. The version is up to your discretion as is the packing and other fields. If this is a stand-alone project that does not have parent dependencies, you may leave the Parent Project section as is. Fill out the appropriate information, and click Finish.
Figure 3. Configure Project

Figure 3. Configure Project

  • You will now notice that your project has been created. You will place your Java code in/src/main/java, resources in /src/main/resources, and your testing code and resources in /src/test/java and /src/test/resources respectively.
Figure 4. Maven Project Structure

Figure 4. Maven Project Structure

Open the pom.xml file to view the structure Maven has set up. In this file, you can see the information entered in the steps above. You may also use the tabs at the bottom of the window to change to view Dependencies, the Dependency Hierarchy, the Effective POM, and the raw xml code for the pom file in the pom.xml tab.

Figure 5. POM

Figure 5. POM

3. Adding dependencies

Dependencies can be added in two ways. Either directly specifying the dependencies in the pom.xml tab or using ‘Dependencies’ tab to add dependencies. We will use the later.

Open the pom.xml file and click on the ‘Dependencies’ tab. Click on the ‘Add…’ button. Eclipse will open a popup where you can define dependencies. Enter the details as below:

Group Id: org.mockito

Artifact Id: mockito-all

Version: 1.9.5

Figure 6. Select dependency

Figure 6. Select dependency

Click OK. Check the pom.xml file. Eclipse will add the below section:

<dependencies>
  <dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>1.9.5</version>
  </dependency>
</dependencies>

Repeat the same steps to add the JUnit dependency

Group Id: junit

Artifact Id: junit

Version: 4.12

Now our final pom will look like below:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.javacodegeeks</groupId>
  <artifactId>mockito</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>Mockito Maven Dependency</name>
  <description>Example of Mockito Maven Dependency</description>
  <dependencies>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-all</artifactId>
      <version>1.9.5</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
  </dependencies>
</project>

4. Testing

Now we will test if our maven project has been set up correctly or not. We will create a simple test class to test this.

MockitoExample.java

package mockito;

import java.util.List;

import org.junit.Test;

import static org.mockito.Mockito.*;
import static org.junit.Assert.*;

public class MockitoExample {

  @Test
  public void test() {
    List<String> mockList = mock(List.class);
    mockList.add("First");
    when(mockList.get(0)).thenReturn("Mockito");
    when(mockList.get(1)).thenReturn("JCG");
    assertEquals("Mockito", mockList.get(0));
    assertEquals("JCG", mockList.get(1));
  }
}

Run this class as JUnit test and it should run successfully. This will prove that your dependencies are setup correctly.

5. Download the source file

In this example we saw how to setup a maven dependency for Mockito using Eclipse

Download
You can download the full source code of this example here: Mockito Maven Dependency
(No Ratings Yet)
Start the discussion Views Tweet it!

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 our best selling eBooks for FREE!

 

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

 

and many more ....

 

Receive Java & Developer job alerts in your Area

 

Leave a Reply

avatar
  Subscribe  
Notify of