Android单元测试—UI测试(Espresso)

前言

我们先回顾一下,在上一篇博客中,主要分享了Android单元测试的逻辑测试部分。接下来,我们重点讲解Android单元测试的UI测试部分!

何为UI测试呢?就是对用户界面的交互元素进行测试,如TextViewImageView,验证其可见性,验证图片、文字是否显示正确。不过实践发现,UI测试有点像集成测试,View的状态往往对数据(网络数据、数据库SQLite或者SharedPeferences)有依赖,这就要求我们要通过Mock的形式对数据依赖进行隔离,不然就没法测试验证。在时间不太允许的情况下,我个人觉得,UI测试覆盖项目中核心或者关键的业务流程即可。依具体情况而定,界面本来就比较简单的话,感觉没有必要单元覆盖。

针对Android UI测试,主要使用谷歌推荐的测试框架Espresso,下面我们来着重介绍一下。

Espresso

根据谷歌官方介绍,Espresso最关键的优势就是它能够检测到主线程空闲状态的时候,在适当的时候运行测试代码,这样就没必要通过Thread.sleep()去让主线程睡眠的方式去同步测试。说白了,就是Espresso框架在测试app时,不会通过阻塞主线程去同步UI测试。

示例

onView(withId(R.id.my_view))         // withId(R.id.my_view) is a ViewMatcher
    .perform(click())                // click() is a ViewAction
    .check(matches(isDisplayed()));  // matches(isDisplayed()) is a ViewAssertion

简单解释一下:通过onView()方法在界面上定位到R.id.my_view这个Button,然后通过perform(click())方式在这个Button上面触发点击事件,最后通过check(matches(isDisplayed()))来检查这个Button是否还显示着。就这么简单,通过这三个步骤就完成了UI的测试工作。

UI测试三部曲

三部曲

Espresso有三个重要的类,分别是Matchers(匹配器),ViewAction(界面行为),ViewAssertions(界面判断),其中Matchers是常常是通过匹配条件来需找UI组件或过滤UI,而ViewAction是来模拟用户操作界面的行为,ViewAssertions对模拟行为操作的View进行变换和结果验证,其三者关系如图所示:

image.png

异步方法测试

Espresso官方文档有这样一段话:

Espresso测试有个很强大之处就是它在多个测试操作中是线程安全的,它会等待当前进程的消息队列中的UI事件,并且在任何一个测试操作中会等待其中的AsyncTask结束才会执行下一个测试。

也就是说,如果代码中是通过AsyncTask或者AsyncTaskCompat方式来执行异步任务,并不需要去额外的处理,只需要等待Espresso处理,它会帮助我们执行异步方法后,再执行我们的测试代码进行断言判断。

但是项目中执行异步可能不是通过AsyncTask方式,或许通过Volley、Retrofit、Thread。那么问题来了,这样的异步任务该如何测试?如果不处理的话,就会出现这样的问题,测试代码执行完毕了,但异步耗时任务可能还未执行完,那么你想在异步任务执行完后验证返回结果是否正确,好像就无能为力!就不卖关子了,现在我们就说一下解决方法吧。

1.使用IdlingResource

看过Espresso源码的同学,应该会知道,Espresso会等待AsyncTask和IdlingResource执行完毕后才会执行我们写的测试代码。这样就只需要实现Espresso提供的IdlingResource接口,就可以实现测试异步方法。具体如何实践,可以参考这个博客,但是你发现了没有,这种方式对原有的代码有侵入性。

2.使用AsyncTask提供的EXECUTOR

因为Espresso会等待AsyncTask执行完,所以我们只需要想办法把异步线程执行切换到AsyncTask所在的线程池执行,就可以测试异步任务。

(1)、Executor
使用Executor线程池来执行异步任务,那么就很简单了,使用AsyncTask.THREAD_POOL_EXECUTOR代替项目中的Executor来执行Runnable

(2)、RxJava
随着RxJava越来越流行,正是其牛逼的切换线程的功能,通过以下方式就可以让你很方便地测试RxJava异步任务:

        RxJavaPlugins.getInstance().reset();
        RxJavaPlugins.getInstance().registerSchedulersHook(new RxJavaSchedulersHook() {
            @Override
            public Scheduler getComputationScheduler() {
                return Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR);
            }

            @Override
            public Scheduler getIOScheduler() {
                return Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR);
            }

            @Override
            public Scheduler getNewThreadScheduler() {
                return Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR);
            }
        });

其他异步线程的框架如果要测试,也可以通过以上两种方式来解决。

Activity跳转

很多时候,在界面中点击一个View跳转到另外的一个Activity,我们要如何验证这个View点击之后是否跳转到正确的Activity呢?Espresso为我们提供了Intented,这个是干嘛用的呢。要先加上build.gradle配置:

    androidTestCompile ('com.android.support.test.espresso:espresso-intents:2.2.2') {
        exclude group: 'com.google.code.findbugs'
    }

Espresso-Intents记录了在测试应用时所有尝试启动的Activity。使用intent的API,类似于Mockito.verify(),你可以断言指定的intnet是否被接收。下面是一个简单的验证intent已经发出的的例子:

    @Test  
    public void validateIntentSentToPackage() {  
        //用户的动作,结果是启动一个外部的“phone”Activity  
        user.clickOnView(system.getView(R.id.callButton));  
  
        // Using a canned RecordedIntentMatcher to validate that an intent resolving  
        // to the "phone" activity has been sent.  
        //通过封装的RecordeIntentMatcher来验证作用于“phone” activity的intent已经被发送  
        intended(toPackage("com.android.phone"));  
    }  

使用intent API,类似于Mockito.when(),你可以为通过startActivityForResult()方法打开的Activity mock设置一个返回结果Intent。对于无法操控用户操作,也不能控制在测试环境下返回结果的activity尤其重要。下面来一个简单的例子:

        Uri uri = Uri.parse("content://com.android.providers.media.documents/document/image%3A1575");
        Intent imageIntent = new Intent();
        imageIntent.setData(uri);
        Instrumentation.ActivityResult imageResult = new Instrumentation.ActivityResult(Activity.RESULT_OK, imageIntent);
        intending(hasComponent(SelectImageActivity.class.getName())).respondWith(imageResult);
        testClick(R.id.progress_business_license_pic);

我来简单解释一下这个例子,点击R.id.progress_business_license_pic打开SelectImageActivity来选择图片,如上面所说,模拟用户选择图片的动作,返回imageResult携带图片地址Uri.parse("content://com.android.providers.media.documents/document/image%3A1575");

项目实践

项目中有一个信息填写的界面:

项目例子

如上图所示,这是一个很典型的用户信息界面,涉及到商户名称、商户品类、商户电话和商户地址等基本信息的填写。在UI单元测试中,我们势必关心其填写的合法性验证和非法信息的显示,以及在填写合法信息后是否可以正确的进入下一步骤。

在这里,只要所有的基本信息合法填写后,界面右上角的“下一步”按钮就会高亮显示且可以点击进入下一步,这个按钮默认是置灰的。我们就按照这种方式来验证“下一步”按钮是否可以高亮点击。但这期间会遇到两个问题:

  1. 当在“商户品类”上点击,就会触发网络请求去服务端拉取商户品类列表,所以就必须把这个异步的网络请求切换到当前线程来执行,具体方式可以参考上面,否则就遇到:测试代码执行完毕,而这个网络请求还没有执行完。
  2. 在选择“商户地址”的时候,点击会跳到地图地位的AddressActivity,然而我们希望隔离这种依赖,只针对当前界面进行测试,所以这个时候就需要intending帮我们解决这样头疼的问题,具体方式可以参考上面。
build.gradle配置

添加testInstrumentationRunner:

    defaultConfig {
        ...
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }

添加编译依赖:

dependencies {
    ...

    androidTestCompile 'com.android.support:support-annotations:23.4.0'
    androidTestCompile 'com.android.support.test:runner:0.5'
    androidTestCompile ('com.android.support.test.espresso:espresso-intents:2.2.2') {
        exclude group: 'com.google.code.findbugs'
    }
    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2') {
        exclude group: 'com.google.code.findbugs'
    }
    androidTestCompile 'org.mockito:mockito-android:2.6.3'
}
BaseEspresso基类
@LargeTest
@RunWith(AndroidJUnit4.class)
public class BaseEspresso<T extends Activity> {

    // 添加Mock拦截器
    static {
        ArrayList<Interceptor> interceptors = new ArrayList<>();
        interceptors.add(new OkHttpMockInterceptor());
        CustomClient.getInstance(interceptors);
    }

    @Rule
    public IntentsTestRule<T> mActivityRule = new IntentsTestRule<T>((Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0], true, false);

    public T mActivity = null;

    /**
     * 模拟用户的点击行为
     *
     * @param id
     */
    public void testClick(final int id) {
        onView(withId(id)).perform(closeSoftKeyboard(), click());
    }

    /**
     * 模拟用户的点击行为
     *
     * @param text
     */
    public void testClick(String text) {
        onView(withText(text)).perform(closeSoftKeyboard(), click());
    }

    /**
     * 模拟用户的点击行为
     *
     * @param id
     * @param text
     */
    public void testClick(final int id, String text) {
        onView(allOf(withId(id), withText(text))).perform(closeSoftKeyboard(), click());
    }

