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’d treat this like a reproducibility and isolation problem first, not a test-writing problem.

My steps would be:

1. Re-run the exact CI artifact locally if possible: same commit, same build type, same simulator/emulator image, same locale and device size.
2. Collect evidence: logs, screenshots/video, test order, network activity, and whether failures correlate with timing or a specific screen.
3. Narrow the scope: run the failing test alone, then with nearby tests, then in the full suite to see if there is shared state leakage.
4. Check common mobile causes: animations not disabled, missing synchronization, stale app state, async work still running, resource contention, or dependence on previous tests.
5. Fix the root cause by making the test deterministic: better selectors, explicit waits on app state, hermetic test data, reset between tests, and stable test fixtures.

I would only use retries as a temporary shield, not a fix. If a test is still flaky after that, I’d quarantine it short-term, keep the behavior covered elsewhere, and assign ownership until the underlying issue is resolved.

I’d make the standards explicit, automated, and incremental.

First, I’d agree as a team on a small set of rules that actually matter: things like no unchecked force unwraps, no obvious thread-safety hazards, no dead code, and no new lint violations in touched files. Then I’d encode as much as possible in tooling so reviewers aren’t the enforcement mechanism.

Practically, that means:

• fast local lint and formatter hooks,
• static-analysis checks in CI,
• a clear severity policy: block on correctness issues, warn on style issues,
• and a review checklist that focuses humans on architecture, naming, and risky trade-offs.

I’d also avoid creating a bottleneck by ratcheting gradually. Don’t fail the whole codebase on legacy warnings; prevent new debt from entering and chip away at old debt over time. If a rule is too noisy, tune or remove it. That keeps trust high.

The goal is consistency and bug prevention, not gatekeeping. Good standards should make reviews shorter, not longer.

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.

I would split the screen or view model into pure logic and side effects.

First, I’d inject dependencies instead of constructing them: an API client interface, a parser/mapper, and a repository or persistence gateway. The view model should orchestrate state, not know how HTTP or storage works.

A good shape is:

• ViewModel: handles user intent and UI state.
• Use case or service: contains business rules.
• Repository: coordinates remote and local data.
• Data sources: one for API, one for storage.
• Mapper: converts raw DTOs into domain models.

That gives you unit-testable seams. You can test the view model with fake dependencies, verify it emits the right state, and test the repository separately with stubbed API responses or an in-memory store. Parsing should happen in a pure function or mapper, so malformed payload handling can be tested without UI or storage.

This design reduces coupling, makes failures easier to localize, and prevents a single class from becoming impossible to test.