非web下的PowerMockito单元测试

一、介绍

    PowerMockito 可以用来 Mock 掉 final 方法（变量）、静态方法（变量）、私有方法（变量）。想要使用 PowerMockito Mock掉这些内容，需要在编写的测试类上使用 注解：@RunWith(PowerMockRunner.class) 及 @PrepareForTest({First.class,Second.class})，对于注解 @PrepareForTest 网上有介绍说，可以不用注解到测试类上，直接注解到测试方法上，但是我在使用的时候不知道为什么不行，仅能注解到测试方法上。

二、调用别的类中的静态方法

（1） Mock 掉静态方法

   Mock 掉静态方法，需要在测试类上使用 @RunWith 及 @PrepareForTest 并 使用PowerMockito.mockStatic方法。

例子：

import java.io.File;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;

public class FileUtil extends FileUtils{
    
    private static final String FILE_EXTEND_SPLIT = ".";
    /***文件分割符****/
    public static final String FILE_SEPARATOR = "/";
    
    /**
     * 获取文件名（没有扩展内容）
     * @param fileName    文件名称
     * @return
     */
    public static String getNameNoExtend(String fileName){
        if(StringUtils.isNotBlank(fileName)){
            String name = fileName;
            int fileExtendSplitIndex = name.lastIndexOf(FILE_EXTEND_SPLIT);
            if(-1 != fileExtendSplitIndex && fileExtendSplitIndex != name.length()-1){
                name = name.substring(0, fileExtendSplitIndex);
            }
            return name;
        }
        return StringUtils.EMPTY;
    }
    
    /**
     * 判断文件是否是目录
     * @param file
     * @return
     */
    public static boolean isDirectory(File file){
        if(isExist(file) && file.isDirectory()){
            return true;
        }
        return false;
    }
    
    /**
     * 判断文件是否存在
     * @param file
     * @return
     */
    public static boolean isExist(File file){
        if(null != file && file.exists()){
            return true;
        }
        return false;
    }
}

View Code

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

import org.apache.commons.lang3.StringUtils;


public class FileExecute {
    
    
    public InputStream getFileInputStream(String filePath){
        if(StringUtils.isNotBlank(filePath)){
            File file = new File(filePath);
            if(FileUtil.isExist(file)){
                try {
                    return new FileInputStream(file);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                    return null;
                }
            }
        }
        return null;
    }
}

View Code

import java.io.File;

import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;

import com.powerMockito.util.TestRunner;

@PrepareForTest({FileUtil.class})
public class FileExecuteTest extends TestRunner{
    private FileExecute fileExecute = new FileExecute();

    @Test
    public void testGetFileInputStream() {
        String filePath = PathUtil.getClassPath() + "FileExecute.properties";
        PowerMockito.mockStatic(FileUtil.class);
        PowerMockito.when(FileUtil.isExist(Mockito.any(File.class))).thenReturn(false);
        Assert.assertNull(fileExecute.getFileInputStream(filePath));

        PowerMockito.verifyStatic();    //可以使用verifyStatic方法来校验静态Mock是否执行，该方法表示校验静态Mock是否执行一次
    }
}

 

（2） 设置类中的静态共有final变量

    在类（A类）中定义了公有静态final常量，类（B类）中会用到A类的静态常量，在测试B中该方法，可能希望改变这个静态常量的值来进行正常测试（如果测试方法使用静态常量原来值无法进行测试，但程序正常执行时用静态常量原来值是可以执行的且是正确的）。在测试方法中的做法是可以先生成A类对象，通过WhiteBox来更改该常量值。当然测试类上仍然需要有 @RunWith 及 @PrepareForTest。

 三、静态类公共方法调用其自身私有方法

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

import org.apache.commons.lang3.StringUtils;

/**
 * 
静态类
 * @version V1.0
 */
public class StaticFileExecute {
    /***常量***/
    private static final String HELLO = new String("hello");
    /***非常量静态私有方法****/
    private static String NO_HELLO = "noHello";
    
    private static InputStream getFileInputStream(String filePath){
        if(StringUtils.isNotBlank(filePath)){
            File file = new File(filePath);
            if(FileUtil.isExist(file)){
                try {
                    return new FileInputStream(file);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                    return null;
                }
            }
        }
        return null;
    }
    
    public static String getStaticFinalHello(){
        return HELLO;
    }
    
