Android 开发单元测试 (Mock)

作者: TiaoPi | 来源:发表于2017-11-23 15:17 被阅读470次

Android 开发单元测试 (Mock)

上一篇文章中说了JUnit4的作为单元测试的情况下去测试java代码的基本用法, 主要讲到了一些用在有返回值的方法,那么这章, 来介绍怎么测试返回值类型为void的代码的如何测试

假设有这样一段代码

 public void loginApp(String name, String password){
        if (name == null || name.length() == 0) return;
        if (password == null || password.length() < 6) return;
        ligon(name, password, new NetworkCallback() {
            @Override
            public void onSuccess(String msg) {

            }

            @Override
            public void onFailure(String msg) {

            }
        });
    }

    public void ligon(String name, String password,NetworkCallback networkCallback){
        user.setName(name);
        user.setPassword(password);
        if (name.equals("TaioPi") && password.equals("123456")) {
            networkCallback.onSuccess("OK");
        }else {
            networkCallback.onFailure("FAIL");
        }
    }

怎么办

使用Mock(模拟对象)

Mock: Mock的概念，其实很简单, 所谓的mock就是创建一个类的虚假的对象，在测试环境中，用来替换掉真实的对象

结果

用来验证这个对象的某些方法的调用情况，调用了多少次，参数是什么等,

指定这个对象的某些方法的行为，返回特定的值，或者是执行特定的动作

Mock框架 : Mockito

Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁。
github : https://github.com/mockito/mockito
官网 : http://site.mockito.org/
官方文档 https://static.javadoc.io/org.mockito/mockito-core/2.12.0/org/mockito/Mockito.html

首先还是Mockito 使用的步骤

先导包

    testCompile "org.mockito:mockito-core:+"
    androidTestCompile "org.mockito:mockito-android:+"

模拟并替换测试代码中外部依赖
执行测试代码
验证测试代码是否被正确的执行

简单实用Mockito

我们这里使用 2.x 来介绍 ,跟刚上一篇一样, 我们这里先把 Mockito的主要功能先列出来, 之后再进行实例使用

1.验证某些行为

一旦mock对象被创建了，mock对象会记住所有的交互。然后你就选择性的验证交互。

        // mock creation 创建mock对象
        MockotiTestBean mockotiTestBean = mock(MockotiTestBean.class);

        //using mock object 使用mock对象
        mockotiTestBean.setMockName("TaioPi");
        mockotiTestBean.setMockAge("26");

        //verification 验证
        verify(mockotiTestBean).setMockName("TaioPi");
        verify(mockotiTestBean).setMockAge("26");

2.测试桩 `Stub`

先说一下概念 : Stub完全是模拟一个外部依赖，用来提供测试时所需要的测试数据。

 // 你可以mock具体的类型,不仅只是接口
//        mockotiTestBean = mock(MockotiTestBean.class);

        //  stubbing 测试桩
        when(mockotiTestBean.getMockName()).thenReturn("TiaoPi");
        when(mockotiTestBean.getMockAge()).thenReturn(26);

        mockotiTestBean.getMockName();
        mockotiTestBean.getMockAge();
        mockotiTestBean.getMockAge();

        // 验证被调用的次数
        verify(mockotiTestBean,times(1)).getMockName();
        verify(mockotiTestBean,times(2)).getMockAge();

重点介绍一下打桩

桩，或称桩代码，是指用来代替关联代码或者未实现代码的代码。
打桩的目的
打桩的目的主要有：隔离、补齐、控制。

   隔离是指将测试任务从产品项目中分离出来，使之能够独立编译、链接，并独立运行。
   补齐是指用桩来代替未实现的代码.
    控制是指在测试时，人为设定相关代码的行为，使之符合测试需求。

3.参数匹配器`matchers`

Mockito以自然的java风格来验证参数值: 使用equals()函数。当需要额外的灵活性时你可能需要使用参数匹配器.参数匹配器使验证和测试桩变得更灵活。

内置参数匹配器 ,,自定义参数匹配器在后面

a690f684-07cd-4f8a-b9fd-310b0dedc23d.png

看代码

        //  stubbing 测试桩
        when(mockotiTestBean.getAge(anyInt())).thenReturn(26);
        
        mockotiTestBean.getAge(anyInt()) 
        // 验证被调用的次数
        verify(mockotiTestBean,times(1)).getAge(anyInt());

