← सभी गाइड पर लौटें

AI Unit Tests for Legacy Code: A 30-Minute Quick Start

Generating unit tests for legacy code with AI works best when you treat the model as a test-writing assistant, not a specification oracle. Start by recording what the code actually does, then use those tests to make future changes safer. This quick-start workflow targets one small module rather than attempting a repository-wide testing overhaul.

1. Pick one risky function and establish a baseline

Choose a function that changes frequently, handles important business rules, or has caused production bugs. Prefer something with observable inputs and outputs: a shipping calculator, permissions checker, or date parser.

Create a branch and run the existing test suite. Record any failures before adding generated tests so you can distinguish old problems from new ones. For Python projects using pytest, run python -m pytest -q. If nothing is tested yet, first confirm that your chosen module imports without starting servers or contacting external services.

2. Give the AI a focused context packet

Provide the target function, relevant helpers, dependency versions, and one nearby test that demonstrates project conventions. Include known business rules, but label them separately from observed implementation behavior.

Do not upload credentials, customer records, production logs containing personal information, or your entire repository unnecessarily. Replace sensitive examples with synthetic data and check your organization's policies before sending proprietary code to any external service.

Use a prompt like this:

“Write pytest characterization tests for this legacy function. Preserve observed behavior; do not refactor production code. Cover normal inputs, boundaries, and exceptions. Separate verified expectations from assumptions. Mock only external boundaries. Return a proposed test file and explain what each assertion protects. If context is missing, ask rather than inventing behavior.”

3. Capture behavior before judging correctness

Characterization tests document the current implementation, including surprising results. They are useful protection during refactoring, but they do not prove that existing behavior matches business requirements.

Suppose inspection and local execution confirm that shipping_fee returns 5 below a subtotal of 50 and 0 at or above 50. Ask for cases immediately below, exactly at, and immediately above that threshold. A generated test might read:

def test_free_shipping_at_threshold(): assert shipping_fee(50) == 0

Place it in a test file with the appropriate import, such as from legacy.shipping import shipping_fee. Add the neighboring boundary cases using the project's actual currency representation. Do not introduce floating-point inputs if the application uses decimal amounts or integer cents.

If the implementation appears wrong, label the test as capturing legacy behavior and open a separate issue. Do not silently convert a suspected bug into an approved requirement.

4. Isolate dependencies without mocking everything

Ask the model to identify network calls, database access, filesystem writes, environment variables, clocks, and randomness. Replace these boundaries with controlled fixtures, temporary directories, or dependency injection where practical.

• Freeze time when testing expiry rules.
• Use a temporary directory instead of writing into the repository.
• Stub the HTTP client rather than making real API requests.
• Keep pure calculation helpers real so assertions exercise meaningful logic.

If importing the module triggers side effects, stop and create a minimal isolation seam first. Review generated tests before execution, and run them in an environment without production credentials or unrestricted network access.

5. Run, review, and challenge the assertions

Run the new test file first, then the full suite. Return tracebacks and relevant code to the AI, asking it to diagnose failures rather than simply change expected values until everything passes.

Check that each test would detect a meaningful regression. Temporarily changing a threshold from 50 to 51 should break the boundary test. Use branch coverage to locate untested decisions, but prioritize useful assertions over chasing a percentage.

6. Keep iteration inexpensive with 59API

59API offers low-cost, pay-as-you-go access to native official-quality models without model downgrading. For example, you can try Claude Sonnet 5.5 or DeepSeek V4 Flash on the same bounded task and compare assertion quality, not just response length.

The API base URL is https://api.59api.com, with compatibility for OpenAI SDK clients, Claude Code, Codex, and Gemini CLI. Use the documented configuration and model identifier for your chosen client. Send focused context and reuse reviewed fixtures to avoid repeatedly paying for irrelevant repository content.

If you want an inexpensive way to try this workflow, consider signing up for 59API and starting with one legacy function. A small, trustworthy test suite is more valuable than hundreds of generated tests nobody has reviewed.

मूल्य · दस्तावेज़