10 Prompts for Writing Unit and Integration Tests with AI

# 10 Prompts for Writing Unit and Integration Tests with AI Writing tests is often seen as a chore, but it’s one of the most critical activities in software development. Unit tests catch regressions early, integration tests ensure components work together, and both save countless hours in debugging. With the rise of AI code assistants, generating test cases has become faster and more reliable. In this article, I share 10 specific, ready-to-use prompts for generating unit and integration tests using AI tools like GitHub Copilot, ChatGPT, or Claude. Each prompt is explained with its purpose and a concrete usage example. ## Why You Need Test Generation Prompts Modern AI models can generate boilerplate test code in seconds. However, without a well-structured prompt, the output is often too generic or misses edge cases. According to the official [pytest documentation](https://docs.pytest.org/en/stable/), a good test should be readable, isolated, and cover both happy paths and failure scenarios. The prompts below follow these principles and can be adapted for **pytest** (Python), **Jest** (JavaScript/TypeScript), and **unittest** (Python standard library). ## Prompt 1: Basic Unit Test for a Pure Function **Task:** Generate a unit test for a simple pure function (e.g., a calculator or string utility). **Prompt:** ``` Write a unit test for the following function using pytest. Cover normal cases, edge cases (empty input, negative numbers), and one error case (e.g., division by zero). Use parametrize where possible. Function: def divide(a: float, b: float) -> float: if b == 0: raise ValueError("Cannot divide by zero") return a / b ``` **Usage Example:** Paste the prompt into any AI coding assistant. The output will be a `test_divide.py` file with 3-5 test cases, including `@pytest.mark.parametrize` for multiple inputs. ## Prompt 2: Integration Test with External API Mock **Task:** Write an integration test that mocks an external API call (e.g., fetching weather data). **Prompt:** ``` Create an integration test for a function that fetches user data from an external API. Use pytest and the requests-mock library. Mock the API response to return HTTP 200 with a valid JSON, and also test for HTTP 404 and timeout scenarios. Function signature: def get_user(user_id: int) -> dict: response = requests.get(f"https://api.example.com/users/{user_id}") response.raise_for_status() return response.json() ``` **Usage Example:** This prompt generates a test that uses `requests_mock` to simulate different API responses, ensuring your error handling works correctly. ## Prompt 3: Database Integration Test with SQLAlchemy **Task:** Generate a test that interacts with a real or in-memory database. **Prompt:** ``` Write an integration test for a CRUD function using SQLAlchemy and an in-memory SQLite database. Test creating a new record, reading it, updating it, and deleting it. Use pytest fixtures to set up and tear down the database session. Function to test: def create_user(db_session, name: str, email: str) -> User: user = User(name=name, email=email) db_session.add(user) db_session.commit() return user ``` **Usage Example:** The AI will output a `conftest.py` with a fixture for `db_session` and a test function that verifies the user is correctly created and retrieved. ## Prompt 4: Async Unit Test with pytest-asyncio **Task:** Write a test for an async function. **Prompt:** ``` Write a unit test for an async function that calls an external service. Use pytest-asyncio to handle async fixtures and tests. Mock the external service call. Async function: async def fetch_price(symbol: str) -> float: async with httpx.AsyncClient() as client: response = await client.get(f"https://api.market.com/price/{symbol}") return response.json()["price"] ``` **Usage Example:** This prompt is perfect for testing async code in Python. The AI will generate a test with `@pytest.mark.asyncio` and a mock for `httpx.AsyncClient`. ## Prompt 5: Jest Unit Test for a React Component **Task:** Generate a Jest test for a React functional component. **Prompt:** ``` Write a Jest unit test for a React component that displays a list of items. Use @testing-library/react. Test that the component renders the list correctly when passed an array, renders an empty state when array is empty, and shows a loading spinner while data is being fetched. Component: function ItemList({ items, isLoading }) { if (isLoading) return Loading... ; if (items.length === 0) return No items ; return ( {items.map(item => {item.name} )} ); } ``` **Usage Example:** The AI will output a `ItemList.test.js` file with `render`, `screen.getByTestId`, and assertions for all three states. ## Prompt 6: Integration Test for a REST API Endpoint **Task:** Write an integration test that starts a test server and calls an endpoint. **Prompt:** ``` Create an integration test for a Flask REST API endpoint using pytest and the test client. Test POST /users with valid data (status 201), missing fields (status 400), and duplicate email (status 409). Endpoint: @app.route('/users', methods=['POST']) def create_user(): data = request.get_json() if 'email' not in data: return jsonify({"error": "Email required"}), 400 # logic to create user ``` **Usage Example:** The prompt yields a test using `app.test_client()` and multiple `assert` statements for each HTTP status code. ## Prompt 7: Edge Case Coverage for a Sorting Algorithm **Task:** Generate a test suite for a custom sorting function, covering edge cases. **Prompt:** ``` Write a comprehensive unit test suite for a custom merge sort implementation using pytest. Include tests for: already sorted list, reverse sorted list, list with duplicates, single element, empty list, and list with negative numbers. Use parametrize. Function: def merge_sort(arr: list) -> list: # implementation ``` **Usage Example:** The AI will generate 6 test cases, all parametrized, ensuring your sorting algorithm is robust. ## Prompt 8: Mocking External Services in Node.js **Task:** Write a Jest test that mocks a third-party module (e.g., axios). **Prompt:** ``` Write a Jest test for a function that sends an email via a third-party service. Mock the axios module to simulate successful and failed email sending. Use jest.mock for the module. Function: const sendEmail = async (to, subject, body) => { await axios.post('https://api.emailservice.com/send', { to, subject, body }); }; ``` **Usage Example:** The prompt will generate a test with `jest.mock('axios')` and two test cases: success and network error. ## Prompt 9: Test Fixtures and Setup/Teardown **Task:** Generate a pytest fixture for a complex object (e.g., a database connection or a web driver). **Prompt:** ``` Create a pytest fixture that sets up a temporary SQLite database, populates it with sample data, and tears it down after each test. Use scope='function'. Then write a test that queries the database. Database schema: CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT, price REAL); ``` **Usage Example:** The AI will output a fixture that creates a database file in `tmp_path` and a test that inserts and queries products. ## Prompt 10: Integration Test with Docker Compose **Task:** Generate an integration test that requires a running Docker container (e.g., PostgreSQL). **Prompt:** ``` Write an integration test in Python that connects to a PostgreSQL database running in a Docker container using testcontainers-python. Test inserting a record and reading it back. Use pytest fixtures for container lifecycle. Function to test: def save_user(conn, user: dict) -> int: cursor = conn.cursor() cursor.execute("INSERT INTO users (name, email) VALUES (%s, %s) RETURNING id", (user['name'], user['email'])) conn.commit() return cursor.fetchone()[0] ``` **Usage Example:** This advanced prompt leverages the `testcontainers` library to spin up a real PostgreSQL container, run tests, and shut it down automatically. ## Conclusion These 10 prompts cover a wide range of testing scenarios, from simple unit tests to complex integration tests with external dependencies. Whether you use pytest, Jest, or unittest, adapting these prompts to your specific framework is straightforward. The key is to be explicit about the expected behavior, edge cases, and mocking strategy. By incorporating these prompts into your workflow, you can significantly accelerate test generation and improve code quality. Remember, AI-generated tests are a starting point — always review and run them to ensure they match your business logic. Happy testing!

10 Prompts for Writing Unit and Integration Tests with AI

Comments

Recent articles

10 Expert Prompts for CI/CD: GitHub Actions, GitLab CI, and ArgoCD

Automating International Transfers with Wise: How the ASI Biont AI Agent Turns the Financial Pipeline into Reality

The Only AI Glossary You’ll Need This Year: Decode Vibe Coding and Beyond

Agent-Driven Development: How Copilot Applied Science Is Rewriting the Rules of Coding

How ASI Biont AI Agent Automates Stripe Payment Reconciliation and Subscription Billing Without Code

OpenAI Proposed Donating 5% of Its Equity to a US Sovereign Wealth Fund: What It Means for AI Governance

10 Prompts for Debugging and Bug Hunting: An Expert Guide to AI-Assisted Code Repair

PlayStation Just Struck a Hammer Blow to Game Preservation: A Developer’s Perspective on the PS5 Pro and Its AI/ML Implications

PAD+ AI v4.0: The Cognitive Architecture That Finally Makes LLMs Think, Not Just Talk