wehub-resource-sync
345 lines
13 KiB
Python
345 lines
13 KiB
Python
"""Build-mode verification: the fixed checklist decides the task state."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from opensquilla.contrib.codetask import build_verify
|
|
from opensquilla.contrib.codetask.types import TaskState
|
|
|
|
|
|
def _make_repo(tmp_path: Path, *, pkg: bool = True, lock: bool = True) -> Path:
|
|
tmp_path.mkdir(parents=True, exist_ok=True)
|
|
if pkg:
|
|
(tmp_path / "package.json").write_text("{}")
|
|
if lock:
|
|
(tmp_path / "package-lock.json").write_text("{}")
|
|
return tmp_path
|
|
|
|
|
|
def _ok(out: str = "ok") -> build_verify._CheckRun:
|
|
return build_verify._CheckRun(ran=True, exit_code=0, timed_out=False, output_tail=out)
|
|
|
|
|
|
def _fail(code: int = 1, out: str = "") -> build_verify._CheckRun:
|
|
return build_verify._CheckRun(ran=True, exit_code=code, timed_out=False, output_tail=out)
|
|
|
|
|
|
def test_missing_lockfile_is_environment_blocked(tmp_path):
|
|
repo = _make_repo(tmp_path, lock=False)
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.ENVIRONMENT_BLOCKED
|
|
assert "package-lock.json" in out.detail
|
|
assert out.build.all_passed is False
|
|
assert out.build.checks == []
|
|
|
|
|
|
def test_all_checks_pass_is_verified(tmp_path, monkeypatch):
|
|
# Pin a deterministic host (linux) and provide its installer, exercising the
|
|
# "all checks pass + installer present -> VERIFIED" path. Every platform now
|
|
# requires its own installer; per-platform cases are covered below.
|
|
monkeypatch.setattr(build_verify.sys, "platform", "linux")
|
|
repo = _make_repo(tmp_path)
|
|
(repo / "dist").mkdir()
|
|
(repo / "dist" / "app-1.0.0.AppImage").write_text("y")
|
|
monkeypatch.setattr(build_verify, "_run_build_check", lambda *a, **k: _ok())
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.VERIFIED
|
|
assert out.build.all_passed is True
|
|
assert [c.name for c in out.build.checks] == [
|
|
"npm_ci",
|
|
"build",
|
|
"package",
|
|
"runtime_deps",
|
|
]
|
|
assert all(c.ok and c.ran for c in out.build.checks)
|
|
assert out.build.installer_path.endswith("app-1.0.0.AppImage")
|
|
|
|
|
|
def test_npm_ci_failure_is_environment_blocked_and_stops_early(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify, "_run_build_check", lambda *a, **k: _fail(1, "npm err"))
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.ENVIRONMENT_BLOCKED
|
|
# stops at the first failing check
|
|
assert [c.name for c in out.build.checks] == ["npm_ci"]
|
|
assert out.build.checks[0].ok is False
|
|
assert out.build.all_passed is False
|
|
|
|
|
|
def test_build_failure_is_failed(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify, "_resolve_cli", lambda name: name)
|
|
|
|
def fake_run(argv, **k):
|
|
if argv[:2] == ["npm", "run"]: # the build step
|
|
return _fail(1, "tsc error")
|
|
return _ok()
|
|
|
|
monkeypatch.setattr(build_verify, "_run_build_check", fake_run)
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.FAILED
|
|
assert [c.name for c in out.build.checks] == ["npm_ci", "build"]
|
|
assert out.build.checks[-1].ok is False
|
|
assert "build" in out.detail
|
|
|
|
|
|
def test_package_failure_is_failed(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify, "_resolve_cli", lambda name: name)
|
|
|
|
def fake_run(argv, **k):
|
|
if argv[0] == "npx": # electron-builder
|
|
return _fail(1, "packaging error")
|
|
return _ok()
|
|
|
|
monkeypatch.setattr(build_verify, "_run_build_check", fake_run)
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.FAILED
|
|
assert [c.name for c in out.build.checks] == ["npm_ci", "build", "package"]
|
|
assert out.build.checks[-1].ok is False
|
|
|
|
|
|
def test_command_not_found_is_recorded(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
|
|
def fake_run(*a, **k):
|
|
return build_verify._CheckRun(
|
|
ran=False,
|
|
exit_code=None,
|
|
timed_out=False,
|
|
output_tail="",
|
|
error="command not found: npm",
|
|
)
|
|
|
|
monkeypatch.setattr(build_verify, "_run_build_check", fake_run)
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.ENVIRONMENT_BLOCKED # npm_ci is the first check
|
|
assert out.build.checks[0].ran is False
|
|
assert "not found" in out.build.checks[0].raw_tail
|
|
|
|
|
|
def test_timeout_is_typed_and_reported(tmp_path, monkeypatch):
|
|
# A hung check must be distinguishable from a build that ran and failed.
|
|
repo = _make_repo(tmp_path)
|
|
|
|
def fake_run(argv, **k):
|
|
if argv[:2] == ["npm", "run"]:
|
|
return build_verify._CheckRun(
|
|
ran=True, exit_code=None, timed_out=True, output_tail="TIMEOUT after 1s"
|
|
)
|
|
return _ok()
|
|
|
|
monkeypatch.setattr(build_verify, "_resolve_cli", lambda name: name)
|
|
monkeypatch.setattr(build_verify, "_run_build_check", fake_run)
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.FAILED
|
|
build_step = out.build.checks[-1]
|
|
assert build_step.name == "build"
|
|
assert build_step.timed_out is True
|
|
assert build_step.ok is False
|
|
assert "timed out" in out.detail
|
|
|
|
|
|
def test_resolve_cli_uses_desktop_node_bin_env(tmp_path, monkeypatch):
|
|
node_bin = tmp_path / "node-bin"
|
|
node_bin.mkdir()
|
|
npm = node_bin / ("npm.cmd" if sys.platform == "win32" else "npm")
|
|
npm.write_text("", encoding="utf-8")
|
|
npm.chmod(0o755)
|
|
monkeypatch.setenv("OPENSQUILLA_NODE_BIN_DIR", str(node_bin))
|
|
monkeypatch.setattr(build_verify.shutil, "which", lambda *a, **k: None)
|
|
|
|
assert build_verify._resolve_cli("npm") == str(npm)
|
|
|
|
|
|
def test_verify_build_prepends_desktop_node_bin_to_child_path(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path / "repo")
|
|
node_bin = tmp_path / "node-bin"
|
|
node_bin.mkdir()
|
|
monkeypatch.setenv("OPENSQUILLA_NODE_BIN_DIR", str(node_bin))
|
|
monkeypatch.setattr(build_verify, "_resolve_cli", lambda name: name)
|
|
|
|
seen_paths: list[str] = []
|
|
|
|
def fake_run(argv, *, cwd, env, timeout):
|
|
seen_paths.append(env["PATH"])
|
|
return _fail(1, "stop after first check")
|
|
|
|
monkeypatch.setattr(build_verify, "_run_build_check", fake_run)
|
|
build_verify.verify_build(repo)
|
|
|
|
assert seen_paths
|
|
assert seen_paths[0].split(build_verify.os.pathsep)[0] == str(node_bin)
|
|
|
|
|
|
def test_verify_build_env_is_non_interactive(tmp_path, monkeypatch):
|
|
# Every verification child must run non-interactively: a prompting build
|
|
# tool should see CI/npm auto-confirm rather than block on the caller's TTY.
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify, "_resolve_cli", lambda name: name)
|
|
|
|
seen_env: list[dict[str, str]] = []
|
|
|
|
def fake_run(argv, *, cwd, env, timeout):
|
|
seen_env.append(env)
|
|
return _fail(1)
|
|
|
|
monkeypatch.setattr(build_verify, "_run_build_check", fake_run)
|
|
build_verify.verify_build(repo)
|
|
|
|
assert seen_env
|
|
env = seen_env[0]
|
|
assert env["CI"] == "1"
|
|
assert env["npm_config_yes"] == "true"
|
|
assert env["CSC_IDENTITY_AUTO_DISCOVERY"] == "false"
|
|
|
|
|
|
def test_run_build_check_closes_stdin_and_is_bounded(tmp_path):
|
|
# Real child: a process that tries to read stdin must get EOF (DEVNULL) and
|
|
# exit promptly rather than blocking; a genuinely hung child must be killed
|
|
# at the deadline and reported as timed_out.
|
|
repo = _make_repo(tmp_path)
|
|
|
|
reads_stdin = [
|
|
sys.executable,
|
|
"-c",
|
|
"import sys; data = sys.stdin.read(); print('read', len(data)); sys.exit(0)",
|
|
]
|
|
run = build_verify._run_build_check(
|
|
reads_stdin, cwd=repo, env=dict(build_verify.os.environ), timeout=30
|
|
)
|
|
assert run.ran is True
|
|
assert run.timed_out is False
|
|
assert run.exit_code == 0
|
|
|
|
hangs = [sys.executable, "-c", "import time; time.sleep(30)"]
|
|
run = build_verify._run_build_check(
|
|
hangs, cwd=repo, env=dict(build_verify.os.environ), timeout=1
|
|
)
|
|
assert run.timed_out is True
|
|
assert run.exit_code is None
|
|
assert "TIMEOUT" in run.output_tail
|
|
|
|
|
|
def test_package_step_is_mac_dmg_on_darwin(monkeypatch):
|
|
monkeypatch.setattr(build_verify.sys, "platform", "darwin")
|
|
name, argv = build_verify._package_step()
|
|
assert name == "package" and "--mac" in argv and "dmg" in argv
|
|
|
|
|
|
def test_package_step_is_linux_appimage_on_linux(monkeypatch):
|
|
# Linux builds a real, tooling-free installer (AppImage), not just --dir.
|
|
monkeypatch.setattr(build_verify.sys, "platform", "linux")
|
|
name, argv = build_verify._package_step()
|
|
assert "--linux" in argv and "AppImage" in argv and "--dir" not in argv
|
|
|
|
|
|
def test_package_step_is_win_nsis_on_win32(monkeypatch):
|
|
monkeypatch.setattr(build_verify.sys, "platform", "win32")
|
|
monkeypatch.setattr(build_verify, "_resolve_cli", lambda name: name)
|
|
name, argv = build_verify._package_step()
|
|
assert name == "package" and "--win" in argv and "nsis" in argv
|
|
|
|
|
|
def test_find_installers_finds_appimage_and_deb_on_linux(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(build_verify.sys, "platform", "linux")
|
|
(tmp_path / "dist").mkdir()
|
|
(tmp_path / "dist" / "app-1.0.0.AppImage").write_text("y")
|
|
(tmp_path / "dist" / "app_1.0.0_amd64.deb").write_text("y")
|
|
(tmp_path / "dist" / "app-1.0.0.dmg").write_text("y") # wrong platform: ignore
|
|
got = build_verify._find_installers(tmp_path)
|
|
assert len(got) == 2
|
|
assert any(p.endswith(".AppImage") for p in got)
|
|
assert any(p.endswith(".deb") for p in got)
|
|
assert not any(p.endswith(".dmg") for p in got)
|
|
|
|
|
|
def test_find_installers_finds_exe_and_skips_unpacked_on_win(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(build_verify.sys, "platform", "win32")
|
|
(tmp_path / "dist").mkdir()
|
|
(tmp_path / "dist" / "App Setup 1.0.0.exe").write_text("y") # the installer
|
|
unpacked = tmp_path / "dist" / "win-unpacked"
|
|
unpacked.mkdir()
|
|
(unpacked / "App.exe").write_text("y") # raw app exe — must NOT be picked up
|
|
got = build_verify._find_installers(tmp_path)
|
|
assert got == [str(tmp_path / "dist" / "App Setup 1.0.0.exe")]
|
|
|
|
|
|
def test_find_installers_lists_all_dmgs_on_darwin(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(build_verify.sys, "platform", "darwin")
|
|
(tmp_path / "dist").mkdir()
|
|
(tmp_path / "dist" / "app-arm64.dmg").write_text("y")
|
|
(tmp_path / "dist" / "app-x64.dmg").write_text("y")
|
|
got = build_verify._find_installers(tmp_path)
|
|
assert len(got) == 2 and all(p.endswith(".dmg") for p in got)
|
|
|
|
|
|
@pytest.mark.skipif(sys.platform == "win32", reason="code-task Windows support is WIP")
|
|
def test_find_installers_finds_dmg_in_custom_output_dir_on_darwin(tmp_path, monkeypatch):
|
|
# electron-builder `directories.output: release` (not the default dist/).
|
|
monkeypatch.setattr(build_verify.sys, "platform", "darwin")
|
|
(tmp_path / "release").mkdir()
|
|
(tmp_path / "release" / "app-1.0.0-arm64.dmg").write_text("y")
|
|
got = build_verify._find_installers(tmp_path)
|
|
assert len(got) == 1 and got[0].endswith("release/app-1.0.0-arm64.dmg")
|
|
|
|
|
|
def test_find_installers_ignores_node_modules_dmgs(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(build_verify.sys, "platform", "darwin")
|
|
nm = tmp_path / "node_modules" / "some-pkg"
|
|
nm.mkdir(parents=True)
|
|
(nm / "vendored.dmg").write_text("y") # must NOT be picked up
|
|
(tmp_path / "release").mkdir()
|
|
(tmp_path / "release" / "real.dmg").write_text("y")
|
|
got = build_verify._find_installers(tmp_path)
|
|
assert got == [str(tmp_path / "release" / "real.dmg")]
|
|
|
|
|
|
def test_clean_package_without_installer_is_failed(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify.sys, "platform", "darwin")
|
|
monkeypatch.setattr(build_verify, "_run_build_check", lambda *a, **k: _ok())
|
|
out = build_verify.verify_build(repo) # all steps exit 0 but no installer
|
|
assert out.state is TaskState.FAILED
|
|
assert "no installer" in out.detail
|
|
assert out.build.all_passed is False
|
|
|
|
|
|
def test_darwin_package_with_dmg_is_verified(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify.sys, "platform", "darwin")
|
|
monkeypatch.setattr(build_verify, "_run_build_check", lambda *a, **k: _ok())
|
|
(repo / "dist").mkdir()
|
|
(repo / "dist" / "app-1.0.0.dmg").write_text("y")
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.VERIFIED
|
|
assert out.build.installer_path.endswith("app-1.0.0.dmg")
|
|
assert out.build.installer_paths == [out.build.installer_path]
|
|
|
|
|
|
def test_win_package_with_exe_is_verified(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify.sys, "platform", "win32")
|
|
monkeypatch.setattr(build_verify, "_resolve_cli", lambda name: name)
|
|
monkeypatch.setattr(build_verify, "_run_build_check", lambda *a, **k: _ok())
|
|
(repo / "dist").mkdir()
|
|
(repo / "dist" / "App Setup 1.0.0.exe").write_text("y")
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.VERIFIED
|
|
assert out.build.installer_path.endswith(".exe")
|
|
|
|
|
|
def test_linux_package_with_appimage_is_verified(tmp_path, monkeypatch):
|
|
repo = _make_repo(tmp_path)
|
|
monkeypatch.setattr(build_verify.sys, "platform", "linux")
|
|
monkeypatch.setattr(build_verify, "_run_build_check", lambda *a, **k: _ok())
|
|
(repo / "dist").mkdir()
|
|
(repo / "dist" / "app-1.0.0.AppImage").write_text("y")
|
|
out = build_verify.verify_build(repo)
|
|
assert out.state is TaskState.VERIFIED
|
|
assert out.build.installer_path.endswith(".AppImage")
|