Testability and Shift-Left Testing Questions

Situation: On a mobile team I joined, we had a lot of regressions in one feature area because the view models were doing too much and our tests were mostly high-level UI tests.

Task: I wanted to improve both code quality and test quality so bugs were caught earlier, without slowing delivery.

Action: I extracted network and persistence logic behind small protocols, moved parsing into a pure mapper layer, and added focused unit tests around the business rules. I also replaced several brittle UI assertions with a smaller number of end-to-end checks that verified the full flow. To keep the team aligned, I added test-review guidance in PRs: if logic could be tested without UIKit/Android UI, it should be.

Result: The feature became much easier to change, and we started catching bad payload handling and state bugs in unit tests instead of in QA or CI. I knew it helped because flaky UI failures went down, PR reviews got simpler, and the same area produced fewer escaped defects after the refactor.

The main lesson for me was that quality improves fastest when tests match the right layer of the architecture.

I usually separate the problem into two concerns: network I/O and persistence.

For network calls, I prefer a stub or fake server over a pure mock when I want realistic request/response behavior. In iOS that often means abstracting the client behind a protocol and stubbing the transport; in Android/Jest-style tests, I’ll use a fake repository or a local test server. For persistence, an in-memory database or fake store is usually better than mocking every DAO method, because it exercises real reads, writes, and queries.

Trade-offs:

• Mocks: best for verifying interactions, but they can make tests brittle if you over-specify call order.
• Stubs: good for fixed responses and deterministic tests, but they don’t model state changes.
• Fakes: great for higher-confidence tests because they behave like a simplified real dependency, but they take more effort to build.

My rule is: use mocks sparingly for collaboration boundaries, use stubs for simple branching, and use fakes or in-memory implementations when the behavior itself matters. That keeps tests fast, readable, and closer to production behavior.

Unit tests, integration tests, and end-to-end tests each protect a different risk.

• Unit tests: verify one class or function in isolation. They are fast, precise, and best for business rules, edge cases, and pure logic.
• Integration tests: verify that components work together, like a repository talking to a database or a view model calling a service. They catch wiring and contract issues.
• End-to-end tests: simulate the user journey through the app UI. They are slower, but they protect the most important flows from a real-user perspective.

If I were starting a feature from scratch, I’d put most logic in unit-testable code, add integration tests at the boundaries that are likely to break, and reserve end-to-end tests for critical paths like sign-in, checkout, or data submission. That gives good coverage without making the suite too slow or brittle.

My rule is simple: test the behavior at the lowest layer that can prove it correctly, and only go higher when the user experience itself is the thing at risk.

Code coverage is useful, but it only tells you that code was executed, not that it was meaningfully verified.

A high number can be misleading when tests:

• execute lines without asserting important outcomes,
• miss edge cases and error paths,
• rely on mocks so heavily that nothing real is exercised,
• or leave critical user flows untested while chasing percentage points.

Meaningful coverage asks, "Are we protecting the product?" I look at:

• branch and path coverage on risky logic,
• tests around recent bug fixes and churn-heavy code,
• mutation testing or at least hand-checking assertion strength,
• escaped defects and flaky-test trends,
• and whether critical user journeys have at least one solid test at the right layer.

For example, a screen can have 95% line coverage and still fail on a null API field or a background/foreground transition. I’d rather have slightly lower coverage with strong assertions on the risky paths than a high percentage that gives false confidence.

I’d design the pipeline in layers so fast feedback happens on every pull request, while deeper confidence is built before release.

PR pipeline:

• format/lint/static analysis,
• unit tests,
• a small set of deterministic integration tests,
• and a build artifact that can be reused downstream.

Pre-release pipeline:

• broader integration and UI coverage,
• device or simulator matrix for the supported OS versions,
• accessibility and release-specific checks,
• and signing/package validation.

To keep it reliable, I’d build once and test many times, cache dependencies, parallelize by test group, and keep the environment as deterministic as possible. Flaky tests need ownership, not silent retries forever. If a test is unstable, quarantine it temporarily and fix the root cause.

I’d also monitor pipeline health: duration, failure reasons, rerun rate, and the percentage of failures caused by the test system versus the product. Engineers trust CI when it is fast, predictable, and clearly signals what actually broke.