mirror of
https://github.com/openglow-org/forgefirm.git
synced 2026-09-27 16:51:12 -07:00
267 lines
13 KiB
Python
267 lines
13 KiB
Python
"""The setup's sheet in the catalog: one live test on the button with a
|
|
piece of wood at hand, its covers map naming the live runner, the
|
|
renderer, the sender, the page, and the driver's laser module; and the
|
|
whole run against a scripted daemon: the placement's jogs and origin,
|
|
then each card's preview and program read, its start, the arm prompt and
|
|
the pick answered, the witnesses judged, the record read at version 1,
|
|
every card's evidence filed under its own key, and the settings the cards
|
|
wrote put back as found at the end."""
|
|
import os
|
|
import sys
|
|
import unittest
|
|
|
|
sys.path.insert(0, os.path.dirname(__file__))
|
|
import helpers # noqa: E402
|
|
from forgetest import catalog # noqa: E402
|
|
from forgetest.runner import Context, Run # noqa: E402
|
|
from forgetest.suite import commission_sheet # noqa: E402
|
|
|
|
LIVE = ["sheet.frame", "laser.focus", "laser.floor", "laser.dose-curve", "laser.corner", "cooling.flow-load"]
|
|
EMISSION = {"hv_max": 610, "laser_on_samples": 900, "thermopile_delta": 600, "lit_s": 30.0}
|
|
|
|
# Each wizard as the daemon runs it: its prompts in order (id, kind,
|
|
# options) and the result it ends with. A "jog" prompt repeats until the
|
|
# origin is set.
|
|
SCRIPT = {
|
|
"sheet.place": ([("place", "jog", ["X-10", "X+10", "Set origin"]),
|
|
("sheet-kind", "choice", ["Full sheet", "One card"]),
|
|
("thickness", "number", ["Set", "Skip"])],
|
|
{"origin_x": 100, "origin_y": 200, "origin_z": 0, "steps_per_mm": {"x": 40.0, "y": 40.0},
|
|
"z_referenced": True, "thickness_mm": 3.2, "alone": False}),
|
|
"sheet.frame": ([("frame-arm", "continue", ["Continue"]), ("frame-ok", "choice", ["Yes", "No", "Again"])],
|
|
{"mark_s": 400, "mark_feed": 3000, "emission": EMISSION}),
|
|
"laser.focus": ([("focus-arm", "continue", ["Continue"]),
|
|
("focus-pick", "multichoice", [str(i) for i in range(1, 13)]),
|
|
("thickness", "number", ["Keep", "Set"])],
|
|
{"pick": 11, "thickness_mm": 3.2, "pick_half_steps": -11, "edge_z_mm": 6.96,
|
|
"steps_per_mm": 2.922, "max_height_mm": 13.81,
|
|
"focus_range_mm": {"min": 2.17, "max": 13.81},
|
|
"stops": {"found": True, "below": 14, "above": 20, "contact_below": 16,
|
|
"contact_above": 22, "why": ""}, "emission": EMISSION}),
|
|
"laser.floor": ([("floor-arm", "continue", ["Continue"]),
|
|
("floor-pick", "choice", ["2", "4", "6", "8", "None"])],
|
|
{"faintest_density": 8.0, "floor_density": 10.0, "emission": EMISSION}),
|
|
"laser.dose-curve": ([("dose-arm", "continue", ["Continue"])],
|
|
{"points": [[10, 0.44], [100, 100]], "curve": "10:0.44,100:100", "emission": EMISSION}),
|
|
"laser.corner": ([("corner-arm", "continue", ["Continue"]),
|
|
("corner-pick", "choice", ["1.00", "1.25", "1.50", "1.75", "2.00"])],
|
|
{"gamma": 1.5, "emission": EMISSION}),
|
|
"cooling.flow-load": ([("load-arm", "continue", ["Continue"])],
|
|
{"lit_s": 30.0, "dose_raw_s": 12000, "peak_c": 0.72, "k_density": 2.14e-5,
|
|
"k_cw": 2.78e-5, "emission": EMISSION}),
|
|
}
|
|
# What each card writes when it ends.
|
|
WRITES = {
|
|
"laser.focus": {"lens_hall_edge_z_mm": "6.96", "lens_stop_below_steps": "14",
|
|
"lens_stop_above_steps": "20"},
|
|
"laser.floor": {"laser_floor_density": "10"},
|
|
"laser.dose-curve": {"laser_dose_curve": "10:0.44,100:100"},
|
|
"laser.corner": {"laser_corner_gamma": "1.5"},
|
|
"cooling.flow-load": {"cool_laser_heat_density": "2.14e-5", "cool_laser_heat_cw": "2.78e-5"},
|
|
}
|
|
FOUND = {"lens_hall_edge_z_mm": "3.35", "lens_stop_below_steps": "10", "lens_stop_above_steps": "12",
|
|
"laser_floor_density": "12",
|
|
"laser_dose_curve": "off", "laser_corner_gamma": "2", "cool_laser_heat_density": "1e-5",
|
|
"cool_laser_heat_cw": "1e-5"}
|
|
|
|
|
|
class RegistrationTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.t = catalog.load_suite()["commission.sheet"]
|
|
|
|
def test_one_live_test_on_the_button_with_the_sheet_at_hand(self):
|
|
t = self.t
|
|
self.assertEqual(t.kind, "live")
|
|
self.assertEqual(t.mode, "grbl")
|
|
self.assertEqual(t.hardware, "takeover")
|
|
self.assertIn("button", t.actions)
|
|
self.assertTrue(t.hands)
|
|
self.assertFalse(t.fixture_runnable(("button", "lid", "interlock")))
|
|
self.assertIsNone(getattr(t, "precheck", None))
|
|
for want in ("commission.check-motion", "laser.emission-witness", "cooling.flow-verify"):
|
|
self.assertIn(want, t.requires)
|
|
|
|
def test_no_other_sheet_test_remains(self):
|
|
ids = [i for i in catalog.load_suite() if i.startswith("commission.sheet")]
|
|
self.assertEqual(ids, ["commission.sheet"])
|
|
|
|
def test_covers_the_live_runner_the_renderer_the_sender_the_page_and_the_driver(self):
|
|
covers = set(self.t.covers)
|
|
for want in (("forgectrl", "src/wizlive.*"), ("forgectrl", "src/sheet.*"), ("forgectrl", "src/jobstream.*"),
|
|
("forgectrl", "src/curverec.*"), ("forgectrl", "src/font_hershey.*"),
|
|
("forgectrl", "src/ui/wizard.*"), ("forgectrl", "src/wizrun.h"),
|
|
("grblhal-glowforge", "src/glowforge_laser.c")):
|
|
self.assertIn(want, covers, "lacks %s" % (want,))
|
|
|
|
def test_the_steps_ask_for_one_press_and_no_page(self):
|
|
text = " ".join(self.t.steps).lower()
|
|
self.assertIn("press the machine's button once", text)
|
|
self.assertNotIn("when the page", text)
|
|
self.assertEqual(len(commission_sheet.CARDS), 6)
|
|
|
|
|
|
class ScriptedDaemon:
|
|
"""The wizard runner as the suite sees it: /wiz/<id>/start opens the
|
|
first prompt, each answer opens the next or ends the wizard with its
|
|
result and its writes, /wiz/dark reports it, GET /wiz carries the
|
|
versions, the sheet preview and program are served per card."""
|
|
|
|
def __init__(self, fake):
|
|
self.fake = fake
|
|
fake.state["settings"].update(FOUND)
|
|
self.dark = {"id": "", "running": False, "phase": "", "progress": 0, "elapsed_s": 0,
|
|
"log": [], "prompt": None, "result": None, "error": "",
|
|
"shots": {"lid": False, "head": False}}
|
|
self.versions = {}
|
|
self.answers = {} # wid -> [values]
|
|
self.order = [] # the wizards as started
|
|
self.previews = []
|
|
self.queue = []
|
|
self.seq = 0
|
|
fake.on_get = self.on_get
|
|
fake.on_post = self.on_post
|
|
|
|
def open_next(self):
|
|
if not self.queue:
|
|
return False
|
|
pid, kind, options = self.queue[0]
|
|
self.seq += 1
|
|
self.dark["prompt"] = {"seq": self.seq, "id": pid, "kind": kind, "text": pid, "options": options}
|
|
return True
|
|
|
|
def on_get(self, path, q):
|
|
if path == "/wiz/dark":
|
|
return 200, dict(self.dark)
|
|
if path == "/wiz":
|
|
return 200, {"versions": dict(self.versions), "required": [], "completed": True}
|
|
if path == "/wiz/sheet.svg":
|
|
self.previews.append(q.get("card"))
|
|
if q.get("card") not in LIVE:
|
|
return 404, {"error": "no such card"}
|
|
return 200, b"<svg xmlns='http://www.w3.org/2000/svg'></svg>", "image/svg+xml"
|
|
if path == "/wiz/sheet.gcode":
|
|
# the frame and the text are M4 at the mark dose, as the daemon serves them
|
|
return 200, b"; mock\nM4 S400\nG0 X60 Y42\nG1 X120 Y42 F3000\nM5\n", "text/plain"
|
|
return None
|
|
|
|
def on_post(self, path, form):
|
|
s = self.fake.state["settings"]
|
|
if path.startswith("/wiz/") and path.endswith("/start"):
|
|
wid = path[len("/wiz/"):-len("/start")]
|
|
if wid not in SCRIPT:
|
|
return 404, {"error": "no such wizard"}
|
|
self.order.append(wid)
|
|
self.queue = list(SCRIPT[wid][0])
|
|
self.dark.update({"id": wid, "running": True, "phase": "starting", "result": None, "error": ""})
|
|
self.open_next()
|
|
return 200, {"started": True, "id": wid}
|
|
if path.startswith("/wiz/") and path.endswith("/answer"):
|
|
wid = path[len("/wiz/"):-len("/answer")]
|
|
p = self.dark.get("prompt")
|
|
if not p or form.get("seq") != str(p["seq"]):
|
|
return 409, {"error": "no such prompt is open"}
|
|
self.answers.setdefault(wid, []).append(form.get("value"))
|
|
if not (p["kind"] == "jog" and form.get("value") != "Set origin"):
|
|
self.queue.pop(0)
|
|
if not self.open_next():
|
|
s.update(WRITES.get(wid, {}))
|
|
self.dark.update({"running": False, "prompt": None, "progress": 100,
|
|
"result": dict(SCRIPT[wid][1])})
|
|
self.versions[wid] = 1
|
|
return 200, {"ok": True}
|
|
if path == "/settings":
|
|
for k, v in form.items():
|
|
if v == "":
|
|
s.pop(k, None)
|
|
else:
|
|
s[k] = v
|
|
return 200, dict(s)
|
|
return None
|
|
|
|
|
|
class SheetRunTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.fake = helpers.FakeForgectrl().start()
|
|
self.daemon = ScriptedDaemon(self.fake)
|
|
|
|
def tearDown(self):
|
|
self.fake.stop()
|
|
|
|
def test_the_whole_sheet_on_one_piece(self):
|
|
t = catalog.load_suite()["commission.sheet"]
|
|
run = Run("test", t.id, t.title)
|
|
run.unattended = True # the ready gate passes; the arm cue is a notice
|
|
t.fn(Context(run, None, t))
|
|
d = self.daemon
|
|
self.assertEqual(d.order, ["sheet.place"] + LIVE)
|
|
self.assertEqual(d.answers["sheet.place"], ["X+10", "X-10", "Set origin", "Full sheet", "3.2"])
|
|
self.assertEqual(d.answers["sheet.frame"], ["Continue", "Yes"])
|
|
self.assertEqual(d.answers["laser.focus"], ["Continue", "11", "Keep"])
|
|
self.assertEqual(d.answers["laser.floor"], ["Continue", "8"])
|
|
self.assertEqual(d.answers["laser.corner"], ["Continue", "1.50"])
|
|
self.assertEqual(d.previews, LIVE)
|
|
cards = run.evidence["cards"]
|
|
self.assertEqual(sorted(cards), sorted(["sheet.place"] + LIVE))
|
|
for wid in LIVE:
|
|
self.assertEqual(cards[wid]["emission"]["hv_max"], 610, wid)
|
|
self.assertEqual(cards[wid]["result"], SCRIPT[wid][1], wid)
|
|
self.assertNotIn("emission", run.evidence)
|
|
self.assertEqual(cards["sheet.place"]["result"]["origin_x"], 100)
|
|
self.assertEqual(run.evidence["settings_before"], FOUND)
|
|
for k, v in FOUND.items():
|
|
self.assertEqual(self.fake.state["settings"][k], v, k) # restored
|
|
|
|
def test_imperial_units_answer_the_thickness_in_inches(self):
|
|
# The number prompts read ui_units: on an imperial machine the
|
|
# placement's thickness is 0.125 in and the record carries 3.175 mm.
|
|
self.fake.state["settings"]["ui_units"] = "imperial"
|
|
place_prompts, place_result = SCRIPT["sheet.place"]
|
|
SCRIPT["sheet.place"] = (place_prompts, dict(place_result, thickness_mm=3.175))
|
|
try:
|
|
t = catalog.load_suite()["commission.sheet"]
|
|
run = Run("test", t.id, t.title)
|
|
run.unattended = True
|
|
t.fn(Context(run, None, t))
|
|
self.assertEqual(self.daemon.answers["sheet.place"][-1], "0.125")
|
|
self.assertEqual(run.evidence["thickness_answer"], "0.125")
|
|
finally:
|
|
SCRIPT["sheet.place"] = (place_prompts, place_result)
|
|
|
|
def test_a_metric_answer_on_an_imperial_machine_fails_the_placement(self):
|
|
# The defect the bench found: 3.2 read as inches is over the 30 mm
|
|
# cap and the wizard records 0; the test must not read that as a pass.
|
|
from forgetest.runner import Failed
|
|
place_prompts, place_result = SCRIPT["sheet.place"]
|
|
SCRIPT["sheet.place"] = (place_prompts, dict(place_result, thickness_mm=0.0))
|
|
try:
|
|
t = catalog.load_suite()["commission.sheet"]
|
|
run = Run("test", t.id, t.title)
|
|
run.unattended = True
|
|
with self.assertRaises(Failed) as cm:
|
|
t.fn(Context(run, None, t))
|
|
self.assertIn("thickness 0.0 mm", str(cm.exception))
|
|
self.assertEqual(self.daemon.order, ["sheet.place"]) # nothing burned
|
|
finally:
|
|
SCRIPT["sheet.place"] = (place_prompts, place_result)
|
|
|
|
def test_a_dark_burn_fails_the_run_and_still_restores(self):
|
|
from forgetest.runner import Failed
|
|
SCRIPT_DARK = dict(SCRIPT["laser.floor"][1])
|
|
SCRIPT_DARK["emission"] = {"hv_max": 0, "laser_on_samples": 0, "thermopile_delta": 0}
|
|
SCRIPT["laser.floor"] = (SCRIPT["laser.floor"][0], SCRIPT_DARK)
|
|
try:
|
|
t = catalog.load_suite()["commission.sheet"]
|
|
run = Run("test", t.id, t.title)
|
|
run.unattended = True
|
|
with self.assertRaises(Failed):
|
|
t.fn(Context(run, None, t))
|
|
self.assertEqual(self.daemon.order, ["sheet.place", "sheet.frame", "laser.focus", "laser.floor"])
|
|
for k, v in FOUND.items():
|
|
self.assertEqual(self.fake.state["settings"][k], v, k)
|
|
finally:
|
|
SCRIPT["laser.floor"] = (SCRIPT["laser.floor"][0], dict(SCRIPT_DARK, emission=EMISSION))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|