4.验证函数的确切,最少,从未调用的次数

        mockotiTestBean.setMockName("TiaoPi");
        mockotiTestBean.setMockName("TiaoPi");
        mockotiTestBean.setMockName("XiaoTiaoPi");
        mockotiTestBean.setMockAge(26);
        mockotiTestBean.setMockAge(26);
        mockotiTestBean.setMockAge(26);
        mockotiTestBean.setMockAge(26);
        mockotiTestBean.setMockAge(26);

        //验证调用
        verify(mockotiTestBean,times(2)).setMockName("TiaoPi");
        verify(mockotiTestBean,times(1)).setMockName("XiaoTiaoPi");
        verify(mockotiTestBean,times(5)).setMockAge(26);

        // 使用never()进行验证,never相当于times(0)
        verify(mockotiTestBean, never()).setMockName("000");

        // 使用atLeast()/atMost()
        verify(mockotiTestBean, atLeastOnce()).setMockName("XiaoTiaoPi");
        verify(mockotiTestBean, atLeast(2)).setMockName("TiaoPi");
        verify(mockotiTestBean, atMost(5)).setMockAge(26);

5.为返回值为`void`的海曙通过打桩抛出异常

stubVoid(Object) 函数用于为无返回值的函数打桩。现在stubVoid()函数已经过时,doThrow(Throwable)成为了它的继承者

doThrow(new RuntimeException("调用了!!!"))
.when(mockotiTestBean).getVoid();

mockotiTestBean.getVoid(); // 调用会有异常

8778512d-20c6-4af9-b902-4706e5741438.png

6.验证执行顺序

创建InOrder对象 : 对那些需要验证顺序的mock对象来创建InOrder对象。

验证执行顺序是非常灵活的-你不需要一个一个的验证所有交互,只需要验证你感兴趣的对象即可。

        mockotiTestBean.setMockName("TiaoPi1");
        mockotiTestBean.setMockName("TiaoPi2");

        // 为该mock对象创建一个inOrder对象  //多个mock 需要创建多个
        InOrder inOrder = inOrder(mockotiTestBean);

        //确保函数首先执行的是setMockName("TiaoPi1"),然后才是setMockName("TiaoPi2");
        inOrder.verify(mockotiTestBean).setMockName("TiaoPi1");
        inOrder.verify(mockotiTestBean).setMockName("TiaoPi2");

7.确保交互操作不会执行在mock对象上

确保模拟对象上无互动发生

        mockotiTestBean.setMockName("TiaoPi");

        // 普通验证
        verify(mockotiTestBean).setMockName("TiaoPi");

        //验证这个交互从来没有执行
        verify(mockotiTestBean,never()).setMockName("xiaoTiaoPi");

        MockotiTestBean mockotiTestBean2 = mock(MockotiTestBean.class);

//        mockotiTestBean2.getVoid(); //如果调用  就回出异常  因为发生过交互

        //验证mock对象从来没有交互
        verifyZeroInteractions(mockotiTestBean2);

8.找出冗余的互动

未被验证到的Mock

verifyNoMoreInteractions()并不建议在每个测试函数中都使用 ,尽量实用never()

        mockotiTestBean.setMockName("TiaoPi");
        mockotiTestBean.setMockAge(26);

        verify(mockotiTestBean).setMockName("TiaoPi");
        verify(mockotiTestBean).setMockAge(26);

        //setMockName 和 setMockAge 都需要验证   否则 下面的验证将会失败
        verifyNoMoreInteractions(mockotiTestBean);

9. 简化mock对象的创建

最小化重复的创建代码
使测试类的代码可读性更高
使验证错误更易于阅读，因为字段名可用于标识mock对象

使用@Mock 注解和 MockitoAnnotations.initMocks(this)
注意: MockitoAnnotations.initMocks(this)需要放在测试执行之前

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);
    }

    /**
     * 简化mock对象的创建
     */
    @Mock
    MockotiTestBean mockotiTestBean2;

    @Test
    public void testMockCreate(){

        mockotiTestBean2.setMockAge(anyInt());
        verify(mockotiTestBean2).setMockAge(anyInt());

    }

10. 为连续的调用做测试桩 `stub`

有时我们需要为同一个函数调用的不同的返回值或异常做测试桩。典型的运用就是使用mock迭代器。