    /**
     * 模拟用户的点击行为
     *
     * @param id
     * @param scrollTo
     */
    public void testClick(final int id, boolean scrollTo) {
        if (scrollTo) {
            onView(allOf(withId(id))).perform(closeSoftKeyboard(), scrollTo(), click());
        } else {
            onView(allOf(withId(id))).perform(closeSoftKeyboard(), click());

        }
    }

    /**
     * 模拟用户的输入文本行为
     *
     * @param id
     * @param text
     * @return
     */
    public String testInputText(final int id, String text) {
        onView(withId(id)).perform(scrollTo(), clearText(), replaceText(text), closeSoftKeyboard());
        return text;
    }

    /**
     * 检查View的文本变化是否正确
     *
     * @param id
     * @param text
     */
    public void testTextEquals(final int id, String text) {
        onView(withId(id)).check(matches(withText(text)));
    }

    /**
     * 检查View是否可见
     *
     * @param id
     */
    public void testViewVisible(final int id) {
        onView(withId(id))
                .check(matches(isDisplayed()));
    }

    /**
     * 检查View是否可见
     *
     * @param text
     */
    public void testViewVisible(String text) {
        onView(withText(text))
                .check(matches(isDisplayed()));
    }

    /**
     * 检查View是否可见
     *
     * @param id
     * @param text
     */
    public void testViewVisible(final int id, String text) {
        onView(allOf(withId(id), withText(text)))
                .check(matches(isDisplayed()));
    }

    /**
     * 检查View是否不可见
     *
     * @param id
     */
    public void testViewUnVisible(final int id) {
        onView(withId(id))
                .check(matches(not(isDisplayed())));
    }

    /**
     * 模拟用户点击Dialog
     *
     * @param id
     */
    public void testDialogClick(int id) {
        onView(withId(id)).inRoot(isDialog())
                .check(matches(isDisplayed()))
                .perform(click());
    }

    /**
     * 模拟用户点击Dialog
     *
     * @param text
     */
    public void testDialogClick(String text) {
        onView(withText(text)).inRoot(isDialog())
                .check(matches(isDisplayed()))
                .perform(click());
    }

    /**
     * 检查View是否可用
     *
     * @param id
     */
    public void testViewEnable(int id) {
        onView(withId(id))
                .check(matches(isEnabled()));
    }

    /**
     * 检查View是否不可用
     *
     * @param id
     */
    public void testViewUnEnable(int id) {
        onView(withId(id))
                .check(matches(not(isEnabled())));
    }

    /**
     * 初始化Activity
     *
     * @return
     */
    public T getActivity() {
        return getActivity(null);
    }

    /**
     * 初始化Activity
     *
     * @return
     */
    public T getActivity(Intent intent) {
        if (intent == null) {
            intent = new Intent();
        }
        if (mActivity == null) {
            mActivityRule.launchActivity(intent);
            mActivity = mActivityRule.getActivity();
        }
        return mActivity;
    }

    /**
     * 获取可见的Fragment
     *
     * @return
     */
    public Fragment getVisibleFragment() {
        if (mActivity == null) {
            getActivity();
        }
        if (!(mActivity instanceof FragmentActivity)) {
            return null;
        }
        FragmentManager fm = ((FragmentActivity) mActivity).getSupportFragmentManager();
        if (fm == null || fm.getFragments() == null || fm.getFragments().size() == 0) {
            return null;
        }
        for (int i = fm.getFragments().size() - 1; i >= 0; --i) {
            Fragment fragment = fm.getFragments().get(i);
            if (fragment != null
                    && fragment.isResumed()
                    && fragment.isVisible()
                    && fragment.getUserVisibleHint()) {
                return fragment;
            }
        }
        return null;
    }

    /**
     * 获取除DialogFragment之外可见的Fragment
     *
     * @return
     */
    public Fragment getVisibleExcludeDialogFragment() {
        if (mActivity == null) {
            getActivity();
        }
        if (!(mActivity instanceof FragmentActivity)) {
            return null;
        }
        FragmentManager fm = ((FragmentActivity) mActivity).getSupportFragmentManager();
        if (fm == null || fm.getFragments() == null || fm.getFragments().size() == 0) {
            return null;
        }
        for (int i = fm.getFragments().size() - 1; i >= 0; --i) {
            Fragment fragment = fm.getFragments().get(i);
            if (fragment != null
                    && !(fragment instanceof DialogFragment)
                    && fragment.isResumed()
                    && fragment.isVisible()
                    && fragment.getUserVisibleHint()) {
                return fragment;
            }
        }
        return null;
    }

    /**
     * 检查Fragment是否可见
     *
     * @param type
     */
    public void testFragmentVisible(Class type) {
        Assert.assertTrue(type.isInstance(getVisibleFragment()));
    }

