Unit testing with JUnit in Android Kotlin - Deep Dive

Overview - Unit testing with JUnit

What is it?

Unit testing with JUnit means writing small programs that check if parts of your app work correctly. JUnit is a tool that helps you run these checks automatically. It looks at one piece of your code at a time, like a tiny robot tester. This helps catch mistakes early before your app goes to users.

Why it matters

Without unit tests, bugs can hide in your app and cause crashes or wrong results. Testing with JUnit saves time and frustration by finding problems early. It makes your app more reliable and easier to improve. Imagine building a house without checking if each brick fits well — unit tests are like checking every brick before building.

Where it fits

Before learning unit testing, you should know basic Kotlin programming and how Android apps work. After mastering unit testing, you can learn about integration testing and UI testing to check bigger parts of your app. Unit testing is the first step in making your app solid and bug-free.

Mental Model

Core Idea

Unit testing with JUnit is like having a tiny helper that runs your code pieces and tells you if they work as expected.

Think of it like...

Think of unit testing as checking each ingredient in a recipe before cooking. If the salt is missing or too much, the dish won't taste right. Testing each ingredient ensures the final meal is perfect.

┌───────────────┐
│ Your Kotlin   │
│ Function/Unit │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ JUnit Test    │
│ Runs Checks   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Pass or Fail  │
│ Result       │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What is Unit Testing?

Concept: Unit testing means checking small parts of your code to make sure they work right.

Unit testing focuses on testing one function or class at a time. For example, if you have a function that adds two numbers, a unit test will check if it returns the correct sum for given inputs.

Result

You understand that unit testing isolates small code parts to verify their correctness.

Understanding that testing small pieces individually helps find bugs quickly and makes fixing easier.

2

Foundation

Introduction to JUnit Framework

Concept: JUnit is a tool that helps you write and run unit tests in Kotlin for Android.

JUnit provides annotations like @Test to mark test functions. It runs these tests and shows if they pass or fail. It also offers assertions like assertEquals to compare expected and actual results.

Result

You can write a simple test function using JUnit and run it to see if your code works.

Knowing that JUnit automates running tests saves time and reduces human error in checking results.

3

Intermediate

Writing Your First JUnit Test in Kotlin

🤔Before reading on: do you think a test function needs to return a value or just run assertions? Commit to your answer.

Concept: Test functions in JUnit do not return values; they use assertions to check conditions.

Example: import org.junit.Test import org.junit.Assert.* class CalculatorTest { @Test fun testAdd() { val result = 2 + 3 assertEquals(5, result) } } This test checks if 2 + 3 equals 5 using assertEquals.

Result

Running this test shows 'pass' if the sum is correct, or 'fail' if not.

Understanding that tests verify conditions with assertions rather than returning values clarifies how JUnit signals success or failure.

4

Intermediate

Using Setup and Teardown Methods

🤔Before reading on: do you think setup code runs before or after each test? Commit to your answer.

Concept: JUnit allows setup code to run before each test and cleanup code after each test using @Before and @After annotations.

