AndroidTesting: Mock Context
Continuing with our Android Testing series, we take a short detour before we proceed to create more unit and functional tests.
We have visited Mock Objects before and evaluated our Test Driven Development purism and the concerns about not using real objects, but this is another discussion.
Sometimes, introducing mock objects in our tests is recommended, desirable, useful or even unavoidable.
Android SDK provides some classes to help us in this quest in the package android.test.mock:
MockApplication: A mock Application class
MockContentResolver A mock ContentResolver class that isolates the test code from the real content system
MockContext A mock Context class
MockDialogInterface A mock DialogInterface class
MockPackageManager A mock PackageManager class
MockResources A mock Resources class
mock context overview
Mock Context class implements all methods in a non-functional way and throw UnsopportedOperationException.
This can be used to inject other dependencies, mocks, or monitors into the classes under testing. A fine control can be obtained extending this class.
Extend this class to provide your desired behaviour overriding the correspondent methods.
mocking file and database operations
In some cases, all we need is to be able to mock the file and database operations. For example, if we are testing the application on a real device perhaps we don't want to affect existing files during our tests.
Such cases can take advantage of another class that is not part of the android.test.mock package but of android.test instead, that is RenamingDelegatingContext. I think it belongs to the former but it is in the parent package for apparently no reason.
This class let us mock operations and files and databases are prefixed by a prefix that is specified in the constructor. All other operations are delegated to the delegating Context that you must specify in the constructor too.
Suppose our Activity under test uses some files we want to control in some way, maybe introducing specialised content to drive our tests and we don't want or we can't use the real files, in this case we create a RenamingDelegatingContext specifying a pefix, we provide that files, and our unchanged Activity will use them.
Our Activity under test, MockContextExamplesActivity, displays the content of a file inside a TextView, what we intend is to be able to display different content during a test than during normal operation of the Activity.
MockContextExamplesActivity.java
A very simple Activity. Shows the content of the file myfile.txt inside a TextView.
package com.codtech.android.training.mockcontext.examples; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import android.app.Activity; import android.graphics.Color; import android.os.Bundle; import android.widget.TextView; public class MockContextExamplesActivity extends Activity { public final static String FILE_NAME = "myfile.txt"; private TextView tv; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); tv = (TextView) findViewById(R.id.TextView); final byte[] buffer = new byte[1024]; try { final FileInputStream fis = openFileInput(FILE_NAME); final int n = fis.read(buffer); tv.setText(new String(buffer, 0, n-1)); } catch (Exception e) { tv.setText(e.toString()); tv.setTextColor(Color.RED); } } public String getText() { return tv.getText().toString(); } } |
MyMockContext.java
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import android.content.Context; import android.test.RenamingDelegatingContext; import android.util.Log; /** * @author diego * */ public class MyMockContext extends RenamingDelegatingContext { private static final String TAG = "MyMockContext"; private static final String MOCK_FILE_PREFIX = "test."; /** * @param context * @param filePrefix */ public MyMockContext(Context context) { super(context, MOCK_FILE_PREFIX); makeExistingFilesAndDbsAccessible(); } /* (non-Javadoc) * @see android.test.RenamingDelegatingContext#openFileInput(java.lang.String) */ @Override public FileInputStream openFileInput(String name) throws FileNotFoundException { Log.d(TAG, "actual location of " + name + " is " + getFileStreamPath(name)); return super.openFileInput(name); } /* (non-Javadoc) * @see android.test.RenamingDelegatingContext#openFileOutput(java.lang.String, int) */ @Override public FileOutputStream openFileOutput(String name, int mode) throws FileNotFoundException { Log.d(TAG, "actual location of " + name + " is " + getFileStreamPath(name)); return super.openFileOutput(name, mode); } } |
test.myfile.txt
We also need to provide at least the text file containing the sample text.
The directory where these files are located is created during package installation, so you may want to wait till you install the package for the first time to run this command.
Notice that we are using a "test." prefix in this file creation as we did in our MyMockContext class.
To do this just run this command:
diego@bruce:\~$ adb shell echo "This is sample text" \ \> /data/data/com.codtech.android.training.mockcontext.examples/files/test.myfile.txt |
Remember to change package name if you are using a different one.
If you also want to create some real context to be displayed by the Activity use this command:
diego@bruce:\~$ adb shell echo "This is REAL text" \ \> /data/data/com.codtech.android.training.mockcontext.examples/files/myfile.txt |
Notice that here there's no "test." prefix because it's the real file.
MockContextExamplesTest.java
Now when we create some tests we can use this mock context.
import android.content.Context; import android.content.Intent; import android.test.ActivityUnitTestCase; import com.codtech.android.training.mockcontext.examples.MockContextExamplesActivity; /** * @author diego * */ public class MockContextExamplesTests extends ActivityUnitTestCase<MockContextExamplesActivity> { public MockContextExamplesTests() { super(MockContextExamplesActivity.class); } /** * @throws java.lang.Exception */ protected void setUp() throws Exception { } /** * @throws java.lang.Exception */ protected void tearDown() throws Exception { } public void testSampleTextDisplayed() { // mock context Context mockContext = new MyMockContext(getInstrumentation().getTargetContext()); setActivityContext(mockContext); startActivity(new Intent(), null, null); final MockContextExamplesActivity activity = getActivity(); assertNotNull(activity); assertEquals("This is sample text", activity.getText()); } public void testRealTextDisplayed() { // real context setActivityContext(getInstrumentation().getTargetContext()); startActivity(new Intent(), null, null); final MockContextExamplesActivity activity = getActivity(); assertNotNull(activity); assertFalse("This is sample text".equals(activity.getText())); } } |
Conclusion
Though this is an oversimplified example it shows the most important concepts behind Mock Contexts and the way you can use Delegating Context to isolate your Activity from other parts of the system like the filesystem in this case.
Copyright © 2009 Diego Torres Milano. All rights reserved.