    public static String getFinalNoHello(){
        return NO_HELLO;
    }
    
    
    public static boolean hasInputStream(String filePath){
        InputStream inputstream = getFileInputStream(filePath);
        if(null != inputstream){
            return true;
        }
        return false;
    }
}

View Code

mport static org.junit.Assert.*;

import java.io.File;
import java.io.FileInputStream;

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;

/**
 * 
针对静态类中的方法进行测试
 * @version V1.0
 */
@RunWith(PowerMockRunner.class)
@PrepareForTest({FileUtil.class,StaticFileExecute.class})
public class StaticFileExecuteTest {
    private String filePath = PathUtil.getClassPath() + "FileExecute.properties";
    
    /**
     * 公共静态方法调用私有静态方法，对私有静态方法进行mock
     * @throws Exception 
     */
    @Test
    public void testHasInputStream() throws Exception {
        PowerMockito.spy(StaticFileExecute.class);
        PowerMockito.doReturn(null).when(StaticFileExecute.class,"getFileInputStream",filePath);
        Assert.assertFalse(StaticFileExecute.hasInputStream(filePath));
        /***静态方法被执行了一次***/
        PowerMockito.verifyPrivate(StaticFileExecute.class,Mockito.times(1)).invoke("getFileInputStream",filePath);
        
        PowerMockito.doReturn(new FileInputStream(new File(filePath))).when(StaticFileExecute.class,"getFileInputStream",filePath);
        Assert.assertTrue(StaticFileExecute.hasInputStream(filePath));
        /***静态方法被执行了二次***/
        PowerMockito.verifyPrivate(StaticFileExecute.class,Mockito.times(2)).invoke("getFileInputStream",filePath);
    }
    
    @Test
    public void testGetStringsAfterSplit() {
        fail("Not yet implemented");
    }
    
}

     在示例中，静态类 StaticFileExecute 中的 公共静态 hasInputStream 方法使用私有方法 getFileInputStream。对 hasInputStream 进行测试的时候，需要将 getFileInputStream 方法 mock 掉。mock步骤：

• 对 StaticFileExecute 静态类型进行spy mock；（spy mock 出的表示对象除非指明when，才会返回指定的内容，否则真实执行）；
• 对静态类中的私有方法进行mock；（使用doReturn，这样程序不会进入私有方法内部）；
• 校验私有方法被执行的次数，使用 verifyPrivate；

上述测试用例在Junit4的环境下可以成功执行，但是在统计覆盖率的时候，@preparefortest 中的类 覆盖率为0；为了能够统计出覆盖率，需要进行修正。

(1)  eclipse 使用 插件；

• 使用 EclEmma Java Code Coverage for Eclipse 插件；
• 修改测试类中内容，使用JavaAgent 及 rule；

import static org.junit.Assert.fail;

import java.io.File;
import java.io.FileInputStream;

import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.agent.PowerMockAgent;
import org.powermock.modules.junit4.rule.PowerMockRule;


/**
 * 
针对静态类中的方法进行测试
 * @version V1.0
 */
@PrepareForTest({FileUtil.class,StaticFileExecute.class})
public class JavaAgentStaticExecuteTest {
    private String filePath = PathUtil.getClassPath() + "FileExecute.properties";
    @Rule
    public PowerMockRule rule = new PowerMockRule();
    static {
        PowerMockAgent.initializeIfNeeded();
     }
    /**
     * 公共静态方法调用私有静态方法，对私有静态方法进行mock
     * @throws Exception 
     */
    @Test
    public void testHasInputStream() throws Exception {
        PowerMockito.spy(StaticFileExecute.class);
        PowerMockito.doReturn(null).when(StaticFileExecute.class,"getFileInputStream",filePath);
        Assert.assertFalse(StaticFileExecute.hasInputStream(filePath));
        /***静态方法被执行了一次***/
        PowerMockito.verifyPrivate(StaticFileExecute.class,Mockito.times(1)).invoke("getFileInputStream",filePath);
        
        PowerMockito.doReturn(new FileInputStream(new File(filePath))).when(StaticFileExecute.class,"getFileInputStream",filePath);
        Assert.assertTrue(StaticFileExecute.hasInputStream(filePath));
        /***静态方法被执行了一次***/
        PowerMockito.verifyPrivate(StaticFileExecute.class,Mockito.times(2)).invoke("getFileInputStream",filePath);
    }
    
    @Ignore
    public void testGetStringsAfterSplit() {
        fail("Not yet implemented");
    }
    
}

