Unit Testing Skills for AI Agents

Jest unit testing patterns with mocking, spies, snapshots, and async testing

User-centric React component testing with queries, events, and async utilities

Blazing fast Vite-native unit testing with Jest-compatible API and ESM support

Python testing with pytest fixtures, parametrize, markers, and plugins

Mock Service Worker for seamless API mocking in browser and Node.js environments

Official Vue.js testing utilities for component mounting, mocking, and assertions

Track test coverage with Istanbul/nyc, generate reports, and enforce thresholds

Test React, Vue, and Angular components in isolation with Storybook interactions and play functions

Angular TestBed component testing with dependency injection, async testing, and Jasmine

Component and API snapshot testing to detect unexpected changes across releases

Test-driven development workflow patterns with red-green-refactor cycle and refactoring techniques

Test data strategies using Faker.js, factories, builders, and database seeding

Test isolation techniques including database cleanup, transaction rollback, parallel test execution, and shared resource management.

Coverage-guided fuzz testing using libFuzzer for C/C++ applications to find memory corruption, buffer overflows, and crash-inducing inputs.

Test quality verification with Stryker mutation testing for JavaScript and TypeScript

Master the Test-Driven Development approach with Red-Green-Refactor cycles, writing tests before code, comprehensive coverage patterns, and quality code practices for building robust, maintainable software.

Flutter app testing with widget tests, integration tests, golden tests, Mockito, bloc testing, and Flutter Driver for end-to-end scenarios.

Test fixture design patterns including builders, factories, object mothers, and fixture management for maintainable test data setup.

Test-Driven Development mastery with red-green-refactor cycle, outside-in TDD, test-first design, and incremental development patterns.

Svelte component testing with @testing-library/svelte, vitest, component rendering, event simulation, store testing, and SvelteKit testing.

Go testing with testing package, table-driven tests, subtests, benchmarks, test fixtures, httptest, and testify assertions.

Approval testing methodology using ApprovalTests library for verifying complex outputs against human-approved results with diff-based review.

Swift testing with XCTest, Swift Testing framework, async/await testing, SwiftUI preview testing, and performance measurement.

Flexible JavaScript testing framework with async support, hooks, and rich reporter ecosystem

API mocking with Mock Service Worker for browser and Node.js environments including request interception, response simulation, and network error testing.

Writing custom static analysis rules for ESLint, Semgrep, and SonarQube to enforce project-specific code quality and security standards.

FastAPI application testing with TestClient, dependency injection overrides, async testing, database testing with SQLAlchemy, and OpenAPI validation.

Fuzz testing for Rust applications using cargo-fuzz and libFuzzer to discover memory safety issues, panics, and undefined behavior.

Express.js API testing with supertest, middleware testing, route handler testing, error handling verification, and authentication testing.

Vue.js component testing using Vue Test Utils with mount/shallow mount, event simulation, Vuex/Pinia store testing, and composition API testing.

Generative testing with fast-check to discover edge cases automatically

Testing library backward compatibility including public API surface verification, semver compliance, TypeScript type compatibility, and migration path validation.

Comprehensive guide to test doubles including mocks, stubs, spies, fakes, and dummies with when-to-use guidelines and anti-pattern avoidance.

Identify untested code paths, uncovered branches, and missing test scenarios using coverage analysis, risk mapping, and change-based coverage tracking

Advanced debugging patterns for test failures covering root cause analysis, flakiness investigation, performance debugging, and systematic troubleshooting methodologies.

Optimizing test suite execution speed with parallelization, test splitting, caching, selective test execution, and test impact analysis.

Data-driven testing with parameterized tests, test matrices, combinatorial testing, and pairwise parameter generation techniques.

NestJS application testing with @nestjs/testing, dependency injection mocking, e2e testing with supertest, guard testing, and pipe validation testing.

Build reusable test data factories with builder patterns, realistic fake data generation, relationship handling, and database seeding for consistent test environments

Rails application testing with RSpec, FactoryBot, Capybara, system tests, request specs, model specs, and Rails-specific testing conventions.

