在本文中，我们将为您详细介绍如何使用PowerMockito模拟构造函数的相关知识，并且为您解答关于powermock构造函数的疑问，此外，我们还会提供一些关于java–可以在非最终具体类中的Powe
在本文中，我们将为您详细介绍如何使用PowerMockito模拟构造函数的相关知识，并且为您解答关于powermock 构造函数的疑问，此外，我们还会提供一些关于java – 可以在非最终具体类中的Powermockito模拟最终方法？、java – 如何使用Mockito传递构造函数参数、JavaPowerMockito模拟单个静态方法和返回对象、Junit，Mockito，PowerMockito 进行单元测试的有用信息。
本文目录一览：- 如何使用PowerMockito模拟构造函数（powermock 构造函数）
- java – 可以在非最终具体类中的Powermockito模拟最终方法？
- java – 如何使用Mockito传递构造函数参数
- JavaPowerMockito模拟单个静态方法和返回对象
- Junit，Mockito，PowerMockito 进行单元测试
如何使用PowerMockito模拟构造函数（powermock 构造函数）
我正在尝试第一次使用PowerMockito模拟类构造函数，但是它不起作用。我当前的代码是：
public class Bar {
public String getText() {
return "Fail";
}
}
public class Foo {
public String getValue(){
Bar bar= new Bar();
return bar.getText();
}
}
@RunWith(PowerMockRunner.class)
@PrepareForTest(Bar.class)
public class FooTest {
private Foo foo;
@Mock
private Bar mockBar;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
PowerMockito.whenNew(Bar.class).withNoArguments().thenReturn(mockBar);
foo= new Foo();
}
@Test
public void testGetValue() throws Exception {
when(mockBar.getText()).thenReturn("Success");
assertEquals("Success",foo.getValue());
}
}
测试失败，因为返回的值为“ Fail”。我的问题在哪里？
java – 可以在非最终具体类中的Powermockito模拟最终方法？
public class ABC {
public final String myMethod(){
return "test test";
}
}
使用powermockito在junit中调用myMethod()可以返回别的东西吗？谢谢
解决方法
@RunWith(powermockrunner.class)
@PrepareForTest(ABC.class)
public class ABCTest {
@Test
public void finalCouldBeMock() {
final ABC abc = powermockito.mock(ABC.class);
powermockito.when(abc.myMethod()).thenReturn("toto");
assertEquals("toto",abc.myMethod());
}
}
java – 如何使用Mockito传递构造函数参数
我想使用Mockito框架模拟一个类,它有几个构造函数参数.
如何在不为私有成员变量生成setter的情况下传递这些构造函数参数？
谢谢
您正在寻找的是spy,而不是模拟.如果你决定使用间谍,你将从一个真实的对象中创建它,它已经使用你需要构造的任何参数构建.
但是在你考虑使用间谍之前,我建议你更仔细地考虑一下你正在测试的是什么,以及为什么你认为你需要用模拟实现替换你的一些方法,而不是其他方法.
JavaPowerMockito模拟单个静态方法和返回对象
我想从包含2个静态方法m1和m2的类中模拟静态方法m1。我希望方法m1返回一个对象。
我尝试了以下
1）
PowerMockito.mockStatic(Static.class, new Answer<Long>() { @Override public Long answer(InvocationOnMock invocation) throws Throwable { return 1000l; } });这将同时调用m1和m2，它们具有不同的返回类型，因此会给出返回类型不匹配错误。
2）PowerMockito.when(Static.m1(param1, param2)).thenReturn(1000l); 但是，执行m1时不会调用此方法。
3）PowerMockito.mockPartial(Static.class, "m1"); 给出了我不能从http://code.google.com/p/powermock/wiki/MockitoUsage获得的，无法提供模拟部分的编译器错误。
答案1
小编典典你想要做的是1的一部分和2的全部的组合。
你需要使用PowerMockito.mockStatic为类的所有静态方法启用静态模拟。这意味着可以使用when-thenReturn语法对它们进行存根。
但是，当你调用尚未在模拟实例上显式存根的方法时，你正在使用的2个参数的mathStatic重载为Mockito / PowerMock应该执行的操作提供了默认策略。
从javadoc：
创建具有指定策略的类模拟，以解决交互问题。这是一个非常高级的功能，通常你不需要它来编写不错的测试。但是，在使用旧系统时可能会有所帮助。这是默认答案，因此仅当你不存根方法调用时才会使用它。
该默认默认磕碰的策略是只返回NULL，0或假的对象，数量和布尔值的方法。通过使用2-arg重载，你说的是“不，不，不，默认情况下，使用此Answer子类的answer方法获取默认值。它返回Long，因此，如果你有静态方法返回的值与长期存在问题。
而是使用模拟静态的1-arg版本启用静态方法的存根，然后使用when-thenReturn指定对特定方法执行的操作。例如：
import static org.mockito.Mockito.*;import org.junit.Test;import org.junit.runner.RunWith;import org.mockito.invocation.InvocationOnMock;import org.mockito.stubbing.Answer;import org.powermock.api.mockito.PowerMockito;import org.powermock.core.classloader.annotations.PrepareForTest;import org.powermock.modules.junit4.PowerMockRunner;class ClassWithStatics { public static String getString() { return "String"; } public static int getInt() { return 1; }}@RunWith(PowerMockRunner.class)@PrepareForTest(ClassWithStatics.class)public class StubJustOneStatic { @Test public void test() { PowerMockito.mockStatic(ClassWithStatics.class); when(ClassWithStatics.getString()).thenReturn("Hello!"); System.out.println("String: " + ClassWithStatics.getString()); System.out.println("Int: " + ClassWithStatics.getInt()); }}字符串型静态方法被存根以返回“ Hello！”，而整数型静态方法使用缺省的存根，返回0。
Junit，Mockito，PowerMockito 进行单元测试
文档入口：
https://github.com/powermock/powermock/wiki
私有方法mock文档：
https://github.com/powermock/powermock/wiki/MockPrivate
静态方法mock文档
https://github.com/powermock/powermock/wiki/MockStatic
案例参考：
https://ehlxr.me/2017/07/25/use-introduction-of-powermock/
概述：
介绍基于Junit ，Mockito，PowerMockito 常用的测试方法，包括异常测试，私有方法测试，没有返回值的方法测试，基于mock或spy的测试；
其中包含常规方法mock，私有方法mock。
一 测试介绍
1）测试原则：
凡是需要验证的方法都可以写单元测试，证明预期行为（不区分 controller，service ，dao）
2）测试分类：
a）单元测试：测试方法的 “逻辑” 是否满足期望。
b）集成测试：集成各个依赖组件，测试整体流程是否能通。
3）关于依赖：
单元测试一般测试当前方法的逻辑，不测试被依赖的类方法或自己的私有方法。
4）Mock 和 Spy 生成类区别
Mock：生成的类，所有方法都不是真实的方法，而且返回值都是NULL； 通过when 指定行为。
Spy：生成的类，所有方法都是真实方法，返回值都是和真实方法一样的；通过when 来将某个真实的方法，替换为指定行为的执行。
5）参考
1）普通mockito mock
http://site.mockito.org/
2）使用powerMock ，增强 静态方法，私有方法能力；
https://github.com/powermock/powermock
二 Demo 本程序依赖
Xml代码
<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>x.test</groupId>
<artifactId>test</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>test</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<junit.version>4.12</junit.version>
<mockito.version>2.8.47</mockito.version>
<powermock.version>1.7.0</powermock.version>
<assertj.version>3.8.0</assertj.version>
</properties>
<dependencies>
<!-- test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>${mockito.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>${powermock.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito2</artifactId>
<version>${powermock.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>${assertj.version}</version>
<scope>test</scope>
</dependency>
<!-- utils -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>20.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
三 简单的测试
测试抛异常，无返回值的方法测试，私有方法测试
1）被测试类
Java代码
package x.test.simple;
import com.google.common.base.Strings;
/**
* 测试demo class
* <p>
* Created by shilei on 2017/7/10.
*/
public class HelloWho {
private String who;
public HelloWho(String who) {
//条件路径
if (Strings.isNullOrEmpty(who)) {
throw new IllegalArgumentException("who can not be null!");
}
//赋值路径
this.who = who;
}
public void sayHello() {
System.out.println(getHelloMessage());
}
private String getHelloMessage() {
return "Hello " + who;
}
}
2）测试类
Java代码
package x.test.simple;
import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.powermock.reflect.Whitebox;
/**
* 基础测试：
* <p>
* 1 测试抛异常
* 2 测试无返回值
* 3 测试私有方法
*/
public class HelloWhoTest {
@Test(expected = IllegalArgumentException.class)
public void test_construction_empty_who_throw_exception() {
new HelloWho("");
}
@Test(expected = IllegalArgumentException.class)
public void test_construction_null_who_throw_exception() {
new HelloWho(null);
}
/**
* 无返回值的方法测试，查看其修改的成员变量是否成功
*/
@Test
public void test_construction_args_set_who() throws Exception {
//预期结果
String expectWho = "A";
//执行被测试方法
HelloWho helloWho = new HelloWho(expectWho);
//白盒，获取修改的成员变量
String actualWho = (String) Whitebox.getField(helloWho.getClass(), "who").get(helloWho);
//断言
Assertions.assertThat(actualWho).isEqualTo(expectWho);
}
/**
* 测试私有方法
*/
@Test
public void test_getHelloMessage() throws Exception {
//准备方法参数
String who = "A";
//准备预期结构
String expextMessage = "Hello " + who;
//执行被测试方法
HelloWho helloWho = new HelloWho(who);
String actualMessage = Whitebox.invokeMethod(helloWho, "getHelloMessage");
//断言
Assertions.assertThat(actualMessage).isEqualTo(expextMessage);
}
}
四 基于Mock的测试
依赖mock，私有方法mock，验证方法是否被执行
1）被依赖类Dao
Java代码
package x.test.adv.dao.pojo;
/**
* 用户
* <p>
* Created by shilei on 2017/7/10.
*/
public class User {
}
package x.test.adv.dao;
import x.test.adv.dao.pojo.User;
/**
* 用户dao
* Created by shilei on 2017/7/10.
*/
public interface UserDao {
/**
* 保存
*
* @param user 用户
* @return true : 保存成功 ； false ： 用户已存在
*/
boolean save(User user);
}
2）待测试类Service
Java代码
package x.test.adv.service;
import x.test.adv.dao.pojo.User;
/**
* 用户服务
* <p>
* Created by shilei on 2017/7/10.
*/
public interface UserService {
/**
* 保存 ， 如果保存成功，记录日志
*
* @param user user
*/
void save(User user);
}
package x.test.adv.service.impl;
import x.test.adv.dao.UserDao;
import x.test.adv.dao.pojo.User;
import x.test.adv.service.UserService;
/**
* 带依赖的测试
* <p>
* Created by shilei on 2017/7/10.
*/
public class UserServiceImpl implements UserService {
private UserDao userDao;
@Override
public void save(User user) {
//保存
boolean isSave = userDao.save(user);
//写大数据日志
if (isSave) {
writeLog(user);
}
}
private void writeLog(User user) {
System.out.println(user);
}
}
3）测试类
Java代码
package x.test.adv.service.impl;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import x.test.adv.dao.UserDao;
import x.test.adv.dao.pojo.User;
/**
* 带依赖的测试：
* 1 mock 依赖
* 2 mock 私有方法
*/
@RunWith(PowerMockRunner.class)
//mock 静态方法，私有方法，需要添加该注解，以便通知框架
@PrepareForTest(UserServiceImpl.class)
public class UserServiceImplTest {
//mock 依赖注入到该bean
@InjectMocks
private UserServiceImpl userServiceImpl;
//mock 依赖
@Mock
private UserDao userDao;
//完成依赖注入
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
/**
* 测试保存成功，写日志
*/
@Test
public void test_save_true_verify_writelog() throws Exception {
// 侦查对象
UserServiceImpl spyUserService = PowerMockito.spy(userServiceImpl);
//创建输入
User user = new User();
//打桩
// mock 依赖行为，等价于 BDDMockito.given(userDao.save(user)).willReturn(true);
Mockito.when(userDao.save(user)).thenReturn(true);
//mock 私有方法
PowerMockito.doNothing().when(spyUserService, "writeLog", user);
//调用实际方法
spyUserService.save(user);
//断言 writelog 被执行一次
PowerMockito.verifyPrivate(spyUserService, Mockito.times(1)).invoke("writeLog", user);
}
/**
* 测试保存成功，写日志
*/
@Test
public void test_save_false_no_writelog() throws Exception{
// 侦查对象
UserServiceImpl spyUserService = PowerMockito.spy(userServiceImpl);
//创建输入
User user = new User();
//打桩
// mock 依赖行为，等价于 BDDMockito.given(userDao.save(user)).willReturn(true);
Mockito.when(userDao.save(user)).thenReturn(false);
//mock 私有方法
PowerMockito.doNothing().when(spyUserService, "writeLog", user);
//调用实际方法
spyUserService.save(user);
//断言 writelog 被执行一次
PowerMockito.verifyPrivate(spyUserService, Mockito.times(0)).invoke("writeLog", user);
}
}
今天的关于如何使用PowerMockito模拟构造函数和powermock 构造函数的分享已经结束，谢谢您的关注，如果想了解更多关于java – 可以在非最终具体类中的Powermockito模拟最终方法？、java – 如何使用Mockito传递构造函数参数、JavaPowerMockito模拟单个静态方法和返回对象、Junit，Mockito，PowerMockito 进行单元测试的相关知识，请在本站进行查询。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
