Powermock là gì?
PowerMock là một Java mock framework được sử dụng để giải quyết các vấn đề mà thường được coi là khó khăn hoặc thậm chí không thể viết Unit Test, chẳng hạn như static method, static class, final class, private method, contructor.
PowerMock thực hiện các thủ thuật này bằng cách sửa đổi byte code trong thời gian thực thi (run-time) khi các phương thức test đang được thực thi. PowerMock cũng chứa một số tiện ích cho phép chúng ta truy cập dễ dàng hơn vào trạng thái bên trong của một đối tượng.
PowerMock bao gồm 2 extension API: Mockito và EasyMock. Chúng ta có thể sử dụng một trong hai API đó với một test framework JUnit hoặc TestNG.
PowerMockito là một extension của PowerMock để hỗ trợ Mockito. Nếu bạn đã quen sử dụng Mockito thì cũng nhanh chóng hiểu và làm việc được PowerMockito. Nó mở rộng các API hiện có, đồng thời thêm một vài phương thức và annotation mới cho các tính năng mới. Chẳng hạn, Mockito.mock() –> PowerMockito.mock(), Mockito.spy() –> PowerMockito.spy(), …
Lưu ý: chỉ sử dụng PowerMock khi thực sự cần thiết, bởi vì nó phá vỡ tính bao đóng (encapsulation) của OOP. PowerMock thường được sử dụng để viết test cho legacy code hoặc third-party, nơi chúng ta không thể viết test theo cách thông thường. Trong các trường hợp còn lại, chúng ta nên cố gắng tái cấu trúc lại mã nguồn (refactor code) để hiểu hiểu, dễ test hơn chỉ với JUnit và Mockito.
Cài đặt PowerMock sử dụng Mockito và JUnit
Để sử dụng Mockito chúng ta cần thêm thư viện này vào project. Với project maven, chúng ta mở file pom.xml và thêm khai báo sau:
<!-- https://mvnrepository.com/artifact/org.powermock/powermock-module-junit4 --> <dependency> <groupId>org.powermock</groupId> <artifactId>powermock-module-junit4</artifactId> <version>1.7.4</version> <scope>test</scope> </dependency> <!-- https://mvnrepository.com/artifact/org.powermock/powermock-api-mockito2 --> <dependency> <groupId>org.powermock</groupId> <artifactId>powermock-api-mockito2</artifactId> <version>1.7.4</version> <scope>test</scope> </dependency>
Để sử dụng PowerMockito, chúng ta sử dụng 2 annotation:
- @RunWith(PowerMockRunner.class) : khai báo chạy test với PowerMockito.
- @PrepareForTest : một mảng các class cần mock với PowerMockito hoặc sử dụng với thuộc tính fullyQualifiedNames để khai báo với PowerMockito chuẩn bị chạy với tất cả các class trong package name được khai báo.
Ví dụ:
@RunWith(PowerMockRunner.class)
@PrepareForTest( { YourClassWithEgStaticMethod.class })
public class YourTestCase {
// Test cases
}
Ví dụ sử dụng PowerMockito
Mock constructor
Để mock một constructor, chúng ta sử dụng cấu trúc sau:
PowerMockito.whenNew(classWillBeConstructored).withNoArguments().thenReturn(object); PowerMockito.whenNew(classWillBeConstructored).withAnyArguments().thenReturn(object); PowerMockito.whenNew(classWillBeConstructored).withArguments(firstArgument, additionalArguments).thenReturn(object);
Ví dụ chương trình của chúng ta như sau:
public interface UserDao {
void insert();
}
public class UserDaoImpl implements UserDao {
public UserDaoImpl() {
throw new UnsupportedOperationException("Cannot connect database");
}
@Override
public void insert() {
throw new UnsupportedOperationException("This function is unimplemented yet");
}
}
public class UserService {
private UserDao userDao;
private UserService() {
userDao = new UserDaoImpl();
}
public static UserService createInstance() {
return new UserService();
}
public void insert() {
userDao.insert();
}
}
Như bạn thấy, chúng ta không thể gọi new UserService() để tạo instance của UserService. Chúng ta chỉ có cách gọi phương thức createInstance(), tuy nhiên phương thức này lại có khởi tạo UserDao bên trong. Class UserDao chưa được implement hoặc có lỗi nên class UserService không thể thực thi test. Để tránh phụ thuộc vào nhau và dễ dàng viết test, chúng ta sử dụng PowerMock như sau:
package com.gpcoder.powermock.private_constructor;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest(UserService.class)
public class ConstructorTest {
@Mock
private UserDaoImpl userDao;
@Test
public void privateConstructorTest() throws Exception {
Mockito.doNothing().when(userDao).insert();
PowerMockito.whenNew(UserDaoImpl.class).withNoArguments().thenReturn(userDao);
UserService userService = UserService.createInstance();
userService.insert();
Mockito.verify(userDao).insert();
}
}
Cách sử dụng PowerMock trong ví dụ trên như sau:
- @PrepareForTest(UserService.class) : chúng ta nói với PowerMock khởi tạo dữ liệu test cho class UserService. Do cần mock contructor của UserDaoImpl trong constructor của UserService.
- Tiếp theo chúng ta tạo một mock object và chỉ định không làm gì khi phương thức userService.insert() được gọi.
- Cuối cùng chúng ta chỉ định khi constructor của class UserDaoImpl được gọi, hãy trả về một mock object (userDao).
Mock static methods
Để test các phương thức static chúng ta sử dụng các phương thức sau:
PowerMockito.mockStatic(classToMockWithStaticMethod); // For return specify value PowerMockito.when(classToMockWithStaticMethod).thenReturn(expectedResult); // For return nothing method (void method) PowerMockito.doNothing().when(classToMockWithStaticMethod, "staticMethodName", arguments);
Giả sử chúng ta có class với các phương thức static được sử dụng như sau:
package com.gpcoder.powermock.static_method;
public class DatabaseHelper {
private DatabaseHelper() {
throw new UnsupportedOperationException("Cannot call directly");
}
public static boolean connect() {
throw new RuntimeException("Cannot connect to database");
}
public static void executeSQL(String sql) {
throw new UnsupportedOperationException("This function is unimplemented yet");
}
}
public class DatabaseChecker {
public boolean isDatabaseConnected() {
return DatabaseHelper.connect();
}
public void checkSql(String sql) {
DatabaseHelper.executeSQL(sql);
}
}
Chúng ta sẽ viết test cho class DatabaseChecker như sau:
package com.gpcoder.powermock.static_method;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest(DatabaseHelper.class)
public class StaticMethodTest {
private DatabaseChecker databaseChecker;
@Before
public void prepareForTest() {
databaseChecker = new DatabaseChecker();
}
@Test
public void staticMethodTest() {
boolean expectedResult = true;
PowerMockito.mockStatic(DatabaseHelper.class);
PowerMockito.when(DatabaseHelper.connect()).thenReturn(expectedResult);
Assert.assertEquals(expectedResult, databaseChecker.isDatabaseConnected());
}
@Test
public void staticVoidMethodTest() throws Exception {
PowerMockito.mockStatic(DatabaseHelper.class);
PowerMockito.doNothing().when(DatabaseHelper.class, "executeSQL", Mockito.anyString());
databaseChecker.checkSql("DELETE FROM ...");
PowerMockito.verifyStatic(DatabaseHelper.class);
}
}
Mock final classes
Đối với các final class, chúng ta không thể sử dụng Mockito.mock() hoặc Mockito.spy(). Để tạo các mock object cho final class, chúng ta cần phải sử dụng PowerMock.
Ví dụ:
package com.gpcoder.powermock.final_clazz;
public final class FinalClazz {
public String doSomething() {
return "gpcoder.com";
}
}
package com.gpcoder.powermock.final_clazz;
import 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({ FinalClazz.class })
public class FinalClazzTest {
@Test
public void mockFinalClazzTest() {
FinalClazz mockedObject = PowerMockito.mock(FinalClazz.class);
PowerMockito.when(mockedObject.doSomething()).thenReturn("gpcoder.com");
Assert.assertEquals("gpcoder.com", mockedObject.doSomething());
}
@Test
public void spyFinalClazzTest() {
FinalClazz mockedObject = PowerMockito.spy(new FinalClazz());
Assert.assertEquals("gpcoder.com", mockedObject.doSomething());
}
}
Mock final method
Tương tự final class, chúng ta phải sử dụng PowerMock cho final method.
Ví dụ:
package com.gpcoder.powermock.final_method;
public class FinalMethod {
public final String doSomething() {
return "gpcoder.com";
}
}
package com.gpcoder.powermock.final_method;
import 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({ FinalMethod.class })
public class FinalMethodTest {
@Test
public void mockFinalClazzTest() {
FinalMethod mockedObject = PowerMockito.mock(FinalMethod.class);
PowerMockito.when(mockedObject.doSomething()).thenReturn("gpcoder.com");
Assert.assertEquals("gpcoder.com", mockedObject.doSomething());
}
@Test
public void spyFinalClazzTest() {
FinalMethod mockedObject = PowerMockito.spy(new FinalMethod());
Assert.assertEquals("gpcoder.com", mockedObject.doSomething());
}
}
Mock private methods
PowerMockito cung cấp lớp tiện ích Whitebox hỗ trợ test các phương thức private. Không phải là ý tưởng tốt để test mock các phương thức private, bởi vì nó phá vỡ tính bao đóng (encapsulation). Tuy nhiên, đôi lúc chúng ta cần viết test để cover code trước khi nó được refactor thì chúng ta có thể sử dụng Whitebox.
- Whitebox.setIternalState() : được sử dụng để gán giá trị cho một private field của một instance hoặc class.
- Whitebox.getIternalState() : được sử dụng để lấy giá trị từ một private field của một instance hoặc class.
- Whitebox.invokeMethod() : được sử dụng để gọi một phương thức private của một instance hoặc class.
- Whitebox.invokeConstructor() : được sử dụng để tạo một instance của một private constructor.
Ví dụ invokeConstructor()
package com.gpcoder.powermock.private_method;
public class PrivateConstructor {
private String username;
private PrivateConstructor() {
this.username = "default value when no argument";
}
private PrivateConstructor(String username) {
this.username = username;
}
public String getUsername() {
return username;
}
}
package com.gpcoder.powermock.private_method;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
@RunWith(PowerMockRunner.class)
@PrepareForTest(PrivateConstructor.class)
public class PrivateConstructorTest {
@Test
public void constructorWithoutArgs() throws Exception {
PrivateConstructor mockedObject = Whitebox.invokeConstructor(PrivateConstructor.class);
Assert.assertEquals("default value when no argument", mockedObject.getUsername());
}
@Test
public void constructorWithArgs() throws Exception {
PrivateConstructor mockedObject = Whitebox.invokeConstructor(PrivateConstructor.class, "gpcoder.com");
Assert.assertEquals("gpcoder.com", mockedObject.getUsername());
}
}
Ví dụ invokeMethod(), setInternalState(), setInternalState()
package com.gpcoder.powermock.private_method;
public class PrivateMethod {
private String username;
public String getUsername() {
return username;
}
private void setUsername(String username) {
this.username = username;
}
public void resetUsername() {
setUsername("NONAME");
}
}
package com.gpcoder.powermock.private_method;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
@RunWith(PowerMockRunner.class)
@PrepareForTest(PrivateMethod.class)
public class PrivateMethodTest {
@Test
public void invokeMethodTest() throws Exception {
PrivateMethod obj = new PrivateMethod();
Whitebox.invokeMethod(obj, "setUsername", "gpcoder.com");
Assert.assertEquals("gpcoder.com", obj.getUsername());
}
@Test
public void setInternalStateTest() throws Exception {
PrivateMethod obj = new PrivateMethod();
Whitebox.setInternalState(obj, "username", "gpcoder.com");
Assert.assertEquals("gpcoder.com", obj.getUsername());
}
@Test
public void getInternalStateTest() throws Exception {
PrivateMethod obj = new PrivateMethod();
Whitebox.setInternalState(obj, "username", "gpcoder.com");
Assert.assertEquals("gpcoder.com", Whitebox.getInternalState(obj, "username"));
}
@Test
public void doNothingWhenCallPrivateMethod() throws Exception {
PrivateMethod obj = PowerMockito.spy(new PrivateMethod());
// Do nothing when resetUsername() was called
PowerMockito.doNothing().when(obj, "setUsername", Mockito.anyString());
obj.resetUsername();
// Verify obj.resetUsername() was called
PowerMockito.verifyPrivate(obj).invoke("setUsername", Mockito.anyString());
// Verify username is null because setUsername() never executed
Assert.assertNull(obj.getUsername());
}
}
Ví dụ verify static method
Để verify các phương thức static method đã được call hay chưa chúng ta sử dụng phương thức PowerMockito.verifyStatic().
public class UserUtils {
public static void validate(String username) {
throw new UnsupportedOperationException("This function is unimplemented yet");
}
public static String generateUniqueId() {
throw new UnsupportedOperationException("This function is unimplemented yet");
}
}
public class UserService {
public String insert() {
final String username = "gpcoder.com";
UserUtils.validate(username);
String uuid = UserUtils.generateUniqueId();
UserUtils.validate(uuid);
return username;
}
}
import java.util.UUID;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ UserUtils.class })
public class UserServiceTest {
@Test
public void verifyCalledStaticMethodTest() throws Exception {
// Object under test
UserService userService = new UserService();
// Mock
PowerMockito.mockStatic(UserUtils.class);
PowerMockito.doNothing().when(UserUtils.class, "validate", Mockito.anyString());
PowerMockito.when(UserUtils.class, "generateUniqueId").thenReturn(UUID.randomUUID().toString());
// Execute method under test
String actual = userService.insert();
// Test
Assert.assertEquals("gpcoder.com", actual);
PowerMockito.verifyStatic(UserUtils.class, Mockito.times(2));
UserUtils.validate(Mockito.anyString());
PowerMockito.verifyStatic(UserUtils.class, Mockito.times(1));
UserUtils.generateUniqueId();
}
}
Lưu ý: đối với static method hơi đặc biệt, chúng ta phải:
- @PrepareForTest : class chứa phương thức static cần mock.
- PowerMockito.mockStatic() : class chứa phương thức static cần mock.
- Thực thi phương thức cần test.
- Gọi PowerMockito.verifyStatic(), sau đó gọi tiếp một phương thức test để Powermock lắng nghe kết quả.
Tài liệu tham khảo: