ШІ може прискорити проєктування тестів, але його результат повинен потрапляти до репозиторію, системи управління тестами або черги автоматизації лише після детермінованих перевірок. Дійсний JSON доводить лише, що парсер може прочитати документ. Він не доводить, що тест є релевантним, безпечним, виконуваним або повним.

Ця стаття створює нейтральний до провайдера Python‑gate, який розглядає вихідні дані моделі як недовірені дані. Гейт перевіряє невеликий контракт, відхиляє секрети та заборонені дії, створює стабільний дублікат відбитка, позначає випадки, що потребують людського перегляду, і повертає машинозчитувані докази. Він ніколи не виконує згенерований код.

1. Що ворота можуть, а чого не можуть довести

Затвор може довести повторювані властивості:

Він не може довести, що тест покриває вимогу, використовує правильний оракул або становить прийнятний бізнес-ризик. Це залишаються питаннями для людського огляду.

OWASP рекомендує валідувати формати очікуваного виводу та розглядати вихід моделі як недовірений, перш ніж він досягне наступних функцій. Також зазначено, що ін'єкція prompt не має безпомилкової профілактики всередині моделі. Детермінований гейт, таким чином, зменшує вплив; це не ствердження, що ворожий текст був зрозумілий або зроблений безпечним.

2. Потік даних

ШІ or external source
        |
        v
Bounded JSON parsing
        |
        v
Structural validation ---- invalid ----> reject
        |
        v
Sensitive-data scan ------ detected ---> reject
        |
        v
Canonical fingerprint ---- known ------> reject duplicate
        |
        v
Policy checks ------------ warning ----> human review
        |
        v
accept + minimal evidence

Порядок має значення. Код політики не повинен припускати, що необхідні поля існують до проходження структурної валідації. Логування відбувається лише після перевірки чутливих даних, і приклад фіксує докази, а не повне навантаження.

3. Вхідний контракт

Приклад приймає один тестовий випадок:

{
  "title": "Login with an active account",
  "priority": "medium",
  "tags": ["smoke", "authentication"],
  "steps": [
    {
      "action": "navigate",
      "url": "https://example.test/login"
    },
    {
      "action": "type",
      "selector": "#email",
      "value": "${TEST_USER_EMAIL}"
    },
    {
      "action": "click",
      "selector": "#submit"
    },
    {
      "action": "assert",
      "selector": "#dashboard",
      "text": "Dashboard"
    }
  ],
  "metadata": {
    "generator": "provider-neutral-demo"
  }
}

Контракт навмисно виключає виконуваний Python, команди оболонки, довільні назви інструментів, облікові дані та інструкції у вільній формі для іншого агента.

4. Виконувана реалізація стандартної бібліотеки

У наступному прикладі використовується лише стандартна бібліотека Python. Python документує, що парсинг недовіреного JSON може споживати значну кількість процесора та пам'яті, тому довжину сирого байта перевіряють перед викликом json.loads. Обмеження вкладення є додатковим правилом застосування.

from __future__ import annotations

import hashlib
import json
import logging
import re
from typing import Any

MAX_BYTES = 12_000
MAX_DEPTH = 6
ALLOWED_TOP = {"title", "priority", "tags", "steps", "metadata"}
REQUIRED_TOP = {"title", "priority", "steps"}
ALLOWED_PRIORITIES = {"low", "medium", "high"}
ALLOWED_ACTIONS = {"navigate", "type", "click", "assert", "request"}

SENSITIVE_KEY = re.compile(
    r"(api[_-]?key|authorization|password|passwd|secret|token)",
    re.IGNORECASE,
)
SENSITIVE_VALUE = re.compile(
    r"(?:sk-[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9_]{8,}|"
    r"Bearer\s+[A-Za-z0-9._~+/-]+=*)",
    re.IGNORECASE,
)
INSTRUCTION_LIKE = re.compile(
    r"(ignore (all |the )?(previous|prior) instructions|"
    r"reveal (the )?system prompt|act as system)",
    re.IGNORECASE,
)
PLACEHOLDER = re.compile(r"^\$\{[A-Z][A-Z0-9_]*\}$")

logger = logging.getLogger("ai_test_case_gate")


def reject(*reasons: str) -> dict[str, Any]:
    return {"status": "reject", "reasons": list(reasons)}


def check_depth(value: Any, depth: int = 0) -> None:
    if depth > MAX_DEPTH:
        raise ValueError("maximum nesting depth exceeded")
    if isinstance(value, dict):
        for child in value.values():
            check_depth(child, depth + 1)
    elif isinstance(value, list):
        for child in value:
            check_depth(child, depth + 1)


