Complete name-first 1C adapter saved-state support
This commit is contained in:
@@ -0,0 +1,484 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Validate and optionally probe rare 1C metadata-kind fixtures."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable
|
||||
|
||||
|
||||
SCHEMA = "onec_metadata_kind_fixture_manifest.v1"
|
||||
REPORT_SCHEMA = "onec_metadata_kind_fixture_check.v1"
|
||||
SUPPORTED_MODES = {"extension_saved_state", "dedicated_base_active"}
|
||||
REFERENCE_USAGE = "external_reference_only_not_vendored"
|
||||
DESIGNER_ACCESS_MODE = "operating_system_integrated_only"
|
||||
SECRET_KEY_RE = re.compile(r"(password|passwd|pwd|secret|token|парол|секрет)", re.IGNORECASE)
|
||||
Rpc = Callable[[str, str, dict[str, Any], float, str], dict[str, Any]]
|
||||
|
||||
|
||||
def load_json(path: Path) -> dict[str, Any]:
|
||||
value = json.loads(path.read_text(encoding="utf-8-sig"))
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError("manifest root must be a JSON object")
|
||||
return value
|
||||
|
||||
|
||||
def write_json(path: Path, value: dict[str, Any]) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
temporary = path.with_name(path.name + ".tmp")
|
||||
temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
|
||||
temporary.replace(path)
|
||||
|
||||
|
||||
def rpc(adapter_url: str, method: str, payload: dict[str, Any], timeout: float, service_token: str) -> dict[str, Any]:
|
||||
headers = {"Content-Type": "application/json; charset=utf-8"}
|
||||
if service_token:
|
||||
headers["Authorization"] = f"Bearer {service_token}"
|
||||
request = urllib.request.Request(
|
||||
adapter_url.rstrip("/") + "/rpc",
|
||||
data=json.dumps({"method": method, "payload": payload}, ensure_ascii=False).encode("utf-8"),
|
||||
headers=headers,
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(request, timeout=timeout) as response:
|
||||
value = json.loads(response.read().decode("utf-8"))
|
||||
return value if isinstance(value, dict) else {"status": "error", "error": "response_not_object"}
|
||||
|
||||
|
||||
def finding(code: str, message: str, *, fixture_id: str | None = None) -> dict[str, Any]:
|
||||
value = {"severity": "error", "code": code, "message": message}
|
||||
if fixture_id:
|
||||
value["fixture_id"] = fixture_id
|
||||
return value
|
||||
|
||||
|
||||
def secret_key_paths(value: Any, prefix: str = "") -> list[str]:
|
||||
hits: list[str] = []
|
||||
if isinstance(value, dict):
|
||||
for key, nested in value.items():
|
||||
path = f"{prefix}.{key}" if prefix else str(key)
|
||||
if SECRET_KEY_RE.search(str(key)):
|
||||
hits.append(path)
|
||||
hits.extend(secret_key_paths(nested, path))
|
||||
elif isinstance(value, list):
|
||||
for index, nested in enumerate(value):
|
||||
hits.extend(secret_key_paths(nested, f"{prefix}[{index}]"))
|
||||
return hits
|
||||
|
||||
|
||||
def validate_manifest(manifest: dict[str, Any]) -> list[dict[str, Any]]:
|
||||
findings: list[dict[str, Any]] = []
|
||||
if manifest.get("schema") != SCHEMA:
|
||||
findings.append(finding("invalid_schema", f"schema must be {SCHEMA}"))
|
||||
|
||||
policy = manifest.get("policy")
|
||||
if not isinstance(policy, dict):
|
||||
findings.append(finding("missing_policy", "policy must be an object"))
|
||||
else:
|
||||
if policy.get("provisioning_tool") != "1c_designer":
|
||||
findings.append(finding("unsafe_provisioning_tool", "fixtures must be provisioned by 1C Designer"))
|
||||
if policy.get("direct_sql_write_allowed") is not False:
|
||||
findings.append(finding("direct_sql_write_not_forbidden", "direct SQL fixture writes must be forbidden"))
|
||||
if policy.get("credentials_in_manifest_allowed") is not False:
|
||||
findings.append(finding("credentials_not_forbidden", "credentials must be forbidden in the manifest"))
|
||||
|
||||
for path in secret_key_paths(manifest):
|
||||
findings.append(finding("credential_key_in_manifest", f"credential-like key is forbidden: {path}"))
|
||||
|
||||
designer = manifest.get("designer")
|
||||
if not isinstance(designer, dict):
|
||||
findings.append(finding("missing_designer_requirements", "designer requirements must be an object"))
|
||||
designer = {}
|
||||
required_version = str(designer.get("required_version") or "")
|
||||
if not re.fullmatch(r"\d+\.\d+\.\d+\.\d+", required_version):
|
||||
findings.append(finding("invalid_designer_version", "designer.required_version must be an exact four-part version"))
|
||||
if designer.get("access_mode") != DESIGNER_ACCESS_MODE:
|
||||
findings.append(finding("unsafe_designer_access_mode", f"designer.access_mode must be {DESIGNER_ACCESS_MODE}"))
|
||||
if designer.get("credential_arguments_allowed") is not False:
|
||||
findings.append(finding("designer_credential_arguments_not_forbidden", "Designer credential arguments must be forbidden"))
|
||||
export_script = str(designer.get("export_script") or "")
|
||||
if not export_script.endswith(".ps1") or Path(export_script).is_absolute():
|
||||
findings.append(finding("invalid_designer_export_script", "designer.export_script must be a repository-relative PowerShell path"))
|
||||
|
||||
external_reference = manifest.get("external_reference")
|
||||
if not isinstance(external_reference, dict):
|
||||
findings.append(finding("missing_external_reference", "external_reference must be an object"))
|
||||
external_reference = {}
|
||||
if external_reference.get("usage") != REFERENCE_USAGE:
|
||||
findings.append(finding("unsafe_external_reference_usage", f"external_reference.usage must be {REFERENCE_USAGE}"))
|
||||
if not str(external_reference.get("repository") or "").startswith("https://"):
|
||||
findings.append(finding("invalid_external_reference_repository", "external_reference.repository must be an HTTPS URL"))
|
||||
if not re.fullmatch(r"[0-9a-f]{40}", str(external_reference.get("commit") or "")):
|
||||
findings.append(finding("invalid_external_reference_commit", "external_reference.commit must be a full Git commit"))
|
||||
for key in ("source_path", "license"):
|
||||
if not str(external_reference.get(key) or "").strip():
|
||||
findings.append(finding("incomplete_external_reference", f"external_reference.{key} is required"))
|
||||
|
||||
required_kinds = manifest.get("required_kinds")
|
||||
if not isinstance(required_kinds, list) or not required_kinds or any(not isinstance(item, str) or not item for item in required_kinds):
|
||||
findings.append(finding("invalid_required_kinds", "required_kinds must be a non-empty string array"))
|
||||
required_kinds = []
|
||||
|
||||
fixtures = manifest.get("fixtures")
|
||||
if not isinstance(fixtures, list):
|
||||
findings.append(finding("invalid_fixtures", "fixtures must be an array"))
|
||||
return findings
|
||||
|
||||
seen_ids: set[str] = set()
|
||||
seen_kinds: set[str] = set()
|
||||
for fixture in fixtures:
|
||||
if not isinstance(fixture, dict):
|
||||
findings.append(finding("invalid_fixture", "each fixture must be an object"))
|
||||
continue
|
||||
fixture_id = str(fixture.get("id") or "")
|
||||
kind = str(fixture.get("kind") or "")
|
||||
if not fixture_id:
|
||||
findings.append(finding("missing_fixture_id", "fixture id is required"))
|
||||
elif fixture_id in seen_ids:
|
||||
findings.append(finding("duplicate_fixture_id", f"duplicate fixture id: {fixture_id}", fixture_id=fixture_id))
|
||||
seen_ids.add(fixture_id)
|
||||
if not kind:
|
||||
findings.append(finding("missing_fixture_kind", "fixture kind is required", fixture_id=fixture_id))
|
||||
elif kind in seen_kinds:
|
||||
findings.append(finding("duplicate_fixture_kind", f"duplicate fixture kind: {kind}", fixture_id=fixture_id))
|
||||
seen_kinds.add(kind)
|
||||
|
||||
target = fixture.get("target")
|
||||
mode = target.get("mode") if isinstance(target, dict) else None
|
||||
if mode not in SUPPORTED_MODES:
|
||||
findings.append(finding("invalid_target_mode", f"unsupported target mode: {mode}", fixture_id=fixture_id))
|
||||
if mode == "extension_saved_state":
|
||||
for key in ("base_id", "extension", "state"):
|
||||
if not isinstance(target.get(key), str) or not target.get(key):
|
||||
findings.append(finding("missing_extension_target", f"target.{key} is required", fixture_id=fixture_id))
|
||||
if required_version and target.get("platform_version") != required_version:
|
||||
findings.append(
|
||||
finding(
|
||||
"fixture_designer_version_mismatch",
|
||||
f"target.platform_version must equal designer.required_version ({required_version})",
|
||||
fixture_id=fixture_id,
|
||||
)
|
||||
)
|
||||
if mode == "dedicated_base_active" and target.get("base_override_required") is not True:
|
||||
findings.append(finding("unsafe_shared_legacy_target", "dedicated legacy fixture must require an explicit base override", fixture_id=fixture_id))
|
||||
|
||||
selector = fixture.get("selector")
|
||||
names = selector.get("names") if isinstance(selector, dict) else None
|
||||
if not isinstance(names, list) or not names or any(not isinstance(name, str) or not name.strip() for name in names):
|
||||
findings.append(finding("invalid_selector_names", "selector.names must be a non-empty string array", fixture_id=fixture_id))
|
||||
methods = fixture.get("smoke_methods")
|
||||
if not isinstance(methods, list) or not methods or any(not isinstance(method, str) or not method for method in methods):
|
||||
findings.append(finding("invalid_smoke_methods", "smoke_methods must be a non-empty string array", fixture_id=fixture_id))
|
||||
|
||||
missing = sorted(set(required_kinds) - seen_kinds)
|
||||
extra = sorted(seen_kinds - set(required_kinds))
|
||||
if missing:
|
||||
findings.append(finding("required_fixture_missing", f"fixtures missing for kinds: {', '.join(missing)}"))
|
||||
if extra:
|
||||
findings.append(finding("unexpected_fixture_kind", f"unexpected fixture kinds: {', '.join(extra)}"))
|
||||
kind_paths = external_reference.get("kind_paths")
|
||||
if not isinstance(kind_paths, dict):
|
||||
findings.append(finding("missing_external_reference_kind_paths", "external_reference.kind_paths must be an object"))
|
||||
else:
|
||||
missing_reference_kinds = sorted(set(required_kinds) - set(kind_paths))
|
||||
if missing_reference_kinds:
|
||||
findings.append(
|
||||
finding(
|
||||
"external_reference_kind_missing",
|
||||
f"external reference paths missing for kinds: {', '.join(missing_reference_kinds)}",
|
||||
)
|
||||
)
|
||||
return findings
|
||||
|
||||
|
||||
def normalize_guid(value: Any) -> str:
|
||||
return str(value or "").strip().strip("{}").casefold()
|
||||
|
||||
|
||||
def matches_selector(obj: dict[str, Any], selector: dict[str, Any]) -> bool:
|
||||
names = {str(value).strip().casefold() for value in selector.get("names") or []}
|
||||
guid = normalize_guid(selector.get("guid"))
|
||||
object_name = str(obj.get("name") or "").strip().casefold()
|
||||
object_guid = normalize_guid(obj.get("guid"))
|
||||
if guid and object_guid == guid:
|
||||
return True
|
||||
return bool(object_name and object_name in names)
|
||||
|
||||
|
||||
def object_public_selector(base_id: str, fixture: dict[str, Any], obj: dict[str, Any]) -> dict[str, Any]:
|
||||
selector: dict[str, Any] = {"base_id": base_id, "kind": fixture["kind"]}
|
||||
if obj.get("name"):
|
||||
selector["name"] = obj["name"]
|
||||
if obj.get("guid"):
|
||||
selector["guid"] = obj["guid"]
|
||||
target = fixture.get("target") or {}
|
||||
route = obj.get("route") if isinstance(obj.get("route"), dict) else {}
|
||||
extension_guid = obj.get("extension_guid") or route.get("extension_guid")
|
||||
if extension_guid:
|
||||
selector["extension_guid"] = extension_guid
|
||||
elif target.get("extension"):
|
||||
selector["extension"] = target["extension"]
|
||||
return selector
|
||||
|
||||
|
||||
def probe_smoke_methods(
|
||||
adapter_url: str,
|
||||
service_token: str,
|
||||
timeout: float,
|
||||
fixture: dict[str, Any],
|
||||
base_id: str,
|
||||
obj: dict[str, Any],
|
||||
rpc_call: Rpc,
|
||||
) -> list[dict[str, Any]]:
|
||||
selector = object_public_selector(base_id, fixture, obj)
|
||||
results: list[dict[str, Any]] = []
|
||||
for method in fixture.get("smoke_methods") or []:
|
||||
payload = {**selector, "timeout_seconds": max(1, int(timeout))}
|
||||
if method == "metadata.object.attributes":
|
||||
payload["only"] = "all"
|
||||
try:
|
||||
response = rpc_call(adapter_url, method, payload, timeout, service_token)
|
||||
status = str(response.get("status") or "unknown")
|
||||
results.append({"method": method, "status": status, **({"error": response.get("error")} if response.get("error") else {})})
|
||||
except (TimeoutError, urllib.error.URLError, OSError, ValueError, json.JSONDecodeError) as exc:
|
||||
results.append({"method": method, "status": "transport_error", "error": type(exc).__name__, "message": str(exc)[:300]})
|
||||
return results
|
||||
|
||||
|
||||
def check_fixture_live(
|
||||
fixture: dict[str, Any],
|
||||
adapter_url: str,
|
||||
service_token: str,
|
||||
timeout: float,
|
||||
base_overrides: dict[str, str],
|
||||
rpc_call: Rpc,
|
||||
probe_cache: dict[tuple[str, str, str, str], dict[str, Any]] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
fixture_id = str(fixture["id"])
|
||||
target = fixture.get("target") or {}
|
||||
base_id = base_overrides.get(fixture_id) or target.get("base_id")
|
||||
if target.get("base_override_required") and fixture_id not in base_overrides:
|
||||
return {
|
||||
"id": fixture_id,
|
||||
"kind": fixture["kind"],
|
||||
"status": "target_not_configured",
|
||||
"message": f"Pass --target-base {fixture_id}=BASE_ID for the dedicated legacy fixture.",
|
||||
}
|
||||
if not base_id:
|
||||
return {"id": fixture_id, "kind": fixture["kind"], "status": "target_not_configured"}
|
||||
|
||||
payload: dict[str, Any]
|
||||
method: str
|
||||
if target.get("mode") == "extension_saved_state":
|
||||
method = "extension.objects.find"
|
||||
payload = {
|
||||
"base_id": base_id,
|
||||
"extension": target["extension"],
|
||||
"state": target.get("state") or "working",
|
||||
"limit": 100,
|
||||
"use_cache": True,
|
||||
"full_scan": False,
|
||||
"refresh_cache": False,
|
||||
"timeout_seconds": max(1, int(timeout)),
|
||||
}
|
||||
else:
|
||||
method = "metadata.objects.list"
|
||||
payload = {
|
||||
"base_id": base_id,
|
||||
"kind": fixture["kind"],
|
||||
"limit": 100,
|
||||
"refresh_cache": True,
|
||||
"timeout_seconds": max(1, int(timeout)),
|
||||
}
|
||||
|
||||
cache_key = (
|
||||
method,
|
||||
str(base_id),
|
||||
str(target.get("extension") or ""),
|
||||
str(target.get("state") or ""),
|
||||
)
|
||||
cached_probe_error: dict[str, Any] | None = None
|
||||
try:
|
||||
if probe_cache is not None and cache_key in probe_cache:
|
||||
cached = probe_cache[cache_key]
|
||||
cached_probe_error = cached.get("__probe_error__") if isinstance(cached.get("__probe_error__"), dict) else None
|
||||
if cached_probe_error is not None:
|
||||
raise TimeoutError(str(cached_probe_error.get("message") or "cached adapter probe failed"))
|
||||
response = cached
|
||||
else:
|
||||
response = rpc_call(adapter_url, method, payload, timeout, service_token)
|
||||
if probe_cache is not None:
|
||||
probe_cache[cache_key] = response
|
||||
except (TimeoutError, urllib.error.URLError, OSError, ValueError, json.JSONDecodeError) as exc:
|
||||
error_name = str(cached_probe_error.get("error")) if cached_probe_error else type(exc).__name__
|
||||
error_message = str(cached_probe_error.get("message")) if cached_probe_error else str(exc)[:300]
|
||||
if probe_cache is not None and cached_probe_error is None:
|
||||
probe_cache[cache_key] = {
|
||||
"__probe_error__": {
|
||||
"error": error_name,
|
||||
"message": error_message,
|
||||
}
|
||||
}
|
||||
return {
|
||||
"id": fixture_id,
|
||||
"kind": fixture["kind"],
|
||||
"base_id": base_id,
|
||||
"status": "adapter_error",
|
||||
"probe_method": method,
|
||||
"error": error_name,
|
||||
"message": error_message,
|
||||
**({"probe_error_reused": True} if cached_probe_error is not None else {}),
|
||||
}
|
||||
|
||||
objects = response.get("objects") if isinstance(response.get("objects"), list) else response.get("items")
|
||||
objects = [obj for obj in (objects or []) if isinstance(obj, dict)]
|
||||
kind_objects = [obj for obj in objects if str(obj.get("kind") or "") == str(fixture["kind"])]
|
||||
matched = next((obj for obj in kind_objects if matches_selector(obj, fixture.get("selector") or {})), None)
|
||||
if not matched:
|
||||
return {
|
||||
"id": fixture_id,
|
||||
"kind": fixture["kind"],
|
||||
"base_id": base_id,
|
||||
"status": "fixture_missing" if response.get("status") in {"ok", "not_found"} else "adapter_error",
|
||||
"probe_method": method,
|
||||
"adapter_status": response.get("status"),
|
||||
"observed_names": sorted({str(obj.get("name")) for obj in kind_objects if obj.get("name")})[:20],
|
||||
}
|
||||
|
||||
expected_states = set(fixture.get("expected_activation_states") or [])
|
||||
activation_state = str(matched.get("activation_state") or "active")
|
||||
smoke = probe_smoke_methods(adapter_url, service_token, timeout, fixture, base_id, matched, rpc_call)
|
||||
failed_smoke = [item["method"] for item in smoke if item.get("status") != "ok"]
|
||||
state_ok = not expected_states or activation_state in expected_states
|
||||
return {
|
||||
"id": fixture_id,
|
||||
"kind": fixture["kind"],
|
||||
"base_id": base_id,
|
||||
"status": "fixture_ready" if state_ok and not failed_smoke else "fixture_degraded",
|
||||
"probe_method": method,
|
||||
"adapter_status": response.get("status"),
|
||||
"object": {
|
||||
"name": matched.get("name"),
|
||||
"guid": matched.get("guid"),
|
||||
"activation_state": activation_state,
|
||||
},
|
||||
"smoke": smoke,
|
||||
**({"failed_smoke_methods": failed_smoke} if failed_smoke else {}),
|
||||
**({"unexpected_activation_state": activation_state} if not state_ok else {}),
|
||||
}
|
||||
|
||||
|
||||
def parse_base_overrides(values: list[str]) -> dict[str, str]:
|
||||
result: dict[str, str] = {}
|
||||
for value in values:
|
||||
fixture_id, separator, base_id = value.partition("=")
|
||||
if not separator or not fixture_id.strip() or not base_id.strip():
|
||||
raise ValueError(f"invalid --target-base value: {value}; expected FIXTURE_ID=BASE_ID")
|
||||
result[fixture_id.strip()] = base_id.strip()
|
||||
return result
|
||||
|
||||
|
||||
def check_manifest(
|
||||
manifest_path: Path,
|
||||
*,
|
||||
live: bool = False,
|
||||
adapter_url: str = "http://docker-gpu.cin.su:8011",
|
||||
service_token: str = "",
|
||||
timeout: float = 90,
|
||||
base_overrides: dict[str, str] | None = None,
|
||||
require_ready: bool = False,
|
||||
rpc_call: Rpc = rpc,
|
||||
) -> dict[str, Any]:
|
||||
try:
|
||||
manifest = load_json(manifest_path)
|
||||
except (OSError, ValueError, json.JSONDecodeError) as exc:
|
||||
findings = [finding("manifest_read_failed", str(exc))]
|
||||
manifest = {}
|
||||
else:
|
||||
findings = validate_manifest(manifest)
|
||||
|
||||
fixture_results: list[dict[str, Any]] = []
|
||||
if not findings:
|
||||
if live:
|
||||
probe_cache: dict[tuple[str, str, str, str], dict[str, Any]] = {}
|
||||
fixture_results = [
|
||||
check_fixture_live(
|
||||
fixture,
|
||||
adapter_url,
|
||||
service_token,
|
||||
timeout,
|
||||
base_overrides or {},
|
||||
rpc_call,
|
||||
probe_cache,
|
||||
)
|
||||
for fixture in manifest.get("fixtures") or []
|
||||
]
|
||||
else:
|
||||
fixture_results = [
|
||||
{"id": fixture["id"], "kind": fixture["kind"], "status": "not_checked"}
|
||||
for fixture in manifest.get("fixtures") or []
|
||||
]
|
||||
|
||||
ready = len([item for item in fixture_results if item.get("status") == "fixture_ready"])
|
||||
gaps = len([item for item in fixture_results if item.get("status") in {"fixture_missing", "fixture_degraded", "target_not_configured", "adapter_error"}])
|
||||
passed = not findings and (not require_ready or (bool(fixture_results) and ready == len(fixture_results)))
|
||||
return {
|
||||
"schema": REPORT_SCHEMA,
|
||||
"created_at_utc": datetime.now(timezone.utc).isoformat(),
|
||||
"status": "invalid_manifest" if findings else ("ready" if fixture_results and ready == len(fixture_results) else ("gaps_found" if live else "manifest_valid")),
|
||||
"passed": passed,
|
||||
"manifest_path": str(manifest_path),
|
||||
"live": live,
|
||||
"require_ready": require_ready,
|
||||
"adapter_url": adapter_url if live else None,
|
||||
"findings": findings,
|
||||
"fixtures": fixture_results,
|
||||
"counts": {
|
||||
"findings": len(findings),
|
||||
"fixtures": len(fixture_results),
|
||||
"ready": ready,
|
||||
"gaps": gaps,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description="Validate and optionally probe rare 1C metadata-kind fixtures.")
|
||||
parser.add_argument("--manifest", type=Path, default=Path("config/1c_metadata_kind_fixtures.json"))
|
||||
parser.add_argument("--live", action="store_true")
|
||||
parser.add_argument("--adapter-url", default="http://docker-gpu.cin.su:8011")
|
||||
parser.add_argument("--service-token-env", default="ONEC_ADAPTER_SERVICE_TOKEN")
|
||||
parser.add_argument("--timeout", type=float, default=90)
|
||||
parser.add_argument("--target-base", action="append", default=[], metavar="FIXTURE_ID=BASE_ID")
|
||||
parser.add_argument("--require-ready", action="store_true")
|
||||
parser.add_argument("--output", type=Path)
|
||||
args = parser.parse_args()
|
||||
|
||||
try:
|
||||
base_overrides = parse_base_overrides(args.target_base)
|
||||
except ValueError as exc:
|
||||
parser.error(str(exc))
|
||||
result = check_manifest(
|
||||
args.manifest,
|
||||
live=args.live,
|
||||
adapter_url=args.adapter_url,
|
||||
service_token=os.environ.get(args.service_token_env, ""),
|
||||
timeout=args.timeout,
|
||||
base_overrides=base_overrides,
|
||||
require_ready=args.require_ready,
|
||||
)
|
||||
if args.output:
|
||||
write_json(args.output, result)
|
||||
print(json.dumps(result, ensure_ascii=False, indent=2))
|
||||
return 0 if result["passed"] else 2
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in New Issue
Block a user