• 在执行的时候，需要配置JVM参数： -ea -noverify -javaagent:D:/XXXX/.m2/repository/org/powermock/powermock-module-javaagent/1.7.0/powermock-module-javaagent-1.7.0.jar

POM 文件配置：

"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">
    4.0.0
    com.powerMockito.example
    PowerMockitoExample
    0.0.1-SNAPSHOT

    
        4.12
        1.10.19
        1.7.0
        1.3
        3.2.2
        3.1
        1.4
        1.6.2
    
    
        
            junit
            junit
            ${junit.version}
            test
        

        
            org.slf4j
            slf4j-log4j12
            ${slf4j-log4j12.version}
        

        
        
            org.mockito
            mockito-all
            ${mockito-all.version}
            test
        
        
            org.powermock
            powermock-module-junit4
            ${powermock.version}
            test
        
        
            org.powermock
            powermock-api-mockito
            ${powermock.version}
            test
        
        
            org.powermock
            powermock-module-junit4-rule-agent
            1.7.0
            test
        
        
            org.powermock
            powermock-classloading-xstream
            1.7.0
            test
        
        
            org.hamcrest
            hamcrest-library
            ${hamcrest-library.version}
            test
        
        
            commons-collections
            commons-collections
            ${commons-collections.version}
        
        
            org.apache.commons
            commons-lang3
            ${commons-lang3.version}
        
        
            commons-io
            commons-io
            ${commons-io.version}
        
    
    
       
           
                org.apache.maven.plugins  
                maven-compiler-plugin  
                  
                    1.8  
                    1.8  
                  
             
            
            
                org.codehaus.mojo
                findbugs-maven-plugin
                
                    High
                    Default
                    true
                    target/site/findbugs
                
            
            
                org.apache.maven.plugins
                maven-surefire-plugin
                2.20
                
                     -Xms256m -Xmx256m -XX:MetaspaceSize=64m -XX:MaxMetaspaceSize=128m -Dfile.encoding=utf-8 -javaagent:${settings.localRepository}\org\powermock\powermock-module-javaagent\1.7.0\powermock-module-javaagent-1.7.0.jar -ea -noverify
                     true
                    
                        **/*Test.java
                    
                
            
            
            
                org.codehaus.mojo
                cobertura-maven-plugin
                
                    xml
                    utf-8
                    
                        
                            **/*.class
                        
                    
                
            
       
    

 

(2) Maven跑单元测试

     如果通过 Maven 命令跑通单元测试，并生成测试报告与覆盖率报告。需要如上图的 POM文件的配置。但需注意的是：目前执行命令 clean package  cobertura:cobertura  直接统计覆盖率会报错，还没有找到解决方案。

 

补充说明

使用该工具进行Mock的时候，需要注意PowerMock有两个重要的注解：

–@RunWith(PowerMockRunner.class)

–@PrepareForTest( { YourClassWithEgStaticMethod.class })

如果单元测试用例里没有使用注解@PrepareForTest，那么可以不用加注解@RunWith(PowerMockRunner.class)，反之亦然。当需要使用PowerMock强大功能（Mock静态、final、私有方法等）的时候，就需要加注解@PrepareForTest。

(1)     某个实例对象或静态类部分方法需要mock，其它方法正常执行

该种情况主要发生在一个单元测试用例中，在该测试用例中，设计的逻辑是对某个实例对象或静态类的一个方法进行mock，使其返回自己想要的结果，而去别的方法在该用例中正常执行。此时可以使用PowerMockito.spy()。示例如下：

