Android开发之逻辑单元测试

单元测试的必要性

  • 完整,规范的单元测试有利于提升程序的“自动化”验证
  • 降低后期程序的维护成本
  • 高覆盖率的单元测试在很大程度上能提前发现一些潜在的bug
  • 编写单元测试的过程中可以帮助程序模块化重构,一个耦合性非常高的程序是无法针对他编写完善的单元测试的
private void connectImpl(String domain, String ip, int port) {
        callOnStartConnect(domain,ip,port);
        try {
            socket = createSocket();
            String hostname = domain;
            if (!"".equals(ip) && ip != null) {
                hostname = ip;
            }
            //String hostname = DomainManager.getHostName(domain, ip);
            long start = System.currentTimeMillis();
            InetSocketAddress inetSocketAddress = createInetSocketAddress(hostname, port);
            long end = System.currentTimeMillis();
            long inetTime = end - start;
            InetAddress inetAddress = inetSocketAddress.getAddress();
            if (inetAddress != null) {
                ip = inetAddress.getHostAddress();
            }
            long startConn = System.currentTimeMillis();
            socket.connect(inetSocketAddress, connectTimeout);
            long endConn = System.currentTimeMillis();
            long connectTime = endConn - startConn;
            LogUtil.i(TAG, "connect时间间隔(ms):" + connectTime);
            inputStream = socket.getInputStream();
            outputStream = socket.getOutputStream();
            TCPConnection.this.domain = domain;
            TCPConnection.this.ip = ip;
            TCPConnection.this.port = port;
            callOnConnected(domain,ip,port,inetTime,connectTime);

            LogUtil.i(TAG, "connect to server success,domain:" + domain + ",port:" + port);
        } catch (IOException e) {
            LogUtil.w(TAG, e);//注意:Log工具直接把UnknownHostException返回""

            callOnConnectFailed(domain, ip, port,e);
            return;
        }
        startReadData();
    }
private InetSocketAddress createInetSocketAddress(String hostname, int port) {
        long start = System.currentTimeMillis();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(hostname, port);
        long end = System.currentTimeMillis();
        long inetTime = end - start;
        LogUtil.i(TAG, "inetSocketAddress时间间隔(ms):" + inetTime);
        InetAddress inetAddress = inetSocketAddress.getAddress();
        String localDnsIp = null;
        if (inetAddress != null) {
            localDnsIp = inetAddress.getHostAddress();
        }
        LogUtil.i(TAG, "local dns ip:" + localDnsIp);
        return inetSocketAddress;
    }

以上createInetSocketAddress方法就是我在编写单元测试的时候单独抽离出来的方法,一方面我需要mock一个InetSocketAddress来满足测试需求,另一方面,单独抽离一个createInetSocketAddress方法从代码上看也是必要的,让方法职责更加单一,如果把createInetSocketAddress的实现直接耦合到connectImpl方法中,那么connectImpl的代码除了连接tcp的逻辑外还有创建InetSocketAddress的逻辑,这样就比较混乱,而且方法体也变长

Android单元测试的分类

纯代码逻辑的单元测试,也就是Java单元测试,在test目录下

  • 目前我们项目中用junit + powermock这一套单元测试框架,选择powermock的一个重要的原因就是:现如今比较流行的Mock工具如jMock 、EasyMock 、Mockito等都有一个共同的缺点:不能mock静态、final、私有方法等。而PowerMock能够完美的弥补以上三个Mock工具的不足,具体详细信息可以参考这篇文章:http://blog.csdn.net/jackiehff/article/details/14000779

什么是mock?为什么要mock?

  • mock就是模拟,在代码逻辑测试中,有时候我们需要某一个方法返回我们指定的值,这样才能跑我们预测的代码逻辑,从而通过验证执行结果的正确性来反映该代码逻辑是否有问题,比如:
/**
     * 开始处理同步通知任务
     *
     * @param syncKey 消息版本号
     */
    private synchronized void executeTask(final long imAccountId, final long syncKey) {
        Queue<Runnable> queue = getTaskQueue(imAccountId);
        queue.offer(new Runnable() {
            @Override
            public void run() {
                handleInformResponse(imAccountId, syncKey, new OnNextCallback() {
                    @Override
                    public void onNext() {
                        LogUtil.d(TAG, "sync request on next");
                        scheduleNext(imAccountId);
                    }
                });
            }
        });
        if (isLocked(imAccountId)) {
            LogUtil.w(TAG, "the imAccountId [" + imAccountId + "] is locked.");
            return;
        }
        lock(imAccountId);
        scheduleNext(imAccountId);
        LogUtil.d(TAG, "execute the inform task");
    }
