Guardrails AI — Testing Guardrails¶

app/guards.py              # guard factories: build_support_guard(), build_triage_guard()
tests/conftest.py          # fixtures, metrics collection off
tests/test_guards.py       # unit + flow tests
tests/data/pii_cases.jsonl # labelled regression samples
tests/test_quality.py      # FP/FN rates, CI thresholds

# app/guards.py
from typing import Literal

from pydantic import BaseModel, Field

from guardrails import Guard, OnFailAction
from guardrails_ai.secrets_present import SecretsPresent
from guardrails_ai.valid_choices import ValidChoices
from guardrails_ai.valid_length import ValidLength


def build_support_guard() -> Guard:
    return (
        Guard(name="support-bot")
        .use(SecretsPresent(on_fail=OnFailAction.EXCEPTION), ValidLength(max=4000, on_fail="exception"), on="messages")
        .use(SecretsPresent(on_fail=OnFailAction.FIX))
    )


class Triage(BaseModel):
    label: str = Field(validators=[ValidChoices(choices=["bug", "feature", "question"], on_fail="reask")])
    priority: Literal["low", "medium", "high"]


def build_triage_guard() -> Guard:
    return Guard.for_pydantic(Triage)

# tests/conftest.py
import pytest

from app.guards import build_support_guard, build_triage_guard


@pytest.fixture
def support_guard():
    guard = build_support_guard()
    guard.configure(allow_metrics_collection=False)     # no anonymous telemetry from CI
    return guard


@pytest.fixture
def triage_guard():
    guard = build_triage_guard()
    guard.configure(allow_metrics_collection=False)
    return guard

def test_clean_answer_passes_unchanged(support_guard):
    outcome = support_guard.validate("Go to Settings -> Security -> Reset 2FA.")
    assert outcome.validation_passed
    assert outcome.validated_output == outcome.raw_llm_output
    assert outcome.validation_summaries == []


def test_secret_in_answer_is_masked(support_guard):
    outcome = support_guard.validate("Use AKIAIOSFODNN7EXAMPLE to call the API.")
    assert outcome.validation_passed                                   # fix => "passed" ...
    assert "AKIAIOSFODNN7EXAMPLE" not in outcome.validated_output
    assert [s.validator_name for s in outcome.validation_summaries] == ["SecretsPresent"]   # ... but reported


def test_guard_wiring(support_guard):
    assert {type(v).__name__ for v in support_guard.get_validators("messages")} == {"SecretsPresent", "ValidLength"}
    assert [type(v).__name__ for v in support_guard.get_validators("output")] == ["SecretsPresent"]


def test_triage_schema(triage_guard):
    ok = triage_guard.parse('{"label": "bug", "priority": "high"}')
    bad = triage_guard.parse('{"label": "urgent", "priority": "high"}', num_reasks=0)
    assert ok.validated_output == {"label": "bug", "priority": "high"}
    assert not bad.validation_passed and bad.validated_output is None

import pytest

CASES = [
    pytest.param("Your order ships tomorrow.", False, id="plain"),
    pytest.param("Contact support@example.com for help.", False, id="email-is-not-a-secret"),
    pytest.param("aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", True, id="aws-secret"),
    pytest.param("token: ghp_1234567890abcdefghijklmnopqrstuvwxyzAB", True, id="github-token"),
]


@pytest.mark.parametrize(("text", "has_secret"), CASES)
def test_secret_detection(support_guard, text, has_secret):
    assert bool(support_guard.validate(text).validation_summaries) is has_secret

import json
from pathlib import Path

from app.guards import build_support_guard

MAX_FNR = 0.02      # missed secrets: security budget
MAX_FPR = 0.05      # blocked clean answers: UX budget


def test_secret_guard_rates():
    guard = build_support_guard()
    tp = fp = fn = tn = 0
    for line in Path("tests/data/secrets_cases.jsonl").read_text().splitlines():
        case = json.loads(line)                               # {"text": "...", "label": true}
        flagged = bool(guard.validate(case["text"]).validation_summaries)
        tp += flagged and case["label"]
        fp += flagged and not case["label"]
        fn += (not flagged) and case["label"]
        tn += (not flagged) and not case["label"]
    fnr, fpr = fn / max(tp + fn, 1), fp / max(fp + tn, 1)
    print(f"TP={tp} FP={fp} FN={fn} TN={tn} FNR={fnr:.3f} FPR={fpr:.3f}")
    assert fnr <= MAX_FNR, f"missed secrets: {fnr:.1%}"
    assert fpr <= MAX_FPR, f"over-blocking: {fpr:.1%}"

import pytest
from guardrails.errors import ValidationError


def test_reask_recovers(triage_guard):
    replies = iter(['{"label": "urgent", "priority": "high"}', '{"label": "bug", "priority": "high"}'])
    sent = []

    def fake_llm(*, messages, **kwargs):
        sent.append(messages)
        return next(replies)

    outcome = triage_guard(llm_api=fake_llm, messages=[{"role": "user", "content": "Checkout crashes"}], num_reasks=1)

    assert outcome.validation_passed and outcome.validated_output["label"] == "bug"
    assert len(triage_guard.history.last.iterations) == 2
    assert "urgent" in sent[1][-1]["content"]                 # reask prompt quotes the bad value


def test_input_block_skips_llm(support_guard):
    calls = []
    with pytest.raises(ValidationError):
        support_guard(llm_api=lambda *, messages, **kw: calls.append(1) or "ok",
                      messages=[{"role": "user", "content": "my key AKIAIOSFODNN7EXAMPLE"}])
    assert calls == []                                        # blocked before the model

def test_reask_exhausted(triage_guard):
    outcome = triage_guard(
        model="anthropic/claude-haiku-4-5",
        messages=[{"role": "user", "content": "Label this"}],
        mock_response='{"label": "urgent", "priority": "high"}',   # every attempt returns the same bad value
        num_reasks=1,
    )
    assert not outcome.validation_passed
    assert len(triage_guard.history.last.iterations) == 2          # original + 1 reask, then stop