Diego Torres Milano's blog: December 2009

Android Testing: ContentProvider integration test using mock content

This document can be read in Google Docs (http://docs.google.com/View?id=ddwc44gs_221tm2kqmgp), cut and paste link if you have problems accessing it.

introduction
mocking content provider operations
1. android-mock
examples
1. content provider unit tests
2. activity and content provider functional tests
conclusion

introduction

Your application uses a ContentProvider maybe from more than one Activity. You have unit-tested the ContentProvider already using ProviderTestCase2 and in some cases implementing a RenamingDelegatingContext.

But when we try to produce functional or integration tests of your Activities against your ContentProvider it's not so evident what test case to use. The most obvious choice is ActivityInstrumentationTestCase2 mainly if your functional tests simulate user experience because you may need sendKeys() or similar methods, which are readily available on these tests.

The first problem you may encounter is that's no clear where to inject a MockContentResolver in your test to be able to use a test database instance or database fixture with your ContentProvider. There's no way to inject a MockContext either.

We have visited Mock Objects before and evaluated Test Driven Development. You may want to take a look if you are not familiar with mock objects on Android.

An alternative approach to this problem is introduced by tenacious33 in Android functional testing with MockContext.

mocking content provider operations

In order to create an ActivityInstrumentationTestCase2 and be able to mock content provider operations and optionally use a database fixture we need a different approach.

Download:

Binaries and source code of android-mock and MockContentResolverActivity main and test sample projects can be downloaded from http://sites.codtech.com/android/Home/source-code

android-mock

android-mock is a library encapsulating some of the needed functionality to simplify functional and integration tests of activities that use content providers.

We are introducing the library here and we will be presenting a practical example later.

This is the UML Class Diagram of the library. Green classes belong to android library.

ActivityAndContentProviderInstrumentationTestCase2<T extends Activity, P extends ContentProvider>

This is a functional or integration test of an Activity that uses a MockContextWithMockContentResolver context and uses the specified ContentProvider under tests.

You should extend this class to create your tests and everything will be setup automatically.

During the setup process the abstract method createDatabaseFixture(Context mockContext) is invoked to give you the opportunity of creating your database fixture.

The last step of the setup process invokes your Activity's onCreate() method.

MockContextWithMockContentResolver<P extends ContentProvider>

A mock context, with a mock content resolver using the specified ConentProvider under test. The mock context is a RenamingDelegatingContext that renames file and database operations prefixing them with "test." by default.

This provides a way to inject a ContentResolver into an ActivityAndContentProviderInstrumentationTestCase2 permitting the introduction of database fixtures.

GenericMockContentResolver<P extends ConentProvider>

A generic mock content resolver using the specified ConentProvider under test. This content resolver uses the specified content provider to resolve data for authority.

examples

To demonstrate the use of this library we have an Activity that presents some data using a ContentProvider. They are very simple an similar to other examples with the same functionality. In this case we are using a content provider with authority on a simple table Samples.AUTHORITY.

Our Activity in the following example is MyMockContentResolverActivity and the content provider is MyContentProvider.

We will concentrate now on the tests.

content provider unit tests

This tests will be as usual implemented using ProviderTestCase2<P>. This is pretty standard so we are not pay much attention to it.

activity and content provider functional tests

We reach the point. MyMockContentResolverActivityTests class implements the tests extending ActivityAndContentProviderInstrumentationTestCase2 and specifying the Activity and ContentProvider under test as well as the authority, Samples.AUTHORITY in this particular example.

These tests can be run completely isolated from real data, so you can be confident and exercise your database through your Activity not worrying about your real data.

    









              /*
 * Copyright © 2009 COD Technologies Ltd.  www.codtech.com
 * 
 * $Id$
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.codtech.android.training.mockcontentresolver.examples.test;

import android.app.Activity;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.util.Log;
import android.view.KeyEvent;
import android.widget.TextView;

import com.codtech.android.mock.ActivityAndContentProviderInstrumentationTestCase2;
import com.codtech.android.training.mockcontentresolver.examples.MyMockContentResolverActivity;
import com.codtech.android.training.mockcontentresolver.examples.provider.MyContentProvider;
import com.codtech.android.training.mockcontentresolver.examples.provider.Samples;

public class MyMockContentResolverActivityTests extends
		ActivityAndContentProviderInstrumentationTestCase2<MyMockContentResolverActivity,
                    MyContentProvider> {

	private static final String TEST_CASE_1 = "test case 1";
	private static final String TAG = "MyMockContentResolverActivityTests2";

	public MyMockContentResolverActivityTests(String name) {
		super(MyMockContentResolverActivity.class.getPackage().getName(),
                    MyMockContentResolverActivity.class, MyContentProvider.class,
                    Samples.AUTHORITY);
		setName(name);
	}

	@Override
	public void createDatabaseFixture(Context mockContext) {
		final ContentResolver cr = mockContext.getContentResolver();
		cr.delete(Samples.CONTENT_URI, " 1 = 1 ", null);
		final ContentValues cv = new ContentValues();
		cv.put(Samples.NAME, TEST_CASE_1);
		final Uri uri = cr.insert(Samples.CONTENT_URI, cv);
		assertNotNull(uri);
	}

	public void testDatabaseFixture() {
		final Activity activity = getActivity();
		final ContentResolver cr = activity.getContentResolver();
		final Cursor c = cr.query(Samples.CONTENT_URI, new String[] { Samples._ID },
                    null, null, null);
		assertTrue(c.getCount() != 0);
		c.close();
	}
	
	public void testSimpleCreate() {
		final Activity activity = getActivity();
		assertNotNull(activity);
		final TextView tv = (TextView) activity.findViewById(
                    com.codtech.android.training.mockcontentresolver.examples.R.id.TextView01);
		assertNotNull(tv);
	}

	public void testDatabaseTestCase1() {
		final Activity activity = getActivity();
		assertNotNull(activity);
		TextView tv = (TextView) activity.findViewById(
                    com.codtech.android.training.mockcontentresolver.examples.R.id.TextView01);
		assertNotNull(tv);
		assertEquals("Cursor returns 1 row\n" + TEST_CASE_1, tv.getText().toString());
		sendKeys(KeyEvent.ACTION_DOWN);
	}
}
      
    
  

createDatabaseFixture

Firstly, the database is cleaned up to start the test from a know base. Strictly speaking this could not be necessary but we prefer to err on the safe side.

Secondly, a single row is inserted to materialize our fixture.

Remember this is an abstract method in ActivityAndContentProviderInstrumentationTestCase2.

testDatabaseFixture

Simple test, just to verify that our database fixture is correct.

testSimpleCreate

Verify that our Activity has been created correctly and everything is in place.

testDatabaseTestCase1

Functional test, we verify the data presented in the Activity, check that the information is the expected one and finally we send key events simulating user interaction.

In this test we are not using the ContentResolver nor the database directly and we see everything from the Activity's perspective.

conclusion

Though this is an oversimplified example it shows the most important concepts behind android-mock library classes and how you can implement your tests relying on it.

Comments are gladly welcome.

We are now applying all the techniques discussed in previous posts to test our android projects.

However, all the projects reviewed were so simple that no one used external libraries so we never faced the problem of using them from our tests.

In this example we are using a dummy external library we have called libdummy-0.0.1-SANPSHOT.jar. In our Activity we are creating an object from one of the library's classes.

When we write the tests and we need to resolve the references to that objects we may feel tempted to include libdummy in test project's external jars, but doing so

[2009-12-07 16:01:14 - TCTDD11Test]Launching instrumentation android.test.InstrumentationTestRunner on device emulator-5554
[2009-12-07 16:01:25 - TCTDD11Test]Test run failed: Class ref in pre-verified class resolved to unexpected implementation
[2009-12-07 16:01:25 - TCTDD11Test]Test run complete

we receive the previous error.

The solution is to export the external jar from the main project. Open project Properties and edit Java Build Path to include the external library

and export it to be contributed to dependent test project

and this will cause no problems running the tests.

Update: Android Compatibility library: Testing Fragments
The aforementioned solution can also be applied to the android-support.jar, the library needed to support Fragments in pre-Honeycomb versions. As before, this should be exported in the main project and used in tests.

Hope this helps.

Update: Using ant

Sometimes you may want to use ant to build your projects, for example when you are building using a Continuous Integration server like Hudson, Jenkins, Bamboo, CruiseControl or similar.

To achieve this goal the easiest way is to update the main and test projects using the android update project and android update test-project commands.

The missing step using this approach is the inclusion of the external libraries we used in our previous examples. In the libs directory of the main project include the used libraries. It's preferable to create symbolic links so they are automatically updated if you update the libraries by any mean.

This is how the libs directory will look like:

$ ls -l libs
total 16
lrwxr-xr-x 1 diego staff 82 1 Aug 18:13 android-support-v4.jar -> ../../../../opt/android-sdk/extras/android/compatibility/v4/android-support-v4.jar
lrwxr-xr-x 1 diego staff 46 1 Aug 18:29 libdummy-0.0.1-SNAPSHOT.jar -> ../../libdummy/lib/libdummy-0.0.1-SNAPSHOT.jar

Having done so, you will be able to create you application using ant debug and run the tests by ant run-tests and the libraries will be automatically included in the test project.

Diego Torres Milano's blog

Tuesday, December 22, 2009

Android Testing: ContentProvider integration tests using mock con