Skip to main content
skill CX Codex

testing-strategies · rohitg00 — Claude Code skill: testing patterns and strategies

testing-strategies — a skill for contract tests, snapshot tests, property-based tests, and behavior-driven test organization with TypeScript examples.

Apache-2.0 ★ 2,858 updated 2026-05-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a claude-code
Open on GitHub

What testing-strategies does

The skill provides patterns for different test types: contract tests with Pact verify API compatibility between services, snapshot tests capture component output, property-based tests with fast-check find invariant violations. Inside: Arrange-Act-Assert structure examples, integration tests with testcontainers for Postgres, minimal mocks.

The skill shows how to write tests by behavior rather than method names and where each approach fits. Integration tests with a database require testcontainers to run.

What it helps with

  • organize tests by behavior with readable names
  • verify contract between microservices without running both
  • capture component or formatter output with snapshots
  • find edge cases in algorithms via property-based tests
  • run integration tests with a real database in a container

Example prompts for the agent

  • Write a Pact contract test for the /api/orders endpoint between OrderService and PaymentService
  • Add a property-based test for the sortUsers function, check that array length stays the same
  • Set up an integration test with PostgreSqlContainer for the user repository

How to install testing-strategies

1Skills CLI (Vercel)

npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a claude-code

2Manually: put the files in place

~/.claude/skills/testing-strategies/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/testing-strategies/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about testing-strategies

How to install testing-strategies in Claude Code?

Run npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a claude-code, the skill will appear at ~/.claude/skills/testing-strategies/SKILL.md.

What does the testing-strategies skill do?

Provides examples of contract tests with Pact, snapshot tests, property-based tests with fast-check, integration tests with testcontainers, and Arrange-Act-Assert structure for behavior-driven organization.

Which libraries are needed for the skill examples?

Contract tests need @pact-foundation/pact, property-based tests need fast-check, integration tests with a database need @testcontainers/postgresql. Without them, the corresponding examples will not run.

Source text

SKILL.md · Apache-2.0
---
name: testing-strategies
description: Testing strategies including contract testing, snapshot testing, mutation testing, property-based testing, and test organization
---

# Testing Strategies

## Test Structure (Arrange-Act-Assert)

```typescript
describe("OrderService", () => {
  describe("createOrder", () => {
    it("creates an order with valid items and returns order ID", async () => {
      const repo = new InMemoryOrderRepository();
      const service = new OrderService(repo);
      const input = { customerId: "c1", items: [{ productId: "p1", quantity: 2 }] };

      const result = await service.createOrder(input);

      expect(result.id).toBeDefined();
      expect(result.status).toBe("pending");
      expect(result.items).toHaveLength(1);
      const saved = await repo.findById(result.id);
      expect(saved).toEqual(result);
    });

    it("rejects order with empty items", async () => {
      const service = new OrderService(new InMemoryOrderRepository());

      await expect(
        service.createOrder({ customerId: "c1", items: [] })
      ).rejects.toThrow("Order must have at least one item");
    });
  });
});
```

Name tests by behavior, not method name. Each test should be independent and self-contained.

## Contract Testing (Pact)

```typescript
import { PactV4 } from "@pact-foundation/pact";

const provider = new PactV4({
  consumer: "OrderService",
  provider: "UserService",
});

describe("UserService contract", () => {
  it("returns user by ID", async () => {
    await provider
      .addInteraction()
      .given("user with id user-1 exists")
      .uponReceiving("a request for user user-1")
      .withRequest("GET", "/api/users/user-1")
      .willRespondWith(200, (builder) => {
        builder.jsonBody({
          id: "user-1",
          name: "Alice",
          email: "[email protected]",
        });
      })
      .executeTest(async (mockServer) => {
        const client = new UserClient(mockServer.url);
        const user = await client.getUser("user-1");
        expect(user.name).toBe("Alice");
      });
  });
});
```

Contract tests verify that consumer expectations match provider capabilities without requiring both services to be running.

## Snapshot Testing

```typescript
import { render } from "@testing-library/react";

it("renders the user profile card", () => {
  const { container } = render(
    <UserCard user={{ name: "Alice", email: "[email protected]", role: "admin" }} />
  );

  expect(container).toMatchSnapshot();
});

it("renders the order summary with inline snapshot", () => {
  const summary = formatOrderSummary(mockOrder);

  expect(summary).toMatchInlineSnapshot(`
    "Order #123
    Items: 3
    Total: $45.99
    Status: Pending"
  `);
});
```

Use inline snapshots for small outputs. Review snapshot diffs carefully during code review.

## Property-Based Testing

```typescript
import fc from "fast-check";

describe("sortUsers", () => {
  it("always returns the same number of elements", () => {
    fc.assert(
      fc.property(
        fc.array(fc.record({ name: fc.string(), age: fc.nat(120) })),
        (users) => {
          const sorted = sortUsers(users, "name");
          return sorted.length === users.length;
        }
      )
    );
  });

  it("produces a sorted result for any input", () => {
    fc.assert(
      fc.property(
        fc.array(fc.record({ name: fc.string(), age: fc.nat(120) })),
        (users) => {
          const sorted = sortUsers(users, "age");
          for (let i = 1; i < sorted.length; i++) {
            if (sorted[i].age < sorted[i - 1].age) return false;
          }
          return true;
        }
      )
    );
  });
});
```

## Integration Test with Test Containers

