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

http://www.51testing.com/html/24/n-3722724.html

Android 单元测试实战—— 调研与选型

http://www.51testing.com/html/72/n-4462572.html

Android单元测试——逻辑测试    http://www.51testing.com/html/14/n-3720914.html

前言

　　何为UI测试呢？就是对用户界面的交互元素进行测试，如TextView、ImageView，验证其可见性，验证图片、文字是否显示正确。不过实践发现，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测试三部曲

　　三部曲

图片发自App

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

图片发自App

异步方法测试

　　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");

　项目实践

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

图片发自App

项目例子

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

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

　　当在“商户品类”上点击，就会触发网络请求去服务端拉取商户品类列表，所以就必须把这个异步的网络请求切换到当前线程来执行，具体方式可以参考上面，否则就遇到：测试代码执行完毕，而这个网络请求还没有执行完。

　　在选择“商户地址”的时候，点击会跳到地图地位的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 {

　　    // 添加Mock拦截器

　　    static {

　　        ArrayList interceptors = new ArrayList<>();

　　        interceptors.add(new OkHttpMockInterceptor());

　　        CustomClient.getInstance(interceptors);

　　    }

　　    @Rule

　　    public IntentsTestRule mActivityRule = new IntentsTestRule((Class) ((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() {

　　                    @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 {

　　    @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，还可以把运行结果和覆盖率都展示给我们看，是不是很方便呀！