Getting Started with Mockable for Android Testing

Mock APIs and mock web services allow you to simulate the behavior of a real API or web service during testing. This is useful for several reasons, such as:

• Testing your code without relying on external dependencies
• Testing how your code handles different types of responses from an API or web service
• Testing your code in an environment that closely mirrors production

To use a mock API or web service, you'll need to set it up in your testing environment. Typically, this entails building a virtual server that mimics the real API or web service and then set it up to produce specific results in response to certain requests. After setting up the mock API or web service, you may use it in your tests the same way you would an actual API or web service.

One of the key benefits of using mock services in testing is that it allows you to isolate your tests from external dependencies. This makes running tests in a consistent, reliable environment easier, and it speeds up the discovery and resolution of problems.

In this post, we are going to learn about Mockable.

What Is Mockable?

Mockable is an Android library that allows developers to use mock objects in their local unit tests. Mock objects are test doubles that have defined interactions and behavior. They can be used to mimic the behavior of actual objects in a controlled way. This can be useful when testing code that depends on classes or methods from the Android framework, as these cannot be accessed directly in local tests.

The Mockable Android library is included with the Android Gradle plugin when you run local unit tests. It contains all the public methods and classes of the Android APIs. The methods' internal code, however, has been removed. This allows developers to build local tests that reference classes in the Android framework, such as Context, while also allowing mocking frameworks like Mockito or MockK.

How to Use Mockable or Mock Objects in an Android Unit Test

To use mock objects in an Android unit test, you should follow these steps:

• Add the Mockito library dependency to your build.gradle file. This will allow you to use Mockito's mock object creation and behavior specification functions in your tests.

    dependencies {
        testImplementation 'org.mockito:mockito-core:2.+'
      }

• Annotate your test class with @RunWith(MockitoJUnitRunner::class). This will tell the Mockito test runner to validate your framework usage and simplify the initialization of your mock objects.
  

    @RunWith(MockitoJUnitRunner::class)
    class MyTestClass {
      ...
    }

• Declare a mock object field in your test class and annotate it with @Mock. This will create a mock object of the specified type that can be used in your tests.

    class MyTestClass {
        @Mock
        private lateinit var mockObject: MyObject
      
        ...
      }

• In your test method, create an instance of the class you want to test and inject the mock object into it. You can then use the when() and thenReturn() methods to specify the behavior of the mock object.

    @Test
    fun testMethod() {
      // Given a mocked object injected into the object under test...
      val mockObject = mock<MyObject> {
          on { methodA() } doReturn "mock result"
          on { methodB(any()) } doReturn true
      }
      val objectUnderTest = ClassUnderTest(mockObject)
    
      ...
    }

• Call the method you want to test on the instance of the class under test.

    @Test
    fun testMethod() {
      ...
    
      // ...when the method with the dependency is called...
      val result = objectUnderTest.testMethod()
    
      ...
    }

• Use the assert* methods to verify that the result of the method under test is as expected.

    @Test
    fun testMethod() {
      ...
    
      // ...then the result should be as expected.
      assertEquals("Expected result", result)
    }

With these steps, you can use the Mockable Android library using the Mockito framework. We have comprehensive guides on how to approach testing Kotlin applications using MockK and how to do mock tests in Kotlin applications, if you want to learn more.

Annotations Provided by Mockito

In addition to @Test and @Mock, there are several other annotations provided by Mockito that can be useful in Android unit testing.

Here are a few:

• @Before: Methods annotated with @Before are run before each test. This can be useful for initializing common objects or setting up a particular test environment.
• @After: Methods annotated with @After are run after each test. This can be useful for cleaning up resources or resetting any changes made during a test.
• @BeforeClass: Methods annotated with @BeforeClass are run once before all tests in the class. This can be useful for performing expensive setup operations that don't need to be repeated for each test.
• @AfterClass: Methods annotated with @AfterClass are run once all tests in the class have been completed. This can be useful for de-allocating resources or performing cleanup operations.
• @InjectMocks: This annotation is used to inject mock objects into an object under test. Simply declare a field with the @InjectMocks annotation, and Mockito will inject the mock objects into that field. 
• @Spy: This annotation is used to create a spy object, which is a partially mocked object that allows you to specify the behavior of certain methods while still calling the real implementation of others. To create a spy object, simply declare a field with the @Spy annotation, and then use the doReturn() method to specify the behavior of specific methods.
• @Captor: This annotation is used to create an argument captor, which allows you to capture the arguments passed to a mock object's methods. To create an argument captor, simply declare a field with the @Captor annotation. Then use the capture() method to capture the arguments passed to the mock object's methods.

What Are Some Best Practices for Mocking Testing?

Mocking is an important part of testing components today. If done right, it’ll generate less code for you to maintain without additional cost. That's why best practices exist. Let's take a look at a few.

• Use mocking sparingly. Thus only use mocking when it's necessary to isolate a specific component or unit for testing. Misuse in mocking can lead to brittle and hard-to-maintain tests.
• Create mock objects that accurately represent the real objects they're replacing. This means using the same method signatures and returning values as the real objects. It ensures the mock objects behave similarly because test results wouldn't be accurate if the mock object behaves differently than the real object.
• Use mock objects to simulate failure. Mocking can be a valuable tool for simulating failure scenarios, such as database errors, which can be challenging to reproduce in a test environment. This helps ensure that the system is robust and can handle failures gracefully.
• Avoid hardcoding specific values into mock objects, as this can make it difficult to change the test setup later. Instead, try to use more generic values that you can easily change. This can make the tests more flexible and easier to maintain.
• Test mock objects independently. It's a good idea to test mock objects separately from the rest of the system to ensure that they behave as expected. This can help to catch any issues with the mock objects early on before they cause problems in the main system.
• Keep mock objects in sync with the real objects. As the real objects change over time, keeping the mock objects up to date is also essential. This also ensures the tests are in sync with the real objects and accurately reflect the system's behavior.

Conclusion

To streamline your Android testing process, consider using the Mockable Android library. This'll allow you to use mock objects in local unit tests and reference classes in the Android framework. By using a mocking framework like Mockito, you can specify the behavior of mock objects and ultimately build better-quality Android apps.

If you're looking to take your testing even further, consider using Waldo, the automated end-to-end testing platform trusted by leading industry developers. Waldo's Recorder allows you to easily replicate user flows and create functional tests for multiple device configurations while using Results Studio allows you to identify and fix bugs quickly. In addition, its test-chaining feature streamlines your testing process even further.