业务代码

这里的LoginActivity里面的intiPresenter和initView修饰符都为public是为了方便在编写unit test的时候，可以直接从外部调用，也可以写成private，然后在test的时候使用反射。这个就看团队的规范和个人爱好吧，我个人认为编写unit test的时候，用反射也没有关系。

unit test

回到unit test-实例

在要测试的类类名点击右键就可以比较方便地创建一个Test类。

Presenter测试

回到unit test-实例

Presenter主要是对业务进行测试，测试Presenter里面的业务代码的执行结果是否符合预期。一旦发现不符合预期，则有可能编写的测试代码有问题，亦或是业务代码本身就有问题，只是没有被测出来等等。Presenter的测试代码尽量不要涉及UI测试，否则会导致整个测试类看起来非常乱。既包含业务测试，又包含UI测试。
LoginSuccessRequesterMock

object LoginSuccessRequesterMock : ILoginContact.ILoginRequester {
    override fun login(userName: String, password: String, loginListener: loginListener) {
        loginListener(LoginRequester.REQUEST_SUCCESS, LoginModel(userName, password))
    }
}

LoginFailedRequesterMock

object LoginFailedRequesterMock : ILoginContact.ILoginRequester {
    override fun login(userName: String, password: String, loginListener: loginListener) {
        loginListener(LoginRequester.REQUEST_FAILED, null)
    }
}

LoginPresenterTest

class LoginPresenterTest {
    // 这里的Presenter只有一个测试方法，所以不想要创建一个成员变量也是没问题的
    // 但考虑到大部分Presenter都至少不止一个方法，所以建议Presenter都使用成员变量
    private lateinit var presenter: LoginPresenter
    private lateinit var view: ILoginContact.ILoginView

    @Before
    fun setUp() {
        // 使用spy的目的是，为了方便测试Presenter里面的某些方法是否被调用
        presenter = Mockito.spy(LoginPresenter)
        // 由于View在这里只是负责测试逻辑是否正确，所以完全可以使用mock，无需使用spy或是new
        view = Mockito.mock(ILoginContact.ILoginView::class.java)
        presenter.addView(view)
    }

    @Test
    fun login() {
        // 方法的参数建议单独创建，方便测试
        val userName = "username"
        val password = "password"
        // 由于在Presenter里面将网络请求叫给了Requester去做，所以在编写unit test的时候
        // 就可以更方便地控制请求的结果，只需要设置了不同的Requester就行了，无需修改Presenter里面的代码
        val loginSuccessRequester = LoginSuccessRequesterMock
        val loginFailedRequester = LoginFailedRequesterMock

        // 设置请求成功的时候
        // 可以看到在LoginPresenter的Requester是：ILoginRequester，所以这种情况下就可以自由切换Requester，而不是只能LoginRequester的实现类
        presenter.requester = loginSuccessRequester
        presenter.login(userName, password)
        // 测试login方法是否被调用
        Mockito.verify(presenter).login(userName, password)
        // 测试View是否调用了showLoading
        Mockito.verify(view).showLoading(RequestType.REQUEST_LOGIN)
        // 测试View是否调用了hideLoading
        Mockito.verify(view).hideLoading(RequestType.REQUEST_LOGIN)
        // 测试loginModel是否相等
        Assert.assertEquals(presenter.loginModel, LoginModel(userName, password))
        // 测试View是否调用了onLoginSuccess
        // 这里需要注意的是：由于这里的LoginModel使用的是data class，所以会自动override toString方法
        // 并且mock额比较方式就是使用toString，所以如果发现明明代码没问题，但却测试没办法通过
        // 就可以试试手动override toString方法
        Mockito.verify(view).onLoginSuccess(LoginModel(userName, password))

        // 设置请求失败的时候
        presenter.requester = loginFailedRequester
        presenter.login(userName, password)
        // 这里，由于上面调用了1次，所以这里就变成了调用了2次，所以这种情况下就可以需要使用，VerificationMode
        // 要使用times还是atLeast就看业务需要和个人习惯吧
        Mockito.verify(presenter,Mockito.atLeast(1)).login(userName, password)
        Mockito.verify(view,Mockito.atLeast(1)).showLoading(RequestType.REQUEST_LOGIN)
        Mockito.verify(view,Mockito.atLeast(1)).hideLoading(RequestType.REQUEST_LOGIN)
        //由于请求失败，所以会调用showNetError方法，所以这里需要测试
        Mockito.verify(view).showNetError(RequestType.REQUEST_LOGIN)
    }

    @After
    fun tearDown() {
        presenter.removeView(view)
    }
}

View测试

回到unit test-实例

View测试只是测试调用特定方法之后，相应的View有没有变成和预期一样的结果。所以这里没必要编写过多的业务代码，尽可能地少编写业务代码辅助测试。所以View层的测试代码就会变得比较简单。只是会比较麻烦，因为View的很多代码对于java来说是不存在的，所以需要手动mock出来。
LoginActivityTest

class LoginActivityTest {
    private lateinit var view: LoginActivity

    @Before
    fun setUp() {
        view = Mockito.spy(LoginActivity::class.java)
    }

    @Test
    fun testPresenter() {
        // 为了提升覆盖率， 所以有一些看起来好像不相关的代码，也最好形式上调用一下
        view.initPresenter()
        val inViewPresenter = view::class.java.getDeclaredField("presenter").let {
            it.isAccessible = true
            it.get(view) as LoginPresenter
        }
        Assert.assertTrue(inViewPresenter.views.contains(view))
        view.deinitPresenter()
        Assert.assertFalse(inViewPresenter.views.contains(view))
    }

