← Retour aux guides

AI Unit Tests for Legacy Code: A Practical Guide

Why legacy code is hard to test

Legacy code usually has two traits that make unit testing painful: it was not designed with tests in mind, and it often mixes logic, I/O, and hidden dependencies. That means a simple function may reach into a database, read environment variables, or depend on global state. When you try to add tests, you can quickly get stuck deciding what to mock, what to keep real, and how to avoid breaking behavior that already exists in production.

This is where AI can help. Instead of asking it to magically write perfect tests, use it as a fast pair programmer that helps you understand the code, identify seams, and draft the first version of tests. The goal is not just more tests; it is useful characterization tests that lock in current behavior before you refactor.

The best way to use AI: start with one small unit

Do not paste an entire legacy repository into a prompt. Start with a single function, class, or module that has a clear job. If the code is large, extract the smallest method you can reasonably test. AI works better when you give it a focused target and enough context to infer inputs, outputs, and dependencies.

• Choose one function with business logic, not a giant controller.
• Include related helper methods if they affect the result.
• Paste any existing tests, even if they are weak or incomplete.
• Tell the model which test framework you use, such as Jest, Pytest, or JUnit.

A prompt that gets better test results

A good prompt should ask for more than just code. Ask the model to explain assumptions, highlight edge cases, and separate deterministic logic from external dependencies. For example: “Here is a legacy function. Generate unit tests for the current behavior using Jest. Prefer characterizing tests over refactors. Identify mocks needed, edge cases, and any ambiguous behavior.”

This kind of prompt gives you a useful first draft and makes the model show its reasoning. You can then review the output and adjust the tests before running them.

What the AI should help you find

The most valuable output is often not the tests themselves, but the missing structure around them. Good AI-generated tests usually reveal:

• Inputs and outputs: what the function accepts and what it returns.
• Branch coverage: success paths, failures, null values, and boundary cases.
• Dependencies: which calls should be mocked and which should remain real.
• Unexpected behavior: old quirks that users may depend on.

For legacy systems, that last point matters a lot. A test that captures current behavior may protect you from accidental regressions even if the behavior is not ideal. Once those tests exist, you can refactor with more confidence.

A simple workflow for legacy code

Here is a practical workflow you can repeat:

• 1. Read the code once. Note the main purpose and any obvious dependencies.
• 2. Ask AI for a test plan. Request scenarios, edge cases, and mock suggestions before code.
• 3. Generate the first test file. Let the AI draft the structure, imports, and assertions.
• 4. Run the tests. Fix syntax issues, missing mocks, or wrong assumptions.
• 5. Refine the prompt. If a test fails for the wrong reason, tell the model exactly what happened.
• 6. Add one or two manual assertions. Human review is still essential for correctness.

This loop is especially effective when you are working through a codebase that has little or no test coverage. AI reduces the blank-page problem and helps you move faster without starting from scratch.

How to keep AI tests reliable

AI can be overly confident, so verify every generated test against the actual runtime behavior. Watch for brittle assertions, over-mocking, and tests that only repeat implementation details. A strong unit test should fail when behavior changes, not when internal code is rearranged.

Also, make sure the tests are readable to your team. If the AI produces clever but confusing fixtures, simplify them. Clear names and direct setup code will save time later.

Why 59API is a smart way to do this cheaply

If you are generating and refining lots of test drafts, cost matters. 59API is a low-cost AI API relay that gives developers pay-as-you-go access to Claude models and GPT models through the API base URL https://api.59api.com. It is a practical choice when you want official-quality models without paying premium platform pricing.

Because 59API is fully compatible with Claude Code, Codex, and any OpenAI SDK, you can plug it into the tools you already use for code review and test generation. That makes it easy to compare prompts, iterate on failing tests, and keep your workflow simple. If you are exploring this approach for a real project, it is worth signing up and trying a few test-generation runs on your least-tested module.

For teams or solo developers doing a lot of experimentation, the pay-as-you-go model and referral rebate can make the iteration loop even more affordable.

Final takeaway

AI will not turn legacy code into clean architecture overnight, but it can help you generate the first useful unit tests much faster. Start small, ask for a test plan first, verify the output, and use the results to protect behavior before you refactor. That is the fastest path from fragile legacy code to a testable codebase.

Tarifs · Docs