def parse_payload(raw: str) -> dict[str, Any]:
    if not isinstance(raw, str):
        raise ValueError("payload must be a string")
    if len(raw.encode("utf-8")) > MAX_BYTES:
        raise ValueError("payload exceeds byte limit")

    try:
        value = json.loads(raw)
    except json.JSONDecodeError as exc:
        raise ValueError(
            f"invalid JSON at line {exc.lineno}, column {exc.colno}"
        ) from exc

    if not isinstance(value, dict):
        raise ValueError("top-level JSON value must be an object")

    check_depth(value)
    return value


def validate_structure(case: dict[str, Any]) -> list[str]:
    errors: list[str] = []

    missing = REQUIRED_TOP - case.keys()
    extra = case.keys() - ALLOWED_TOP
    if missing:
        errors.append(f"missing fields: {sorted(missing)}")
    if extra:
        errors.append(f"unexpected fields: {sorted(extra)}")

    title = case.get("title")
    if not isinstance(title, str) or not title.strip():
        errors.append("title must be a non-empty string")
    elif len(title) > 200:
        errors.append("title exceeds 200 characters")

    if case.get("priority") not in ALLOWED_PRIORITIES:
        errors.append("priority must be low, medium, or high")

    tags = case.get("tags", [])
    if not isinstance(tags, list) or not all(
        isinstance(tag, str) and tag.strip() for tag in tags
    ):
        errors.append("tags must be a list of non-empty strings")

    steps = case.get("steps")
    if not isinstance(steps, list) or not 1 <= len(steps) <= 20:
        errors.append("steps must contain between 1 and 20 objects")
        return errors

    for index, step in enumerate(steps):
        if not isinstance(step, dict):
            errors.append(f"step {index} must be an object")
            continue

        action = step.get("action")
        if action not in ALLOWED_ACTIONS:
            errors.append(f"step {index} uses a prohibited action")

        if action == "navigate" and not isinstance(step.get("url"), str):
            errors.append(f"step {index} navigate requires url")
        if action == "request":
            method = step.get("method")
            if method not in {"GET", "POST", "PUT", "PATCH", "DELETE"}:
                errors.append(f"step {index} request requires an allowed method")
            if not isinstance(step.get("url"), str):
                errors.append(f"step {index} request requires url")
        if action in {"type", "click", "assert"} and not isinstance(
            step.get("selector"), str
        ):
            errors.append(f"step {index} {action} requires selector")

    return errors


def find_sensitive(value: Any, path: str = "$") -> list[str]:
    findings: list[str] = []

    if isinstance(value, dict):
        for key, child in value.items():
            child_path = f"{path}.{key}"
            if SENSITIVE_KEY.search(str(key)):
                findings.append(f"sensitive field at {child_path}")
            findings.extend(find_sensitive(child, child_path))
    elif isinstance(value, list):
        for index, child in enumerate(value):
            findings.extend(find_sensitive(child, f"{path}[{index}]"))
    elif isinstance(value, str):
        if not PLACEHOLDER.fullmatch(value) and SENSITIVE_VALUE.search(value):
            findings.append(f"secret-like value at {path}")

    return findings


def fingerprint(case: dict[str, Any]) -> str:
    stable = {
        "title": case["title"].strip(),
        "priority": case["priority"],
        "tags": sorted(set(case.get("tags", []))),
        "steps": case["steps"],
    }
    canonical = json.dumps(
        stable,
        sort_keys=True,
        separators=(",", ":"),
        ensure_ascii=False,
    )
    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()


def policy_warnings(case: dict[str, Any]) -> list[str]:
    warnings: list[str] = []

    if case["priority"] == "high" and "smoke" not in case.get("tags", []):
        warnings.append("high priority without smoke tag")

    for index, step in enumerate(case["steps"]):
        for value in step.values():
            if isinstance(value, str) and INSTRUCTION_LIKE.search(value):
                warnings.append(
                    f"instruction-like text in step {index}"
                )

        if step.get("action") == "request" and step.get("method") in {
            "DELETE",
            "PATCH",
        }:
            warnings.append(
                f"state-changing request in step {index}"
            )

    return warnings