/**
     * 检测一个会话的同步通知处理是否被锁定
     *
     * @param imAccountId im帐户系统id
     * @return true表示已该帐户有正在处理中的同步通知,反之
     */
    private boolean isLocked(long imAccountId) {
        synchronized (imformLockMap) {
            LockStatus lockStatus = imformLockMap.get(imAccountId);
            if (lockStatus == null) {
                return false;
            }
            if (System.currentTimeMillis() - lockStatus.lockTimestamp >= 20000 && lockStatus.locked) {
                lockStatus.locked = false;
                imformLockMap.put(imAccountId, lockStatus);
            }
            return lockStatus.locked;
        }
    }

上面在测试executeTask方法的时候,isLocked返回true和false分别执行的是不通的分支逻辑,因此需要通过控制isLocked的返回值来分别覆盖到这两个逻辑执行流程,mock方法isLocked并返回指定的值,首先需要创建一个经过mock的对象,只有mock的对象才能mock对象中的所有方法或者变量:

syncInformHandler = PowerMockito.mock(SyncInformHandler.class);
PowerMockito.doReturn(false).when(syncInformHandler, "isLocked", Mockito.anyLong());
// or
PowerMockito.doReturn(true).when(syncInformHandler, "isLocked", Mockito.anyLong());
  • mock后的对象有什么区别?
HeartConfig heartConfig = PowerMockito.mock(HeartConfig.class);
// heartConfig = new HeartConfig();

如上heartConfig被mock后生成的对象,它与new出来对象的区别在于,new出来的heartConfig对象,当你调用getMinHeart()方法的时候会真正的去执行这个方法,而且对象被new出来之后,对象中的一些值已经被初始化了,例如对象中的变量的赋值,静态代码块,构造函数都已经执行;但是对于mock出来的heartConfig对象,它的一切都是空的,调用getMinHeart()也不会真正的去执行这个方法,而是执行powermock框架的代理方法,heartConfig对象中的全局变量的复制都是空的,比如说:

private int test = 2;

如果对象new出来之后,那么test的值一定就是2,而对于mock出来的对象,test的值是0

powermock几种常用的mock方式

  • 如果使用powermock,需要在类加入注释:
@RunWith(PowerMockRunner.class)
public class HeartStateContextTest {
// ...
}
  • 如果需要mock对象中的private,final,static,native方法或者final class,使用PowerMockito.whenNew,需要给类加入注解,注解里加入你要mock的class:
@PrepareForTest({SyncInformHandler.class, ManagerFactory.class, RequestEntityFactory.class, AccountStore.class})
public class SyncInformHandlerTest {
// ...
}
  • mock常规的public方法
HeartConfig heartConfig = PowerMockito.mock(HeartConfig.class);
PowerMockito.doReturn(120).when(heartConfig).getMinHeart();
PowerMockito.doReturn(580).when(heartConfig).getMaxHeart();
PowerMockito.doReturn(60).when(heartConfig).getStep();
PowerMockito.doReturn(3).when(heartConfig).getMaxFailedCount();
  • mock类中的private方法
syncInformHandler = PowerMockito.mock(SyncInformHandler.class);
PowerMockito.doReturn(false).when(syncInformHandler, "canDoSync", Mockito.anyLong(), Mockito.anyLong());
  • mock类中的静态方法
PowerMockito.mockStatic(ManagerFactory.class);
managerFactory = PowerMockito.mock(ManagerFactory.class);
PowerMockito.when(ManagerFactory.getInstance()).thenReturn(managerFactory);
  • doReturn和thenReturn的区别
SyncInformHandler syncInformHandler = PowerMockito.mock(SyncInformHandler.class);
PowerMockito.doReturn(1).when(syncInformHandler).getReturn();
Assert.assertEquals(1, syncInformHandler.getReturn());
PowerMockito.when(syncInformHandler.getReturn()).thenReturn(2);
Assert.assertEquals(2, syncInformHandler.getReturn());

以上的测试用例代码是可以正常跑通的,这里说明二者都可用

PowerMockito.mockStatic(ManagerFactory.class);
managerFactory = PowerMockito.mock(ManagerFactory.class);
PowerMockito.when(ManagerFactory.getInstance()).thenReturn(managerFactory);
// 不能用如下写法
// PowerMockito.doReturn(managerFactory).when(ManagerFactory.getInstance());

以上的代码就显示出doReturn和thenReturn的区别了,thenReturn之前的when里的参数是可以调用响应方法的,但是doReturn后面的when只能是一个Object类型的参数

List list = new LinkedList();
List spy = PowerMockito.spy(list);
// 以下会抛出IndexOutOfBoundsException异常
// PowerMockito.when(spy.get(0)).thenReturn("sss");
PowerMockito.doReturn("sss").when(spy).get(0);
Assert.assertEquals("sss", spy.get(0));