```typescript
import { PostgreSqlContainer } from "@testcontainers/postgresql";

let container: any;
let db: Database;

beforeAll(async () => {
  container = await new PostgreSqlContainer("postgres:16").start();
  db = await createDatabase(container.getConnectionUri());
  await db.migrate();
}, 60000);

afterAll(async () => {
  await db.close();
  await container.stop();
});

it("creates and retrieves a user", async () => {
  const user = await db.user.create({ name: "Alice", email: "[email protected]" });
  const found = await db.user.findById(user.id);
  expect(found).toEqual(user);
});
```

## Test Doubles

```typescript
function createMockEmailService(): EmailService {
  const sent: Array<{ to: string; subject: string }> = [];
  return {
    send: async (to, subject, body) => { sent.push({ to, subject }); },
    getSent: () => sent,
  };
}

const emailService = createMockEmailService();
const service = new NotificationService(emailService);
await service.notifyUser("user-1", "Welcome");
expect(emailService.getSent()).toHaveLength(1);
expect(emailService.getSent()[0].subject).toBe("Welcome");
```

## Anti-Patterns

- Testing implementation details instead of behavior
- Sharing mutable state between tests (no `beforeEach` reset)
- Writing tests that depend on execution order
- Mocking everything instead of using real dependencies for integration tests
- Ignoring flaky tests instead of fixing the root cause
- Testing trivial getters/setters while missing edge cases

## Checklist

- [ ] Tests organized by behavior, not by method or file
- [ ] Each test follows Arrange-Act-Assert structure
- [ ] Contract tests verify inter-service API compatibility
- [ ] Snapshot tests reviewed during code review (not blindly updated)
- [ ] Property-based tests cover invariants for algorithmic code
- [ ] Integration tests use test containers for real dependencies
- [ ] Test doubles are minimal and behavior-focused
- [ ] CI fails on flaky test detection

© rohitg00 · Apache-2.0 · rohitg00/awesome-claude-code-toolkit

Similar skills

All skills for Testing and QA →

testing-strategies by other authors comes first.

testing-strategies akillness The testing-strategies skill turns unclear test policy into a focused validation brief. Use it to choose the gate, risk level, and evidence a change needs. CX Codex +1 370installs testing-strategies c0x12c testing-strategies gives your coding agent ready test patterns for a Micronaut and Kotlin backend: integration tests, repository tests, test data builders. CX Codex +1 ★ 111repo stars java-testing-advanced pluginagentmarketplace java-testing-advanced — a Java testing skill that spins up real databases and Kafka in containers, checks API contracts, and hunts coverage gaps with mutation testing. CX Codex +1 333installs langchain4j-testing-strategies giuseppe-trisciuoglio langchain4j-testing-strategies is a Claude Code skill for testing LangChain4j apps in Java. It provides patterns for mocked models, integration checks, and RAG workflows. CX Codex +1 3,900installs contract-testing-builder patricio0312rev contract-testing-builder implements API contract testing with Pact, OpenAPI, and JSON Schema to catch breaking changes before deploying services. CX Codex +1 266installs testing-integration OrchestKit The testing-integration skill supports integration and contract tests for APIs, services, databases, and Zod schemas. It applies when testing API or service boundaries. CX Codex +1 131installs golang-testing-strategies Claude MPM Team golang-testing-strategies — a skill for writing Go tests: table-driven cases, testify assertions, gomock mocks, benchmarks and CI coverage. Useful when a project's test suite needs structure. CX Codex +1 464installs 130-java-testing-strategies Juan Antonio Breña Moral 130-java-testing-strategies — a skill that reviews Java tests through RIGHT-BICEP, A-TRIP and CORRECT: missing cases, flaky tests, boundary conditions. CX Codex +1 401installs

From the same set178

The whole set →
real-estate-tech real-estate-tech designs proptech platforms with MLS feeds, PostGIS spatial queries, property valuation models, and listing pipelines. Helps build property search and transaction backends. CX Codex ★ 2,858repo stars error-coordinator error-coordinator — a subagent classifies failures in multi-agent workflows, selects retry or fallback paths, and preserves the context needed for recovery. CX Codex ★ 2,858repo stars performance-engineer performance-engineer — a subagent that finds bottlenecks through measurement, not guesswork. Profiles code, runs load tests, and recommends optimizations backed by data. CX Codex ★ 2,858repo stars feature-engineer feature-engineer designs feature stores, transformation pipelines, and encoding strategies for ML models. Prevents train-serve skew across batch training and online serving. CX Codex ★ 2,858repo stars geospatial-engineer The geospatial-engineer subagent for Claude Code, Codex, and Cursor builds GIS apps with PostGIS, spatial queries, mapping APIs, and geospatial data pipelines. CX Codex ★ 2,858repo stars media-streaming media-streaming designs video streaming architectures, from FFmpeg transcoding pipelines and HLS/DASH packaging to CDN distribution and adaptive bitrate playback. CX Codex ★ 2,858repo stars accessibility-specialist The accessibility-specialist subagent reviews interfaces against WCAG 2.2, keyboard access, screen readers, and ARIA. Use it during UI accessibility checks. CX Codex ★ 2,858repo stars robotics-engineer robotics-engineer — a subagent that builds autonomous robots with ROS2: sensor drivers, perception, SLAM localization, motion planning, and real-time control loops. CX Codex ★ 2,858repo stars

Project sponsors

Companies that keep this analytics open