Example: import org.junit.Before import org.junit.After class CalculatorTest { lateinit var calculator: Calculator @Before fun setup() { calculator = Calculator() } @After fun teardown() { // Clean resources if needed } @Test fun testAdd() { assertEquals(5, calculator.add(2, 3)) } } Setup prepares objects fresh for each test to avoid interference.

Result

Each test runs with a clean state, preventing bugs caused by leftover data.

Knowing how to prepare and clean test environments ensures tests are independent and reliable.

5

Intermediate

Testing Exceptions and Edge Cases

🤔Before reading on: do you think tests should check only correct inputs or also wrong inputs? Commit to your answer.

Concept: Good tests check how code behaves with wrong inputs or errors, including exceptions.

Example: @Test(expected = IllegalArgumentException::class) fun testDivideByZero() { val calculator = Calculator() calculator.divide(5, 0) // Should throw exception } This test passes only if divide throws IllegalArgumentException when dividing by zero.

Result

Tests catch errors early by verifying your code handles bad inputs safely.

Understanding that testing failure cases prevents crashes and improves app stability.

6

Advanced

Mocking Dependencies in Unit Tests

🤔Before reading on: do you think unit tests should test real external services or fake ones? Commit to your answer.

Concept: Mocks are fake objects that simulate real dependencies to isolate the unit under test.

In Android, you might mock a database or network call to test logic without real connections. Libraries like Mockito help create mocks. Example: val mockService = mock(Service::class.java) `when`(mockService.getData()).thenReturn("Fake Data") This lets you test your code using mockService without real network calls.

Result

Tests run faster and more reliably by avoiding real external dependencies.

Knowing how to mock dependencies is key to writing pure unit tests that focus on your code only.

7

Expert

JUnit 5 Features and Kotlin Integration

🤔Before reading on: do you think JUnit 5 supports Kotlin features like lambdas and extensions better than JUnit 4? Commit to your answer.

Concept: JUnit 5 offers modern features like better Kotlin support, dynamic tests, and improved extension models.

JUnit 5 allows writing tests with Kotlin idioms, such as lambdas and extension functions, making tests cleaner. Example: @Test fun testWithLambda() { val list = listOf(1, 2, 3) assertTrue(list.any { it > 2 }) } JUnit 5 also supports parameterized tests and conditional test execution.

Result

You can write more expressive and flexible tests using Kotlin and JUnit 5 features.

Understanding the latest JUnit version unlocks more powerful testing patterns and better Kotlin compatibility.

Under the Hood

JUnit runs tests by scanning your code for functions marked with @Test. It creates a new instance of the test class for each test method, runs setup methods, then the test, and finally teardown methods. It catches exceptions and assertion failures to report pass or fail results. This isolation ensures tests do not affect each other.

Why designed this way?

JUnit was designed to automate testing and make it easy to write repeatable tests. Creating a new instance per test avoids shared state bugs. The annotation system keeps tests simple and readable. Alternatives like manual testing were slow and error-prone.

┌───────────────┐
│ Test Runner   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Create Test   │
│ Instance      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Run @Before   │
│ Setup         │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Run @Test     │
│ Method        │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Run @After    │
│ Teardown      │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Report Result │
└───────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Do you think unit tests run on the actual Android device by default? Commit to yes or no.

Common Belief: Unit tests run on the real Android device or emulator by default.

Reality: Unit tests with JUnit run on the local JVM on your computer, not on Android devices. Tests that run on devices are called instrumented tests.

Why it matters: Confusing these leads to slow tests and setup errors. Knowing this helps you write fast unit tests that run instantly on your computer.

Quick: Do you think a failing test means your code is always wrong? Commit to yes or no.

Common Belief: If a test fails, the code is definitely broken and must be fixed immediately.

Reality: Tests can fail due to wrong test code, incorrect assumptions, or environment issues, not just code bugs.

Why it matters: Blindly trusting failing tests can waste time chasing false problems. Understanding this helps debug tests and code effectively.

Quick: Do you think unit tests replace the need for manual testing? Commit to yes or no.

Common Belief: Unit tests cover all possible bugs, so manual testing is unnecessary.

Reality: Unit tests check small parts but cannot catch all user experience or integration issues that manual testing finds.

Why it matters: Relying only on unit tests can miss real-world problems. Combining testing types ensures better app quality.

Expert Zone

1

JUnit creates a new test class instance for each test method, preventing shared state but requiring careful setup for expensive resources.

2

Kotlin's null safety and extension functions can simplify test code but require understanding how JUnit interacts with Kotlin features.

3

Parameterized tests in JUnit 5 allow running the same test logic with different inputs, reducing code duplication and improving coverage.

When NOT to use

Unit testing with JUnit is not suitable for testing UI elements or full app workflows. For those, use instrumented tests with Espresso or UI Automator. Also, avoid unit tests for code that heavily depends on Android framework classes without mocking.

Production Patterns

In real apps, developers write unit tests for business logic and utility classes. They use mocking frameworks like Mockito to isolate dependencies. Continuous integration systems run these tests automatically on every code change to catch bugs early.

Connections

Test-Driven Development (TDD)

Unit testing with JUnit is the foundation for practicing TDD, where tests are written before code.

Knowing how to write good unit tests enables you to design your code better by thinking about requirements first.

Software Quality Assurance

Unit testing is a key part of quality assurance processes that ensure software reliability.

Understanding unit testing helps grasp how automated checks fit into larger quality strategies.

Scientific Method

Unit testing mirrors the scientific method by forming hypotheses (expected behavior) and experiments (tests) to validate them.

Seeing tests as experiments helps appreciate the importance of repeatability and evidence in software correctness.

Common Pitfalls

#1 Writing tests that depend on each other causing failures when run in different order.

Wrong approach:

class CalculatorTest {
var total = 0

@Test
fun testAdd() {
total += 5
assertEquals(5, total)
}

@Test
fun testSubtract() {
total -= 3
assertEquals(2, total)
}
}

Correct approach:

class CalculatorTest {
@Test
fun testAdd() {
val total = 0 + 5
assertEquals(5, total)
}

@Test
fun testSubtract() {
val total = 5 - 3
assertEquals(2, total)
}
}

Root cause:

Tests share mutable state, breaking isolation and causing flaky results.

#2 Testing multiple things in one test making it hard to find the cause of failure.

Wrong approach:

@Test
fun testAddAndSubtract() {
assertEquals(5, calculator.add(2, 3))
assertEquals(1, calculator.subtract(3, 2))
}

Correct approach:

@Test
fun testAdd() {
assertEquals(5, calculator.add(2, 3))
}

@Test
fun testSubtract() {
assertEquals(1, calculator.subtract(3, 2))
}

Root cause:

Combining multiple checks hides which part failed and complicates debugging.

#3 Not mocking external dependencies causing slow or flaky tests.

Wrong approach:

@Test
fun testFetchData() {
val data = realNetworkService.fetch()
assertNotNull(data)
}

Correct approach:

@Test
fun testFetchData() {
val mockService = mock(NetworkService::class.java)
`when`(mockService.fetch()).thenReturn("Fake Data")
val data = mockService.fetch()
assertEquals("Fake Data", data)
}

Root cause:

Using real services in unit tests makes tests slow and unreliable.

Key Takeaways

Unit testing with JUnit helps you check small parts of your code automatically to catch bugs early.

JUnit uses annotations like @Test and assertions to run tests and report results without manual checking.

Writing independent tests with setup and teardown ensures reliable and repeatable test runs.

Mocking dependencies isolates your code under test, making tests faster and more focused.

Understanding JUnit's design and latest features unlocks powerful testing techniques for professional Android development.