以上代码,注释掉的不能用,会抛出IndexOutOfBoundsException异常,因为thenReturn会调用真实的方法执行,而doReturn不会,只会执行stubbed(插桩)方法

  • mock类中private变量
IMInternal imInternal = PowerMockito.mock(IMInternal.class);
PushInfo pushInfo = PowerMockito.mock(PushInfo.class);
PowerMockito.doReturn(pushInfo).when(imInternal).getPushInfo();
syncInformHandler = PowerMockito.mock(SyncInformHandler.class);
Whitebox.setInternalState(syncInformHandler, "imInternal", imInternal);

这里mock了SyncInformHandler类中的private类型的全局变量imInternal,其实就是通过Whitebox.setInternalState方法把我们外部生成的imInternal对象通过反射set进去

  • 对于一个mock对象,有时候我们并不需要里面所有的方法都被mock,有一些方法我们还是想真正执行,可用:doCallRealMethod()方法来标记某一个方法要被真的调用:
PowerMockito.doCallRealMethod().when(syncInformHandler).handle(Mockito.any(PushRequest.class), Mockito.any(PushResponse.class));
  • 对于一个new出来的对象,我们想控制该对象中某些方法的返回值,由于不是mock对象,所以无法mock里面的方法,但是可以通过PowerMockito.spy()来监视这个real object
List list = new LinkedList();
List spy = PowerMockito.spy(list);
PowerMockito.doReturn("sss").when(spy).get(0);
Assert.assertEquals("sss", spy.get(0));

这里有一点需要注意,Mockito.spy()和PowerMockito.spy()区别在于Mockito无法监视对象的final方法,但是PowerMockito可以,其实PowerMockito是基于Mockito的基础上拓展开发的,所以功能更加强大,也兼容了Mockito的功能

  • mock对象自定义的构造函数
SyncInformHandler syncInformHandler = PowerMockito.mock(SyncInformHandler.class);

如果是用以上方式去mock出来的对象,那么是通过默认空参数的构造函数去mock的,想通过自定义带参数的构造函数去mock可用如下方式:

SyncInformHandler syncInformHandler = PowerMockito.mock(SyncInformHandler.class);
PowerMockito.whenNew(SyncInformHandler.class).withArguments(Mockito.anyInt()).thenReturn(syncInformHandler);
SyncInformHandler s1 = new SyncInformHandler(2);
PowerMockito.doReturn(5).when(s1).getReturn();
Assert.assertEquals(5, s1.getReturn());

当使用new SyncInformHandler(2)这个构造函数来创建对象s1的时候,whenNew就会强行把s1替换成我们mock的对象syncInformHandler,然后就能够对s1对象使用各种mock方法了,为什么要这么玩?总感觉多次一举,直接使用mock对象不就好了?我认为,这里可能会更加灵活,mock对象无法指定构造函数,而whenNew可以针对性的指定哪些构造函数new出来的对象是可以使用mock的,哪些构造函数new出来的对象是无需mock的

  • 验证方法是否有被执行过,验证方法被调用的次数;有时候一个方法并没有返回值,所以没办法通过判断返回值的方式来验证结果是否是我们锁预期的,因此可通过检测方法中某一个子方法是否被调用过,被调用的次数来检测是否符合我们的预期:
验证public方法是否被执行过
Mockito.verify(syncKeyManager, Mockito.never()).putServerSyncKey(Mockito.anyLong(), Mockito.anyLong());
// 验证private方法是否被执行过2次
PowerMockito.verifyPrivate(syncInformHandler, Mockito.times(2)).invoke("dealSyncInform", Mockito.any(PushResponse.class));
// 验证指定构造函数是否被执行过,这个要和whenNew结合使用
SyncInformHandler mock = PowerMockito.mock(SyncInformHandler.class);
        PowerMockito.whenNew(SyncInformHandler.class).withArguments(Mockito.any(IMInternal.class)).thenReturn(mock);
SyncInformHandler read = new SyncInformHandler(null);
        PowerMockito.verifyNew(SyncInformHandler.class).withArguments(Mockito.any(IMInternal.class));

如何编写单元测试用例

  • 首先,要理清楚程序逻辑,罗列出程序所有重要的分支,一般方案设计的时候会画一个流程图,可以把流程图细化下,满足什么条件跑if分支,满足什么条件跑else分支
  • 针对每一条程序逻辑分支流程编写一个单元测试用例方法,如果该程序逻辑分支很简单,可以把几个逻辑分支合并成一个单元测试方法
@RunWith(PowerMockRunner.class)
@PrepareForTest({SyncInformHandler.class})
public class ResponseDispatcherTest {

    public void testJUnit() {
        if (isPass()) {
            System.out.println("pass");
        } else {
            System.out.println("no pass");
        }
    }

