wuyefei541579607
- 浏览: 7239 次
- 性别:
- 来自: 长沙
-
文章分类
最新评论
PowerMock主要就是模拟对象，并得到你想要的结果
pom.xml增加相关依赖
testcase基类 配置文件视情况而定
主要是init方法，根据接口mock对象塞到指定对象中，并保存到mockMap中。
编写具体测试类，继承上面的基类。
并创建setUp方法，加之以@Before注解，内部调用init方法。方便后续测试方法调用。
常用powerMock方法：
pom.xml增加相关依赖
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
<!-- powermockitor test framework -->
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>1.4.10</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId>
<version>1.4.10</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>3.0.0.RELEASE</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
testcase基类 配置文件视情况而定
主要是init方法，根据接口mock对象塞到指定对象中，并保存到mockMap中。
/**
* Copyright (c) 2011-2014 All Rights Reserved.
*/
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.slf4j.Logger;
import org.springframework.beans.BeansException;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.GlobalTransactionalTestExecutionListener;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.test.context.transaction.TransactionConfigurationAttributes;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.interceptor.DelegatingTransactionAttribute;
import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute;
@RunWith(SpringJUnit4ClassRunner.class)
@TransactionConfiguration(defaultRollback = false)
@TestExecutionListeners(GlobalTransactionalTestExecutionListener.class)
@ContextConfiguration(locations = {"classpath:app-test.xml"})
public abstract class SpringContextTests extends AbstractJUnit4SpringContextTests {
protected Map<String, Object> mockMap = new HashMap<String, Object>();
protected Object getBean(String name) {
return applicationContext.getBean(name);
}
protected void init(Object target, Class<?>... classes) {
// mock classes
Class<?> targetClass = target.getClass();
List<Field> list = getFields(targetClass);
List<Class<?>> mockList = Arrays.asList(classes);
for (Field field : list) {
String fieldName = field.getName();
Object obj = null;
Class<?> type = field.getType();
int modifier = type.getModifiers();
if (!Modifier.isStatic(modifier) && !Modifier.isFinal(modifier) && !Logger.class.equals(type)) {
if (mockList.contains(type)) {
Object ret = mockMap.get(fieldName) == null ? PowerMockito.mock(type) : mockMap.get(fieldName);
mockMap.put(fieldName, ret);
setProperty(target, fieldName, ret);
} else if (Modifier.isInterface(modifier)) {
if (fieldName.contains("Adapter")) {
setProperty(target, fieldName, getBean(fieldName));
} else {
Set<Class<?>> set = getClasses(type.getName().split("." + type.getSimpleName())[0]);
for (Class<?> setClass : set) {
if (type.isAssignableFrom(setClass)
&& !Modifier.isInterface(setClass.getModifiers())
&& ((setClass.getSimpleName().substring(0, 1).toLowerCase() + setClass.getSimpleName().substring(1)).contains(fieldName) || setClass.getSimpleName().contains("Converter"))) {
try {
obj = setClass.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
if (obj != null) {
init(obj, classes);
}
setProperty(target, fieldName, obj);
}
}
}
} else {
try {
obj = type.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
setProperty(target, fieldName, obj);
}
}
}
}
private List<Field> getFields(Class<?> targetClass) {
List<Field> list = new ArrayList<Field>();
list.addAll(Arrays.asList(targetClass.getDeclaredFields()));
list.addAll(Arrays.asList(targetClass.getFields()));
return list;
}
/**
* 从包package中获取所有的Class
*
* @param pack
* @return
*/
public Set<Class<?>> getClasses(String pack) {
// 第一个class类的集合
Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageName = pack;
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
// 得到协议的名称
String protocol = url.getProtocol();
// 如果是以文件的形式保存在服务器上
if ("file".equals(protocol)) {
// 获取包的物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
} else if ("jar".equals(protocol)) {
// 如果是jar包文件
// 定义一个JarFile
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection()).getJarFile();
// 从此jar包 得到一个枚举类
Enumeration<JarEntry> entries = jar.entries();
// 同样的进行循环迭代
while (entries.hasMoreElements()) {
// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
JarEntry entry = entries.nextElement();
String name = entry.getName();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后面的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾 是一个包
if (idx != -1) {
// 获取包名 把"/"替换成"."
packageName = name.substring(0, idx).replace('/', '.');
}
// 如果可以迭代下去 并且是一个包
if ((idx != -1) || recursive) {
// 如果是一个.class文件 而且不是目录
if (name.endsWith(".class") && !entry.isDirectory()) {
// 去掉后面的".class" 获取真正的类名
String className = name.substring(packageName.length() + 1, name.length() - 6);
try {
// 添加到classes
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
// log
// .error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
// log.error("在扫描用户定义视图时从jar包获取文件出错");
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
/**
* 以文件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
public void findAndAddClassesInPackageByFile(String packageName,
String packagePath,
final boolean recursive,
Set<Class<?>> classes) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
// log.warn("用户定义包名 " + packageName + " 下没有任何文件");
return;
}
// 如果存在 就获取包下的所有文件 包括目录
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
public boolean accept(File file) {
return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
}
});
// 循环所有文件
for (File file : dirfiles) {
// 如果是目录 则继续扫描
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive, classes);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0, file.getName().length() - 6);
try {
// 添加到集合中去
// classes.add(Class.forName(packageName + '.' + className));
// 经过回复同学的提醒，这里用forName有一些不好，会触发static方法，没有使用classLoader的load干净
classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
} catch (ClassNotFoundException e) {
// log.error("添加用户自定义视图类错误 找不到此类的.class文件");
e.printStackTrace();
}
}
}
}
public void setProperty(Object obj, String propertyName, Object value) {
Class<?> cls = obj.getClass();
try {
Field field = cls.getDeclaredField(propertyName);
if (!Modifier.isFinal(field.getModifiers())) {
field.setAccessible(true);
field.set(obj, value);
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
private TransactionDefinition transactionDefinition;
private PlatformTransactionManager transactionManager;
private TransactionStatus transactionStatus;
public void beginTransaction() {
RuleBasedTransactionAttribute transactionAttribute = new RuleBasedTransactionAttribute();
transactionAttribute
.setPropagationBehavior(TransactionDefinition.PROPAGATION_NESTED);// nested
// transactions
transactionDefinition = new DelegatingTransactionAttribute(
transactionAttribute) {
public String getName() {
return "ClassTransactionalTestCase";
}
};
transactionManager = getTransactionManager();
transactionStatus = transactionManager
.getTransaction(transactionDefinition);
}
public void endTransaction() {
transactionManager.rollback(transactionStatus);
}
private TransactionConfigurationAttributes retrieveConfigurationAttributes() {
Class<?> clazz = this.getClass();
Class<TransactionConfiguration> annotationType = TransactionConfiguration.class;
TransactionConfiguration config = clazz.getAnnotation(annotationType);
if (logger.isDebugEnabled()) {
logger.debug("Retrieved @TransactionConfiguration [" + config
+ "] for test class [" + clazz + "]");
}
String transactionManagerName;
boolean defaultRollback;
if (config != null) {
transactionManagerName = config.transactionManager();
defaultRollback = config.defaultRollback();
} else {
transactionManagerName = (String) AnnotationUtils.getDefaultValue(
annotationType, "transactionManager");
defaultRollback = (Boolean) AnnotationUtils.getDefaultValue(
annotationType, "defaultRollback");
}
TransactionConfigurationAttributes configAttributes = new TransactionConfigurationAttributes(
transactionManagerName, defaultRollback);
if (logger.isDebugEnabled()) {
logger.debug("Retrieved TransactionConfigurationAttributes ["
+ configAttributes + "] for class [" + clazz + "]");
}
return configAttributes;
}
private PlatformTransactionManager getTransactionManager() {
String tmName = retrieveConfigurationAttributes()
.getTransactionManagerName();
try {
return this.applicationContext.getBean(tmName,
PlatformTransactionManager.class);
} catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn(
"Caught exception while retrieving transaction manager with bean name ["
+ tmName + "] for test context [" + this + "]",
ex);
}
throw ex;
}
}
}
编写具体测试类，继承上面的基类。
并创建setUp方法，加之以@Before注解，内部调用init方法。方便后续测试方法调用。
常用powerMock方法：
PowerMockito.doReturn(result).when(mock).someMethod(Mockito.any(Argument.class)...); PowerMockito.doThrow(new RuntimeException()).when(mock).someVoidMethod();
分享到：
发表评论
相关推荐
PowerMock 是一个强大的Java单元测试框架，它扩展了其他单元测试库如EasyMock，使得能够对静态方法、构造函数、final类和方法、私有方法以及删除静态初始化器等进行模拟和测试。在传统的单元测试中，这些通常被视为...
PowerMock是一个强大的Java单元测试框架，它扩展了其他如EasyMock等工具的功能，允许开发者对静态方法、构造函数、final类和方法、私有方法以及删除静态初始化器进行模拟和测试。在“powerMock的测试样例集合”中，...
PowerMock 也是一个单元测试模拟框架，它是在其它单元测试模拟框架的基础上做出的扩展。通过提供定制的类加载器以及一些字节码篡改技巧的应用，PowerMock 现了对静态方法、构造方法、私有方法以及 Final 方法的模拟...
PowerMock是一个强大的Java框架，它的主要目标是使得那些在传统单元测试中难以或者无法测试的代码变得可测试。这个框架扩展了诸如Mockito等其他流行的模拟库的功能，使其能够处理更复杂的模拟场景。在传统的单元测试...
PowerMock和Mockito是两个非常流行的Java单元测试框架，结合JUnit，它们可以提供强大的测试能力。在本文中，我们将深入探讨"PowerMock+Mockito-junit测试套件1.6.3版本"中的关键概念、功能和使用方法。 **PowerMock...
在单元测试领域，PowerMock是一个强大的工具，它扩展了诸如Mockito等模拟框架的功能，允许开发者模拟静态方法、构造函数、final类和方法、私有方法以及删除静态初始化器等。这一工具对于测试那些难以或者无法正常...
PowerMock 是一个强大的Java单元测试框架的扩展，它允许开发者模拟静态方法、构造函数、final 类、enum 和私有方法，这些都是传统单元测试工具如JUnit和EasyMock无法处理的。这个压缩包“PowerMock.zip”可能包含...
单元测试是软件开发过程中的重要环节，它是一种用于验证代码模块功能是否按预期工作的独立测试。本文将深入探讨单元测试的概念、重要性以及如何进行有效的单元测试。 单元测试主要是针对程序中的最小可测试单元，如...
《PowerMock实战手册》是一本专注于使用PowerMock进行单元测试的指南，结合了Junit测试框架和Mockito库，为开发者提供了全面的测试解决方案。在实际的软件开发中，单元测试是确保代码质量的重要环节，它能帮助我们找...
PowerMock 是一个强大的 Java 测试框架的扩展工具，它允许开发者在单元测试中模拟静态方法、构造函数、最终类和删除静态初始化器等通常难以测试的场景。在 Java 单元测试领域，EasyMock 和 JUnit 是两个常用库，...
单元测试是软件开发过程中的重要环节，特别是在Java编程中，它被视为确保代码质量、提高可维护性和降低缺陷率的关键步骤。单元测试是对程序中最小可测试单元进行检查和验证，通常是一个函数、方法或类。它的目的是...
PowerMock是一个强大的Java单元测试框架，它扩展了如Mockito这样的工具，允许开发者模拟静态方法、构造函数、final类和方法、私有方法以及删除静态初始化器。在Java开发中，有时我们需要对不可Mock的对象进行单元...
PowerMock 是一个强大的Java单元测试框架，它扩展了其它单元测试工具，如Mockito，使得开发者可以模拟静态方法、构造函数、final类和方法、删除静态初始化器等。这款库在进行复杂对象模拟时非常有用，尤其是在处理...
进行单元测试时，我们可以使用JUnit作为测试框架，Mockito来模拟依赖对象，以及PowerMock等库来模拟静态方法和构造函数，以便于测试Filter的各个部分。同时，为了模拟Servlet容器环境，可能还需要使用如Tomcat ...
`powermock-easymock-junit-1.4`这个特定的jar包结合了PowerMock和EasyMock的功能，并与JUnit集成，为开发者提供了一套强大的单元测试工具。它允许你在JUnit测试中使用PowerMock的所有特性，比如模拟那些通常难以...
PowerMock是一个强大的Java单元测试框架，它允许测试代码中静态方法、私有方法以及final类的模拟。它通常与JUnit和EasyMock等测试框架结合使用，用于更高效的单元测试。 标题“PowerMock实战”意味着本书将深入介绍...
Android单元测试(三)：PowerMock框架的使用 Android单元测试(四)：Robolectric框架的使用 Android单元测试(五)：网络接口测试 Android单元测试(六)：RxJava测试 Android单元测试(七)：MVP与单元测试 ...
在Spring MVC框架中，单元测试是确保代码质量的重要步骤，特别是在控制器层（Controller）。这篇博客主要探讨了如何使用JUnit进行Spring MVC Controller的单元测试。在实际开发中，单元测试可以帮助我们尽早发现潜在...