gecko/mobile/android/base/tests/ContentProviderTest.java.in

253 lines
9.2 KiB
Java

#filter substitution
package @ANDROID_PACKAGE_NAME@.tests;
import @ANDROID_PACKAGE_NAME@.*;
import android.content.ContentProvider;
import android.content.ContentProviderClient;
import android.content.ContentValues;
import android.content.Context;
import android.content.ContentProviderResult;
import android.content.ContentProviderOperation;
import android.content.OperationApplicationException;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.content.pm.ApplicationInfo;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.os.Build;
import android.net.Uri;
import android.test.AndroidTestCase;
import android.test.IsolatedContext;
import android.test.ProviderTestCase2;
import android.test.RenamingDelegatingContext;
import android.test.mock.MockContentResolver;
import android.test.mock.MockContext;
import android.util.Log;
import java.io.File;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
/*
* ContentProviderTest provides the infrastructure to run content provider
* tests in an controlled/isolated environment, guaranteeing that your tests
* will not affect or be affected by any UI-related code. This is basically
* a heavily adapted port of Android's ProviderTestCase2 to work on Mozilla's
* infrastructure.
*
* For some tests, we need to have access to UI parts, or at least launch
* the activity so the assets with test data become available, which requires
* that we derive this test from BaseTest and consequently pull in some more
* UI code than we'd ideally want. Furthermore, we need to pass the
* Activity and not the instrumentation Context for the UI part to find some
* of its required resources.
* Similarly, we need to pass the Activity instead of the Instrumentation
* Context down to some of our users (still wrapped in the Delegating Provider)
* because they will stop working correctly if we do not. A typical problem
* is that databases used in the ContentProvider will be attempted to be
* opened twice.
*/
abstract class ContentProviderTest extends BaseTest {
protected ContentProvider mProvider;
protected MockContentResolver mResolver;
protected ClassLoader mClassLoader;
protected ArrayList<Runnable> mTests;
protected Class mProviderClass;
protected Class mProviderContract;
protected String mProviderAuthority;
protected IsolatedContext mProviderContext;
private class ContentProviderMockContext extends MockContext {
@Override
public Resources getResources() {
// We will fail to find some resources if we don't point
// at the original activity.
return ((Context)getActivity()).getResources();
}
@Override
public String getPackageResourcePath() {
return getInstrumentation().getContext().getPackageResourcePath();
}
@Override
public File getDir(String name, int mode) {
return getInstrumentation().getContext().getDir(this.getClass().getSimpleName() + "_" + name, mode);
}
@Override
public Context getApplicationContext() {
return this;
}
@Override
public SharedPreferences getSharedPreferences(String name, int mode) {
return getInstrumentation().getContext().getSharedPreferences(name, mode);
}
@Override
public ApplicationInfo getApplicationInfo() {
return getInstrumentation().getContext().getApplicationInfo();
}
}
private class DelegatingTestContentProvider extends ContentProvider {
ContentProvider mTargetProvider;
public DelegatingTestContentProvider(ContentProvider targetProvider) {
super();
mTargetProvider = targetProvider;
}
private Uri appendTestParam(Uri uri) {
try {
return appendUriParam(uri, "PARAM_IS_TEST", "1");
} catch (Exception e) {}
return null;
}
@Override
public boolean onCreate() {
return mTargetProvider.onCreate();
}
@Override
public String getType(Uri uri) {
return mTargetProvider.getType(uri);
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
return mTargetProvider.delete(appendTestParam(uri), selection, selectionArgs);
}
@Override
public Uri insert(Uri uri, ContentValues values) {
return mTargetProvider.insert(appendTestParam(uri), values);
}
@Override
public int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs) {
return mTargetProvider.update(appendTestParam(uri), values,
selection, selectionArgs);
}
@Override
public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
return mTargetProvider.query(appendTestParam(uri), projection, selection,
selectionArgs, sortOrder);
}
@Override
public ContentProviderResult[] applyBatch (ArrayList<ContentProviderOperation> operations)
throws OperationApplicationException {
return mTargetProvider.applyBatch(operations);
}
@Override
public int bulkInsert(Uri uri, ContentValues[] values) {
return mTargetProvider.bulkInsert(appendTestParam(uri), values);
}
}
private void setUpProviderClassAndAuthority(String providerClassName,
String authorityField) throws Exception {
mProviderContract = mClassLoader.loadClass("org.mozilla.gecko.db.BrowserContract");
mProviderAuthority = (String) mProviderContract.getField(authorityField).get(null);
mProviderClass = mClassLoader.loadClass(providerClassName);
}
private void setUpContentProvider() throws Exception {
mResolver = new MockContentResolver();
final String filenamePrefix = this.getClass().getSimpleName() + ".";
RenamingDelegatingContext targetContextWrapper =
new RenamingDelegatingContext(
new ContentProviderMockContext(),
(Context)getActivity(),
filenamePrefix);
mProviderContext = new IsolatedContext(mResolver, targetContextWrapper);
ContentProvider targetProvider = (ContentProvider) mProviderClass.newInstance();
targetProvider.attachInfo(mProviderContext, null);
mProvider = new DelegatingTestContentProvider(targetProvider);
mProvider.attachInfo(mProviderContext, null);
mResolver.addProvider(mProviderAuthority, mProvider);
}
public Uri getContentUri(String className) throws Exception {
return getUriColumn(className, "CONTENT_URI");
}
public Uri getUriColumn(String className, String columnId) throws Exception {
Class aClass = mClassLoader.loadClass("org.mozilla.gecko.db.BrowserContract$" + className);
return (Uri) aClass.getField(columnId).get(null);
}
public String getStringColumn(String className, String columnId) throws Exception {
Class aClass = mClassLoader.loadClass("org.mozilla.gecko.db.BrowserContract$" + className);
return (String) aClass.getField(columnId).get(null);
}
public int getIntColumn(String className, String columnId) throws Exception {
Class aClass = mClassLoader.loadClass("org.mozilla.gecko.db.BrowserContract$" + className);
Integer intColumn = (Integer) aClass.getField(columnId).get(null);
return intColumn.intValue();
}
public Uri appendUriParam(Uri uri, String paramName, String value) throws Exception {
String param = (String) mProviderContract.getField(paramName).get(null);
return uri.buildUpon().appendQueryParameter(param, value).build();
}
public void setTestName(String testName) {
mAsserter.setTestName(this.getClass().getName() + " - " + testName);
}
public void setUp() throws Exception {
throw new Exception("You should call setUp(providerClassName, authorityUriField) instead");
}
public void setUp(String providerClassName, String authorityUriField) throws Exception {
super.setUp();
mClassLoader = getInstrumentation().getContext().getClassLoader();
mTests = new ArrayList<Runnable>();
setUpProviderClassAndAuthority(providerClassName, authorityUriField);
setUpContentProvider();
}
public void tearDown() throws Exception {
if (Build.VERSION.SDK_INT >= 11) {
mProvider.shutdown();
}
String databaseName = null;
try {
Method getDatabasePath =
mProviderClass.getDeclaredMethod("getDatabasePath", String.class, boolean.class);
String defaultProfile = "default";
databaseName = (String) getDatabasePath.invoke(mProvider, defaultProfile, true /* is test */);
} catch (Exception e) {}
if (databaseName != null)
mProviderContext.deleteDatabase(databaseName);
super.tearDown();
}
public AssetManager getAssetManager() {
return getInstrumentation().getContext().getAssets();
}
}