Prompt Library

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Generate comprehensive JUnit unit tests for the following Java class or method: Code: {paste code here} Guidelines: • Use JUnit 5 • Include positive, negative, boundary, and exception cases • Mock external dependencies using Mockito • Follow the Arrange-Act-Assert structure • Aim for 90%+ code coverage • Suggest improvements if the code is not easily testable Output format: 1. Imports 2. Test class 3. Individual test methods with explanations 4. Coverage summary 5. Missing edge cases (if any)

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Write high-quality Jest unit tests for the following JavaScript/TypeScript code (non-UI logic such as utils, services, pure functions, etc.): Code: {paste code} Requirements: • Use Jest as the test runner • Focus on business logic, pure functions, helpers, or services (non-UI) • Include assertions for valid, invalid, and boundary inputs • Mock external dependencies (HTTP clients, DB/SDK, timers, etc.) • Cover asynchronous behavior (promises, async/await) where applicable • Ensure coverage > 90% Output format: - Test file with imports - Individual test blocks with clear, descriptive names - Mocks/spies/stubs setup - Notes on untestable areas or recommended refactors

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Write Jest + React Testing Library unit tests for the following React component(s): Component Code: {paste React component(s)} Context: - State management: {Redux / Zustand / Context API / none} - Routing: {React Router / Next.js / none} Requirements: • Use Jest with React Testing Library • Test rendering, props, state changes, callbacks and side-effects • Interact with the component like a real user (click, type, select, etc.) • Cover different props combinations and edge cases • Mock network calls, context providers, and external modules as needed Output format: 1. Test file with imports 2. Test cases grouped by behavior (rendering, interactions, conditional UI) 3. Usage of RTL queries (getByRole, getByText, etc.) and user-event 4. Notes on improving component testability (if relevant)

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Generate Angular unit tests for the following component and/or service: Angular Code: {paste component/service} Angular Version: {vX.X} Requirements: • Use Angular TestBed with Jasmine and Karma (or Jest if specified) • For components: test template bindings, inputs, outputs, DOM changes, and interactions • For services: test business logic, HTTP calls (HttpTestingController), and error handling • Mock dependencies using TestBed providers or spies • Include positive, negative, boundary and error scenarios Output format: 1. Test module/TestBed setup 2. Individual test cases for each behavior 3. Mock/stub configuration for services and HTTP 4. Suggestions for refactoring to improve testability (if needed)

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Write unit tests for the following Vue.js component(s): Vue Component Code: {paste component} Stack: - Vue Version: {2 / 3} - Test Runner: {Vitest / Jest} - State Management: {Vuex / Pinia / none} Requirements: • Use Vue Test Utils with Vitest or Jest • Test rendering, props, events, emitted outputs, and reactive state • Interact with the component (clicks, inputs, selects, etc.) • Mock HTTP calls, global plugins, and stores where required • Cover different prop values and edge conditions Output format: 1. Test setup (mount/shallowMount, plugins, stores) 2. Test cases grouped by feature/behavior 3. Emitted events and DOM assertion examples 4. Recommendations for improving component testability (if applicable)

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Generate complete Pytest unit tests for the following code: Code: {paste here} Guidelines: • Use pytest (no unittest boilerplate) • Include fixtures for reusable test data • Mock external dependencies using unittest.mock or pytest-mock • Validate positive, negative, edge, and exception flows • Ensure high branch coverage Output format: 1. Imports 2. Fixtures 3. Test cases 4. Coverage summary 5. Suggested improvements to make code more testable

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Write robust xUnit unit tests for the following C# code: Code: {paste code here} Guidelines: • Use xUnit test framework • Mock dependencies using Moq • Include expected success, failure, boundary and exception scenarios • Follow Arrange-Act-Assert structure • Validate thrown exceptions using Assert.Throws Output format: - Test class with imports - Individual test methods with meaningful names - Mock configuration - Missing edge case recommendations

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Write Go unit tests for the following code: Code: {paste here} Guidelines: • Use the Go testing package • Prefer table-driven tests • Mock external dependencies using gomock or lightweight test doubles • Cover success, failure, boundary, and concurrency (if applicable) • Add benchmarks if relevant Output format: - _test.go file content - Table-driven test blocks - Helper functions / mocks - Improvement notes (if needed)

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Generate complete PHPUnit unit tests for the following PHP code: Code: {paste code here} Guidelines: • Use PHPUnit 10 • Mock dependencies using Mockery • Include positive, negative, edge and exception flows • Validate return values, state changes, and DB/API interactions (mocked) Output format: - Test class - Test methods with clear descriptive names - Mock configuration - Remaining edge case suggestions

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Write RSpec unit tests for the following Ruby code: Code: {paste here} Guidelines: • Use RSpec 3 • Follow describe / context / it structure • Use mocks/stubs via rspec-mocks • Cover happy, sad, edge and exception paths • Recommend refactorings if the code is difficult to test Output format: - RSpec test file - Blocks grouped by behavior - Mock/stub usage - List of uncovered edge cases

