477 lines
25 KiB
Python
477 lines
25 KiB
Python
"""自有 SQLite/HTTP CMS 业务验收；不启动压测，不使用部署数据库。"""
|
|
|
|
import argparse
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from contextlib import closing, contextmanager
|
|
from datetime import datetime, timezone
|
|
import http.client
|
|
import json
|
|
from pathlib import Path
|
|
import secrets
|
|
import shutil
|
|
import sqlite3
|
|
import sys
|
|
import tempfile
|
|
from threading import Barrier
|
|
import time
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
sys.path.insert(0, str(ROOT / "test/performance"))
|
|
from cms import (CmsClient, available_port, catalog_key, copy_cms_project,
|
|
decode_response, execute, isolated_settings, login_client,
|
|
provision_identity, require)
|
|
from process import Process
|
|
from settings import write_private_json
|
|
|
|
ARTICLE = "/news/article/admin/manage"
|
|
REVISION = "/content/revision/admin/manage/create"
|
|
CATEGORY = "/content/category/admin/manage"
|
|
ASSET = "/media/asset/admin/manage/upload"
|
|
SCHEDULE = "/publishing/schedule/admin/manage/schedule"
|
|
ROLES = "/user/authorization/admin/manage"
|
|
BUSINESS_TABLES = ("article", "revision", "publication", "schedule", "operation", "asset", "category")
|
|
|
|
|
|
def append_member_fixture(project):
|
|
"""复用真实凭据/成员关系 fixture；仅追加到本运行器复制的 plain 项目。"""
|
|
fixtures = ROOT / "test/dever-tests/fixtures/postgres_api"
|
|
for target, name in (("user/account/app.dever", "account_app.dever"),
|
|
("user/membership/app.dever", "membership_app.dever"),
|
|
("user/account/api.dever", "account_api.dever")):
|
|
path = project / "module" / target
|
|
require(path.is_file(), "compiler mode requires the plain CMS project")
|
|
with path.open("a") as destination:
|
|
destination.write("\n" + (fixtures / name).read_text())
|
|
|
|
|
|
def sql_read(database, sql, parameters=()):
|
|
with closing(sqlite3.connect(database.as_uri() + "?mode=ro", uri=True, timeout=5)) as connection:
|
|
connection.row_factory = sqlite3.Row
|
|
return [dict(row) for row in connection.execute(sql, parameters)]
|
|
|
|
|
|
def snapshot(database):
|
|
return {table: sql_read(database, f'SELECT * FROM "{table}" ORDER BY id')
|
|
for table in BUSINESS_TABLES}
|
|
|
|
|
|
def fixture_write(database, sql, parameters=()):
|
|
# 此入口只接收自有临时数据库。所有正常业务创建和授权仍走真实 API/CMD。
|
|
with closing(sqlite3.connect(database, timeout=5)) as connection:
|
|
with connection:
|
|
connection.execute(sql, parameters)
|
|
|
|
|
|
@contextmanager
|
|
def reject_inserts(database, table):
|
|
require(table in BUSINESS_TABLES, "unsupported failure injection table")
|
|
fixture_write(database, f'''CREATE TRIGGER cms_reject_insert BEFORE INSERT ON "{table}"
|
|
BEGIN SELECT RAISE(ABORT, 'owned CMS acceptance failure'); END''')
|
|
try:
|
|
yield
|
|
finally:
|
|
fixture_write(database, "DROP TRIGGER cms_reject_insert")
|
|
|
|
|
|
def wait_for(check, process, label, timeout=15):
|
|
deadline = time.monotonic() + timeout
|
|
while time.monotonic() < deadline:
|
|
require(process.child.poll() is None, f"{label}: child exited; see {process.directory}")
|
|
value = check()
|
|
if value:
|
|
return value
|
|
time.sleep(0.05)
|
|
raise TimeoutError(f"{label}: timed out after {timeout}s")
|
|
|
|
|
|
def ready(process, client):
|
|
def probe():
|
|
try:
|
|
client.request("GET", ARTICLE + "/list", expected=401)
|
|
return True
|
|
except (OSError, http.client.HTTPException):
|
|
client.close()
|
|
return False
|
|
wait_for(probe, process, "API startup", timeout=20)
|
|
|
|
|
|
def multipart(client, content, *, expected=200, field="file"):
|
|
boundary = "cms-" + secrets.token_hex(12)
|
|
body = (f'--{boundary}\r\nContent-Disposition: form-data; name="{field}"; '
|
|
'filename="article.txt"\r\nContent-Type: text/plain\r\n\r\n').encode()
|
|
body += content + f"\r\n--{boundary}--\r\n".encode()
|
|
client.connection.request("POST", ASSET, body, {
|
|
"Content-Type": f"multipart/form-data; boundary={boundary}",
|
|
"Origin": client.origin, "Cookie": client.cookies.get("admin", ""),
|
|
})
|
|
response = client.connection.getresponse()
|
|
reply = response.read()
|
|
require(response.status == expected,
|
|
f"upload: HTTP {response.status}, expected {expected}: {reply!r}")
|
|
if expected != 200:
|
|
require(json.loads(reply)["code"] != 0, "upload rejection returned success")
|
|
return None
|
|
return decode_response(reply, response.status)
|
|
|
|
|
|
class Acceptance:
|
|
def __init__(self, executable, directory, settings, identity, password, member, member_password):
|
|
self.executable = executable
|
|
self.directory = directory
|
|
self.settings = settings
|
|
self.identity = identity
|
|
self.password = password
|
|
self.member_identity = member
|
|
self.member_password = member_password
|
|
self.port = settings["http"]["port"]
|
|
self.owner = CmsClient(self.port)
|
|
self.member = CmsClient(self.port)
|
|
self.anonymous = CmsClient(self.port)
|
|
self.database = directory / "data/tenants" / f"tenant_{identity['tenant_id']}.db"
|
|
self.worker_number = 0
|
|
self.checks = []
|
|
|
|
def close(self):
|
|
for client in (self.owner, self.member, self.anonymous):
|
|
client.close()
|
|
|
|
def passed(self, name):
|
|
self.checks.append(name)
|
|
print(f"PASS {name}", flush=True)
|
|
|
|
def assert_unchanged(self, before, label):
|
|
require(snapshot(self.database) == before, f"{label}: business rows changed")
|
|
|
|
def create(self, client, slug, **fields):
|
|
return client.request("POST", ARTICLE + "/create", {
|
|
"slug": slug, "title": f"Title {slug}", "body": "Draft body", **fields,
|
|
}, site="admin")
|
|
|
|
def edit(self, client, article, *, title="Edited title", expected=200):
|
|
revision = client.request("POST", REVISION, {
|
|
"selected_article_id": article["id"], "title": title, "body": "Edited body",
|
|
"expected_version": article["version"], "category_id": article.get("category_id"),
|
|
"asset_id": article.get("asset_id"),
|
|
}, site="admin", expected=expected)
|
|
if expected != 200:
|
|
return None
|
|
current = client.request("GET", ARTICLE + "/detail", {"id": article["id"]}, site="admin")
|
|
require(revision["article_id"] == current["id"] and revision["version"] == current["version"]
|
|
and revision["title"] == current["title"] and revision["body"] == current["body"],
|
|
"revision and current article disagree")
|
|
return current
|
|
|
|
def schedule(self, client, article, milliseconds):
|
|
instant = datetime.fromtimestamp(milliseconds / 1000, timezone.utc)
|
|
return client.request("POST", SCHEDULE, {
|
|
"article_id": article["id"],
|
|
"publish_at": instant.isoformat(timespec="milliseconds").replace("+00:00", "Z"),
|
|
}, site="admin")
|
|
|
|
def job(self, schedule):
|
|
rows = sql_read(self.database,
|
|
"SELECT * FROM _dever_jobs WHERE target=? ORDER BY id",
|
|
("publishing.schedule.job.publish",))
|
|
matches = [row for row in rows if json.loads(row["payload"])["schedule_id"] == schedule["id"]]
|
|
require(len(matches) == 1, f"schedule {schedule['id']} must own exactly one Job: {rows}")
|
|
return matches[0]
|
|
|
|
@contextmanager
|
|
def worker(self):
|
|
self.worker_number += 1
|
|
settings = {**self.settings, "runtime": {**self.settings["runtime"], "mode": "worker"}}
|
|
write_private_json(self.directory / "config/setting.json", settings, replace=True)
|
|
try:
|
|
with Process([self.executable], self.directory / f"worker-{self.worker_number}") as process:
|
|
yield process
|
|
require(process.child.returncode == 0, f"Worker did not shut down cleanly: {process.directory}")
|
|
finally:
|
|
write_private_json(self.directory / "config/setting.json", self.settings, replace=True)
|
|
|
|
def authorization(self):
|
|
login_client(self.owner, self.identity, self.password, "cms")
|
|
login_client(self.member, self.member_identity, self.member_password, "cms")
|
|
before = snapshot(self.database)
|
|
self.anonymous.request("GET", ARTICLE + "/list", expected=401)
|
|
self.member.request("GET", ARTICLE + "/list", site="admin", expected=403)
|
|
for client, status in ((self.anonymous, 401), (self.member, 403)):
|
|
client.request("POST", ARTICLE + "/create", {
|
|
"slug": "must-not-create", "title": "Rejected", "body": "Rejected",
|
|
}, site="admin", expected=status)
|
|
self.assert_unchanged(before, "unauthenticated and ungranted writes")
|
|
catalog = self.owner.request("GET", ROLES + "/permissions", site="admin")
|
|
selections = (("news", "article", "create", "POST"),
|
|
("news", "article", "list", "GET"),
|
|
("news", "article", "detail", "GET"),
|
|
("news", "article", "publish", "POST"),
|
|
("news", "article", "remove", "DELETE"),
|
|
("content", "revision", "create", "POST"),
|
|
("publishing", "schedule", "schedule", "POST"))
|
|
keys = [catalog_key(catalog, component, domain, "admin", action, method)
|
|
for component, domain, action, method in selections]
|
|
self.owner.request("POST", ROLES + "/save", {
|
|
"id": "cms-editor", "name": "CMS editor", "all_permissions": False,
|
|
"permission_keys": keys,
|
|
}, site="admin")
|
|
self.owner.request("POST", ROLES + "/grant", {
|
|
"user_id": self.member_identity["user_id"], "role_id": "cms-editor",
|
|
}, site="admin")
|
|
self.member.request("GET", ARTICLE + "/list", {"size": 20}, site="admin")
|
|
self.passed("real login, ungranted denial and explicit member role")
|
|
|
|
def editorial(self):
|
|
category = self.owner.request("POST", CATEGORY + "/create", {"name": " CMS News "}, site="admin")
|
|
upload = multipart(self.owner, b"CMS attachment\n")
|
|
stored = self.directory / "data/upload" / upload["storage_key"]
|
|
require(stored.read_bytes() == b"CMS attachment\n", "uploaded bytes changed")
|
|
files = sorted(path.name for path in stored.parent.iterdir())
|
|
rows = snapshot(self.database)
|
|
multipart(self.owner, b"x" * 2049, expected=400)
|
|
multipart(self.owner, b"bad field", field="unknown", expected=400)
|
|
require(sorted(path.name for path in stored.parent.iterdir()) == files,
|
|
"rejected upload persisted a file")
|
|
require(not list((self.directory / "data/tmp").iterdir()), "upload temporary files leaked")
|
|
self.assert_unchanged(rows, "rejected uploads")
|
|
article = self.create(self.owner, "linked-article", category_id=category["id"], asset_id=upload["id"])
|
|
require(article["category_id"] == category["id"] and article["asset_id"] == upload["id"],
|
|
"article lost category/asset references")
|
|
before = snapshot(self.database)
|
|
self.edit(self.member, article, expected=403)
|
|
self.member.request("POST", ARTICLE + "/publish", {"article_id": article["id"]},
|
|
site="admin", expected=403)
|
|
self.member.request("DELETE", ARTICLE + "/remove", {"id": article["id"]},
|
|
site="admin", expected=403)
|
|
self.member.request("POST", SCHEDULE, {
|
|
"article_id": article["id"],
|
|
"publish_at": datetime.fromtimestamp(time.time() + 30, timezone.utc).isoformat(timespec="milliseconds"),
|
|
}, site="admin", expected=403)
|
|
self.assert_unchanged(before, "non-author mutation")
|
|
edited = self.edit(self.owner, article)
|
|
require(edited["version"] == article["version"] + 1, "edit did not advance version")
|
|
before = snapshot(self.database)
|
|
self.edit(self.owner, article, expected=409)
|
|
self.assert_unchanged(before, "stale edit")
|
|
self.passed("multipart cleanup, attachment references, author and stale-version rejection")
|
|
|
|
# 失败发生在文章写入之后，必须连同版本/修订一起回滚。
|
|
with reject_inserts(self.database, "revision"):
|
|
self.edit(self.owner, edited, title="Must roll back", expected=500)
|
|
self.assert_unchanged(before, "revision insert failure")
|
|
self.passed("HTTP edit failure rolls back article and revision")
|
|
winner = self.concurrent_edit(edited)
|
|
before = snapshot(self.database)
|
|
with reject_inserts(self.database, "publication"):
|
|
self.owner.request("POST", ARTICLE + "/publish", {"article_id": article["id"]},
|
|
site="admin", expected=500)
|
|
self.assert_unchanged(before, "publication insert failure")
|
|
published = self.owner.request("POST", ARTICLE + "/publish", {"article_id": article["id"]}, site="admin")
|
|
require(published["title"] == winner["title"] and published["body"] == winner["body"],
|
|
"publication is not the winning stored revision")
|
|
before = snapshot(self.database)
|
|
self.owner.request("POST", ARTICLE + "/publish", {"article_id": article["id"]}, site="admin", expected=409)
|
|
self.assert_unchanged(before, "repeated manual publish")
|
|
self.owner.request("DELETE", CATEGORY + "/disable", {"id": category["id"]}, site="admin")
|
|
before = snapshot(self.database)
|
|
self.owner.request("POST", ARTICLE + "/create", {
|
|
"slug": "disabled-category", "title": "Rejected", "body": "Rejected", "category_id": category["id"],
|
|
}, site="admin", expected=409)
|
|
self.assert_unchanged(before, "disabled category")
|
|
self.passed("publish snapshot, late-failure rollback, repeat conflict and disabled category")
|
|
|
|
def concurrent_edit(self, article):
|
|
barrier = Barrier(2, timeout=5)
|
|
def compete(index):
|
|
client = CmsClient(self.port)
|
|
client.cookies = self.owner.cookies.copy()
|
|
try:
|
|
barrier.wait()
|
|
payload = {"selected_article_id": article["id"], "title": f"Concurrent {index}",
|
|
"body": "Winning body", "expected_version": article["version"],
|
|
"category_id": article["category_id"], "asset_id": article["asset_id"]}
|
|
client.connection.request("POST", REVISION, json.dumps(payload), {
|
|
"Content-Type": "application/json", "Origin": client.origin,
|
|
"Cookie": client.cookies["admin"],
|
|
})
|
|
response = client.connection.getresponse()
|
|
body = response.read()
|
|
document = json.loads(body)
|
|
require(set(document) == {"code", "message", "data"}, "invalid race envelope")
|
|
require((response.status, document["code"]) in ((200, 0), (409, 409)),
|
|
f"unexpected concurrent edit: {response.status} {body!r}")
|
|
return response.status, document["data"]
|
|
finally:
|
|
client.close()
|
|
prior = len(sql_read(self.database, "SELECT id FROM revision WHERE article_id=?", (article["id"],)))
|
|
with ThreadPoolExecutor(max_workers=2) as pool:
|
|
results = list(pool.map(compete, (1, 2)))
|
|
require(sorted(status for status, _ in results) == [200, 409], "concurrent edit must have one winner")
|
|
winner = next(value for status, value in results if status == 200)
|
|
require(winner["version"] == article["version"] + 1, "concurrent version advanced twice")
|
|
revisions = sql_read(self.database, "SELECT * FROM revision WHERE article_id=? ORDER BY version", (article["id"],))
|
|
require(len(revisions) == prior + 1 and revisions[-1]["title"] == winner["title"],
|
|
"concurrent edit persisted duplicate or mismatched revisions")
|
|
self.passed("two simultaneous edits produce one version and one revision")
|
|
return winner
|
|
|
|
def scheduled_publish(self):
|
|
articles = [self.create(self.owner, f"scheduled-{index}") for index in (1, 2)]
|
|
due = int(time.time() * 1000) + 3000
|
|
schedules = [self.schedule(self.owner, article, due) for article in articles]
|
|
jobs = [self.job(schedule) for schedule in schedules]
|
|
require(len({job["id"] for job in jobs}) == 2 and all(job["run_at"] == due for job in jobs),
|
|
"same-time schedules merged or enqueue_at lost the due time")
|
|
before = snapshot(self.database)
|
|
with self.worker() as worker:
|
|
require(time.time() * 1000 < due - 500, "fixture did not leave a pre-due observation window")
|
|
while time.time() * 1000 < due - 300:
|
|
require(worker.child.poll() is None, "worker stopped before due time")
|
|
require(all(self.job(value)["state"] == "pending" for value in schedules), "Job ran early")
|
|
self.assert_unchanged(before, "not-yet-due schedule")
|
|
time.sleep(0.05)
|
|
wait_for(lambda: all(self.job(value)["state"] == "succeeded" for value in schedules), worker,
|
|
"same-time scheduled publications")
|
|
for article in articles:
|
|
require(len(sql_read(self.database, "SELECT id FROM publication WHERE slug=?", (article["slug"],))) == 1,
|
|
"scheduled article was not published exactly once")
|
|
self.passed("real future enqueue_at and independent same-time publications")
|
|
before = snapshot(self.database)
|
|
for schedule in schedules:
|
|
# 重放真实已完成任务；保留原身份/租户/权限/指纹/payload，不伪造执行身份。
|
|
fixture_write(self.database, "UPDATE _dever_jobs SET state='pending',attempt=0,run_at=?,"
|
|
"claim_token='',lease_until=0,error='' WHERE id=? AND state='succeeded'",
|
|
(int(time.time() * 1000), self.job(schedule)["id"]))
|
|
with self.worker() as worker:
|
|
wait_for(lambda: all(self.job(value)["state"] == "succeeded" for value in schedules), worker,
|
|
"completed task replay")
|
|
self.assert_unchanged(before, "completed task replay")
|
|
self.passed("completed Job replay adds no publication or audit")
|
|
|
|
def retry_and_revocation(self):
|
|
article = self.create(self.owner, "retry-publish")
|
|
schedule = self.schedule(self.owner, article, int(time.time() * 1000) + 500)
|
|
before = snapshot(self.database)
|
|
with reject_inserts(self.database, "publication"):
|
|
with self.worker() as worker:
|
|
wait_for(lambda: self.job(schedule)["attempt"] == 1
|
|
and self.job(schedule)["state"] == "pending", worker, "first failed Job attempt")
|
|
failed = self.job(schedule)
|
|
require(failed["error"] == "handler_failed", "fixture did not reach business failure")
|
|
self.assert_unchanged(before, "failed Job transaction")
|
|
with self.worker() as worker:
|
|
wait_for(lambda: self.job(schedule)["state"] == "succeeded", worker, "automatic delayed retry")
|
|
require(self.job(schedule)["attempt"] == 2, "retry did not use exactly one new claim")
|
|
self.passed("Job late failure rolls back publication/audit/status and retries successfully")
|
|
|
|
article = self.create(self.member, "revoked-publish")
|
|
schedule = self.schedule(self.member, article, int(time.time() * 1000) + 500)
|
|
before = snapshot(self.database)
|
|
self.owner.request("DELETE", ROLES + "/revoke", {
|
|
"user_id": self.member_identity["user_id"], "role_id": "cms-editor",
|
|
}, site="admin")
|
|
self.member.request("GET", ARTICLE + "/list", site="admin", expected=403)
|
|
with self.worker() as worker:
|
|
wait_for(lambda: self.job(schedule)["state"] == "blocked", worker, "revoked queued permission")
|
|
require(self.job(schedule)["error"] == "identity_rejected", "Job blocked for the wrong reason")
|
|
self.assert_unchanged(before, "permission revoked before Job execution")
|
|
self.passed("immediate role revocation blocks queued Job before business writes")
|
|
|
|
def session_lifecycle(self):
|
|
before = snapshot(self.database)
|
|
logged_out = self.owner.request("POST", "/user/account/admin/session/logout", {}, site="admin")
|
|
require(logged_out["revoked"], "logout did not revoke the session")
|
|
# 保留旧 Cookie 再请求，证明服务端撤销而非仅清除浏览器 Cookie。
|
|
self.owner.request("GET", ARTICLE + "/list", site="admin", expected=401)
|
|
login_client(self.owner, self.identity, self.password, "cms")
|
|
self.owner.request("GET", ARTICLE + "/list", {"size": 20}, site="admin")
|
|
control = self.directory / "data/db/platform.db"
|
|
expired = int(time.time() * 1000) - 1
|
|
fixture_write(control, "UPDATE session SET expires_at=? WHERE user_id=? AND site='admin'",
|
|
(expired, self.identity["user_id"]))
|
|
self.owner.request("GET", ARTICLE + "/list", site="admin", expected=401)
|
|
self.owner.request("GET", "/news/article/front/browse/list", {"size": 100}, site="front")
|
|
self.assert_unchanged(before, "revoked and expired sessions")
|
|
self.passed("logout invalidates the old cookie; expired admin session preserves front isolation")
|
|
|
|
def run(self):
|
|
with Process([self.executable], self.directory / "api") as process:
|
|
ready(process, self.anonymous)
|
|
self.authorization()
|
|
self.editorial()
|
|
self.scheduled_publish()
|
|
self.retry_and_revocation()
|
|
self.session_lifecycle()
|
|
require(process.child.returncode == 0, f"API did not shut down cleanly: {process.directory}")
|
|
|
|
|
|
def run(args, directory, report):
|
|
project = directory / "project"
|
|
copy_cms_project(args.project, project)
|
|
# 忽略输入工程的任何数据库地址；本验收只生成自有 SQLite 配置。
|
|
settings = json.loads((project / "config/setting.json").read_text())
|
|
settings["database"] = {"default": {"type": "sqlite", "path": "data/db/platform.db",
|
|
"tenant_directory": "data/tenants", "max_connections": 4,
|
|
"max_page_size": 100}}
|
|
settings = isolated_settings(settings, available_port())
|
|
settings["runtime"] = {"mode": "api", "shutdown_ms": 3000}
|
|
settings["job"] = {"workers": 1, "poll_ms": 50, "lease_ms": 60000,
|
|
"retry_base_ms": 2000, "retry_max_ms": 2000}
|
|
settings["http"]["upload"] = {"file_bytes": 2048}
|
|
write_private_json(project / "config/setting.json", settings, replace=True)
|
|
if args.compiler:
|
|
append_member_fixture(project)
|
|
execute([args.compiler, "check", project], project, "check")
|
|
execute([args.compiler, "build", project, "--output", project / "cms-app"], project, "build", timeout=300)
|
|
else:
|
|
shutil.copy2(args.executable, project / "cms-app")
|
|
executable = project / "cms-app"
|
|
# 二进制不含部署配置或fixture凭据，可复用以免调试断言时反复编译。
|
|
shutil.copy2(executable, args.output / "cms-app")
|
|
report["executable_bytes"] = executable.stat().st_size
|
|
identity, password = provision_identity(executable, project, "cms")
|
|
member_password = secrets.token_urlsafe(24)
|
|
member = execute([executable, "user.account.fixture_member", json.dumps({
|
|
"selected_tenant_id": identity["tenant_id"], "email": "member@example.invalid",
|
|
"display_name": "CMS member", "password": member_password,
|
|
})], project, "member", envelope=True)
|
|
acceptance = Acceptance(executable, project, settings, identity, password, member, member_password)
|
|
report["passed"] = acceptance.checks
|
|
try:
|
|
acceptance.run()
|
|
return {"passed": acceptance.checks, "database": "owned SQLite", "load_test": False}
|
|
finally:
|
|
acceptance.close()
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
source = parser.add_mutually_exclusive_group(required=True)
|
|
source.add_argument("--compiler", type=Path, help="explicit Dever compiler; builds an owned plain source copy")
|
|
source.add_argument("--executable", type=Path, help="prepared CMS executable including fixture_member CMD")
|
|
parser.add_argument("--project", type=Path, default=ROOT / "examples/cms/dever")
|
|
parser.add_argument("--output", type=Path, required=True, help="new directory for credential-free report/logs")
|
|
args = parser.parse_args()
|
|
args.project = args.project.resolve(strict=True)
|
|
for name in ("compiler", "executable"):
|
|
if getattr(args, name):
|
|
setattr(args, name, getattr(args, name).resolve(strict=True))
|
|
args.output.mkdir(parents=True, exist_ok=False)
|
|
report = {"success": False}
|
|
with tempfile.TemporaryDirectory(prefix="dever-cms-acceptance-") as temporary:
|
|
directory = Path(temporary)
|
|
try:
|
|
report.update(run(args, directory, report), success=True)
|
|
except BaseException as error:
|
|
report["error"] = f"{type(error).__name__}: {error}"
|
|
raise
|
|
finally:
|
|
for log in directory.rglob("*.log"):
|
|
destination = args.output / log.relative_to(directory)
|
|
destination.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(log, destination)
|
|
write_private_json(args.output / "report.json", report)
|
|
print(json.dumps(report, ensure_ascii=False, indent=2))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|