    @Test
    fun initView() {
        // 这里直接使用了view的id，这是kotlin的一个扩展库（虽然最新已废弃）
        // 使用过show kotlin bytecode的朋友应该都知道，实际上最终编译出来的代码是使用 _$_findViewCache
        // 这里一个变量来存储，所以为了保证在调用initView的时候不会出现空指针异常，需要在调用之前将所需
        // 的view设置进去
        val button = Mockito.mock(Button::class.java)
        view::class.java.getDeclaredField("_\$_findViewCache").also {
            it.isAccessible = true
            it.set(view, hashMapOf(R.id.login_btn to button))
        }
        view.initView()
        // 验证Button是否调用了setOnClickListener，由于在initView里面，使用的是匿名对象
        // 所以如果直接编写：Mockito.verify(button).setOnClickListener{}，会测试失败
        // 这个时候就可以使用Mockito.any(View.OnClickListener::class.java)来充当View.OnClickListener对象
        Mockito.verify(button).setOnClickListener(Mockito.any(View.OnClickListener::class.java))

        // 如果View是Activity，并且使用的是findViewById的方式，则可以这样做
        // val delegate = Mockito.mock(AppCompatDelegate::class.java)
        // Mockito.`when`(view.delegate).thenReturn(delegate)
        // Mockito.`when`(delegate.findViewById<View>(R.id.login_btn)).thenReturn(Mockito.mock(Button::class.java))
        // 授人以鱼不如授人以渔，我所在的团队中，View并不是使用Activity的方式
        // 上面这段代码其实是看了Activity的findViewById之后写出来的，所以如果View是以其他形式出现
        // 可以去看该对象的源码，从而找到解决出异常的办法
    }

    @Test
    fun showLoading() {
        // 这里的AppCompatImageView是随便写的，只是为了让界面有一个View测试
        // 由于java api并不存在AppCompatImageView，所以只能mock出来，这里用spy的话，会出现一堆问题
        // 所以还是用mock比较方便
        val loadingView = Mockito.mock(AppCompatImageView::class.java)
        // 说实话，每次都要写这样一段代码，其实挺烦的，建议实际开发的时候抽成一个方法
        // 实际开发中，我就编写了一个工具，这样就可以减少重复代码的编写了
        view::class.java.getDeclaredField("_\$_findViewCache").also {
            it.isAccessible = true
            it.set(view, hashMapOf(R.id.loadingview to loadingView))
        }
        // 调用view.showLoading(RequestType.REQUEST_LOGIN)，实际上会调用：loadingview.visibility = View.VISIBLE
        view.showLoading(RequestType.REQUEST_LOGIN)
        // 测试是否调用了visibility = View.VISIBLE
        Mockito.verify(loadingView).visibility = View.VISIBLE
    }

    @Test
    fun hideLoading() {
        val loadingView = Mockito.mock(AppCompatImageView::class.java)
        view::class.java.getDeclaredField("_\$_findViewCache").also {
            it.isAccessible = true
            it.set(view, hashMapOf(R.id.loadingview to loadingView))
        }
        // 如果在某些情况下，没办法使用类似上面的verify方式进行验证
        // 则可以使用这种方式辅助验证
        var visibility = -1
        Mockito.`when`(loadingView.setVisibility(View.GONE)).thenAnswer {
            if (it.arguments[0].equals(View.GONE)) {
                visibility = View.GONE
            }
        }
        view.hideLoading(RequestType.REQUEST_LOGIN)
        Assert.assertEquals(visibility, View.GONE)
    }

    @Test
    fun onLoginSuccess() {
        val textView = Mockito.mock(AppCompatTextView::class.java)
        view::class.java.getDeclaredField("_\$_findViewCache").also {
            it.isAccessible = true
            it.set(view, hashMapOf(R.id.result_tv to textView))
        }
        val model = LoginModel("u", "t")
        view.onLoginSuccess(model)
        Mockito.verify(textView).text = model.userName
    }
}

ViewModel测试

回到unit test-实例

MVP和MVVM一个比较大的区别是：MVVM使用了ViewModel对View进行更新，所以这里单独将ViewModel拿出来说明。
首先提醒一下，由于所在团队中不是使用databinding+viewmodel，所以不清楚如果代码这样写，test要怎么做，所以不提供相关示例。

TestViewModelActivity

class TestViewModelActivity : AppCompatActivity() {
    private lateinit var viewModel: TestViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_test_view_model)
        viewModel = initViewModel()
        bindViewModel()
        setData()
    }

    fun initViewModel(): TestViewModel = ViewModelProvider(this)[TestViewModel::class.java]

    fun bindViewModel() {
        viewModel.text.observe(this) {
            textView.text = it
        }
    }

    fun setData() {
        viewModel.text.value = "test test test"
    }
}

TestViewModelActivityTest

class TestViewModelActivityTest {
    private lateinit var activity: TestViewModelActivity

    // 可以尝试把这行代码去掉，会发现测试setData方法的时候出现空指针异常
    // 因为LiveData最终通知数据更新离不开Handler，但这是Android的，所以google用了这个来解决这个问题
    @get:Rule
    val rule: TestRule = InstantTaskExecutorRule()

    @Before
    fun setUp() {
        activity = Mockito.spy(TestViewModelActivity())
    }

    @Test
    fun setData() {
        val viewModel = TestViewModel()
        // 塞一个ViewModel进去
        activity::class.java.getDeclaredField("viewModel").also {
            it.isAccessible = true
            it.set(activity, viewModel)
        }
        activity.bindViewModel()
        // 比较遗憾的是：调用这之后并不会执行Observer里面的代码
        activity.setData()
        // 但可以通过观察viewModel里面的变量的value来确实测试有没有通过
        Assert.assertEquals(viewModel.text.value, "test test test")
    }
}