如何优化单元测试？如何基于已有用例构建新单元测试用例？

Great questions—these are super common pain points when you're growing your test suite, so let's break them down clearly:

• Stick to single responsibility per test: Each test should verify one specific behavior, not a dozen. For example, don't cram "user login succeeds" and "user login fails with wrong password" into the same test. Splitting them makes failures easier to debug and keeps tests readable.
• Eliminate duplicate setup/teardown: Use your testing framework's built-in setup/teardown hooks (like @BeforeEach in JUnit, setup_method in pytest) or extract common logic into helper functions. If 10 tests all need a pre-configured admin user, write a create_admin_user() function once instead of copying the initialization code every time.
• Test boundary conditions explicitly: Don't just test "happy path" inputs. Make sure to cover edge cases like empty strings, maximum/minimum values, null/None inputs, and invalid formats—these are where bugs often hide.
• Avoid testing implementation details: Focus on what the code does, not how it does it. For example, don't assert that a private _calculate_discount() method was called; instead, verify that apply_discount() returns the correct final price. This way, you can refactor internal code without breaking tests.
• Use expressive assertions: Ditch generic assert statements when you can use assertion libraries that make expectations clearer. For example, in Java with AssertJ: assertThat(user.getAge()).isGreaterThan(18) is way more readable than assert user.getAge() > 18.
• Keep tests fast and isolated: Never rely on external resources like databases or APIs in unit tests—use mocks or stubs instead. Each test should run independently, so the order of execution doesn't affect results. Slow tests get skipped, and dependent tests are a nightmare to debug.
• Prune obsolete tests regularly: If a feature gets removed or modified beyond recognition, delete the old tests. Cluttering your suite with unused tests makes maintenance harder and slows down runs.

Copy-pasting tests leads to "test debt"—change one thing, and you have to update 10 copies. Here's how to fix that:

• Extract common test logic into reusable helpers: If multiple tests share the same setup steps (like creating a test order, or calling a common service method), turn that code into a helper function or method. For example:

  def create_test_order(items=None, status="PENDING"):
      order = Order()
      order.items = items or []
      order.status = status
      return order
  

  Now any test that needs an order can call this function, and you only update the logic once if requirements change.
• Use parameterized testing: If you're writing multiple tests that differ only in input and expected output, use parameterized tests. Most frameworks support this—here's a pytest example:

  @pytest.mark.parametrize("input_amount, expected_tax", [
      (100, 8),
      (50, 4),
      (0, 0),
      (-10, 0)  # Edge case for negative amounts
  ])
  def test_calculate_tax(input_amount, expected_tax):
      assert calculate_tax(input_amount) == expected_tax
  

  This replaces 4 separate copy-pasted tests with one clean test and a list of parameters.
• Leverage test class inheritance (if applicable): For frameworks like JUnit or pytest (with classes), create a base test class that includes common setup and helpers, then have your specific test classes inherit from it. For example:

  public abstract class BaseOrderTest {
      protected Order testOrder;
  
      @BeforeEach
      void setupBaseOrder() {
          testOrder = new Order();
          testOrder.setId(1L);
      }
  }
  
  public class OrderStatusTest extends BaseOrderTest {
      @Test
      void testOrderCanBeShipped() {
          testOrder.setStatus("READY");
          // Test shipping logic here
      }
  }
  

• Use test data factories: Build factory functions or classes to generate test data with configurable options. This is especially useful for complex objects. For example, using a builder pattern in Python:

  class UserBuilder:
      def __init__(self):
          self.role = "USER"
          self.email = "user@test.com"
  
      def with_admin_role(self):
          self.role = "ADMIN"
          return self
  
      def build(self):
          user = User()
          user.role = self.role
          user.email = self.email
          return user
  

  Then new tests can create users with UserBuilder().with_admin_role().build()—no copy-pasting, and easy to modify defaults later.
• Avoid hardcoding dependencies: Use dependency injection or mock frameworks to make test dependencies reusable. If multiple tests need a mock payment service, configure the mock once in a helper function instead of setting it up in every test.

内容的提问来源于stack exchange，提问作者Adam Lee