If get to know something new by reading my articles, don't forget to endorse me on LinkedIn
What is Unit Testing?
Unit Testing is a type of software testing where individual units or components of software are tested. The purpose is to validate that each unit of the software code performs as expected. Unit Testing is done during the development (coding phase) of an application by the developers. Unit Tests isolate a section of code and verify its correctness. A unit may be an individual function, method, procedure, module, or object.
More about Unit Testing
What is Roboletric?
Running tests on an Android emulator or device is slow! Building, deploying, and launching the app often takes a minute or more. That’s no way to do TDD. There must be a better way.
Robolectric is the industry-standard unit testing framework for Android. Robolectric is a framework that brings fast and reliable unit tests to Android. Tests run inside the JVM on your workstation in seconds.
Robolectric provides a JVM-compliant version of the android.jar file. Robolectric handles inflation of views, resource loading, and lots of other stuff that’s implemented in native C code on Android devices.
This enables you to run your Android tests in your continuous integration environment without any additional setup. Roboletric supports resource handling, e.g., inflation of views. You can also use the findViewById() to search in a view.
Roboletric is not an integration test framework, i.e., you cannot test the interaction of Android components with it.
Roboletric does not require additional mocking frameworks, of course, it is still possible to use frameworks like Mockito if desired.
Benefits of Roboletric?
Run tests in a simulated Android environment inside a JVM
Reduced overhead and flakiness of an emulator
Run 10x faster than those on cold-started emulators
Supports 17 different versions of Android
Let's simplify Roboletric
A testing tool for Android
Can test pure Java/Kotlin code
Provide the ability to test Android Framework code
Don't require a simulator to run the test
It uses the host machine to run the tests and which is much faster
Installation
Update your app build.gradle
android {
android {
testOptions {
unitTests {
includeAndroidResources = true
}
}
}
}
dependencies {
testImplementation 'junit:junit:4.13.2'
testImplementation 'org.robolectric:robolectric:4.9'
}
Sync the project and Roboletric is ready for use
First Test
Let's create a class called RoboletricFirstTest under the test package.
@RunWith(RobolectricTestRunner::class)
class RoboletricFirstTest {
private var conditionToMatch = ""
@Before
fun setup() {
conditionToMatch = "Hello Roboletric!"
}
@Test
fun `our first test to match the greetings`() {
assert(conditionToMatch == "Hello Roboletric!")
}
@After
fun release() {
conditionToMatch = ""
}
}
Run the test (ctrl+shift+F10)and check the output:
✅ Tests passed: 1 out 1 test
Congratulations, we successfully passed our first Roboletric Test.
Things to notice:
testImplementation 'org.robolectric:robolectric:4.9' test implementation is applicable for test package only but not for androidTest package. For androidTest package use androidTestImplementation.
Test classes must be annotated with @RunWith(RobolectricTestRunner::class)
In a class, there might be several tests and to run those tests, we may need to initialize some dependent objects before the test runs. To initialize objects use the annotation @Before in your method.
And to release the object when the tests are finished, use the annotation @After in your method.
Practical Testing with Repository
Let's think about practical testing where we might want to test our repository, repository is responsible for making a network call and returning the response. [But for testing purposes, we are using a mock repository implementation]
Create a new repository(interface) under a package called com.rommansabbir.robolectricexample.basictesting
interface AuthRepository {
fun login(username : String, password : String): String
fun register(username: String, password: String): Boolean
}
Our auth repository contains two APIs called login and register. In a real project, we will have the implementation of network calls.
Create two new classes called AuthRepositoryTestImpl and AuthRepositoryTest under the package called com. rommansabbir.roboletricexample.basictesting(test package).
class AuthRepositoryTestImpl : AuthRepository {
override fun login(username: String, password: String): String {
return if (username == "rommansabbir" && password == "123456") "login_access" else "Login error"
}
override fun register(username: String, password: String): Boolean {
return username == "rommansabbir" && password == "123456"
}
}
Here is our test implementation of auth repository.
@RunWith(RobolectricTestRunner::class)
class AuthRepositoryTest {
private var authRepo: AuthRepository? = null
@Before
fun setup() {
authRepo = AuthRepositoryTestImpl()
}
@Test
fun `test a valid login`() {
assert(authRepo?.login("rommansabbir", "123456") == "login_access")
}
@Test
fun `test a invalid login`() {
assert(authRepo?.login("rommansabbir", "password") == "Login error")
}
@Test
fun `test a valid registration`() {
assert(authRepo?.register("rommansabbir", "123456") == true)
}
@Test
fun `test a invalid registration`() {
assert(authRepo?.register("rommansabbir", "password") == false)
}
@After
fun release() {
authRepo = null
}
}
Here are our tests for auth repository.
Run the test (ctrl+shift+F10)and check the output:
✅ Tests passed: 4 out 4 test
Application Context-Related Test
In our test, we might need to use the application context to run tests (ex: SharedPreferences usages). Let's create a new class called AppContextTest.
@RunWith(RobolectricTestRunner::class)
class AppContextTest {
private var context: Application? = null
private var sharedPreferences: SharedPreferences? = null
private val key: String = "TEST_KEY"
@Before
fun setup() {
context = ApplicationProvider.getApplicationContext()
sharedPreferences = context?.getSharedPreferences("test", Context.MODE_PRIVATE)
}
@Test
fun `context and shared pref should be not null`() {
assert(context != null)
assert(sharedPreferences != null)
}
@Test
fun `test a shared pref writing & get the written object`() {
var writeDone = false
sharedPreferences?.edit {
putBoolean(key, true)
commit()
writeDone = true
}
assert(writeDone)
assert(sharedPreferences?.getBoolean(key, false) == writeDone)
}
@After
fun release() {
sharedPreferences = null
context = null
}
}
Here, we are getting the application context by accessing the ApplicationProvider.getApplicationContext() API. We need to add the required dependency testImplementation 'androidx.test:core:1.5.0'
Run the test (ctrl+shift+F10)and check the output:
✅ Tests passed: 2 out 2 test
Activity Testing
Let's test a Activity, where we will test the button name maches to a string (resource) and button click is performed.
@RunWith(RobolectricTestRunner::class)
class MainActivityTest {
private var mainActivity: MainActivity? = null
@Before
fun setup() {
mainActivity = Robolectric.buildActivity(MainActivity::class.java).create().resume().get()
}
@Test
fun `check activity is initialized properly`() {
assert(mainActivity != null)
}
@Test
fun `check the button name`() {
assert(mainActivity?.binding?.mainButton?.text == mainActivity?.getString(R.string.welcome_button))
}
@Test
fun `check button pressed`() {
var isPressed = false
mainActivity?.binding?.mainButton?.apply {
setOnClickListener{
isPressed = true
}
performClick()
}
assert(isPressed)
}
@Test
fun release() {
mainActivity = null
}
}
Run the test (ctrl+shift+F10)and check the output:
✅ Tests passed: 4 out 4 test
Service Testing
Create a new service called MyService under package com.rommansabbir.robolectricexample.myservice
class MyService : Service() {
companion object {
var isServiceInitialized = false
var isServiceDestroyed = false
}
override fun onBind(intent: Intent): IBinder? {
return null
}
override fun onCreate() {
super.onCreate()
isServiceInitialized = true
}
override fun onDestroy() {
super.onDestroy()
isServiceDestroyed = true
}
}
Create a class called MyServiceTest under package com.rommansabbir.robolectricexample.myservice (test package)
@RunWith(RobolectricTestRunner::class)
class MyServiceTest {
private var service: MyService? = null
@Before
fun setup() {
service = Robolectric.buildService(MyService::class.java).get()
MyService.isServiceInitialized = false
MyService.isServiceDestroyed = false
}
@Test
fun `check if the service is created by calling onCreate method`() {
service?.onCreate()
assert(MyService.isServiceInitialized)
}
@Test
fun `check if the service is destroyed by calling onDestroy method`() {
service?.onDestroy()
assert(MyService.isServiceDestroyed)
}
@After
fun release() {
service = null
}
}
Run the test (ctrl+shift+F10)and check the output:
✅ Tests passed: 2 out 2 test
If get to know something new by reading my articles, don't forget to endorse me on LinkedIn
I hope this article will help you to cover basic Android testing with Roboletric.
Project Link (Github): Click here to view the repository
That's it for today. Happy Coding...
