Copy-paste prompts that generate production-ready unit tests in seconds. Each prompt produces working test code you can run immediately, not templates or frameworks to fill out later.
These prompts pair well with Jasper AI for Developers-specific tone control, or Copy.ai for fast iteration.
React Component Testing
You are writing Jest unit tests for a React component.
Component name: {component_name} Component props: {prop_names_and_types} Key user interactions: {click_hover_input_events} External dependencies: {api_calls_or_context_used} Edge cases to test: {error_states_empty_data_loading} Testing library: {jest_react_testing_library / enzyme / vitest}
Write 6 to 8 complete test cases covering happy path, user interactions, edge cases, and prop validation. Include proper setup, mocking for external dependencies, and descriptive test names. Output runnable test file with imports.
When to use it: You’ve just finished a React component and need comprehensive test coverage before your PR review tomorrow morning.
Pro tip: Always include at least one test that verifies the component doesn’t crash with undefined props—this catches 80% of production React errors.
You are testing a React form component with validation.
Form component: {form_component_name} Form fields: {field_names_types_validation_rules} Validation library: {yup / zod / joi / custom} Submit behavior: {api_call_redirect_callback} Error handling: {field_errors_submit_errors_network_errors} Required fields: {required_field_names}
Write 5 focused test cases: successful form submission, validation errors on required fields, validation errors on invalid input, network error handling, and form reset behavior. Include user event simulation and async testing patterns. 200 to 300 lines of test code.
When to use it: Your form component is working but you need bulletproof tests before deployment to catch regression bugs.
Pro tip: Test validation by triggering blur events, not just form submission—users trigger validation by clicking away from fields, and these bugs are hard to catch manually.
You are writing snapshot and visual regression tests for a React component.
Component: {component_name} Visual states to capture: {default_loading_error_success_empty} Props variations: {different_prop_combinations} Responsive breakpoints: {mobile_tablet_desktop_widths} Theme variations: {light_dark_high_contrast} Browser support: {chrome_firefox_safari_edge}
Write 4 to 6 snapshot tests covering all visual states and prop combinations. Include proper component wrapping with theme providers and responsive containers. Add comments explaining what each snapshot protects against.
When to use it: You’re about to refactor component styling or structure and need safety nets to catch visual breaking changes.
Pro tip: Update snapshots immediately after intentional design changes, but always review the diff first—auto-updating without checking hides real regressions.
You are testing a React hook with complex state logic.
Hook name: {hook_name} Hook parameters: {input_parameters_and_types} State variables: {state_names_initial_values} Hook methods: {method_names_and_purposes} Side effects: {api_calls_local_storage_timers} Dependencies: {other_hooks_context_external_libs}
Write 7 test cases using React Testing Library’s renderHook: initial state, each method call, side effect triggers, cleanup behavior, and error scenarios. Include proper mocking and async testing. Structure as describe blocks by functionality.
When to use it: You’ve built a custom hook that manages complex state and need thorough testing before other developers start using it.
Pro tip: Test hook cleanup by calling result.unmount() explicitly—memory leaks from untested cleanup functions cause mysterious performance issues in production.
You are writing integration tests for a React component that connects to Redux store.
Component: {connected_component_name} Redux actions: {action_names_and_payloads} Store selectors: {selector_names_and_return_types} Initial store state: {relevant_state_slice} User workflows: {click_sequences_form_flows} Async actions: {thunk_names_api_endpoints}
Write 4 to 5 integration tests covering complete user workflows from interaction to state change. Include store setup, action dispatching verification, and state assertions. Mock API calls but test real Redux logic. 250 to 400 lines of test code.
When to use it: Your component works with Redux and you need to test the full data flow before pushing to staging.
Pro tip: Use a real store with initial state instead of mocking everything—this catches selector bugs and action payload mismatches that unit tests miss.
Python Function Testing
You are writing pytest unit tests for a Python function with business logic.
Function name: {function_name} Function parameters: {param_names_types_defaults} Return type: {return_type_and_structure} Business rules: {validation_logic_calculations} External dependencies: {database_api_file_system} Error conditions: {invalid_input_network_errors_business_rule_violations}
Write 8 to 10 test cases covering happy path, edge cases, error handling, and boundary conditions. Include proper fixtures, mocking, and parametrized tests where appropriate. Use descriptive test names that explain the business scenario.
When to use it: You’ve implemented a core business function and need comprehensive test coverage before code review.
Pro tip: Use pytest.mark.parametrize for testing multiple input combinations—one parametrized test often replaces 5 repetitive test functions and makes maintenance easier.
You are testing a Python class with multiple methods and internal state.
Class name: {class_name} Constructor parameters: {init_params_and_validation} Public methods: {method_names_and_purposes} Internal state: {attributes_that_change} External integrations: {apis_databases_file_operations} Lifecycle behavior: {setup_teardown_resource_management}
Write a complete test class with setup/teardown, 6 to 8 test methods covering method interactions, state changes, and integration points. Include proper mocking and fixture usage. Group related tests with descriptive comments.
When to use it: You’ve built a class that manages complex state or resources and need thorough testing before other code depends on it.
Pro tip: Test method call order dependencies explicitly—if methodA() must be called before methodB(), write a test that verifies methodB() fails appropriately when called first.
You are writing pytest tests for data processing functions with pandas DataFrames.
Function: {data_processing_function_name} Input data structure: {dataframe_columns_types} Processing steps: {filtering_grouping_aggregation_transformation} Output format: {result_columns_data_types} Data quality checks: {null_handling_duplicate_removal_validation} Performance considerations: {large_dataset_memory_usage}
Write 6 test cases covering typical data scenarios, edge cases like empty DataFrames, malformed data handling, and performance with large datasets. Include sample data fixtures and result verification. 300 to 500 lines including test data setup.
When to use it: Your data processing pipeline is complete and you need robust testing before running it on production datasets.
Pro tip: Create small, focused test datasets that expose edge cases rather than using real data—synthetic data with known edge cases catches more bugs than random samples.
You are testing async Python functions that make API calls.
Async function: {async_function_name} API endpoints called: {endpoint_urls_and_methods} Request parameters: {headers_query_params_body} Response handling: {success_parsing_error_handling} Retry logic: {retry_conditions_backoff_strategy} Timeout behavior: {timeout_values_fallback_actions}
Write 7 async test cases using pytest-asyncio covering successful requests, API errors, network timeouts, retry scenarios, and malformed responses. Include proper mocking with aioresponses or httpx_mock. Structure tests by scenario type.
When to use it: You’ve implemented async API integration and need thorough testing before deploying code that makes external calls.
Pro tip: Test timeout scenarios explicitly with real delays, not just mocked timeouts—actual timeout behavior often differs from mocked behavior in subtle ways.
You are writing property-based tests using hypothesis for a Python function.
Function under test: {function_name} Input types: {parameter_types_constraints} Properties to test: {mathematical_invariants_business_rules} Input constraints: {valid_ranges_format_requirements} Output properties: {return_value_characteristics} Edge cases: {boundary_values_special_inputs}
Write 4 to 5 property-based tests using hypothesis strategies. Define custom strategies for complex inputs, test invariant properties, and include examples for edge cases. Add traditional unit tests for specific known scenarios. 150 to 250 lines total.
When to use it: You have a function with complex logic that needs testing beyond manual test cases, especially mathematical or data transformation functions.
Pro tip: Start with simple hypothesis strategies and add constraints gradually—overly complex initial strategies often generate invalid test data that obscures real bugs.
API Endpoint Testing
You are writing integration tests for a REST API endpoint.
Endpoint: {http_method} {endpoint_url} Authentication: {jwt_api_key_oauth_none} Request body schema: {json_structure_required_optional_fields} Success response: {status_code_response_structure} Error responses: {error_status_codes_error_messages} Business logic: {validation_rules_side_effects}
Write 8 to 10 test cases covering successful requests, validation errors, authentication failures, and edge cases. Include proper test data setup, response assertion, and cleanup. Use your testing framework’s HTTP client utilities. 400 to 600 lines with setup.
When to use it: You’ve implemented a new API endpoint and need comprehensive testing before frontend integration begins.
Pro tip: Test with malformed JSON and missing Content-Type headers explicitly—these edge cases cause confusing 500 errors that are hard to debug in production.
You are testing API rate limiting and throttling behavior.
API endpoint: {endpoint_url} Rate limit: {requests_per_time_window} Rate limit headers: {header_names_values} Throttling response: {status_code_response_body} Reset behavior: {time_window_reset_logic} Bypass conditions: {admin_tokens_whitelisted_ips}
Write 5 test cases covering normal usage within limits, rate limit triggering, rate limit headers verification, reset window behavior, and bypass scenarios. Include proper timing and async test handling. Mock time advancement where needed.
When to use it: Your API has rate limiting and you need to verify it works correctly before high-traffic deployment.
Pro tip: Use fixed time mocking instead of real delays for rate limit tests—tests that sleep for real time are flaky and slow down your CI pipeline.
You are writing tests for API authentication and authorization flows.
Authentication method: {jwt_oauth2_api_key_session} Protected endpoints: {endpoint_urls} User roles: {role_names_permissions} Token validation: {expiration_signature_claims} Authorization rules: {resource_access_permissions} Error responses: {unauthorized_forbidden_token_expired}
Write 7 test cases covering successful authentication, token validation, role-based access, token expiration, and permission denial scenarios. Include proper test user setup and token generation utilities. Structure by authentication flow.
When to use it: You’ve implemented auth for your API and need thorough security testing before production deployment.
Pro tip: Test with tokens that are syntactically valid but have invalid signatures—these catch configuration errors in JWT libraries that accept any well-formed token.
You are testing API pagination and filtering functionality.
Endpoint: {paginated_endpoint_url} Pagination style: {offset_cursor_page_number} Page size limits: {min_max_default_page_size} Filter parameters: {filterable_fields_operators} Sort parameters: {sortable_fields_default_order} Response structure: {data_pagination_metadata}
Write 6 test cases covering basic pagination, page boundaries, filtering combinations, sorting behavior, and large result sets. Include edge cases like empty results and invalid pagination parameters. Verify response metadata accuracy.
When to use it: Your API returns paginated data and you need to test all pagination edge cases before frontend developers start using it.
Pro tip: Test with page sizes of 0 and negative numbers explicitly—many pagination libraries have undefined behavior for invalid page sizes that cause 500 errors.
You are writing performance tests for API endpoints under load.
Endpoint: {endpoint_url} Expected load: {requests_per_second} Response time targets: {p50_p95_p99_milliseconds} Concurrent users: {user_count} Test duration: {test_length_minutes} Resource monitoring: {cpu_memory_database_metrics}
Write a load testing script using locust or similar tool with 4 test scenarios: baseline performance, target load, stress testing, and sustained load. Include proper ramp-up, metrics collection, and pass/fail criteria. Add monitoring verification.
When to use it: Your API is ready for production and you need to verify it meets performance requirements under realistic load.
Pro tip: Run load tests against a production-like environment with realistic data volumes—performance tests against empty databases give false confidence.
Database Testing
You are writing tests for database queries and transactions.
Database type: {postgresql_mysql_mongodb_sqlite} Query/function name: {query_name_stored_procedure} Input parameters: {parameter_names_types} Expected results: {result_structure_row_counts} Data dependencies: {required_tables_test_data} Transaction behavior: {commit_rollback_isolation_level}
Write 6 test cases covering successful queries, edge cases with empty results, invalid parameters, transaction rollback scenarios, and performance with large datasets. Include proper test data setup and cleanup. Use database testing utilities.
When to use it: You’ve written complex database queries or stored procedures that need testing before integration with application code.
Pro tip: Use database transactions for test isolation—wrap each test in a transaction and rollback at the end to avoid test data pollution and speed up test runs.
You are testing database migration scripts.
Migration type: {schema_change_data_migration_index_creation} Source schema version: {current_version} Target schema version: {new_version} Data transformation: {column_changes_data_updates} Rollback strategy: {down_migration_backup_restore} Performance impact: {migration_time_downtime_estimate}
Write 5 test cases covering successful migration, rollback functionality, data integrity verification, migration with existing data, and migration failure scenarios. Include before/after schema validation and data consistency checks.
When to use it: You have database migration scripts ready to run and need confidence they won’t break production data.
Pro tip: Test migrations against a copy of production data, not just synthetic test data—real data often has edge cases and inconsistencies that break migrations.
You are writing integration tests for ORM models and relationships.
ORM framework: {sqlalchemy_django_orm_prisma_typeorm} Model name: {primary_model_name} Relationships: {foreign_keys_many_to_many_nested_relations} Model methods: {custom_methods_properties_validation} Database constraints: {unique_constraints_check_constraints} Cascade behavior: {delete_update_cascade_rules}
Write 7 test cases covering model creation, relationship loading, constraint validation, cascade operations, custom methods, and query optimization. Include proper test data factories and relationship verification.
When to use it: Your ORM models have complex relationships and you need to verify they work correctly before building application features on top.
Pro tip: Test N+1 query problems explicitly by counting SQL queries—relationship loading that works fine with test data often creates performance issues with real data volumes.
You are testing database connection pooling and error handling.
Database connection pool: {connection_pool_library} Pool configuration: {min_max_connections_timeout_settings} Error scenarios: {connection_timeout_pool_exhaustion_network_failure} Recovery behavior: {retry_logic_connection_refresh} Monitoring: {pool_metrics_connection_health_checks} Load patterns: {concurrent_requests_sustained_load}
Write 6 test cases covering normal operation, pool exhaustion, connection failures, recovery scenarios, and concurrent access patterns. Include proper async testing and connection state verification. Mock database failures where needed.
When to use it: Your application uses connection pooling and you need to verify it handles failures gracefully before production deployment.
Pro tip: Test pool exhaustion by opening connections without closing them—this simulates application bugs that leak connections and verifies your pool configuration catches them.
You are writing tests for data access layer caching behavior.
Caching layer: {redis_memcached_in_memory_database_cache} Cached operations: {query_types_cache_keys} Cache invalidation: {time_based_event_based_manual} Cache miss handling: {fallback_to_database_error_handling} Cache consistency: {read_through_write_through_write_behind} Performance targets: {cache_hit_ratio_response_time}
Write 5 test cases covering cache hits, cache misses, invalidation scenarios, consistency verification, and performance under load. Include cache state verification and proper test isolation. Mock external cache when needed.
When to use it: You’ve implemented caching for database operations and need to verify cache behavior before enabling it in production.
Pro tip: Test cache invalidation timing carefully—race conditions between cache updates and database writes cause data inconsistency bugs that are hard to reproduce.
Frequently Asked Questions
How do I modify these prompts for TypeScript instead of JavaScript?
Add “TypeScript” to the testing library specification and include “with proper type definitions and interface validation” in the constraints. The prompts will generate typed test code with proper imports and type assertions.
What’s the best way to test API endpoints that require real external services?
Use the API endpoint prompts but add “Mock external service calls using {mocking_library}” to the external dependencies variable. This generates tests with proper service mocking while still testing your integration logic.
Can these prompts generate tests for legacy code without existing test coverage?
Yes, especially the Python function and database testing prompts. Include “legacy code without existing tests” in the business logic variable and specify “focus on critical path scenarios” in the constraints for targeted coverage.