Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    test legion

    1

    Deterministic mutation testing and edge-case generation for Python and JavaScript suites.

    $19.90

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    test legion

    test legion

    Example session with this skill installed

    Run a mutation gauntlet on the auth module and show me any survivors. Use a 70% kill-rate threshold.

    • Read your context and instructions
    • Compiled the test legion

    I have executed the mutation gauntlet for the auth module. The system generated 45 mutants by swapping comparison operators and flipping boolean logic. The current suite killed 32 mutants, resulting in a 71.1% kill rate.

    Mutation Analysis: auth_service.py

    Mutant IDTypeLocationStatusResult
    MUT-001ComparisonSwapauth_service.py:42KILLEDCaught by test_expired_token
    MUT-002BooleanFlipauth_service.py:89SURVIVEDNo test covers is_admin logic
    MUT-003BoundaryUpdateauth_service.py:112KILLEDCaught by test_password_min_length
    MUT-004ArithmeticSwapauth_service.py:156SURVIVEDToken expiry calculation not asserted

    Kill Rate Ledger Update

    • Module: src/services/auth
    • Previous Rate: 68.5%
    • Current Rate: 71.1%
    • Status: PASSED (Gate threshold 70%)

    Next steps

    1. Strengthen assertions in tests/test_auth.py to cover the is_admin flag logic identified in MUT-002.
    2. Add a specific test case for token expiry duration to address the survivor at line 156.
    3. Run centurion gate --killrate 75 to lock in this new quality baseline.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Test suites often provide a false sense of security through high code coverage that fails to catch logical errors. Centurion replaces shallow coverage metrics with a mutation gauntlet and an edge-case horde to ensure your tests actually catch bugs. It targets Python and JavaScript/TypeScript codebases, using a deterministic agent architecture to hunt for boundary failures, race conditions, and weak assertions.

    What it does

    • Edge-case generation deploys a matrix of 9,600 boundary hunters to test empty inputs, unicode, concurrency, and malformed data.
    • Mutation testing runs a gauntlet that swaps AST operators to verify if your existing suite can actually detect logic changes.
    • Kill-rate ratcheting enforces a monotonic ledger where module quality scores can only improve, never regress.
    • Flaky test quarantine identifies and isolates non-deterministic tests with a generated hypothesis for the fix.
    • Fixture foraging generates deterministic test fixtures based on real types, schemas, and traffic patterns.

    How it works

    1. Deploy by running centurion deploy <repo> to survey the framework and establish a deployment plan.
    2. Horde the target with centurion horde <module> to generate a parameterized edge-case matrix file.
    3. Mutate the codebase using centurion mutate to identify survivors where logic was changed but tests still passed.
    4. Gate the build with centurion gate to enforce a minimum kill-rate threshold before allowing a merge.

    Frameworks & tools

    Supports Python 3.9+ (pytest) and Node 18+ (Jest, Vitest, Playwright). Works with any CLI-based environment including Claude Code, Cursor, and standard CI/CD shells.

    Why this beats prompting it yourself

    Writing edge cases manually is tedious and prone to human oversight. This skill automates the creation of exhaustive test matrices and uses AST-level mutation to prove your assertions are actually functional rather than just passing.

    Use cases

    • Hardening a mission-critical payment module against boundary condition errors.
    • Identifying "tautology" tests that pass regardless of whether the code works.
    • Enforcing a strict quality floor for new pull requests using the kill-rate gate.
    • Debugging intermittent CI failures by isolating flaky tests into a managed quarantine.

    Known limitations

    The mutation gauntlet will not run if the baseline test suite is currently failing. Core operations are restricted to Python 3.9+ and Node 18+ toolchains.

    Baseline suite must pass before mutation runs. Requires Python 3.9+ or Node 18+. Limited to pytest, Jest, Vitest, and Playwright frameworks.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Browser
    Read Files
    Write Files
    Listed28 days ago

    What's inside

    Frequently Asked Questions

    Test Legion goes beyond coverage metrics by performing AST (Abstract Syntax Tree) mutations, intentionally changing your code's logic to see if your tests notice. This ensures your assertions are actually meaningful and not just passing because they touch the lines of code.

    It is designed for Python 3.9+ (pytest) and Node.js 18+ (Jest, Vitest, Playwright) environments. It integrates seamlessly with CLI-based AI agents like Claude Code and Cursor, as well as standard CI/CD pipelines.

    The 'Kill-rate ratcheting' feature creates a permanent ledger of your code quality. Once a module achieves a certain mutation kill-rate, the 'centurion gate' command prevents any future commits from being merged if they lower that quality score.

    You receive the full Test Legion agent skill, including the edge-case generation engine, the mutation gauntlet, and the flaky test quarantine system. The purchase includes documentation for integration with popular IDEs and CI tools.

    Yes, the 'Fixture foraging' feature analyzes your existing schemas and real traffic patterns to generate deterministic, production-like test data. This saves hours of manual work creating mock objects and edge-case inputs.

    New in Testing & Debugging