← Voltar aos guias

AI Unit Tests for Legacy Code: A 2026 Field Guide

Generating unit tests for legacy code with AI works best when you treat the model as a test author whose work needs evidence. Older systems often hide business rules in conditionals, database calls, and undocumented defaults. A useful 2026 workflow starts by capturing observable behavior, then checks whether generated tests can detect meaningful changes.

1. Choose a small target and establish a baseline

Start with one function or class that changes frequently or has caused production defects. Pricing calculations, permission checks, and input normalization are good candidates. Avoid asking an agent to cover an entire repository in one pass: large batches make incorrect assumptions harder to spot.

Run the existing tests first and record failures. Identify the test framework, runtime version, fixtures, and commands used in continuous integration. Give the AI the target implementation, relevant callers, dependency interfaces, and one representative test file. Exclude credentials and customer records; use synthetic examples.

2. Capture current behavior before changing it

For poorly documented code, begin with characterization tests: tests that record what the implementation currently does. These provide a safety net for refactoring, but current behavior is not automatically correct behavior.

Suppose a pricing function applies a discount before calculating tax and returns zero for an empty basket. Ask the model to identify these behaviors and their evidence. Check expected results against existing documentation, approved examples, or manually verified calculations. Label suspicious behavior for review instead of silently treating it as a requirement.

A useful prompt is: “Generate pytest characterization tests for calculate_total. Preserve production code. Cover empty input, discount boundaries, rounding, and invalid quantities. Explain the evidence for each expected result. Flag uncertain behavior. Follow the supplied test conventions.”

3. Control dependencies at clear boundaries

Legacy functions often read the clock, query databases, or call external services. Ask the AI to list these dependencies before generating tests. Freeze time, seed randomness when appropriate, and replace network calls with controlled responses.

• Mock the service boundary and exercise the real calculation or decision logic.
• Use fixtures that include missing fields, empty responses, and dependency errors.
• Assert observable outputs and effects, such as a returned total or a queued notification.
• Avoid asserting private helper calls unless the interaction itself is a requirement.

When isolation requires a production change, request the smallest reviewable seam, such as an injectable clock. Review that change separately. If behavior depends on database constraints or transaction semantics, add integration tests as well; mocks cannot establish those guarantees.

4. Run every batch and inspect the assertions

Generate a handful of tests, then execute them. For a Python pricing module, a focused command might be pytest tests/test_pricing.py -q. Return actual failures to the model, including relevant tracebacks. Require it to explain the cause before editing: a failure can reveal an incorrect expectation, an environment problem, or a real defect.

Reject tests that duplicate the implementation to compute expected values, catch every exception, or assert only that a result exists. Prefer small examples with independently calculated answers. Check that each test would fail if its named behavior broke.

5. Measure whether the tests detect mistakes

Line coverage shows which code executed; it does not establish correctness. Inspect branch coverage around business decisions, then use targeted mutation testing where practical. For example, changing a discount boundary from greater-than to greater-than-or-equal should fail a boundary test.

After focused tests pass, run the relevant package suite. For a confirmed bug fix, first demonstrate that the regression test fails on the old implementation and passes with the fix. Keep characterization expectations separate from deliberately corrected behavior.

6. Keep AI test generation affordable with 59API

Repeated generation and repair can consume substantial tokens. Send focused context, reuse concise project instructions, and reserve more capable models for difficult dependency analysis or ambiguous rules.

59API provides low-cost, pay-as-you-go access to Claude and GPT models, with native, official-quality models and no downgrade. It works with Claude Code, Codex, and OpenAI SDK workflows; its API base URL is https://api.59api.com. Follow its configuration instructions for your chosen client, and compare current model pricing against your workload. A referral rebate offers another potential saving. Sign up for 59API to try this workflow on one small legacy module and measure the cost of producing reviewed, passing tests.

Preços · Docs