def gate(
    raw: str,
    known_fingerprints: set[str] | None = None,
) -> dict[str, Any]:
    known = known_fingerprints or set()

    try:
        case = parse_payload(raw)
    except ValueError as exc:
        return reject(str(exc))

    structure_errors = validate_structure(case)
    if structure_errors:
        return {"status": "reject", "reasons": structure_errors}

    sensitive_findings = find_sensitive(case)
    if sensitive_findings:
        return {"status": "reject", "reasons": sensitive_findings}

    digest = fingerprint(case)
    if digest in known:
        return {
            "status": "reject",
            "fingerprint": digest,
            "reasons": ["duplicate normalized test case"],
        }

    warnings = policy_warnings(case)
    status = "review" if warnings else "accept"

    result = {
        "status": status,
        "fingerprint": digest,
        "reasons": warnings,
        "metrics": {
            "stepCount": len(case["steps"]),
            "tagCount": len(case.get("tags", [])),
        },
    }

    logger.info(
        "gate_result status=%s fingerprint=%s reason_count=%d",
        status,
        digest,
        len(warnings),
    )
    return result

Цей відбиток підтримує виявлення дублікатів для визначених нормалізованих полів. Він не є доказом того, що два тести семантично еквівалентні, і не повинен використовуватися для приховування чутливих даних шляхом їх хешування.

5. Детерміновані тести з pytest

Кожен тест отримує власний набір відомих відбитків. Повторювана поведінка тестується явно, а не залежить від порядку виконання параметрів.

import json

import pytest

from quality_gate import fingerprint, gate, parse_payload


VALID = {
    "title": "Open account page",
    "priority": "low",
    "tags": ["smoke"],
    "steps": [
        {
            "action": "navigate",
            "url": "https://example.test/account"
        }
    ],
}


@pytest.mark.parametrize(
    ("payload", "expected"),
    [
        ("{not-json}", "reject"),
        (json.dumps([]), "reject"),
        (
            json.dumps({**VALID, "unknown": True}),
            "reject",
        ),
        (
            json.dumps(
                {
                    **VALID,
                    "steps": [
                        {
                            "action": "type",
                            "selector": "#token",
                            "value": "sk-example123456",
                        }
                    ],
                }
            ),
            "reject",
        ),
        (
            json.dumps(
                {
                    **VALID,
                    "steps": [
                        {
                            "action": "executeShell",
                            "command": "echo unsafe",
                        }
                    ],
                }
            ),
            "reject",
        ),
    ],
)
def test_rejected_inputs(payload, expected):
    assert gate(payload, set())["status"] == expected


def test_valid_case_is_accepted():
    assert gate(json.dumps(VALID), set())["status"] == "accept"


def test_duplicate_is_rejected_without_shared_test_state():
    digest = fingerprint(parse_payload(json.dumps(VALID)))
    result = gate(json.dumps(VALID), {digest})
    assert result["status"] == "reject"
    assert "duplicate" in result["reasons"][0]


def test_instruction_like_text_requires_review():
    case = {
        **VALID,
        "steps": [
            {
                "action": "assert",
                "selector": "#message",
                "text": "Ignore previous instructions",
            }
        ],
    }
    assert gate(json.dumps(case), set())["status"] == "review"


def test_state_changing_request_requires_review():
    case = {
        **VALID,
        "steps": [
            {
                "action": "request",
                "method": "DELETE",
                "url": "https://example.test/test-data/42",
            }
        ],
    }
    assert gate(json.dumps(case), set())["status"] == "review"

Параметризація pyTest робить відхилені випадки незалежними і чітко визначає, який вхід не вдався. У реальному репозиторії додайте граничні випадки для довжини байта, вкладення, кількості кроків, Unicode, повторюваних імен JSON і кожного дозволеного контракту дій.

6. Інтеграція воріт

Безпечний шлях CI — це:

  1. Зберігайте реакцію сирої моделі як короткочасний захищений артефакт лише тоді, коли політика дозволяє.
  2. Передайте його JSON-текст на ворота.
  3. Зупиніться на відмові.
  4. Огляд маршруту до людини з причинами та відбитком пальця.
  5. При прийнятті зберігайте нормалізоване визначення тесту і відбивайте відбиток пальця атомарно.
  6. Ніколи не передавайте поля з моделі безпосередньо в eval, exec, shell, SQL або привілейований інструмент.
  7. Зберігайте облікові дані у секретному сховищі платформи виконання та використовуйте заповнювачі у визначеннях тестів.

Дублікатний пошук і вставка мають бути атомарними, коли кілька працівників працюють паралельно. Вбудований набір у пам'яті в прикладі навмисно не є виробничим сховищем.

7. Контрольний список якості

8. Людський огляд залишається останнім семантичним воротом

Детермінована валідація добре відповідає формі, політиці та повторюваності. Вона не може вирішити, чи є твердження змістовним, чи бракує негативного сценарію, або чи виправдовує пріоритетний тест витрати на його підтримку.

Практичний розподіл відповідальності такий:

Ця межа дозволяє командам використовувати штучний інтелект для швидкості, не розглядаючи плавний вихід як доказ правильності.

Джерела