Laravel PHP testing with PHPUnit, feature tests, browser tests with Dusk, database factories, mocking facades, and HTTP testing helpers.

Systematically generate negative test cases covering invalid inputs, unauthorized actions, missing required fields, exceeded limits, and malformed request payloads

Flask application testing with test client, fixture patterns, SQLAlchemy model testing, blueprint testing, and Flask-specific extension testing.

Generate boundary value test cases for numeric ranges, string lengths, date ranges, collection sizes, and domain-specific constraints using systematic analysis techniques

Validate error boundary implementations in React and other frameworks ensuring graceful degradation, proper fallback UI rendering, and error recovery flows

Modern JavaScript testing strategies with Jest, Mocha, and testing best practices covering unit testing, integration testing, mocking, async patterns, and DOM testing.

Generate comprehensive test cases from state machine models covering all states, transitions, guard conditions, and invalid transition attempts for workflow-heavy features

Generate and evaluate mutation tests to assess test suite effectiveness by introducing controlled code mutations and verifying test detection rates

Smart contract testing with Hardhat, Foundry, and Brownie including unit tests, gas optimization, reentrancy checks, and fork testing.

Generate comprehensive test plans with coverage matrices and risk-based testing

Generate optimized test combinations using pairwise (all-pairs) testing algorithms to achieve maximum coverage with minimum test cases across multiple input parameters

Component testing with Cypress including mount API, React/Vue/Angular component testing, stub patterns, and visual snapshot testing.

Testing error handling paths including exception propagation, error boundaries, retry logic, circuit breakers, and graceful degradation.

Golden file testing pattern for comparing output against approved baselines with update workflows, diff tools, and version control integration.

Enforces rigorous verification evidence before any claims of task completion, preventing false positives, untested deployments, and premature celebration with a structured gate function.

Isolating and testing individual UI components with dependency mocking, state injection, and visual snapshot verification.

Testing application configurations including environment variable validation, feature flag combinations, config file parsing, and default value verification.

Kotlin testing with JUnit 5, MockK, Kotest, coroutine testing, Android testing with Espresso, and Kotlin-specific assertion libraries.

Advanced mutation testing using Stryker, PIT, and mutmut to measure test suite quality by introducing controlled mutations and tracking kill rates.

Spring Boot application testing with @SpringBootTest, MockMvc, @DataJpaTest, Testcontainers, and Spring Security testing patterns.

Comprehensive Python testing best practices with pytest, covering unit testing, integration testing, mocking, fixtures, property-based testing, and test architecture.

Next.js application testing covering Server Components, App Router, API routes, middleware, dynamic routes, and SSR/SSG testing patterns.

Generating realistic test data with Faker libraries for names, addresses, emails, dates, and domain-specific data with reproducible seed control.

Testing WebAssembly modules including compilation verification, memory management, interop testing, and performance benchmarking of WASM components.

Optimizing test coverage beyond line coverage including branch coverage, mutation score, path coverage, and identifying meaningful coverage gaps.

Testing serverless functions including Lambda, Cloud Functions, and Edge Functions with local emulation, cold start testing, and timeout handling.

Rust testing with built-in test framework, integration tests, doc tests, property-based testing with proptest, and cargo test configuration.

HTTP request mocking with Nock for Node.js testing including request intercepting, response recording, and external API simulation.

.NET testing with xUnit, NUnit, MSTest, FluentAssertions, Moq, integration testing with WebApplicationFactory, and Entity Framework testing.

Modern JavaScript and TypeScript testing with Vitest, covering unit testing, integration testing, mocking, snapshots, browser mode, and Vite integration.

Testing event sourcing patterns including event store validation, projection testing, saga orchestration, and event versioning compatibility.

Django application testing with TestCase, fixtures, factory_boy, model testing, view testing, middleware testing, and Django REST framework testing.

Testing concurrent code including race condition detection, deadlock prevention, thread safety verification, and parallel execution correctness.

Building hermetic tests that are fully isolated from external dependencies using fakes, containers, and deterministic time/random sources.