Spying or Mocking Abstract Classes

Abstract classes are referred to as the class declared with the abstract keyword that may or may not include the abstract methods. In Java, abstract classes cannot be instantiated, but they can be sub-classed. It can also have static fields and static methods.

In this section, we will discuss mocking or spying of abstract classes. We will analyze several cases of testing the abstract classes using non-abstract methods.

For spying or mocking the abstract classes, we need to add the following Maven dependencies:

JUnit
Mockito
PowerMock

All the required dependencies of the project are given below:

  <dependency>      <groupId>junit</groupId>      <artifactId>junit</artifactId>      <version>4.12</version>      <scope>test</scope>  </dependency>    <dependency>      <groupId>org.mockito</groupId>      <artifactId>mockito-all</artifactId>      <version>1.10.19</version>      <scope>test</scope>  </dependency>    <dependency>      <groupId>org.powermock</groupId>      <artifactId>powermock-module-junit4</artifactId>      <version>1.7.4</version>      <scope>test</scope>  </dependency>    <dependency>      <groupId>org.powermock</groupId>      <artifactId>powermock-api-mockito</artifactId>      <version>1.7.0</version>      <scope>test</scope>  </dependency>  

The PowerMock dependencies are only required for the test in which we make use of PowerMock.

Examples of Mocking Abstract Class

1. Spying abstract class using Mockito.spy()

In this example, we are going to spy the abstract classes using the Mockito.spy() method. The Mockito.spy() method is used to create a spy instance of the abstract class.

Step 1: Create an abstract class named Abstract1_class that contains both abstract and non-abstract methods.

Abstract1_class.java

  public abstract class Abstract1_class {    public abstract int newAbstractmethod();    public String methodUnderTest() {  return “one” ;  }   }  

Step 2: Create a JUnit test case named Abstract1Test. It contains a spy instance of the abstract class.

Abstract1Test.java

  import static org.junit.Assert.*;  import org.junit.Test;  import org.mockito.Mockito;  import junit.framework.Assert;    public class Abstract1Test {    @Test  public void testing_usingSpy() {   Abstract1_class abstclas = Mockito.spy(Abstract1_class.class);      String res = abstclas.methodUnderTest();   Assert.assertEquals(“one”, res);  }   }  

Output

The following output shows that the test is successfully running.

The drawback of using the Mockito.spy() method is that it will invoke the abstract class constructor during the creation of spy instance. In most of the cases, the constructor uses external dependencies that can be an obstacle to our unit test executions. These external dependencies are usually known as the test impediments. It is the reason to use Mockito.mock() method for mocking abstract classes.

2. Mocking abstract class using Mockito.mock()

In this example, we are going to mock the abstract classes using the Mockito.mock() method.

Usually, mocking is used to create a clone or dummy object of the class. In other words, it makes a class vacant from its logic or algorithms. The created mock instance does not contain code (logic) inside the methods.

Step 1: Create an abstract class named Abstract_Class that contains both abstract and non- abstract methods.

Abstract_Class.java

   public abstract class Abstract_Class {    public String sayMock() {  return “Hii.. ” + getName() + symbol() ;  }    private String symbol(){  return “!!”;  }    protected abstract String getName();     }  

Step 2: Create a JUnit test case named AbstractTestClass for mocking the abstract class.

AbstractTestClass.java

  import static org.junit.Assert.*;  import static org.mockito.Mockito.mock;  import static org.mockito.Mockito.when;    import org.junit.Test;    public class AbstractTestClass {    @Test  public void test_AbstractClasses() {    Abstract_Class ac = mock(Abstract_Class.class);  when(ac.sayMock()).thenCallRealMethod();  when(ac.getName()).thenReturn(“Jyotika”);  assertEquals(“Hii.. Jyotika!!”, ac.sayMock());  }    }  

In the above code, ac is a mocked instance created using Mockito.mock() method.

Output

The following output shows that the test is successfully running using Mockito.

The above approach is not the best, but it can be used. The next approach is recommended because it uses PowerMock, and can have control over the private methods defined in the abstract classes.

3. Mocking abstract class using PowerMock

In the following example, we will use PowerMockito.mock() method for mocking the abstract classes. Using PowerMock instead of Mockito.mock() is a better approach as it can have control over the private as well as static methods.

Step1: Create an abstract class named Abstract_class that contains both abstract and non-abstract methods.

Abstract_class.java

  public abstract class Abstract_Class {    public abstract int myAbstractMethod();    public String sayMock() {  return getName() + “13” ;  }     private String getName(){  return “Jyotika”;  }   }  

Step 2: Create a JUnit test case named AbstractTestClass for testing purposes.

AbstractTestClass.java

  import static org.junit.Assert.*;     import org.junit.Test;  import org.junit.runner.RunWith;  import org.powermock.api.mockito.PowerMockito;  import org.powermock.core.classloader.annotations.PrepareForTest;  import org.powermock.modules.junit4.PowerMockRunner;    @RunWith(PowerMockRunner.class)  @PrepareForTest( Abstract_Class.class)  public class AbstractTestClass {    @Test  public void test_AbstractClassesusing_PowerMock() throws Exception {  // given   Abstract_Class ac = PowerMockito.mock(Abstract_Class.class);  PowerMockito.doCallRealMethod().when(ac).sayMock();  PowerMockito.doReturn(“Sharma”).when(ac , “getName”);  //when  String newstring = ac.sayMock();  //then  assertEquals(“Sharma13”, newstring);  System.out.println(newstring);  }   }  

Here, we have asked the PowerMock to stub the private method’s return values so that we can test the sayMock() method without any test impediments. Mockito alone cannot stub this method, that is why we have used PowerMock along with Mockito.

Output

The following output shows that the test is successfully running using PowerMock with Mockito.

Next Topic#

Mockito Spying or Mocking Abstract Classes

Spying or Mocking Abstract Classes

Examples of Mocking Abstract Class

1. Spying abstract class using Mockito.spy()

2. Mocking abstract class using Mockito.mock()

3. Mocking abstract class using PowerMock

AUC-ROC Curve in Machine Learning

How to Change Color in Photoshop

You may also like