Mobile App Testing Strategies Cheat Sheet

Updated 2026-05-16

Next Topic: Mobile Offline-First Development Cheat Sheet

🧠Study flashcards on this topic80 cards · spaced repetition→

Mobile app testing encompasses the practices, frameworks, and tools used to validate functionality, performance, and usability across iOS and Android platforms. Testing strategies span multiple layers—from unit tests that verify isolated logic to end-to-end tests that simulate real user journeys across devices. The ecosystem includes native frameworks (XCTest, JUnit), cross-platform tools (Detox, Maestro), and cloud-based device farms for scale. A key challenge in mobile testing is the fragmentation of devices, OS versions, and screen sizes, making comprehensive test coverage essential. Understanding when to apply each testing type—balancing speed, reliability, and real-world fidelity—distinguishes effective mobile QA from brittle test suites that slow development.

What This Cheat Sheet Covers

This topic spans 15 focused tables and 132 indexed concepts, 80 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Unit Testing FrameworksTable 2: Component and Widget TestingTable 3: Integration TestingTable 4: End-to-End Testing FrameworksTable 5: UI Testing PatternsTable 6: Snapshot and Visual Regression TestingTable 7: Device Farms and Cloud TestingTable 8: Mocking and Stubbing StrategiesTable 9: Accessibility TestingTable 10: Performance Profiling and TestingTable 11: Test Organization and ArchitectureTable 12: CI/CD Integration for TestingTable 13: Network and API TestingTable 14: Security and Compliance TestingTable 15: Test Data Management

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Unit Testing Frameworks

Unit tests are the foundation of any mobile test suite—fast, isolated checks that verify a single function or class behaves correctly. The frameworks here split along platform lines: XCTest and Quick/Nimble for Swift, JUnit and Robolectric for Android, Jest for React Native, plus the mocking libraries (Mockito, OCMock, Cuckoo) you reach for when a unit depends on collaborators you'd rather fake.

Framework	Example	Description
XCTest	`func testAddition() {` `XCTAssertEqual(calculator.add(2, 3), 5)` `}`	• Apple's native testing framework for Swift and Objective-C • integrated into Xcode with test navigator and code coverage tools
JUnit 4	`@Test` `public void testMultiplication() {` `assertEquals(6, calculator.multiply(2, 3));` `}`	• Industry-standard Java testing framework for Android unit tests • uses annotations like `@Test`, `@Before`, and `@After`.
JUnit 5	`@Test` `void testDivision() {` `assertThrows(ArithmeticException.class, () -> calc.divide(5, 0));` `}`	• Modern JUnit version with parameterized tests, nested test classes, and improved extension model • preferred for new Android projects
Jest	`test('formats currency', () => {` `expect(formatCurrency(1234.5)).toBe('$1,234.50');` `});`	• JavaScript testing framework widely used for React Native unit tests • includes mocking, snapshot testing, and watch mode
Quick/Nimble	`it("validates email format") {` `expect(validator.isValid("test@example.com")).to(beTrue())` `}`	• BDD-style testing framework for iOS with expressive matchers • popular alternative to XCTest for Swift projects
Robolectric	`@Test` `public void clickButton_shouldNavigate() {` `button.performClick();` `assertNotNull(shadowOf(activity).getNextStartedActivity());` `}`	• Android testing framework that runs tests in the JVM without an emulator • faster than instrumented tests but limited Android API fidelity
Mockito	`UserRepository mockRepo = mock(UserRepository.class);` `when(mockRepo.getUser(1)).thenReturn(testUser);` `verify(mockRepo).getUser(1);`	• Java mocking framework for creating test doubles • essential for isolating units under test from dependencies in Android
OCMock	`id mockService = OCMClassMock([DataService class]);` `OCMStub([mockService fetchData]).andReturn(testData);`	• Objective-C mocking library for iOS • supports partial mocks and method stubbing for legacy codebases
Cuckoo	`let mockService = MockDataService()` `stub(mockService) { mock in` `when(mock.fetchData()).thenReturn(testData)` `}`	• Swift mocking framework with type-safe stubs and verification • generates mocks via code generation
XCTestExpectation	`let expectation = XCTestExpectation(description: "API call")` `apiClient.fetch { _ in expectation.fulfill() }` `wait(for: [expectation], timeout: 5.0)`	• XCTest mechanism for testing asynchronous code • waits until expectations are fulfilled or timeout occurs

