Mastering Effective Unit Tests: Principles, Practices, and Design Tips

What Is Unit Testing

A unit test is an automated piece of code that invokes a work unit and verifies certain assumptions about its final result.

Unit tests are usually written with a unit‑test framework; as long as the product code does not change, the test results remain stable.

Why Unit Testing Is Needed

The significance of unit testing can be summarized in three points:

Unit testing is the most effective way to ensure your code produces the desired results.

Unit testing helps shape design.

Unit testing is one of the best forms of documentation.

Unit tests describe expected behavior, enable rapid fault localisation when code changes break something, and give confidence for safe refactoring.

What Makes a Unit Test Effective

Effective unit tests should be readable, maintainable, trustworthy, and fast.

Readability

“Good programmers write code that computers can read. Great programmers write code that humans can read.” – Martin Fowler

Maintainability

Using a consistent coding convention helps the team locate problems quickly and eliminates code smells.

Trustworthiness

Trustworthy tests are repeatable, isolated from the environment, contain real assertions, and do not depend on execution order.

Tests must be repeatable.

Tests must be isolated from external dependencies.

Tests without verification are unreliable.

Do not rely on test order.

Assertions must be precise to pinpoint failures.

Fast Execution

Fast tests shorten feedback cycles and keep the test suite responsive.

Why Effective Unit Tests Matter

Ineffective tests add maintenance cost and ultimately cause test failures.

The diagram shows that the value of CI comes from two factors: the foundation of unit‑testing capability (horizontal axis) and the effectiveness of those tests (vertical axis). Without effective tests, a solid foundation brings no value.

How to Write Effective Unit Tests (Flutter Example)

Use a Test Framework

Flutter provides flutter_test and integration_test packages.

Adopt a Consistent Coding Convention

Whether AAA (Arrange‑Act‑Assert) or GWT (Given‑When‑Then), a uniform style improves readability and maintainability.

Use Test Doubles

Dummy : does nothing, returns null or zero.

Stub : returns values that drive the code along a specific path.

Spy : like a stub but records interactions for later verification.

Mock : like a spy with built‑in expectations and assertions.

Fake : a lightweight implementation of business rules.

One Assertion per Test

Clear intent makes failures easy to locate.

One Mock per Test

Avoid multiple mocks; keep verification simple.

Avoid Redundant Tests

Redundant tests increase maintenance cost.

Avoid Conditional Logic

Conditionals make tests harder to maintain and less precise.

Deterministic Tests

Do not depend on time, randomness, concurrency, external services, etc.

Fast Execution

Avoid sleep or other slow operations.

Avoid Over‑Specification

Only test what truly belongs to unit testing; discard tests that become a maintenance burden.

Golden tests for pixel‑perfect UI are useful but should be used cautiously.

Test Pyramid

The test pyramid (Mike Cohn, *Succeeding with Agile*) recommends many fast unit tests at the bottom, fewer integration tests in the middle, and very few end‑to‑end tests at the top.

Where to Start Adding Unit Tests

Prioritise regression tests for P0 cases.

Avoid over‑specified end‑to‑end tests.

Introduce contract tests where appropriate.

Then expand from the middle of the pyramid, gradually adding lower‑level unit tests.

Testable Design Guidelines

Avoid complex private or protected methods.

Avoid final methods.

Avoid static methods.

Be cautious with new inside code.

Do not embed logic in constructors.

Avoid singletons.

Prefer composition over inheritance.

Avoid service locators.

Design to interfaces.

Unit Testing and Refactoring

Writing tests often drives refactoring; refactoring also requires tests to guarantee correctness. Follow the discipline of "no‑test‑refactor is meaningless", refactor frequently, decisively, and ensure tests always pass.

If You Can’t Do Full TDD, Do Test‑First

Even without strict TDD, writing tests before code (test‑first) improves design and forces clear interface boundaries.

Understanding Code Coverage

Do not turn coverage into a management metric. Use it to guide improvement, not to punish teams. – *The Clean Coder*.

Pursuing coverage for its own sake leads to meaningless tests that increase maintenance cost.

Consolidating Best Practices

Code review is the best way to capture and share testing best practices, treating unit tests as first‑class citizens.

Isolating Unit Tests from Integration Tests

Integration tests involve real dependencies and are slower and less stable. Keep a "green safety zone" where unit tests are isolated from integration tests.

Unit Testing and A/B Testing

Although unrelated, both aim to protect production quality; A/B switches act as a safety net similar to unit tests.

Final Thoughts

Unit testing has evolved from optional to essential for modern software engineering. Culture, discipline, and continuous learning are key to making unit tests effective.

References

《单元测试的艺术》

《有效的单元测试》

《Succeeding with Agile》

《匠艺整洁之道》

Test Pyramid: https://martinfowler.com/articles/practical-test-pyramid.html

Software Engineering at Google: https://qiangmzsx.github.io/Software-Engineering-at-Google/#/zh-cn/Chapter-12_Unit_Testing/Chapter-12_Unit_Testing