testing

testing is a skill for Claude Code, Codex from furkangonel/cowrangler. It costs 35 tokens per session (1,466 once invoked), scanned A, original, MIT.

A testing guide covering unit tests, integration tests, end-to-end tests, test-driven development (TDD), and exploratory checks.

In plain words
What is it for?
Use it to plan tests, structure test cases, check web applications, and report bugs with evidence.
Why use it?
It helps find incorrect behavior, edge cases, and failures before users encounter them.

Skill for Claude CodeCodex

Written for no agent in particular: nothing here depends on one. Also seen: positional $N argument.

Needs its repository: it reads a path above its own folder, which exists only inside the repository. The line is jest.mock("../services/EmailService"); // External service.

Good fit Use it to plan tests, structure test cases, check web applications, and report bugs with evidence.

Compare 6 skills from other repositories ↓
Install

Getting it into your agent

It runs from inside its repository, so the clone comes first — what it calls does not travel with the file alone.

Clone the repo
git clone --depth 1 https://github.com/furkangonel/cowrangler
agentmods
npx agentmods add skills/furkangonel/cowrangler/testing

Made for: Claude Code, Codex.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for testing

README.md
[![agentmods](https://agentmods.dev/badge/skills/furkangonel/cowrangler/testing.svg)](https://agentmods.dev/skills/furkangonel/cowrangler/testing)
Your own site
<a href="https://agentmods.dev/skills/furkangonel/cowrangler/testing"><img src="https://agentmods.dev/badge/skills/furkangonel/cowrangler/testing.svg" alt="Measured on agentmods" height="20"></a>
Per session 35 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.
When invoked 1,466 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. A grade says what 26 rules found in the file — not that it is safe.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5.1 $0.00035 $0.01466
Opus 5 $0.00017 $0.00733
Sonnet 5 $0.00007 $0.00293
Haiku 4.5 $0.00003 $0.00147

Measured 4d ago against content hash b75d0d7e88c8, method: parsed. Prices are Anthropic first-party input rates as of 2026-09-07, from the pricing page.

Security

Grade A, and why

testing scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 4d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

bundled_skills/testing/SKILL.md · 175 lines

How it starts

The opening of the file, as written. The whole thing — 175 lines — stays where its author put it; the contents beside it link to each section on GitHub.

Testing SOP

Test Pyramid

        /\
       /e2e\       ← Few, slow, test full user journeys
      /──────\
     /integr. \    ← Some, test component interactions
    /──────────\
   /  unit tests \ ← Many, fast, test single units in isolation
  /──────────────\

What to Test — Behavioral Coverage Checklist

For every function/module, think through:

  • Happy path: normal inputs → expected output
  • Edge cases: empty string, zero, null, undefined, empty array, max integer
  • Error cases: invalid input, missing required field, network failure
  • Boundary values: min/max allowed values, exact boundary, just over/under
  • Side effects: does it correctly modify state, call dependencies?

Test Structure — Arrange, Act, Assert

describe("UserService.createUser", () => {
  it("should hash the password before saving", async () => {
    // ARRANGE
    const mockRepo = { save: jest.fn().mockResolvedValue({ id: "1" }) };
    const service = new UserService(mockRepo);
    const plainPassword = "secret123";

    // ACT
    await service.createUser({ email: "[email protected]", password: plainPassword });

    // ASSERT
    const savedUser = mockRepo.save.mock.calls[0][0];
    expect(savedUser.password).not.toBe(plainPassword);
    expect(savedUser.password).toMatch(/^\$2[aby]\$/); // bcrypt hash
  });

  it("should throw if email already exists", async () => {
    // ARRANGE
    const mockRepo = { save: jest.fn().mockRejectedValue(new DuplicateKeyError()) };
    const service = new UserService(mockRepo);

    // ACT & ASSERT
    await expect(
      service.createUser({ email: "[email protected]", password: "pass" })
    ).rejects.toThrow("Email already in use");
  });
});

Naming Tests

it("should <expected behavior> when <condition>")
it("should throw <error> if <invalid condition>")
it("should return <value> given <input>")

Mocking Strategy

// Mock external dependencies, not internal logic
jest.mock("../services/EmailService");        // External service
jest.mock("../repositories/UserRepository"); // Database layer

// Do NOT mock:
// - The unit under test itself
// - Simple utility functions
// - Pure functions with no side effects

Read the full file on GitHub · 175 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 4d ago First seen · 175 lines · 35 tokens per session scan A b75d0d7e88c8

Subscribe to this mod's changes

testing is a skill published in the GitHub repository furkangonel/cowrangler (2 stars, last pushed yesterday), licensed MIT. It adds 35 tokens to every session and 1,466 once invoked, about $0.0002 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-09-03.

Related

Other skills, from other repositories

implement

Implement a technical design by decomposing it into dependency-ordered vertical slices, executing each with TDD red-green, reviewing each via an isolated sub-agent, and persisting progress to a state file so work survives session restarts. Use when the user has a tech design (doc or settled conversation) and says…

open-octo/octo-agent · 97 tokens

testing-expert

Expert-level software testing with unit tests, integration tests, E2E tests, TDD/BDD, and testing best practices. Use when the user mentions TDD, BDD, unit tests, integration tests, or end-to-end tests, or when the task involves Testing Fundamentals, Unit Testing, Integration Testing, or End-to-End Testing.

personamanagmentlayer/pcl · 73 tokens

cf-tdd

Use when writing new production code, adding features, implementing, or refactoring — e.g. "implement this", "build this feature", "create a function", "add a new endpoint", "write the implementation", "refactor this", "write a test", "add tests", "create a component", "implement the API", "add a route". Also…

dinhanhthi/coding-friend · 136 tokens

test-writer

Write thorough, meaningful tests for any function, module, or API. Use when user asks to add tests, improve coverage, or ensure a piece of code is tested before shipping.

chandrudp29/skillhub · 40 tokens

Testing

Write comprehensive tests using TDD, maintain test coverage, and follow testing best practices.

saolalab/clawforce · 18 tokens

test-generator

Generate comprehensive unit, integration, and end-to-end tests. Use when adding test coverage, writing tests for new features, or improving existing test suites.

asgarovf/locusai · 33 tokens