One level up from pure logic, these tools exercise individual UI pieces—a button, a profile card, a single screen—rendered in a lightweight test environment rather than on a real device. Each framework is tied to its rendering layer (ViewInspector for SwiftUI, Compose UI testing for Jetpack, Flutter's WidgetTester, Testing Library for React Native), and the recurring lesson is to assert on what the user sees and does, not on implementation details.

Technique	Example	Description
ViewInspector	`let view = try ContentView().inspect()` `let text = try view.find(text: "Welcome").string()`	• SwiftUI testing library that introspects view hierarchies at runtime • enables unit testing of SwiftUI components without UI rendering

The rest of this section is part of the full cheat sheet

Table 3: Integration Testing

Integration tests check that components actually work together—your view model talking to a real database, navigation firing the right intents, a network layer parsing a live response shape. The patterns below lean heavily on substituting the slow or unpredictable parts (in-memory databases, mocked URL sessions, stubbed intents) so the test stays deterministic while still crossing the seams that unit tests skip.

Pattern	Example	Description
Instrumented Tests	`@Test` `fun testDatabaseInsertion() {` `val dao = db.userDao()` `dao.insert(User("Alice"))` `assertEquals(1, dao.getAll().size)` `}`	• Android tests that run on a real device or emulator • used for database, file system, and framework-dependent code

The rest of this section is part of the full cheat sheet

Table 4: End-to-End Testing Frameworks

End-to-end frameworks drive the whole app the way a user would—tapping through real screens and asserting on what actually appears. The big tradeoff between them is synchronization and scope: gray-box tools like Detox and white-box ones like EarlGrey hook into app internals to know when things settle, while black-box drivers like Appium and XCUITest stay outside the process. Maestro's simple YAML sits at the easy-to-write end, the older Calabash at the legacy end.

Framework	Example	Description
Detox	`await element(by.id('loginButton')).tap();` `await expect(element(by.text('Dashboard'))).toBeVisible();`	• React Native E2E framework with gray-box testing and automatic synchronization • waits for app to be idle before assertions

The rest of this section is part of the full cheat sheet

Table 1: Unit Testing Frameworks

Framework	Example	Description
XCTest	`func testAddition() {` `XCTAssertEqual(calculator.add(2, 3), 5)` `}`	• Apple's native testing framework for Swift and Objective-C • integrated into Xcode with test navigator and code coverage tools
JUnit 4	`@Test` `public void testMultiplication() {` `assertEquals(6, calculator.multiply(2, 3));` `}`	• Industry-standard Java testing framework for Android unit tests • uses annotations like `@Test`, `@Before`, and `@After`.
JUnit 5	`@Test` `void testDivision() {` `assertThrows(ArithmeticException.class, () -> calc.divide(5, 0));` `}`	• Modern JUnit version with parameterized tests, nested test classes, and improved extension model • preferred for new Android projects
Jest	`test('formats currency', () => {` `expect(formatCurrency(1234.5)).toBe('$1,234.50');` `});`	• JavaScript testing framework widely used for React Native unit tests • includes mocking, snapshot testing, and watch mode
Quick/Nimble	`it("validates email format") {` `expect(validator.isValid("test@example.com")).to(beTrue())` `}`	• BDD-style testing framework for iOS with expressive matchers • popular alternative to XCTest for Swift projects
Robolectric	`@Test` `public void clickButton_shouldNavigate() {` `button.performClick();` `assertNotNull(shadowOf(activity).getNextStartedActivity());` `}`	• Android testing framework that runs tests in the JVM without an emulator • faster than instrumented tests but limited Android API fidelity
Mockito	`UserRepository mockRepo = mock(UserRepository.class);` `when(mockRepo.getUser(1)).thenReturn(testUser);` `verify(mockRepo).getUser(1);`	• Java mocking framework for creating test doubles • essential for isolating units under test from dependencies in Android
OCMock	`id mockService = OCMClassMock([DataService class]);` `OCMStub([mockService fetchData]).andReturn(testData);`	• Objective-C mocking library for iOS • supports partial mocks and method stubbing for legacy codebases
Cuckoo	`let mockService = MockDataService()` `stub(mockService) { mock in` `when(mock.fetchData()).thenReturn(testData)` `}`	• Swift mocking framework with type-safe stubs and verification • generates mocks via code generation
XCTestExpectation	`let expectation = XCTestExpectation(description: "API call")` `apiClient.fetch { _ in expectation.fulfill() }` `wait(for: [expectation], timeout: 5.0)`	• XCTest mechanism for testing asynchronous code • waits until expectations are fulfilled or timeout occurs

Table 2: Component and Widget Testing

Technique	Example	Description
ViewInspector	`let view = try ContentView().inspect()` `let text = try view.find(text: "Welcome").string()`	• SwiftUI testing library that introspects view hierarchies at runtime • enables unit testing of SwiftUI components without UI rendering

Table 3: Integration Testing

Pattern	Example	Description
Instrumented Tests	`@Test` `fun testDatabaseInsertion() {` `val dao = db.userDao()` `dao.insert(User("Alice"))` `assertEquals(1, dao.getAll().size)` `}`	• Android tests that run on a real device or emulator • used for database, file system, and framework-dependent code

Table 4: End-to-End Testing Frameworks

Framework	Example	Description
Detox	`await element(by.id('loginButton')).tap();` `await expect(element(by.text('Dashboard'))).toBeVisible();`	• React Native E2E framework with gray-box testing and automatic synchronization • waits for app to be idle before assertions