Android Unit Testing and Test Driven Development

Learn to unit test a LoginUseCaseSync with external dependencies by injecting test doubles for LoginHttpEndpointSync, AuthTokenCache, and EvenBusPoster.

Explore test doubles to isolate the system under test by substituting dependencies with fake, stub, and mock implementations, enabling fast, reliable unit tests.

Learn to test the LoginUseCaseSync with test doubles for external dependencies, verify interactions with LoginHttpEndpointSync, AuthTokenCache, and EventBusPoster, and cover negative cases and requirement-driven tests.

Convert listed test cases into actual tests using test doubles like mocks and fakes. Inspect endpoint interactions, capture parameters, and validate auth token storage across success and error scenarios.

Validate SUT interactions with EventBusPosterTd using test doubles, assert events and non-interactions, and ensure authentication, network errors, and thorough test coverage.

Practice using test doubles to test the FetchUserProfileUseCaseSync class in exercise four, following module instructions and description.txt, and compare with LoginUseCaseSync as a reference.

Clarifies the three main test doubles—fakes, stubs, mocks—and explains how the term mock has multiple meanings, often used as a synonym for test double and for mocking frameworks.

Explore how static methods impact unit testing using UserInputValidator, where full name and username validation rely on server calls, creating test doubles challenges and potentially untestable code.

Explore how singletons share static state, causing cross-test interference and flaky tests that fail randomly. Learn why avoiding singletons improves unit testability and reliability.

Master test doubles for substituting external dependencies, covering fakes, stubs, and mocks with distinct behaviors. Understand why static methods resist substitution and why singletons should be avoided.

Compare manual test doubles with the Mockito framework for unit testing, using the same LoginUseCaseSync to demonstrate how Mockito reduces effort while manual doubles remain useful for complex cases.

Set up system under test with Mockito mocks, initialize them with mock(), verify loginSync is called on the endpoint once, and capture arguments with ArgumentCaptor to check username and password.

Practice unit testing of the UpdateUsernameUseCaseSync with Mockito test doubles in the mockito-fundamentals module's exercise5, following description.txt instructions and spotting embedded bugs.

Differentiate objects from data structures by explaining why some dependencies are injected and others instantiated, relate this to the single responsibility principle, and show how test doubles support unit testing.

Master the triple a pattern for unit tests: arrange, act, assert, where the setup configures the environment, the behavior runs (loginSync), and assertions verify outcomes.

Leverage a generated test method template in Android Studio to automatically insert arrange, act, and assert comments, saving time while ensuring consistent test readability across the team.

Annotate tests with JUnit's @RunWith and use MockitoJUnitRunner to initialize mocks with @Mock, removing boilerplate.

Create a reusable Android unit test class template with a setup method, a system under test declaration using a class name placeholder, MockitoJUnitRunner, and organized imports and region directives.

Mockito is a versatile library for creating stubs and mocks with configurable doubles; use it for about 90 percent of tests, and fall back to manual doubles for complex needs.

Understand why testing after production code hides requirements from public apis and biases results. Adopt test driven development to write tests first, ensuring reliable unit testing and better coverage.

Apply the all tests up-front test driven development technique: write all tests against an empty sut, shape its public api, use mocks for dependencies, run tests, fix implementation, and refactor.

Practice test-driven development by writing all tests upfront for exercise 6, implement FetchUserUseCaseSync, study @Nullable implications, and run instructor’s reference tests against your SUT.

Convert requirements into tests to reduce reliance on production code and remove bias from internal implementation. Acknowledge that upfront tests can miss coverage due to typos.

Learn Uncle Bob's three rules for test driven development: don't write production code until a unit test fails, write tests to fail, and write only enough production code to pass.

Learn Uncle Bob's test driven development technique by implementing a PingServer use case, writing failing tests first, and building production code minimally to pass tests, then refactor.

Practice Uncle Bob's test-driven development techniques by following the three rules in a cycle, implementing the GetReputationHttpEndpointSync interface from scratch, and running all tests to ensure the design is complete.

Learn how Uncle Bob's test-driven development for Android unit testing uses tests-first, one test per feature, and rapid iteration to reduce mental overhead and address post hoc production code tests.

Explore using Android Studio split screen to pair tests with production code in test-driven development; learn vertical splits, keyboard shortcuts, and keymap customization to switch, split, and navigate between files.

Explore the shift from synchronous to asynchronous execution in Android unit testing, and learn how to test observers as a key approach to handling background results.

Develop and test a fetch cart items use case that asynchronously retrieves items from a server, then notifies observers, using test-driven development, mocks, and observer pattern verification.

Implement an asynchronous use case that fetches contacts from the server using GetContactsHttpEndpoint, exposing filtering on the use case, while practicing test driven development and the three rules of TDD.

Master test driven development for Android unit testing by writing tests before production code, using Uncle Bob's granular technique for complex designs, and balancing pragmatism with build-time limits.

Explore how Android framework functions as a Java superset, applying general and Java-specific unit testing principles to Android, and learn to handle the framework's unique testing challenges.

The lecture demonstrates that Android-dependent classes can be unit tested using a Context proxy and test doubles, debunking the myth and guiding test-driven development with mocks.

Investigate the challenges of unit testing in android, from isEmpty() and other static API calls to mocks, Bundle constraints, and avoiding android-specific dependencies.

Expose the major challenges of unit testing in Android by showing how Activity inheritance blocks test doubles, yields massive framework code, and prevents full coverage in practice.

Dissect Android apps into UI, application, domain, and infrastructure layers, minimize logic in Activities and Fragments, and unit test domain logic with use cases.

Explore how unit testing applies to a real Android app, the Stack Overflow browser, by testing narrowly defined classes while the UI layer remains abstracted via MVC.

Find the commit introducing the tutorial application with git log --grep, then reset with git reset --hard to the initial bare state and review the changes.

Develop unit tests for the FetchLastActiveQuestionsUseCase by mocking the endpoint, validating success and failure notifications to listeners, and exploring coverage and mutation testing concepts.

Mutation testing checks that tests actually exercise the system under test by mutating statements and watching for failures, reinforcing test-driven development and the three rules.

Practice unit testing the FetchQuestionDetailsUseCase and its asynchronous observable behavior, following the pattern from earlier exercises, while learning git workflows for exercise nine.

Learn to unit test Android controllers using manual test doubles and mocks, centralize test data, and validate binding, navigation, and error handling across onStart, onStop, and onQuestionClicked.

Unit test the question details controller by extracting fragment logic into a standalone controller using test driven development, writing tests first, and validating on emulator or device.

Explore unit testing time-related caching behavior by implementing a 10-second cache, introducing a time provider, and driving development with test-driven approaches.

Practice unit testing time dependent functionality by implementing in-memory caching with timeout in FetchQuestionDetailsUseCase, using a global use case across question details screens, and refactoring tests under tdd guidelines.

Treat unit testing as a discipline aligned with test driven development and single responsibility principle. Use a pragmatic 0 or 1 rule: test all requirements for each unit, avoid dogmatism.

Begin your Android unit testing journey by adding the first unit test. Validate data format logic, extract it into a standalone class using Uncle Bob's technique, mitigate Android framework limitations.

Integrate unit tests with continuous integration, practice testing pragmatically from low hanging fruits, and grow through pair programming and code reviews to master unit testing as a core skill.

Explore bonus resources and links to instructor’s other android and programming courses, with discounts for enrolling. Subscribe to the newsletter, follow on x, and read the blog for android updates.