andorid ui自动化测试4种策略

by Mona El Mahdy 

Overview 

This post reviews four strategies for Android UI testing with the goal of creating UI tests that are fast, reliable, and easy to debug.

Before we begin, let’s not forget an import rule: whatever can be unit tested should be unit tested.  Robolectric and gradle unit tests support are great examples of unit test frameworks for Android. UI tests, on the other hand, are used to verify that your application returns the correct UI output in response to a sequence of user actions on a device.  Espresso is a great framework for running UI actions and verifications in the same process. For more details on the Espresso and UI Automator tools, please see:  test support libraries. 

The Google+ team has performed many iterations of UI testing. Below we discuss the lessons learned during each strategy of UI testing. Stay tuned for more posts with more details and code samples. 

Strategy 1: Using an End-To-End Test as a UI Test 

Let’s start with some definitions. A  UI test ensures that your application returns the correct UI output in response to a sequence of user actions on a device. An  end-to-end (E2E) test brings up the full system of your app including all backend servers and client app. E2E tests will guarantee that data is sent to the client app and that the entire system functions correctly. 

Usually, in order to make the application UI functional, you need data from backend servers, so UI tests need to simulate the data but not necessarily the backend servers. In many cases UI tests are confused with E2E tests because E2E is very similar to manual test scenarios. However, debugging and stabilizing E2E tests is very difficult due to many variables like network flakiness, authentication against real servers, size of your system, etc. 


When you use UI tests as E2E tests, you face the following problems:

• Very large and slow tests. 
• High flakiness rate due to timeouts and memory issues. 
• Hard to debug/investigate failures. 
• Authentication issues (ex: authentication from automated tests is very tricky).

Let’s see how these problems can be fixed using the following strategies.

Strategy 2: Hermetic UI Testing using Fake Servers

In this strategy, you avoid network calls and external dependencies, but you need to provide your application with data that drives the UI. Update your application to communicate to a local server rather than external one, and create a fake local server that provides data to your application. You then need a mechanism to generate the data needed by your application. This can be done using various approaches depending on your system design. One approach is to record server responses and replay them in your fake server. 

Once you have hermetic UI tests talking to a local fake server, you should also have  server hermetic tests. This way you split your E2E test into a server side test, a client side test, and an integration test to verify that the server and client are in sync (for more details on integration tests, see the backend testing section of  blog). 

Now, the client test flow looks like: 


While this approach drastically reduces the test size and flakiness rate, you still need to maintain a separate fake server as well as your test. Debugging is still not easy as you have two moving parts: the test and the local server. While test stability will be largely improved by this approach, the local server will cause some flakes. 

Let’s see how this could this be improved... 

Strategy 3: Dependency Injection Design for Apps. 

To remove the additional dependency of a fake server running on Android, you should use dependency injection in your application for swapping real module implementations with fake ones. One example is  Dagger, or you can create your own dependency injection mechanism if needed. 

This will improve the testability of your app for both unit testing and UI testing, providing your tests with the ability to mock dependencies. In  instrumentation testing, the test apk and the app under test are loaded in the same process, so the test code has runtime access to the app code. Not only that, but you can also use classpath override (the fact that test classpath takes priority over app under test) to override a certain class and inject test fakes there. For example, To make your test hermetic, your app should support injection of the networking implementation. During testing, the test injects a fake networking implementation to your app, and this fake implementation will provide seeded data instead of communicating with backend servers.


Strategy 4: Building Apps into Smaller Libraries 

If you want to scale your app into many modules and views, and plan to add more features while maintaining stable and fast builds/tests, then you should build your app into small components/libraries. Each library should have its own UI resources and user dependency management. This strategy not only enables mocking dependencies of your libraries for hermetic testing, but also serves as an experimentation platform for various components of your application. 

Once you have small components with dependency injection support, you can build a test app for each component. 

The test apps bring up the actual UI of your libraries, fake data needed, and mock dependencies. Espresso tests will run against these test apps. This enables testing of smaller libraries in isolation. 

For example, let’s consider building smaller libraries for login and settings of your app. 


The settings component test now looks like: 


Conclusion 

UI testing can be very challenging for rich apps on Android. Here are some UI testing lessons learned on the Google+ team:

1. Don’t write E2E tests instead of UI tests. Instead write unit tests and integration tests beside the UI tests. 
2. Hermetic tests are the way to go. 
3. Use dependency injection while designing your app. 
4. Build your application into small libraries/modules, and test each one in isolation. You can then have a few integration tests to verify integration between components is correct . 
5. Componentized UI tests have proven to be much faster than E2E and 99%+ stable. Fast and stable tests have proven to drastically improve developer productivity.