You are a Senior Software Engineer specializing in writing high-coverage unit tests with deep expertise in testability, mocking, clean code practices, and edge-case validation. Generate complete Swift unit tests for the following code: Code: {paste code} Guidelines: • Use XCTest framework • Mock dependencies using protocol-based stubs/mocks • Ensure success, failure, edge, and async cases are covered • Validate business logic and state transitions Output format: 1. Test class 2. Individual test methods 3. Mocks/Stubs 4. Coverage notes 5. Recommendations for improving testability

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Design and improve API integration tests for the following APIs: APIs / Endpoints involved: {list endpoints and their purpose} Context: - System / Product: {describe} - Tech Stack: {backend language, framework, API gateway if any} - Auth Method: {JWT / OAuth2 / API key / Session} Goals: • Validate request/response correctness, status codes, and error handling • Validate data contracts (required fields, types, constraints) • Cover integration flows across multiple dependent APIs • Include positive, negative, boundary, and failure-path scenarios Output format: 1. List of integration test scenarios grouped by flow 2. For each scenario, specify: - Pre-conditions - API calls sequence (with dependencies) - Expected responses and side effects - Validation points (DB / cache / queues / logs if applicable) 3. Suggestions for automating these tests (tooling, framework, and structure) 4. Additional edge cases or resilience tests you recommend

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Create an integration testing approach for the microservices described below: Microservices and Responsibilities: {list services and what they do} Data Flow / Events: {describe or paste diagrams if available} Goals: • Validate service-to-service communication (sync and async) • Validate event/queue/topic flows (Kafka/RabbitMQ/etc.) • Ensure data consistency across services and databases • Identify failure points and retry/compensation behavior Output format: 1. Integration test strategy tailored to these microservices 2. Test scenarios grouped by business flow (order, payment, notification, etc.) 3. For each scenario, specify: - Services involved - APIs/events used - Test data and pre-conditions - Expected cross-service behavior and data consistency checks 4. Suggestions for automation stack (test framework, mocking strategy, environment setup) 5. Recommended resilience tests (time-outs, partial failures, retries, idempotency)

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Design integration tests for code that interacts with the database as described below: Code / Modules: {paste code or describe modules} Database Details: - Type: {PostgreSQL / MySQL / MongoDB / etc.} - Key Tables/Collections: {list} - Important Constraints: {FKs, unique, not null, etc.} Goals: • Verify that queries and ORM logic work correctly end-to-end • Validate transactions, rollback behavior, and isolation expectations • Ensure constraints and indexes are respected • Cover migration/rollback scenarios if relevant Output format: 1. List of integration test scenarios involving DB operations 2. For each scenario include: - Preloaded test data (seed) - Operation(s) under test - Expected DB state before and after - Rollback / error handling expectations 3. Recommended tooling and patterns (test containers, in-memory DB, fixtures) 4. Suggestions to keep tests stable, performant, and CI-friendly

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Create integration test scenarios for interactions with third-party or external systems described below: External Systems / Providers: {payment gateway, SMS provider, CRM, etc.} Integration Style: - Sync: {REST/SOAP/GraphQL} - Async: {webhooks, queues, events} Goals: • Validate correct requests sent to providers • Validate handling of provider responses, including errors and timeouts • Ensure correct behavior for retries, idempotency, and partial failures Output format: 1. List of integration test scenarios per provider 2. For each scenario specify: - Triggering action in your system - Expected requests to third-party - Mocked responses (success, failure, timeout, throttling, malformed) - Expected behavior in your system (state, logs, notifications) 3. Recommendations for using sandbox environments vs mocks/stubs 4. Suggestions for ongoing regression automation

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Design end-to-end (E2E) test flows for the following web application: Application Description: {describe app} Key User Roles: {list roles} Critical User Journeys: {checkout, signup, login, etc.} Goals: • Cover real user paths from UI through backend to DB and external services • Validate business rules and critical workflows • Include positive, negative, and edge-case flows Output format: 1. List E2E scenarios grouped by user role and journey 2. For each scenario specify: - Pre-conditions (accounts, data, config) - Step-by-step user actions in the browser - Expected UI behavior and backend side effects - Data validation points (DB, logs, emails, notifications) 3. Suggestions for automating these flows (tool choice: Cypress/Playwright/etc.) 4. Smoke vs regression test set recommendations

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Create end-to-end (E2E) test flows for the mobile application described below: App Description: {describe} Platforms: {iOS / Android} Important Features / Journeys: {login, onboarding, payments, push notifications, etc.} Goals: • Test user journeys across app, backend APIs, and push/notification systems • Cover online/offline behavior where relevant • Address device fragmentation (screen sizes, OS versions) Output format: 1. E2E test scenarios grouped by feature/journey 2. For each scenario specify: - Device/OS assumptions - User actions in the app - Expected app UI states and navigation - Backend/API and notification side effects 3. Recommendations for test automation tools (Appium, Detox, etc.) 4. Suggestions for stable test data and environment setup

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Identify and define E2E tests for the most critical business journeys in this system: Business Context: {domain: e-commerce, fintech, SaaS, healthcare, etc.} Key Business Outcomes: {successful payment, subscription renewal, order fulfillment, etc.} Goals: • Protect revenue-critical and compliance-critical flows • Ensure cross-system reliability (UI + services + external providers) Output format: 1. List of critical business journeys (with short description of value/impact) 2. For each journey specify: - Start trigger (user action, scheduled job, API call) - Systems/modules involved - End condition of a "successful journey" - E2E test scenarios (happy path + key failure paths) 3. Tag each scenario as Smoke / Regression / High-Risk 4. Recommendations for which journeys must always run before every release

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Generate robust Selenium-based UI test scenarios and skeleton code for the web app described below: Application / Page(s): {describe or paste URLs} Tech Stack: {frontend framework if known} Goals: • Automate key UI flows • Interact with forms, tables, modals, and dynamic elements • Ensure cross-browser compatibility (Chrome, Firefox, Edge, etc.) Output format: 1. List of Selenium test scenarios (high-level) 2. For each scenario provide: - Steps to perform in browser - Expected UI results 3. Provide example Selenium test code in {language: Java/Python/C#} 4. Suggestions for locator strategy (data-testid, CSS, XPath) and page-object design

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Create Cypress test scenarios and sample specs for the following web application/pages: Application / Components: {describe or list pages} Goals: • Cover core UI flows using Cypress best practices • Validate front-end logic, client-side validation, and basic API calls • Ensure selectors are stable and test-friendly Output format: 1. Test scenarios grouped by page/feature 2. Cypress spec examples including: - visit(), get(), contains(), click(), type(), intercept(), etc. - Assertions for UI state and network calls 3. Recommendations for test structure (spec organization, fixtures, commands.js) 4. Suggestions for running these tests in CI

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Design Playwright-based UI tests for the web app described below: Application / Flow: {describe} Browsers / Devices: {Chromium, Firefox, WebKit; desktop/mobile viewport} Goals: • Test UI behavior across browsers • Validate visual and functional behavior under realistic conditions Output format: 1. List of Playwright test scenarios 2. Example Playwright test file in {TypeScript/JavaScript} including: - Page navigation - Element interactions - Assertions - Network interception if relevant 3. Suggestions for using fixtures, test hooks, and parallel execution 4. Recommendations for handling flakiness (waiting strategies, retries)

You are a Senior Software Engineer and QA Automation Specialist with deep expertise in microservices, CI/CD pipelines, API contracts, data flows, mocking/stubbing, business workflows, and edge-case validation. Create Puppeteer-based browser automation scenarios for the web page or flow described below: Page / Flow: {describe or paste URL} Goals: • Automate key navigations and interactions • Perform DOM checks and screenshot capture • Optionally measure performance metrics Output format: 1. List of browser automation scenarios 2. Example Puppeteer scripts that: - Launch browser and page - Navigate and perform actions - Assert on DOM/text/attributes - Optionally capture screenshots / PDFs 3. Recommendations when to use Puppeteer vs full E2E test frameworks 4. Suggestions for integrating scripts in CI pipelines

You are a Senior Performance Engineer and SRE with deep expertise in load, stress, spike, and endurance testing for distributed systems. Generate a comprehensive performance test plan for the system described below. System / Application Description: {describe app: APIs, web app, microservices, queues, DB, etc.} Non-Functional Requirements / SLAs (if known): {throughput, latency, error rate, CPU/memory limits, etc.} Context: - Users/Clients: {estimated concurrent users or RPS} - Tech Stack: {backend, DB, infra} - Environments: {staging, perf, prod-like} Goals: • Define clear objectives for performance testing (speed, scalability, stability, capacity) • Cover Load, Stress, Spike, and Soak/Endurance testing types • Map business flows to performance scenarios • Identify metrics, tools, and environments needed Output format: 1. Introduction and scope of performance testing 2. Types of performance tests to be executed (Load, Stress, Spike, Soak) 3. Key user journeys / APIs to be tested and why they matter 4. Test environment requirements and assumptions 5. Workload model (concurrent users, RPS, ramp-up patterns, test duration) 6. Metrics to collect (response times, percentiles, error rates, resource utilization, etc.) 7. Pass/fail criteria and SLA/ SLO definitions 8. Tools and frameworks recommendation (JMeter / k6 / Locust / others) 9. Risks, constraints, and dependencies 10. Reporting format and schedule

You are a Senior Performance Engineer and SRE with deep expertise in load testing APIs using tools like JMeter, k6, and Locust. Create detailed load test scenarios for the following API(s). APIs / Endpoints: {list endpoints with brief purpose} Tool Preference: {JMeter / k6 / Locust / any} Target Load: - Baseline RPS: {X} - Peak RPS: {Y} - Expected concurrent users: {Z} - Test duration: {e.g., 30 min steady state} Goals: • Validate that APIs can handle expected production load • Ensure response times and error rates meet SLAs • Identify performance bottlenecks under normal/peak load Output format: 1. List of load test scenarios per API (happy path + critical variants) 2. For each scenario specify: - Endpoint and HTTP method - Request payloads and parameter variations - Load pattern (ramp-up, steady state, ramp-down) - Expected success criteria (latency percentiles, error rate, throughput) 3. Suggest how to model these in {chosen tool} (threads/VUs, stages, duration, thresholds) 4. Optional: Provide a starter script structure or pseudo-code for {chosen tool} 5. Recommendations for running these tests in CI/CD and analyzing results

You are a Senior Performance Engineer and SRE with deep expertise in stress testing distributed systems. Design stress test scenarios to find the breaking point of the system described below. System / Application Description: {describe app} Current Known Limits (if any): {RPS, concurrent users, infra limits} Goals: • Discover the maximum load the system can handle before failure • Observe failure modes (graceful degradation vs hard crash) • Validate auto-scaling and fall-back mechanisms (if any) Output format: 1. Stress test strategy overview 2. Stress test scenarios including: - Starting load and step increments - Ramp-up pattern (how fast to increase load) - Max load targets and stop conditions 3. For each scenario specify: - Metrics to watch (latency, errors, CPU, memory, saturation, queue depth, etc.) - Failure signals that indicate breaking point 4. Recommendations for tooling (JMeter / k6 / Locust) and configuration 5. Suggestions on how to interpret results and set safe capacity limits

You are a Senior Performance Engineer and SRE with deep expertise in handling bursty and spiky traffic patterns. Create spike test scenarios for the system or APIs described below. System / API Description: {describe} Typical Traffic vs Spikes: - Normal load: {X RPS / users} - Spike load: {Y RPS / users} - Spike frequency: {how often spikes happen} Goals: • Validate system behavior under sudden traffic spikes • Check how quickly the system recovers after a spike • Verify auto-scaling, rate limiting, and backpressure mechanisms Output format: 1. Description of spike patterns (shape, magnitude, duration) 2. Test scenarios including: - Baseline steady load - Instant jump to spike load - Return to baseline 3. For each scenario specify: - Metrics to monitor (latency, errors, saturation, scaling events) - Expected behavior and acceptable degradation 4. Suggestions for implementing spike tests in JMeter / k6 / Locust 5. Recommendations for alerting and dashboards to watch during spikes

You are a Senior Performance Engineer and SRE with deep expertise in long-duration stability and endurance testing. Design a soak test for the system below to uncover memory leaks, resource exhaustion, and slow degradation. System / Application Description: {describe} Expected Continuous Load: {RPS / concurrent users / job throughput} Test Duration Target: {e.g., 8 hours, 24 hours, 72 hours} Goals: • Ensure the system remains stable under sustained load • Detect memory leaks, connection leaks, slow performance degradation • Validate log growth, disk usage, and other long-term resource patterns Output format: 1. Soak test workload model (load level, ramp-up, duration) 2. Test scenarios describing which flows/APIs will be exercised continuously 3. Monitoring and metrics checklist (infra, app, DB, queues, GC, etc.) 4. Pass/fail criteria based on stability and performance thresholds 5. Recommendations for test tooling setup (JMeter / k6 / Locust) and scheduling 6. Suggestions for comparing start vs end-of-test system health

You are a Senior Web Performance Engineer with deep expertise in Core Web Vitals, frontend optimization, and browser performance analysis. Analyze and propose browser performance test scenarios for the web page or application described below. Page / Application URL(s): {list URLs or routes} Tech Stack: {framework: React / Angular / Vue / plain JS, SSR/SPA/MPA, CDN usage, etc.} User Context: - Target devices: {desktop, mobile} - Target networks: {3G, 4G, WiFi} - Key markets/regions: {if relevant} Goals: • Evaluate and improve page load performance and runtime responsiveness • Optimize Core Web Vitals (LCP, FID/INP, CLS, TTFB, etc.) • Identify render-blocking resources and heavy scripts Output format: 1. Browser performance testing strategy using tools like Lighthouse, WebPageTest, and browser devtools 2. Test scenarios including: - First visit (cold cache) - Repeat visit (warm cache) - Different device/network profiles 3. Metrics to capture (Core Web Vitals, bundle size, requests, CPU time, memory usage) 4. A checklist of frontend optimization opportunities (images, fonts, JS/CSS, caching, lazy loading) 5. Suggestions for integrating performance checks into CI/CD (budgets, automated Lighthouse runs)

You are a Senior Product Manager and Technical Writer with deep expertise in product strategy, UX thinking, engineering collaboration, and writing implementation-ready Product Requirement Documents. Create a PRD for the feature described below: Feature / Product Description: {describe} Target Users / Personas: {list} Business Goals / Problem to Solve: {describe} Output format: 1. Overview / Background 2. Problem Statement and Why Now 3. Target Users and Personas 4. Goals and Non-Goals 5. User Journeys and UX Narratives 6. Detailed Requirements (functional + non-functional) 7. Dependencies and Assumptions 8. Risks and Limitations 9. Success Metrics / KPIs 10. Release Phases and Milestones Tone: Precise, business-aligned, and implementation-ready for engineering, design, and QA teams.

You are a Senior Product Manager and Technical Writer specializing in standards-driven design documentation and decision clarity. Convert the following feature idea into a complete RFC (Request for Comments) proposal. Feature Summary: {describe} Context / Motivation: {why this feature is needed} Output format: 1. Title and Summary 2. Motivation and Problem Context 3. Proposed Design and Expected Behavior 4. UX and User Impact 5. Technical Implementation Plan 6. API / Database / Service Changes (if any) 7. Deployment and Migration Considerations 8. Security / Privacy / Compliance Factors 9. Alternatives Considered and Decisions Made 10. Open Questions and Pending Decisions Tone: Neutral, technical, structured for engineering leadership review.