我如何在 Android 应用程序中模拟 REST 后端

Question

My android app communicate with backend service through REST API . I want to mock out this API to quickly develop the front end. I am using android volley as client side networking library.

Answer 1

You can use the dependency injection design pattern for this.

Basically you specify an interface that defines a set of methods corresponding to the queries you have in your REST backend, eg:

interface DataSupplier {
    // Lookup user by ID
    User getUser(int id);

    // Get all blog posts posted by a specific user.
    List<BlogPost> getUsersBlogPosts(int userId);
}

Now in the class where you need to query the backend, you specify an injector. This can be done in multiple ways (eg constructor injection, setter injection - see the wiki article for more details). An injector lets you inject an implementation of the dependency into the class that depends on it. Let us assume you use constructor injection. Your class that uses the backend would look like this:

public class DependentClass {

    private final DataSupplier mSupplier;

    public DependentClass(DataSupplier dataSupplier) {
        mSupplier = dataSupplier;
    }

    // Now you simply call mSupplier whenever you need to query the mock
    // (or - later in development - the real) REST service, e.g.:
    public void printUserName() {
        System.out.println("User name: " + mSupplier.getUser(42).getName());
    }
}

Then you create a mock implementation of DataSupplier :

public class MockRestService implements DataSupplier {

    @Override
    public User getUser(int id) {
        // Return a dummy user that matches the given ID
        // with 'Alice' as the username.
        return new User(id, "Alice");
    }

    @Override
    public List<BlogPost> getUsersBlogPosts(int userId) {
        List<BlogPost> result = new ArrayList<BlogPost>();
        result.add(new BlogPost("Some Title", "Some body text"));
        result.add(new BlogPost("Another Title", "Another body text"));
        result.add(new BlogPost("A Third Title", "A third body text"));
        return result;
    }
}

and use that to instantiate your dependent class:

DepedentClass restClient = new DepedentClass(new MockRestService());

Now you can use restClient as if it was connected to your actual backend. It will simply return dummy objects that you can use to develop your front end.

When you are done with your front end and ready to implement your backend, you do so by creating another implementation of DataSupplier that sets up a connection to your REST backend and queries it for real objects. Let us say you name this implementation RestService . Now you can simply replace the constructor creating the MockRestService with your RestService constructor like so:

DepedentClass restClient = new DepedentClass(new RestService());

And there you have it: by swapping a single constructor call, you can change your front end code from using dummy objects to using real REST-delivered objects. You could even have a debug flag and create the restClient according to the state of your application (debug or release):

boolean debug = true;
DependentClass restClient = null;
if (debug) {
    restClient = new DepedentClass(new MockRestService());
} else {
    restClient = new DepedentClass(new RestService());
}

Answer 2

I've recently created RESTMock . It is a library for Mocking REST API's in android tests. It can be used during development though. You would need to set it up following the README on github and create a basic Android Instrumentation test that would start your app and do nothing. This way the app is started with the Mock Server in background.

Example test:

public class SmokeTest {
    @Rule public ActivityTestRule<MainActivity> rule = new ActivityTestRule<MainActivity>(
            SplashActivity.class,
            true,
            false);


    @Test
    public void smokeTest() throws InterruptedException {
        rule.launchActivity(null);
        Thread.sleep(10000000);
    }
}