Paul Payne
e438f45b54
Model:
- Drop `requires` from ProgramSpec; requires is now deployment-only.
Collapse Requirement to {ref, bind} with kind defaulting to "deployment"
(drop the unused `version`). System-package preconditions stay on the
program as `system_dependencies`, synthesized into {kind: system} for the
functional check. relations.py/deploy.py read only the deployment's requires.
- create.py seeds a stack's substrate dependency onto the deployment, not the
program. Docs + tests updated.
UI:
- Add a `requires` editor (useRequires) on service, job, and static detail
pages — edit service→service deps (ref + optional bind env var).
- Restore the gateway route table "Open" column: a kind-aware in-app link to
each route's deployment.
- Reformat the reach control: name baked into each option
(localhost:PORT (local) / <name>.<domain> (internal) / <name>.<pubdomain> (public)).
- Services page: sort statics in with systemd services by name, add a
search + kind-filter bar mirroring the programs page.
110 lines
4.4 KiB
Python
110 lines
4.4 KiB
Python
"""Tests for the relationship model (core/src/castle_core/relations.py)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import pytest
|
|
|
|
import castle_core.config as C
|
|
from castle_core import relations as R
|
|
from castle_core.manifest import ProgramSpec, SystemdDeployment
|
|
|
|
|
|
def _dep(program: str, requires: list | None = None) -> SystemdDeployment:
|
|
spec: dict = {
|
|
"manager": "systemd",
|
|
"program": program,
|
|
"run": {"launcher": "command", "argv": [program]},
|
|
}
|
|
if requires is not None:
|
|
spec["requires"] = requires
|
|
return SystemdDeployment.model_validate(spec)
|
|
|
|
|
|
def _cfg(programs: dict, deployments: dict) -> C.CastleConfig:
|
|
return C.CastleConfig(
|
|
root=None,
|
|
gateway=C.GatewayConfig(port=9000),
|
|
repo=None,
|
|
programs=programs,
|
|
deployments=deployments,
|
|
)
|
|
|
|
|
|
def test_system_dependencies_is_the_system_requirement_alias() -> None:
|
|
"""`system_dependencies` surfaces as a {kind: system} requirement."""
|
|
cfg = _cfg(
|
|
{"t": ProgramSpec(id="t", system_dependencies=["pandoc"])}, {"t": _dep("t")}
|
|
)
|
|
reqs = R.requirements_of(cfg, "t")
|
|
assert [(r.kind, r.ref) for r in reqs] == [("system", "pandoc")]
|
|
|
|
|
|
def test_requirements_merge_system_deps_and_deployment_requires_deduped() -> None:
|
|
"""The requirement set unions the program's system_dependencies (as {kind: system})
|
|
with the deployment's own requires, de-duplicated by (kind, ref)."""
|
|
prog = ProgramSpec(id="web", system_dependencies=["pandoc"])
|
|
# Two identical deployment requires — deduped to one.
|
|
dep = _dep("web", requires=[{"ref": "api"}, {"ref": "api"}])
|
|
cfg = _cfg(
|
|
{"web": prog, "api": ProgramSpec(id="api")}, {"web": dep, "api": _dep("api")}
|
|
)
|
|
kinds = {(r.kind, r.ref) for r in R.requirements_of(cfg, "web")}
|
|
assert kinds == {("system", "pandoc"), ("deployment", "api")} # deduped
|
|
|
|
|
|
def test_deployment_edge_carries_bind_and_counts_fan_in() -> None:
|
|
"""A {kind: deployment} requirement becomes an edge (with bind), and the target's
|
|
fan-in is the count of distinct dependents."""
|
|
cfg = _cfg(
|
|
{"web": ProgramSpec(id="web"), "cli": ProgramSpec(id="cli"), "api": ProgramSpec(id="api")},
|
|
{
|
|
"web": _dep("web", requires=[{"ref": "api", "bind": "API_URL"}]),
|
|
"cli": _dep("cli", requires=[{"ref": "api"}]),
|
|
"api": _dep("api"),
|
|
},
|
|
)
|
|
m = R.build_model(cfg, check=False)
|
|
edge = next(e for e in m.edges if e.src == "web" and e.dst == "api")
|
|
assert edge.kind == "deployment" and edge.bind == "API_URL"
|
|
api = next(n for n in m.nodes if n.name == "api")
|
|
assert api.depended_on_by == 2 # web + cli
|
|
|
|
|
|
def test_functional_predicate_reports_unmet(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
"""`functional?` is derived: a missing system package is unmet; a present
|
|
deployment requirement is satisfied."""
|
|
prog = ProgramSpec(id="web", system_dependencies=["pandoc"])
|
|
cfg = _cfg(
|
|
{"web": prog, "api": ProgramSpec(id="api")},
|
|
{"web": _dep("web", requires=[{"ref": "api"}]), "api": _dep("api")},
|
|
)
|
|
monkeypatch.setattr(R.shutil, "which", lambda _: None) # not on PATH
|
|
monkeypatch.setattr(R, "_dpkg_installed", lambda _: False) # nor as a package
|
|
m = R.build_model(cfg, check=True)
|
|
web = next(n for n in m.nodes if n.name == "web")
|
|
assert web.unmet == ["system:pandoc"] # deployment:api exists → satisfied
|
|
assert web.functional is False
|
|
|
|
|
|
def test_system_requirement_satisfied_by_package_not_on_path(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
"""A package name that isn't a command (poppler-utils) is satisfied when the
|
|
package is installed — a PATH lookup alone would wrongly report it unmet."""
|
|
prog = ProgramSpec(id="t", system_dependencies=["poppler-utils"])
|
|
cfg = _cfg({"t": prog}, {"t": _dep("t")})
|
|
monkeypatch.setattr(R.shutil, "which", lambda _: None) # no `poppler-utils` binary
|
|
monkeypatch.setattr(R, "_dpkg_installed", lambda pkg: pkg == "poppler-utils")
|
|
t = next(n for n in R.build_model(cfg, check=True).nodes if n.name == "t")
|
|
assert t.functional is True and t.unmet == []
|
|
|
|
|
|
def test_missing_deployment_requirement_is_unmet() -> None:
|
|
cfg = _cfg(
|
|
{"web": ProgramSpec(id="web")},
|
|
{"web": _dep("web", requires=[{"ref": "ghost"}])},
|
|
)
|
|
m = R.build_model(cfg, check=True)
|
|
web = next(n for n in m.nodes if n.name == "web")
|
|
assert web.unmet == ["deployment:ghost"] and web.functional is False
|