Testability and Shift-Left Testing Questions

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 avoid arbitrary sleeps because they make tests slow and nondeterministic. Instead, I try to control the source of asynchrony.

Patterns I use:

• Expectations or latches: wait for a specific callback or event, with a timeout only as a safety net.
• Fake clocks or test schedulers: for timers, debounce logic, or reactive streams, I advance virtual time manually instead of waiting in real time.
• Injected executors/dispatchers: run work on a test-controlled thread or immediate executor.
• Async/await or promise testing: await the final state rather than polling.
• For streams, subscribe in the test, emit events explicitly, and assert the sequence.

The key is to make the async dependency injectable so the test controls when work happens. That keeps tests fast, repeatable, and easy to debug. If a test still needs a timeout, I keep it short and use it only to fail fast, not to "solve" synchronization. The best async tests are ones where the test owns time and input, not the app.

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 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.

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.