/**
     * 为连续的调用做测试桩 `stub`
     */
    @Test
    public void testConsecutive() throws  Exception{

        //连续调用
        when(mockotiTestBean.getAge(anyInt())).thenReturn(26)
                .thenReturn(25)
                .thenReturn(24);

        //简单模式
//        when(mockotiTestBean.getAge(anyInt())).thenReturn(26,25,24);

        //第一次调用
        Log.d("第一次调用",mockotiTestBean.getAge(anyInt()) + "");
        Log.d("第二次调用",mockotiTestBean.getAge(anyInt()) + "");
        Log.d("第三次调用",mockotiTestBean.getAge(anyInt()) + "");

    }

d265f3b6-f40c-4a82-9ca7-ed5aea7346f8.png

11. 为回调打桩

建议使用thenReturn() 或thenThrow()来打桩

        doThrow(new RuntimeException("调用了Click")).when(mockotiTestBean)
                .setMockClick(any(MockotiTestBean.MockClick.class));

        mockotiTestBean.setMockClick(new MockotiTestBean.MockClick() {
            @Override
            public void click(int a) {

            }
        });

12.doReturn()、doThrow()、doAnswer()、doNothing()、doCallRealMethod()系列方法的运用

通过when(Object)为无返回值的函数打桩有不同的方法,因为编译器不喜欢void函数在括号内…

使用doThrow(Throwable) 替换stubVoid(Object)来为void函数打桩是为了与doAnswer()等函数族保持一致性。

当你调用doThrow(), doAnswer(), doNothing(), doReturn() and doCallRealMethod() 这些函数时可以在适当的位置调用when()函数. 当你需要下面这些功能时这是必须的:

测试void函数

在受监控的对象上测试函数

不知一次的测试为同一个函数，在测试过程中改变mock对象的行为。

最后. 监控真实对象`spy`

为真实对象创建一个监控(spy)对象;当你使用这个spy对象时真实的对象也会也调用，除非它的函数被stub了。
spy与mock的唯一区别就是默认行为不一样：spy对象的方法默认调用真实的逻辑，mock对象的方法默认什么都不做，或直接返回默认值

        MockotiTestBean spy = spy(mockotiTestBean);

        //打桩
        when(spy.getAge(anyInt())).thenReturn(26);
        Log.d("获去getAge",spy.getAge(anyInt()) + "'");

        //调用真实对象的函数
        spy.setMockName("TaioPi");
        verify(spy).setMockName("TaioPi");

介绍完成之后, 我们回到之前的问题, 为上面的代码进行测试

     public void loginApp(String name, String password){
        if (name == null || name.length() == 0) return;
        if (password == null || password.length() < 6) return;
        ligon(name, password, new NetworkCallback() {
            @Override
            public void onSuccess(String msg) {

            }

            @Override
            public void onFailure(String msg) {

            }
        });
    }

    public void ligon(String name, String password,NetworkCallback networkCallback){
        user.setName(name);
        user.setPassword(password);
        if (name.equals("TaioPi") && password.equals("123456")) {
            networkCallback.onSuccess("OK");
        }else {
            networkCallback.onFailure("FAIL");
        }
    }

测试代码

首先验证login()

     @Test
    public void testLogin ()  throws Exception{

        JUnitTest jUnitTest = mock(JUnitTest.class);
        JUnitTest.NetworkCallback networkCallback = mock(JUnitTest.NetworkCallback.class);

        doAnswer(new Answer<JUnitTest.NetworkCallback>() {
            @Override
            public JUnitTest.NetworkCallback answer(InvocationOnMock invocation) throws Throwable {
                Object[] arguments = invocation.getArguments();

                JUnitTest.NetworkCallback networkCallback = (JUnitTest.NetworkCallback) arguments[2];
                networkCallback.onFailure("500");

                return networkCallback;
            }
        }).when(jUnitTest).ligon(anyString(),anyString(),any(JUnitTest.NetworkCallback.class));

        doNothing().when(networkCallback).onFailure("500");

        jUnitTest.ligon("TaiaoPi0000", "123456", networkCallback);

        verify(jUnitTest).ligon("TaiaoPi0000","123456", networkCallback);


        //验证回调是不是执行了
//       doCallRealMethod().when(jUnitTest).ligon(anyString(),anyString(),any(JUnitTest.NetworkCallback.class));

    }

然后验证 loginApp()

    @Test
    public void testLoginApp ()  throws Exception{

        JUnitTest jUnitTest = mock(JUnitTest.class);

        //这里什么都不做   执行了就好
        doNothing().when(jUnitTest).loginApp(anyString(),anyString());

        jUnitTest.loginApp("TaiaoPi","123456");

        verify(jUnitTest).loginApp("TaiaoPi","123456");
    }

Android 开发单元测试 (Mock)