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
npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a claude-codeWhat 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/ordersendpoint betweenOrderServiceandPaymentService - Add a property-based test for the
sortUsersfunction, check that array length stays the same - Set up an integration test with
PostgreSqlContainerfor the user repository
How to install testing-strategies
1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a claude-code2Manually: put the files in place
~/.claude/skills/testing-strategies/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/testing-strategies/
1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a codex2Manually: put the files in place
.agents/skills/testing-strategies/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a cursor2Manually: put the files in place
.cursor/skills/testing-strategies/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install rohitg00/awesome-claude-code-toolkit skills/testing-strategies2Manually: put the files in place
.github/skills/testing-strategies/SKILL.md1Skills CLI (Vercel)
npx skills add rohitg00/awesome-claude-code-toolkit --skill testing-strategies -a gemini-cli2Platform CLI
gemini skills install https://github.com/rohitg00/awesome-claude-code-toolkit --path skills/testing-strategiesManually: put the files in place
.devin/skills/testing-strategies/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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.