    public boolean isPass() {
        return true;
    }

    @Test
    public void testStart() throws Exception {
        ResponseDispatcherTest responseDispatcherTest = PowerMockito.mock(ResponseDispatcherTest.class);
        PowerMockito.doCallRealMethod().when(responseDispatcherTest).testJUnit();

        PowerMockito.doReturn(false).when(responseDispatcherTest).isPass();
        responseDispatcherTest.testJUnit();

        PowerMockito.doReturn(true).when(responseDispatcherTest).isPass();
        responseDispatcherTest.testJUnit();
    }
}

testJUnit方法中有两条逻辑分支,那么我们就能控制isPass()返回值来分别执行到这两条逻辑分支,这里只是举一个简单的编写用例,先不用看方法命名规范性问题

  • 对于android程序来说,很多时候代码里面可能会有android的一些相关的类,接口等,但是在JUnit环境下,是没有这些环境的,例如说Context,任何运行到android类的地方都会直接崩溃,这时候需要把这些类或者方法mock掉,返回我们指定的值,Java单元测试的重点是测试Java代码的逻辑,具体的android相关的是不关注的,可以通过android单元测试来测试android的相关代码
  • 每一个单元测试方法都要写详细的注释,减少后面其他人来维护这个单元测试的成本
  • 单元测试用户针对类去写,一个类:className对应一个单元测试用例类:TestclassName,而且包名是一样的,这样在单元测试用例类中就能直接访问protected方法了
  • 单元测试的编写也可以有“模块测试”与“集成测试”的概念,比如说一个方法里面执行了6个子方法,我们可分别验证这6个子方法的正确性,然后再验证这6个子方法合起来跑的结果是否是正确的,也就是验证一个功能处理逻辑的正确性
  • 误区:场景测试,针对一些比较复杂场景的方案设计和编码,罗列出原先设计方案所支持的那些场景,然后用单元测试模拟这些场景来测试,例如我想测试一些多线程场景的问题,所以在测试方法里会开启多个线程,而且在这些线程运行结束之前这个测试方法不能结束,所以要wait,这样有可能导致这个测试方法运行很久,对于一个大工程来说,测试类可能有几十个,测试方法可能有上百个,那么会导致这个工程跑单元测试的时候跑很久才结束,可能会大大降低jinkens的编译速度,因为理论上一个单元测试方法的执行时间都是ms级别的,针对这种问题,考虑放到androidTest下去测试,不要在逻辑单元测试中做

Android单元测试,在androidTest目录下

  • 四大组件的测试(生命周期)
  • UI测试
  • sqlite数据库测试
  • 文件存储测试(sd卡,SharedPreferences)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏刘君君

Builder模式

22850
来自专栏向治洪

picasso图片缓存框架

picasso是Square公司开源的一个Android图形缓存库,地址http://square.github.io/picasso/,可以实现图片下载和缓...

32180
来自专栏博岩Java大讲堂

Java日志体系(commons-logging)Java日志系统学习

70950
来自专栏大闲人柴毛毛

深入剖析Spring(二)——IoC容器的实现

Spring的两种IoC容器 BeanFactory 基础类型的IoC容器; 采用延迟初始化策略(容器初始化完成后并不会创建bean的对象,只有当收到初...

35740
来自专栏一枝花算不算浪漫

[Java 缓存] Java Cache之 Guava Cache的简单应用.

41460
来自专栏郭霖

Android图片加载框架最全解析(四),玩转Glide的回调与监听

大家好,今天我们继续学习Glide。 在上一篇文章当中,我带着大家一起深入探究了Glide的缓存机制,我们不光掌握了Glide缓存的使用方法,还通过源码分析对缓...

63960
来自专栏阿杜的世界

Spring中的资源加载策略

Resouce接口可以根据资源的不同类型,或者资源位置的不同,给出对应的具体实现,Spring框架提供了一些实现类:

9020
来自专栏developerHaoz 的安卓之旅

Android 关于内存泄露,你必须了解的东西

内存管理的目的就是让我们在开发过程中有效避免我们的应用程序出现内存泄露的问题。内存泄露相信大家都不陌生,我们可以这样理解:「没有用的对象无法回收的现象就是内存泄...

7410
来自专栏向治洪

Android数据库Realm实践

Android开发中常用的数据库有5个: 1. OrmLite OrmLite 不是 Android 平台专用的ORM框架,它是Java ORM。支持JDBC连...

26090
来自专栏chenssy

【死磕 Spring】----- IOC 之 Spring 统一资源加载策略

在学 Java SE 的时候我们学习了一个标准类 java.net.URL,该类在 Java SE 中的定位为统一资源定位器(Uniform Resource ...

17230

扫码关注云+社区

领取腾讯云代金券