ИИ может ускорять проектирование тестов, но его выход должен поступать в репозиторий, систему управления тестами или очередь автоматизации только после детерминированных проверок. Валидный JSON доказывает только, что парсер может прочитать документ. Он не доказывает, что тест актуален, безопасен, исполняем или полон.

В этой статье создаётся нейтральный к провайдеру Python‑гейт, который рассматривает вывод модели как недоверенные данные. Гейт проверяет небольшой контракт, отклоняет секреты и запрещённые действия, создаёт стабильный дублирующий отпечаток, отмечает случаи, требующие человеческой проверки, и возвращает машиночитаемые доказательства. Он никогда не выполняет сгенерированный код.

1. Что ворота могут и не могут доказать

Затвор может доказать повторяемые свойства:

Он не может доказать, что тест покрывает требование, использует правильный оракул или представляет приемлемый бизнес-риск. Это остаются вопросы для человеческого обзора.

OWASP рекомендует проверять ожидаемые форматы вывода и рассматривать выводы модели как ненадёжные до того, как они достигнут следующих функций. Также отмечается, что инжекция запросов не имеет безошибочной защиты внутри модели. Таким образом, детерминированный элемент снижает воздействие; это не утверждение, что враждебный текст был понят или сделан безопасным.

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 может потреблять значительное количество CPU и памяти, поэтому длина сырого байта проверяется перед вызовом 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. При accept сохраняйте нормированное определение теста и отпечаток пальца атомарно.
  6. Никогда не передавайте поля из модели напрямую в eval, exec, shell, SQL или привилегированный инструмент.
  7. Храните учетные данные в секретном хранилище платформы исполнения и используйте заполняющие элементы в определениях тестов.

Дублирующий поиск и вставка должны быть атомарными, если несколько рабочих рабочих работают параллельно. Набор в памяти в примере намеренно не является производственным хранилищем.

7. Чек‑лист QA

8. Человеческий обзор остаётся последними семантическими воротами

Детерминированная валидация хорошо определяет форму, политику и повторяемость. Она не может решить, имеет ли утверждение смысл, отсутствует ли отрицательный сценарий или оправдывает ли приоритетный тест затраты на его обслуживание.

Практическое разделение ответственности такова:

Эта граница позволяет командам использовать ИИ для достижения скорости, не рассматривая свободный вывод как доказательство корректности.

Источники