    /**
     * 休眠
     *
     * @param time
     */
    public void sleep(long time) {
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取字符串
     *
     * @param resId
     * @return
     */
    public String getString(int resId) {
        if (mActivity == null) {
            getActivity();
        }
        return mActivity.getString(resId);
    }

    /**
     * 在执行执行测试代码前,先登录
     */
    protected void loginAccount() {
        UserApi.getInstance().loginByPwd("13636330012", "123abc")
                .subscribe(new Subscriber<LoginResult>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(LoginResult loginResult) {
                        AuthInfo ai = OAuthManager.getInstance().getAuth();
                        ai.setSargerasToken(loginResult.getSargerasToken());
                        OAuthManager.getInstance().saveAuth(ai);
                        Store store = AppCookie.getStoreInfo();
                        store.setAccountType(loginResult.getAccountType());
                        AppCookie.saveStoreInfo(store);
                    }
                });
    }

    @Before
    public void setUp() {
        // 切换RxJava的工作线程
        RxJavaPlugins.getInstance().reset();
        RxJavaPlugins.getInstance().registerSchedulersHook(new RxJavaSchedulersHook() {
            @Override
            public Scheduler getComputationScheduler() {
                return Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR);
            }

            @Override
            public Scheduler getIOScheduler() {
                return Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR);
            }

            @Override
            public Scheduler getNewThreadScheduler() {
                return Schedulers.from(AsyncTask.THREAD_POOL_EXECUTOR);
            }
        });
        
        // 在执行测试前,执行用户登录操作,防止对用户信息有依赖
        loginAccount();
    }

    @After
    public void tearDown() {
        // 清除用户数据
        OrderSet.getInstance().clearOrder();
        OrderSet.getInstance().clearIgnoreOrder();
        PreferenceUtil.clearAll();
        OAuthManager.getInstance().clear();
    }

}
测试代码
@LargeTest
public class CreateAuthenticationActivityTest extends BaseEspresso<CreateAuthenticationActivity> {

    @Test
    public void activityTestBasic() {
        AppCookie.setTempAuthentication(null);
        Shop shop = AppCookie.getShopInfo();
        if (shop == null) {
            shop = new Shop();
        }
        int status = shop.getVerifyStatus();
        shop.setVerifyStatus(Shop.STATUS_UNAUTHORIZED);
        AppCookie.saveShopInfo(shop);

        getActivity();
        Assert.assertNotNull(mActivity);
        Fragment fragment = getVisibleFragment();
        Assert.assertTrue(fragment instanceof AuthBasicFragment);
        testViewVisible(R.id.et_retailer_name);

        Intent addressIntent = new Intent();
        FeoAddress address = new FeoAddress(true, "上海市普陀区", "真北路788号", 0, 0, false);
        addressIntent.putExtra(SearchAddressActivity.ADDRESS_ITEM, address);
        Instrumentation.ActivityResult result = new Instrumentation.ActivityResult(Activity.RESULT_OK, addressIntent);
        intending(hasComponent(SearchAddressActivity.class.getName())).respondWith(result);
        intending(hasComponent(SelectCityActivity.class.getName())).respondWith(result);

        testInputText(R.id.et_retailer_name, "测试商户");
        Assert.assertTrue(!(((AuthBasicFragment) fragment).menuItem.isEnabled()));
        testClick(R.id.tv_retailer_category_select);
        sleep(1000);
        testDialogClick(R.id.tv_completed);
        Assert.assertTrue(!(((AuthBasicFragment) fragment).menuItem.isEnabled()));
        testInputText(R.id.et_retailer_phone, "13600000000");
        Assert.assertTrue(!(((AuthBasicFragment) fragment).menuItem.isEnabled()));
        testClick(R.id.tv_retailer_poi_address);
        Assert.assertTrue(((AuthBasicFragment) fragment).menuItem.isEnabled());

        testClick(R.id.menu_auth);
        fragment = getVisibleFragment();
        Assert.assertTrue(fragment instanceof AuthCertificateFragment);
        Assert.assertTrue(!((AuthCertificateFragment) fragment).menuItem.isEnabled());

        shop = AppCookie.getShopInfo();
        shop.setVerifyStatus(status);
        AppCookie.saveShopInfo(shop);
    }

}

一键运行测试Case

// 运行src/test/路径下的Case
./gradlew testDebugUnitTest --continue

// 运行src/androidTest/路径下的Case
./gradlew connectedDebugAndroidTest --continue

通过上述两个命令就可以一键运行我们所有的测试Case,还可以把运行结果和覆盖率都展示给我们看,是不是很方便呀!

结尾

通过两个篇幅(Android单元测试实践—逻辑测试Android单元测试实践—UI测试)的方式讲述在Android环境下如何实践单元测试,主要包括MVP代码重构、代码编写时的注意点、纯Java代码测试以及Android代码测试,希望对您有帮助,要是有什么不足的地方,欢迎大家指正!最后,感谢您对本博客的关注与支持!

推荐阅读更多精彩内容