Files
make-cad/test/test_part_builder.py
T
2026-08-15 16:17:11 +08:00

430 lines
15 KiB
Python

from __future__ import annotations
from concurrent.futures import ThreadPoolExecutor
import importlib.util
import threading
import time
from pathlib import Path
import sys
import pytest
import simplecadapi as scad
from simplecadapi.artifacts.canonical import ArtifactValidationError
def _load_function(path: Path, source: str, name: str):
path.write_text(source, encoding="utf-8")
spec = importlib.util.spec_from_file_location(f"part_fixture_{path.stem}", path)
assert spec is not None and spec.loader is not None
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module, getattr(module, name)
def _policy(root: Path, mode: str = "read_write") -> scad.CachePolicy:
return scad.CachePolicy(mode=mode, root=root)
def test_part_reuses_runtime_in_process_and_restores_across_wrappers(
tmp_path: Path,
) -> None:
calls = 0
policy = _policy(tmp_path / "cache")
@scad.part(id="cached_box", cache=policy)
def build_box(width: float = 2.0) -> scad.Part:
nonlocal calls
calls += 1
body = scad.make_box_rsolid(width=width, height=3.0, depth=4.0)
body = scad.apply_tag(shape=body, tag="role.body")
part = scad.make_part_rpart(part_id="cached_box", body=body)
connector = scad.make_placement_connector_rconnector(
connector_id="mount",
placement=scad.make_placement_rplacement(origin=(1.0, 0.0, 0.0)),
)
return scad.add_connector_rpart(part=part, connector=connector)
cold = build_box()
memory_warm = build_box()
restored_builder = scad.part(id="cached_box", cache=policy)(build_box.__wrapped__)
disk_warm = restored_builder()
assert calls == 1
assert not cold.cache_report.hit
assert memory_warm.cache_report.hit
assert memory_warm.cache_report.part_lookups == 0
assert memory_warm.cache_report.bytes_read == 0
assert memory_warm.feature_graph is cold.feature_graph
assert memory_warm.value is cold.value
assert disk_warm.cache_report.hit
assert disk_warm.cache_report.part_lookups == 1
assert disk_warm.cache_report.bytes_read > 0
assert disk_warm.feature_graph is not cold.feature_graph
assert disk_warm.value is not cold.value
assert disk_warm.value.body is not cold.value.body
assert disk_warm.value.body.get_volume() == pytest.approx(24.0)
assert disk_warm.definition.canonical_bytes == cold.definition.canonical_bytes
assert disk_warm.feature_graph.canonical_bytes == cold.feature_graph.canonical_bytes
assert disk_warm.feature_graph.restore_session().graph.to_dict() == (
cold.feature_graph.restore_session().graph.to_dict()
)
assert disk_warm.value.connector_ids() == ("mount",)
assert disk_warm.definition.interface_hashes == cold.definition.interface_hashes
assert scad.list_tags(shape=disk_warm.value.body) == scad.list_tags(
shape=cold.value.body
)
def test_part_operations_create_only_a_whole_part_cache_record(
tmp_path: Path,
) -> None:
policy = _policy(tmp_path / "cache")
@scad.part(id="layered_cache", cache=policy)
def build() -> scad.Solid:
body = scad.make_box_rsolid(width=4.0, height=4.0, depth=2.0)
tool = scad.make_cylinder_rsolid(
radius=1.0,
height=4.0,
bottom_face_center=(2.0, 2.0, -1.0),
)
return scad.cut_rsolid(body, tool)
result = build()
store = scad.ContentAddressedStore(policy)
assert not result.cache_report.hit
assert store.stats().records == 1
assert (store.records_dir / "part").exists()
def test_part_accepts_solid_and_wraps_definition_id(tmp_path: Path) -> None:
@scad.part(id="solid_result", cache=_policy(tmp_path / "cache"))
def build() -> scad.Solid:
return scad.make_box_rsolid(width=1.0, height=2.0, depth=3.0)
result = build()
assert result.value.part_id == "solid_result"
assert result.value.body.get_volume() == pytest.approx(6.0)
assert result.feature_graph.result_node_ids == (
result.feature_graph.restore_session().result_node_ids
)
def test_part_deduplicates_concurrent_same_parameter_calls(tmp_path: Path) -> None:
calls = 0
guard = threading.Lock()
@scad.part(id="concurrent_part", cache=_policy(tmp_path / "cache"))
def build(width: float) -> scad.Solid:
nonlocal calls
with guard:
calls += 1
time.sleep(0.05)
return scad.make_box_rsolid(width=width, height=2.0, depth=3.0)
with ThreadPoolExecutor(max_workers=8) as executor:
results = list(executor.map(lambda _: build(4.0), range(8)))
assert calls == 1
assert sum(not result.cache_report.hit for result in results) == 1
assert all(result.value is results[0].value for result in results)
assert all(
result.value.body.get_volume() == pytest.approx(24.0) for result in results
)
def test_part_rejects_wrong_result_and_mismatched_part_id(tmp_path: Path) -> None:
@scad.part(id="expected", cache=_policy(tmp_path / "cache-a"))
def wrong_type():
scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
return ()
@scad.part(id="expected", cache=_policy(tmp_path / "cache-b"))
def wrong_id():
body = scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
return scad.make_part_rpart(part_id="actual", body=body)
with pytest.raises(ArtifactValidationError, match="solid_cardinality_invalid"):
wrong_type()
with pytest.raises(ArtifactValidationError, match="definition_id_mismatch"):
wrong_id()
def test_part_rejects_multiple_explicit_results(tmp_path: Path) -> None:
@scad.part(id="multiple", cache=_policy(tmp_path / "cache"))
def build():
first = scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
second = scad.make_box_rsolid(width=2.0, height=2.0, depth=2.0)
session = scad.get_active_session()
assert session is not None
session.capture_result(value=(first, second))
return second
with pytest.raises(ArtifactValidationError, match="exactly one result node"):
build()
def test_part_rejects_nested_session_and_async(tmp_path: Path) -> None:
@scad.part(id="nested", cache=_policy(tmp_path / "cache"))
def build():
return scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
with scad.GraphSession(graph_id="outer"):
with pytest.raises(RuntimeError, match="cannot be nested"):
build()
async def async_build():
return None
with pytest.raises(TypeError, match="does not support async"):
scad.part(async_build)
def test_part_key_changes_with_arguments_and_file_bytes_not_mtime(
tmp_path: Path,
) -> None:
(tmp_path / "pyproject.toml").write_text(
"[project]\nname='fixture'\nversion='1.0.0'\n", encoding="utf-8"
)
source = tmp_path / "input.txt"
source.write_text("alpha", encoding="utf-8")
module, function = _load_function(
tmp_path / "builder.py",
"import simplecadapi as scad\n"
"calls = 0\n"
"def build(width, depth):\n"
" global calls\n"
" calls += 1\n"
" return scad.make_box_rsolid(width=width, height=1.0, depth=depth)\n",
"build",
)
build = scad.part(
id="dependent",
inputs=(scad.file_input("input.txt"),),
cache=_policy(tmp_path / "cache"),
project_root=tmp_path,
)(function)
first = build(2.0, 3.0)
same = build(2.0, 3.0)
changed_argument = build(4.0, 3.0)
previous_mtime = source.stat().st_mtime_ns
source.write_text("bravo", encoding="utf-8")
source.touch()
assert source.stat().st_mtime_ns >= previous_mtime
changed_file = build(4.0, 3.0)
assert module.calls == 3
assert same.cache_report.hit
assert (
len(
{
first.cache_report.build_key,
changed_argument.cache_report.build_key,
changed_file.cache_report.build_key,
}
)
== 3
)
def test_part_helper_source_change_rebuilds_same_key_without_quarantine(
tmp_path: Path,
monkeypatch: pytest.MonkeyPatch,
) -> None:
(tmp_path / "pyproject.toml").write_text(
"[project]\nname='source-fixture'\nversion='1.0.0'\n",
encoding="utf-8",
)
helper_path = tmp_path / "cache_helper.py"
builder_path = tmp_path / "builder.py"
helper_path.write_text(
"import simplecadapi as scad\n"
"def make_body():\n"
" return scad.make_box_rsolid(width=1.0, height=2.0, depth=3.0)\n",
encoding="utf-8",
)
builder_source = (
"import cache_helper\n"
"def build():\n"
" return cache_helper.make_body()\n"
)
monkeypatch.syspath_prepend(str(tmp_path))
_module, function = _load_function(builder_path, builder_source, "build")
policy = _policy(tmp_path / "cache")
first = scad.part(
id="helper_dependent",
cache=policy,
project_root=tmp_path,
)(function)()
first_key = first.cache_report.build_key
first_quarantine = scad.ContentAddressedStore(policy).stats().quarantined
encoded = scad.encode_part_definition(first.definition)
from simplecadapi.scene.archive import preflight_zip_bytes
archive = preflight_zip_bytes(encoded, manifest_name="part-definition.json")
feature_payload = archive.members[
"blobs/" + first.definition.feature_graph_ref.path
]
archived_graph = scad.load_feature_graph_artifact(feature_payload)
helper_snapshot = next(
item for item in archived_graph.source_files if item.display_path == "cache_helper.py"
)
assert archived_graph.blobs[helper_snapshot.uri] == helper_path.read_bytes()
helper_path.write_text(
"import simplecadapi as scad\n"
"def make_body():\n"
" # Deliberately changes helper bytes without changing builder bytes.\n"
" return scad.make_box_rsolid(width=1.0, height=5.0, depth=3.0)\n",
encoding="utf-8",
)
importlib.invalidate_caches()
sys.modules.pop("cache_helper", None)
_module, changed_function = _load_function(builder_path, builder_source, "build")
changed = scad.part(
id="helper_dependent",
cache=policy,
project_root=tmp_path,
)(changed_function)()
assert changed.cache_report.build_key == first_key
assert not changed.cache_report.hit
assert changed.cache_report.miss_reason == "source_changed"
assert changed.value.body.get_volume() == pytest.approx(15.0)
assert scad.ContentAddressedStore(policy).stats().quarantined == first_quarantine
def test_part_argument_normalizer_rejects_unknown_cycles_and_nonfinite(
tmp_path: Path,
) -> None:
class Unknown:
pass
@scad.part(id="arguments", cache=_policy(tmp_path / "cache"))
def build(value):
return scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
cycle: list[object] = []
cycle.append(cycle)
with pytest.raises(ArtifactValidationError, match="unsupported canonical value"):
build(Unknown())
with pytest.raises(ArtifactValidationError, match="cycle_invalid"):
build(cycle)
with pytest.raises(ArtifactValidationError, match="number must be finite"):
build(float("nan"))
def test_part_cache_modes_off_read_only_and_refresh(tmp_path: Path) -> None:
calls = 0
cache_root = tmp_path / "cache"
def body() -> scad.Solid:
nonlocal calls
calls += 1
return scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
cached = scad.part(id="modes", cache=_policy(cache_root))(body)
assert not cached().cache_report.hit
assert cached().cache_report.hit
after_cached = calls
off = scad.part(id="modes", cache=_policy(cache_root, "off"))(body)
assert not off().cache_report.hit
assert not off().cache_report.hit
after_off = calls
read_only = scad.part(id="modes", cache=_policy(cache_root, "read_only"))(body)
assert read_only().cache_report.hit
after_read_only = calls
refresh = scad.part(id="modes", cache=_policy(cache_root, "refresh"))(body)
refreshed = refresh()
assert not refreshed.cache_report.hit
assert refreshed.cache_report.miss_reason == "refresh"
assert (after_cached, after_off, after_read_only, calls) == (1, 3, 3, 4)
def test_part_corrupt_payload_rebuilds_and_quarantines(tmp_path: Path) -> None:
calls = 0
policy = _policy(tmp_path / "cache")
@scad.part(id="corrupt", cache=policy)
def build() -> scad.Solid:
nonlocal calls
calls += 1
return scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
first = build()
store = scad.ContentAddressedStore(policy)
entry = store.get("part", first.cache_report.build_key)
assert entry is not None
store.object_path(entry.record.object_hash).write_bytes(b"not-a-cache-payload")
rebuilt = scad.part(id="corrupt", cache=policy)(build.__wrapped__)()
assert calls == 2
assert not rebuilt.cache_report.hit
assert rebuilt.cache_report.corrupt_entries == 0
assert rebuilt.cache_report.miss_reason == "record_missing"
assert store.stats().quarantined >= 1
def test_part_rejects_legacy_export_dir(tmp_path: Path) -> None:
with pytest.raises(TypeError, match="export_dir"):
scad.part(
id="exported",
cache=_policy(tmp_path / "cache"),
export_dir=tmp_path / "out",
)
def test_part_definition_archive_round_trip_and_reexport(tmp_path: Path) -> None:
@scad.part(id="definition_io", cache=_policy(tmp_path / "cache"))
def build() -> scad.Solid:
return scad.make_box_rsolid(width=2.0, height=3.0, depth=4.0)
result = build()
first = scad.export_part_definition(
result.definition,
tmp_path / "first.part-definition.zip",
)
loaded = scad.load_part_definition(first)
second = scad.export_part_definition(
loaded,
tmp_path / "second.part-definition.zip",
)
assert loaded.canonical_bytes == result.definition.canonical_bytes
assert first.read_bytes() == second.read_bytes()
def test_part_definition_archive_rejects_mutated_and_extra_blobs(
tmp_path: Path,
) -> None:
from simplecadapi.scene.archive import canonical_zip_bytes, preflight_zip_bytes
@scad.part(id="definition_corrupt", cache=_policy(tmp_path / "cache"))
def build() -> scad.Solid:
return scad.make_box_rsolid(width=1.0, height=1.0, depth=1.0)
encoded = scad.encode_part_definition(build().definition)
archive = preflight_zip_bytes(encoded, manifest_name="part-definition.json")
members = dict(archive.members)
body_name = next(name for name in members if name.endswith(".brep"))
members[body_name] += b"x"
mutated = canonical_zip_bytes(members, manifest_name="part-definition.json")
with pytest.raises(
ArtifactValidationError, match="blob_size_mismatch|blob_hash_mismatch"
):
scad.load_part_definition(mutated)
members = dict(archive.members)
members["blobs/unexpected.bin"] = b"unexpected"
extra = canonical_zip_bytes(members, manifest_name="part-definition.json")
with pytest.raises(ArtifactValidationError, match="member set differs"):
scad.load_part_definition(extra)