If you are implementing a local Service as a component of
your app, you should test the Service to ensure that it doesn't behave in an
unexpected way. You can create
instrumented unit tests to verify that the behavior in the Service
is correct; for example, the service stores and returns valid data values and performs
data operations correctly.
AndroidX Test provides an API for
testing your Service objects in isolation. The
ServiceTestRule
class is a JUnit 4 rule that starts your service before your unit test methods
run, and shuts down the service after tests complete. By using this test rule, you ensure that the
connection to the service is always established before your test method runs. To
learn more about JUnit 4 rules, see the JUnit documentation.
Note: The
ServiceTestRule
class does not support testing of IntentService objects.
If you need to test a IntentService object, you should encapsulate the logic
in a separate class and create a corresponding unit test instead.
Set up your testing environment
Before building your integration test for the service, make sure to configure your project for instrumented tests, as described in Set up project for AndroidX Test.
Create an integration test for services
Your integration test should be written as a JUnit 4 test class. To learn more about creating JUnit 4 test classes and using JUnit 4 assertion methods, see Create an instrumented unit test class.
To create an integration test for your service, add the @RunWith(AndroidJUnit4::class)
annotation at the beginning of your test class definition. You also need to specify the
AndroidJUnitRunner class that AndroidX Test provides
as your default test runner. This step is described in more detail in
Run Instrumented Unit Tests.
Next, create a
ServiceTestRule
instance in your test by using the @Rule annotation.
Kotlin
@get:Rule val serviceRule = ServiceTestRule()
Java
@Rule public final ServiceTestRule serviceRule = new ServiceTestRule();
The following example shows how you might implement an integration test for a service.
The test method testWithBoundService verifies that the app binds successfully to a
local service and that the service interface behaves correctly.
Kotlin
@Test
@Throws(TimeoutException::class)
fun testWithBoundService() {
// Create the service Intent.
val serviceIntent = Intent(
ApplicationProvider.getApplicationContext<Context>(),
LocalService::class.java
).apply {
// Data can be passed to the service via the Intent.
putExtra(SEED_KEY, 42L)
}
// Bind the service and grab a reference to the binder.
val binder: IBinder = serviceRule.bindService(serviceIntent)
// Get the reference to the service, or you can call
// public methods on the binder directly.
val service: LocalService = (binder as LocalService.LocalBinder).getService()
// Verify that the service is working correctly.
assertThat(service.getRandomInt(), `is`(any(Int::class.java)))
}
Java
@Test
public void testWithBoundService() throws TimeoutException {
// Create the service Intent.
Intent serviceIntent =
new Intent(ApplicationProvider.getApplicationContext(),
LocalService.class);
// Data can be passed to the service via the Intent.
serviceIntent.putExtra(LocalService.SEED_KEY, 42L);
// Bind the service and grab a reference to the binder.
IBinder binder = serviceRule.bindService(serviceIntent);
// Get the reference to the service, or you can call
// public methods on the binder directly.
LocalService service =
((LocalService.LocalBinder) binder).getService();
// Verify that the service is working correctly.
assertThat(service.getRandomInt()).isAssignableTo(Integer.class);
}
Run integration tests for services
You can run integration tests from Android Studio or
from the command-line. Make sure to specify
AndroidJUnitRunner as the default instrumentation runner in your project.
To run the integration test for your service, follow the steps for running instrumented tests described in Getting started with testing.
You should also read about Services.
Additional resources
To learn more about this topic, consult the following additional resources.