@Before     public void before() throws Exception{         observable = PowerMockito.spy(InstallProgressObservable.getDefaultInstance());   //spy的对象类要放入到@prepareForTest中         PowerMockito.doNothing().when(observable, "notifyObs");         observable.setDetail("");     }

说明：

在上面的代码中mock了InstallProgressObservable对象，而只有执行该对象的notifyObs方法时，才不执行任何动作。其它方法均真实执行。spy的对象类要放入到@prepareForTest中。这里把模拟结果（PowerMockito.doNothing）放在when前面，表示不会真是执行后面的方法，否则程序中会真是执行到，则不会达到模拟的效果。

(2)     Mock静态类的公有静态方法

对静态类的静态方法进行mock，指定其返回模拟数据，此时可以使用PowerMockito.mockStatic方法，并使用PowerMockito.verifyStatic进行校验，主要是校验静态方法是否被执行到。

示例如下：

@Test public void testStartTool() throws Exception {    PowerMockito.mockStatic(CmdUtil.class); PowerMockito.doReturn(false).when(CmdUtil.class,"cmdBool",Mockito.anyString(),   Mockito.anyString(), Mockito.anyVararg());   //这种写法仅在mock的对象填写仅@PrepareForTest中才可以 Whitebox.invokeMethod(ToolInstall.class, "startTool", toolInfo,observable); PowerMockito.verifyStatic(Mockito.times(1)); CmdUtil.cmdBool(Mockito.anyString(), Mockito.anyString(), Mockito.anyVararg()); }

说明：

在上面的代码中mock了CmdUtil.cmdBool方法，首先使用PowerMockito.mockStatic模拟静态类（该静态类需要登记到 @PrepareForTest中）；其次是进行对该静态类中的某个方法进行mock数据；最后在执行完成之后，进行静态类的校验，判断mock的静态方法是否被执行，使用PowerMockito.verifyStatic，注意：在这行后面需要将mock的静态方法再执行一遍。

(3)     执行私有方法

在写单元测试用例的时候，可以直接针对私有方法写单元测试用例，此时面临调用私有方法的情况，通常情况下，我们会写反射类来执行我们测试的私有方法，但是当需要校验参数，让参数为null的时候，直接使用反射类是不行的，需要在反射类的基础上做些额外的逻辑。面对该问题，PowerMockito提供了调用私有方法的方式，直接使用Whitebox.invokeMethod。

示例如下：

@Test public void testStartTool() throws Exception {  Whitebox.invokeMethod(ToolInstall.class, "startTool", toolInfo,observable); }

说明：

在上面的代码中直接使用Whitebox.invokeMethod即可，如果是要对私有方法进行null参数校验，参数要指明是什么类型，如上面的代码改为：Whitebox.invokeMethod(ToolInstall.class,

"startTool", (ToolInfo)null,(InstallProgressObservable)null);

(4)     Mock静态类私有方法

桌面程序中经常出现直接调用静态类的方法，而该方法又会调用该类的其它私有静态方法。写单元测试时，有时需要将静态私有方法进行mock，模拟各种数据校验测试的静态方法的逻辑性，此时就需要对静态私有方法进行Mock，也就是该类的一部分方法要正常执行，另一部分要被mock掉。面对该中情况下，使用PowerMockito.spy，校验私有方法的执行情况，使用PowerMockito.verifyPrivate。

示例如下：

@Test public void testInstallTool_product_notool() throws Exception   {     PowerMockito.spy(ToolInstall.class);    PowerMockito.doReturn(null).when(ToolInstall.class,"getInstallableTool",productName,rootInstallPath);     ToolInstall.installTool(productName,   rootInstallPath, observable);     PowerMockito.verifyPrivate(ToolInstall.class, Mockito.times(1)).invoke("getInstallableTool", productName,rootInstallPath);     PowerMockito.doReturn(Collections.emptyMap()).when(ToolInstall.class,"getInstallableTool",productName,rootInstallPath);     ToolInstall.installTool(productName,  rootInstallPath, observable);     PowerMockito.verifyPrivate(ToolInstall.class, Mockito.times(2)).invoke("getInstallableTool", productName,rootInstallPath); }

说明：

在上面的代码中Mock了ToolInstall 静态类中的getInstallableTool 静态私有方法，而该类的公有installTool静态方法调用getInstallableTool私有方法，测试代码的意图是想让该私有方法返回mock的数据。直接使用PowerMockito.spy mock静态类（该ToolInstall静态类需要登记到 @PrepareForTest中），使用PowerMockito.doReturn….when…..的方式mock私有方法，校验时使用PowerMockito.verifyPrivate，第一个参数为静态类，第二个参数为执行次数。在使用PowerMockito.verifyPrivate时，必须在其返回对象直接使用invoke方法，否则该校验不起作用；invoke中要指明mock的私有方法名称及私有方法需要的参数，该参数应该与mock该方法时使用的一致。

(5)     Mock构造函数

在一个测试方法中若需对被测方法中的某个对象生成进行模拟，此时需要对其构造函数进行mock，直接生成测试方法中指定的对象。可以使用PowerMockito.whenNew。

示例如下：

@Test public void testGetInstallableTool_no_tool_directory() throws Exception{     File toolFile = new File("D:\\hello");     PowerMockito.whenNew(File.class).withArguments(Mockito.anyString()).thenReturn(toolFile);     Map toolInfoMap = (Map)TestReflectUtil.callPrivateMethod(ToolInstall.class, "getInstallableTool", this.productName,this.rootInstallPath);     Assert.assertTrue(CollectionUtil.isEmpty(toolInfoMap)); }

说明：

在上面的代码中对ToolInstall静态类的getInstallableTool方法进行了测试，getInstallableTool方法中要生成File对象，此用例对生成的File对象进行Mock（该ToolInstall静态类需要登记到 @PrepareForTest中），指向指定的文件夹。代码中使用了PowerMockito.whenNew(File.class).withArguments(Mockito.anyString()).thenReturn(toolFile); 这句进行了mock，模拟返回的对象为测试方法中创建的File对象。

(6)     阻止静态代码块执行

某个静态类中有静态代码块。由于每次执行一个Test类，都会重新加载该静态类，每加载一次静态类，静态代码块均会被执行。有时不希望执行静态代码，此时可以在测试类中使用注解 @SuppressStaticInitializationFor。

示例如下：

@SuppressStaticInitializationFor("com.hikvision.discinstall.language.core.TranslatorFactory") //阻止静态代码块运行 public class TranslatorFactoryTest{     @Rule     public PowerMockRule rule = new PowerMockRule();     static {         PowerMockAgent.initializeIfNeeded();        } }

说明：

如果多个静态类都在该测试类中被执行到，且这些类都有静态代码块，该注解中的值使用数组的形式。使用该方式有一点不好的地方就是登记到该注解的静态类类，其中的被赋予初始值的静态属性均不生效，值均为null。为了让静态属性赋值仍然生效，此时需要使用PowerMockRule和Agent。要引入powermock-module-junit4-rule-agent.jar包，且测试类中不能使用@RunWith(PowerMockRunner.class)，具体可见上述代码中test类中的代码，此时必须有该段代码，但有该段又引入另一个问题，此时无法进行bug调试，打断点不生效，因此建议在调试测试用例时，可以不先禁止静态代码块的执行，当没有问题时，再禁止即可。

(7)     覆盖率统计

被测试类在测试方法中被mock掉，且登记到了@PrepareForTest注解中时，此时进行代码统计，被测试类不会被统计到。此时需要使用PowerMockRule。具体用法见（6）中的代码说明部分。

(8)     Mock jdk提供的静态方法

当被测试方法中调用了jdk的静态方法，且想在测试方法中将其mock掉，除了安装mock静态类的公有方法方式来之外，还需要将调用jdk静态方法所属类登记到测试类中的@PrepareTest中。

示例如下：

@PrepareForTest({LanguageUtil.class,Locale.class}) public class LanguageUtilTest{     @Rule     public PowerMockRule rule = new   PowerMockRule();     static {         PowerMockAgent.initializeIfNeeded();      }     @Test     public void testGetSystemLanguage_fail() throws Exception {         //系统提供的静态方法，需要将调用静态方法的类放入到prepareForTest         PowerMockito.mockStatic(Locale.class);         PowerMockito.doReturn(null).when(Locale.class,"getDefault");         Assert.assertTrue(StringUtils.isBlank(LanguageUtil.getSystemLanguage()));     }     @Test     public void testUUID() throws Exception{         PowerMockito.mockStatic(UUID.class);         PowerMockito.doReturn(null).when(UUID.class,"randomUUID");         Assert.assertFalse(LanguageUtil.testUUID());     } }

说明：

在该实例中要测试LanguageUtil.getSystemLanguage()方法，该方法在实现时调用了jdk的Locale.getDefault()方法，此时要对它进行Mock，使用PowerMockito.mockStatic方式，同时需要将Local类及LanguageUtil类登记到@ PrepareForTest中。

(9)     对常量进行设置

在写单元测试用例时，也经常会对某个静态类中的某个常量进行模拟值，此时可以使用Whitebox.setInternalState。

示例如下：

@PrepareForTest({PathConstants.class}) public class ConfigResolverNoPrepareTest extends   TestRunner{     @Test public void   generateViewConfig_main() throws Exception{     Whitebox.setInternalState(PathConstants.class, "PRODUCT_PARENT_PATH",PathConstants.CLASS_PATH + "platform");    //私有静态 }

说明：

使用Whitebox.setInternalState可以对任意的对象属性或类属性进行设置模拟值。但是需要注意的是，若是对常量设置值，需要将类登记到测试类的@PrepareForTest中。