Unit Test Code – Android
In Android development, unit testing focuses on testing individual components of your app
in isolation, ensuring they behave as expected. Here's a breakdown of what should be
tested using unit test code in Android:
1. Business Logic
• ViewModels: Test the logic inside ViewModel classes, which typically contain
business logic and interact with repositories.
• Use Cases (or Interactors): Test individual use cases, ensuring they execute the
right business logic and return the expected data.
• Utility Classes: Any helper or utility class that performs calculations, formatting, or
data manipulation should be tested.
2. Repository Layer
• Data Sources: Test whether the repository interacts with local (Room,
SharedPreferences) and remote data sources (APIs) correctly.
• Mocking Network Calls: Use tools like Mockito to mock API responses and ensure
that your repository handles the data correctly.
3. Data Models
• Serialization and Deserialization: Test your model classes (e.g., JSON to object,
and object to JSON).
• Data Transformation: If any model data transformation or mapping occurs, ensure
it behaves as expected.
4. Service/Manager Logic
• Background Services: Test whether services like WorkManager are being executed
properly with the right input/output.
• Custom Services/Managers: Any custom manager classes (e.g., SessionManager)
should be tested.
5. Edge Cases and Error Handling
• Exception Handling: Ensure that exceptions are caught and handled properly.
• Edge Case Input: Test methods with edge case inputs, such as null values, empty
lists, or out-of-range numbers.
6. Dependency Injection
• DI Setup: Ensure your dependency injection (e.g., with Hilt or Dagger) is working
correctly in isolating dependencies for unit testing.
7. Android Components (Using Mocks)
• Lifecycle Events: Test lifecycle methods in ViewModels or other components that
react to Android lifecycle events.
• Context-dependent Classes: Classes dependent on Android framework
components (e.g., Context, Activity) should be mocked and tested for correctness.
8. Third-Party Library Wrappers
• Custom Wrappers: If you use third-party libraries for things like logging or network
operations, you should test any custom wrapper classes you create to interact with
these libraries.
9. Edge Cases and Negative Scenarios
• Test edge cases such as invalid inputs, null values, or timeouts, and ensure
appropriate error handling.
Common Tools for Unit Testing in Android:
• JUnit: For writing the test cases.
• Mockito: For mocking dependencies and isolating the component being tested.
• Robolectric: To simulate Android framework classes.
• Truth/AssertJ: For making assertions about test results.
