More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    FixtureForge

    1

    Generate deterministic, AI-enriched Pydantic test fixtures with automatic foreign key wiring and a pytest plugin.

    Free

    Security scanned
    FixtureForge

    FixtureForge

    Example session with this skill installed

    Generate a pytest conftest.py file that sets up fixtures for User and Order models, ensuring they are deterministic for CI and use the forge_swarm_fixture for a dataset of 5 users and 20 orders.

    • Read your context and instructions
    • Compiled the fixtureforge

    I have generated the conftest.py configuration using fixtureforge. This setup ensures that your User and Order models are correctly wired with foreign key support and remain deterministic for CI environments by using a fixed seed.

    pytest conftest.py configuration

    import pytest
    from fixtureforge.pytest_plugin import forge_fixture, forge_swarm_fixture
    from myapp.models import User, Order
    
    # Individual fixtures for granular control
    # count=1 returns a single instance, others return lists
    forge_fixture(User, count=5, seed=42, name="users")
    forge_fixture(Order, count=20, seed=42, name="orders")
    
    # Swarm fixture for relational datasets
    # This ensures User and Order relationships are resolved automatically
    forge_swarm_fixture(
        models=[User, Order], 
        counts=[5, 20], 
        seed=42,
        name="swarm_data"
    )
    
    # Example usage in a test file:
    # def test_order_linking(swarm_data):
    #     users = swarm_data["User"]
    #     orders = swarm_data["Order"]
    #     assert len(users) == 5
    #     assert all(o.user_id in [u.id for u in users] for o in orders)
    

    Next steps

    1. Ensure myapp.models is accessible in your Python path.
    2. Run pytest with the FORGE_SEED=42 environment variable set in your CI pipeline.
    3. Use the swarm_data fixture in your integration tests to verify FK relationships.

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

    About this skill

    Testing Pydantic models with generic Faker data often results in "Lorem Ipsum" that breaks logic or looks unprofessional during demos. Manual fixture wiring is brittle, especially when handling foreign key relationships across multiple models.

    What it does

    • Semantic Generation calls LLMs for realistic content in fields like bio, description, or review.
    • Structural Routing automatically handles id and *_id fields using a counter and internal FK registry.
    • Deterministic CI switches to pure Faker and sequential counters when use_ai=False is set, ensuring 100% reproducible tests.
    • Automatic FK Wiring resolves relationships between models without manual mapping if the parent model is generated first.
    • Batched API Calls groups semantic field generation to minimize network overhead and costs.

    How it works

    1. Initialize the Forge by creating a Forge instance, optionally passing a seed and use_ai flag.
    2. Define Pydantic Models as standard BaseModel subclasses with typed fields.
    3. Generate Data using create() for single instances or create_batch() for multiple objects.
    4. Apply Domain Rules via forge.memory.add_rule() to inject specific logic into the LLM prompt.

    Frameworks & tools

    This skill requires Python 3.11+, Pydantic 2.5+, and Faker 22.0+. It supports Anthropic, OpenAI, Gemini, and Groq providers.

    Why this beats prompting it yourself

    Writing raw prompts for test data requires manual parsing and validation back into Pydantic models. This tool automates the schema mapping, relationship management, and batching logic that a simple prompt cannot handle natively.

    Use cases

    • Generating realistic user profiles for frontend staging environments.
    • Creating deterministic test suites for CI pipelines that require stable IDs.
    • Building complex relational datasets for integration testing without manual FK mapping.
    • Seeding databases with context-aware product reviews or support tickets.

    Known limitations

    This tool only supports Pydantic BaseModel subclasses. It does not work with plain dictionaries, standard dataclasses, or legacy Pydantic v1 models.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Testing & Debugging.

    Requires Pydantic 2.5+. Supports only BaseModel subclasses, not plain dicts or dataclasses. AI features require provider API keys in environment variables.

    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 buying a skill.

    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

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 16 days ago

    • Free with an Agensi account

    Software
    Python

    Permissions

    Terminal / Shell
    Network Access
    Listed16 days ago
    Updated12 days ago

    What's inside

    Frequently Asked Questions

    Fixtureforge solves the issue of "messy" test data by using LLMs to generate realistic, context-aware content (like bios or reviews) while simultaneously managing complex Pydantic foreign key relationships automatically.

    Yes, you can set `use_ai=False` to switch to a deterministic mode using pure Faker and sequential counters, ensuring your CI/CD pipelines remain 100% reproducible and cost-effective.

    Fixtureforge is built for modern Python environments, requiring Python 3.11+ and Pydantic 2.5+; please note it does not support legacy Pydantic v1 models or standard Python dataclasses.

    The skill includes the core Forge engine, a dedicated pytest plugin for seamless integration into your test suite, and built-in support for OpenAI, Anthropic, Gemini, and Groq providers.

    Relationship management is handled automatically through an internal FK registry; as long as you generate the parent model first, Fixtureforge intelligently maps the IDs to child models without manual configuration.

    New in Testing & Debugging

    Free