Turn any AI agent into an AI Scientist. The #1 Agent Skills library for science, used by 250,000+ scientists worldwide. 177 ready-to-use validated skills plus 100+ scientific databases covering biology, chemistry, medicine, and drug discovery. Compatible with Cursor, Claude Code, Codex, Pi, Antigravity, and the open Agent Skills standard.
Python agent-skillsai-scientistbioinformaticschemoinformaticsclaudeclaude-skillsclaudecodeclinical-researchcomputational-biologydata-analysisdrug-discoverygenomicsmaterials-sciencemetabolomicsproteomicsscientific-computingscientific-visualization
"""Tests for the Fictiv skill's bundled tooling.
`check_cad_file.py` is standard-library only, so everything here runs in the
bare environment. The STEP fixtures are real Open CASCADE exports from
build123d 0.11 (a 60 x 40 x 15 mm block with a 4 mm through hole, the same
geometry re-expressed in inch units the way SolidWorks and Creo write them,
two separate solids in one file, and a lone face). STL meshes are generated
in-test because a cube is twelve triangles.
The browser scripts (`quote_state.js`, `list_dropdown_options.js`) only run
against a logged-in app.fictiv.com session, so they are checked for syntax and
for the read-only promise the skill makes about them, not for behaviour.
"""
from __future__ import annotations
import json
import re
import shutil
import struct
import subprocess
import sys
import tempfile
import unittest
from pathlib import Path
import skill_contract
SKILL_ROOT = Path(__file__).resolve().parents[2] / "skills" / "fictiv"
SCRIPTS = SKILL_ROOT / "scripts"
FIXTURES = Path(__file__).resolve().parent / "fixtures"
sys.path.insert(0, str(SCRIPTS))
import check_cad_file # noqa: E402
CliHelpTests = skill_contract.cli.help_test_case(SKILL_ROOT)
BROWSER_SCRIPTS = ("quote_state.js", "list_dropdown_options.js")
CUBE_FACES = (
((0, 0, 0), (1, 1, 0), (1, 0, 0)), ((0, 0, 0), (0, 1, 0), (1, 1, 0)),
((0, 0, 1), (1, 0, 1), (1, 1, 1)), ((0, 0, 1), (1, 1, 1), (0, 1, 1)),
((0, 0, 0), (1, 0, 0), (1, 0, 1)), ((0, 0, 0), (1, 0, 1), (0, 0, 1)),
((0, 1, 0), (1, 1, 1), (1, 1, 0)), ((0, 1, 0), (0, 1, 1), (1, 1, 1)),
((0, 0, 0), (0, 0, 1), (0, 1, 1)), ((0, 0, 0), (0, 1, 1), (0, 1, 0)),
((1, 0, 0), (1, 1, 0), (1, 1, 1)), ((1, 0, 0), (1, 1, 1), (1, 0, 1)),
)
def cube(size: tuple[float, float, float], drop: int = 0) -> list:
"""Triangles of an axis-aligned box, optionally with `drop` facets removed."""
faces = CUBE_FACES[: len(CUBE_FACES) - drop]
return [tuple(tuple(c * s for c, s in zip(v, size)) for v in tri) for tri in faces]
def write_binary_stl(path: Path, tris: list) -> None:
with open(path, "wb") as fh:
fh.write(b"\0" * 80 + struct.pack("<I", len(tris)))
for tri in tris:
fh.write(struct.pack("<3f", 0, 0, 0))
for v in tri:
fh.write(struct.pack("<3f", *v))
fh.write(b"\0\0")
def write_ascii_stl(path: Path, tris: list) -> None:
rows = ["solid test"]
for tri in tris:
rows += ["facet normal 0 0 0", "outer loop"]
rows += [f"vertex {x} {y} {z}" for x, y, z in tri]
rows += ["endloop", "endfacet"]
path.write_text("\n".join(rows + ["endsolid test"]) + "\n")
def scaled_step(src: Path, dst: Path, sx: float, sy: float, sz: float) -> None:
"""Copy a STEP file with every CARTESIAN_POINT scaled per axis.
The result is not a valid solid for the curved faces, but the checker only
reads vertex coordinates for its bounding box, which is what is under test.
"""
def scale(m: re.Match) -> str:
coords = [float(c) for c in m.group(2).split(",")]
if len(coords) != 3: # 2D parameter-space points on pcurves
return m.group(0)
x, y, z = coords
return f"{m.group(1)}{x * sx:.6G},{y * sy:.6G},{z * sz:.6G}{m.group(3)}"
text = src.read_text()
dst.write_text(re.sub(r"(CARTESIAN_POINT\('[^']*',\()([^)]*)(\))", scale, text))
class StepInspectionTests(unittest.TestCase):
def test_single_mm_block_is_clean(self):
r = check_cad_file.check(str(FIXTURES / "block_mm.step"), "cnc")
self.assertEqual(r["blocking"], [])
self.assertEqual(r["warnings"], [])
self.assertEqual(r["info"]["solid_bodies"], 1)
self.assertEqual(r["info"]["length_unit"], "mm")
self.assertEqual(r["info"]["approx_bbox_mm"], [60.0, 40.0, 15.0])
self.assertIn("214", r["info"]["schema"])
def test_inch_unit_is_detected_and_bbox_converted_to_mm(self):
# The inch file still carries an SI millimetre entity as the conversion
# base, so the inch check has to win over the millimetre one.
r = check_cad_file.check(str(FIXTURES / "block_inch.step"), "cnc")
self.assertEqual(r["info"]["length_unit"], "inch")
self.assertEqual(r["info"]["approx_bbox_mm"], [50.8, 25.4, 12.7])
self.assertEqual(r["blocking"], [])
def test_multi_body_blocks_cnc_but_only_warns_for_3dp(self):
path = str(FIXTURES / "two_bodies.step")
cnc = check_cad_file.check(path, "cnc")
self.assertEqual(cnc["info"]["solid_bodies"], 2)
self.assertTrue(any("2 solid bodies" in b for b in cnc["blocking"]))
printed = check_cad_file.check(path, "3dp")
self.assertEqual(printed["blocking"], [])
self.assertTrue(any("2 solid bodies" in w for w in printed["warnings"]))
def test_surface_only_model_is_blocked(self):
r = check_cad_file.check(str(FIXTURES / "surface_only.step"), "cnc")
self.assertEqual(r["info"]["solid_bodies"], 0)
self.assertTrue(any("only surface geometry" in b for b in r["blocking"]))
def test_itar_marking_is_blocked(self):
with tempfile.TemporaryDirectory() as tmp:
marked = Path(tmp) / "marked.step"
text = (FIXTURES / "block_mm.step").read_text()
marked.write_text(text.replace("PRODUCT('", "PRODUCT('ITAR CONTROLLED ", 1))
r = check_cad_file.check(str(marked), "cnc")
self.assertTrue(any("ITAR" in b for b in r["blocking"]))
def test_oversize_cnc_part_warns(self):
with tempfile.TemporaryDirectory() as tmp:
long_bar = Path(tmp) / "long.step"
scaled_step(FIXTURES / "block_mm.step", long_bar, 35, 1, 1)
r = check_cad_file.check(str(long_bar), "cnc")
self.assertEqual(r["info"]["approx_bbox_mm"], [2100.0, 40.0, 15.0])
self.assertTrue(any("exceeds Fictiv's published cnc envelope" in w for w in r["warnings"]))
def test_unknown_units_are_not_reported_as_millimetres(self):
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / "unknown.step"
path.write_text((FIXTURES / "block_mm.step").read_text().replace(
"SI_UNIT(.MILLI.,.METRE.)", "SI_UNIT($,.UNRECOGNIZED.)"))
r = check_cad_file.check(str(path), "cnc")
self.assertEqual(r["info"]["length_unit"], "unknown")
self.assertEqual(r["info"]["approx_bbox_units"], [60.0, 40.0, 15.0])
self.assertNotIn("approx_bbox_mm", r["info"])
def test_envelope_check_is_orientation_independent(self):
# 900 x 700 x 100 mm fits the 914 x 609 x 914 mm FDM envelope once the
# part is laid flat; comparing sorted part dims to unsorted envelope
# axes used to flag it.
with tempfile.TemporaryDirectory() as tmp:
big = Path(tmp) / "big.step"
scaled_step(FIXTURES / "block_mm.step", big, 15, 17.5, 100 / 15)
r = check_cad_file.check(str(big), "3dp")
self.assertEqual(r["info"]["approx_bbox_mm"], [900.0, 700.0, 100.0])
self.assertFalse(any("envelope" in w for w in r["warnings"]), r["warnings"])
class StlInspectionTests(unittest.TestCase):
def setUp(self):
self._tmp = tempfile.TemporaryDirectory()
self.tmp = Path(self._tmp.name)
def tearDown(self):
self._tmp.cleanup()
def test_binary_and_ascii_closed_box_are_watertight(self):
for writer, encoding in ((write_binary_stl, "binary"), (write_ascii_stl, "ascii")):
with self.subTest(encoding=encoding):
path = self.tmp / f"box_{encoding}.stl"
writer(path, cube((60, 40, 15)))
r = check_cad_file.check(str(path), "3dp")
self.assertEqual(r["info"]["encoding"], encoding)
self.assertEqual(r["info"]["triangles"], 12)
self.assertTrue(r["info"]["watertight"])
self.assertEqual(r["info"]["bbox_units"], [60.0, 40.0, 15.0])
self.assertEqual(r["blocking"], [])
self.assertEqual(r["warnings"], [])
def test_open_mesh_warns(self):
path = self.tmp / "open.stl"
write_binary_stl(path, cube((60, 40, 15), drop=1))
r = check_cad_file.check(str(path), "3dp")
self.assertFalse(r["info"]["watertight"])
self.assertEqual(r["info"]["non_manifold_or_open_edges"], 3)
self.assertTrue(any("not watertight" in w for w in r["warnings"]))
def test_mesh_is_blocked_for_non_printing_processes(self):
path = self.tmp / "box.stl"
write_binary_stl(path, cube((60, 40, 15)))
for process in ("cnc", "sheet", "urethane", "im"):
with self.subTest(process=process):
r = check_cad_file.check(str(path), process)
self.assertTrue(any("3D printing only" in b for b in r["blocking"]))
def test_tiny_mesh_suggests_inch_units(self):
path = self.tmp / "tiny.stl"
write_binary_stl(path, cube((2, 1, 0.5)))
r = check_cad_file.check(str(path), "3dp")
self.assertTrue(any("25.4x too small" in w for w in r["warnings"]))
self.assertEqual(r["info"]["bbox_if_inch_in_mm"], [50.8, 25.4, 12.7])
class ExtensionTests(unittest.TestCase):
def setUp(self):
self._tmp = tempfile.TemporaryDirectory()
self.tmp = Path(self._tmp.name)
def tearDown(self):
self._tmp.cleanup()
def touch(self, name: str, content: bytes = b"x") -> str:
path = self.tmp / name
path.write_bytes(content)
return str(path)
def test_rejected_formats_block(self):
for name, fragment in (
("part.igs", "IGES"),
("part.iges", "IGES"),
("part.f3d", "Fusion 360"),
("part.dxf", "DXF"),
("part.psm", "Solid Edge sheet metal"),
("part.pwd", "Solid Edge weldment"),
("top.sldasm", "assembly files"),
("part.xyz", "unrecognized extension"),
):
with self.subTest(name=name):
r = check_cad_file.check(self.touch(name), "cnc")
self.assertTrue(any(fragment in b for b in r["blocking"]), r["blocking"])
def test_mesh_formats_in_uploader_do_not_bypass_process_restriction(self):
for ext in ("acs", "wrl"):
path = self.touch(f"part.{ext}")
self.assertTrue(check_cad_file.check(path, "cnc")["blocking"])
self.assertEqual(check_cad_file.check(path, "3dp")["blocking"], [])
def test_upload_only_formats_require_support_verification(self):
for ext in ("3mf", "gts", "ifczip", "xmt"):
result = check_cad_file.check(self.touch(f"part.{ext}"), "cnc")
self.assertTrue(any("support is unverified" in b for b in result["blocking"]))
def test_pdf_alone_warns_but_does_not_block(self):
r = check_cad_file.check(self.touch("drawing.pdf"), "cnc")
self.assertEqual(r["blocking"], [])
self.assertTrue(any("drawings cannot be quoted alone" in w for w in r["warnings"]))
def test_ambiguous_native_formats_warn(self):
prt = check_cad_file.check(self.touch("part.prt"), "cnc")
self.assertTrue(any("ambiguous" in w for w in prt["warnings"]))
sw = check_cad_file.check(self.touch("part.SLDPRT"), "cnc")
self.assertTrue(any("single configuration" in w for w in sw["warnings"]))
def test_empty_and_missing_files_block(self):
self.assertIn("file is empty", check_cad_file.check(self.touch("e.step", b""), "cnc")["blocking"])
self.assertIn("file not found", check_cad_file.check(str(self.tmp / "nope.step"), "cnc")["blocking"])
class CliTests(unittest.TestCase):
def run_cli(self, *args: str) -> subprocess.CompletedProcess:
return subprocess.run(
[sys.executable, str(SCRIPTS / "check_cad_file.py"), *args],
capture_output=True,
text=True,
timeout=60,
)
def test_exit_zero_when_nothing_blocks(self):
proc = self.run_cli(str(FIXTURES / "block_mm.step"))
self.assertEqual(proc.returncode, 0, proc.stderr)
self.assertIn("[OK]", proc.stdout)
def test_exit_one_when_any_file_blocks(self):
proc = self.run_cli(str(FIXTURES / "block_mm.step"), str(FIXTURES / "two_bodies.step"))
self.assertEqual(proc.returncode, 1)
self.assertIn("[BLOCKED]", proc.stdout)
def test_json_output_is_one_record_per_file(self):
proc = self.run_cli(str(FIXTURES / "block_inch.step"), "--process", "3dp", "--json")
records = json.loads(proc.stdout)
self.assertEqual(len(records), 1)
self.assertEqual(records[0]["process"], "3dp")
self.assertEqual(records[0]["info"]["length_unit"], "inch")
def test_unknown_process_is_rejected(self):
proc = self.run_cli(str(FIXTURES / "block_mm.step"), "--process", "laser")
self.assertEqual(proc.returncode, 2)
class BrowserScriptTests(unittest.TestCase):
"""The page scripts are pasted into a browser JS tool on a live session."""
def test_scripts_parse(self):
node = shutil.which("node")
if node is None:
self.skipTest("node is not installed")
# Parse each file as an async function body: that accepts the top-level
# `await` list_dropdown_options.js relies on, as the browser tool does.
check = (
"const AsyncFunction = (async () => {}).constructor;"
"new AsyncFunction(require('fs').readFileSync(process.argv[1], 'utf8'));"
)
for name in BROWSER_SCRIPTS:
with self.subTest(script=name):
proc = subprocess.run(
[node, "-e", check, str(SCRIPTS / name)],
capture_output=True,
text=True,
timeout=60,
)
self.assertEqual(proc.returncode, 0, proc.stderr)
def test_scripts_are_read_only(self):
# SKILL.md sends agents to these scripts on quote and checkout pages,
# next to "Place order"; they must never act on the page or the network.
forbidden = re.compile(r"\.click\(|dispatchEvent|\.submit\(|\bfetch\(|XMLHttpRequest|sendBeacon")
for name in BROWSER_SCRIPTS:
with self.subTest(script=name):
source = (SCRIPTS / name).read_text(encoding="utf-8")
self.assertIsNone(forbidden.search(source))
def test_async_script_keeps_its_leading_await(self):
# The JS tool does not unwrap a bare Promise, so dropping the `await`
# makes the script return `{}`.
source = (SCRIPTS / "list_dropdown_options.js").read_text(encoding="utf-8")
code = [ln for ln in source.splitlines() if ln.strip() and not ln.lstrip().startswith("//")]
self.assertTrue(code[0].startswith("await (async"), code[0])
if __name__ == "__main__":
unittest.main()