Testing & QA Framework

Every DEFONEOS MCP server ships with a dedicated test_*.py suite covering tool discovery, schema validation, input fuzzing, and error handling. Below is a sample of the 30 suites:

DEFONEOS uses hypothesis for property-based testing — generating thousands of random inputs per test to find edge cases that hand-written tests miss.

SIGIL Chain Integrity Property Test

# test_sigil_chain_properties.py
from hypothesis import given, strategies as st
from defoneos_sigil_mcp import SigilChain, SigilEntry

@given(
    actor=st.text(min_size=1, max_size=20),
    action=st.text(min_size=1, max_size=20),
    payload=st.text(min_size=0, max_size=500)
)
def test_sigil_chain_hash_integrity(actor, action, payload):
    """Every SIGIL entry must hash-chain to the previous."""
    chain = SigilChain()
    entry = chain.emit(actor=actor, action=action, payload=payload)
    # Property 1: digest = SHA-256(prev_digest + entry_content)
    expected = hashlib.sha256(
        (chain.last_digest + entry.canonical_form()).encode()
    ).hexdigest()
    assert entry.digest == expected
    # Property 2: Ed25519 signature validates against digest
    assert chain.verify(entry)
    # Property 3: chain cannot be reordered
    chain2 = SigilChain()
    entries = [chain.emit("a","test","x") for _ in range(10)]
    reordered = list(reversed(entries))
    assert not chain2.validate_reordered(reordered)

@given(
    n=st.integers(min_value=1, max_value=1000)
)
def test_sigil_chain_tamper_detection(n):
    """Any single-byte modification must break the chain."""
    chain = SigilChain()
    for i in range(n):
        chain.emit("test_agent", "action_" + str(i), "payload_" + str(i))
    # Tamper entry 5
    tampered = list(chain.entries)
    tampered[5] = tampered[5]._replace(payload="TAMPERED")
    assert not chain.validate(tampered)  # Must detect tampering

YOLOv8 Detection Property Test

# test_yolov8_properties.py
@given(
    width=st.integers(min_value=64, max_value=4096),
    height=st.integers(min_value=64, max_value=4096),
    num_boxes=st.integers(min_value=0, max_value=50)
)
def test_nms_output_bounds(width, height, num_boxes):
    """NMS output must never exceed input box count."""
    boxes = generate_random_boxes(num_boxes, width, height)
    result = nms(boxes, iou_threshold=0.45)
    assert len(result) <= num_boxes
    # Property: no two output boxes overlap > threshold
    for i, j in combinations(result, 2):
        assert iou(i, j) <= 0.45

DEFONEOS runs 5 chaos experiments in staging before every release to verify resilience:

Run Full Suite

# Run all tests (L0-L4) with coverage
pytest tests/ -n auto --cov=defoneos --cov-report=html --cov-fail-under=85

# Run only unit + property tests (fast feedback)
pytest tests/unit/ tests/property/ -n auto --tb=short

# Run only E2E scenarios
pytest tests/e2e/ -m e2e --browser=chromium

# Run chaos experiments (staging only)
python -m defoneos.chaos.run_all --env=staging

Run Single MCP Test Suite

# Test a specific MCP server
pytest tests/mcps/test_defoneos_fusion_mcp.py -v

# Generate hypothesis statistics
pytest tests/property/test_sigil_properties.py --hypothesis-show-statistics

DEFONEOS ships with audit-grade test coverage — every release gated by 1,730+ automated checks.